Best way to output parallelized data to the window?

[corcordp]

--EDIT: Revised code--

(click to show/hide)

--kernel.cu--

#include <iostream>
#include <SFML/Graphics.hpp>
#include <complex>
#include <cuda.h>
#include <cuda_runtime.h>
#include <stdio.h>
#include <cuComplex.h>
#include <chrono>
#include <thread>

#define zoom_multiplier 4
class settings {
   double xMax, xMin, cMax, cMin;   //S is -2
   int precision;
   double resolution_multiplier; //Reccomended is 20
   double penSize, autozoom_x, autozoom_c;
   bool autozoom;
public:
   settings() {
      xMax = 2;
      xMin = -2;
      cMax = 2;
      cMin = -2;
      std::cout << "Precision? Recommended: 30\n";
      std::cin >> precision;
      std::cout << "\nPixel size? Recommended: 1\n";
      std::cin >> resolution_multiplier;

      
      
      std::cout << "\nAutozoom? (true, false)\n";
      std::cin >> autozoom;
      if (autozoom) {
         autozoom_x = -0.7336438924199521;
         autozoom_c = 0.2455211406714035; //Two coordinates that I thought were cool
      }




   }
   bool get_autozoom() {
      return autozoom;
   }
   double getAZ_x() {
      return autozoom_x;
   }
   double getAZ_y() {
      return autozoom_c;
   }
   double getMin_x()
   {
      return xMin;
   }
   double getMin_c() {
      return cMin;
   }
   double getMax_x() {
      return xMax;
   }
   double getMax_c() {
      return cMax;
   }
   double XstepSize() {
      //Screen is 1920 pixels wide. We have a image of width (100 * (xmax - xmin)), so our pixels
      return  ((xMax - xMin) / 1920) * resolution_multiplier;
   }
   double YstepSize() {
      return ((cMax - cMin) / 1080) * resolution_multiplier;
   }
   int getPrecision() {
      return precision;
   }
   
   //void zoom(double x, double y, sf::View &myView) {
   //   myView.setCenter(sf::Vector2f(x, y));
   //   myView.setSize(myView.getSize().x / 4, myView.getSize().y / 4);
   //   xMin = myView.getCenter().x - (myView.getSize().x / 4);
   //   xMax = myView.getCenter().x + (myView.getSize().x / 4);
   //   cMin = myView.getCenter().y - (myView.getSize().y / 4);
   //   cMax = myView.getCenter().y + (myView.getSize().y / 4);
   //
//   }
   void setPrecision(int newPrecision) {
      precision = newPrecision;
   }
   int getRes() { return resolution_multiplier; }
   void zoom( double x, double y) {
      double centerX = x;
      double centerC = y;
      double sizeX = (xMax - xMin);
      double sizeC = (cMax - cMin);
      xMin = centerX - (sizeX / zoom_multiplier);
      xMax = centerX + (sizeX / zoom_multiplier);
      cMin = centerC - (sizeC / zoom_multiplier);
      cMax = centerC + (sizeC / zoom_multiplier);
   }


};
__global__
void process(int n, int iterations, double Minx, double Miny, double *fz, sf::Uint8 *pixels, double x_step, double y_step, int displayX, int displayY) {
   //   std::cout << blockIdx.x << std::endl;

   int id = blockIdx.x*blockDim.x + threadIdx.x;
   fz[id] = 0;
   
   if (id < n) {
      float i;
      int x_index = id % displayX;
      int y_index = ((id - x_index) / displayX);
      //convert x_index to coord_pos
      double c_r = Minx + (x_index * x_step);
      double c_i = Miny + (y_index * y_step);

      double zr = 0; double zi = 0; double zrsqr = 0; double zisqr = 0;

      for (i = 0; i < iterations; i=i+2) {
         
         zi = zr * zi;
         zi += zi;
         zi += c_i;
         zr = zrsqr - zisqr + c_r;
         zrsqr = pow(zr, 2);
         zisqr = pow(zi, 2);
         zi = zr * zi;
         zi += zi;
         zi += c_i;
         zr = zrsqr - zisqr + c_r;
         zrsqr = pow(zr, 2);
         zisqr = pow(zi, 2);
         if (zrsqr+zisqr > 4) {
               break;
         }

         
         

      }
      if ( i >= iterations ) {
         pixels[id * 4] = 30;
         pixels[4 * id + 1] = 10;
         pixels[4 * id + 2] = 60;
         pixels[4 * id + 3] = 255;
      }else {
         
         
         pixels[id * 4] = 255 * (i / iterations);
         pixels[4 * id + 1] = 100 / (i / iterations);
         pixels[4 * id + 2] = 255;
         pixels[4 * id + 3] = 255;
      }
   }
}

