Koodit: C++: 2D Bumpmapperi (SDL)

#include "SDL.h"
#include <math.h>

enum {
  SCREENWIDTH = 640,
  SCREENHEIGHT = 480,
  SCREENBPP = 32,
  SCREENFLAGS = SDL_HWSURFACE | SDL_DOUBLEBUF
};

#define max(a, b)((a) > (b)) ? (a) : (b)

// valon sijainti
float lz, lx, ly;

// bumpmappi
int bumpmap[SCREENWIDTH][SCREENHEIGHT];
int tex[SCREENWIDTH][SCREENHEIGHT][3];

float pz[SCREENWIDTH][SCREENHEIGHT];
float px[SCREENWIDTH][SCREENHEIGHT];
float py[SCREENWIDTH][SCREENHEIGHT];

// Palauttaa pikselin (x,y) arvon
Uint32 _fastcall getpixel(SDL_Surface *surface, int x, int y)
{
    int bpp = surface->format->BytesPerPixel;
    // p on osoitin pikseliin, jonka haluamme kopioida
    Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;

    switch(bpp) {
    case 1:
        return *p;

    case 2:
        return *(Uint16 *)p;

    case 3:
        if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
            return p[0] << 16 | p[1] << 8 | p[2];
        else
            return p[0] | p[1] << 8 | p[2] << 16;

    case 4:
        return *(Uint32 *)p;

    default:
        return 0;       // ei pitäisi tapahtua.
    }
}

void DrawScene(SDL_Surface* surface, SDL_Event* event)
{
    // Lukitse pinta, jotta voimme käsitellä pikseleitä suoraan
    if ( SDL_MUSTLOCK(surface) ) {
        if ( SDL_LockSurface(surface) < 0 ) {
            fprintf(stderr, "Can't lock the screen: %s\n", SDL_GetError());
            return;
        }
    }
    lz = 30;
    // pointteri pikseleihin
    Uint8 *p = (Uint8 *)surface->pixels;

    // muuttujat etukäteen(hieman nopeampi näin)
    float Lx, Ly, Lz, f, clr;
    for(int y=1;y<SCREENHEIGHT-1;y++)
    {
        for(int x=1;x<SCREENWIDTH-1;x++)
        {
            // normaalidata talteen

            // valovektori
            Lx = lx-x;
            Ly = ly-y;
            Lz = lz;

            // SSE:tä käyttävä neliöjuuri
            f = Lx*Lx + Ly*Ly + Lz*Lz;
            __asm
            {
                movss xmm0, f
                rsqrtss xmm0, xmm0
                rcpss xmm0, xmm0
                movss f, xmm0
            }
            // Jos tietokoneesi ei tue SSE:tä, korvaa edelliset rivit tällä:
            //f = sqrtf(Lx*Lx + Ly*Ly + Lz*Lz);

            // normalisoidaan
            Lx /= f;
            Ly /= f;
            Lz /= f;

            // clr on normalisoidun valovektorin ja normaalivektorin pistekertoma, eli niiden välisen kulman kosini
            clr = Lx*px[x][y] + Ly*py[x][y] + Lz*pz[x][y];

            // phong kartoitus, eli  dot * diff + dot^2 * spec + ambient
            clr = max(clr*0.6+clr*clr*0.4, 0);

            // Blendaa yhteen phong ja taustakuva
            int clrr = (tex[x][y][0]*clr + clr*255) / 2;
            int clrg = (tex[x][y][1]*clr + clr*255) / 2;
            int clrb = (tex[x][y][2]*clr + clr*255) / 2;

            // Pikseli oikeaan kohtaan
            *(Uint32 *)(p + y * surface->pitch + x * 4) = (clrr << 16) | (clrg << 8) | clrb;
        }
    }
    // poistetaan lukitus
    if ( SDL_MUSTLOCK(surface) ) {
        SDL_UnlockSurface(surface);
    }
    //päivitä pinta
    SDL_Flip(surface);
}

int main(int argc, char* argv[])
{
    //alusta systeemit
    SDL_Init(SDL_INIT_VIDEO);
    //aseta exit
    atexit(SDL_Quit);
    //luo ikkuna
    SDL_Surface* pSurface = SDL_SetVideoMode ( SCREENWIDTH, SCREENHEIGHT, SCREENBPP, SCREENFLAGS );

    lz = ly = lz = 0;

    // ladataan kuvio
    SDL_Surface *bmpBump = SDL_LoadBMP("Bumpmap2.bmp");
    for (int x=0;x<SCREENWIDTH;x++)
        for (int y=0;y<SCREENHEIGHT;y++)
        {
            // punaväri
            bumpmap[x][y] = getpixel(bmpBump, x,y) >> 16;
        }
    // ei tavita enää
    SDL_FreeSurface(bmpBump);

    // Tekstuurin data talteen, jotta saadaan nopeampi linkki dataan
    SDL_Surface* texture = SDL_LoadBMP("tex.bmp");
    for (int x=0;x<SCREENWIDTH;x++)
        for (int y=0;y<SCREENHEIGHT;y++)
        {
            tex[x][y][0] = getpixel(texture, x,y) >> 16;
            tex[x][y][1] = (getpixel(texture, x,y) >> 8) & 0xff;
            tex[x][y][2] = getpixel(texture, x,y) & 0xff;
        }
    SDL_FreeSurface(texture);


    // precalcitaan kuvan normaalit
    float tx,ty;
    for (int x=-SCREENWIDTH/2;x<SCREENWIDTH/2;x++)
        for (int y=-SCREENHEIGHT/2;y<SCREENHEIGHT/2;y++)
        {
            tx=x/(SCREENWIDTH/2);
            ty=y/(SCREENHEIGHT/2);

            // lasketaan normaali
            float nx = bumpmap[x+SCREENWIDTH/2+1][y+SCREENHEIGHT/2] - bumpmap[x+SCREENWIDTH/2-1][y+SCREENHEIGHT/2];
            float ny = bumpmap[x+SCREENWIDTH/2][y+SCREENHEIGHT/2+1] - bumpmap[x+SCREENWIDTH/2][y+SCREENHEIGHT/2-1];
            float nz = max(1 - sqrtf(tx*tx + ty*ty), 0); // täytyy flipata z..

            // normalisoidaan
            float length = sqrtf(nx*nx + ny*ny + nz*nz);
            pz[x+SCREENWIDTH/2][y+SCREENHEIGHT/2] = nz / length;
            px[x+SCREENWIDTH/2][y+SCREENHEIGHT/2] = nx / length;
            py[x+SCREENWIDTH/2][y+SCREENHEIGHT/2] = ny / length;
        }

    // normi sdl-looppi
    SDL_Event event;
    for (;;)
    {
        if ( SDL_PollEvent ( &event ) )
        {
            if ( event.type == SDL_QUIT ) break;
            // liikutetaan valoa
            lx = event.motion.x;
            ly = event.motion.y;
        }
        DrawScene(pSurface, &event);
    }

    // vapautellaan
    SDL_FreeSurface(pSurface);

    return(0);
}