Welcome to Fractal Forums

struct BMPHeader
	{
		short bfType;		  // "BM"
		int bfSize;           // Size of file in bytes
		int bfReserved;       // set to 0
		int bfOffBits;        // Byte offset to actual bitmap data (= 54)
		int biSize;           // Size of BITMAPINFOHEADER, in bytes (= 40)
		int biWidth;          // Width of image, in pixels
		int biHeight;         // Height of images, in pixels
		short biPlanes;       // Number of planes in target device (set to 1)
		short biBitCount;     // Bits per pixel
		int biCompression;    // Type of compression (0 if no compression)
		int biSizeImage;      // Image size, in bytes (0 if no compression)
		int biXPelsPerMeter;  // Resolution in pixels/ meter of display device
		int biYPelsPerMeter;  // Resolution in pixels/ meter of display device
		int biClrUsed;        // Number of colors in the color table (if 0, use maximum allowed by biBitCount)
		int biClrImportant;   // Number of important colors. If 0, all colors are important
	};


	class RenderObject
	{
	private:
		FILE*				file;
		struct BMPHeader	bmph;
		int					bytesPerLine;

	public:
		RenderObject(void)
		{
			file = NULL;
		}

		bool OpenFile(char* filename, int width, int height)
		{
			bytesPerLine = 4 * width;

			bmph.bfType = 0x4D42;
			bmph.bfOffBits = 54;
			bmph.bfSize = bmph.bfOffBits + bytesPerLine * height;
			bmph.bfReserved = 0;
			bmph.biSize = 40;
			bmph.biWidth = width;
			bmph.biHeight = -height;
			bmph.biPlanes = 1;
			bmph.biBitCount = 32;
			bmph.biCompression = 0;
			bmph.biSizeImage = bytesPerLine * height;
			bmph.biXPelsPerMeter = 0;
			bmph.biYPelsPerMeter = 0;
			bmph.biClrUsed = 0;       
			bmph.biClrImportant = 0; 

			errno_t err = fopen_s(&file, filename, "wb");
			
			if(err != 0)
			{ return false; }
  
			fwrite(&bmph.bfType, 2, 1, file);
			fwrite(&bmph.bfSize, 4, 1, file);
			fwrite(&bmph.bfReserved, 4, 1, file);
			fwrite(&bmph.bfOffBits, 4, 1, file);
			fwrite(&bmph.biSize, 4, 1, file);
			fwrite(&bmph.biWidth, 4, 1, file);
			fwrite(&bmph.biHeight, 4, 1, file);
			fwrite(&bmph.biPlanes, 2, 1, file);
			fwrite(&bmph.biBitCount, 2, 1, file);
			fwrite(&bmph.biCompression, 4, 1, file);
			fwrite(&bmph.biSizeImage, 4, 1, file);
			fwrite(&bmph.biXPelsPerMeter, 4, 1, file);
			fwrite(&bmph.biYPelsPerMeter, 4, 1, file);
			fwrite(&bmph.biClrUsed, 4, 1, file);
			fwrite(&bmph.biClrImportant, 4, 1, file);

			return true;
		}

		void Render(int* ptr)
		{
			fwrite(ptr, bytesPerLine, 1, file);
		}

		void CloseFile(void)
		{
			fclose(file);
		}
	};

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<inttypes.h>
#define SMOOTH log( 0.5 * log( window->ESCAPE ))

//prototyping the structures .. 

struct window{
  int xscreen,yscreen,Nxscreen,Nyscreen;
  unsigned long long int MAX,ESCAPE;
  long double ximage,yimage,xoff,yoff;
}wdw,*window;

struct bmpfile{
  unsigned char    magic[2];
}bf,*bfp;

struct fileheader{
  uint32_t         filesize;
  uint16_t         creator1;
  uint16_t         creator2;
  uint32_t         bmpoffset;
}fh,*fhp;

