Raytrace_2.cpp

// include Simple Direct-media Layer
#include <SDL/SDL.h>
#pragma comment( lib, "SDL.lib" )

#include <math.h>

// setup some basic data types
typedef   signed long long s64;
typedef unsigned long long u64;
typedef unsigned int       u32;
typedef   signed int       s32;
typedef   signed short     s16;
typedef unsigned char      byte;
typedef   signed long long fp64;

// ---- ----- ---- ---- ---- ---- ---- ---- FRAMEWORK SPECIFICS
namespace framework
{
    // the title name for this application
    const char *app_name    = "Raytrace Demo";

    // size of the video buffer
    const int vidSize       = 512;

    // pixel size
    const int vidScale      = 1;

    // video buffer
    u32 *video              = NULL;

    // number of pixels in the video buffer
    const int nPixels       = vidSize * vidSize;

    // calculated real SDL video buffer size
    const int scrRes        = vidSize * vidScale;

    // the real SDL video buffer
    SDL_Surface *screen     = NULL;

    // rate onTick is called in FPS
    const int tickFPS       = 45;

    // mouse position
    int mousex              = 0;
    int mousey              = 0;

}; // namespace framework
using namespace framework;

// ---- ----- ---- ---- ---- ---- ---- ---- MATH HELPER FUNCTIONS
namespace mathHelper
{
    static u32 randSeed = 0xBABEFACE;

    static s64 absi( s64 a )
    {
        if ( a < 0 ) return -a;
        else         return  a;
    }

    static s64 maxi( s64 a, s64 b )
    {
        if ( a > b ) return a;
        else         return b;
    }

    static s64 mini( s64 a, s64 b )
    {
        if ( a < b ) return a;
        else         return b;
    }

    inline u32 randi( void )
    {
        randSeed *= 1103515245;
        randSeed += 12345;
        return (randSeed >> 15) & 0xFFFF;
    }

    inline u32 scale( u32 a, byte scale )
    {
        return (a * scale) >> 8;
    }

}; // namespace mathHelper
using namespace mathHelper;

// ---- ----- ---- ---- ---- ---- ---- ---- FIXED POINT HELPER FUNCTIONS
namespace fixedPointHelper
{
    const fp64 fp_1 = 0x10000;

    fp64 fp_mul( fp64 a, fp64 b )
    {
        return (a * b) >> 16;
    }

    fp64 fp_div( fp64 a, fp64 b )
    {
        return (a << 16) / b;
    }

    fp64 fp_ceil( fp64 a )
    {
        return (a | 0xFFFF) + 1;
    }

    fp64 fp_floor( fp64 a )
    {
        return a & (~0xFFFF);
    }

    fp64 fp_fract( fp64 a )
    {
        return a & 0xFFFF;
    }

    fp64 fp_ifract( fp64 a )
    {
        return 0xFFFF - (a & 0xFFFF);
    }

    int fp_to_int( fp64 a )
    {
        return (int) (a >> 16);
    }

    fp64 int_to_fp( int a )
    {
        return (a << 16);
    }

    fp64 fp_rand( int max )
    {
        return ((randi() % max) << 16) | (randi() & 0xFFFF);
    }

}; // namespace fixedPointHelper
using namespace fixedPointHelper;

// ---- ----- ---- ---- ---- ---- ---- ---- DRAWING HELPER FUNCTIONS
namespace videoHelper
{
    static u32 drawColour = 0xFFFFFF;

    inline void plot( int x, int y )
    {
        bool out  = x < 0;
             out |= y < 0;
             out |= x >= vidSize;
             out |= y >= vidSize;
        if ( out ) return;
        video[ x + y * vidSize ] = drawColour;
    }

    inline u32 readPixel( int x, int y )
    {
        bool out  = x < 0;
             out |= y < 0;
             out |= x >= vidSize;
             out |= y >= vidSize;
        if ( out ) return 0;
        return video[ x + y * vidSize ];
    }

    void circle( s32 x0, s32 y0, s32 radius )
    {
        s32 error  =  1 - radius;
        s32 errorY =  1;
        s32 errorX = -2 * radius;

        s32 x = radius, y = 0;

        plot(x0, y0 + radius);
        plot(x0, y0 - radius);
        plot(x0 + radius, y0);
        plot(x0 - radius, y0);

        while(y < x)
        {
            if (error > 0)
                { x--; errorX += 2; error += errorX; }
                { y++; errorY += 2; error += errorY; }

            plot(x0 + x, y0 + y);
            plot(x0 - x, y0 + y);
            plot(x0 + x, y0 - y);
            plot(x0 - x, y0 - y);
            plot(x0 + y, y0 + x);
            plot(x0 - y, y0 + x);
            plot(x0 + y, y0 - x);
            plot(x0 - y, y0 - x);
        }
    }

