Keskustelu: Koodit: C: Phongipallojen paluu

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

/* PI / 180, eli muuntokerroin asteista radiaaneiksi */
#define RADIKS 0.01745329251994329577
/* ikkunan kokomäärityksiä */
#define WID 400
#define HEI 300
/* P niinku pufferi */
#define PWID (2 * WID)
#define PHEI (2 * HEI)
#define KESKIX (WID / 2)
#define KESKIY (HEI / 2)
/* palleroiden määrä */
#define YHT 6
/* minkä tyyppiseksi määritellään esilaskettu taulukko (puf)
 * koklaa floatilla ja intillä, huomaa nopeusero ja miten
 * float näyttää paljon pehmeämmältä */
#define TYYPPI float

typedef struct {
    int x, y;
} pallero;

void piirtele(SDL_Surface *screeni);
void alustaPuf();

pallero pallerot[YHT] = {{0, HEI / 2}, {120, HEI / 2}, {220, HEI / 2}};
TYYPPI puf[PHEI][PWID];

int main(int argc, char **argv) {
    SDL_Surface *screeni;
    SDL_Color colorit[256];
    SDL_Event eventti;
    int i, pomppu, rot, rotx[360], roty[360];
    Uint32 aika, framet;

    if (SDL_Init(SDL_INIT_VIDEO) < 0) {
        fprintf(stderr, "SDL ei initoitunut: %s\n", SDL_GetError());
        return 0;
    }
    /* 8-bittiset värit ja paletti */
    screeni = SDL_SetVideoMode(WID, HEI, 8, SDL_HWSURFACE | SDL_DOUBLEBUF |
            SDL_HWPALETTE);
    if (!screeni) {
        fprintf(stderr, "Videomoodin asetus epäonnas: %s\n", SDL_GetError());
        SDL_Quit();
        return 0;
    }
    SDL_WM_SetCaption("Phongipallerovempele", NULL);
    /* määritellään paletin värit ja asetetaan se */
    for (i = 0; i < 256; i++) {
        colorit[i].r = i;
        colorit[i].g = i;
        colorit[i].b = i;
    }
    SDL_SetColors(screeni, colorit, 0, 256);
    /* esilasketaan soikiota pyörivän palleron sijainnit */
    for (i = 0; i < 360; i++) {
        rotx[i] = KESKIX + 50 + 140 * sin(i * RADIKS);
        roty[i] = KESKIY + 80 * sin((i + 50) * RADIKS);
    }
    alustaPuf();

    /* näistä lasketaan lopussa koko homman framemäärä ja aika */
    framet = 0;
    aika = SDL_GetTicks();
    /* pomppivaa palloa varten*/
    pallerot[3].x = 30;
    pallerot[3].y = 60;
    pomppu = 0;
    while (1) {
        SDL_PollEvent(&eventti);
        if (eventti.type == SDL_QUIT ||
            (eventti.type == SDL_KEYDOWN &&
            eventti.key.keysym.sym == SDLK_ESCAPE)
           ) break;
        /* pikselien suoraa käsittelyä varten */
        if (SDL_MUSTLOCK(screeni)) {
            if (SDL_LockSurface(screeni) < 0) {
                fprintf(stderr, "Screeni ei lukkiutunut: %s\n",
                        SDL_GetError());
                return 0;
            }
        }

        /* pomppiva pallo */
        if (pallerot[3].y + pomppu > HEI) pomppu = -pomppu + 1;
        pallerot[3].y += pomppu;
        pomppu += 1;

        /* ellipsiä kiertävä pallo */
        rot = framet % 360;
        pallerot[4].x = rotx[rot];
        pallerot[4].y = roty[rot];

        /* hiiren mukaan liikkuva pallero */
        pallerot[5].x = eventti.motion.x;
        pallerot[5].y = eventti.motion.y;
        /* kai se o ikkunan sisällä? */
        if (pallerot[5].x < 0) pallerot[5].x = 0;
        if (pallerot[5].x >= WID) pallerot[5].x = WID - 1;
        if (pallerot[5].y < 0) pallerot[5].y = 0;
        if (pallerot[5].y >= HEI) pallerot[5].y = HEI - 1;

        piirtele(screeni);
        if (SDL_MUSTLOCK(screeni)) SDL_UnlockSurface(screeni);
        SDL_Flip(screeni);
        framet++;
    }
    aika = SDL_GetTicks() - aika;
    SDL_Quit();
    printf("Aika: %.3f sek, framet: %d kpl, fps: %.3f\n", aika / 1000.,
           framet, 1000. * framet / aika);
    return 0;
}