struct bmpinfoheader{
  uint32_t        headersize;
  int32_t         width;
  int32_t         height;
  uint16_t        nplanes;
  uint16_t        bitsperpixel;
  uint32_t        compressiontype;
  uint32_t        bitmapbytesize;
  int32_t         hres;
  int32_t         vres;
  uint32_t        ncolors;
  uint32_t        nimpcolors;
}bh,*bhp;

struct rgb{
  unsigned char r;
  unsigned char g;
  unsigned char b;
 }; 

//prototype the functions ..

struct rgb *color(  long long int count,struct window* window, struct rgb* thc, int c );
int multiply(long double real, long double imaginary,struct window* window );
void control( struct window* window, int bpl,struct bmpfile* bfp,
	      struct fileheader* fhp,struct bmpinfoheader* bhp );
void start();
//color gives four values for color red green blue ..
struct rgb *color( long long int count, struct window* window, struct rgb* thc,int x ){
  int d, r, c = 1,cn, red = 0, green = 0, blue = 0;
 
  cn = count % 512;

  //if the count is over the max then the color should be black ..

  if(count == window->MAX){
    thc[x].b = 0;
    thc[x].g = 0;
    thc[x].r = 0;
    return( thc );
  }
  //otherwise find a color ..
  while(( cn % 256 ) != 0 ){
    d = cn / 256;
    r = cn % 256;
    
    switch( c ){
    case 1: red = r;
      break;
    case 2: green = r;
      break;
    case 3: blue = r;
      break;
    default:printf("shit happens\n");
    }
    cn = d;
    ++c;
   }
  //put color into struct array .. single dimension array of screen width size .. 
  //will write a single line ( row ) at a time.

