Prima Shareware 3/DuCom_Prima-Shareware-3_cd1.bin/PROGRAMO/PASCAL/HEJB/GRAPH/OBRAZ3D.PAS

Pascal/Delphi Source File | 1993-12-10 | 23.2 KB | 710 lines

{$g+}
unit obraz3d;

interface
uses dos, crt;

const
  _z_back        = $80;  { z sou⌐adnice pozadí }

  { viz typ bodu }
  _mazat         = $10;  { bod je samostatne pamêti a se zhasnutím p⌐estane existovat }
  _pouzit        = $20;  { bod je zobrazen }
  _pozadi        = $40;  { bod je pozadí }

type
  bod_fyz_obrazu = byte;

const
  maximum_obrazu = 65535 div (4+sizeof(bod_fyz_obrazu))-1; { maximální poçet bodû spojitého obrazu }

  __sada_3d_8x8  = $80;         { grafické módy }
  __sada_2d_8x8  = $40;

  _mnptr         = $fff0;
  _mptr          = $ffff000f;

type
  typ_pole_bytu         = array[0..65534]of byte; { pomocné typy }
  ptr_to_pole_bytu      = ^typ_pole_bytu;

  typ_ind_obrazu        = 0..maximum_obrazu-1;
  typ_souradnic = shortint; { typ sou⌐adnice dvou a t⌐írozmêrnÿch bodû }
  tsou_2d       = record
                   x, y : typ_souradnic;
                 end;
  tsou_3d       = record
                   case boolean of
                     true  : (x, y, z  : typ_souradnic);
                     false : (x2d, y2d : typ_souradnic);
                 end;
  ptr_tsou_3d  = ^tsou_3d; { pomocnÿ ukazatel }

  typ_bod_3d  = ^typ_ob_bodu; { ukazatel na bod virtuální obrazovky }
  typ_ob_bodu = record        { typ bodu virtuální obrazovky }
                  case byte of
                    0    : ( _l, _h : word); { pomocné promênné }
                    1    : (typ   : byte;
      { x x x x x x x x                                              }
      { ^ ^ ^ ^ ^ ^ ^ ^                                              }
      { | | | | | | | |                                              }
      { | | | | -----------> lo adresy dal¿ího v segmentu            }
      { | | | -------------> 1 .. bod je v samostné pamêti           }
      { | | ---------------> 1 .. bod je pouæit v 3d obrazu          }
      { | -----------------> 1 .. bod je souçástí pozadí             }
      { -------------------> zatím nepouæit                          }
                             z     : shortint;
      { tohle je z souradnice daneho bodu                            }
                             dalsi : word;
      { segment dalsiho bodu obrazu                                  }
                             obsah : bod_fyz_obrazu;);
      { obsah fyzické obrazovky                                      }
                    2    : ( point : typ_bod_3d); { pomocná promênná }
                end;

  typ_obrazu_3d    = array[typ_ind_obrazu]of typ_ob_bodu; { typ pole, ve kterém jsou uloæeny body pozadí virtuální obrazovky }
  ptr_to_3d_obraz  = ^typ_obrazu_3d; { a typ ukazatele na toto pole }

  ptr_to_3d_obrazovka = ^typ_obrazovka_3d;
  typ_obrazovka_3d = object{ typ virtuální obrazovky }
             posunx, posuny, levy, pravy, horni, dolni : typ_souradnic;
             sirka    : typ_souradnic;
             velikost : word;
             __obraz  : ptr_to_3d_obraz;
              { v tomto poli jsou ulozeny body pozadi }

             procedure zobraz_bod_obsah_xy (x, y, z : typ_souradnic; co : bod_fyz_obrazu);
             procedure zhasni_bod_obsah_xy (x, y, z : typ_souradnic; co : bod_fyz_obrazu);
              { zobrazí a zhasnou znak a atribut (co) na danou posici [x, y, z]. p⌐i zhasnutí p⌐estane bod existovat v pamêti }
             procedure zobraz_bod_pozadi_xy(x, y : typ_souradnic;co : bod_fyz_obrazu);
              { zobrazí a zhasnou znak a atribut (co) na danou posici [x, y, -128] do pozadí obrazovky }

             procedure zobraz_bod_xy       (x, y : typ_souradnic; bod : typ_bod_3d);
             procedure zhasni_bod_xy       (x, y : typ_souradnic; bod : typ_bod_3d);
              { zobrazí a zhasnou bod ve virtuální obrazovce }
             procedure obnov_bod_xy        (x, y : typ_souradnic);
              { obnoví bod virtuální obrazovky }
             procedure presun_bod_xy       (x1, y1, x2, y2 : typ_souradnic; bod : typ_bod_3d );
              { p⌐esune bod ve virtuální obrazovce }

              { na pozici [x, y, z] se mûæe nacházet více bodû, jednoznaçnê }
              { je bod u⌐çen pouze ukazatelem na tento bod }

             procedure zacni(_posunx, _posuny, _levy, _pravy, _horni, _dolni : typ_souradnic);
              { zabere v dynamické pamêti místo pro pozadí virtuální obrazovky, }
              { p⌐izpûsobí do pot⌐ebného tvaru a p⌐eçte do této pamêti to, }
              { co je právê na fyzické obrazovce. }

             procedure cti_pozadi;
              { p⌐eçte do pozadí virtuální obrazovky právê aktivní fyzickou obrazovku }

             procedure vytvor_pozadi;
              { p⌐izpûsobí pamêƒ pro pozadí virtuální obrazovky }
              { do pot⌐ebného tvaru (t.j. x*y cyklickÿch seznamû) }

             procedure obnov_obraz;
              { obnoví obsah virtuální obrazovky na fyzickou }

             procedure skoncuj;
             procedure clrscr;
              { vymaæe pozadí virtuální obrazovky }


           private
             procedure zrus_pozadi;
              { na fyzickou obrazovku p⌐epí¿e pozadí z virtuální }
              { a uvolní samostatnou pamêƒ virtuální obrazovky }
              { (t.j. pozadí a samostatné body) }
             procedure zobraz_bod_pozadi(adrobj : integer; co : bod_fyz_obrazu);
             procedure copy_screen( pom3d :  ptr_to_3d_obraz; pomvel  : word;
                                   zbytek :  bod_fyz_obrazu);

           end;
