//temporalVisualizer.c - display temporal distortion portals in video
#include <stdio.h>
#include <math.h>
#include "SDL.h"
#include "SDL_image.h"

#define WIDTH  1024     // screen dimensions
#define HEIGHT 768
#define MAX_IMAGES 110  // number of frames to read from disk
#define PORTAL_DIA 50   // center distortion portal size

// use 1 for per pixel correctness, multiples of ten for faster 'chunking'
int chunkSize=1;

int pixels[WIDTH][HEIGHT];      // frame number at each pixel coordinate
int animateGrid[WIDTH][HEIGHT]; // record animation position at each pixel

SDL_Surface *screen;            // surface to display to user
SDL_Event event;                // keyboard, mouse event handling
SDL_Surface* immutableImage;    // base image to overwrite each frame
SDL_Surface* frame[MAX_IMAGES]; // array of frames to animate
SDL_Rect baseRect;              // immutable image clipping rect
SDL_Rect src;                   // current frame clipping rect

int mouseX = 0;
int mouseY = 0;
int mouseIsDown = 0;
int stopMainLoop = 0;

                
void initScreen();
void loadImages();
void checkEvents();
void resetPixels();
void circleSetPixels(float, float, float);   
void lineSet(int, int, int, int, int);
void topCircle(float, float, int, float);
void bottomCircle(float, float, int, float);
void drawPixels();
void animateFrames();

                
void initScreen()
{
  const SDL_VideoInfo *info;
  Uint8  video_bpp;
  Uint32 videoflags;

  if ( SDL_Init(SDL_INIT_VIDEO) < 0 )
  {
    fprintf(stderr, "Problem initializing SDL: %s\n",SDL_GetError());
    exit(1);
  }
  atexit(SDL_Quit);

  info = SDL_GetVideoInfo();
  video_bpp = info->vfmt->BitsPerPixel;

  // store surfaces in hardware video memory where possible, and enable 
  // double buffering on the displayable surface
  videoflags = SDL_HWSURFACE | SDL_RESIZABLE | SDL_DOUBLEBUF;

  if ( (screen=SDL_SetVideoMode(WIDTH,HEIGHT,video_bpp,videoflags)) == NULL )
  {
    fprintf(stderr, "Video mode error: %s\n",SDL_GetError());
    exit(2);
  }
  SDL_WM_SetCaption("temporalVisualization","temporalVisualization");

}//initScreen

                
void loadImages()
{
  int i=0;
  char filename[100];

  for( i=1; i<=MAX_IMAGES; i++ )
  {
    sprintf(filename,"temporal.images/%d.jpg",i);

    SDL_Surface *tempSurface;
    if( (tempSurface=IMG_Load(filename))==NULL )
    {
      fprintf(stderr, "Image load error for file %s\n",filename);
      exit(3);
    }

    frame[i] = SDL_ConvertSurface(tempSurface, screen->format, SDL_HWSURFACE);

    fprintf(stdout,"loaded image %d\n",i);
  }//for i

  sprintf(filename,"temporal.images/%d.jpg",1);
  immutableImage = SDL_ConvertSurface( IMG_Load(filename),
                    screen->format, SDL_HWSURFACE);

  baseRect.x = 1;
  baseRect.y = 1;
  baseRect.w = immutableImage->w;
  baseRect.h = immutableImage->h;

}//loadImages

                
void checkEvents()
{
  while ( SDL_PollEvent(&event) )
  {
    if( event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_ESCAPE)
    {
      stopMainLoop = 1;
    }//if escape pressed

    if( event.type == SDL_MOUSEBUTTONUP   ){ mouseIsDown = 0; }
    if( event.type == SDL_MOUSEBUTTONDOWN ){ mouseIsDown = 1; }

    if( event.type == SDL_MOUSEMOTION )
    {
      mouseX = event.motion.x;
      mouseY = event.motion.y;

      //snap mouse to grid if not per-pixel mode
      if( chunkSize > 1 )
      {
        mouseX = (int) mouseX/chunkSize;
        mouseX *= chunkSize;
        mouseY = (int) mouseY/chunkSize;
        mouseY *= chunkSize;
      }//if not trying high precision
    }//mouse motion

  }//while pollevent
}//checkEvents

                
void resetPixels()
{
  int x,y =0;
  for( x=0; x<=WIDTH; x+=chunkSize )
  {
    for( y=0; y<=HEIGHT; y+=chunkSize )
    {
      pixels[x][y]= 1;
    }//y
  }//x
}//resetPixels

                
void circleSetPixels(float startx, float starty, float inFrame)
{
  float frameInc = (inFrame-1) / PORTAL_DIA;
  float i=0;
  float currFrame=1;

  for( i=(PORTAL_DIA*2); i>=PORTAL_DIA; i-- )
  {
    int xshift = (PORTAL_DIA-i) * 2;
    int yshift = PORTAL_DIA-i;

    topCircle(    startx+xshift, starty+yshift, i, currFrame );
    bottomCircle( startx+xshift, starty+yshift, i, currFrame );
    currFrame += frameInc;
  }//for i
}//circleSetPixels

                
void bottomCircle(float startx, float starty, int r, float inFrame)
{
  int i = 1;
  float nexty = starty +(r*2);
  for( i=r; i>=1; i-- )
  {
    int length = (int) (sqrt( cos(0.5f * 3.14159 * (i-r)/r)) * r * 2);
    int ofs = (r*2) - (length/2);
    lineSet(startx+ofs, nexty-i, length, chunkSize, inFrame );
  }//i
}//bottomCircle

