program kocka;
{$P+}
{$X+}
{$M 65520,0,655320}
uses graph;
var pocet_vrcholov, pocet_hran, pocet_stien : integer;
    data : text;
    i, j : integer;
    vrcholy : array [0..10,0..2] of real;
    hrany : array [0..20,0..1] of byte;
    steny : array [0..20,-1..10] of byte;
    vektory : array[0..20,0..2] of real;
    c : char;

{vrcholy su v subore zadane ako trojice cisel x,y,z pred tymto polom je
pocet vrcholov v objekte}

function nacitajVrcholy(var udaje : text):byte;
var i,j : byte;
    pv : byte;

begin
     readln(udaje,pv);
     for i := 0 to pv-1 do
     begin
          for j := 0 to 2 do
          begin
               read(udaje,vrcholy[i,j]);
          end;
     readln(udaje);
     end;
     nacitajVrcholy := pv;
end;

{hranu tvoria dva vrcholy, ktore su vyjadrene cez ich index v poli vrcholov}

function nacitajHrany(var udaje : text) : byte;
var i,j : byte;
    ph : byte;

begin
     readln(udaje,ph);
     for i := 0 to ph-1 do
     begin
          for j := 0 to 1 do
              read(udaje, hrany[i,j]);
          readln(udaje);
     end;
     nacitajHrany := ph;
end;

{kazda stena je  dana poctom vrcholov ktore ju tvoria
a cislami tychto vrcholov}

function nacitajSteny(var udaje : text) : byte;
var i,j : byte;
    ps : byte;

begin
     readln(udaje,ps);
     for i := 0 to ps-1 do
     begin
          read(udaje,steny[i,-1]);
          for j := 0 to steny[i,-1]-1 do
              read(udaje, steny[i,j]);
          readln(udaje);
     end;
     nacitajSteny := ps;
end;

{nacita normalove vektory stien}
procedure nacitajVektory(var udaje : text; pv : byte);

begin
     for i := 0 to pv do
     begin
          for j := 0 to 2 do
              read(udaje, vektory[i,j]);
         readln(udaje);
     end;
end;

procedure bod(x,y:integer;f:byte);
begin
     asm
        mov ah, $0C
        mov bh, 0
        mov dx, y
        mov cx, x
        mov al, f
        int $10
     end;
end;

function zistifarbubodu(x,y : integer) : byte;

var f : byte;
begin
     asm
        mov ah, $0D
        mov bh, 0
        mov dx, y
        mov cx, x
        int $10
        mov f, al;
     end;
     zistifarbubodu := f;
end;

procedure farbi(x,y : integer; farba, hranica : byte);

var pom :byte;
procedure ofarbi(x,y : integer);
begin
     pom :=  zistifarbubodu(x,y);
     if ((pom<>hranica) and (pom<>farba)) then
     begin
          bod(x,y,farba);
          ofarbi(x-1,y);
          ofarbi(x+1,y);
          ofarbi(x,y-1);
          ofarbi(x,y+1);
     end;
end;
begin
ofarbi(x,y);
end;

procedure usecka(x1,y1,x2,y2:integer;farba: byte);
var dy, dx, x, y, p : integer;
    vymena,zniz:boolean;
    pom,pp,ppp: integer;

begin
    vymena:=false;
    zniz:=false;

    if abs(y2-y1)>=abs(x2-x1) then
       begin pom:=x1; x1:=y1; y1:=pom;
             pom:=x2; x2:=y2; y2:=pom;
             vymena:=true;
       end;

    if x2<x1 then begin pom:=x1; x1:=x2; x2:=pom;
                        pom:=y1; y1:=y2; y2:=pom;
                  end;

    if y2<y1 then zniz:=true;
     dy:=abs(y2-y1);
     dx:=abs(x2-x1);
     x:=x1;
     y:=y1;
     p:=2*dy-dx;
     pp:=2*dy;
     ppp:=pp-2*dx;

     while x<=x2 do
        begin
         if vymena then bod(y,x,farba) else bod(x,y,farba);
         if p<=0 then p:=p+pp else begin p:=p+ppp;
                                        if zniz then dec(y) else inc(y);
                                  end;
         inc(x);
        end;

          end;

procedure nastav;
begin
     asm
        mov ah, 0
        mov al, $12
        int $10
     end;
