main.cpp

/*
** PixelMachine
** v 0.2.20071108
**
** A ray-traced 3D renderer by SuperJer
**
** Email = superjer@superjer.com
** Web = http://www.superjer.com/
**
**
**
*/

#include <SDL/SDL.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <memory.h>
#include <time.h>

#define NICEME (0)
#ifdef unix
# include <sys/time.h>
# include <sys/resource.h>
# undef NICEME
# define NICEME (setpriority(PRIO_PROCESS,0,10))
#endif
#ifdef WIN32
# include <windows.h>
# undef NICEME
# define NICEME (SetPriorityClass(GetCurrentProcess(),BELOW_NORMAL_PRIORITY_CLASS))
#endif

#include "pixelmachine.h"
#include "sjui.h"


#define MIN(a,b) ((a)<(b)?(a):(b))
#define MAX(a,b) ((a)>(b)?(a):(b))
#define SWAP(t,a,b) {t SWAP_temp = a;a = b;b = SWAP_temp;}

#define W 800
#define H 600
#define MULTIS 2
#define THREADS 8
#define PHOTONS 0


Uint32 gutime = 0;
Uint32 gutimenow = 0;

SDL_Surface *sdlscreen = NULL;
SDL_Surface *sdlrender = NULL;
SDL_Thread *thread;
const SDL_VideoInfo *pinfo;
PIXELMACHINE *pixelmachine;
SJUI ui;
SJUI_HANDLE h_menu,h_render;

int run_pixel_machine( void *data );
void Render();
void SetVideo( const int nw, const int nh );
bool InRect( const SDL_Rect *porect, const int nx, const int ny );
void Cleanup();


int main( int argc, char* argv[] )
{
 SDL_Event event;
 Uint32 u;
 Uint32 v;
 int i;
 int w = W;
 int h = H;
 int multis = MULTIS;
 int threads = THREADS;
 int photons = PHOTONS;
 unsigned seed = (unsigned)-1;
 bool preview = true;

 NICEME;

 // Process cmd line args
 for(i=1; i<argc; i++)
 {
 if( argv[i][0]=='-' ) switch( argv[i][1] )
 {
 case 'w': w = atoi(argv[i]+2); break;
 case 'h': h = atoi(argv[i]+2); break;
 case 'm': multis = atoi(argv[i]+2); break;
 case 't': threads = atoi(argv[i]+2); break;
 case 'p': photons = atoi(argv[i]+2); break;
 case '-': printf( "Usage: [OPTION]... [SEED]\nRender ray-traced 3D images generated randomly with seed number SEED.\n\n option default description\n -wNUM %7d Set image output width to NUM\n -hNUM %7d Set image output height to NUM\n -mNUM %7d Set multisampling level to NUM (level 2 recommended)\n -tNUM %7d Parallelize with NUM threads\n -pNUM %7d Simulate lighting with NUM million photons!\n",W,H,MULTIS,THREADS,PHOTONS ), exit(0);
 default: fprintf( stderr, "Halt! -%c isn't one of my options!\nUse --help for help.\n", argv[i][1] ), exit(-1);
 }
 else if( seed==(unsigned)-1 )
 {
 seed = atoi(argv[i]);
 if( !seed )
 fprintf( stderr, "Halt! SEED ought to be a positive number, not %s\n", argv[i] ), exit(-1);
 }
 else
 fprintf( stderr, "Halt! I'm confused by cmd line argument #%d: %s\n", i, argv[i] ), exit(-1);
 }
 if( w<1 ) w=W;
 if( h<1 ) h=H;
 if( multis<1 ) multis=MULTIS;
 if( threads<1 ) threads=THREADS;
 if( photons<1 ) photons=PHOTONS;

 // Use time as seed if not otherwise specified
 if( seed==(unsigned)-1 )
 seed = (unsigned)time(NULL);

 // Init SDL
 if( SDL_Init( SDL_INIT_TIMER|SDL_INIT_AUDIO|SDL_INIT_VIDEO ) < 0 || !SDL_GetVideoInfo() )
 return 0;

 // Create Window
 SetVideo( w, h );
 SDL_WM_SetCaption("PixelMachine", NULL);

 pinfo = SDL_GetVideoInfo();

 // font init
 SJF_Init(pinfo);

 //ui setup
 ui.init();
 h_menu = ui.new_control(0,0,0,0);
 h_render = ui.new_control(h_menu,80,15,SJUIF_EXTENDSV);
 ui.set_caption(h_menu,"Click to render...");
 ui.set_caption(h_render,"Loading");

 //pm preview render setup
 pixelmachine = new PIXELMACHINE;
 pixelmachine->init(seed,100,75,1,threads,(photons?1:0));
 thread = SDL_CreateThread(run_pixel_machine,NULL);

 // MAIN LOOP
 while( 1 )
 {
 while( SDL_PollEvent(&event) ) switch(event.type)
 {
 case SDL_VIDEOEXPOSE:
 ;
 break;
 case SDL_VIDEORESIZE:
 SetVideo( event.resize.w, event.resize.h );
 break;
 case SDL_MOUSEBUTTONDOWN:
 if( preview )
 {
 //pm full render go!
 preview = false;
 pixelmachine->cancel = true;
 SDL_WaitThread(thread,NULL); //BUG: thread may not be valid?
 delete pixelmachine;
 pixelmachine = new PIXELMACHINE;
 pixelmachine->init(seed,w,h,multis,threads,photons);
 thread = SDL_CreateThread(run_pixel_machine,NULL);
 }
 break;
 case SDL_KEYDOWN:
 ;
 break;
 case SDL_QUIT:
 pixelmachine->cancel = true;
 SDL_WaitThread(thread,NULL); //BUG: thread may not be valid?
 delete pixelmachine;
 Cleanup();
 break;
 }

 gutimenow = SDL_GetTicks();
 if( (Uint32)(gutimenow-gutime)>50 )
 {
 Render();
 gutime = gutimenow;
 }

 // chill out for a bit
 SDL_Delay(10);
 }

 return 0;
}