void topCircle(float startx, float starty, int r, float inFrame)
{
  int i = 1;
  for( i=1; i<=r; i++ )
  {
    int length = (int) (sqrt( cos(0.5f * 3.14159 * (i-r)/r)) * r * 2);
    int ofs = (r*2) - (length/2);
    lineSet(startx+ofs, starty+i, length, chunkSize, inFrame );
  }//i
}//topCircle

                
void lineSet(int inX, int inY, int inWidth, int inHeight, int frameNum )
{
  if( chunkSize > 1 )
  {
    inX = (int) inX/chunkSize;
    inX *= chunkSize;
    inY = (int) inY/chunkSize;
    inY *= chunkSize;
  }//snap to grid if not in per-pixel mode

  int x=0;
  for( x=inX; x<=(inX+inWidth); x+= chunkSize )
  {
    int y=0;
    for( y=inY; y<=(inY+inHeight); y+=chunkSize )
    {
      if( x < WIDTH && y < HEIGHT )
      {
        if( frameNum > pixels[x][y] ){ pixels[x][y] = frameNum; }
      }//if on screen

    }//for y
  }//for x
}//lineSet

                
void drawPixels()
{
  int x,y = 0;
  for( x=0; x<=WIDTH; x+=chunkSize )
  {
    for( y=0; y<=HEIGHT; y+=chunkSize )
    {
      src.x=x;
      src.y=y;
      src.w = chunkSize;
      src.h = chunkSize;
      SDL_BlitSurface( frame[pixels[x][y]], &src, screen, &src);
    }//y
  }//x
}//drawPixels

                
void animateFrames()
{
  int x,y =0;
  for( x=0; x<=WIDTH; x+=chunkSize )
  {
    for( y=0; y<=HEIGHT; y+=chunkSize )
    {
      if( animateGrid[x][y] > 1 ){ animateGrid[x][y]--; }
    }//y
  }//x
}//animateFrames

                
int main(int argc, char *argv[])
{
  initScreen();
  loadImages();

  while ( stopMainLoop == 0 )
  {
    checkEvents();
    if( mouseIsDown ){ animateGrid[mouseX][mouseY] = MAX_IMAGES-1; }
    resetPixels();

    int x,y = 0;
    for( x=0; x<=WIDTH; x+=chunkSize )
    {
      for( y=0; y<=HEIGHT; y+=chunkSize )
      {
        if( animateGrid[x][y] > 1 ){ circleSetPixels(x,y, animateGrid[x][y] ); }
      }//y
    }//x

    SDL_BlitSurface(immutableImage, NULL, screen, &baseRect);
    drawPixels();
    SDL_Flip(screen);

    animateFrames();

  }// while stopMainLoop == 0

  SDL_Quit();
  return(0);
}//main

                
        mouseX = (int) mouseX / chunkSize;
        mouseX *= chunkSize;
        mouseY = (int) mouseY / chunkSize;
        mouseY *= chunkSize;