lots of changes, serialization is done better, grid is defined better, etc.
This commit is contained in:
Yggdrasil75
98
util/grid/g3_serialization.hpp
Normal file
98
util/grid/g3_serialization.hpp
Normal file
@@ -0,0 +1,98 @@
|
||||
#ifndef GRID3_Serialization
|
||||
#define GRID3_Serialization
|
||||
|
||||
#include <fstream>
|
||||
#include <cstring>
|
||||
#include "grid3.hpp"
|
||||
|
||||
constexpr char magic[4] = {'Y', 'G', 'G', '3'};
|
||||
|
||||
inline bool VoxelGrid::serializeToFile(const std::string& filename) {
|
||||
std::ofstream file(filename, std::ios::binary);
|
||||
if (!file.is_open()) {
|
||||
std::cerr << "failed to open file (serializeToFile): " << filename << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
file.write(magic, 4);
|
||||
int dims[3] = {gridSize.x, gridSize.y, gridSize.z};
|
||||
file.write(reinterpret_cast<const char*>(dims), sizeof(dims));
|
||||
size_t voxelCount = voxels.size();
|
||||
for (const Voxel& voxel : voxels) {
|
||||
auto write_member = [&file](const auto& member) {
|
||||
file.write(reinterpret_cast<const char*>(&member), sizeof(member));
|
||||
};
|
||||
|
||||
std::apply([&write_member](const auto&... members) {
|
||||
(write_member(members), ...);
|
||||
}, voxel.members());
|
||||
}
|
||||
|
||||
file.close();
|
||||
return !file.fail();
|
||||
}
|
||||
|
||||
std::unique_ptr<VoxelGrid> VoxelGrid::deserializeFromFile(const std::string& filename) {
|
||||
std::ifstream file(filename, std::ios::binary);
|
||||
if (!file.is_open()) {
|
||||
std::cerr << "failed to open file (deserializeFromFile): " << filename << std::endl;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// Read and verify magic number
|
||||
char filemagic[4];
|
||||
file.read(filemagic, 4);
|
||||
if (std::strncmp(filemagic, magic, 4) != 0) {
|
||||
std::cerr << "Error: Invalid file format or corrupted file (expected "
|
||||
<< magic[0] << magic[1] << magic[2] << magic[3]
|
||||
<< ", got " << filemagic[0] << filemagic[1] << filemagic[2] << filemagic[3]
|
||||
<< ")" << std::endl;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// Create output grid
|
||||
auto outgrid = std::make_unique<VoxelGrid>();
|
||||
|
||||
// Read grid dimensions
|
||||
int dims[3];
|
||||
file.read(reinterpret_cast<char*>(dims), sizeof(dims));
|
||||
|
||||
// Resize grid
|
||||
outgrid->gridSize = Vec3i(dims[0], dims[1], dims[2]);
|
||||
outgrid->voxels.resize(dims[0] * dims[1] * dims[2]);
|
||||
|
||||
// Read voxel count
|
||||
size_t voxelCount;
|
||||
file.read(reinterpret_cast<char*>(&voxelCount), sizeof(voxelCount));
|
||||
|
||||
// Verify voxel count matches grid dimensions
|
||||
size_t expectedCount = static_cast<size_t>(dims[0]) * dims[1] * dims[2];
|
||||
if (voxelCount != expectedCount) {
|
||||
std::cerr << "Error: Voxel count mismatch. Expected " << expectedCount
|
||||
<< ", found " << voxelCount << std::endl;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// Read all voxels
|
||||
for (size_t i = 0; i < voxelCount; ++i) {
|
||||
auto members = outgrid->voxels[i].members();
|
||||
|
||||
std::apply([&file](auto&... member) {
|
||||
((file.read(reinterpret_cast<char*>(&member), sizeof(member))), ...);
|
||||
}, members);
|
||||
}
|
||||
|
||||
file.close();
|
||||
|
||||
if (file.fail() && !file.eof()) {
|
||||
std::cerr << "Error: Failed to read from file: " << filename << std::endl;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
std::cout << "Successfully loaded grid: " << dims[0] << " x "
|
||||
<< dims[1] << " x " << dims[2] << std::endl;
|
||||
|
||||
return outgrid;
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -11,18 +11,57 @@
|
||||
#include "../output/frame.hpp"
|
||||
#include "../noise/pnoise2.hpp"
|
||||
#include "../vecmat/mat4.hpp"
|
||||
//#include "serialization.hpp"
|
||||
#include <vector>
|
||||
#include <algorithm>
|
||||
#include "../basicdefines.hpp"
|
||||
|
||||
constexpr char magic[4] = {'Y', 'G', 'G', '3'};
|
||||
//constexpr char magic[4] = {'Y', 'G', 'G', '3'};
|
||||
|
||||
Mat4f lookAt(const Vec3f& eye, const Vec3f& center, const Vec3f& up) {
|
||||
Vec3f const f = (center - eye).normalized();
|
||||
Vec3f const s = f.cross(up).normalized();
|
||||
Vec3f const u = s.cross(f);
|
||||
|
||||
Mat4f Result = Mat4f::identity();
|
||||
Result(0, 0) = s.x;
|
||||
Result(1, 0) = s.y;
|
||||
Result(2, 0) = s.z;
|
||||
Result(3, 0) = -s.dot(eye);
|
||||
Result(0, 1) = u.x;
|
||||
Result(1, 1) = u.y;
|
||||
Result(2, 1) = u.z;
|
||||
Result(3, 1) = -u.dot(eye);
|
||||
Result(0, 2) = -f.x;
|
||||
Result(1, 2) = -f.y;
|
||||
Result(2, 2) = -f.z;
|
||||
Result(3, 2) = f.dot(eye);
|
||||
return Result;
|
||||
}
|
||||
|
||||
Mat4f perspective(float fovy, float aspect, float zNear, float zfar) {
|
||||
float const tanhalfF = tan(fovy / 2);
|
||||
Mat4f Result = 0;
|
||||
Result(0,0) = 1 / (aspect * tanhalfF);
|
||||
Result(1,1) = 1 / tanhalfF;
|
||||
Result(2,2) = zfar / (zNear - zfar);
|
||||
Result(2,3) = -1;
|
||||
Result(3,2) = -(zfar * zNear) / (zfar - zNear);
|
||||
return Result;
|
||||
}
|
||||
|
||||
struct Voxel {
|
||||
//float active;
|
||||
float weight;
|
||||
bool active;
|
||||
//Vec3f position;
|
||||
float alpha;
|
||||
Vec3ui8 color;
|
||||
// TODO: add curving and similar for water and glass and so on.
|
||||
auto members() const -> std::tuple<const float&, const bool&, const float&, const Vec3ui8&> {
|
||||
return std::tie(weight, active, alpha, color);
|
||||
}
|
||||
|
||||
auto members() -> std::tuple<float&, bool&, float&, Vec3ui8&> {
|
||||
return std::tie(weight, active, alpha, color);
|
||||
}
|
||||
};
|
||||
|
||||
struct Camera {
|
||||
@@ -64,48 +103,114 @@ struct Camera {
|
||||
}
|
||||
};
|
||||
|
||||
struct Vertex {
|
||||
Vec3f position;
|
||||
Vec3f normal;
|
||||
Vec3ui8 color;
|
||||
Vec2f texCoord;
|
||||
|
||||
Vertex() = default;
|
||||
Vertex(Vec3f pos, Vec3f norm, Vec3ui8 colr, Vec2f tex = Vec2f(0,0)) : position(pos), normal(norm), color(colr), texCoord(tex) {}
|
||||
};
|
||||
|
||||
struct Tri {
|
||||
size_t v0,v1,v2;
|
||||
Tri() = default;
|
||||
Tri(size_t a, size_t b, size_t c) : v0(a), v1(b), v2(c) {}
|
||||
};
|
||||
|
||||
class Mesh {
|
||||
private:
|
||||
std::vector<Vertex> vertices;
|
||||
std::vector<Tri> tris;
|
||||
Vec3f boundBoxMin;
|
||||
Vec3f boundBoxMax;
|
||||
public:
|
||||
Mesh() = default;
|
||||
|
||||
void clear() {
|
||||
vertices.clear();
|
||||
tris.clear();
|
||||
boundBoxMax = Vec3f(0,0,0);
|
||||
boundBoxMin = Vec3f(0,0,0);
|
||||
}
|
||||
|
||||
void addVertex(const Vertex& vertex) {
|
||||
vertices.push_back(vertex);
|
||||
boundBoxMin = boundBoxMin.min(vertex.position);
|
||||
boundBoxMax = boundBoxMax.max(vertex.position);
|
||||
}
|
||||
|
||||
void addTriangle(const Tri& triangle) {
|
||||
tris.push_back(triangle);
|
||||
}
|
||||
|
||||
void addTriangle(uint32_t v0, uint32_t v1, uint32_t v2) {
|
||||
tris.emplace_back(v0, v1, v2);
|
||||
}
|
||||
|
||||
const std::vector<Vertex>& getVertices() const { return vertices; }
|
||||
const std::vector<Tri>& getTriangles() const { return tris; }
|
||||
|
||||
size_t getVertexCount() const { return vertices.size(); }
|
||||
size_t getTriangleCount() const { return tris.size(); }
|
||||
|
||||
Vec3f getBoundingBoxMin() const { return boundBoxMin; }
|
||||
Vec3f getBoundingBoxMax() const { return boundBoxMax; }
|
||||
Vec3f getBoundingBoxSize() const { return boundBoxMax - boundBoxMin; }
|
||||
Vec3f getBoundingBoxCenter() const { return (boundBoxMin + boundBoxMax) * 0.5f; }
|
||||
|
||||
// Calculate normals if they're not already set
|
||||
void calculateNormals() {
|
||||
// Reset all normals to zero
|
||||
for (auto& vertex : vertices) {
|
||||
vertex.normal = Vec3f(0, 0, 0);
|
||||
}
|
||||
|
||||
// Accumulate face normals to vertices
|
||||
for (const auto& tri : tris) {
|
||||
const Vec3f& v0 = vertices[tri.v0].position;
|
||||
const Vec3f& v1 = vertices[tri.v1].position;
|
||||
const Vec3f& v2 = vertices[tri.v2].position;
|
||||
|
||||
Vec3f edge1 = v1 - v0;
|
||||
Vec3f edge2 = v2 - v0;
|
||||
Vec3f normal = edge1.cross(edge2).normalized();
|
||||
|
||||
vertices[tri.v0].normal = vertices[tri.v0].normal + normal;
|
||||
vertices[tri.v1].normal = vertices[tri.v1].normal + normal;
|
||||
vertices[tri.v2].normal = vertices[tri.v2].normal + normal;
|
||||
}
|
||||
|
||||
// Normalize all vertex normals
|
||||
for (auto& vertex : vertices) {
|
||||
if (vertex.normal.lengthSquared() > 0) {
|
||||
vertex.normal = vertex.normal.normalized();
|
||||
} else {
|
||||
vertex.normal = Vec3f(0, 1, 0); // Default up normal
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void optimize() {
|
||||
calculateNormals();
|
||||
//optimize may have optional params later for future expansion of features
|
||||
}
|
||||
};
|
||||
|
||||
class VoxelGrid {
|
||||
private:
|
||||
double binSize = 1;
|
||||
Vec3i gridSize;
|
||||
//int width, height, depth;
|
||||
std::vector<Voxel> voxels;
|
||||
std::unique_ptr<Mesh> cachedMesh;
|
||||
bool meshDirty = true;
|
||||
|
||||
float radians(float rads) {
|
||||
return rads * (M_PI / 180);
|
||||
}
|
||||
|
||||
static Mat4f lookAt(const Vec3f& eye, const Vec3f& center, const Vec3f& up) {
|
||||
Vec3f const f = (center - eye).normalized();
|
||||
Vec3f const s = f.cross(up).normalized();
|
||||
Vec3f const u = s.cross(f);
|
||||
|
||||
Mat4f Result = Mat4f::identity();
|
||||
Result(0, 0) = s.x;
|
||||
Result(1, 0) = s.y;
|
||||
Result(2, 0) = s.z;
|
||||
Result(3, 0) = -s.dot(eye);
|
||||
Result(0, 1) = u.x;
|
||||
Result(1, 1) = u.y;
|
||||
Result(2, 1) = u.z;
|
||||
Result(3, 1) = -u.dot(eye);
|
||||
Result(0, 2) = -f.x;
|
||||
Result(1, 2) = -f.y;
|
||||
Result(2, 2) = -f.z;
|
||||
Result(3, 2) = f.dot(eye);
|
||||
return Result;
|
||||
}
|
||||
|
||||
static Mat4f perspective(float fovy, float aspect, float zNear, float zfar) {
|
||||
float const tanhalfF = tan(fovy / 2);
|
||||
Mat4f Result = 0;
|
||||
Result(0,0) = 1 / (aspect * tanhalfF);
|
||||
Result(1,1) = 1 / tanhalfF;
|
||||
Result(2,2) = zfar / (zNear - zfar);
|
||||
Result(2,3) = -1;
|
||||
Result(3,2) = -(zfar * zNear) / (zfar - zNear);
|
||||
return Result;
|
||||
}
|
||||
|
||||
public:
|
||||
VoxelGrid() : gridSize(0,0,0) {
|
||||
std::cout << "creating empty grid." << std::endl;
|
||||
@@ -115,93 +220,9 @@ public:
|
||||
voxels.resize(w * h * d);
|
||||
}
|
||||
|
||||
//bool serializeToFile(const VoxelGrid grid, const std::string& filename);
|
||||
bool serializeToFile(const std::string& filename) {
|
||||
std::ofstream file(filename, std::ios::binary);
|
||||
if (!file.is_open()) {
|
||||
std::cerr << "failed to open file (serializeToFile): " << filename << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
file.write(magic, 4);
|
||||
|
||||
//file.write(reinterpret_cast<const char*>(&binSize), sizeof(binSize));
|
||||
|
||||
// Write grid dimensions
|
||||
int dims[3] = {gridSize.x, gridSize.y, gridSize.z};
|
||||
file.write(reinterpret_cast<const char*>(dims), sizeof(dims));
|
||||
|
||||
// Write voxel data
|
||||
size_t voxelCount = voxels.size();
|
||||
file.write(reinterpret_cast<const char*>(&voxelCount), sizeof(voxelCount));
|
||||
|
||||
// Write each voxel
|
||||
for (const Voxel& voxel : voxels) {
|
||||
file.write(reinterpret_cast<const char*>(&voxel.active), sizeof(voxel.active));
|
||||
file.write(reinterpret_cast<const char*>(&voxel.color.x), sizeof(voxel.color.x));
|
||||
file.write(reinterpret_cast<const char*>(&voxel.color.y), sizeof(voxel.color.y));
|
||||
file.write(reinterpret_cast<const char*>(&voxel.color.z), sizeof(voxel.color.z));
|
||||
}
|
||||
|
||||
file.close();
|
||||
return !file.fail();
|
||||
}
|
||||
bool serializeToFile(const std::string& filename);
|
||||
|
||||
static std::unique_ptr<VoxelGrid> deserializeFromFile(const std::string& filename) {
|
||||
VoxelGrid outgrid;
|
||||
std::ifstream file(filename, std::ios::binary);
|
||||
if (!file.is_open()) {
|
||||
std::cerr << "Error: Could not open file for reading: " << filename << std::endl;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// Read and verify magic number
|
||||
char filemagic[4];
|
||||
file.read(filemagic, 4);
|
||||
if (std::strncmp(filemagic, "YGG7", 4) != 0) {
|
||||
std::cerr << "Error: Invalid file format or corrupted file" << std::endl;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// Read binSize
|
||||
//file.read(reinterpret_cast<char*>(&binSize), sizeof(binSize));
|
||||
|
||||
// Read grid dimensions
|
||||
int dims[3];
|
||||
file.read(reinterpret_cast<char*>(dims), sizeof(dims));
|
||||
outgrid.resize(Vec3i(dims[0], dims[1], dims[2]));
|
||||
//gridSize = Vec3i(dims[0], dims[1], dims[2]);
|
||||
|
||||
// Read voxel count
|
||||
size_t voxelCount;
|
||||
file.read(reinterpret_cast<char*>(&voxelCount), sizeof(voxelCount));
|
||||
|
||||
// Verify voxel count matches grid dimensions
|
||||
size_t expectedCount = static_cast<size_t>(dims[0]) * dims[1] * dims[2];
|
||||
if (voxelCount != expectedCount) {
|
||||
std::cerr << "Error: Voxel count mismatch. Expected " << expectedCount
|
||||
<< ", found " << voxelCount << std::endl;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// Resize and read voxels
|
||||
//voxels.resize(voxelCount);
|
||||
grid->voxels.resize(voxelCount);
|
||||
for (size_t i = 0; i < voxelCount; ++i) {
|
||||
file.read(reinterpret_cast<char*>(&grid->voxels[i].active), sizeof(grid->voxels[i].active));
|
||||
file.read(reinterpret_cast<char*>(&grid->voxels[i].color.x), sizeof(grid->voxels[i].color.x));
|
||||
file.read(reinterpret_cast<char*>(&grid->voxels[i].color.y), sizeof(grid->voxels[i].color.y));
|
||||
file.read(reinterpret_cast<char*>(&grid->voxels[i].color.z), sizeof(grid->voxels[i].color.z));
|
||||
}
|
||||
|
||||
file.close();
|
||||
if (file.fail()) {
|
||||
std::cerr << "Error: Failed to read from file: " << filename << std::endl;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
return grid;
|
||||
}
|
||||
static std::unique_ptr<VoxelGrid> deserializeFromFile(const std::string& filename);
|
||||
|
||||
Voxel& get(int x, int y, int z) {
|
||||
return voxels[z * gridSize.x * gridSize.y + y * gridSize.x + x];
|
||||
@@ -215,6 +236,10 @@ public:
|
||||
return voxels[xyz.z * gridSize.x * gridSize.y + xyz.y * gridSize.x + xyz.x];
|
||||
}
|
||||
|
||||
const Voxel& get(const Vec3i& xyz) const {
|
||||
return voxels[xyz.z * gridSize.x * gridSize.y + xyz.y * gridSize.x + xyz.x];
|
||||
}
|
||||
|
||||
void resize(int newW, int newH, int newD) {
|
||||
std::vector<Voxel> newVoxels(newW * newH * newD);
|
||||
int copyW = std::min(static_cast<int>(gridSize.x), newW);
|
||||
@@ -266,11 +291,11 @@ public:
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
bool inGrid(Vec3<T> voxl) {
|
||||
bool inGrid(Vec3<T> voxl) const {
|
||||
return (voxl >= 0 && voxl.x < gridSize.x && voxl.y < gridSize.y && voxl.z < gridSize.z);
|
||||
}
|
||||
|
||||
void voxelTraverse(const Vec3d& origin, const Vec3d& end, std::vector<Vec3i>& visitedVoxel) {
|
||||
void voxelTraverse(const Vec3d& origin, const Vec3d& end, std::vector<Vec3i>& visitedVoxel) const {
|
||||
Vec3i cv = (origin / binSize).floorToI();
|
||||
Vec3i lv = (end / binSize).floorToI();
|
||||
Vec3d ray = end - origin;
|
||||
@@ -338,7 +363,7 @@ public:
|
||||
return gridSize.z;
|
||||
}
|
||||
|
||||
frame renderFrame(const Camera& cam, Vec2i resolution, frame::colormap colorformat = frame::colormap::RGB) {
|
||||
frame renderFrame(const Camera& cam, Vec2i resolution, frame::colormap colorformat = frame::colormap::RGB) const {
|
||||
TIME_FUNCTION;
|
||||
Vec3f forward = cam.forward();
|
||||
Vec3f right = cam.right();
|
||||
@@ -421,8 +446,221 @@ public:
|
||||
std::cout << "Inactive voxels: " << (totalVoxels - activeVoxels) << std::endl;
|
||||
std::cout << "Active percentage: " << activePercentage << "%" << std::endl;
|
||||
std::cout << "Memory usage (approx): " << (voxels.size() * sizeof(Voxel)) / 1024 << " KB" << std::endl;
|
||||
std::cout << "Mesh cached: " << (cachedMesh ? "Yes" : "No") << std::endl;
|
||||
if (cachedMesh) {
|
||||
std::cout << "Mesh vertices: " << cachedMesh->getVertexCount() << std::endl;
|
||||
std::cout << "Mesh triangles: " << cachedMesh->getTriangleCount() << std::endl;
|
||||
}
|
||||
std::cout << "============================" << std::endl;
|
||||
}
|
||||
|
||||
private:
|
||||
// Helper function to check if a voxel is on the surface
|
||||
bool isSurfaceVoxel(int x, int y, int z) const {
|
||||
if (!inGrid(Vec3i(x, y, z))) return false;
|
||||
if (!get(x, y, z).active) return false;
|
||||
|
||||
// Check all 6 neighbors
|
||||
static const std::array<Vec3i, 6> neighbors = {{
|
||||
Vec3i(1, 0, 0), Vec3i(-1, 0, 0),
|
||||
Vec3i(0, 1, 0), Vec3i(0, -1, 0),
|
||||
Vec3i(0, 0, 1), Vec3i(0, 0, -1)
|
||||
}};
|
||||
|
||||
for (const auto& n : neighbors) {
|
||||
Vec3i neighborPos(x + n.x, y + n.y, z + n.z);
|
||||
if (!inGrid(neighborPos) || !get(neighborPos).active) {
|
||||
return true; // At least one empty neighbor means this is a surface voxel
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
// Get normal for a surface voxel
|
||||
Vec3f calculateVoxelNormal(int x, int y, int z) const {
|
||||
Vec3f normal(0, 0, 0);
|
||||
|
||||
// Simple gradient-based normal calculation
|
||||
if (inGrid(Vec3i(x+1, y, z)) && !get(x+1, y, z).active) normal.x += 1;
|
||||
if (inGrid(Vec3i(x-1, y, z)) && !get(x-1, y, z).active) normal.x -= 1;
|
||||
if (inGrid(Vec3i(x, y+1, z)) && !get(x, y+1, z).active) normal.y += 1;
|
||||
if (inGrid(Vec3i(x, y-1, z)) && !get(x, y-1, z).active) normal.y -= 1;
|
||||
if (inGrid(Vec3i(x, y, z+1)) && !get(x, y, z+1).active) normal.z += 1;
|
||||
if (inGrid(Vec3i(x, y, z-1)) && !get(x, y, z-1).active) normal.z -= 1;
|
||||
|
||||
if (normal.lengthSquared() > 0) {
|
||||
return normal.normalized();
|
||||
}
|
||||
return Vec3f(0, 1, 0); // Default up normal
|
||||
}
|
||||
|
||||
Vertex getEdgeVertex(int edge, int x, int y, int z, float isoLevel = 0.5f) const {
|
||||
// Edge vertices based on Marching Cubes algorithm
|
||||
static const std::array<std::array<int, 2>, 12> edgeVertices = {{
|
||||
{0, 1}, {1, 2}, {2, 3}, {3, 0}, // Bottom edges
|
||||
{4, 5}, {5, 6}, {6, 7}, {7, 4}, // Top edges
|
||||
{0, 4}, {1, 5}, {2, 6}, {3, 7} // Vertical edges
|
||||
}};
|
||||
|
||||
static const std::array<Vec3f, 8> cubeVertices = {{
|
||||
Vec3f(0, 0, 0), Vec3f(1, 0, 0), Vec3f(1, 1, 0), Vec3f(0, 1, 0),
|
||||
Vec3f(0, 0, 1), Vec3f(1, 0, 1), Vec3f(1, 1, 1), Vec3f(0, 1, 1)
|
||||
}};
|
||||
|
||||
const auto& [v1, v2] = edgeVertices[edge];
|
||||
const Vec3f& p1 = cubeVertices[v1];
|
||||
const Vec3f& p2 = cubeVertices[v2];
|
||||
|
||||
// For binary voxels, we can just use midpoint
|
||||
Vec3f position = (p1 + p2) * 0.5f;
|
||||
|
||||
// Convert to world coordinates
|
||||
position = position + Vec3f(x, y, z);
|
||||
position = position * binSize;
|
||||
|
||||
// Get colors from neighboring voxels
|
||||
Vec3ui8 color1 = get(x, y, z).color;
|
||||
Vec3ui8 color2 = color1;
|
||||
|
||||
// Determine which neighboring voxel to use for the second color
|
||||
// This is simplified - in a full implementation, you'd interpolate based on values
|
||||
if (v2 == 1) color2 = get(x+1, y, z).color;
|
||||
else if (v2 == 3) color2 = get(x, y+1, z).color;
|
||||
else if (v2 == 4) color2 = get(x, y, z+1).color;
|
||||
|
||||
// Interpolate color
|
||||
Vec3ui8 color(
|
||||
static_cast<uint8_t>((color1.x + color2.x) / 2),
|
||||
static_cast<uint8_t>((color1.y + color2.y) / 2),
|
||||
static_cast<uint8_t>((color1.z + color2.z) / 2)
|
||||
);
|
||||
|
||||
// Calculate normal (simplified)
|
||||
Vec3f normal = calculateVoxelNormal(x, y, z);
|
||||
|
||||
return Vertex(position, normal, color);
|
||||
}
|
||||
|
||||
// Helper function to add a face to the mesh
|
||||
void addFace(Mesh& mesh, const Vec3f& basePos, const Vec3f& normal,
|
||||
const Vec3ui8& color, bool flipWinding = false) {
|
||||
Vec3f right, up;
|
||||
|
||||
// Determine right and up vectors based on normal
|
||||
if (std::abs(normal.x) > std::abs(normal.y)) {
|
||||
right = Vec3f(0, 0, 1);
|
||||
} else {
|
||||
right = Vec3f(1, 0, 0);
|
||||
}
|
||||
up = normal.cross(right).normalized();
|
||||
right = up.cross(normal).normalized();
|
||||
|
||||
// Create face vertices
|
||||
float halfSize = binSize * 0.5f;
|
||||
Vec3f center = basePos + normal * halfSize;
|
||||
|
||||
Vec3f v0 = center - right * halfSize - up * halfSize;
|
||||
Vec3f v1 = center + right * halfSize - up * halfSize;
|
||||
Vec3f v2 = center + right * halfSize + up * halfSize;
|
||||
Vec3f v3 = center - right * halfSize + up * halfSize;
|
||||
|
||||
// Add vertices to mesh
|
||||
uint32_t startIndex = static_cast<uint32_t>(mesh.getVertexCount());
|
||||
|
||||
mesh.addVertex(Vertex(v0, normal, color));
|
||||
mesh.addVertex(Vertex(v1, normal, color));
|
||||
mesh.addVertex(Vertex(v2, normal, color));
|
||||
mesh.addVertex(Vertex(v3, normal, color));
|
||||
|
||||
// Add triangles (two triangles per quad)
|
||||
if (flipWinding) {
|
||||
mesh.addTriangle(startIndex, startIndex + 1, startIndex + 2);
|
||||
mesh.addTriangle(startIndex, startIndex + 2, startIndex + 3);
|
||||
} else {
|
||||
mesh.addTriangle(startIndex, startIndex + 2, startIndex + 1);
|
||||
mesh.addTriangle(startIndex, startIndex + 3, startIndex + 2);
|
||||
}
|
||||
}
|
||||
|
||||
public:
|
||||
// Mesh generation using Naive Surface Nets (simpler than Marching Cubes)
|
||||
std::unique_ptr<Mesh> meshify() {
|
||||
TIME_FUNCTION;
|
||||
|
||||
// If mesh is cached and not dirty, return it
|
||||
if (cachedMesh && !meshDirty) {
|
||||
return std::make_unique<Mesh>(*cachedMesh);
|
||||
}
|
||||
|
||||
auto mesh = std::make_unique<Mesh>();
|
||||
mesh->clear();
|
||||
|
||||
// For each voxel that's on the surface, create a quad
|
||||
for (int z = 0; z < gridSize.z; z++) {
|
||||
for (int y = 0; y < gridSize.y; y++) {
|
||||
for (int x = 0; x < gridSize.x; x++) {
|
||||
if (!get(x, y, z).active) continue;
|
||||
|
||||
const Voxel& voxel = get(x, y, z);
|
||||
Vec3f basePos(x * binSize, y * binSize, z * binSize);
|
||||
|
||||
// Check each face
|
||||
// Right face (x+)
|
||||
if (!inGrid(Vec3i(x+1, y, z)) || !get(x+1, y, z).active) {
|
||||
addFace(*mesh, basePos, Vec3f(1, 0, 0), voxel.color, true);
|
||||
}
|
||||
// Left face (x-)
|
||||
if (!inGrid(Vec3i(x-1, y, z)) || !get(x-1, y, z).active) {
|
||||
addFace(*mesh, basePos, Vec3f(-1, 0, 0), voxel.color, false);
|
||||
}
|
||||
// Top face (y+)
|
||||
if (!inGrid(Vec3i(x, y+1, z)) || !get(x, y+1, z).active) {
|
||||
addFace(*mesh, basePos, Vec3f(0, 1, 0), voxel.color, true);
|
||||
}
|
||||
// Bottom face (y-)
|
||||
if (!inGrid(Vec3i(x, y-1, z)) || !get(x, y-1, z).active) {
|
||||
addFace(*mesh, basePos, Vec3f(0, -1, 0), voxel.color, false);
|
||||
}
|
||||
// Front face (z+)
|
||||
if (!inGrid(Vec3i(x, y, z+1)) || !get(x, y, z+1).active) {
|
||||
addFace(*mesh, basePos, Vec3f(0, 0, 1), voxel.color, true);
|
||||
}
|
||||
// Back face (z-)
|
||||
if (!inGrid(Vec3i(x, y, z-1)) || !get(x, y, z-1).active) {
|
||||
addFace(*mesh, basePos, Vec3f(0, 0, -1), voxel.color, false);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Optimize the mesh
|
||||
mesh->optimize();
|
||||
|
||||
// Cache the mesh
|
||||
cachedMesh = std::make_unique<Mesh>(*mesh);
|
||||
meshDirty = false;
|
||||
|
||||
return mesh;
|
||||
}
|
||||
|
||||
// Get cached mesh (regenerates if dirty)
|
||||
std::unique_ptr<Mesh> getMesh() {
|
||||
return meshify();
|
||||
}
|
||||
|
||||
// Clear mesh cache
|
||||
void clearMeshCache() {
|
||||
cachedMesh.reset();
|
||||
meshDirty = true;
|
||||
}
|
||||
|
||||
// Check if mesh needs regeneration
|
||||
bool isMeshDirty() const {
|
||||
return meshDirty;
|
||||
}
|
||||
|
||||
};
|
||||
//#include "g3_serialization.hpp" needed to be usable
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,22 +0,0 @@
|
||||
#ifndef GRID3_Serialization
|
||||
#define GRID3_Serialization
|
||||
|
||||
#include <fstream>
|
||||
#include <cstring>
|
||||
#include "grid3.hpp"
|
||||
|
||||
constexpr char magic[4] = {'Y', 'G', 'G', '3'};
|
||||
|
||||
inline bool serializeToFile(const VoxelGrid& grid, const std::string& filename) {
|
||||
std::ofstream file(filename, std::ios::binary);
|
||||
if (!file.is_open()) {
|
||||
std::cerr << "failed to open file (serializeToFile): " << filename << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
file.write(magic, 4);
|
||||
//int dims[3] = {grid.gridSize.x, grid.gridSize.y, grid.gridSize.z};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user