   thc[x].b = blue * 4;
   thc[x].g = green * 8;
   thc[x].r = red * 16;
   return(thc);
}
// multiply is an iterative process which returns a count which is 
// converted into a color. 
int multiply(long double real, long double imaginary, struct window* window ){

  unsigned long long int count = 1;
  long double x,y,z = 0,xx,yy,tempr = real,tempi = imaginary;
  //made some significant speed gains in control function by trying to use less division
  //so tried it here z is computed once used 3 times ..

  while( count < window->MAX &&
	  abs( z ) < window->ESCAPE ){
    x = tempr * tempr;
    y = tempi * tempi;
    z = tempr * tempi;

    xx = x - y;
    yy = 2 * z;
    z = x + y;

    tempr = real + xx;
    tempi = imaginary + yy;
    count++;
  }
  if(count >= window->MAX ){
    return count;
  }
  return ( count - ( log( 0.5 * log( z )) - SMOOTH ) / log( 2 ));
}
void control( struct window* window, int bpl,struct bmpfile* bfp,
	      struct fileheader* fhp,struct bmpinfoheader* bhp ){

  //create the array to hold each line colors .. 
  int x,y,count;
  long double real,imaginary, convx,convy;

  struct rgb array[ bpl ];
  struct rgb *thc;
  thc = array;
 
  FILE *fp;

  printf("control\n");

  //zero array ..
  for(count = 0; count < window->Nxscreen -1; count++ ){
    array[x].b = 0;
    array[x].g = 0;
    array[x].r = 0;
    //    array[x].reserve = 50;
   }
  //write the headers for the bitmap ..

  fp = fopen("image-01.bmp","wb");
  fwrite(bfp,sizeof(bf),1,fp);
  fwrite(fhp,sizeof(fh),1,fp);
  fwrite(bhp,sizeof(bh),1,fp);
  
  //save time divide once use many times ..
  // numbers give an imaginary number for each pixel ..

  convx =  window->ximage / window->Nxscreen;
  convy =  window->yimage / window->Nyscreen;

  for( y = window->Nyscreen; y < 0; y++ ){
    for( x = 1; x < window->Nxscreen;  x++ ){
      real = convx * x - window->xoff;
      imaginary = window->yoff - ( convy * y );
      count = multiply( real, imaginary, window );  
      color( count, window, thc, x );
    }  
    //should have a full array here .. write it out .. I know the bitmap starts from
    //bottom left to top right but all I want at this stage is something close to mandelbrot set.
    //I have tried to accomadate this by starting y at max and reducing to zero.
    fwrite(&array,sizeof(array),1,fp); 
   }
  fclose( fp );
}
void start( ){
  //setting the conditions for the bitmap .. also screen size and image size.
 
  int bpl;
  bfp = &bf;
  fhp = &fh;
  bhp = &bh;
  window = &wdw;
  
  window->MAX = 128;//can and will change these later
  window->ESCAPE = 4;

  window->xscreen = 809;
  window->yscreen = -500;

  window->Nxscreen = window->xscreen;
  window->Nyscreen = window->yscreen;
 
 //make sure the screen is divisible by 4 ..
  bpl = window->Nxscreen;
  while(bpl % 4 != 0){
    bpl++;
  }
  window->ximage = 3.2; //I am going to draw small set with sdl .. when I see something I like 
  window->yimage = 2.0; //I will draw it with this program .. so these conditions will change ..
  window->xoff = 2.2;      //a data struct in my sdl program holds the info and writes it out for me.
  window->yoff = 1.0; 

  bfp->magic[0] = 'B';
  bfp->magic[1] = 'M';
  
  fhp->filesize = fhp->bmpoffset + abs(window->Nyscreen * bpl);//being lazy I do not want to compute these each 
  //time.
  fhp->bmpoffset = 54;
  fhp->creator1 = 0;
  fhp->creator2 = 0;  
 
  bhp->width = bpl;
  bhp->height = - window->Nyscreen;
  bhp->nplanes = 1;
  bhp->bitsperpixel = 24;
  bhp->compressiontype = 0;
  bhp->bitmapbytesize = bpl * bhp->height;
  bhp->hres = 2835;
  bhp->vres = 2835;
  bhp->ncolors = 0;
  bhp->nimpcolors = 0;
  bhp->headersize = bhp->bitsperpixel + bhp->bitmapbytesize;
 
  control( window,bpl,bfp,fhp,bhp );
}
int main( int argc, char * argv[] ){
  printf("main\n");

  start(); //GO!!
  return(0);
}

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<SDL/SDL.h>
 
#define smooth log( 0.5 * log( window->ESCAPE ))

SDL_Surface *screen;
SDL_Event event;

struct window{
  int xscreen,yscreen,Nxscreen,Nyscreen;
  int a,b,c,d;
  unsigned long long int MAX,ESCAPE;
  long double ximage,yimage,xoff,yoff;
};

struct data{
  int Nxscreen[50],Nyscreen[50];
  long double ximage[50],yimage[50],xoff[50],yoff[50];
};

struct pxcolor{
  int r;
  int g;
  int b;
}arraycolor[512],*prgb;

void write_data(struct data* data);
struct window *image_size( struct window* window );
struct window *window_size( struct window* window );
struct window *mouse( int z, struct window* window );
void putpixel( int x, int y, Uint32 colors );
Uint32 getcolor( int count,struct window* window, struct pxcolor* prgb );
int multiply(long double real, long double imaginary,struct window* window );
void numbers( struct window* window, struct pxcolor* prgb );
void repeat( struct window* window, struct pxcolor* prgb );
void control( struct window* window, struct data* data, struct pxcolor* prgb );
void start( );
void numbers( struct window* window, struct pxcolor* prgb );
void unlock();
void lock();
void sdl( struct window* window );

