SDL - Przekształcenia na płaszczyźnie

// Przekształcenia na płaszczyźnie
// (C)2012 Koło Informatyczne
// I LO w Tarnowie
//-------------------------------

#include "newgfx.h"
#include <cmath>
#include <ctime>

// Funkcja tworzy macierz jednostkową

void Identity(double x[][3])
{
    int i,j;

    for(i = 0; i < 3; i++)
      for(j = 0; j < 3; j++)
        x[i][j] = (i == j) ? 1 : 0;
}

// A = A x B

void Multiply(double a[][3], double b[][3])
{
    double c[3][3];
    int i,j;

    for(i = 0; i < 3; i++)
      for(j = 0; j < 3; j++)
        c[i][j] = a[i][0]*b[0][j] + a[i][1]*b[1][j] + a[i][2]*b[2][j];

    for(i = 0; i < 3; i++)
      for(j = 0; j < 3; j++) a[i][j] = c[i][j];
}

// Dodaje do przekształcenia translację
// g[][] - macierz przekształcenia
// Tx - przesunięcie w osi x
// Ty - przesunięcie w osi y

void Translation(double g[][3], double Tx, double Ty)
{
    double t[3][3];

    Identity(t);   // tworzymy w t macierz jednostkową
    t[2][0] = Tx;  // dodajemy przesunięcie
    t[2][1] = Ty;
    Multiply(g,t); // dodajemy translację do przekształcenia
}

// Dodaje do przekształcenia rotację
// g[][] - macierz przekształcenia
// alfa - kąt w radianach

void Rotation(double g[][3], double alfa)
{
    double r[3][3],sa;

    sa = sin(alfa);
    Identity(r);   // tworzymy w r macierz jednostkową
    r[0][0] = r[1][1] = cos(alfa);
    r[0][1] = sa;
    r[1][0] = -sa;
    Multiply(g,r); // dodajemy rotację do przekształcenia
}

// Skalowanie
// g[][] - macierz przekształcenia
// Sxy - współczynnik skali na obu osiach

void Scaling(double g[][3], double Sxy)
{
    double s[3][3];

    Identity(s);   // tworzymy w s macierz jednostkową
    s[0][0] = s[1][1] = Sxy;
    Multiply(g,s); // dołączamy skalowanie do przekształcenia
}

// Oblicza współrzędne punktów po przekształceniu
// g[][] - macierz przekształcenia
// f - łamana źródłowa
// d - łamana docelowa

void Transformation(double g[][3],Sint32 * f, Sint32 * d)
{
    Sint32 licznik,i;
    double x,y;

    do
    {
        licznik = * d++ = * f++;  // odczytujemy liczbę punktów

        for(i = 0; i < licznik; i++)
        {
            x = * f++;    // odczytujemy współrzędne punktu
            y = * f++;

            // obliczamy współrzędne przekształcone i umieszczamy je
            // w łamanej docelowej na miejscu x i y

            * d++ = round(g[0][0]*x + g[1][0]*y + g[2][0]); // x'
            * d++ = round(g[0][1]*x + g[1][1]*y + g[2][1]); // y'
        }
    } while(licznik);
}

int main(int argc, char *argv[])
{
    int waiting = 1;
    int x,y,dx,dy,dr,dg,db;
    double alpha,da,scale,ds,G[3][3];
    Uint32 r,g,b;

    Sint32 f[] = {5,-60,-60, 60,-60, 60, 60,-60, 60,-60,-60,
                  4,  0,-40, 40, 40,-40, 40,  0,-40,
                  4,-40,-40,-20,-40,-40,  0,-40,-40,
                  4, 20,-40, 40,-40, 40,  0, 20,-40,
                  0};
    Sint32 d[100]; // figura docelowa - musi mieć co najmniej tyle samo elementów co f

    SDL_Surface * screen;
    SDL_Event event;

    const double DPI = 6.28318530717958;

    srand(time(NULL));   // inicjujemy generator pseudolosowy

    if(!SDL_Init(SDL_INIT_VIDEO))
    {
        atexit(SDL_Quit);

        screen = SDL_SetVideoMode(1024, 768, 32, SDL_HWSURFACE | SDL_FULLSCREEN);

        x = y = 1;
        dx = (1 + rand() % 3) * (1 - 2 * (rand() % 2));
        dy = (1 + rand() % 3) * (1 - 2 * (rand() % 2));
        alpha = 0;
        da = 0.03;   // zmiana kata przy każdym kadrze animacji
        scale = 1;
        ds = 0.01;   // zmiana skali
        r = 0; g = 0; b = 0;
        dr = 2; dg = 3; db = 5;

        do
        {
            SDL_Delay(16);

            Identity(G);           // tworzymy macierz przekształcenia
            Scaling(G,scale);      // dodajemy skalowanie
            Rotation(G,alpha);     // dodajemy obrót
            Translation(G,x,y);    // dodajemy przesunięcie

            Transformation(G,f,d); // wyznaczamy łamaną po transformacji

            if(SDL_MUSTLOCK(screen)) SDL_LockSurface(screen);

            gfxFillPoly(screen,d,(r << 16) | (g << 8) | b);

            if(SDL_MUSTLOCK(screen)) SDL_UnlockSurface(screen);

            SDL_UpdateRect(screen, 0, 0, 0, 0);

            if(SDL_MUSTLOCK(screen)) SDL_LockSurface(screen);

            gfxFillPoly(screen,d,0); // wymazujemy figurę z ekranu

            if(SDL_MUSTLOCK(screen)) SDL_UnlockSurface(screen);

            // modyfikujemy parametry ruchu dla następnego kadru

            x += dx;
            y += dy;
            if((x <= 0) || (x > screen->w)) dx = -dx;
            if((y <= 0) || (y > screen->h)) dy = -dy;

            alpha += da;
            if(alpha >= DPI) alpha = 0;

            scale *= 1 + ds;
            if((scale < 0.3) || (scale > 6)) ds = -ds;

            if(r + dr > 255) dr = -dr;
            if(g + dg > 255) dg = -dg;
            if(b + db > 255) db = -db;

            r += dr;
            g += dg;
            b += db;

            // sprawdzamy, czy nie naciśnięto ESC - jeśli tak, kończymy.

            if (SDL_PollEvent(&event))
                if ((event.type == SDL_QUIT) ||
                   ((event.type == SDL_KEYDOWN) &&
                    (event.key.keysym.sym == SDLK_ESCAPE))) waiting = 0;
        } while(waiting);
    }

    return 0;
}