/* päivittää näytön kuvan */
void piirtele(SDL_Surface *screeni) {
    int i, x, y;
    Uint8 *p;
    TYYPPI valo;

    /* osoitin näyttöpinnan pikseleihin */
    p = (Uint8 *)screeni->pixels;
    /* tää oli aluksi helpommin tajuttavassa muodossa mutta optimoin pari
    * turhaa pluslaskua pois ni nopeutu fps:n tai kaks :o
    * tää voisi olla myös tyyliin: ylooppi alkaa nollasta ja loppuu HEI:hin
    * (näytön korkeus), eli piirretään siis jokainen näytöllä näkyvä pikseli.
    * puf on kaksi kertaa leveämpi kuin näyttö, ja siinä oleva "pallo"
    * on sen keskellä (eli koordinaateissa (WID, HEI)), jolloin nykyistä
    * palloa vastaava y-koordinaatti pufissa on HEI + y - palloy.
    *
    * selventävä esimerkki: jos pallo on vaikka 100 px päässä näytön
    * yläreunasta, niin kun y on 100 (eli ollaan kirkkaimassa kohdassa),
    * niin pufistakin pitäisi saada kirkkain kohta, eli keskikohta.
    * kun y = 100, niin saadaan HEI + y - palloy, jolloin y ja palloy ovat
    * samat, niin jää vain HEI, eli pufin keskikohta.
    *
     * Tai sitte siis ehkä pikkuse parempi selitys:
    * ensin siirrytään pufin keskelle (eli (WID, HEI)), ja sitten koska
    * x- ja y-koordinaatit ovat etäisyys _näytön vasemmasta yläkulmasta_,
    * siirrytään myös pufferissa oikealle alas eli _plussataan_ x ja y,
    * ja sitten lopuksi samaan tyyliin toisteppäi miinustetaan pallon
    * x- ja y-koordinaatit.
    * Katso myös selitteessä oleva linkki kuvaan. */
    for (y = HEI; y < PHEI; y++) {
        for (x = WID; x < PWID; x++) {
            valo = 0;
            /* lasketaan vaa simppelisti yhteen oikeat kohdat esilasketusta
            * pufferista */
            for (i = 0; i < YHT; i++)
                valo += puf[y - pallerot[i].y][x - pallerot[i].x];
            if (valo > 255) valo = 255;
            /* pikselit ovat semmosessa järjestyksessä muistissa, että kun
            * y-looppi on ensin ja x sen sisällä, käydään pikselit itestään
            * läpi semmoisessa järjestyksessä, että voidaan vaan kasvattaa
            * osoitinta (siirtää se osoittaamaan seuraavaan tavuun muistissa)
            * samalla asetetaan sen nyt osoittaman muistin arvo valomääräksi */
            *p++ = valo;
        }
    }
}

/* esilaskee phongpufferin */
void alustaPuf() {
    /* e niinku etäisyys */
    double ex, ey, ez, ez2, e, valo, ee;
    int x, y;

    ez = 25;
    ez2 = ez * ez;
    for (y = 0; y < PHEI; y++) {
        for (x = 0; x < PWID; x++) {
            /* täytetään pufferin joka pikseli oikealla väriarvolla
            * kaavan toiminnan voi katsoa siitä pekin vinkistä */
            ex = x - WID;
            ey = y - HEI;
            e = sqrt(ex * ex + ey * ey + ez2);
            ee = ez / e;
            valo = ee * 127 + ee * ee * 128;
            puf[y][x] = valo;
        }
    }
}