trying to fix noise.

util/grid/grid2.hpp

@@ -225,6 +225,9 @@ public:
 
     Grid2 noiseGenGrid(size_t minx,size_t miny, size_t maxx, size_t maxy
                        , float minChance = 0.1f, float maxChance = 1.0f, bool color = true) {
+        std::cout << "generating a noise grid with the following: (" << minx << ", " << miny 
+                << ") by (" << maxx << ", " << maxy << ") " << "chance: " << minChance 
+                << " max: " << maxChance << " gen colors: " << color << std::endl;
         std::vector<Vec2> poses;
         std::vector<Vec4> colors;
         std::vector<float> sizes;
@@ -233,6 +236,7 @@ public:
                 Vec2 pos = Vec2(x,y);
                 float alpha = noisegen.permute(Vec2(x,y));
                 if (alpha > minChance && alpha < maxChance) {
+                    std::cout << "generating at: " << pos.x << ", " << pos.y << ")" << std::endl;
                     if (color) {
                         float red = noisegen.permute(pos);
                         float green = noisegen.permute(pos);
@@ -585,7 +589,7 @@ public:
     // no return because it passes back a 1d vector of ints between 0 and 255 with a width and height
     //get region as rgb 
     void getGridRegionAsRGB(const Vec2& minCorner, const Vec2& maxCorner,
-                           int& width, int& height, std::vector<uint8_t>& rgbData) const {
+                       int& width, int& height, std::vector<uint8_t>& rgbData) const {
         TIME_FUNCTION;
         // Calculate dimensions
         width = static_cast<int>(maxCorner.x - minCorner.x);
@@ -605,13 +609,13 @@ public:
         //     for (int y = minCorner.y; x < maxCorner.y; y++){
         //         Vec2 pos = Vec2(x,y);
         //         size_t posID = getPositionVec(pos, 1.0f, false);
-
+        
         //     }
         // }
         // For each position in the grid, find the corresponding pixel
         for (const auto& [id, pos] : Positions) {
             size_t size = Sizes.at(id);
-                
+            
             // Calculate pixel coordinates
             int pixelXm = static_cast<int>(pos.x - size/2 - minCorner.x);
             int pixelXM = static_cast<int>(pos.x + size/2 - minCorner.x);
@@ -622,7 +626,7 @@ public:
             pixelXM = std::min(width - 1, pixelXM);
             pixelYm = std::max(0, pixelYm);
             pixelYM = std::min(height - 1, pixelYM);
-
+            
             // Ensure within bounds
             if (pixelXM >= minCorner.x && pixelXm < width && pixelYM >= minCorner.y && pixelYm < height) {
                 const Vec4& color = Colors.at(id);
@@ -632,7 +636,7 @@ public:
                     for (int px = pixelXm; px <= pixelXM; ++px){
                         int index = (py * width + px);
                         Vec4 dest = rgbaBuffer[index];
-                        
+                    
                         // Alpha blending: new_color = src * src_alpha + dest * (1 - src_alpha)
                         dest.r = color.r * srcAlpha + dest.r * invSrcAlpha;
                         dest.g = color.g * srcAlpha + dest.g * invSrcAlpha;

util/noise/pnoise2.hpp

@@ -14,13 +14,16 @@ private:
     std::default_random_engine rng;
     float TR,TL,BR,BL;
 public:
-    PNoise2() {
-        permutation.reserve(256);
-        for (int i = 0; i < 256; i++){
-            permutation[i] = i;
+    PNoise2() : rng(std::random_device{}()){
+        //permutation.reserve(256);
+        std::vector<float> permutationt;
+        for (int i = 0; i < 255; i++){
+            //permutation[i] = i;
+            permutationt.push_back(i);
         }
-        std::ranges::shuffle(permutation, rng);
-        permutation.insert(permutation.end(),permutation.begin(),permutation.end());
+        std::ranges::shuffle(permutationt, rng);
+        permutation.insert(permutation.end(),permutationt.begin(),permutationt.end());
+        permutation.insert(permutation.end(),permutationt.begin(),permutationt.end());
     }
 
     float permute(Vec2 point) {

util/output/frame.hpp

@@ -504,4 +504,43 @@ private:
 
 };
 
+
+std::ostream& operator<<(std::ostream& os, frame& f) {
+    os << "Frame[" << f.getWidth() << "x" << f.getHeight() << "] ";
+    
+    // Color format
+    os << "Format: ";
+    switch (f.colorFormat) {
+        case frame::colormap::RGB: os << "RGB"; break;
+        case frame::colormap::RGBA: os << "RGBA"; break;
+        case frame::colormap::BGR: os << "BGR"; break;
+        case frame::colormap::BGRA: os << "BGRA"; break;
+        case frame::colormap::B: os << "Grayscale"; break;
+        default: os << "Unknown"; break;
+    }
+    
+    // Compression info
+    os << " | Compression: " << f.getCompressionTypeString();
+    
+    // Size info
+    if (f.isCompressed()) {
+        os << " | " << f.getSourceSize() << "B -> " << f.getTotalCompressedSize() 
+        << "B (ratio: " << std::fixed << std::setprecision(2) << f.getCompressionRatio() << ":1)";
+    } else {
+        os << " | Size: " << f.getData().size() << "B";
+    }
+    
+    // Data status
+    os << " | Data: ";
+    if (!f.getData().empty()) {
+        os << "raw(" << f.getData().size() << " bytes)";
+    } else if (f.getCompressedDataSize() > 0) {
+        os << "compressed(" << f.getCompressedDataSize() << " words)";
+    } else {
+        os << "empty";
+    }
+    
+    return os;
+}
+
 #endif