end;

procedure zrus;
begin
     asm
     mov ah, 0
     mov al, 3
     int $10
     end;
end;

procedure nakresliUtvarHranami(ph : byte; farba : integer);
var i,j : byte;

begin
     for i := 0 to ph-1 do
     begin
         usecka(round(vrcholy[hrany[i,0],0]),round(vrcholy[hrany[i,0],1]),
          round(vrcholy[hrany[i,1],0]),round(vrcholy[hrany[i,1],1]),farba);
     end;
end;


{vykreslenie utvaru cez jeho steny, su vykreslene len vyditelne steny}
procedure nakresliUtvarStenami(ps : byte; farba : integer);
var i,j : byte;

begin
     for i := 0 to ps-1 do
     begin
          if (vektory[i,2] > 0) then
             for j := 0 to steny[i,-1]-1 do
                 usecka(
                    round(vrcholy[steny[i,j],0]),
                    round(vrcholy[steny[i,j],1]),
                    round(vrcholy[steny[i,(j+1) mod 4],0]),
                    round(vrcholy[steny[i,(j+1) mod 4],1]),
                    farba);
     end;
end;

procedure nafarbiUtvarStenami(ps : byte; hranica : byte);
var i,j : byte;
var pomx, pomy : real;

begin
     for i := 0 to ps-1 do
     begin
          if (vektory[i,2] > 0) then
             begin
                  pomx := (vrcholy[steny[i,0],0]+vrcholy[steny[i,2],0])/2;
                  pomy := (vrcholy[steny[i,0],1]+vrcholy[steny[i,2],1])/2;
                  farbi(round(pomx),round(pomy),round(14*vektory[i,2]),hranica);
                  end;

     end;
end;


procedure vymazUtvarStenami(ps : byte; farba,hranica : byte);
var i,j : byte;
var pomx, pomy : real;

begin
     for i := 0 to ps-1 do
     begin
          if (vektory[i,2] > 0) then
             begin
                  pomx := (vrcholy[steny[i,0],0]+vrcholy[steny[i,2],0])/2;
                  pomy := (vrcholy[steny[i,0],1]+vrcholy[steny[i,2],1])/2;
                  farbi(round(pomx),round(pomy),farba,hranica);

                  end;

     end;
end;

procedure otocenie_x(fi : real; pv,ps : byte);
var x,y,z : real;
    i : byte;
    co,si : real;
begin
     co := cos(fi);
     si := sin(fi);
     for i := 0 to pv-1 do
     begin
     x := vrcholy[i,0];
     y := vrcholy[i,1];
     z := vrcholy[i,2];
     vrcholy[i,0] := x;
     vrcholy[i,1] := y*co - z*si;
     vrcholy[i,2] := y*si + z*co;
     end;
     for i := 0 to ps-1 do
     begin
          x := vektory[i,0];
          y := vektory[i,1];
          z := vektory[i,2];
          vektory[i,0] := x;
          vektory[i,1] := y*co-z*si;
          vektory[i,2] := y*si+z*co;
     end;
end;

procedure otocenie_y(fi : real; pv,ps : byte);
var x,y,z : real;
    i : byte;
    co,si : real;
begin
     co := cos(fi);
     si := sin(fi);
     for i := 0 to pv-1 do
     begin
     x := vrcholy[i,0];
     y := vrcholy[i,1];
     z := vrcholy[i,2];
     vrcholy[i,0] := x*co+z*si;
     vrcholy[i,1] := y;
     vrcholy[i,2] := -x*si + z*co;
     end;
     for i := 0 to ps-1 do
     begin
          x := vektory[i,0];
          y := vektory[i,1];
          z := vektory[i,2];
          vektory[i,0] := x*co+z*si;
          vektory[i,1] := y;
          vektory[i,2] := -x*si+z*co;
     end;
end;

procedure otocenie_z(fi : real; pv,ps : byte);
var x,y,z : real;
    i : byte;
    co,si : real;