int main()
{
   settings instance;

   sf::RenderWindow window(sf::VideoMode(1920, 1080), "Chaos Explorer");

   int displayX = ceil(1920 / instance.getRes());
   int displayY = ceil(1080 / instance.getRes());
   sf::Uint8 *pixels = new sf::Uint8[displayX * displayY * 4];
   sf::Sprite sprite;
   int total_size = displayX * displayY; //How many elements in this array?
   std::cout << "arrays purged succesfully";
   double *fz;
   cudaMallocManaged(&fz, total_size * sizeof(double));
   cudaMallocManaged(&pixels, 4*total_size * sizeof(sf::Uint8));
   sf::Texture texture;
   while (window.isOpen()) {

      std::cout << "total length: " << total_size << std::endl;

      for (int i = 0; i < total_size; i++) {
         fz = 0.0f;
      }

      {
         double Minx = instance.getMin_x();
         double Miny = instance.getMin_c();
         int iterations = instance.getPrecision();
         double x_step = instance.XstepSize();
         double y_step = instance.YstepSize();
         std::cout << "--Process Initiated--\nBetween X: " << Minx << ", " << instance.getMax_x() << "\nC: " << Miny << ", " << instance.getMax_c() << std::endl;
         std::cout << "Processing data points: sending elements to CUDA\n";
         //cudaMemcpy(d_fz, fz, total_size * sizeof(double), cudaMemcpyHostToDevice);
         
         auto start = std::chrono::high_resolution_clock::now();
         process <<<total_size, 1 >>> (total_size, iterations, Minx, Miny, fz, pixels, x_step, y_step, displayX, displayY);
         cudaDeviceSynchronize();
         auto stop = std::chrono::high_resolution_clock::now();
         auto duration = std::chrono::duration_cast<std::chrono::microseconds>(stop - start);
         std::cout << "Iterative processing time (GPU): " << duration.count() / pow(10, 6) << " seconds" << std::endl;
         start = std::chrono::high_resolution_clock::now();
         std::cout << "creating image from data array...";
         sf::Image image;
         image.create(displayX, displayY, pixels);
         texture.loadFromImage(image);
         sprite.setTexture(texture);
         window.draw(sprite);
         window.display();
         stop = std::chrono::high_resolution_clock::now();
         duration = std::chrono::duration_cast<std::chrono::microseconds>(stop - start);

         std::cout << "Image processing time (CPU): " << duration.count() / pow(10, 6) << " seconds" << std::endl;






         //std::cout << "system 1: \n";


         sf::Event event;


         std::cout << "render complete" << std::endl;
         bool wait = false;
         
         if (instance.get_autozoom() == false) {
             wait = true;
         }
         else {
            //autozoom routine;
            instance.zoom(instance.getAZ_x(), instance.getAZ_y());
            instance.setPrecision(instance.getPrecision() + 9);

         }
         while (wait) {

            while (window.pollEvent(event))
            {
               if (event.type == sf::Event::Closed) {
                  free(fz);
                  free(pixels);
                  window.close();
                  //return 0;
               }
               if (event.type == sf::Keyboard::Escape) {
                  free(fz);
                  free(pixels);
                  window.close();
                  //return 0;
               }
               if (sf::Mouse::isButtonPressed(sf::Mouse::Left)) {
                  sf::Vector2i mousepos = sf::Mouse::getPosition(window);

                  //XMin + (pixels * stepx), XMin + (pixels * stepx)
                  //sf::Vector2f plotpos(instance.getMin_x() + (mousepos.x * instance.XstepSize()), instance.getMin_c() + (mousepos.y * instance.YstepSize()));
                  instance.zoom(instance.getMin_x() + (mousepos.x * instance.XstepSize()), instance.getMin_c() + (mousepos.y * instance.YstepSize()));

                  //instance.zoom(plotpos.x, plotpos.y);
                  //camera.setSize(camera.getSize().x / 2, camera.getSize().y / 2);
                  instance.setPrecision(instance.getPrecision() + ;

                  wait = false;


               }
            }

         }




         }


      }


   
   return 0;
}

Hi guys, first time posting here...
I've been working on a mandelbrot plotting application. It works with CUDA, where each evaluated point on the complex plane is assigned an individual thread. The thread runs the mandelbrot iteration on it's assigned point.
The thread stops iterating when the iteration diverges, and a color (alpha channel format) value is assigned to the point.
These alpha values are stored in a uint8 array of size (x_resolution * y_resolution * 4).  Previously, I have used a rectangleShape and had the CPU manually plot each point, changing the fillcolor of the shape based on the data. This was very slow.
Some other people have shown that an array of uint8 can be turned into an sf::image by referring the array in the images constructor, but when I tried that I just got an error.

Here is the code for the version I am trying to get to work...

(click to show/hide)

#include <iostream>
#include <SFML/Graphics.hpp>
#include <complex>
#include <cuda.h>
#include <cuda_runtime.h>
#include <stdio.h>
#include <cuComplex.h>
#include <chrono>
#include <thread>
class settings {
   double xMax, xMin, cMax, cMin;   //S is -2
   int precision;
   double resolution_multiplier; //Reccomended is 20
   double penSize;
public:
   settings() {
      xMax = 2;
      xMin = -2;
      cMax = 2;
      cMin = -2;
      precision = 35;
      resolution_multiplier = 1;
   }
   sf::Vector2f getMin() {
      sf::Vector2f min(xMin, cMin);
      return min;
   }
   sf::Vector2f getMax() {
      sf::Vector2f max(xMax, cMax);
      return max;
   }
   sf::Vector2f getPen() {
      sf::Vector2f mypen(((xMax - xMin) / 1920) * resolution_multiplier * 2, ((cMax - cMin) / 1080) * resolution_multiplier);
      return mypen;

   }
   double XstepSize() {
      //Screen is 1920 pixels wide. We have a image of width (100 * (xmax - xmin)), so our pixels
      return  ((xMax - xMin) / 1920) * resolution_multiplier;
   }
   double YstepSize() {
      return ((cMax - cMin) / 1080) * resolution_multiplier;
   }
   int getPrecision() {
      return precision;
   }
   void zoom(double x, double y, sf::View &myView) {
      myView.setCenter(sf::Vector2f(x, y));
      myView.setSize(myView.getSize().x / 4, myView.getSize().y / 4);
      xMin = myView.getCenter().x - (myView.getSize().x / 4);
      xMax = myView.getCenter().x + (myView.getSize().x / 4);
      cMin = myView.getCenter().y - (myView.getSize().y / 4);
      cMax = myView.getCenter().y + (myView.getSize().y / 4);
   }
   void setPrecision(int newPrecision) {
      precision = newPrecision;
   }
   int getRes() { return resolution_multiplier; }



};

__global__
void process(int n, int iterations, double Minx, double Miny, double *fz, sf::Uint8 *pixels, double x_step, double y_step, int displayX, int displayY) {
   //   std::cout << blockIdx.x << std::endl;

   int id = blockIdx.x*blockDim.x + threadIdx.x;
   fz[id] = 0;
   if (id < n) {
      int i;

      int x_index = id % displayX;
      int y_index = ((id - x_index) / displayX);
      //convert x_index to coord_pos
      double c_r = Minx + (x_index * x_step);
      double c_i = Miny + (y_index * y_step);


      double zr = 0; double zi = 0; double zrsqr = 0; double zisqr = 0;

      for (i = 0; i < iterations; i++) {
         zi = zr * zi;
         zi += zi;
         zi += c_i;
         zr = zrsqr - zisqr + c_r;
         zrsqr = zr * zr;
         zisqr = zi * zi;

         if ((abs(zrsqr) >= 2) || (abs(zisqr) >= 2)) {
            break;
         }

         if (zrsqr + zisqr > 6.0) break;
      }

      pixels[id*4] = 255;
      pixels[4 * id + 1] = 255;
      pixels[4 * id + 2] = 255;
      pixels[4 * id + 3] = 255;


   }

}





int main()
{
   settings instance;

   sf::RenderWindow window(sf::VideoMode(1920, 1080), "Fractal Explorer");

   sf::View camera;


   camera.setSize(sf::Vector2f(instance.getMax().x - instance.getMin().x, instance.getMax().y - instance.getMin().y));
   std::cout << "X: " << camera.getSize().x << "\nY: " << camera.getSize().y;

   camera.setCenter(0, 0);
   sf::RectangleShape pen(instance.getPen());

   pen.setFillColor(sf::Color::Blue);

   //Create a giant array for the GPU to do the iterations on

   //Declare giant tables;
   int displayX = ceil(1920 / instance.getRes());
   int displayY = ceil(1080 / instance.getRes());
   sf::Uint8 *pixels = new sf::Uint8[displayX * displayY * 4];
   sf::Sprite sprite;
   int total_size = displayX * displayY; //How many elements in this array?
   std::cout << "arrays purged succesfully";
   double *fz;
   cudaMallocManaged(&fz, total_size * sizeof(double));
   cudaMallocManaged(&pixels, total_size * sizeof(sf::Uint8));
   sf::Texture texture;
   while (window.isOpen()) {







      std::cout << "total length: " << total_size << std::endl;





      for (int i = 0; i < total_size; i++) {
         fz = 0.0f;
      }

      {
         std::cout << "Y points: " << displayY << "\nX points: " << displayX << std::endl;
         //cudaMemcpy(d_fz, fz, total_size * sizeof(double), cudaMemcpyHostToDevice);

         double Minx = instance.getMin().x;
         double Miny = instance.getMin().y;
         int iterations = instance.getPrecision();
         double x_step = instance.XstepSize();
         double y_step = instance.YstepSize();
         auto start = std::chrono::high_resolution_clock::now();
         process <<<total_size, 1 >>> (total_size, iterations, Minx, Miny, fz, pixels, x_step, y_step, displayX, displayY);
         cudaDeviceSynchronize();
         auto stop = std::chrono::high_resolution_clock::now();
         auto duration = std::chrono::duration_cast<std::chrono::microseconds>(stop - start);
         std::cout << "duration: " << duration.count() << std::endl;

         
         sf::Image image;
         image.create(displayX, displayY, pixels);
         texture.loadFromImage(image);

         
         sprite.setTexture(texture);
         window.draw(sprite);
         window.display();






         std::cout << "system 1: \n";

         window.setView(camera);

         sf::Event event;


         int get;
         int index_x = 0;
         int index_y = 0;
         //window.clear(sf::Color::Black);
         for (double C_complex = instance.getMin().y; C_complex < instance.getMax().y; C_complex = C_complex + instance.YstepSize()) {
            index_x = 0;
            int my_index;
            for (double C_real = instance.getMin().x; C_real < instance.getMax().x; C_real = C_real + instance.XstepSize()) {

               //std::cout << "-------------\n";
            //   std::cout << "attempted to access index : " << index_x + (displayX * index_y) << std::endl;
               //size_t S = sizeof(fz) / sizeof(fz[0]);
               //std::cout << "out of " << total_size << std::endl;
               //std::cout << "index x " << index_x << "\nindex y " << index_y << std::endl;
               //std::cout << "value: ";


               //std::cout << "out of: " << sizeof(fz) / sizeof(fz[0]) <<std::endl;
               my_index = index_x + (displayX * index_y);
               if (my_index % 10000 == 0) { window.display(); }
               get = fz[index_x + (displayX * index_y)];
               //std::cout << get << std::endl;
               pen.setPosition(C_real, C_complex);
               if (get == instance.getPrecision()) {
                  pen.setFillColor(sf::Color::Black);
                  //   std::cout << "diverge!" << std::endl;
               }
               else {
                  pen.setFillColor(sf::Color(255 * static_cast<double>(get) / instance.getPrecision(), 230 * static_cast<double>(get) / instance.getPrecision(), 255, 255));
               }
               window.draw(pen);
               if (my_index % 10000 == 0) { window.display(); }


               //window.display();



               while (window.pollEvent(event))
               {
                  if (event.type == sf::Event::Closed)
                     window.close();
                  if (event.type == sf::Keyboard::Escape)
                     window.close();
               }
               if (index_x + (displayX * index_y) < total_size) {
                  index_x++;
               }

            }

            if (index_x + (displayX * index_y) < total_size - displayX) {
               index_y++;
            }

         }
         window.display();


         std::cout << "render complete" << std::endl;
         bool wait = true;
         while (wait) {
            while (window.pollEvent(event))
            {
               if (event.type == sf::Event::Closed) {
                  free(fz);
                  window.close();
               }
               if (event.type == sf::Keyboard::Escape) {
                  free(fz);
                  window.close();
               }
               if (sf::Mouse::isButtonPressed(sf::Mouse::Left)) {
                  sf::Vector2i mousepos = sf::Mouse::getPosition(window);
                  sf::Vector2f plotpos = window.mapPixelToCoords(mousepos);


                  instance.zoom(plotpos.x, plotpos.y, camera);
                  camera.setSize(camera.getSize().x / 2, camera.getSize().y / 2);
                  instance.setPrecision(instance.getPrecision() + 20);

                  wait = false;
                  pen.setSize(instance.getPen());


               }
            }


         }


      }


   }
   return 0;
}

When I compile this my IDE breaks
"Unhandled exception at 0x00007FFC5038122E (vcruntime140.dll) in debugBuild.exe: 0xC0000006: In page error reading location 0x0000000704800000 (status code 0xC0000022)."

Visual studio shows the break as occuring when I try to construct the image, on the line image.create(displayX, displayY, pixels);

displayX is the horizontal resolution. displayY is the vertical resolution. pixels is the uint8 array of alpha channels






here is the code for a version that does work (but draws to the renderwindow)

(click to show/hide)

#include <iostream>
#include <SFML/Graphics.hpp>
#include <complex>
#include <cuda.h>
#include <cuda_runtime.h>
#include <stdio.h>
#include <cuComplex.h>
#include <chrono>
#include <thread>
class settings {
   double xMax, xMin, cMax, cMin;   //S is -2
   int precision;
   double resolution_multiplier; //Reccomended is 20
   double penSize;
public:
   settings() {
      xMax = 2;
      xMin = -2;
      cMax = 2;
      cMin = -2;
      precision = 35;
      resolution_multiplier = 1;
   }
   sf::Vector2f getMin() {
      sf::Vector2f min(xMin, cMin);
      return min;
   }
   sf::Vector2f getMax() {
      sf::Vector2f max(xMax, cMax);
      return max;
   }
   sf::Vector2f getPen() {
      sf::Vector2f mypen(((xMax - xMin) / 1920) * resolution_multiplier * 2, ((cMax - cMin) / 1080) * resolution_multiplier);
      return mypen;

   }
   double XstepSize() {
      //Screen is 1920 pixels wide. We have a image of width (100 * (xmax - xmin)), so our pixels
      return  ((xMax - xMin) / 1920) * resolution_multiplier;
   }
   double YstepSize() {
      return ((cMax - cMin) / 1080) * resolution_multiplier;
   }
   int getPrecision() {
      return precision;
   }
   void zoom(double x, double y, sf::View &myView) {
      myView.setCenter(sf::Vector2f(x, y));
      myView.setSize(myView.getSize().x / 4, myView.getSize().y / 4);
      xMin = myView.getCenter().x - (myView.getSize().x / 4);
      xMax = myView.getCenter().x + (myView.getSize().x / 4);
      cMin = myView.getCenter().y - (myView.getSize().y / 4);
      cMax = myView.getCenter().y + (myView.getSize().y / 4);
   }
   void setPrecision(int newPrecision) {
      precision = newPrecision;
   }
   int getRes() { return resolution_multiplier; }



};

__global__
void process(int n, int iterations, double Minx, double Miny, double *fz, double x_step, double y_step, int displayX, int displayY) {
   //   std::cout << blockIdx.x << std::endl;

   int id = blockIdx.x*blockDim.x + threadIdx.x;
   fz[id] = 0;
   if (id < n) {
      int i;

      int x_index = id % displayX;
      int y_index = ((id - x_index) / displayX);
      //convert x_index to coord_pos
      double c_r = Minx + (x_index * x_step);
      double c_i = Miny + (y_index * y_step);


      double zr = 0; double zi = 0; double zrsqr = 0; double zisqr = 0;

      for (i = 0; i < iterations; i++) {
         zi = zr * zi;
         zi += zi;
         zi += c_i;
         zr = zrsqr - zisqr + c_r;
         zrsqr = zr * zr;
         zisqr = zi * zi;

         if ((abs(zrsqr) >= 2) || (abs(zisqr) >= 2)) {
            break;
         }

         if (zrsqr + zisqr > 6.0) break;
      }
      fz[id] = i;


   }

}





int main()
{
   settings instance;

   sf::RenderWindow window(sf::VideoMode(1920, 1080), "");

   sf::View camera;


   camera.setSize(sf::Vector2f(instance.getMax().x - instance.getMin().x, instance.getMax().y - instance.getMin().y));
   std::cout << "X: " << camera.getSize().x << "\nY: " << camera.getSize().y;

   camera.setCenter(0, 0);
   sf::RectangleShape pen(instance.getPen());

   pen.setFillColor(sf::Color::Blue);


   //Create a giant array for the GPU to do the iterations on

   //Declare giant tables;
   int displayX = ceil(1920 / instance.getRes());
   int displayY = ceil(1080 / instance.getRes());

   int total_size = displayX * displayY; //How many elements in this array?
   std::cout << "arrays purged succesfully";
   double *fz;
   cudaMallocManaged(&fz, total_size * sizeof(double));

   while (window.isOpen()) {







      std::cout << "total length: " << total_size << std::endl;





      for (int i = 0; i < total_size; i++) {
         fz = 0.0f;
      }

      {
         std::cout << "Y points: " << displayY << "\nX points: " << displayX << std::endl;
         //cudaMemcpy(d_fz, fz, total_size * sizeof(double), cudaMemcpyHostToDevice);

         double Minx = instance.getMin().x;
         double Miny = instance.getMin().y;
         int iterations = instance.getPrecision();
         double x_step = instance.XstepSize();
         double y_step = instance.YstepSize();
         auto start = std::chrono::high_resolution_clock::now();
         process << <total_size, 1 >> > (total_size, iterations, Minx, Miny, fz, x_step, y_step, displayX, displayY);
         cudaDeviceSynchronize();
         auto stop = std::chrono::high_resolution_clock::now();
         auto duration = std::chrono::duration_cast<std::chrono::microseconds>(stop - start);
         std::cout << "duration: " << duration.count() << std::endl;
         //cudaMemcpy(d_fz, fz, total_size * sizeof(double), cudaMemcpyDeviceToHost);




         std::cout << "system 1: \n";

         window.setView(camera);

         sf::Event event;


         int get;
         int index_x = 0;
         int index_y = 0;
         //window.clear(sf::Color::Black);
         for (double C_complex = instance.getMin().y; C_complex < instance.getMax().y; C_complex = C_complex + instance.YstepSize()) {
            index_x = 0;
            int my_index;
            for (double C_real = instance.getMin().x; C_real < instance.getMax().x; C_real = C_real + instance.XstepSize()){

               //std::cout << "-------------\n";
            //   std::cout << "attempted to access index : " << index_x + (displayX * index_y) << std::endl;
               //size_t S = sizeof(fz) / sizeof(fz[0]);
               //std::cout << "out of " << total_size << std::endl;
               //std::cout << "index x " << index_x << "\nindex y " << index_y << std::endl;
               //std::cout << "value: ";


               //std::cout << "out of: " << sizeof(fz) / sizeof(fz[0]) <<std::endl;
                           my_index = index_x + (displayX * index_y);
                           if (my_index % 10000 == 0) { window.display(); }
                        get = fz[index_x + (displayX * index_y)];
   //std::cout << get << std::endl;
               pen.setPosition(C_real, C_complex);
               if (get == instance.getPrecision()) {
                  pen.setFillColor(sf::Color::Black);
                  //   std::cout << "diverge!" << std::endl;
               }
               else {
                  pen.setFillColor(sf::Color(255 * static_cast<double>(get) / instance.getPrecision(), 230 * static_cast<double>(get) / instance.getPrecision(), 255, 255));
               }
               window.draw(pen);
               if(my_index % 10000 == 0) { window.display();}


               //window.display();



               while (window.pollEvent(event))
               {
                  if (event.type == sf::Event::Closed)
                     window.close();
                  if (event.type == sf::Keyboard::Escape)
                     window.close();
               }
               if (index_x + (displayX * index_y) < total_size) {
                  index_x++;
               }

            }

            if (index_x + (displayX * index_y) < total_size - displayX) {
               index_y++;
            }

         }
         window.display();
         
         
         std::cout << "render complete" << std::endl;
         bool wait = true;
         while (wait) {
            while (window.pollEvent(event))
            {
               if (event.type == sf::Event::Closed) {
                  free(fz);
                  window.close();
               }
               if (event.type == sf::Keyboard::Escape) {
                  free(fz);
                  window.close();
               }
               if (sf::Mouse::isButtonPressed(sf::Mouse::Left)) {
                  sf::Vector2i mousepos = sf::Mouse::getPosition(window);
                  sf::Vector2f plotpos = window.mapPixelToCoords(mousepos);


                  instance.zoom(plotpos.x, plotpos.y, camera);
                  camera.setSize(camera.getSize().x / 2, camera.getSize().y / 2);
                  instance.setPrecision(instance.getPrecision() + 20);
                  
                  wait = false;
                  pen.setSize(instance.getPen());


               }
            }






         }


      }


   }
   return 0;
}

I'm relatively new to c++ and SFML, are there any unrelated things could I be doing differently? I plan to consolidate the loose variables soon (hopefully within the settings class).

Thanks for the help,
Dan

[corcordp]

I realized that when I allocated memory on the GPU for the uint8 array, I actually needed it to be 4*number of pixels... Now the image flashes for a brief second. Still some issues with the window scaling and the colors, but the lack of allocated memory was definitely the cause of this first issue.