void write_data(struct data* data){
  FILE *fp;
  int c;
  
  fp = fopen("image_info","w");
  for(c = 0;c < 50; c++){
    fprintf(fp,"c = %i\n",c);
    fprintf(fp,"Nxscreen = %i\n",data->Nxscreen[c]);
    fprintf(fp,"Nyscreen = %i\n",data->Nyscreen[c]);
    
    fprintf(fp,"ximage = %.40Lf\n",data->ximage[c]);
    fprintf(fp,"yimage = %.40Lf\n",data->yimage[c]);
    
    fprintf(fp,"xoff = %.40Lf\n",data->xoff[c]);
    fprintf(fp,"yoff = %.40Lf\n",data->yoff[c]);
  }
  fclose(fp);
}
struct window *image_size( struct window* window ){
  long double s,t,u,v,z;

  z = window->ximage / window->Nxscreen;
  s = z * window->c - window->xoff;
  u = z * window->a - window->xoff;
  
  z = window->yimage / window->Nyscreen;  
  t = window->yoff - ( z * window->d );
  v = window->yoff - ( z * window->b );
  
  window->ximage = u - s;
  window->yimage = t - v;
  window->xoff = -s;
  window->yoff = t;
  return window;
}
struct window *window_size( struct window* window ){

  int t;
   
  window->Nxscreen = window->a - window->c;
  window->Nyscreen = window->b - window->d;
  
  if( window->Nxscreen > window->Nyscreen ){
    t = window->xscreen / window->Nxscreen;
  }
  else{
    t = window->yscreen / window->Nyscreen;
  }

  window->Nxscreen = window->Nxscreen * t;
  window->Nyscreen = window->Nyscreen * t;
  return window;
}
struct window *mouse( int z, struct window* window ){
 
