530 lines
22 KiB
C++
530 lines
22 KiB
C++
#ifndef VOXEL_GENERATORS_HPP
|
|
#define VOXEL_GENERATORS_HPP
|
|
|
|
#include "grid3.hpp"
|
|
#include <cmath>
|
|
#include <vector>
|
|
#include <functional>
|
|
#include "../noise/pnoise2.hpp"
|
|
#include "../vectorlogic/vec3.hpp"
|
|
#include <array>
|
|
|
|
class VoxelGenerators {
|
|
public:
|
|
// Basic Primitive Generators
|
|
static void createSphere(VoxelGrid& grid, const Vec3f& center, float radius,
|
|
const Vec3ui8& color = Vec3ui8(255, 255, 255),
|
|
bool filled = true) {
|
|
TIME_FUNCTION;
|
|
|
|
Vec3i gridCenter = (center / grid.binSize).floorToI();
|
|
Vec3i radiusVoxels = Vec3i(static_cast<int>(radius / grid.binSize));
|
|
|
|
Vec3i minBounds = gridCenter - radiusVoxels;
|
|
Vec3i maxBounds = gridCenter + radiusVoxels;
|
|
|
|
// Ensure bounds are within grid
|
|
minBounds = minBounds.max(Vec3i(0, 0, 0));
|
|
maxBounds = maxBounds.min(Vec3i(grid.getWidth() - 1, grid.getHeight() - 1, grid.getDepth() - 1));
|
|
|
|
float radiusSq = radius * radius;
|
|
|
|
for (int z = minBounds.z; z <= maxBounds.z; ++z) {
|
|
for (int y = minBounds.y; y <= maxBounds.y; ++y) {
|
|
for (int x = minBounds.x; x <= maxBounds.x; ++x) {
|
|
Vec3f voxelCenter(x * grid.binSize, y * grid.binSize, z * grid.binSize);
|
|
Vec3f delta = voxelCenter - center;
|
|
float distanceSq = delta.lengthSquared();
|
|
|
|
if (filled) {
|
|
// Solid sphere
|
|
if (distanceSq <= radiusSq) {
|
|
grid.set(Vec3i(x, y, z), true, color);
|
|
}
|
|
} else {
|
|
// Hollow sphere (shell)
|
|
float shellThickness = grid.binSize;
|
|
if (distanceSq <= radiusSq && distanceSq >= (radius - shellThickness) * (radius - shellThickness)) {
|
|
grid.set(Vec3i(x, y, z), true, color);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
grid.clearMeshCache();
|
|
}
|
|
|
|
static void createCube(VoxelGrid& grid, const Vec3f& center, const Vec3f& size,
|
|
const Vec3ui8& color = Vec3ui8(255, 255, 255),
|
|
bool filled = true) {
|
|
TIME_FUNCTION;
|
|
|
|
Vec3f halfSize = size * 0.5f;
|
|
Vec3f minPos = center - halfSize;
|
|
Vec3f maxPos = center + halfSize;
|
|
|
|
Vec3i minVoxel = (minPos / grid.binSize).floorToI();
|
|
Vec3i maxVoxel = (maxPos / grid.binSize).floorToI();
|
|
|
|
// Clamp to grid bounds
|
|
minVoxel = minVoxel.max(Vec3i(0, 0, 0));
|
|
maxVoxel = maxVoxel.min(Vec3i(grid.getWidth() - 1, grid.getHeight() - 1, grid.getDepth() - 1));
|
|
|
|
if (filled) {
|
|
// Solid cube
|
|
for (int z = minVoxel.z; z <= maxVoxel.z; ++z) {
|
|
for (int y = minVoxel.y; y <= maxVoxel.y; ++y) {
|
|
for (int x = minVoxel.x; x <= maxVoxel.x; ++x) {
|
|
grid.set(Vec3i(x, y, z), true, color);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// Hollow cube (just the faces)
|
|
for (int z = minVoxel.z; z <= maxVoxel.z; ++z) {
|
|
for (int y = minVoxel.y; y <= maxVoxel.y; ++y) {
|
|
for (int x = minVoxel.x; x <= maxVoxel.x; ++x) {
|
|
// Check if on any face
|
|
bool onFace = (x == minVoxel.x || x == maxVoxel.x ||
|
|
y == minVoxel.y || y == maxVoxel.y ||
|
|
z == minVoxel.z || z == maxVoxel.z);
|
|
|
|
if (onFace) {
|
|
grid.set(Vec3i(x, y, z), true, color);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
grid.clearMeshCache();
|
|
}
|
|
|
|
static void createCylinder(VoxelGrid& grid, const Vec3f& center, float radius, float height,
|
|
const Vec3ui8& color = Vec3ui8(255, 255, 255),
|
|
bool filled = true, int axis = 1) { // 0=X, 1=Y, 2=Z
|
|
TIME_FUNCTION;
|
|
|
|
Vec3f halfHeight = Vec3f(0, 0, 0);
|
|
halfHeight[axis] = height * 0.5f;
|
|
|
|
Vec3f minPos = center - halfHeight;
|
|
Vec3f maxPos = center + halfHeight;
|
|
|
|
Vec3i minVoxel = (minPos / grid.binSize).floorToI();
|
|
Vec3i maxVoxel = (maxPos / grid.binSize).floorToI();
|
|
|
|
minVoxel = minVoxel.max(Vec3i(0, 0, 0));
|
|
maxVoxel = maxVoxel.min(Vec3i(grid.getWidth() - 1, grid.getHeight() - 1, grid.getDepth() - 1));
|
|
|
|
float radiusSq = radius * radius;
|
|
|
|
for (int k = minVoxel[axis]; k <= maxVoxel[axis]; ++k) {
|
|
// Iterate through the other two dimensions
|
|
for (int j = minVoxel[(axis + 1) % 3]; j <= maxVoxel[(axis + 1) % 3]; ++j) {
|
|
for (int i = minVoxel[(axis + 2) % 3]; i <= maxVoxel[(axis + 2) % 3]; ++i) {
|
|
Vec3i pos;
|
|
pos[axis] = k;
|
|
pos[(axis + 1) % 3] = j;
|
|
pos[(axis + 2) % 3] = i;
|
|
|
|
Vec3f voxelCenter = pos.toFloat() * grid.binSize;
|
|
|
|
// Calculate distance from axis
|
|
float dx = voxelCenter.x - center.x;
|
|
float dy = voxelCenter.y - center.y;
|
|
float dz = voxelCenter.z - center.z;
|
|
|
|
// Zero out the axis component
|
|
if (axis == 0) dx = 0;
|
|
else if (axis == 1) dy = 0;
|
|
else dz = 0;
|
|
|
|
float distanceSq = dx*dx + dy*dy + dz*dz;
|
|
|
|
if (filled) {
|
|
if (distanceSq <= radiusSq) {
|
|
grid.set(pos, true, color);
|
|
}
|
|
} else {
|
|
float shellThickness = grid.binSize;
|
|
if (distanceSq <= radiusSq &&
|
|
distanceSq >= (radius - shellThickness) * (radius - shellThickness)) {
|
|
grid.set(pos, true, color);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
grid.clearMeshCache();
|
|
}
|
|
|
|
static void createCone(VoxelGrid& grid, const Vec3f& baseCenter, float radius, float height,
|
|
const Vec3ui8& color = Vec3ui8(255, 255, 255),
|
|
bool filled = true, int axis = 1) { // 0=X, 1=Y, 2=Z
|
|
TIME_FUNCTION;
|
|
|
|
Vec3f tip = baseCenter;
|
|
tip[axis] += height;
|
|
|
|
Vec3f minPos = baseCenter.min(tip);
|
|
Vec3f maxPos = baseCenter.max(tip);
|
|
|
|
// Expand by radius in other dimensions
|
|
for (int i = 0; i < 3; ++i) {
|
|
if (i != axis) {
|
|
minPos[i] -= radius;
|
|
maxPos[i] += radius;
|
|
}
|
|
}
|
|
|
|
Vec3i minVoxel = (minPos / grid.binSize).floorToI();
|
|
Vec3i maxVoxel = (maxPos / grid.binSize).floorToI();
|
|
|
|
minVoxel = minVoxel.max(Vec3i(0, 0, 0));
|
|
maxVoxel = maxVoxel.min(Vec3i(grid.getWidth() - 1, grid.getHeight() - 1, grid.getDepth() - 1));
|
|
|
|
for (int k = minVoxel[axis]; k <= maxVoxel[axis]; ++k) {
|
|
// Current height from base
|
|
float h = (k * grid.binSize) - baseCenter[axis];
|
|
if (h < 0 || h > height) continue;
|
|
|
|
// Current radius at this height
|
|
float currentRadius = radius * (1.0f - h / height);
|
|
|
|
for (int j = minVoxel[(axis + 1) % 3]; j <= maxVoxel[(axis + 1) % 3]; ++j) {
|
|
for (int i = minVoxel[(axis + 2) % 3]; i <= maxVoxel[(axis + 2) % 3]; ++i) {
|
|
Vec3i pos;
|
|
pos[axis] = k;
|
|
pos[(axis + 1) % 3] = j;
|
|
pos[(axis + 2) % 3] = i;
|
|
|
|
Vec3f voxelCenter = pos.toFloat() * grid.binSize;
|
|
|
|
// Calculate distance from axis
|
|
float dx = voxelCenter.x - baseCenter.x;
|
|
float dy = voxelCenter.y - baseCenter.y;
|
|
float dz = voxelCenter.z - baseCenter.z;
|
|
|
|
// Zero out the axis component
|
|
if (axis == 0) dx = 0;
|
|
else if (axis == 1) dy = 0;
|
|
else dz = 0;
|
|
|
|
float distanceSq = dx*dx + dy*dy + dz*dz;
|
|
|
|
if (filled) {
|
|
if (distanceSq <= currentRadius * currentRadius) {
|
|
grid.set(pos, true, color);
|
|
}
|
|
} else {
|
|
float shellThickness = grid.binSize;
|
|
if (distanceSq <= currentRadius * currentRadius &&
|
|
distanceSq >= (currentRadius - shellThickness) * (currentRadius - shellThickness)) {
|
|
grid.set(pos, true, color);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
grid.clearMeshCache();
|
|
}
|
|
|
|
static void createTorus(VoxelGrid& grid, const Vec3f& center, float majorRadius, float minorRadius,
|
|
const Vec3ui8& color = Vec3ui8(255, 255, 255)) {
|
|
TIME_FUNCTION;
|
|
|
|
float outerRadius = majorRadius + minorRadius;
|
|
Vec3f minPos = center - Vec3f(outerRadius, outerRadius, minorRadius);
|
|
Vec3f maxPos = center + Vec3f(outerRadius, outerRadius, minorRadius);
|
|
|
|
Vec3i minVoxel = (minPos / grid.binSize).floorToI();
|
|
Vec3i maxVoxel = (maxPos / grid.binSize).floorToI();
|
|
|
|
minVoxel = minVoxel.max(Vec3i(0, 0, 0));
|
|
maxVoxel = maxVoxel.min(Vec3i(grid.getWidth() - 1, grid.getHeight() - 1, grid.getDepth() - 1));
|
|
|
|
for (int z = minVoxel.z; z <= maxVoxel.z; ++z) {
|
|
for (int y = minVoxel.y; y <= maxVoxel.y; ++y) {
|
|
for (int x = minVoxel.x; x <= maxVoxel.x; ++x) {
|
|
Vec3f pos(x * grid.binSize, y * grid.binSize, z * grid.binSize);
|
|
Vec3f delta = pos - center;
|
|
|
|
// Torus equation: (sqrt(x² + y²) - R)² + z² = r²
|
|
float xyDist = std::sqrt(delta.x * delta.x + delta.y * delta.y);
|
|
float distToCircle = xyDist - majorRadius;
|
|
float distanceSq = distToCircle * distToCircle + delta.z * delta.z;
|
|
|
|
if (distanceSq <= minorRadius * minorRadius) {
|
|
grid.set(Vec3i(x, y, z), true, color);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
grid.clearMeshCache();
|
|
}
|
|
|
|
// Procedural Generators
|
|
static void createPerlinNoiseTerrain(VoxelGrid& grid, float frequency = 0.1f, float amplitude = 10.0f,
|
|
int octaves = 4, float persistence = 0.5f,
|
|
const Vec3ui8& baseColor = Vec3ui8(34, 139, 34)) {
|
|
TIME_FUNCTION;
|
|
|
|
if (grid.getHeight() < 1) return;
|
|
|
|
PNoise2 noise;
|
|
|
|
for (int z = 0; z < grid.getDepth(); ++z) {
|
|
for (int x = 0; x < grid.getWidth(); ++x) {
|
|
// Generate height value using Perlin noise
|
|
float heightValue = 0.0f;
|
|
float freq = frequency;
|
|
float amp = amplitude;
|
|
|
|
for (int octave = 0; octave < octaves; ++octave) {
|
|
float nx = x * freq / 100.0f;
|
|
float nz = z * freq / 100.0f;
|
|
heightValue += noise.permute(Vec2f(nx, nz)) * amp;
|
|
|
|
freq *= 2.0f;
|
|
amp *= persistence;
|
|
}
|
|
|
|
// Normalize and scale to grid height
|
|
int terrainHeight = static_cast<int>((heightValue + amplitude) / (2.0f * amplitude) * grid.getHeight());
|
|
terrainHeight = std::max(0, std::min(grid.getHeight() - 1, terrainHeight));
|
|
|
|
// Create column of voxels
|
|
for (int y = 0; y <= terrainHeight; ++y) {
|
|
// Color gradient based on height
|
|
float t = static_cast<float>(y) / grid.getHeight();
|
|
Vec3ui8 color = baseColor;
|
|
|
|
// Add some color variation
|
|
if (t < 0.3f) {
|
|
// Water level
|
|
color = Vec3ui8(30, 144, 255);
|
|
} else if (t < 0.5f) {
|
|
// Sand
|
|
color = Vec3ui8(238, 214, 175);
|
|
} else if (t < 0.8f) {
|
|
// Grass
|
|
color = baseColor;
|
|
} else {
|
|
// Snow
|
|
color = Vec3ui8(255, 250, 250);
|
|
}
|
|
|
|
grid.set(Vec3i(x, y, z), true, color);
|
|
}
|
|
}
|
|
}
|
|
|
|
grid.clearMeshCache();
|
|
}
|
|
|
|
static void createMengerSponge(VoxelGrid& grid, int iterations = 3,
|
|
const Vec3ui8& color = Vec3ui8(255, 255, 255)) {
|
|
TIME_FUNCTION;
|
|
|
|
// Start with a solid cube
|
|
createCube(grid,
|
|
Vec3f(grid.getWidth() * grid.binSize * 0.5f,
|
|
grid.getHeight() * grid.binSize * 0.5f,
|
|
grid.getDepth() * grid.binSize * 0.5f),
|
|
Vec3f(grid.getWidth() * grid.binSize,
|
|
grid.getHeight() * grid.binSize,
|
|
grid.getDepth() * grid.binSize),
|
|
color, true);
|
|
|
|
// Apply Menger sponge iteration
|
|
for (int iter = 0; iter < iterations; ++iter) {
|
|
int divisor = static_cast<int>(std::pow(3, iter + 1));
|
|
|
|
// Calculate the pattern
|
|
for (int z = 0; z < grid.getDepth(); ++z) {
|
|
for (int y = 0; y < grid.getHeight(); ++y) {
|
|
for (int x = 0; x < grid.getWidth(); ++x) {
|
|
// Check if this voxel should be removed in this iteration
|
|
int modX = x % divisor;
|
|
int modY = y % divisor;
|
|
int modZ = z % divisor;
|
|
|
|
int third = divisor / 3;
|
|
|
|
// Remove center cubes
|
|
if ((modX >= third && modX < 2 * third) &&
|
|
(modY >= third && modY < 2 * third)) {
|
|
grid.set(Vec3i(x, y, z), false, color);
|
|
}
|
|
if ((modX >= third && modX < 2 * third) &&
|
|
(modZ >= third && modZ < 2 * third)) {
|
|
grid.set(Vec3i(x, y, z), false, color);
|
|
}
|
|
if ((modY >= third && modY < 2 * third) &&
|
|
(modZ >= third && modZ < 2 * third)) {
|
|
grid.set(Vec3i(x, y, z), false, color);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
grid.clearMeshCache();
|
|
}
|
|
|
|
// Helper function to check if a point is inside a polygon (for 2D shapes)
|
|
static bool pointInPolygon(const Vec2f& point, const std::vector<Vec2f>& polygon) {
|
|
bool inside = false;
|
|
size_t n = polygon.size();
|
|
|
|
for (size_t i = 0, j = n - 1; i < n; j = i++) {
|
|
if (((polygon[i].y > point.y) != (polygon[j].y > point.y)) &&
|
|
(point.x < (polygon[j].x - polygon[i].x) * (point.y - polygon[i].y) /
|
|
(polygon[j].y - polygon[i].y) + polygon[i].x)) {
|
|
inside = !inside;
|
|
}
|
|
}
|
|
|
|
return inside;
|
|
}
|
|
|
|
// Utah Teapot (simplified voxel approximation)
|
|
static void createTeapot(VoxelGrid& grid, const Vec3f& position, float scale = 1.0f,
|
|
const Vec3ui8& color = Vec3ui8(200, 200, 200)) {
|
|
TIME_FUNCTION;
|
|
|
|
// Simplified teapot using multiple primitive components
|
|
Vec3f center = position;
|
|
|
|
// Body (ellipsoid)
|
|
createSphere(grid, center, 3.0f * scale, color, false);
|
|
|
|
// Spout (rotated cylinder)
|
|
Vec3f spoutStart = center + Vec3f(2.0f * scale, 0, 0);
|
|
Vec3f spoutEnd = center + Vec3f(4.0f * scale, 1.5f * scale, 0);
|
|
createCylinderBetween(grid, spoutStart, spoutEnd, 0.5f * scale, color, true);
|
|
|
|
// Handle (semi-circle)
|
|
Vec3f handleStart = center + Vec3f(-2.0f * scale, 0, 0);
|
|
Vec3f handleEnd = center + Vec3f(-3.0f * scale, 2.0f * scale, 0);
|
|
createCylinderBetween(grid, handleStart, handleEnd, 0.4f * scale, color, true);
|
|
|
|
// Lid (small cylinder on top)
|
|
Vec3f lidCenter = center + Vec3f(0, 3.0f * scale, 0);
|
|
createCylinder(grid, lidCenter, 1.0f * scale, 0.5f * scale, color, true, 1);
|
|
|
|
grid.clearMeshCache();
|
|
}
|
|
|
|
static void createCylinderBetween(VoxelGrid& grid, const Vec3f& start, const Vec3f& end, float radius,
|
|
const Vec3ui8& color, bool filled = true) {
|
|
TIME_FUNCTION;
|
|
|
|
Vec3f direction = (end - start).normalized();
|
|
float length = (end - start).length();
|
|
|
|
// Create local coordinate system
|
|
Vec3f up(0, 1, 0);
|
|
if (std::abs(direction.dot(up)) > 0.99f) {
|
|
up = Vec3f(1, 0, 0);
|
|
}
|
|
|
|
Vec3f right = direction.cross(up).normalized();
|
|
Vec3f localUp = right.cross(direction).normalized();
|
|
|
|
Vec3f minPos = start.min(end) - Vec3f(radius, radius, radius);
|
|
Vec3f maxPos = start.max(end) + Vec3f(radius, radius, radius);
|
|
|
|
Vec3i minVoxel = (minPos / grid.binSize).floorToI();
|
|
Vec3i maxVoxel = (maxPos / grid.binSize).floorToI();
|
|
|
|
minVoxel = minVoxel.max(Vec3i(0, 0, 0));
|
|
maxVoxel = maxVoxel.min(Vec3i(grid.getWidth() - 1, grid.getHeight() - 1, grid.getDepth() - 1));
|
|
|
|
float radiusSq = radius * radius;
|
|
|
|
for (int z = minVoxel.z; z <= maxVoxel.z; ++z) {
|
|
for (int y = minVoxel.y; y <= maxVoxel.y; ++y) {
|
|
for (int x = minVoxel.x; x <= maxVoxel.x; ++x) {
|
|
Vec3f voxelPos(x * grid.binSize, y * grid.binSize, z * grid.binSize);
|
|
|
|
// Project point onto cylinder axis
|
|
Vec3f toPoint = voxelPos - start;
|
|
float t = toPoint.dot(direction);
|
|
|
|
// Check if within cylinder length
|
|
if (t < 0 || t > length) continue;
|
|
|
|
Vec3f projected = start + direction * t;
|
|
Vec3f delta = voxelPos - projected;
|
|
float distanceSq = delta.lengthSquared();
|
|
|
|
if (filled) {
|
|
if (distanceSq <= radiusSq) {
|
|
grid.set(Vec3i(x, y, z), true, color);
|
|
}
|
|
} else {
|
|
float shellThickness = grid.binSize;
|
|
if (distanceSq <= radiusSq &&
|
|
distanceSq >= (radius - shellThickness) * (radius - shellThickness)) {
|
|
grid.set(Vec3i(x, y, z), true, color);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Generate from mathematical function
|
|
template<typename Func>
|
|
static void createFromFunction(VoxelGrid& grid, Func func,
|
|
const Vec3f& minBounds, const Vec3f& maxBounds,
|
|
float threshold = 0.5f,
|
|
const Vec3ui8& color = Vec3ui8(255, 255, 255)) {
|
|
TIME_FUNCTION;
|
|
|
|
Vec3i minVoxel = (minBounds / grid.binSize).floorToI();
|
|
Vec3i maxVoxel = (maxBounds / grid.binSize).floorToI();
|
|
|
|
minVoxel = minVoxel.max(Vec3i(0, 0, 0));
|
|
maxVoxel = maxVoxel.min(Vec3i(grid.getWidth() - 1, grid.getHeight() - 1, grid.getDepth() - 1));
|
|
|
|
for (int z = minVoxel.z; z <= maxVoxel.z; ++z) {
|
|
for (int y = minVoxel.y; y <= maxVoxel.y; ++y) {
|
|
for (int x = minVoxel.x; x <= maxVoxel.x; ++x) {
|
|
Vec3f pos(x * grid.binSize, y * grid.binSize, z * grid.binSize);
|
|
|
|
float value = func(pos.x, pos.y, pos.z);
|
|
|
|
if (value > threshold) {
|
|
grid.set(Vec3i(x, y, z), true, color);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
grid.clearMeshCache();
|
|
}
|
|
|
|
// Example mathematical functions
|
|
static float sphereFunction(float x, float y, float z) {
|
|
return 1.0f - (x*x + y*y + z*z);
|
|
}
|
|
|
|
static float torusFunction(float x, float y, float z, float R = 2.0f, float r = 1.0f) {
|
|
float d = std::sqrt(x*x + y*y) - R;
|
|
return r*r - d*d - z*z;
|
|
}
|
|
|
|
static float gyroidFunction(float x, float y, float z, float scale = 0.5f) {
|
|
x *= scale; y *= scale; z *= scale;
|
|
return std::sin(x) * std::cos(y) + std::sin(y) * std::cos(z) + std::sin(z) * std::cos(x);
|
|
}
|
|
};
|
|
|
|
#endif |