int run_pixel_machine( void *data )
{
 pixelmachine->run();
 return 0;
}


void Render()
{
 int i,j,m,n;
 const SDL_VideoInfo *info;
 SDL_Rect rect;
 Uint32 color;
 int winw;
 int winh;
 double ratiox;
 double ratioy;

 info = SDL_GetVideoInfo();
 winw = info->current_w;
 winh = info->current_h;

 if( sdlrender )
 {
 if( !SDL_LockSurface(sdlrender) )
 {
 while( pixelmachine->pop_region(&rect) )
 for(i=rect.x; i<rect.x+rect.w; i++)
 for(j=rect.y; j<rect.y+rect.h; j++)
 {
 Uint8 b = pixelmachine->img[(i+j*pixelmachine->w)*3+0];
 Uint8 g = pixelmachine->img[(i+j*pixelmachine->w)*3+1];
 Uint8 r = pixelmachine->img[(i+j*pixelmachine->w)*3+2];
 ratiox = (double)winw/(double)pixelmachine->w;
 ratioy = (double)winh/(double)pixelmachine->h;
 for(m=(int)(i*ratiox);m<(int)((i+1)*ratiox);m++)
 for(n=(int)(j*ratioy);n<(int)((j+1)*ratioy);n++)
 SDL_SetPixel(sdlrender,m,n,r,g,b);
 }
 SDL_UnlockSurface(sdlrender);
 }
 SDL_BlitSurface(sdlrender,NULL,sdlscreen,NULL);
 }

 ui.set_caption(h_render,pixelmachine->statustext);
 ui.paint(sdlscreen);
 SDL_Flip(sdlscreen);
}



void SetVideo( int nw, int nh )
{
 bool different = (!pinfo || nw!=pinfo->current_w || nh!=pinfo->current_h);

 sdlscreen = SDL_SetVideoMode( nw, nh, SDL_GetVideoInfo()->vfmt->BitsPerPixel, SDL_RESIZABLE|SDL_DOUBLEBUF );
 pinfo = SDL_GetVideoInfo();

 if( different && sdlrender )
 SDL_FreeSurface(sdlrender);
 if( different )
 sdlrender = SDL_CreateRGBSurface(0,nw,nh,pinfo->vfmt->BitsPerPixel,pinfo->vfmt->Rmask,pinfo->vfmt->Gmask,pinfo->vfmt->Bmask,pinfo->vfmt->Amask);
}


bool InRect( const SDL_Rect *porect, const int nx, const int ny )
{
 return ( nx>=porect->x && nx<(porect->x+porect->w) &&
 ny>=porect->y && ny<(porect->y+porect->h) );
}


void Cleanup()
{
 ui.destroy();
 SDL_Quit();
 exit(0);
}