  if( z == 1 ){
    window->c = event.button.x;
    window->d = event.button.y;
  }
  if( z != 1 ){
    window->a = event.button.x;
    window->b = event.button.y;
  }
  return window;  
}
void putpixel( int x, int y, Uint32 colors ){

  Uint32 *bufp;
  bufp = ( Uint32 *)screen->pixels + y*screen->pitch / 4 + x;
  *bufp = colors;
}
Uint32 getcolor( int count, struct window* window, struct pxcolor* prgb ){
  int  red = prgb[( count % 512 )].r;
  int  green = prgb[( count % 512 )].g;
  int blue = prgb[( count % 512 )].b;
  Uint32 colors;
   if(count == window->MAX){
     return( colors = SDL_MapRGB(screen->format,0,0,0));
   }
   else{
     return colors = SDL_MapRGB(screen->format,
				( blue ),( green ),( red ));
   }
}
int multiply(long double real, long double imaginary, struct window* window ){

  int count = 1;
  long double x,y,z = 0,xx,yy,tempr = real,tempi = imaginary;
 
  while( count < window->MAX &&
	  abs( z ) < window->ESCAPE ){
    x = tempr * tempr;
    y = tempi * tempi;
    z = tempr * tempi;

    xx = x - y;
    yy = 2 * z;
    z = x + y;
  
    tempr = real + xx;
    tempi = imaginary + yy;
    count++;
  }
  if(count >= window->MAX ){
    return count;
  }
  else{
    return ( count - ( log( 0.5 * log( z )) - smooth ) / log( 2 ));
  }
}
void numbers( struct window* window, struct pxcolor* prgb ){
  
  int x,y,count;
  Uint32 colors;
  long double real,imaginary, convx,convy;
 
  convx =  window->ximage / window->Nxscreen;
  convy =  window->yimage / window->Nyscreen;

  for( x = 1; x < window->Nxscreen; x++ ){
    for( y = 1; y < window->Nyscreen; y++ ){
      real = convx * x - window->xoff;
      imaginary = window->yoff - ( convy * y );
      count = multiply( real, imaginary, window );
      colors = getcolor( count, window, prgb);
      putpixel( x, y, colors );
    }
  }SDL_UpdateRect( screen,0,0,window->Nxscreen,window->Nyscreen );
  printf("draw finish\n");
}
void repeat( struct window* window, struct pxcolor* prgb){

  sdl( window );
  lock();
  numbers( window,prgb );
  unlock();
}
void control(struct window* window, struct data* data, struct pxcolor* prgb ){

  int c = 1;
  int z = 1;

  while( SDL_WaitEvent( &event )){
    switch( event.type ){
    case SDL_MOUSEBUTTONDOWN:{
      if (event.button.button == SDL_BUTTON_LEFT){
      mouse( z, window );
      if( z != 1 ){

	image_size( window );
	window_size( window );

	data->Nxscreen[c] = window->Nxscreen;
	data->Nyscreen[c] = window->Nyscreen;
	data->ximage[c] = window->ximage;
	data->yimage[c] = window->yimage;
	data->xoff[c] = window->xoff;
	data->yoff[c] = window->yoff;

	c++;
	repeat( window, prgb  );
      }
         z = -z;
      }

	 break;
      }
    case SDL_KEYDOWN:{

      /***DOUBLE WINDOW SIZE***/
      if( event.key.keysym.sym == SDLK_2 ){
	window->Nxscreen = window->Nxscreen * 2;
	window->Nyscreen = window->Nyscreen * 2;
	repeat( window, prgb  );
      }

      if( event.key.keysym.sym == SDLK_3 ){
	window->MAX = 4096;
	window->ESCAPE = 100;	
	repeat( window, prgb  );
      }
      if( event.key.keysym.sym == SDLK_4 ){
	window->MAX = window->MAX * 2;
	window->ESCAPE = window->ESCAPE * 2;	
	repeat( window, prgb  );
      }
      if( event.key.keysym.sym == SDLK_b ){
	c = c - 1;
	window->Nxscreen = data->Nxscreen[c];
	window->Nyscreen = data->Nyscreen[c];

	window->ximage = data->ximage[c];
	window->yimage = data->yimage[c];

	window->xoff = data->xoff[c];
	window->yoff = data->yoff[c];
	repeat( window, prgb  );
      }
       if( event.key.keysym.sym == SDLK_s ){
	SDL_SaveBMP( screen, "shot.bmp" );
      } 
       if( event.key.keysym.sym == SDLK_ESCAPE ){
	write_data(data);
	return( SDL_Quit());
      }
      break;
    }
    }}

}
void unlock(){

   if( SDL_MUSTLOCK( screen )){   
    SDL_UnlockSurface( screen );
  }
}
void lock(){
           
  if( SDL_MUSTLOCK( screen )){
    if( SDL_LockSurface( screen ) < 0 ){
      return;
    }
  }
}
void sdl( struct window* window ){

  SDL_Init( SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE );
  SDL_WM_SetCaption("smooth.c",NULL);
 
              screen = SDL_SetVideoMode
		( window->Nxscreen,window->Nyscreen,
		  32,SDL_SWSURFACE );  
}

void start( ){
 
  int c;
  struct window wdw;
  struct window *window;
  window = &wdw;

  struct data dta;
  struct data *data;
  data = &dta;
  prgb = arraycolor;

  window->MAX = 128;
  window->ESCAPE = 4;
  window->xscreen = 809;
  window->yscreen = 500;
  window->Nxscreen = window->xscreen;
  window->Nyscreen = window->yscreen;
  window->ximage = 3.2;
  window->yimage = 2.0;
  window->xoff = 2.2;
  window->yoff = 1.0;


  for(c = 0; c < 50; c++){
    data->Nxscreen[c] = 0;
    data->Nyscreen[c] = 0;
    data->ximage[c] = 0;
    data->yimage[c] = 0;
    data->xoff[c] = 0;
    data->yoff[c] = 0;
  }
  //make sure initial image is avaliable so no further attempt to go back is made.
  data->Nxscreen[0] = 809;
  data->Nyscreen[0] = 500;
  data->ximage[0] = 3.2;
  data->yimage[0] = 2.0;
  data->xoff[0] = 2.2;
  data->yoff[0] = 1.0;

  for( c = 0; c < 512; c++ ){
    prgb[c].r = 0;
    prgb[c].g = 0;
    prgb[c].b = 0;
  }

  for( c = 0; c < 512; c++ ){
    prgb[c].r = c % 256;
    prgb[c].g = ( c + 32 ) % 256;
    prgb[c].b = ( c + 64 ) % 256;
  }
  repeat( window, prgb );
  control( window, data, prgb );  
}
int main( int argc, char * argv[] ){
  
  start();
  return(0);
}

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<inttypes.h>
#define smooth log( 0.5 * log( window->ESCAPE ))