    void line( s32 X0, s32 Y0, s32 X1, s32 Y1 )
    {
        s32  incrementVal = 0;
        s32  shortLen     = Y1 - Y0;
        s32  longLen      = X1 - X0;
        bool yLonger      = false;
        s32  decInc       = 0;
        s32  endVal       = 0;
        s32  j            = 0;

        if ( absi( shortLen ) > absi( longLen ) )
        {
            int swap = shortLen;
            shortLen = longLen;
            longLen  = swap;
            yLonger  = true;
        }

        endVal = longLen;

        if ( longLen < 0 )
        {
            incrementVal = -1;
            longLen      = -longLen;
        }
        else
            incrementVal = 1;

        if ( longLen == 0 )
            decInc = 0;
        else
            decInc = (shortLen << 16) / longLen;

        if ( yLonger )
        {
            for ( s32 i=0; i!=endVal; i+=incrementVal )
            {
                plot( X0 + (j >> 16), Y0 + i );
                j += decInc;
            }
        }
        else
        {
            for ( s32 i=0; i!=endVal; i+=incrementVal )
            {
                plot( X0 + i, Y0 + (j >> 16) );
                j += decInc;
            }
        }
    }

    u32 randColour( void )
    {
        return ((randi()&0xFF) << 16 ) | ((randi()&0xFF) << 8 ) | ((randi()&0xFF) );
    }

}; // namesapce videoHelper
using namespace videoHelper;

// ---- ----- ---- ---- ---- ---- ---- ---- DEMO CODE ( the good stuff )
namespace demo
{
    struct vec3
    {
        float x, y, z;

        vec3( )
            : x( 0 ), y( 0 ), z( 0 )
        {
        }

        vec3( float _tx, float _ty, float _tz )
            : x( _tx ), y( _ty ), z( _tz )
        {
        }

        void normalize( void )
        {
            float d = 1.0f / sqrtf( x*x + y*y + z*z );
            x *= d;
            y *= d;
            z *= d;
        }

        vec3 operator - ( const vec3 &a )
        {
            return vec3( x - a.x, y - a.y, z - a.z );
        }

        vec3 operator + ( const vec3 &a )
        {
            return vec3( x + a.x, y + a.y, z + a.z );
        }

        float operator * ( const vec3 &a )
        {
            return x*a.x + y*a.y + z*a.z;
        }

        vec3 operator * ( const float s )
        {
            return vec3( x*s, y*s, z*s );
        }

        float lengthSqr( void )
        {
            return x*x + y*y + z*z;
        }

    };

    struct sSphere
    {
        sSphere( )
            : origin( 0, 0, 0 ), radius( 0 )
        {
        }

        sSphere( float x, float y, float z, float r )
            : origin( x, y, z ), radius( r )
        {
        }

        sSphere( float x, float y, float z, float r, u32 c )
            : origin( x, y, z ), radius( r ), colour( c )
        {
        }

        vec3   origin;
        float radius;
        u32    colour;
    };

    struct sPlane
    {
        vec3  normal;
        float offset;
    };

    struct sRay
    {
        vec3 origin;
        vec3 normal;
    };

    bool intersect( sRay &ray, sSphere &sphere, vec3 &ipoint )
    {
        vec3  EO    = sphere.origin - ray.origin;
        float v     = EO * ray.normal;
        float disc  = sphere.radius * sphere.radius;
              disc -= (EO*EO) - (v*v);

        if ( disc < 0.0 )
            return false;

        float d = sqrtf( disc );
        ipoint = ray.origin + ray.normal * (v-d);

        return true;
    }

    bool intersect( sRay &ray, sPlane &plane, vec3 &ipoint )
    {
        float t = - ( ray.origin * plane.normal + plane.offset ) / ( ray.normal * plane.normal );
        ipoint = ray.origin + ray.normal * t;
        return (t > 0);
    }

    const int nSpheres = 3;

    sSphere spheres[ nSpheres ] =
    {
        sSphere(    0,  32, 315, 96, randColour( ) ),
        sSphere( -128, -32, 512, 48, randColour( ) ),
        sSphere(    0, -64, 256, 64, randColour( ) )
    };

    sPlane floor = { vec3( 0,-1, 0), 96.0f };

    void onInit( void )
    {
    /*
        for ( int i=0; i<nSpheres; i++ )
        {
            sSphere &s = spheres[i];

            s.origin.x = (float) ( randi() % 256) - 128;
            s.origin.y = (float) ( randi() % 256) - 128;
            s.origin.z = (float) ( randi() % 256) + 128;
            s.radius   = (float) ( randi() % 5) + 8;
            s.colour   = randColour( );
        }
    */
    }

    void onKeyHit( SDLKey key )
    {
        switch ( key )
        {
        case ( SDLK_SPACE ):
            onInit( );
        }
    }