begin
     co := cos(fi);
     si := sin(fi);
     for i := 0 to pv-1 do
     begin
     x := vrcholy[i,0];
     y := vrcholy[i,1];
     z := vrcholy[i,2];
     vrcholy[i,0] := x*co-y*si;
     vrcholy[i,1] := x*si+y*co;
     vrcholy[i,2] := z;
     end;
     for i := 0 to ps-1 do
     begin
          x := vektory[i,0];
          y := vektory[i,1];
          z := vektory[i,2];
          vektory[i,0] := x*co-y*si;
          vektory[i,1] := x*si+y*co;
          vektory[i,2] := z;
     end;
end;
{ovladanie telesa vykresleneho cez hrany}

{procedure ovladanie_h(kod : char; pv,ph,ps : byte);

begin
     case kod of
          'a': begin
                    nakresliUtvarHranami(ph,0);
                    otocenie_y(0.12,pv,ps);
                    nakresliUtvarHranami(ph,13);
                    end;
          'd': begin
                    nakresliUtvarHranami(ph,0);
                    otocenie_y(-0.12,pv,ps);
                    nakresliUtvarHranami(ph,13);
          end;
          's': begin
                    nakresliUtvarHranami(ph,0);
                    otocenie_x(-0.12,pv,ps);
                    nakresliUtvarHranami(ph,13);
          end;
          'w': begin
                    nakresliUtvarHranami(ph,0);
                    otocenie_x(0.12,pv,ps);
                    nakresliUtvarHranami(ph,13);
          end;
          'k': begin
                    nakresliUtvarHranami(ph,0);
                    otocenie_z(-0.12,pv,ps);
                    nakresliUtvarHranami(ph,13);
          end;
          'l': begin
                    nakresliUtvarHranami(ph,0);
                    otocenie_z(0.12,pv,ps);
                    nakresliUtvarHranami(ph,13);
          end;
     end;

end;}

{riadene otacanie telesa vykreslovaneho cez steny}
{procedure ovladanie_s(kod : char; pv,ps : byte);

begin
     case kod of
          'a': begin
                    nakresliUtvarStenami(ps,0);
                    otocenie_y(0.12,pv,ps);
                    nakresliUtvarStenami(ps,13);
                    end;
          'd': begin
                    nakresliUtvarStenami(ps,0);
                    otocenie_y(-0.12,pv,ps);
                    nakresliUtvarStenami(ps,13);
          end;
          's': begin
                    nakresliUtvarStenami(ps,0);
                    otocenie_x(-0.12,pv,ps);
                    nakresliUtvarStenami(ps,13);
          end;
          'w': begin
                    nakresliUtvarStenami(ps,0);
                    otocenie_x(0.12,pv,ps);
                    nakresliUtvarStenami(ps,13);
          end;
          'k': begin
                    nakresliUtvarStenami(ps,0);
                    otocenie_z(-0.12,pv,ps);
                    nakresliUtvarStenami(ps,13);
          end;
          'l': begin
                    nakresliUtvarStenami(ps,0);
                    otocenie_z(0.12,pv,ps);
                    nakresliUtvarStenami(ps,13);
          end;
     end;

end;}

procedure vypis;
var i,j : integer;

begin
     for i := 0 to pocet_stien-1 do
     begin
          for j := 0 to 2 do
              write(vektory[i,j]);
          writeln;
     end;
end;


{*********-----------**********}

begin
     assign(data,'c:\tmp\grafikaa\udaje2.txt');
     reset(data);
     pocet_vrcholov := nacitajVrcholy(data);
     pocet_hran := nacitajHrany(data);
     pocet_stien := nacitajSteny(data);
     nacitajVektory(data,pocet_stien);
     nastav;
     for i := 0 to 90 do
     begin
     otocenie_x(i*PI/180,pocet_vrcholov,pocet_stien);
     otocenie_y(i*PI/180,pocet_vrcholov,pocet_stien);
     otocenie_z(i*PI/180,pocet_vrcholov,pocet_stien);
     nakresliutvarstenami(pocet_stien,15);

     nafarbiutvarstenami(pocet_stien,15);

     vymazutvarstenami(pocet_stien,0,15);
     nakresliutvarstenami(pocet_stien,0);
     end;
{     bod(300,300,7);
     writeln(zistifarbubodu(300,300));}
{     c := 't';
     while (c<>'q') do
     begin
          c := readkey;
          ovladanie_s(c,pocet_vrcholov,pocet_stien);
     end;}
     readln;
     zrus;

end.