//prototyping the structures .. 

struct window{
  int Nxscreen,Nyscreen;
  unsigned long long int MAX,ESCAPE;
  long double ximage,yimage,xoff,yoff;
}wdw,*window;

struct pxcolor{
  int r[512];
  int g[512];
  int b[512];
}rgb,*prgb;

struct bmp{
  unsigned char magic[2];    // "BM"
}bfp,*bf
;
struct header{
  uint32_t filesize;                   // Size of file in bytes
  uint16_t creator1;                   //Set to 0
  uint16_t creator2;                   // Set to 0
  uint32_t offset;                     // Byte offset to actual bitmap data (= 54)
  uint32_t headersize;                 // Size of BITMAPINFOHEADER, in bytes (= 40)
  int32_t width;                       // Width of image, in pixels
  int32_t height;                      // Height of images, in pixels
  uint16_t nplanes;                    // Number of planes in target device (set to 1)
  uint16_t bitsperpixel;               // Bits per pixel
  uint32_t compressiontype;            // Type of compression (0 if no compression)
  uint32_t bitmapbytesize;             // Image size, in bytes (0 if no compression)<----remember 0
  int32_t hres;                        // Resolution in pixels/ meter of display device
  int32_t vres;                        // Resolution in pixels/ meter of display device
  uint32_t ncolors;                    // Number of colors in the color table (if 0, use maximum allowed by biBitCount)
  uint32_t nimpcolors;                 // Number of important colors. If 0, all colors are important
}bmp,*hp;

struct rgb{
  unsigned char r;
  unsigned char g;
  unsigned char b;
 }; 

//prototype the functions ..

struct rgb *color(  long long int count,struct window* window, 
		    struct rgb* thc, int x,
		    struct pxcolor* prgb );
int multiply(long double real, long double imaginary,struct window* window );
void control( struct window* window, int bpl, struct header* hp, 
	      struct bmp* bf, struct pxcolor* prgb );
void start();

