Atelier Cod'Art

#include <iostream>
#include <cmath>
#include <SDL/SDL.h>

#include "tool.h"




#define PASS   256.0
#define REPEAT 3.f
#define SIZEX  512
#define SIZEY  512

//-----------------------------------------------------------------------------

// Procudral 3D mesh \o/

//-----------------------------------------------------------------------------
float obj( float x, float y,float z )
{
    x *= REPEAT;
    y *= REPEAT;
    z *= REPEAT;
	return fabs( cos(x)*cos(y)*cos(z)+sin(x)*sin(y)*sin(z) );
}

//-----------------------------------------------------------------------------

//  Main

//-----------------------------------------------------------------------------
int main(int argc, char *argv[])
{
    //Init SDL
    SDL_Init(SDL_INIT_VIDEO);
    SDL_Surface *ecran = SDL_SetVideoMode(SIZEX, SIZEY, 32, SDL_HWSURFACE);



    //Start raycasting
    for(float x=0.f; x<1.f; x+= 1.f/SIZEX)
    for(float y=0.f; y<1.f; y+= 1.f/SIZEY)
    {
        Uint32 pixel;
        vec3 ray    = { x-0.3, y, 0.0 };        
        vec3 rayDir = { x*4-2.0, y*4-2.0, 1.0 };
        rayDir.x /= 128;
        rayDir.y /= 128;
        rayDir.z /= 128;
        vec3 color = { 1.0f, 0.5f, 0.3f };
        for(float i=0; i<PASS; i++ )
        {
            float intensity = obj(ray.x, ray.y, ray.z);
            if( intensity > 0.6 ) // Intensity > 0.6 = solid, else blank
            {
                //Compute normal
                vec3 n = { 0.f, 0.f, 0.f};
                n.x = obj(ray.x, ray.y, ray.z)-obj(ray.x-0.1, ray.y, ray.z);
                n.y = obj(ray.x, ray.y, ray.z)-obj(ray.x, ray.y-0.1, ray.z);
                n.z = obj(ray.x, ray.y, ray.z)-obj(ray.x, ray.y, ray.z-0.1);
                Normalize(n);

                //Light dir
                vec3 l = { 0.0,1.0,0.0};

                 //Diffuse light
                float lighting = fmax( dot(l,n), 0.0);

                //Final color
                color.x = fmin( lighting+(i/PASS*1.0), 1.0); // light + linear fog
                color.y = fmin( lighting+(i/PASS*0.5), 1.0); // light + linear fog
                color.z = fmin( lighting+(i/PASS*0.3), 1.0); // light + linear fog
                break;
            }

            //Init to next pass :)
            ray.x += rayDir.x;
            ray.y += rayDir.y;
            ray.z += rayDir.z;
        }

        //SDL Pixel stuff
        pixel=SDL_MapRGBA(ecran->format, (int)(color.x*255), (int)(color.y*255), (int)(color.z*255), 255);
        SetPixel(ecran,(int)(x*SIZEX),(int)(y*SIZEY),pixel);
    }

    //Display & sleep
    SDL_Flip(ecran);
    Sleep();


    SDL_SaveBMP(ecran, "render.bmp");

    SDL_Quit();
    return 0;
}

//-----------------------------------------------------------------------------

// vec3 struct

//-----------------------------------------------------------------------------
typedef struct
{
    float x,y,z;
}vec3;

//-----------------------------------------------------------------------------

// Length

//-----------------------------------------------------------------------------

float Length( float x, float y, float z )

{

    return sqrt( x*x + y*y + z*z);

}

//-----------------------------------------------------------------------------

// Normalize

//-----------------------------------------------------------------------------

void Normalize( vec3 &vec )

{

    vec.x /= Length( vec.x, vec.y, vec.z );

    vec.y /= Length( vec.x, vec.y, vec.z );

    vec.z /= Length( vec.x, vec.y, vec.z );

}



//-----------------------------------------------------------------------------

// dot product

//-----------------------------------------------------------------------------

float dot( vec3 &a, vec3 &b )

{

    return (a.x * b.x) + (a.y * b.y) + (a.z * b.z);

}



//-----------------------------------------------------------------------------

// SetPixel

//-----------------------------------------------------------------------------
void SetPixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
{
    int nbOctetsParPixel = surface->format->BytesPerPixel;
    Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * nbOctetsParPixel;
    switch(nbOctetsParPixel)
    {
        case 1:
            *p = pixel;
            break;

        case 2:
            *(Uint16 *)p = pixel;
            break;

        case 3:
            if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
            {
                p[0] = (pixel >> 16) & 0xff;
                p[1] = (pixel >> 8) & 0xff;
                p[2] = pixel & 0xff;
            }
            else
            {
                p[0] = pixel & 0xff;
                p[1] = (pixel >> 8) & 0xff;
                p[2] = (pixel >> 16) & 0xff;
            }
            break;

        case 4:
            *(Uint32 *)p = pixel;
            break;
    }
}

//-----------------------------------------------------------------------------

// Sleep

//-----------------------------------------------------------------------------
void Sleep()
{
    int continuer = 1;
    SDL_Event event;
 
    while (continuer)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT:
                continuer = 0;
        }
    }
}