const
  pamet_bod_3d = sizeof(typ_ob_bodu);
  __nula3d       : typ_ob_bodu = (typ : 0; z : -128; _h : 0; obsah : 0);
  __nula_3d      : tsou_3d = (x:0;y:0;z:0);
  mizera         : bod_fyz_obrazu = 0;
var
  ___bod    : tsou_3d; { pro predavani hodnot }


function xyz_bod(x, y, z : typ_souradnic):ptr_tsou_3d;
{procedure initgraph(var graphdriver:integer; var graphmode: integer;
   pathtodriver: string);
}implementation
uses
  graph;

{procedure initgraph(var graphdriver:integer; var graphmode: integer;
   pathtodriver: string);

begin
  graph.initgraph(graphdriver, graphmode, pathtodriver);
  if graphdriver = vga
    then asm
           mov al, 13h
       int 10h
         end;
end;

function getpixel(x,y: integer): bod_fyz_obrazu;
var color : byte;
begin
  asm      mov ah, 0dh
           mov bh, 0
           mov dx, y
           mov cx, x
           mov color, al
           int 10h
  end;
  getpixel := color;
end;


procedure putpixel(x, y : integer; color : bod_fyz_obrazu);
begin
  asm      mov ah, 0ch
           mov bh, 0
           mov dx, y
           mov cx, x
           mov al, byte ptr color
           int 10h
  end;
end;
}
function xyz_bod(x, y, z : typ_souradnic):ptr_tsou_3d;
begin
  xyz_bod := @___bod;
  ___bod.x := x;
  ___bod.y := y;
  ___bod.z := z;
end;

procedure typ_obrazovka_3d.copy_screen( pom3d :  ptr_to_3d_obraz;
                     pomvel  : word;
                      zbytek : bod_fyz_obrazu);
var velcykl1, velcykl2, i : word;
begin
  if pomvel > velikost
    then begin velcykl1 := velikost-1; velcykl2 := pomvel-1 end
    else begin velcykl2 := velikost-1; velcykl1 := pomvel-1 end;

  for i := 0 to velcykl1 do zobraz_bod_pozadi(i, pom3d^[i].obsah);
  for i := velcykl1+1 to velcykl2 do zobraz_bod_pozadi(i, 0);
end;

procedure typ_obrazovka_3d.zobraz_bod_obsah_xy(x, y, z : typ_souradnic;  co : bod_fyz_obrazu);
label nezobrazit;
var pom : typ_bod_3d;
begin
  if x >= levy then if x <= pravy then if y >= horni then if y <= dolni then
    begin
      new(pom);
      pom^.z     := z;
      pom^.typ   := _mazat;
      pom^.obsah := co;
      zobraz_bod_xy(x, y, pom);
    end;
  nezobrazit:
end;

procedure typ_obrazovka_3d.zhasni_bod_obsah_xy(x, y, z : typ_souradnic; co : bod_fyz_obrazu);
label dalsi, konec, nezobrazit;
var    bod, tmpbod : typ_bod_3d;

    adrobj : integer;
    barva  : bod_fyz_obrazu;
begin
(*  bod := nil;
  if x >= levy then if x <= pravy then if y >= horni then if y <= dolni then
    begin
{      adrobj := x-levy + (y-horni)*(pravy-levy);
      bod := @__obraz^[adrobj];
      repeat
        tmpbod := ptr(bod^._h, bod^._l and $0f);
        if (tmpbod^.typ and _pozadi) <> 0 then exit;
      until not(     ((tmpbod^.typ and _mazat) = 0)
                  or (tmpbod^.z <> z)
                  or (tmpbod^.obsah <> co)
               );

}
      asm
                 les di, self

                 mov al, es:[di].pravy
                 sub al, es:[di].levy
                 xor ah, ah
                 mov bl, y
                 xor bh, bh
                 mul bx
                 xor ch, ch
                 add ax, cx
                 mov adrobj, ax

                 push ds

                 lds si, self                        { hejbaci objekt }
                 lds si, ds:[si].__obraz             { obraz3d }

                 shl ax, 1
                 mov dx, ax
                 shl dx, 1
                 add dx, ax                              { dx := dx*sizeof(typ_ob_bodu) }
                 add si, dx                      { odkud se má zrusit }

                 mov al, z
                 mov cx, co

{ ds:si adresa dalsiho pixelu, dx:bx adresa predchoziho pixelu }

   dalsi:        mov bx, si                { uloæení predchozi adresy }
                 mov dx, ds
                 lds si, ds:[si]               { adresa dal¿ího prvku }
                 and si, 0fh

                 test ds:typ_ob_bodu([si]).typ, _pozadi { je to pozadí ? }
                 jnz konec { ne - to, co se ma ru¿it, v seznamu nejni }


                 cmp al, ds:typ_ob_bodu([si]).z       { sou stejnÿ z ? }
                 jne dalsi                { nejsou ! }
                 cmp cx, ds:typ_ob_bodu([si]).obsah   { sou stejny obsahy ? }
                 jne dalsi                { nejsou ! }
                                          { sou stejny }
                 test ds:typ_ob_bodu([si]).typ, _mazat{ je pixel samostatny ? }
                 jz dalsi         { nejni, nemuzu mazat, ale hledat dal }

                 mov word ptr bod, si
                 mov word ptr bod+2, ds
                   { ds:si ruseny bod   }
                   { dx:bx bod pred nim }
                 lds si, ds:[si]         { pointer z ds:[si] se p⌐esune na dx:[bx] }
                 mov ax, ds
                 mov ds, dx
                 mov cx, ds:[bx]
                 and cl,0f0h
                 and si,0fh
                 or cx, si
                 mov ds:[bx], cx
                 mov ds:[bx+2], ax
                   { dx:bx bod pred rusenym }

                 test ds:typ_ob_bodu([bx]).typ, _pozadi
                 jz konec

                 lds bx, ds:[bx]
                 and bx, 0fh
                 mov ax, ds:typ_ob_bodu([bx]).obsah { bod byl vidêt, na obrazovku musí následující za tímto }
                 mov barva, ax
      end;
                 putpixel(x+posunx, y+posuny, barva);
      asm
    konec :      pop ds
      end;
  end;
  if bod <> nil then dispose(bod);
  nezobrazit:
*)end;

procedure typ_obrazovka_3d.vytvor_pozadi;
{ procedura vytvo⌐í pozadi v poli obraz, t.j do bod uloæí:      }
{  - obsah fyzické obrazovky na dané pozici                     }
{  - sou⌐adnici z = $80 (-128) _z_back                          }
{  - do horních bitû pole typ nastaví hodnotu 0110              }
{  - do spodních bitû pole typ a do pole dalsi                  }
{    uloæí ukazatel na sebe sama                                }

var x, y : typ_souradnic;
    k    : word;
    pompoint : typ_bod_3d;
