/* Kääntäminen: gcc -o metaballs metaballs.c -O3 -ggdb -lSDL -lm */

#include <stdlib.h>
#include <math.h>
#include <SDL/SDL.h>

#define RES_X 800
#define RES_Y 800

typedef struct metaball {
    int x, y;
} metaball;

typedef union {
    struct {unsigned char b, g, r;} rgb;
    Uint32 sdl;
} unioncolor;

#define pallot_count 5
metaball pallot[pallot_count] = {{0,0}};

unioncolor *pixelcoord(SDL_Surface *screen, int x, int y) {
	return (unioncolor *) ((Uint8 *)screen->pixels +  y * screen->pitch + (x << 2));
}

inline long calcfactor(int dx, int dy)
{
    /* Range is 0 - 2^24 */
    const long max = 0x1000000;
    long long div = dx * dx + dy * dy;
    
    if (div == 0)
        return max;
    
    return max / div;
}

inline long calctotal(int x, int y)
{
    int i, dx, dy;
    long total = 0;
    
    for (i=0; i<pallot_count; i++) {
        dx = pallot[i].x - x;
        dy = pallot[i].y - y;
        
        total += calcfactor(dx, dy);
    }
    
    return total;
}

void draw(SDL_Surface *screen)
{
    int x, y;
    int ix, iy;
    long topright, topleft, bottomright, bottomleft;
    long total;
    unioncolor *pixel;
    
    const int largestep = 50;
    const long treshold_min = 5000;
    const long treshold_max = treshold_min + treshold_min / 10;
    
    const long t_min = treshold_min - 100;
    const long t_max = treshold_max + 100;
    
    memset(screen->pixels, 255, 4 * RES_X * RES_Y);
    
    for (x=0; x<RES_X; x+=largestep) {
        bottomleft = calctotal(x, 0);
        bottomright = calctotal(x + largestep, 0);
        
        for (y=0; y<RES_Y; y+=largestep) {
            topright = bottomright;
            topleft = bottomleft;
            bottomright = calctotal(x + largestep, y + largestep);
            bottomleft = calctotal(x, y + largestep);
            
            /* Check for transition */
            if ((topright < t_min && topleft < t_min && bottomright < t_min && bottomleft < t_min) ||
                (topright > t_max && topleft > t_max && bottomright > t_max && bottomleft > t_max))
                continue;
            
            for (ix=x; ix<x+largestep; ix++) {
                for (iy=y; iy<y+largestep; iy++) {
                    total = calctotal(ix, iy);
                    
                    if (total > treshold_min && total < treshold_max) {
                        pixel = pixelcoord(screen, ix, iy);
                        pixel->sdl = 0;
                    }
                }
            }
        }
    }

    SDL_Flip(screen);
}

void reposition() {
	int cycle;
	int i;
	
	cycle = SDL_GetTicks() / 2;
	
	for (i=0; i<pallot_count; i++) {
		pallot[i].x = sin((float)cycle / (i * 1000 + 1000)) * RES_X / 2 + RES_X / 2;
		pallot[i].y = sin((float)cycle / (i * i * 600 + 1000)) * RES_Y / 2 + RES_Y / 2;
	}
}

int main(int argc, char *argv[]) 
{ 
    if( SDL_Init(SDL_INIT_VIDEO) < 0 )
    {
        printf("Unable to init SDL: %s\n", SDL_GetError());
        exit(1);
    }
    
    atexit(SDL_Quit);
    SDL_Surface *screen;
    screen = SDL_SetVideoMode(RES_X, RES_Y, 32, SDL_HWSURFACE|SDL_DOUBLEBUF);
    
    long ticks;
    
    while(1)
    {
        ticks = SDL_GetTicks() + 20; // Vakio 50 fps
        
        SDL_Event event;
        while( SDL_PollEvent(&event) )
        {
            if( event.type == SDL_QUIT || event.type == SDL_KEYDOWN )
                exit(0);
        }

        reposition();
        draw(screen);
    
        ticks -= SDL_GetTicks();
        if (ticks > 0)
            SDL_Delay(ticks);
    }
    return 0;
}