yggdrasil75/stupidsimcpp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fixed 1 direction

Browse Source
This commit is contained in:
yggdrasil75
2026-01-02 05:15:08 -05:00
parent a9caaeb40f
commit 7bc711a3ad
3 changed files with 75 additions and 42 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
tests/g3test2.cpp
View File

@@ -5,23 +5,28 @@
#include "../util/grid/grid3.hpp" #include "../util/grid/grid3.hpp"
#include "../util/output/bmpwriter.hpp" #include "../util/output/bmpwriter.hpp"
#include "../util/noise/pnoise2.hpp" #include "../util/noise/pnoise2.hpp"
#include "../util/timing_decorator.cpp"
// Constants // Constants
const size_t GRID_SIZE = 1024; const size_t GRID_SIZE = 128;
const size_t RENDER_WIDTH = 512; const size_t RENDER_WIDTH = 512;
const size_t RENDER_HEIGHT = 512; const size_t RENDER_HEIGHT = 512;
// Function to generate grayscale noise grid // Function to generate grayscale noise grid
void generateNoiseGrid(VoxelGrid& grid, PNoise2& noise) { void generateNoiseGrid(VoxelGrid& grid, PNoise2& noise) {
TIME_FUNCTION;
std::cout << "Generating 1024x1024x1024 noise grid..." << std::endl; std::cout << "Generating 1024x1024x1024 noise grid..." << std::endl;
// Generate Perlin noise in the grid // Generate Perlin noise in the grid
#pragma omp parallel for
for (size_t z = 0; z < GRID_SIZE; ++z) { for (size_t z = 0; z < GRID_SIZE; ++z) {
if (z % 64 == 0) { if (z % 64 == 0) {
std::cout << "Processing layer " << z << " of " << GRID_SIZE << std::endl; std::cout << "Processing layer " << z << " of " << GRID_SIZE << std::endl;
} }
#pragma omp parallel for
for (size_t y = 0; y < GRID_SIZE; ++y) { for (size_t y = 0; y < GRID_SIZE; ++y) {
#pragma omp parallel for
for (size_t x = 0; x < GRID_SIZE; ++x) { for (size_t x = 0; x < GRID_SIZE; ++x) {
// Create 3D noise coordinates (scaled for better frequency) // Create 3D noise coordinates (scaled for better frequency)
float scale = 0.05f; // Controls noise frequency float scale = 0.05f; // Controls noise frequency
@@ -34,12 +39,16 @@ void generateNoiseGrid(VoxelGrid& grid, PNoise2& noise) {
// Higher threshold = sparser voxels // Higher threshold = sparser voxels
float threshold = 0.3f; float threshold = 0.3f;
float active = (normalizedNoise > threshold) ? normalizedNoise : 0.0f; float active = (normalizedNoise > threshold) ? normalizedNoise : 0.0f;
//float active = 1;
// Create grayscale color based on noise value // Create grayscale color based on noise value
uint8_t grayValue = static_cast<uint8_t>(normalizedNoise * 255); uint8_t grayValue = static_cast<uint8_t>(normalizedNoise * 255);
Vec3ui8 color(grayValue, grayValue, grayValue); Vec3ui8 color(grayValue, grayValue, grayValue);
#pragma omp critical
grid.set(x, y, z, active, color); if (active > threshold) {
grid.set(x, y, z, active, color);
//std::cout << "setting a voxel to color: " << color << " with alpha of " << active << std::endl;
}
} }
} }
} }
@@ -50,7 +59,7 @@ void generateNoiseGrid(VoxelGrid& grid, PNoise2& noise) {
// Function to render grid from a specific viewpoint // Function to render grid from a specific viewpoint
bool renderView(const std::string& filename, VoxelGrid& grid, const Vec3f& position, bool renderView(const std::string& filename, VoxelGrid& grid, const Vec3f& position,
const Vec3f& direction, const Vec3f& up = Vec3f(0, 1, 0)) { const Vec3f& direction, const Vec3f& up = Vec3f(0, 1, 0)) {
TIME_FUNCTION;
Camera cam(position, direction, up); Camera cam(position, direction, up);
std::vector<uint8_t> renderBuffer; std::vector<uint8_t> renderBuffer;
@@ -92,45 +101,46 @@ int main() {
// Camera distance from center (outside the grid) // Camera distance from center (outside the grid)
float cameraDistance = GRID_SIZE * 2.0f; float cameraDistance = GRID_SIZE * 2.0f;
float cameraDir = GRID_SIZE * 0.5f;
// Render from 4 cardinal directions (looking at center) // Render from 4 cardinal directions (looking at center)
std::cout << "\nRendering cardinal views..." << std::endl; std::cout << "\nRendering cardinal views..." << std::endl;
// North view (looking from positive Z towards center) // North view (looking from positive Z towards center)
renderView("north_view.bmp", grid, renderView("output/north_view.bmp", grid,
gridCenter + Vec3f(0, 0, cameraDistance), gridCenter + Vec3f(0, 0, cameraDistance),
Vec3f(0, 0, -1)); // Look towards negative Z Vec3f(0, 0, -1)); // Look towards negative Z
// South view (looking from negative Z towards center) // South view (looking from negative Z towards center)
renderView("south_view.bmp", grid, renderView("output/south_view.bmp", grid,
gridCenter + Vec3f(0, 0, -cameraDistance), gridCenter + Vec3f(0, 0, -cameraDistance),
Vec3f(0, 0, 1)); // Look towards positive Z Vec3f(0, 0, 1)); // Look towards positive Z
// East view (looking from positive X towards center) // East view (looking from positive X towards center)
renderView("east_view.bmp", grid, renderView("output/east_view.bmp", grid,
gridCenter + Vec3f(cameraDistance, 0, 0), gridCenter + Vec3f(cameraDistance, 0, 0),
Vec3f(-1, 0, 0)); // Look towards negative X Vec3f(-1, 0, 0)); // Look towards negative X
// West view (looking from negative X towards center) // West view (looking from negative X towards center)
renderView("west_view.bmp", grid, renderView("output/west_view.bmp", grid,
gridCenter + Vec3f(-cameraDistance, 0, 0), gridCenter + Vec3f(-cameraDistance, 0, 0),
Vec3f(1, 0, 0)); // Look towards positive X Vec3f(1, 0, 0)); // Look towards positive X
// Zenith view (looking from above) // Zenith view (looking from above)
std::cout << "\nRendering zenith and nadir views..." << std::endl; std::cout << "\nRendering zenith and nadir views..." << std::endl;
renderView("zenith_view.bmp", grid, renderView("output/zenith_view.bmp", grid,
gridCenter + Vec3f(0, cameraDistance, 0), gridCenter + Vec3f(0, cameraDistance, 0),
Vec3f(0, -1, 0), // Look down Vec3f(0, -1, 0), // Look down
Vec3f(0, 0, -1)); // Adjust up vector for proper orientation Vec3f(0, 0, -1)); // Adjust up vector for proper orientation
// Nadir view (looking from below) // Nadir view (looking from below)
renderView("nadir_view.bmp", grid, renderView("output/nadir_view.bmp", grid,
gridCenter + Vec3f(0, -cameraDistance, 0), gridCenter + Vec3f(0, -cameraDistance, 0),
Vec3f(0, 1, 0), // Look up Vec3f(0, 1, 0), // Look up
Vec3f(0, 0, 1)); // Adjust up vector Vec3f(0, 0, 1)); // Adjust up vector
// Optional: Create a front view (alternative to north) // Optional: Create a front view (alternative to north)
renderView("front_view.bmp", grid, renderView("output/front_view.bmp", grid,
gridCenter + Vec3f(0, 0, cameraDistance), gridCenter + Vec3f(0, 0, cameraDistance),
Vec3f(0, 0, -1), Vec3f(0, 0, -1),
Vec3f(0, 1, 0)); Vec3f(0, 1, 0));
@@ -151,4 +161,5 @@ int main() {
std::cerr << "Error: " << e.what() << std::endl; std::cerr << "Error: " << e.what() << std::endl;
return 1; return 1;
} }
FunctionTimer::printStats(FunctionTimer::Mode::ENHANCED);
} }

9
util/grid/grid3.hpp
View File

@@ -147,7 +147,7 @@ public:
tDelta.x = std::abs(1.0 / rayDir.x); tDelta.x = std::abs(1.0 / rayDir.x);
tDelta.y = std::abs(1.0 / rayDir.y); tDelta.y = std::abs(1.0 / rayDir.y);
tDelta.z = std::abs(1.0 / rayDir.z); tDelta.z = std::abs(1.0 / rayDir.z);
tMax = mix((rayOrigin - currentVoxel) / -rayDir, ((currentVoxel + 1) - rayOrigin) / rayDir, rayDir > 0); tMax = mix(((rayOrigin - currentVoxel.toFloat()) / -rayDir).toFloat(), (((currentVoxel.toFloat() + 1) - rayOrigin) / rayDir).toFloat(), rayDir.mask([](float x, float value) { return x > 0; }, 0));
if (!inGrid(rayOrigin)) { if (!inGrid(rayOrigin)) {
/* /*
The initialization phase begins by identifying the voxel in which the ray origin, → The initialization phase begins by identifying the voxel in which the ray origin, →
@@ -179,9 +179,9 @@ public:
if (tEntry < 0.0) tEntry = 0.0; if (tEntry < 0.0) tEntry = 0.0;
if (tEntry > 0.0) { if (tEntry > 0.0) {
rayOrigin = rayOrigin + rayDir + tEntry; rayOrigin = rayOrigin + rayDir * tEntry;
currentVoxel = rayOrigin.floorToT(); currentVoxel = rayOrigin.floorToT();
tMax = mix(((currentVoxel + 1) - rayOrigin) / rayDir, (rayOrigin - currentVoxel) / -rayDir, rayDir > 0 ); tMax = mix(((currentVoxel.toFloat() + 1) - rayOrigin) / rayDir, (rayOrigin - currentVoxel) / -rayDir, rayDir.mask([](float x, float value) { return x > 0; }, 0) );
} }
} }
@@ -238,6 +238,9 @@ public:
} }
} }
} }
if (aalpha > EPSILON) {
std::cout << "hit at: " << currentVoxel << " with value of " << aalpha << std::endl;
}
return hit; return hit;
} }

75
util/vectorlogic/vec3.hpp
View File

@@ -27,19 +27,23 @@ public:
} }
// Arithmetic operations // Arithmetic operations
Vec3 operator+(const Vec3& other) const { template<typename U>
Vec3 operator+(const Vec3<U>& other) const {
return Vec3(x + other.x, y + other.y, z + other.z); return Vec3(x + other.x, y + other.y, z + other.z);
} }
Vec3 operator-(const Vec3& other) const { template<typename U>
Vec3 operator-(const Vec3<U>& other) const {
return Vec3(x - other.x, y - other.y, z - other.z); return Vec3(x - other.x, y - other.y, z - other.z);
} }
Vec3 operator*(const Vec3& other) const { template<typename U>
Vec3 operator*(const Vec3<U>& other) const {
return Vec3(x * other.x, y * other.y, z * other.z); return Vec3(x * other.x, y * other.y, z * other.z);
} }
Vec3 operator/(const Vec3& other) const { template<typename U>
Vec3 operator/(const Vec3<U>& other) const {
return Vec3(x / other.x, y / other.y, z / other.z); return Vec3(x / other.x, y / other.y, z / other.z);
} }
@@ -233,6 +237,17 @@ public:
return x >= other.x || y >= other.y || z >= other.z; return x >= other.x || y >= other.y || z >= other.z;
} }
template<typename CompareFunc>
Vec3<bool> mask(CompareFunc comp, T value) const {
return Vec3<bool>(comp(x, value), comp(y, value), comp(z, value));
}
template<typename CompareFunc>
Vec3<bool> mask(CompareFunc comp, const Vec3& other) const {
return Vec3<bool>(comp(x, other.x), comp(y, other.y), comp(z, other.z));
}
Vec3 abs() const { Vec3 abs() const {
return Vec3(std::abs(x), std::abs(y), std::abs(z)); return Vec3(std::abs(x), std::abs(y), std::abs(z));
} }
@@ -248,6 +263,10 @@ public:
Vec3<size_t> floorToT() const { Vec3<size_t> floorToT() const {
return Vec3<size_t>(static_cast<size_t>(std::floor(x)), static_cast<size_t>(std::floor(x)), static_cast<size_t>(std::floor(z))); return Vec3<size_t>(static_cast<size_t>(std::floor(x)), static_cast<size_t>(std::floor(x)), static_cast<size_t>(std::floor(z)));
} }
Vec3<float> toFloat() const {
return Vec3<float>(static_cast<float>(x), static_cast<float>(y), static_cast<float>(z));
}
Vec3 ceil() const { Vec3 ceil() const {
return Vec3(std::ceil(x), std::ceil(y), std::ceil(z)); return Vec3(std::ceil(x), std::ceil(y), std::ceil(z));
@@ -292,33 +311,33 @@ public:
} }
// Template friend operators to allow different scalar types // Template friend operators to allow different scalar types
template<typename S> // template<typename S>
friend Vec3<T> operator+(S scalar, const Vec3<T>& vec) { // friend Vec3<T> operator+(S scalar, const Vec3<T>& vec) {
return Vec3<T>(static_cast<T>(scalar + vec.x), // return Vec3<T>(static_cast<T>(scalar + vec.x),
static_cast<T>(scalar + vec.y), // static_cast<T>(scalar + vec.y),
static_cast<T>(scalar + vec.z)); // static_cast<T>(scalar + vec.z));
} // }
template<typename S> // template<typename S>
friend Vec3<T> operator-(S scalar, const Vec3<T>& vec) { // friend Vec3<T> operator-(S scalar, const Vec3<T>& vec) {
return Vec3<T>(static_cast<T>(scalar - vec.x), // return Vec3<T>(static_cast<T>(scalar - static_cast<S>(vec.x)),
static_cast<T>(scalar - vec.y), // static_cast<T>(scalar - static_cast<S>(vec.y)),
static_cast<T>(scalar - vec.z)); // static_cast<T>(scalar - static_cast<S>(vec.z)));
} // }
template<typename S> // template<typename S>
friend Vec3<T> operator*(S scalar, const Vec3<T>& vec) { // friend Vec3<T> operator*(S scalar, const Vec3<T>& vec) {
return Vec3<T>(static_cast<T>(scalar * vec.x), // return Vec3<T>(static_cast<T>(scalar * vec.x),
static_cast<T>(scalar * vec.y), // static_cast<T>(scalar * vec.y),
static_cast<T>(scalar * vec.z)); // static_cast<T>(scalar * vec.z));
} // }
template<typename S> // template<typename S>
friend Vec3<T> operator/(S scalar, const Vec3<T>& vec) { // friend Vec3<T> operator/(S scalar, const Vec3<T>& vec) {
return Vec3<T>(static_cast<T>(scalar / vec.x), // return Vec3<T>(static_cast<T>(scalar / vec.x),
static_cast<T>(scalar / vec.y), // static_cast<T>(scalar / vec.y),
static_cast<T>(scalar / vec.z)); // static_cast<T>(scalar / vec.z));
} // }
Vec3 reflect(const Vec3& normal) const { Vec3 reflect(const Vec3& normal) const {
return *this - 2.0f * this->dot(normal) * normal; return *this - 2.0f * this->dot(normal) * normal;