begin
  k := 0;
  for y := horni to dolni do
    for x := levy to pravy do
      begin
        pompoint := @__obraz^[k];
        asm
          mov ax, word ptr pompoint{normalisace adresy }
          shr ax, 4
          add word ptr pompoint+2, ax
          and word ptr pompoint, $f
        end;
        pompoint^.point := typ_bod_3d(longint(pompoint)+_pozadi or _pouzit + _z_back shl 8);

        pompoint^.obsah := getpixel(x+posunx, y+posuny);

        inc(k);
      end;
end;

procedure typ_obrazovka_3d.zobraz_bod_pozadi_xy    (x, y : typ_souradnic;co : bod_fyz_obrazu);
label nejni_videt;
begin
(*  if x >= levy then if x <= pravy then if y >= horni then if y <= dolni then
    begin
      asm
                 push ds

                 les di, self

                 mov al, es:[di].pravy
                 sub al, es:[di].levy
                 xor ah, ah
                 mov bl, y
                 xor bh, bh
                 mul bx
                 xor ch, ch
                 add ax, cx               { ax = adrobj }

                 lds si, self             { hejbaci objekt }
{                 les di, ds:[si].fyz_obraz{ obrazovka }
                 lds si, ds:[si].__obraz  { pozadi }

                 shl ax, 1                { adrobj * 2 }
                 mov bx, ax

                 shl bx, 1                { adrobj * 4 }
                 add bx, ax               { adrobj * 6 }
                 add si, bx               { adrobj * 6 pricist k adr. pozadi }

                 mov ax, co               { uloæ co do 3d }
                 mov ds:typ_ob_bodu([si]).obsah, ax

                 lds si, ds:[si]
                 and si, 0fh
                 test ds:typ_ob_bodu([si]).typ, _pozadi { je co taky na obrazovce ? }

                 jz nejni_videt           { t.j. za nim je pozadi }
                 pop ds
      end;
                 putpixel(x+posunx, y+posuny, co);

      asm        push ds
   nejni_videt : pop ds
      end
    end;
*)end;

procedure typ_obrazovka_3d.zobraz_bod_pozadi(adrobj : integer; co : bod_fyz_obrazu);
{ do pozadí umístí procedura na posici adrobj co. pokud pozadí }
{ bylo vidêt, zobrazí co                                       }
{ procedura je v po⌐ádku                                       }

label nejni_videt;
begin
(*  asm
                 push ds

                 lds si, self             { hejbaci objekt }
{                 les di, ds:[si].fyz_obraz{ obrazovka }
                 lds si, ds:[si].__obraz  { pozadi }

                 mov bx, adrobj           { adresa v obrazovce }
                 cmp bx, 0ffffh
                 jle nejni_videt
                 cmp bx, ds:[si].velikost
                 jg  nejni_videt

                 shl bx, 1                { adrobj * 2 }
                 mov ax, bx
{                 add di, bx               { pricist k adrese fyz. obrazovky }

                 shl bx, 1                { adrobj * 4 }
                 add bx, ax               { adrobj * 6 }
                 add si, bx               { adrobj * 6 pricist k adr. pozadi }

                 mov ax, co               { uloæ co do 3d }
                 mov ds:typ_ob_bodu([si]).obsah, ax

                 lds si, ds:[si]
                 and si, 0fh
                 test ds:typ_ob_bodu([si]).typ, _pozadi { je co taky na obrazovce ? }
                 jz nejni_videt           { t.j. za nim je pozadi }

                 pop ds
  end;

{                 putpixel(x+posunx, y+posuny, co);}
  asm
                 push ds

   nejni_videt : pop ds
  end
*)end;

procedure typ_obrazovka_3d.cti_pozadi;
{ procedura p⌐eçte fyzickou obrazovku a uloæí do pozadí 3d obrazovky }
{ procedura je v po⌐ádku                                       }
var i : word;
begin
  for i := 0 to velikost-1 do
    zobraz_bod_pozadi(i, getpixel(i mod (sirka), i div (sirka)));
end;

procedure typ_obrazovka_3d.obnov_obraz;
var x, y, k : integer;
begin
  k := 0;
  for y := horni to dolni do
    for x := levy to pravy do
      begin
        putpixel(x+posunx, y+posuny, typ_bod_3d(ptr(__obraz^[k]._h, $0f and __obraz^[k]._h))^.obsah);
        inc(k);
      end;
end;

procedure typ_obrazovka_3d.clrscr;
var x, y, k : integer;
    barva : bod_fyz_obrazu;
label zvets, dalsi, konec;
begin
  k := 0;
  for y := horni to dolni do
    for x := levy to pravy do
      begin
        __obraz^[k].obsah := mizera;
        inc(k);
      end;
end;

procedure typ_obrazovka_3d.zrus_pozadi;
{ procedura je v po⌐ádku                                       }

var rus_bod, fyz, o3d, tmp : typ_bod_3d;
label nerusit, dalsi1, dalsi2, dalsi3, zvetsit;
begin
(*  asm
                 push ds

                 les si, self
                 mov cx, es:[si].velikost
{                 dec cx}
{                 les di, [si].fyz_obraz}
                 lds si, [si].__obraz

    dalsi1:      mov bx, typ_ob_bodu([si]).obsah { je, presun 3d -> fyz_obraz }


                 mov es:[di], bx
                 test typ_ob_bodu([si]).typ, _pozadi
                 jz zvetsit

                 mov word ptr o3d, si
                 mov word ptr o3d+2, ds
                 mov word ptr fyz, di
                 mov word ptr fyz+2, es

    dalsi2:      lds si, ds:[si]
                 and si, 0fh
    dalsi3:      test ds:typ_ob_bodu([si]).typ, _pozadi
                 jnz nerusit         { uæ neni æádnÿ volnÿ bod }
                 test ds:typ_ob_bodu([si]).typ, _mazat
                 jz dalsi2

                 mov word ptr rus_bod, si
                 mov word ptr rus_bod+2, ds

                 lds si, ds:[si]
                 and si, 0fh
                 mov word ptr tmp, si
                 mov word ptr tmp+2, ds

                 pop ds
                 push cx

    end;         dispose(rus_bod);
    asm          pop cx
                 push ds

                 mov si, word ptr tmp
                 mov ds, word ptr tmp+2
                 jmp dalsi3


    nerusit:     mov di, word ptr fyz
                 mov es, word ptr fyz+2
                 mov si, word ptr o3d
                 mov ds, word ptr o3d+2

    zvetsit:     add si, 6
                 add di, 2
                 loop dalsi1

                 pop ds
  end;
*)end;

procedure typ_obrazovka_3d.skoncuj;
{ procedura je v po⌐ádku                                       }
var pomvel : word;
begin
  pomvel := velikost;
  zrus_pozadi;
  freemem(__obraz, pomvel*pamet_bod_3d)
end;

procedure typ_obrazovka_3d.zacni;
{ procedura je v po⌐ádku                                       }
begin
  posunx := _posunx;
  posuny := _posuny;
  levy   := _levy  ;
  pravy  := _pravy ;
  horni  := _horni ;
  dolni  := _dolni ;

  sirka := pravy-levy+1;
  velikost := sirka * (dolni-horni+1);

  getmem(__obraz, velikost*pamet_bod_3d);
  rectangle(posunx+levy, posuny+horni, posunx+pravy, posuny+dolni);
  vytvor_pozadi;
{  cti_pozadi;}
end;

procedure vypis(bod : typ_bod_3d);
var bodvyhl, bodpred : typ_bod_3d;
    pi : integer;
    ven : text;
begin
  assign(ven,'con');
  rewrite(ven);

  asm
    mov ax, word ptr bod{normalisace adresy }
    shr ax, 4
    add word ptr bod+2, ax
    and word ptr bod, $f
  end;

  bodvyhl := bod;
  repeat
    writeln(ven, bodvyhl^. _h:4, ':',
                 bodvyhl^. _l and $f, ' ',
                 bodvyhl^. z : 4,
                 bodvyhl^. obsah : 6,
                 bodvyhl^. typ and $f0 : 5);
    longint(bodvyhl) := longint(bodvyhl^.point) and $ffff000f;
  until bod = bodvyhl;
  writeln(ven);
  close(ven);
end;


procedure typ_obrazovka_3d.zobraz_bod_xy(x, y : typ_souradnic; bod : typ_bod_3d);
var bodvyhl, bodpred : typ_bod_3d;
    pi : integer;
begin
  if (bod^.typ and _pouzit) = 0 then
    if x >= levy then if x <= pravy then if y >= horni then if y <= dolni then
      begin
        asm
          mov ax, word ptr bod{normalisace adresy }
          shr ax, 4
          add word ptr bod+2, ax
          and word ptr bod, $f
        end;
        pi := (x-levy)+(y-horni)*(sirka);
        bodvyhl := @__obraz^[pi].point;
        repeat
          bodpred := bodvyhl;
          longint(bodvyhl) := longint(bodvyhl^.point) and $ffff000f;
        until bod^.z > bodvyhl^.z;
{        vypis(@__obraz^[pi].point);}
        bod^.point := typ_bod_3d((longint(bod^.point) and $fff0) or longint(bodvyhl));
        bod^.typ := bod^.typ or _pouzit;
        bodpred^.point := typ_bod_3d((longint(bodpred^.point) and $fff0) or longint(bod));
        if (bodpred^.typ and _pozadi) <> 0 then { zobrazuje se na fyzickou }
          putpixel(x+posunx, y+posuny, bod^.obsah);
{        vypis(@__obraz^[pi].point);}
      end;
end;

procedure typ_obrazovka_3d.zhasni_bod_xy    (x,y : typ_souradnic; bod : typ_bod_3d);
label neni_co;
var bodvyhl, bodpred : typ_bod_3d;

begin
  if (bod^.typ and _pouzit) <> 0 then
    if x >= levy then if x <= pravy then if y >= horni then if y <= dolni then
      begin
        asm
          mov ax, word ptr bod{normalisace adresy }
          shr ax, 4
          add word ptr bod+2, ax
          and word ptr bod, $f
        end;
        bodvyhl := @__obraz^[(x-levy)+(y-horni)*(sirka)].point;
        repeat
          bodpred := bodvyhl;
          longint(bodvyhl) := longint(bodvyhl^.point) and $ffff000f;
          if (bodvyhl^.typ and _pozadi) <> 0 then goto neni_co;
        until bodvyhl = bod;

        bod^.typ := bod^.typ and not _pouzit;
        bodpred^.point := typ_bod_3d((longint(bodpred^.point) and $fff0) or (longint(bod^.point) and $ffff000f));
        if (bodpred^.typ and _pozadi) <> 0 then
          putpixel(x+posunx, y+posuny, typ_bod_3d(longint(bodpred^.point) and $ffff000f)^.obsah);
      end;
neni_co:;
end;

procedure typ_obrazovka_3d.obnov_bod_xy    (x, y : typ_souradnic);
label dalsi, konec;
var adrobj : integer;
begin
  if x >= levy then if x <= pravy then if y >= horni then if y <= dolni then
    putpixel(x, y, typ_bod_3d(ptr(__obraz^[x+y*(sirka)]._h,
                          $0f and __obraz^[x+y*(sirka)]._l))^.obsah);

end;

procedure typ_obrazovka_3d.presun_bod_xy(x1, y1, x2, y2 : typ_souradnic; bod : typ_bod_3d );
label zobrazit;
var bodvyhl, bodpred : typ_bod_3d;

begin
        asm
          mov ax, word ptr bod{normalisace adresy }
          shr ax, 4
          add word ptr bod+2, ax
          and word ptr bod, $f
        end;

  if (bod^.typ and _pouzit) <> 0 then
    if x1 >= levy then if x1 <= pravy then if y1 >= horni then if y1 <= dolni then
      begin
        bodvyhl := @__obraz^[(x1-levy)+(y1-horni)*(sirka)].point;
        repeat
          bodpred := bodvyhl;
          longint(bodvyhl) := longint(bodvyhl^.point) and $ffff000f;
          if (bodvyhl^.typ and _pozadi) <> 0 then goto zobrazit;
        until bodvyhl = bod;

        bod^.typ := bod^.typ or not _pouzit;
        bodpred^.point := typ_bod_3d((longint(bodpred^.point) and $fff0) or (longint(bod^.point) and $ffff000f));
        if (bodpred^.typ and _pozadi) <> 0 then
          putpixel(x1+posunx, y1+posuny, typ_bod_3d(longint(bodpred^.point) and $ffff000f)^.obsah);
      end;

zobrazit :

    if x2 >= levy then if x2 <= pravy then if y2 >= horni then if y2 <= dolni then
      begin
        bodvyhl := @__obraz^[(x2-levy)+(y2-horni)*(sirka)].point;
        repeat
          bodpred := bodvyhl;
          longint(bodvyhl) := longint(bodvyhl^.point) and $ffff000f;
        until bod^.z > bodvyhl^.z;
        bod^.point := typ_bod_3d((longint(bod^.point) and $fff0) or longint(bodvyhl));
        bodpred^.point := typ_bod_3d((longint(bodpred^.point) and $fff0) or longint(bod));
        if (bodpred^.typ and _pozadi) <> 0 then { zobrazuje se na fyzickou }
          putpixel(x2+posunx, y2+posuny, bod^.obsah);
      end;
end;

end.