    u32 rayShoot( sRay &ray )
    {
        //
        float min = -1.0f;
        u32 colour = 0;
        //
        vec3 ipoint( 0, 0, 0 );
        //
        for ( int i=0; i<nSpheres; i++ )
        {
            if ( intersect( ray, spheres[i], ipoint ) )
            {
                float dst = ipoint.lengthSqr( );

                if ( dst < min || min < 0.0f )
                {
                    min = dst;
                    vec3 normal = (ipoint - spheres[i].origin);

                    float irad = 1.0f / spheres[i].radius;
                    normal.x *= irad;
                    normal.y *= irad;
                    normal.z *= irad;

                    int r = (int)(127.0 + 127.0 * normal.x);
                    int g = (int)(127.0 + 127.0 * normal.y);
                    int b = (int)(127.0 - 127.0 * normal.z);

//                  colour = spheres[i].colour;
                    colour = (r<<16) | (g<<8) | b;
                }
            }
        }

        if ( intersect( ray, floor, ipoint ) )
        {
            float dst = ipoint.lengthSqr( );
            if ( dst < min || min < 0.0f )
            {
                colour = 0x102040;
            }
        }

        return colour;
    }

    void incWrap( float &x, float y )
    {
        const float _2PI = 6.28318530718f;
        if ( (x+=y) > _2PI ) x -= _2PI;
    }

    float t = 0.0;

    void onTick( void )
    {
        float hvs = vidSize / 2.0;

        for ( int y=0; y<vidSize; y++ )
        {
            for ( int x=0; x<vidSize; x++ )
            {
                sRay ray = { vec3( ), vec3( x-hvs, y-hvs, hvs*2 ) };
                ray.normal.normalize( );
                drawColour = rayShoot( ray );
                plot( x, y );
            }
        }

        incWrap( t, 0.01f );

        spheres[0].origin.x = sin( (float)t ) * 256.0f;

    }

}; // namespace demo
using namespace demo;

// ---- ----- ---- ---- ---- ---- ---- ---- FRAMEWORK FUNCIONS
namespace framework
{
    static bool app_init( void )
    {
        if ( SDL_Init( SDL_INIT_VIDEO ) != 0 )
            return false;

        SDL_WM_SetCaption( app_name, NULL );

        screen = SDL_SetVideoMode( scrRes, scrRes, 32, 0 );
        if ( screen == NULL )
            return false;

        if ( vidScale == 1 )    video = (u32*)screen->pixels;
        else                    video = new u32[ nPixels ];

        return true;
    }

    static void blit_2x( void )
    {
        //
        const int stride = screen->w;

        u32 *dst = (u32*) screen->pixels;

        int a = 0;

        for ( int i=0; i<nPixels; i++ )
        {
            u32 colour = video[ i ];

            // x4 pixel write
            dst[0       ] = colour;
            dst[1       ] = colour;
            dst[  stride] = colour;
            dst[1+stride] = colour;

            dst += 2;
            if ( a++ >= vidSize )
            {
                a = 0;
                // add on ONE stride not two since one length
                // has already been walked
                dst += stride;
            }
        }
    }

    static void app_draw( void )
    {
        if ( vidScale <= 1 )
            return;

        if ( vidScale == 2 )
        {
            blit_2x( );
            return;
        }

        for ( int i=0; i<nPixels; i++ )
        {
            SDL_Rect rect =
            {
                (i % vidSize) * vidScale,
                (i / vidSize) * vidScale,
                                vidScale,
                                vidScale
            };
            SDL_FillRect( screen, &rect, video[ i ] );
        }
    }

    static bool app_tick( void )
    {
        static bool active = true;

        SDL_Event event;
        while ( SDL_PollEvent( &event ) )
        {
            switch ( event.type )
            {
            case ( SDL_QUIT ):
                active = false;
                break;
            case ( SDL_KEYUP ):
                {
                    if ( event.key.keysym.sym == SDLK_ESCAPE )
                        active = false;
                    else
                        onKeyHit( event.key.keysym.sym );
                }
                break;
            }
        }
        return active;
    }

    static void app_quit( void )
    {
        //
        if ( video != NULL )
            if ( video != screen->pixels )
                delete [] video;
        video = NULL;
        //
        if ( screen != NULL )
            SDL_FreeSurface( screen );
        //
        SDL_Quit( );
    }

}; // namespace framework

// windows entry point
int __stdcall WinMain( int, int, int, int )
{
    // start up SDL
    atexit( app_quit );
    if (! app_init( ) )
        return 1;
    // get keyboard access
    u32 keyCount = 0;
    byte *keys = SDL_GetKeyState( (int*) &keyCount );
    // seed the random
    randSeed ^= SDL_GetTicks( );
    // call the on initialize function
    onInit( );
    //
    int oldTicks = SDL_GetTicks( );
    // work out the tick threshold in milliseconds
    const int tickThresh = 1000 / tickFPS;
    //
    while ( app_tick( ) )
    {
        int diff = SDL_GetTicks() - oldTicks;

        if ( diff < 10  )
            SDL_Delay( 10 );

        if ( diff > 500 )
        {
            oldTicks += diff;
            continue;
        }

        while ( diff > tickThresh )
        {
            // grab the mouse state
            SDL_GetMouseState( &mousex, &mousey );
            // tick the application
            onTick( );
            app_draw( );
            SDL_Flip( screen );
            // progress the tick count
            oldTicks += tickThresh;
            diff     -= tickThresh;
        }
    }
    return 0;
}