struct rgb *color( long long int count, struct window* window,
		   struct rgb* thc,int x,
		   struct pxcolor* prgb ){
  int  red = prgb->r[count];
  int  green = prgb->g[count];
  int blue = prgb->b[count];

  if(count == window->MAX){
    thc[x].b = 0;
    thc[x].g = 0;
    thc[x].r = 0;
    return( thc );
  }
  else{
   thc[x].b = blue;
   thc[x].g = green;
   thc[x].r = red;
   return(thc);
  }
}
// multiply is an iterative process which returns a count which is 
// converted into a color. 
int multiply(long double real, long double imaginary, struct window* window ){

  unsigned long long int count = 1;
  long double x,y,z = 0,xx,yy,tempr = real,tempi = imaginary;

  while( count < window->MAX &&
	  abs( z ) < window->ESCAPE ){
    x = tempr * tempr;
    y = tempi * tempi;
    z = tempr * tempi;

    xx = x - y;
    yy = 2 * z;
    z = x + y;

    tempr = real + xx;
    tempi = imaginary + yy;
    count++;
  }
  if(count >= window->MAX ){
    return count;
  }
  return ( count - ( log( 0.5 * log( z )) - smooth ) / log( 2 ));
}
void control( struct window* window, int bpl, struct header* hp, 
	      struct bmp* bf, struct pxcolor* prgb ){

  //create the array to hold each line colors .. 
  int x,y,count;
  long double real,imaginary, convx,convy;
  struct rgb array[ bpl ];
  struct rgb *thc;
  thc = array;
 
  FILE *fp;

  //zero array ..
  for(count = 0; count < window->Nxscreen -1; count++ ){
    thc[x].b = 0;
    thc[x].g = 0;
    thc[x].r = 0;
    //    array[x].reserve = 50;
   }
  //write the headers for the bitmap ..

  fp = fopen("image-01.bmp","wb");
  fwrite(bf,sizeof(bfp),1,fp);  
  fwrite(&bmp,sizeof(bmp),1,fp); 
  
  //imaginary number for each pixel

  convx =  window->ximage / window->Nxscreen;
  convy =  window->yimage / window->Nyscreen;

  for( y = window->Nyscreen; y < 0; y++ ){
    for( x = 1; x < window->Nxscreen;  x++ ){
      real = convx * x - window->xoff;
      imaginary = window->yoff - ( convy * y );
      count = multiply( real, imaginary, window );  
      color( count, window, thc, x, prgb );
    }  
    //should have a full array here .. write it out .. draw line by line
    fwrite(&array,sizeof(array),1,fp); 
   }
  fclose( fp );
}
void start( ){
  //setting the conditions for the bitmap .. also screen size and image size.
 
  int bpl;
  int c;
  window = &wdw;
  hp = &bmp;
  bf = &bfp;
  struct pxcolor arraycolor;
  prgb = &arraycolor;

  window->MAX = 1028;
  window->ESCAPE = 400;
  window->Nxscreen = 809;
  window->Nyscreen = -500;
  window->ximage = 3.2;  
  window->yimage = 2.0; 
  window->xoff = 2.2;   
  window->yoff = 1.0; 
 
 //make sure the Nxscreen is divisible by 4 ..
  bpl = window->Nxscreen;
  while(bpl % 4 != 0){
    bpl++;
  }
  bf->magic[0] = 'B';
  bf->magic[1] = 'M';
  hp->creator1 = 0;
  hp->creator2 = 0;
  hp->offset = 54;
  hp->filesize = hp->offset + (window->Nyscreen * bpl);
  hp->width = bpl;
  hp->height = -window->Nyscreen;
  hp->nplanes = 1;
  hp->bitsperpixel = 24;
  hp->compressiontype = 0;
  hp->bitmapbytesize = bpl * hp->height;
  hp->hres = 2835;
  hp->vres = 2835;
  hp->ncolors = 0;
  hp->nimpcolors = 0;
  hp->headersize = hp->bitsperpixel + hp->bitmapbytesize;

  //initialise all pxcolor elements to zero 
  for( c = 0; c < 512; c++ ){
    prgb->r[c] = 0;
    prgb->g[c] = 0;
    prgb->b[c] = 0;
  }
  for( c = 0; c < 512; c++ ){
    prgb->r[c] = c % 256;
    prgb->g[c] = ( c + 32 ) % 256;
    prgb->b[c] = ( c + 64 ) % 256;
  }
  control( window,bpl,hp,bf,prgb );
}
int main( int argc, char * argv[] ){
  start(); //GO!!
  return(0);
}

byte[] LinePadding(byte[] line, int width)
{
    //byte to add
    int padding = 0;

    //while width * 3 (rgb) + padding isn't a multiple of 4, add pad byte
    while (((width * 3 + padding) % 4) != 0)
        padding++;

    //if pad isn't needed
    if(padding <= 0)
        return line;

    //Create new array with all elements = 0
    byte[] newLine = new byte[width * 3 + padding];

    //Copy old line in new padded line (left the extra byte = 0)
    Array.Copy(line, newLine, line.Length);

    //return padded line
    return newLine;
}