SC03_pre - Text Only Version * edited by TomCat/Abaddon (tomcat@szif.hu)
############################################################################
> 
>               Hi Tomi!

Hi Dave!

> 
>    Van nehany problemam a makrokkal. Ugy hiszem te tudsz segiteni (vagy
> senki sem... :).
>    Tehat (pelda):
>       1. Szeretnek egy memoriafoglalo makrot csinalni, ami kepes futni
>          real-mode-ban (DOS alatt persze), meg mondjuk pmode-ban is Ervin
>          PMDriver-javal.
>       2. A kulombozo proci modok kozt ugy valasztana, hogy a fomodul
>          (marmint az az .asm file, ami fordithato) elejen definialok egy
>          olyan szimbolumot, hogy 'mode=real', vagy 'mode=pmode', es mivel
>          nem fogadja ezt csak igy el, csinalok, egy global.sym nevu include
>          file-t, amiben a 'real equ 0', 'pmode=1', stb. benne van. Ezenkivul
>          belefer pl. 'b equ byte ptr', meg tarsai is. (Az elejere meg
>          beirtam, hogy:  IFNDEF global_symbols
>                             global_symbols=1
>                             real equ 0
>                             ...
>                          ENDIF
>         Ezt azert tettem, mert igy mindenhova includalhatom, es biztos, hogy
>         az elso elofordulaskor veszi figyelembe. Idaig mukodne is, igaz
>         valami 'Module is pass dependent - compatibility pass was done'
>         hibauzenetet (warning-ot) ad, ugyhogy ha van otleted a
>         kikuszobloesere az is erdekelne.)

Amit leirtal az eddig ok. A Warning kikuszobolese engem is nagyon erdekelne.

>      3. Most tehat a makro:
> 
>            Malloc MACRO Size
>            LOCAL @@Malloc1,@@Malloc2
>               IF mode eq pmode
>               ; ide jon a pmode-os cucc, csak meg nem kozultaltam Ervinnel
>               ELSE
>               ; RealMode memory allocation
>                  mov   ebx,Size
>                  test  ebx,0fff00000h
>                  stc
>                  jz    @@malloc2
>                  test  bl,0fh
>                  jz    @@malloc1
>                  add   ebx,10h
>               @@Malloc1:
>                  shr   ebx,10h
> 
>                  mov   ah,48h
>                  int   21h
>               @@Malloc2: LABEL
>               ENDIF
>               ENDM
>         Byte-ban keri a lefoglalando memoria meretet (Size).
>         CarryFlag=CY, ha hiba volt, egyebkent CN, es ax a
>         lefoglalt memoria szegmenscime. Megvizsgalja, hogy Size
>         nem tobb-e, mint amit a DOS enged, aztan atszamolja
>         paragrafusokra, utana DOS-IT.

Esetleg ajanlok egy masik megoldast is:

MACRO...
IFDEF PMODE
...
ELSE
...
ENDIF
ENDM

Es forditaskor, ha adsz a TASM-nak egy /DPMODE opciot, akkor a
pmode-u makroid forditodnak le egyebkent meg a real-ek.
Ezt a kov. modon fokozhatjuk:

IFDEF PMODE
INCLUDE PMMACROS.LIB
ELSE
INCLUDE RMMACROS.LIB
ENDIF

Ez esetben ugye, kulon-kulon kell gyujtogeni a makrokat.

>    4. Most jonnek a problemak:
>         a) Ha a Size pont ebx, akkor nem akarok egy mov ebx,ebx utasitast a
>            kodba.

Egyszeru problema, a Makrok Vilaga I.-ben is leirtam a megoldast:

A sima MOV EBX,EBX helyett a kov. kell:
IFDIFI <Size>,<EBX>
MOV EBX,EBX
ENDIF

>         b) Ha a Size szimbolum, akkor nem kell futasi ido alatt szamolgatni,
>            lehet mar forditas alatt is.
>        Raadasul a kod sem lesz ilyen csunya.

Tokeletes megoldast nem tudok. Talan csinalj ket makrot:

MACRO   Malloc  _Address,_Size
IFDIFI <_Size>,<BX>
MOV BX,_Size
ENDIF
MOV AH,48H
INT 21H
IFDIFI <_Address>,<AX>
MOV AX,_Address
ENDIF
ENDM

MACRO   MallocSize   _Address,_Size
IFDIFI <_Size>,<EBX>
MOV EBX,_Size
ENDIF
...
Malloc _Address,BX
ENDM

Igy azt hivod meg amelyik eppen kell.

> 
> Ha akarod tovabbkuldheted a CM-be, csak a folos reszt szedd legyszi' ki
> belole.

Termeszetesen tovabbkuldtem, mert a te problemadbol mas is tanulhat,
amire meg nem tudok valaszolni, arra talan mas tud. Legkozelebb ha
hasonlo kerdeseid lesznek, akkor egybol a CODER-L@D6.SZIF.HU-ra kuldd.
Lehet, hogy valaki gyorsabban valaszolt volna ( na azert ezt ketlem :).

>                 Koszi
>                        Dave(tm)
> 

Nincs mit, G.O.D.

TomCat
............................................................................
Kozben utananeztem nehany dolognak, es sikerult egy megoldast talalnom a 
problemamra. Egyebkent az ott szereplo memoriafoglalo makro nem mukodik,
csak erre kesobb jottem ra... :(
Az otlet a kovetkezo:
Van egy .TYPE nevu operator, ami valami hasonlora lehetett kitalalva.
A MASM is ismeri, persze a TASM is, de csak MASM kompatibilis modban, 
tehat IDEAL-ban nem megy. Ugy mukodik, hogy:
.TYPE parameter
Ez visszaad egy byte-ot, aminek a bitjeit vizsgalva meg lehet tudni, hogy 
milyen tipusu a parameter.
        Bit     Leiras
        ------------------------------------------------------------------------
         0      Program relativ szimbolum
         1      Adat relativ szimbolum
         2      Kostans
         3      Direkt cimzesi mod
         4      Regiszter
         5      A szibolbolum definialva van (azert meg jo, hogy eszukbe jutott)
         7      A szimbolum kulso
Ha a 2. es a 3. bit 0, akkor a kifejezes regiszter indirekt cim (pl.[BX]).
Ha 0 a kapott byte, akkor a szimbolum nem definialt.
(Tehat az 'IFNDEF x' es az 'IFE (.TYPE x)' ugyanazt jelenti. Raadasul meg 
az utobbi sem kuszoboli ki a 'Modul is Pass Dependent...' hibauzenetet 
/lehet, hogy nem pont ez a hibauzenet, de a lenyege ugyanaz./).
Most pedig egy pelda:

Makro MACRO abc
IF (.TYPE abc) AND 3    ;is it segment-relative
   ASSUME ds:SEG abc
   mov  ax,SEG abc
   mov  ds,ax
ENDIF
                        ;here comes the body of the macro
ENDM

Letezik egy masik operator is, ugy hivjak SYMTYPE. Ez IDEAL modban 
mukodik csak, es annyi kulonbseggel, hogy ha a szimbolum nem definialt, 
akkor hibat general.

A leiras megtalahato a TASM User's Guide 2.5-ben (valoszinu a tobbiben 
is).

Idezem a konyv elejet (tetszett):
"You might have heard that assembly language programming is a balck art 
suited only to hackers and wizards. Don't belive it! Assembly language is 
nothing more than a human form of the language of the computer itself ..."

Most pedig egy kerdes:
Hogy lehet a 'Modul is pass-dependent - compatibility pass was done' 
warningot kikuszobolni, ha pl. IFNDEF-et, vagy IFDEF-et akarok hasznalni?

                        G.O.D. / A b a d d o N
############################################################################
  Arrol van szo, hogy az SC_1 PRE valtozataval egy kis problema van. 
Megpedig az, hogy pl. az F-PROT nem hajlando beolvasni a filet. Megneztem 
a headert, de semmi specit nem talaltam benne. Ugyanugy pl. az UNP is 
kiakad rajta. Mit buveszkedtel rajta? El sem tudom kepzelni, de nagyon 
erdekelne ez a kis EXE-trick. Ha one kedved, ird meg, vagy tedd kozze a 
CODER_L-ben ...
                                                   Szabo Balazs
                                                       dLux
............................................................................
 Nos, a helyzet az, hogy az SC kodja eredetileg COM fajlban irodott es
aztan csak utolag kerult ele egy mesterseges EXE fejlec. Megpedig azert,
hogy az adat fajlokat hozza lehessen masolni a fofajlhoz. Igy az egesz
egy fajlban foglalhat helyet, ami egy diskmag-nal elvarhato, elegans megoldas.
Egyebkent erdemes lefuttatni rajta a TBAV-ot is, mert az is nagyon erdekes
dolgokat szokott kiirni a programjaimrol :)

TomCat/Abaddon
############################################################################
Mas: lathattatok, legalabbis azok akik idoben jelentkeztek, a
WildStock95 info textben, hogy a produkcioknak futniuk kell
386sx25-on. Nem tudom mi a velemenyetek, mikor jon el az ideje
a 486-os es a Pentium kodoknak ill. az FPU es a TrueColor hasz-
nalatanak a demokban? (Mikor irhatjuk nyugodtan a kodba, hogy
BSWAP vagy CMPXCHG8?)
Velemenyem szerint ma egy demo vagy intro compon az FPU vagy a
TrueColor hasznalatat megtiltani hulyeseg. Mert igazan itt van
mar az ideje, hogy egy kicsit haladjunk a tech fejlodessel!
Mas velemeny???

TomCat/Abaddon
............................................................................
en egyaltalan nem tartom hulyesegnek. lehet, hogy az sx-et
egy kicsit eltuloztak, de szerintem 386-as kodon kivul mast
hasznalni nem erdemes. ilyenkor szembekerulsz avval, hogy  par 
utasitas miatt nem fut a programod 386-os gepeken.

a koprocesszorrol is hasonlo velemenyen vagyok. minek hasznalni?
ott vannak a szep tablazatok. mondjuk egyszerubb a koprocesszor,
de hova lesz a demoiras szepsege?

a 16 millio szin, meg meg lassabba is teszi az egeszet, arrol nem
is beszelve, hogy az itt elterjedt olcso videokartyak nem is 
ismerik.
de ez csak egyedi velemeny.  en szeretnem, hogyha dolgoztam a 
code-al egy csomo idot, akkor minel tobb gepen le is fusson.
az a par nehezites, amit a tablazatok hoznak igazan nem szamit 
ezek mellett. 
es arrol meg nem is beszeltem, hogy pentiumra minek optimalizalni?
gyors az mindenkeppen. tobben szidjak a dope-ot, hogy milyen
lassu. a kompo gep a versenyen egy pentium volt, ezert jmagic
baratunk nem szorakozott az optimalizalassal.

udv,
rod
............................................................................
Szerintem a technika igenis a nagyobb gepek iranyaba fejlodik, szerintem 
tarthatatlan, hogy a kompogep meg mindig DX/2-66 (a-la WiLDSTOCK'95). Sokkal 
jobb lenne, ha lehetne kooprocit hasznalni.
  A demoiras szepseget szerinted hogyan befolyasoljak bizonyos 500K-s 
tablazatok? Szerintem a legszebb mufaj a 4K-intro! Abban minimalis a 
letarolt tablazatok szama.
  Mellesleg manapsag mar nem ritka nehany VL-s videokartya, ami 
tulajdonkeppen kell is.
  A Dope szerintem egyaltalan nem lassu, nekem 386DX/33-on eleg jol ment 
(na nem az elso part). En speciel orulnek, ha ilyen PHONG-ot ki birnek 
hozni magambol ...
                                                   Szabo Balazs
                                                       dLux
............................................................................
Szerintem nagy fun az FPU-t programozni, es en mindenkeppen a
hasznalata mellett szavaznek (akinek meg meg mindig 386-a
van az vegyen bele 387-et is, aztan meg gyozze kivarni!).

Elmondanam, hogy az ujabb VGA kartyak TrueColor-ban gyorsabban
mukodnek, mint 256-os modban. Persze igaz, hogy 1 pixelhez 3 bajtot
kell altalaban kiirni...
A 16M szinrol esetleg lemondok, ugyhogy mar meg is irtam a sajat
TrueColor emulaciomat, s most a 256 szinu VGA kartyakon is fog
futni minden altalam irt projekt.

De igy egy gyorsabb gepen, csak lassabb programot birsz irni.
Szerintem akinek gyors gepe van, az legalabb hadd elvezze a
sebesseget.

Ha hasznalnad az FPU-t, nem kene annyi idot toltened a code-dal.

Na igen, de ha valaki irt volna egy realtime raytracinget
(amit talan lehetet volna azon a gyors compo gepen, akkor
az siman lenyomta volna a dope-t! vagyis erdemes lett volna
optimalizalni).

TomCat/Abaddon
............................................................................
Azert jo lenne ha valaki koprocis cuccot irna, akkor legalabb 
detektalna hogy van-e ...
Oke egy 4K inroba lehet hogy nem fer bele, de egy 64K introba 
bele lehet nyomni. (Akinek nem inge...)
 
Mondj egy ilyet ! Kulonosen olyat amelyik ezt 3(!) byte/pixel 
modban csinalja ! ( 4 byte/pixel mod az kisse mas. )
Es ird le hogy mennyibe kerul, hadd okuljunk.

Ez igy lassabb lesz, az teny. De, ha egyszer truecolorra van 
szukseg (Pl: raytrace) akkor tenyleg azt kell hasznalni.

A software cegek szerint nem erdemes optimalizalni a progikat, 
mert ugyis a gyors (->draga) geppel rendelkezok jelentik a 
fizetokepes keresletet. 

Ha azonban freeware-t irsz, akkor ez a szempont ki van love ...

Hyp-X /Demons
............................................................................
Lehet, de egy demo/intro projekt eseten nem tartom fontosnak...
(Ezzel is osztonzom a demoscenet, hogy szerezze be a sajat FPU-jat ;)
Es biztos, hogy mindenki detektalja a 386 megletet ?!

Az altalam pribalt kartyak 90%-a 3 byte/pixel modban dolgozott.
(Csak a Miro volt 4 byte/pixel-es, megis lassu volt (!)
Az biztos, hogy az utolso ket kartyam mindegyike gyorsabb truecolorban.
SkyEagle kb. 17000+Afa
SIS PCI  kb. 20000+Afa
(Ha kell pontositom az arakat).

TomCat/Abaddon
............................................................................
Hadd szoljak bele egy picit en is ebbe a vitaba (koproci+16M)
1. Tok foloslegesen vitatkoztok...
2. A gepek fejlodni fognak, es ujabb+ujabb hardware-eket kell/lehet hasznalni.
3. Egy ido utan minden ujdonsag elterjed es mindenkinek lesz (koproci is) es
   ekkor mar mindenki tudja majd hasznalni az erre irt progikat.
4. Az hogy ki mikor kezdi programjait az "uj " hardware-re irni, az maganugy es
   a programozotol fugg...
5. Ha vki tul hamar kezdi az uj hardware-eket hasznalni, akkor ugy jar mint a
   Microsoft, a software-hez kell a hardware-t igazitani...
6. Ha vki tul keson kezdi az uj hardware-t hasznalni, akkor lemarad a vilagtol
   merthogy rengeteg idot elpocsekol olyan rutinokra, amiket mar vmi hardware
   kiegeszito segitsegevel rohogve meg lehet valositani.

7. Az optimum (se tul keson se tul hamar) mindenkinel mashol van...

Ennyi. Ha meg most is olvasod ezt a sort akkor mar majdnem vege van..
Egyebkent szerintem a koproci mar elegge elterjedt..

                                        Syg.
............................................................................
Tokeletesen egyetertek. Talan meg azt hozzatennem, hogy ez nem veszekedes
hanem inkabb szakmai vita volt. A ketto kozott az a kulonbseg, hogy itt
nem az van, hogy nekem igazam van te meg hulye vagy (ld.parlament),
hanem minden allasfoglalasban van igazsag es ez segit a sajat igazunk
formalasaban. A mas igazsagat is elfogadom es nem sertodok meg, ha
valaki a dolgot maskepp latja...
Masik eszrevetelem, hogy a Microsoft lepaktal a hardvergyartokkal:
vagyis rogton hasznalja az ujdonsagaikat, igy tobb uj hardver fogy
ill. ujabb szoftver verziok jellenek meg, ami pedig neki bevetel.
S vegulis, ez osztonzi a fejlodest. A baj csak az, hogy a fejlodes
arat mi fizetjuk meg, es azt, majdnem csak egy zsebb-be, a Microsofteba.
( Es hiba bosszankodunk, hogy a Microsoft termekek itt sz'rok, meg ott
sz'rok, mert ot, a monopol helyzetebol kibellenteni, a meglevo nagy
elonye es tokeje miatt, szinte lehetetlen...)
Meg a monopol helyzet se lenne baj annyira, ha Microsoft arra
is odafigyelne, hogy jo termeket keszitsen, s nem csak arra, hogy
minel tobb suskat beszedjen maganak...

TomCat/Abaddon
############################################################################
 Kerdezek. Az az igazsag, hogy VESA-val eddig egyaltalan nem foglalkoztam, 
ugyhogy csak nagy vonalakban tudom hogy hogy megy a dolog. Mennyire 
lassitja le a lapozgatas/vesa rutinok hivasa a programfutast ?

                                                Elore is koszike : Paf
............................................................................
Nos a vesa hasznalata a video mod bekapcsolasa es a memoria lapozason kivul
nem ajanlott. A video mod bekapcsolasa altalaban csak egyszer fordul elo
egy programban, az elejen. Tehat kvazi mind1 milyen gyors.
A lapozasok aranya is meglehetosen keves a memoriaba irasokhoz viszonyitva,
tehat az a par ciklusido amit a driver mellozesevel erhetnek el, az nem
eri meg, mert elvesztjuk a kompatibilitas lehetoseget. Tovabba a VESA
biztositja szamunkra a lapozo rutin (FAR tipusu) kezdocimet. Amit
hasznalva mar igazan nincs ok idovesztesegre...
A tobbi VESA funkcio hasznalata nem ajanlott, mert a VESA drivereknek csak
szukebb hanyada tamogatja.

TomCat/Abaddon
............................................................................
        - Nem tudja valaki, hogy kell az Ark Logic 1000 kartyat
          SVGA-ban lapozni NEM VESA-val?

Ez a kartya ugyanis (ezt uzenem Paf-nak is) VESA-val lapozva idozitest vegez
lapozas elott (megvarja, mig a raszter odaer, vagy ilyesmi) igy NAGYON 
LASSU a lapozasa. (Pl. ha mondjuk ferde egyenessel akarom letorolni a 
kepernyot, azt max. egy bizonyos sebesseggel (bar szep siman) tehetem 
meg...) Egyebkent van valakinek egyaltalan meg ilyen kartyaja rajtam 
kivul? Ha nincs, akkor sajnos nekem magamnak kell kidebuggolnom a 
lapozast a BIOS-bol... :-(((
                                        sTINYO
............................................................................
A VESA driver megmondja a lapozo rutin cimet:
MOV CX,101H (Ez a VGA mod szama 640*480*256 minden kartyan van)
MOV AX,4F01H (Infot kerunk a VGA modrol ES:DI-re)
INT 10H
Na most ES:[DI+0CH] cimen talalhato a lapozo rutin cime (SEG+OFFS).
Aztan DEBUG a lapozas...
Itt BX hatarozza meg, hogy az irasi vagy az olvasasi ablakot szeretnenk
valtani. Ha jol emlekszem akkor pedig AX tartalmazza a kivant lap szamat.

TomCat/Abaddon
############################################################################
Mi az a linearis frame buffer? Csak sejtem mire gondolsz. Erre nincs
altalanos Vesa funkcio, ilyen szinten nem lehet a VGA kartyakat programozni
Vesan keresztul.

TomCat/Abaddon
............................................................................
Nos ez arra valo, hogy a teljes videomemoriat lekepezi valahuva a memoris 
felso reszere, es ebben az esetben nem kell lapozgatassal tokolni, hanem 
linearisan laccodik az egesz.- gomdolom en.
Home'r :-)
............................................................................
A VESA 2.0 szabvany mar tamogatja.
De.
Nincsen rola valakinek leirasa ?

(Egyebkent az UNIVBE csinal VESA 2.0 -t.)

Hyp-X /Demons
............................................................................
leftpzheted, az univbe 5.1-et,ami tud vesa 2.0-t a teeri.oulu.fi-rol
a pub/msdos/programming/scitech/uvbe51a.zip
udv,
rod
............................................................................
 Ha mar ennyien kerdeztek : a linearis frame buffer azt jelenti, hogy a 
grafikus kartya a vram-ot egyben teszi lathatova. Igy a memo linearisan, 
egyben cimezheto, amit ugy kell elkepzelni, hogy pl 64M-tol 1,2,4M-an 
keresztul ( kinek mekkora a vramja ) egyben lathato a video memoria, igy 
lapozas nelkul elerheto az egesz. ISA busz eseten az elso 16M-ban van ez 
a terulet, tipikusan 14M-tol. Amit kuldtem S3 forrast, ha valaki 
belenezett lathatja, hogy hol allitja be a kezdocimet es a hosszat...

                                                                Paf
............................................................................
Unit S3  Version 2.00  01.01.1995  Copyright (c) 1993,95 Dietmar Meschede

The main purpose of this unit is to set up a 320x240x256 or
640x480x256 video mode with a 1 MByte linear address window.

The unit requires a S3 86C928 (or better) graphic chip and
runs only in proteced mode.

unit S3;

{#Z+}

{ S3  Version 2.00  01.01.1995  Dietmar Meschede }
{                                                }
{ Copyright (c) 1993,1995 Dietmar Meschede       }
{                                                }
{ Use at OWN risk!                               }

{#Z-}

{ The main purpose of this unit is to set up a 320x240x256 or  }
{ 640x480x256 video mode with a 1 MByte linear address window. }
{                                                              }
{ The unit requires a S3 86C928 (or better) graphic chip and   }
{ runs only in proteced mode.                                  }

{$DEFINE PROTECTED}
{$I STDUNIT.OPT}

interface

uses
  NewFrontier, VESA;

var
  S3VideoLinearAddress: Longint;
  S3Video, S3Video32: TSelector;

const
  SETUP_OS  = $0102;
  SETUP_VSE = $46E8;

procedure UnlockS3Regs;
procedure LockS3Regs;

procedure S3Init320x240;
procedure S3Init640x480;

procedure DoneS3;

procedure S3SetStartAddress(Start: Longint);

implementation

{ Linear Address Window Control Register (CR58):      }

{ Bits 1-0: LAW-SIZE - Linear Address Window Size     }
{           00 = 64 KB, 01 = 1 MB, 10 = 2MB, 11 = 4MB }
{ Bit 4:    Enable Linear Addressing                  }

{ Linear Address Window Position Registers (CR59-5A): }

{ Bits 9-0: LINEAR ADDRESS-WINDOW-POSITION            }
{           Linear Address Window Position bits 25-16 }
{           LAW-Size = 1 MB: bits 19-16 ignored       }
{           LAW-Size = 2 MB: bits 20-16 ignored       }
{           LAW-Size = 4 MB: bits 21-16 ignored       }

procedure UnlockS3Regs;         { Enables access to all S3 registers }
begin
  WriteReg(CR, $38, $48);
  WriteReg(CR, $39, $A0);
end; { UnlockS3Regs }

procedure LockS3Regs;           { Disables access to extended S3 registers }
begin
  WriteReg(CR, $38, $00);
  WriteReg(CR, $39, $00);
end; { LockS3Regs }

procedure S3Init320x240;
const
  CrtRegs: array[0..$18] of Byte =
             ($5F, $4F, $50, $82, $54, $80, $0D, $3E,
              $00, $41, $00, $00, $00, $00, $00, $00,
              $EA, $2C, $DF, $40, $40, $E7, $06, $A3, $FF);
var
  i: Byte;
begin
  SetVideoMode($13);                            { Init VGA Mode 13h }

  WriteReg(SR, $01, ReadReg(SR, $01) or $20);   { Turn screen off }

  Port[MISC_WT] := $E7;                         { Init Tweak Mode 320x240     }
  WriteReg(CR, $11, ReadReg(CR, $11) and $7F);  { with logical line width 512 }
  for i := $00 to $18 do
    WriteReg(CR, i, CrtRegs[i]);
  WriteReg(CR, $11, ReadReg(CR, $11) or $80);

  UnlockS3Regs;

  WriteReg(CR, $31, $8D);       { Force Enhanced Mode Mappings  }

  WriteReg(CR, $54, $01);       { Read Ahead Extra Prefetch = 1 }

  WriteReg(CR, $58, $00);       { Disable Linear Addressing (!) and other }

  WriteReg(CR, $59, $03);       { Linear Address Window Position = 3000000h }
  WriteReg(CR, $5A, $00);

  WriteReg(CR, $58, $1D);       { Enable Read Ahead Cache & Linear Addressing }
                                { Linear Address Window Size = 1 MByte        }

  LockS3Regs;

  FillChar32(Ptr48(S3Video, 0), $10000, 0);     { Clear S3Video memory !!! }

  WriteReg(SR, $01, ReadReg(SR, $01) and $DF);  { Turn screen on }
end; { S3Init320x240 }

procedure S3Init640x480;
begin
  WriteReg(SR, $01, ReadReg(SR, $01) or $20);   { Turn screen off }

  UnlockS3Regs;
  WriteReg(CR, $58, $00);       { Disable Read Ahead Cache & Linear Addressing }
  WriteReg(CR, $59, $00);       { Linear Address Window Position = 00A0000h }
  WriteReg(CR, $5A, $0A);
  LockS3Regs;

  SetSuperVGAVideoMode($101);                   { Init VESA Mode 101h }

  WriteReg(SR, $01, ReadReg(SR, $01) or $20);   { Turn screen off }

  WriteReg(CR, $13, $80);                       { Logical line width 1024 }

  UnlockS3Regs;

  WriteReg(CR, $40, ReadReg(CR, $40) or $08);   { Enable Fast Write Buffer }

  WriteReg(CR, $58, $00);       { Disable Linear Addressing (!) and other ... }

  WriteReg(CR, $59, $03);       { Linear Address Window Position = 3000000h }
  WriteReg(CR, $5A, $00);

  WriteReg(CR, $58, $1D);       { Enable Read Ahead Cache & Linear Addressing }
                                { Linear Address Window Size = 1 MByte        }

  LockS3Regs;

  FillChar32(Ptr48(S3Video, 0), $10000, 0);      { Clear S3Video memory !!! }

  WriteReg(SR, $01, ReadReg(SR, $01) and $DF);  { Turn screen on }
end; { S3Init640x480 }

procedure DoneS3;
begin
  WriteReg(SR, $01, ReadReg(SR, $01) or $20);   { Turn screen off }

  UnlockS3Regs;
  WriteReg(CR, $58, $00);       { Disable Read Ahead Cache & Linear Addressing }
  WriteReg(CR, $59, $00);       { Linear Address Window Position = 00A0000h }
  WriteReg(CR, $5A, $0A);
  LockS3Regs;

  SetVideoMode($03);            { Init Text Mode 03h }
end; { DoneS3 }

procedure S3SetStartAddress(Start: Longint);
begin
  Start := Start shr 2;
  UnlockS3Regs;
  WriteReg(CR, $0D, $00);
  WriteReg(CR, $0D, Byte(Start));
  WriteReg(CR, $0C, Byte(Start shr 8));
  WriteReg(CR, $31, (ReadReg(CR, $31) and $CF) or (Byte(Start shr 12) and $30));
  WriteReg(CR, $51, (ReadReg(CR, $51) and $FC) or (Byte(Start shr 18) and $03));
  LockS3Regs;
end; { S3SetStartAddress }

var
  SaveExit: Pointer;

procedure S3Exit; far;
begin
  ExitProc := SaveExit;
  FreeDescriptor(S3Video32);
  FreeDescriptor(S3Video);
end; { S3Exit }

var
  Rights: Word;

begin
  S3Video := 0; S3Video32 := 0;
  SaveExit := ExitProc;
  ExitProc := @S3Exit;
  S3VideoLinearAddress := PhysicalAddressMapping($3000000, $100000);
  S3Video := CreateDescriptor(S3VideoLinearAddress, $100000);
  Rights := GetSegmentAccessRights(S3Video);
  Rights := (Rights and $FF70) or $0093;
  SetSegmentAccessRights(S3Video, Rights);
  S3Video32 := CreateData32Alias(S3Video);
end. { unit S3 }
############################################################################
> Aktualis munka : objektum orientalt ablakozos rendszer assembly-ben
Ha van valami preview/doksi/tanulmany, kuldd mar el... (ugy ertem,
a rendszeredrol).
Nemsokara elkezdek egy esemeny-kozpontu rendszerecsket irni (C-ben, egy
prg kornyezetekent), ami egyben elotanulmanya lesz egy hasonlonak, amin te
torod magad. Nem egyedul fogom csinalni, ezert vagyok kivancsi mas dude-k
otleteire is.

ERN0
............................................................................
Itt van Ern0nek (meg meg akit erdekel) az ablakozos cucc. A
magja mar kesz van, de meg egy csomo objektumot kell hozza 
irni, hogy jol hasznalhato legyen. Amit most tud : exit-re 
clickelve kilep. a win-re clickelve lenyit egy ablakot, 
amiben a kov. objektumok vannak ( a desktop felepitese egy
lista alapjan tortenik, ahol fel van sorolva par alap dolog,
pl mouse sprite neve, wallpaper neve meg ilyenek. Ezutan egy 
objektumlista, ezek konstruktorai szepen meghivodnak sorban,
aztan az ablakozo var, es figyeli az egeret ) :

Kill_Button : leoli az ablakot ugy, mintha Cancelt nyomtak
              volna
Title       : az ablak neve, raclickelve es nyomva tartva 
              mozgathato az ablak
Text_Bt_NW  : uj ablak nyitasahoz hasznalt gomb, ebbol harom
              is van
Text        : szovegobjektum, formazo utasitastassal. A 
              gombokat lenyomva ez demonstralodik. 

A win-re tobbszor lehet clickelni, mindig lenyilik egy uj 
ablak. Ha hatulsora clickelunk akkor az kerul az eloterbe.
Max 31 ablak nyithato, mert ekkorara van valaszva az ablak
tabla merete.
A futtatashoz csak HIMEM.SYS legyen bent, diskcache nelkul.
Sorry, de nemigen volt idom fejlesztgetni az extenderemet.

Remelem teccik! Ja, a szurke doboz a kep tetejen majd a 
valaszthato menupontokat fogja tartalmazni ( file, edit, stb )

                                        Udv mindenkinek : Paf
............................................................................
Kiprobaltam az ablakos dolgodat, de nem nagy sikerrel.
Az eredmeny [P90, magyar Win.3.1 HIMEM.SYS-jevel]:

ILLEGAL INSTRUCTION in V86 mode

TomCat/Abaddon
............................................................................
TomCat-hez hasonloan en is kiprobaltam Paf ablakozo proggyjat
[i486 ill. P100, DOS 6.22 ill. Win95]  nekem nem allt
le vedelmi hibaval a rendszer, ellenben hiaba toltogettem mindenfele 
egerdrivereket, nem moccant, ill. kilepett DOS-ba... Most jut eszembe, 
lehet, hogy Win95-bol is DOS-t bootoltam, talan ezert nem volt hibauzenet...

                        sTINYO
............................................................................
1. Az eger drivereket nem erdemes toltogetni, mert sajat pm egerdrivert 
hasznal a proggy. A com2-n. Ha a com2-n volt az eger, es ugy sem ment, 
akkor az azt jelenti, hogy mas formatumban kuldi el az eger a 
valtozasokat. A PCGPE1.0-ban volt szo errol. Abban ugy volt, hogy az eger 
3 byteot kuld el minden mozditasra/nyomasra. Nos az enyem 5 byteot kuld, 
szivtam is vele eleget, mire rajottem. Ha esetleg errol van szo, irok 
megegy drivert, aztan lehet valasztani. Remelem azert nincs 2-nel tobb 
verzio...

2. az ILLEGAL INSTRUCTION in V86 MODE nekem olyankor szokott jonni, 
amikor disk-cache van bent, es az XMS-t akar masolni a rom-bios 
segitsegevel. Amikor a bios megprobal pmode-ba lepni, nyilvan kivetel 
keletkezik. 13-as, hogy pontosak legyunk. A kivetelkezelo megnezi, hogy 
v86-modban tortent-e. Ha igen, akkor az akt. utasitasnak INT xx-nek kell 
lennie, kulonben a fenti hibauzenetet kapjuk. A dolog persze egyszeruen 
megoldhato, emulalni kell az XMS masolast, csak meg nem volt idom ( meg 
kesztetes sem ) megirni. Majd erot veszek magamon...

                                                Addig is ... Paf
............................................................................
Disk-cache nem volt benn, de RAMDRIVE.SYS az igen es onnan probaltam
inditani... Az is baj?

TomCat/Abaddon
............................................................................
 Szerintem igen, mert a ramdrive XMS-t hasznal, ugye ? Nem problema, 
megirtam az xms copy emulaciot ( int 015h, Fn 087h ), nalam mukodik a 
smartdrive-val. Ha nincs bent a HIMEM.SYS, akkor is elindul, de 
csak a conv memot latja.
 Atirtam az egerkezelot, most mar felismeri, hogy a com1-en vagy a 2-n 
van az eger. Egyenlore csak 3 gombos egeret kezel, a ketgombossal elszall.
 Elkuldom az egeszet ujra, hatha nincs meg mindenkinek, es a sprite-ok 
nelkul nem sok latszik belole...
                                                Remelem mukodik ... Paf
begin 644 asmwin.arj
M8.HJ`!X&`0`0``)Q<9])'W&?21\``````````````````$%335=)3BY!4DH`
M`%U5#C@``&#J*0`>!@$`$`$`<0*8\AX7````2````/E:J'T``"````!#2%)?
M(2Y34%(``&#E/#(````+.$U-210_G'0'!L!(Q#0<`W<+]UW<8.HI`!X&`0`0
M`0!Q!9CR'A8```!(````L:)=0```(````$-(4E\C+E-04@``BHF9\@````P[
M:6G)MJ:.3R-)`-S($!0#D7+;]V#J*0`>!@$`$`$`<0B8\AX>````2````-<Y
M\]D``"````!#2%)?)"Y34%(``'@G360````21&V).%^0VN,P[B`G8:3>`>MQ
M+Y.5NO.X8:N>;F#J*0`>!@$`$`$`<1R8\AX9````2````(2PKG0``"````!#
M2%)?)2Y34%(``&[#[`P````/.&U)2`,=W'2\#QP&4'@':+#7:>M%]D!@ZBD`
M'@8!`!`!`'$-F/(>'````$@````+F7E$```@````0TA27R8N4U!2```D/C*'
M````%#IQ44.7'<XZ/(+#'`+;=`8@K)6].9V7^CON8.HI`!X&`0`0`0!Q")CR
M'A8```!(````?2*UK0``(````$-(4E\H+E-04@``]JS<J0````LX34G%V#LY
M$;@P7*@DJ`M)-7WV`&#J*0`>!@$`$`$`<0"8\AX5````2````-TG968``"``
M``!#2%)?*2Y34%(``&[/W64````..$QA**]#<Y(6%HH"*HRDAV/>H&#J*0`>
M!@$`$`$`<0)H\1X3````2````)B*7-T``"````!#2%)?+2Y34%(``/PA.;,`
M```*.TQAJ/9#]<CX>AHR#!OS*>!@ZB@`'@8!`!`!`'$`8/$>#P```$@```"G
M^<'@```@````0TA27RY34%(``/[GE!0````&,&A-3YR0Y.">&0<+X&#J*0`>
M!@$`$`$`<0N8\AX;````2````$TH#BL``"````!#2%)?,"Y34%(``'%R01(`
M```2.XV,PK]QJXP-(/`4'(`I!3UTU9:Z_UMW[F#J*0`>!@$`$`$`<0*8\AX9
M````2`````7R+DP``"````!#2%)?,2Y34%(``"'!AC`````./&UPQ[:&KC/Y
M"3QV$D'0&&\NL]?W9X!@ZBD`'@8!`!`!`'$"F/(>&P```$@```!\=HY-```@
M````0TA27S(N4U!2```)*E\C````$#AQA4+^QW.0EA'0:;>@*3$''T-YGN.N
M_@!@ZBD`'@8!`!`!`'$#F/(>&0```$@```#_Q]!1```@````0TA27S,N4U!2
M``"D>+DP````#SAQ4,6F-SD\FP=!IMV!)*@:=1C_G7?<8.HI`!X&`0`0`0!Q
M?9?R'AL```!(````$G'@,```(````$-(4E\T+E-04@``+%]$`P```!(X47##
M?T;G)A`@&@*<J2*\!M%TG)OQF_V`8.HI`!X&`0`0`0!Q`YCR'AL```!(````
M2]HDA@``(````$-(4E\U+E-04@``:TA+[P```!$X<8C"_8W.2DP!T&@G8"TI
MB<9KF3?'SSV`8.HI`!X&`0`0`0!Q!)CR'AP```!(````V0]!I```(````$-(
M4E\V+E-04@``E7A:J0```!-$3(&G#OP;')>5`P"9AMFA+/233/GS-7UK>&#J
M*0`>!@$`$`$`<0&8\AX6````2````'8:J/\``"````!#2%)?-RY34%(``#P;
MP^X````-/%""&.<C:Y'XC6"((V,ZI):^7L!@ZBD`'@8!`!`!`'$#J/0>%P``
M`$@```"4DRH(```@````0TA27S@N4U!2``#IK4E9````#3A,8!BW1LXQ*2C,
M%A2+2*V>U^?KP&#J*0`>!@$`$`$`<0J8\AX;````2````%=Y+!4``"````!#
M2%)?.2Y34%(``(<+6+,````0.VUI13M,SC0@VD["030#(9NC>9>WO'SV8&#J
M*0`>!@$`$`$`<028\AX;````2````&VHJ\8``"````!#2%)?0"Y34%(``&IV
M/-8````1/&V,Q7]#5QL[$H=A)A4`R"O8W%>\G&\.P&#J*0`>!@$`$`$`<0MH
M\1X8````2````)W.RGL``"````!#2%)?7BY34%(``+F2DB`````-.VEM2+>F
MCC>S`(3(-)X!=TD6Z%1X^&#J*0`>!@$`$`$`<05X\1X6````2````"N]D5@`
M`"````!#2%)?02Y34%(``$!VGG(````-.$Q@&.]&SC"96,P4'(M(K97.^/1@
MZBD`'@8!`!`!`'$&>/$>&````$@```!5^6>P```@````0TA27T(N4U!2``!A
M!SF&````##MQA<6_4W.0J)%3&8+"0#3GI_/SV\!@ZBD`'@8!`!`!`'$%>/$>
M&0```$@```"Z,.'\```@````0TA27T,N4U!2``"GR=T"````$3A,@AD'?&SC
M$+`,=@H!T,27MKD^]]X`8.HI`!X&`0`0`0!Q!GCQ'A0```!(````Z6ME@0``
M(````$-(4E]$+E-04@``S_LU;`````LP;49=,;N2<+#L%`.@*1VON]Q@ZBD`
M'@8!`!`!`'$$>/$>&0```$@```!A8//4```@````0TA27T4N4U!2``"Q!7I\
M````$3A-341>'9R=!H2,PT#@%\CK8[;3>?GP8.HI`!X&`0`0`0!Q`7CQ'AH`
M``!(````PG7V20``(````$-(4E]&+E-04@``%1YB70````\[36U$<AM<GP/D
M0DR"06@1F)+$MNW[]8!@ZBD`'@8!`!`!`'$%>/$>&@```$@```#P23,````@
M````0TA27T<N4U!2``"N=R::````$3ML@AB7*;.3X17'82;=B$J2,V[G[/Y9
M[&#J*0`>!@$`$`$`<0)X\1X5````2````-0;^_4``"````!#2%)?2"Y34%(`
M`(Y?B7<````,.$U)QI@[.1Y\!S($!4!23+?_R&#J*0`>!@$`$`$`<0%X\1X1
M````2````"'B%8<``"````!#2%)?22Y34%(``&RZ";\````),&U&<UC=QG$0
MB!4`S9?X8.HI`!X&`0`0`0!Q%WCQ'A,```!(````JB@9N```(````$-(4E]*
M+E-04@``-'4:)P````PP;49C6-W(<,BH)*`5T7VN\&#J*0`>!@$`$`$`<0MX
M\1X;````2````)%`+1X``"````!#2%)?2RY34%(``$-"M5`````2/)&(PG[3
M<XXP!@$6X`FB6V4Q2+7[Y_ZL`&#J*0`>!@$`$`$`<05X\1X3````2````/%]
M>)H``"````!#2%)?3"Y34%(``"FD10L````-.&AMJ:70T<G`ZD0*X94?^@!@
MZBD`'@8!`!`!`'$">/$>%@```$@```!?#3_Y```@````0TA27TTN4U!2```3
M>XNJ````$#A,82C/0[.1B86(@C@O):I-'-[`8.HI`!X&`0`0`0!Q$WCQ'A(`
M``!(````?12B'0``(````$-(4E].+E-04@``V'@RM`````HP;49G,;N2<-B(
M%4!2-OZ`8.HI`!X&`0`0`0!Q!'CQ'A<```!(````@0JA=P``(````$-(4E]/
M+E-04@``;;AI_0````P\B((99S3^<8Q!(=@H!P8E7MKWO<!@ZBD`'@8!`!`!
M`'$">/$>%P```$@````FXA2K```@````0TA27U`N4U!2``#'Q8-X````#3A0
M8AC&1N<GH4289@H.Q%4V7SO=]F#J*0`>!@$`$`$`<3IX\1X<````2````(?W
MQOP``"````!#2%)?42Y34%(``+.,ZSP````00%"!-1CX.YQKL'$QV$F%T4G)
ML;Y:_H]KS@!@ZBD`'@8!`!`!`'$%>/$>%P```$@```#!AJ`L```@````0TA2
M7U(N4U!2``#H.J\_````##MQA<6_4W.0J)%3&8*#0#3GI>?[U&#J*0`>!@$`
M$`$`<@IX\1X<````2````)>PE]8``"````!#2%)?4RY34%(``/M2[2X````1
M0G"!IQ#]#><E"H,/'@:(F":>G2E9H<7[OV!@ZBD`'@8!`!`!`'(`>/$>%```
M`$@```#O8C9"```@````0TA27U0N4U!2``!+!+_=````##AH82E_L:.28"T5
M!)0:V4[)]F#J*0`>!@$`$`$`<@-X\1X3````2````#^=T,,``"````!#2%)?
M52Y34%(``,,'VZH````,.&AA*:=QHXV`[$0*HY2>[-!@ZBD`'@8!`!`!`'(2
M>/$>%````$@```#W3.%L```@````0TA27U8N4U!2``!`&1)9````#3!I9EG8
MTXQ!00`E@5$NV;RS@&#J*0`>!@$`$`$`<@-X\1X7````2````#TBB88``"``
M``!#2%)?5RY34%(``!WEQ+T````//%%-1I0[W'KL3"Q$$<`WBT<WW/(`8.HI
M`!X&`0`0`0!R`WCQ'AL```!(````NUY0%P``(````$-(4E]8+E-04@``YE+&
M'P````\Z<8E#O<=SCI$L,1P$D%0&$2XVC:5V_YYO8.HI`!X&`0`0`0!R`'CQ
M'A<```!(````,`6GM```(````$-(4E]9+E-04@``M[A-(0````T[48E%O0WG
M'3DNT4!%,#:)=<$5[[!@ZBD`'@8!`!`!`'((>/$>&````$@```"\'JZC```@
M````0TA27UHN4U!2``!^A#CF````#CQ0@AC7(VN1^(%HZ#(#L9JI):_7.>Y@
MZBL`'@8!`!`!`'((:#H?*````.D```!?65Q2```@````15A)5#%?,2Y34%(`
M`(EKV<P````;0Y&.&[=)<>M;GE_`0:5!W'#)@#-OT23O*&MG;0H\H[VF_WIN
M0_!@ZBL`'@8!`!`!`'(3:#H?*````.D````0+VY(```@````15A)5#%?,BY3
M4%(``&ST>Y8````;1(V.&[=EV*C<\OZ#!"H.XX9,`9M^B2=Y0UL[:%'E'>TW
M^]-R'X!@ZBP`'@8!`!`!`'(@@/`>+````)@```"7;/^%```@````2TE,3$)4
M7S$N4U!2```'LENW````'$*2:46T.Y(O;KFA1X(N*0A89+D`+W5V)F1E[AF*
M#?%">GL3[M_^G6NU0&#J+``>!@$`$`$`<BM@#A\L````F````$+?XGD``"``
M``!+24Q,0E1?,BY34%(``)70`A,````<0I)I1;0[DB]NJV%'@N20@@HYL`0^
M8:H:)EQ3,DS*K4W:P^OVW_T[YVL`8.HL`!X&`0`0`0!R!%`V'QX```!(````
M*XBP3@``(````$U/55-%,5\Q+E-04@``-K+_Y````!9$<4@H09+">WVEZ.PT
MF^`2W0D1\73?JVDO16@`8.HL`!X&`0`0`0!R+E`V'QX```!(````$U.#@P``
M(````$U/55-%,5\R+E-04@``*C6'$0```!-$<88X1T2P6M\,OG082?@'JH(8
MIE9T>=^Z1[W`8.HJ`!X&`0`0`0!R)P!!'SD```",`P``8XE6XP``(````%=!
M3$Q0,RY34%(``"&QQ%L````:0FYM5K4$M#OH#:A$GX^!H#86A(8GH*V(`0PY
M@`:[G\JYUIN,:;C&FXQN[NVK%;:MOMJ])\;7H&#J*@`>!@$`$`$`<@JP11\K
M````Z0```.Y`*D8``"````!724XQ7S$N4U!2``!M,)[T````(TA-BC=U0$;M
M&Z^H6A5IV$FW\DH0(8T@R&-KCC>$;PXQ=P/?#N.W?Q>@8.HJ`!X&`0`0`0!R
M`K!%'RL```#I````NW+@10``(````%=)3C%?,BY34%(``*/+AX`````C3&V)
MMW4X4?FW2`BS*M.PDV_DE"!#&D&0QM<<;PC>'&+N![X=QV[^+T!@ZBH`'@8!
M`!`!`'*PGDD?]R(``(9*``"OC(SQ```@````05--5TE.+D5810``0WP#?P``
M&\6&WOW:I*6?[]SGWW`^`YPYR8%)0'A7)QH91!&9`8$%`E4X@HB*HBG.(&$*
MASY0JK.$%V.'U-9=S.YM8V]2YG;&LLR<HR16K`>9B*T4K98M-4JLW[CQJ561
M54^___]]]P!6:G;-SN=MS=\W=[F^;YO?-[WN[O?-]/?2WT-]3?X";YOO;YO\
M:Z'>T;;DDDOLI0_S$PA+^1F3-GIINCR+"&_8X/JPG-:T]43^'X4RM#["!]KP
M^_SA]_.!2Y#[P@^X8XA/0#[3A]]P/L$>0BY<0G(#ZM@"$N@CA`C[E98$M5M@
M2!.L"1L%8$^S]_\_6I":C=>!;._P0%K8$U%L7#D+/$+1$+^8A7I"P:PLPL+E
MUA?=.+V:Y[WZXOOKB\=<4Z`U7]$!:9.YC-3J:#KTV+7QPB)Q)0G$<,M30,"<
M02'C@1<+'FO_#`/8N`8K-YY2PB(#>M`/6,`W],7XWM^">W_38&!^$]N$BX,C
M?8;]`1]^>WC7C>4"TP2J6/&[77L8$OEKF^O$@7R5VOD($OX5S>A"#7Y*!>^D
MN@+4DO<XB3<N("0W>H>/EUJR`9U%^'`>!`>)`6A&]?CO#@".(),",H0ZJ0@7
MFOHH%[WR[7UL"]^XNM$%$!%<WD+9\O%%;L=;;-[?>0;?":)VA"D(\`"OE!!(
MXCK2"`5*'$5O;\*#%/=7_[T!:&64MB"NR2>-XVX%<D_F7("T.%%>-UF+Q:`%
MW4HT%C)7#OA0+OC0+>W*R\CAP/D<B!;I;)WS(%VM0,2YT#Y!Z#>U\4+H6HW@
M.`]W@5#$2AKB'ECEK>U=7AM5]4`-C7<HA>K`Y[5Z<=QR"J!EQ?,AM&]FS0;I
M1;1!O2:)T?<FJ;`&)N3Q!EF]=RQOU([VDN`O68\X(D"38Q,B-1BB"9D8F9,\
M,6%(V&*.)4#%C"58Q2I.X&*:)8#$U(D,5`3[XQ9\G](Q4I/*&+2$JUP15A.X
M&)R3O!BL2=Z,1%FE0%^K/!((I^]@1%/X0Q,C^.,40?SAB9GKA2<*?"C%''X`
M8L8>S&*5/[`8IH^/&)J?)#%0'S`Q9\_*#%2GSXQ:0^B&*L/I0IZS2Z\I!2VS
M>-W(U=P[4*07=^4J)AD`D*A2L]=I&9=4,H&Y*4E)LH"E9IM[7/P/S5.3`T]K
MB,@A`6:&JHC(M*16X.HB8842U(YA'Y".A37M`!<0IHJQ2)RI%W1HKA=8!&Z/
M$'2#9T6!;6L_P0!GZ"+A1M)1]M(;NDL8&7FT>6\;VJEW6\DXO%[["@6A#MWS
M>Z>,1M<A<D>,F]?O^(W.&V@E%&M_U_-(X9BILC7#7T)U$Z#MG"$?;!.Y8I.[
M%0IHTHHTX(W=#27%'J7!P#.7&D!;E/"C($9@8U;O0;=N_;=N#;WO$+V:=]=;
MD'Z\RZ2\A^]>Y5VWM="A\U34,I4T>I*N(-4TLM]Z<7:W8$+-67ARX]0!WC%(
M[.3?F$%3$J--',X$9Y'BP'`L_(\:`+CB;!S8EA2:KQ8#@QFJ\:`X-F6-!!UG
M5<%GP=45F2R><&,LK@"L.36'\&,UBT`H,FL6<&,`!81Y:D9S2//><QBLB\.@
MQ67_%(,6=LWK]FL8];;<(A$"<S8,R:@,0'4;_4/M1['D?T!B\Q>%41-Y=BB<
MD+8H8%.HVS?T1J,-D`:C>:@IL?][%\S8(:0M2G>R?UC,9-=+#`/4PP+TDRM&
M"08?XEK0V(:\M(*YC'C>=;AB&>G!@A!@R2&X;W7)G99O"6R/'H7.QCK1;<QD
MVC\K>A>%VR=JF&2;W^[OLIJ#89>EIJMGI*K1Z*JH^W9U+9M25;/&1TAC,6ST
M=4SI:;14K:J9N-&S;5C;0HN&T9!L&@J39G+M<PS!8HZBJ;4=)6LZ:I9SX*?;
MZ.D;1C-K4-J.K;,PATS9G-3>4R&4P\]FIYGHZFHK<.9@971N&;:IT:.BI6>A
MT=3IFU2XIM'4T=0S[=MV^CJJT7(ST%:X;59I'MJ1G1U-(9=9OR]'IJ.FJ*/0
M5#91GT&4GF<Q54VF"5=2#:;Z-&II(R\,S\AAXZ.OIG*-2,Z<B02O[WSW^['^
M\-_28FF$'C>NI'XBL?C*E_$?Q^NHF.@'.$>5)KX$;C:HY$X$8>U)O(%^UV^'
MLXA>:R%;!9$[*+$.'ZT(?1&YZQ)%,P#YJ44.#C7/*XU@CT_18$)^G%A`VLCI
M-@XQDN,;-QR@#PUW;YE0K@@(P%C`S,N^^390))F@=0%?LCW/+956W?0*I!TP
MM08@"<)E)C;[<\Y8BN>ZP'(YYRT`?),"N`'4F!@KP'`@#YI@<0`/ZS`R8`[(
MP,H`/HF!QR*U]H7/.[4"&O,0E0!06"#CP!:F!R8`SY@<J`,\8&<`&M,#FP85
M4WM3B4[*Y9^/:06OYH4(W,8E#-"H0`X[@V^*>,`V][@%!KEIU+:V750>X<0=
MHM,6EGW$H<U0/<Z!R==0^3"DBX7#C]CDH!I#V1D2A>R@'TC'GL>`1<D,`JCW
MK@@RTZZ8<Y@*T2%4JYKI01QR?JM!(QM\NUPC6G:EP@XTJ6SA-HXZM8P%0+V(
M$>P,BH[*AS5F)-[ZA/[FN7G`6M)4NT'88;1Q"J-E5J;15J/JW+3MOPF26UH3
M36S3ZFX6W#"PB"%[D%8O@A!J6N6G\SKL,`*4B.9JE*#/2R"Q7D9F;1NJ+/9J
M@\=]'Y:=S+51$E!1+);8P./$]07M'FO&2IG-14.:?:MWG`+CJSN>FG74C1`@
M9?D%,-$+,2_KM9Z=2BIA1DG8^7@[9'DT.;H'D[T:BU&;0O&L]EE4PZQ6R^/!
M[9H$N]*F82I6G(]F@=-.L>RPQ+7N-&(Y[(#$>]PPQ+GO7C$&M(&*!>X`(J_]
M1].@]8"0@GL`J09/><L4!ZI[QE0;\]*H#=!,P-KN1&!I^K>_L`GA]1%&O>&O
M;&G\ZBL^,+"D&&'I0AD+9NE,-#PS&SCVC:RQB9[3SSG*?JL;#\P4N7;QRGZS
M&P=C<;3N6/?:8&JVLJ!8"+![MC8/A+\V'8]]WH@2F=!G]^C6UV]'!M'4J.:O
M-J-^&!OR&[;I>\<\!>P`:_Y`(X:WW[)NV2H+\VLFN#;V^^`FUB;??"3:X$(#
MF[9TMKWBVOV*V;1^1R%6=W<+LXK:'?9ISDVB"Q4@&%\^FF]?4-%\`QULPT9#
M,^8:+VZ2]H#$#5^9-H>`$TM$%`03V/H/+?>+6R2#=TO:6[UDW=`A@Y(+GFL(
MI&HJ2-14D:BKUZ_]2`6/O7YZ;J8:8I-ALP)N(>S:F3!$27^/8C2Q-'_.P?"-
MII_"-IM_"75AH7!H>Z-".G>8^4QLX'!@Y3Z>&?8"GAWW5T]_?,1&P#Y!->TI
M1QPXMJK6KX2[U35H;8U:'[#5H;HS+]PVI3?X2"WSH.YC/.87,9L-R"K0UW,%
MBN,#9<:VX1X9TCG@L7.RCF[J'Q`'=@T""T@DO8N8P,,C%*89$.+G+)FP?A=A
M<28(7B;!(2,]BX(0OVEAABW)6!C`R)+$@$$A6=S&-_`V)86^%WQ27PO"+QB/
MQ0?O>&?K?P-P7=WA9+]E?L5Y?SC?U]DOECE/)9=H>77WJ`&+KX@GLXT0M]^P
MUW5J&8[;[]SN`9LVCR`;.P,V?2YP6,]@%S`FN&!+,$+0#P<WQ'U3*;1XE[1O
MDD?>!4VBE!DB.URKMD.'4HMLA6[^7L[R05?\9\D9%JH";1^#)(^ZID`CAZEZ
MH$6A*/"FM9U1-H0P8@W,*`WPB4,Z%2:@+6=<[YBYYD'5'.=C`JZ4NA-@Q3J6
MQV"FEPD-Q=<>=EH0<*F]TMIFH.#NK8FZ&4RS8/\IFI3334DO2H!8/`]Z]+!/
MP(-^!"/P%[\!@_`A7X#%^!I'X&E?@53\"K?@.'X"+\#3/P-.J`W##%7D3<2(
M1Q`X9KB-5F2U#!'9NQNC``T=C=)H-14-,5J*1IC-1,-)/49QI*AP1&J8ZM50
M^?#Q37#>EOKV#IHI>PSY_@-4+*8:1/D3<$.1&YX'Z6OCC@CQ#`D<M(G(C>>3
MD>Z-"X-#6&AL#0C)-K:CP<[6UF@8#7Y[_WKW)+DD\YW[%CZ&[M]^=7/!TGIT
M4;?/)2\`'`G-TCLV\U/,:_N1'1P;H!NZEX#-T'CO)X,R#,0FX<4P:$5?7;$;
MHE=O@T\2?:0X[+&J@2SH2+J\%VAN#``:D$9>7RP2`PY%_+?8A**':!R&TKY-
M(->[+*\`!Q;4&(F^ZIT>DE%#M%G4,D6C`SG0S=<V\-M&$HH=MTE(CM$TN47L
M0;55`%[@(N4\-M($HID9`E5$""40,T9`+'B+ULAM&M=;B\9+:N&9MQG);*K@
M0VB82FX(8>#[<JE*KUN6\H.4\#2:1MQ;E0LMFYWL#;E.LH:(W'"<[Y9RG"SE
MAI.P/V[U`UU<RO-H\<Q3I*GG+-QOD(:(,GA2"_H![2&2<=4_H`XQJ`.6^QEP
M>D.3(I0*D>E7<P='E50K^;@SH?+W]!8T+E@!G#GC:`B=![%"T"12IR:1XU"I
M(_]H7ZK+:C(_A':Q9N-YBDV9^!&2.6D-I<'C@H$K[<^2VJ/&S02DG\SU*<90
M=>"PB38^#,;9_TTZ=8.8D9#DC(=7`)&CHL\,GLP.!V7\=VFG5-)#XE*B:[]8
MPWM1;H#M7P)+V:M:E[+^HSU<[0/#;'-`*"X@..IPI(XF,)D*"7R#7+S<YE6?
M7#MU29"6H&9OV0Q[\"7?@3#\">FWY%4"8GC%@@R(P3,\#)@V$\H5:OV@J!+F
M+3:HLM/SO995KDYR8F\O/4/92W9->REU%QQ1Z'[<A'L\;>BXG%F%F\GD\A,R
MV39S>5GLO.YB7-+R^W(\&P,HYC*SV8:M9R=R^0F&<A'Z"F<,YB<GF>1S&544
M);+L_F1)O*Y<Q7__^Z.]G^S]]?X,`D.,ZIY`,GH."WY;A%U#XID.9JT(8I8L
M(@!KO:6+#M`CM:<.)=LHH216O,33N%V%9*,>X78:\!CE0=DNB61HHM2+K!BN
M%S.\2&BH/*4V'L[%O\[-*'Q@&N'9;QSP.4YYSE&#O70&]J`&QKQ8J9BM?*#"
MNJM#JA)W"CT#]JST8"[,+JUH@Q0@K!!&1^JC`@6KNN"%CZ=LL-+[5=:8F,EN
M3NC%1F5=FEPF:A<>(LP8;1?UU;,?A]2E.F"B3E/Z7V]KU:FA_"<-YHBZ!YF$
MN&.C+G\RED(A+.LG=!UALZH(9)=C`A8^#P1PPGCNE$2Q]H!&-A[`S_RD,EF%
M[IAG!4(>D%0829E#]`J&U=,*@RC^,RC9BH]VA9BWH2VK8:ZW78+A<EPN$B/X
M[E6><4.8`3E(8YG%3ETV9`?&04::2M5`*+UG4&)2:I(50S%NNO%%2XATB+>.
MD<,;8=B>28"KS=D?"V)[&;K;HZ1%).[MEVR/`HL\.FPSNQAB?_:%4?KH5XG\
M:%>)_C0KRCI0U"LI_"A5%D=*"F=2A4*%(9+.KW<J:A2:O*%.[J`H0:@!6:%Q
M1V<JI+:_#+84.X72JLMK-KT98B<2R#*$MJS#21I9]VTO942MY*BRR`<'**7-
MFE%S*)22K+H25A+9C8_=)>U2=\`9I3`WQEC,&ECDS2Q,Z=$$L<N,L<\XSEG,
M7TL10[A=,/Y8Y?HTH"<,F_OE.*#-V,"I2'-UOR].5D_^^RO[70LK^J:Q+LOK
MLKZOHV5_&,H_>&6=!?3.Z5E1_92OWT64O_%V,9^="RA8GPH55*78^V1X71LD
MIHQ*:,0FC#)HKRV8<06_(,A(80-'LED(F5:A12=D&4T$<--`IH%TW/,9.$<#
M@H+)0SQ@,@WHB^O?(H#7U%_3307H4T;LU&WLFIH7I3Y_4IHUO1IH\HRB/#'U
M^R_MO@7_Z;X&__]WOPZ?\XUR#CG<=_?"WK^^$OO:&6/H(K[?@K3I'2"O8L;Z
M74HEX?0HE]\T\_:-1*R_=1+L.C1+^4RB.'8E%__J)^G:9<AKK%:*>1>T4[Y_
M12I>I&]0BOLH`*5,$:U0R-9GUH6FVI3=?=E(;(OO?!3?J4^%*Z'0I7A0HGSV
M=V)ZE/(,Y"0#L#G..(XOR>++M0MZG6\E[8:]SV\B^>I;-+V,\+^/(UU/,V2[
M"#/].1CNL&'%#-["B%')Z0].1PP!%GN6FF.>B_35GUIK'E`[[Y`:EW'.47Y[
M+.90R^C&?6P=^#!,4#L4&0TF#1O&H!M*Z_F\[NUVP!G)R7M=XM2]IT9`=14<
M9,CC)@U4QLT?_H38XR:+T?R)P_0D3T)"35UTYC0@,D=-W]&D'E0VF.S_\ZI^
MU\T'5YZPN\^1-/9+JR)-J2JT8M9\7!S^N'P2^;1Y\?;<'/FU(C_4AR%LYZ\4
M7[G`S[F4[@4YCWP\5K)[QC8?E"3DGO0Y>$>@&D-WJW**V[>-/N2?8HWY14NT
M(H8GML"AMM_)XM^7YZI?5J%XI^7YJI<:!K;?K9/&(]4H8^10QMM^^K)/((X;
M6^=![M&I<R(DY527SDTOM8MY)IIRJ*T9DQZ;Z:@]VXF)/LT836]BY8":<OI&
MRM=5@@U31DDYQ`65KS@&DYFJB9/+U<0_8#'#3*VUH!4%%:QE!HS>CT2JE!"Q
MCWW@$O)\>>@$^(I%BI*^Z4E>^HE)BJS>]]0J!-]D0DMCY.)"2S!_):0DY$!L
M0_&:2>11/UMH^B9/L7!X3`/UOZ'S()2+PE(AAIFRM:4$922FR7&J8?1VM\^[
M,$I*`]&!5,J(SYDH,L?*EUIM<,&N%#7!X+$Q\ABI'%]GC.TCNRE/0UNET[:J
M<5J--H])F\ZP)1U=(WT5+3_;J)+[6?)G.XK-#IM!4]OAL/B`;3/6:JS\AW^+
M^KR?QZORO._."]V0,6-!F1V'`[Y?Y!L^8*,E>N:=?GL)V.%["BC?0UN6S.0G
M<OFLQ-SC7N>[8$EIZ8R,S-=MDLGC>M[PG=4-!+S^/RN4D\=VO]K;S>@S9*0F
MA)H*;09_0@/WME8$L0[)BO2[YS7="W_.Z\>?;+!?$'!60K57B<*$N-^--,>%
M3G4KM1`+PU$#B&XG"A+UBJ`&3JH@7`(#'O1R17>,BQZAP2GG&*?J$I,7A3QS
M%/--IQ+PI8F*#HYW<F!2R>[;XI#=I0XJMCAL#K%EDTP?8M(NM/Y.ZY/N)0XJ
M]B?@4H<4NQ:``+SLCXL"DO7<T6BCL5"A=.06<E*"(+2,WA6Q8ED*V+D(?@<9
MAL#5(87#8$C3!ON._8OKASMDB!Z[VEXT(L**U%0O5F"%D%0,$+<+SPF70J]5
MC.I>WKC3@'FP6^OV9T?;?&WQ]D=\8^$;]-$;Z^X,?#ID.'8G7J#.M]?[9W#U
M:#CFA`CS0IW_TX9^L6Z_/!RZQ;#B)IEP?-"#V^*$E^KGBM@ZN)V./$[9206'
MTIX^>+EA)PP#%@GR:;L<84#"!>*!=*>7EEX$8V17!NOM'M$-[P@1XZ2$8$,N
MX$;%`-3K*=99CD:5Y5K6SWO7@!;+6M.M+ON0FG3DIPQTA.JF3VM.=3K"W/RA
M)^(#+J\')0TAN$L3"<EQ`G0IT^>^XY:P6SY8-EWYPP8P(#MB[_,$0)ADI>G/
MKR^:''IG0K[X]4.^'@S;X.#-O?V-AGQZ2*19@H@F=>E*-!G/SPY$5Q$74RR'
MH!7#'9+N-C1S79]D]Y@Z,U@,VA;K&P6BO5IY?4%175]N@^^'M#,U&/[0S+1[
M%S*"]5B*"<_$/>X#*\<RD4_(1+VF'DZI]F]HPB4D.I(/J/R4,EX9*',_X]+N
M#TY_%5^Q0DMK5\5/$IZ4^O>H)8D)'.M*@ZK5Y?T#F5=FGIST].@GIUZ>GABP
M8UX^H)>?:21ICH[6BSSK$N@F'_-]"=NPR[BZE1.3G\+\]'Z/Q/=6.NK88I6A
M%QU8T&^DN&EHX%8U"+DV*`'A:0>*QAT=CU$%(`I2YC*JG;I;HW3\Z_D!.6T[
M6YC+,0+KK^4$+5+;!-TO\Y0KDYP#NH<@N:'%!=,DH<4-TU/,BYH5NTQP+XI*
M449)8"DJ(X\XL-*W7RHF-U:B(&B3,SQ)<L>$,#:RET(2U=3+)U11#J<0=9E>
MEF$"SAB<-G=B@2>D-W<'^/O8P,O(%6[>(\4/$"@P78K=@2U^Y"">*S!.S;I1
M%EZ_FRR*[848["OF]RCN;42CL=0_FWFAI:JBCL/5Z2J)]G[[/WV?OL_#B`CG
MPJXBO6AB*J:/#\&_#%=VQL_9_AP%]4,8_E.H>)#!_O-`T7S`YPAV>!)TP0&&
M'7CAM;8L&'A`TAN)#:9:=3D1/%]T-,D<9#DC;;^J^`XR7)0YMZ5[)FEEDF,D
MP';A=W&G3B%>]6J"]U%)3AX9&PF+\=.+S&!%[H^/VCX/MW;YIX/AOXY8*4(<
M_8F'Z+$9I9(\[_8Q\V\'KJTLJ@&]#*E##OTNVLC^JL3\!";A'Y1ZZU+(GO"S
MH\1U!*YL;CB/"RRI"*?D(Y4A%JD(^V>%H.FJS/35<7\RJU2ECW4"E+(.ID^@
M$5>ZF4$I9DZF5ZNF<-FFR&X[;'U\GMR(\NOYF#JXW']LD?MTLYMSW4QMT'6<
MVZ\)=\,V;:Z-GUNC9]9J<@\`9_9C3>"V&\`14:6*^9I=K5X/^MI/V-:WS&+^
M?Y+S/49%WH:G(MR!%X7Q;TO#%V@E_T&+A9O3+Y(9T!;<0>/SQ*>L(7D"4\P0
M?>,4UPA?YQ*?@$':"4:SQ94&,K8`@3CFJ4R>=+GM1?NA%RS@'C6LRX#]R1#%
MQHI&$42"[@6YDA<W])G@9]^D(4R)2R$%T8IJQ"EQ*(B"X4D@%QO\OQ_4Z1T<
MM/"T\*6G#5KB:E538QH#JHTIE>,1M4/D%40=5DHC*`@D'J)!XZLK`!JDDLRR
M+QPOI'0AT\>%WG3LJ<\NK#7]%:_'?:_0L-_KDQM^%_&3$*#Q\SA?[9,+"]X]
M4DQ0]*3!Q6(R8UOQ*R8+H!H\]L.%3+^D:2^R`%X7*"4_:)3RQ*1!BF,$H/$B
M%^^)0X2DZ5D#)C9Q"Z]K;O3F*4..O+C<RONO;V_".S)[QF#]'R#!,-R#&QI"
M=\'WT@^^H'W=!]^`/N-PH<"_A+W[_R_!UX!?U#LT<D$C<LGI5Z>E9%C.2$^O
M8+VWO#IQHG-)2T,ZF6:4M$.IEHE+1+J9PI;+A_-J^XDOO\`&+JA+S[0WD0A6
MWT(FV^`$3N>&I2S&^^,<,7KC1Q)<$$="\G@PITJ*(\&)S9SS-O,^7Q0DPB<G
MF6=&`EFJ(T$3RE1,+1FVW(\11V(45SX?;_V1"??#[J;[[A0WX_@A]]X/N(#@
M38[$?X453_0V.0:[TX-B]GAQ<,'[H3"Y1>N&DE8,$&$"2P-8P%E>ZT2\/*':
M^WAKS;&9$-L9GLT&3=\/N#3$S=9EI>[997;(T)?UCX);,PP>&;@M^#184R\Q
M#;0.I!UW)]>\0#;1O@\+C+SN%\^R)RP83!;\^?[(D:D!YLGP9Q1BP@;'8-I$
M.QN^2BSQ=A]#`P@UG&NGYEF6N&;VY+W`Q*;<W2H)5J\V*,##A.2C\;_;RI=+
M&K4HDPM#FAR?CIEH\5Z&N<B`KQ&:<@"#3I=R>7D!REJ+62XJ,!)<P/,G<%7=
MY'#;,<7X$WBI<P*::+/`R4O62W+_<100;B(>9N?1;_<1@1B0(P0>J6S[,/+#
MEP42OOPJ<U0]YH7=0VWDY$.LS$J8*@4M="5A?/>]&@<V"GW?!'`N-@H_/@G+
M2T`VT/+!6Z5++16ED?#MBYU[_6P1Q*<$9PJX1WTX18H=T+GQX,@6@O_@T%H2
M4VOP?ZF@*'Y(M#BE%H/"[`OT5_[X:_P+O!]5N'='ZD+E]KB%,&+W@CX0?<I]
MI3[Y7S8062#PJO'Y>BQ.'GFLZ_$CS"!NZC??JNPAGB=XA7_<9$18TO>@WZ7P
M@@+]T.%M+%W2N+B_P(#Z#-O"KPX.C6$1@E=_M=VSP?$P0T?Q,3'$)D(Y21U_
M"47!CKV5VFCOHQ,5WSR,+^0<0<VC'4R=)="-@:\JXVC)#1L,G_"\!HU'^5%I
M?AO<J*54RHY4<J3YJI5Y<'OU,H7Y\L4XL)P%,1_>!-OHYB7WPL4%E/A?T#FN
MD7V$A9FZ&7!I3B#NLQ0]!!2A#&O';D1&&D"&S-T+5$>E.+W?=&0JA1"L#(3@
M(4H<4C;[XN3W0:R&@`,N/$'.&-N%#<<)'/B;P@@T@@Z<9.7X>'?85ADL7`IJ
MPD9R2AQ?*,R_U(7PEAQXNG2@IAPR99(([,96NH%K9C)(-1JUO;1=@&407(<%
M_AF/NY+N5BL[C3IC5PSBJP?(R[.V:NNI([I7\\S3M28&JOMSXU<,[ZH^2MZN
M_I6Z3`13MFZ-K4G3!1*<*LF349(R4>Q0\3I#FH3T>Z$(:%"TA@C4&YHP1J#L
MJ`1L'<-9^G(C(A.1J#0C*.G6IR)F/Y08J2AXT]SEPO<;$5ZCF<E=TD=3D![-
M1,"BJ1,_LY[JM(QR[2*L;ZDTTH</>-+I29IX*G@B]_O?XR7,BT>]_LDJ9"QV
M]_WR3,EWX$O^RBSQ/Y464_^ZBS(?W468`$UY_?NIHA7$Y]$&#NL5>X12V1O<
M(K&]A]6F\E>IB/EZSC#I9`@5P>H`,'HVU;9&VK<,;351`:I5L',"HL0RWTM/
M#!FV!H-`RC`M%,E<1V<"06AD;V25=_SDDU+J!QE(?J2*!_<'D=#&6)=WKXV8
M.CW+Y\<S_!\0XOC4\7ZGQV_(Z>0>S5J$EL6'F".+O7QE+[[78O_CK06I?O#S
M"F"&0K0>@&&G)D;6.PQM8[$*Y!3?>WDHC[K1(&\J/#3Y<@-M"[L,:KY5L[L3
M<K]T=FG,KU<A"\Y]A.1%&+W7M*9&;OP!5#9&[OPS!,G>J-&@[_S&CB*_E!S*
M,./IL7*6,;"H,`M8V'`'$W%^.]2+0^\/IT,I:#5$Q[X>WYLQ;+4/-V57$A&K
MM6``$`Z$J*\P`LDBLE[KCI;I)@9@YT-`[L@\P#,L!YO:$JADBG(B='&[WOOC
M>+,EX3>)IV^]9+&`I:R*,X5&+@`8LJL7&4V`N5'5>$N$^:@$#/AWM$II[!1'
MVABC&O\(9I?BQID8:!'L2//[2(KO3D7F`D6]HNE0%]T!OJ3?M>^K5^_?_2?-
M7#]!ZJTBN/ZGH^E4WS?'TG>G9E8#LXPR:AFY-W6]C33=C5PU6G&IBNMU\]'7
MD^]_TD!8/>\Z4@-80T@/`][HR`28"^HU@+ZC=F&YZ-4IENG(+KO^L@N]_X6S
M]CN1S+AE47![<+IV@]Z^W]MP:A8?UPN\R\!M%0;,7@[UAK(1H8<T[/6'K3N&
M/L2A;4,;$XTWY(TZZO$IF8[HQ,*$1V9JPP@2_%AV8P33G&$1_(F9T*$$F`NN
M-MW?XKUSNE*U>S]TU*AKC%UO^P-+$TP/\O,R\C+9</-WL:SFP]OD9N!]LT9M
MT:BH9QC"#O#>9IJFDT>GZ9WZO*T_^_*M&\_2/4_E8O\1[[]EK,=VNLAQA28?
MF-RI8AYK]V:B'A`TF@'B.,J^NGBH<$$+,2/%>3TA;642A8Q+*5#P9?Y9K-A8
MMV1[(DTH4FJVZS?3[<G8,P]N)+B]\;K1@X^7$8X.J.#[-A]S`?=`'WU`X6##
M#ZNP"?VX#UH?66.O<A)^?'U<#6@7V(?<'COHR,@=)!](O'%-'TL'*ALP.>'T
M?5U(L,LBQQ2FQJ$=`!^,'#@(2BA>85+L52^?5+UZI?`*E[4"[#%J,</0O2#_
MB6X]X3<A(\:>3E9%CVB(;9@@^*,ZKZ9'X4&?@I&]D?=]KTFO_0JU[_VI.C6B
M+7K%6WU&O'_R:^@5:ZR^:\>JS^HUY/^37\U5KK56O>>;A*5_9_75@52^F-)(
M:1>C>=OHT:MMB0W5@]BTJ)'F$T-+1U56V<8<.QY)I*.H;.'#;$X<`":>CJ*C
M22!D-M64SA^N*!OUNFTC\NH&H7HZJJT^)15,*B*&=/35+]0,$H5<#_@-[AM6
M.!_P#ZG1JW%,WI@]]HI:/34U3HF>)[2.K)&19Z#1UAO?>@]'MI-&VJZG[0>_
MJ`&'I#NCJ6S.HIJEMA^DR*ALW<,Z.HIM%4WS+D?\F754VBI?_3,T+:I<-JK_
MLQZEMIPHW)H_MDT-'4Z%M4$4G(163Y%&T-+8XH/78F\!C[P&0O`<40!@ZBP`
M'@8!`!`!`'*Y5/`>S`$````#``#Z6FV;```@````4$%,151413$N4$%,```/
MX'<;```"/6O:PC2>D/W33]W/"TYM+>IBCU`=>2IQ7BUHU%WWJLH2?R.CX6DW
MD9=`%::<`&7+E:UMEEA):!8`<8O\^<0'+ERX\>-UUWGY^;WOKKKJJJV;-F-!
MHHHSY\\LLL<<<4463)D2E.);D!Z@>@'#I2-P&T"H#7TK5`&<"8"0!>-BOO._
M>7.+6EC"M9Z40UL-2SK2>\8:!;.'RATF*2O)WDNQ79_3#\+/PD_`PO%L`_R#
MG#5J%&@32A:Q<60*WE/B1X8"FT:7B=PO-]AWN+J2V<L65I*>;T^6`C@$6!&X
M(VA%01K"&A%`1G")@B0(6/I&E9*2<5*,,!;:'O_](4":;%(,L*]Q360XC9@&
MVC0\,=SP-9TP-263],#=9"/I(?[*/O><-YO<;FG@PV++TFL&H84BW2'SAV8:
MNX4=HF4%_O)Q^6!ZC#@+7A[@[4-6@43"9>(_VXGUN-\#Z6&W<8;38X[_`[J3
MMH+I_?\L]MDW'7+=3FX-DL[XWT=U?X7XY\KIXO!G;KF[*<V33(K1'UL6F7+]
MXXNI?9U19/^4G[#^^@I4)%0TJ@Y4(*=!6F"I.<7L5!BH:U0>JN"FP5FAD5"9
34-2H;N8OR@JF"I<1>/,\8.H```Y4
`
end
............................................................................
En kiprobaltam es csak egerdriverrel mukodott ! Anelkul meg se moccant az 
eger pedig kiprobaltam 2 es 3 gombos modban is. (Van rajta atkapcsolo.)
Ugylatszik kell a driver hogy lerezetelje...

Miert hasznalsz V86 modot ha egyszer HIMEM.SYS alatt fut a program ? A 
Real hivasokat egyszeru Real modban kezelhetned. Rovidebb is lenne, meg 
nem is szivnal vele. (Ajanlom a PMODE 3.xx verzio forrasat. Tele van 
kommentel is.)

Hyp-X /Demons
............................................................................
Probaltam az asmwin prd-d.
Eger driver nelkul se 2 se 3 gombos modban nem szuperalt.
Betoltve a gmouse.sys 9.06 driver-t:
At kellett kapcsolnom az egeret...
De a windowsom beallitasa miatt utana vissza is kapcsoltam :(
Egyebkent mar a RAMDRIVE.SYS-szel is kitunoen mukodik...

TomCat/Abaddon
............................................................................
 Idoszeru lenne keszitenem egy kisebb (kvazi-) ablakkezelest egy 
uzleti sw-hez, amit tkp. elotanulmanykent, edzeskent irnek egy 
kesobb kifejlesztendo nagyobb durranashoz. Egy elotanulmanyt mar
vegeztem mar e temaban, de az regen volt mar (Sledge Hammer PC),
meg akkor meg nem volt sok kozom az objektumorientalt szemlelethez,
szoval a SH kodja kicsit csunyus.
 
 Csinalt valaki kozuletek library-t, vagy TSR-t, vagy akar csak prg 
reszekent ablakosdit?  Erdekelne, ha nem is forrasilag, hanem inkabb
"csak" a koncepcio, vagy akar nehany otlet. 
 Az egyik legjobb pelda a diskmag; nem bonyolult rendszer, es a legjobb
kvazi-esemenykezelessel megoldani. Aki irt mar (egy-ket) ilyesmit,
ossza meg tapasztalatait velunk.
 
Legyen mondjuk a temakor jelzoje: WI, mint "Windows-based User 
Interface API". Presze ez elfajulhat odaig is, hogy pl. memory
managenment, de hat fajuljon, ha ugy akarja.
 
ERN0
............................................................................
 En jelenleg dolgozom a teman, bar mostanaban nem volt ra idom, ugyhogy a 
dolog meg mindig ugyanugy all, ahogyan legutoljara postaztam a listara.
 Az objektum orientalt szemlelet az jo dolog, es nem is olyan nehez. En 
szemely szerint SOHA nem csinaltam OOP-t C-ben vagy Pascalban, igaz, 
olvastam egy C++ konyvet. Az ablakozomat asmban irom persze, es eloszor 
kicsit vadul hangzott, hogy objektum orientalt assembly, de hamar 
rajottem hogy nagyon elonyos es egyaltalan nem nehez. Az egyeduli 
nehezseg, hogy nincs semmilyen nyelvi tamogatas ( :: meg ilyenek ), 
viszont ez egyben elonyt is jelent, mert nem kell pl tipuskonverzioval 
tokolodni. Az alant elteruloket a kisujjambol szoptam, (C) (P) meg 
hasonlok...

 Mi is az az objektum ? Nos, a sima adattol abban kulonbozik, hogy nem 
csak tisztan adatokbol all, hanem code is tartozik hozza, ami az adatokat 
kezeli. Ezen rutinok neve tagfuggvenyek. Kulonbozo ( de hasonlo ) 
objektumoknak lehet azonos nevu tagfuggvenyuk, es akkor ezt meghivva a 
kivant hatas erheto el, de minden obj eseteben lehetnek obj specifikus 
reszek is. Ha ez most nemigen ertheto, akkor egy konkret peldan keresztul 
megprobalom demonstralni:

 Vannak ablakobjektumaink, mondjuk egy OK gomb, egy CANCEL gomb es egy 
CHECK BOX. Clickelnek az egerrel, es kiderul, hogy valamelyik objektumot 
eltalaltak. Ekkor nem kell az ablakkezelonek tokolodnie, hogy most ha OK, 
akkor ez, ha CANCEL, akkor meg amaz. Egyszeruen meghivjuk az adott 
objektum CLICK tagfuggvenyet, es kesz. Ez esetleg visszaadhat ertekeket, 
hogy le kell-e csukni az ablakot, meg hasonlok. 

 Azt, hogy egy objektumnak milyen tagfuggvenyekre van szuksege, az mar a 
programozon mulik. Kell egy par, ami minden objektumnal megvan, hogy 
egyseges kezelest biztositson.

 En jelenleg az ablakobjektumok irasan kivul azon tokolodom, hogy hogyan 
lehet megoldani az ablakvaltast gyorsan es izlesesen. Jelenleg az van, 
hogy minden ablakhoz eltarolom az altala takart hatteret, es ha egy 
inaktiv ablakra clickelek, akkor az elotte levoket levakarom, levakarom a 
clickeltet is, kirakom az elozoleg levakartakat, vegul a clickeltet. Ez 
igy tokeletes, de nem nez ki tul jol, mert be-be villan ez-az ami aztan 
ugyis at lesz rajzolva. Ez ellen kitaltaltam egy modszert, ami 
megsporolja az ablak hatterinformaciohoz hasznalt memoriat, de kell egy 
globalis kepernyomaszk, ami minden pixelre megmondja, hogy irhato-e vagy 
nem. Elvileg igy gyorsabb lesz egy picivel, mert kevesebb lesz a vmembe 
iras, es a memo-val is jobban sporol, mert a regi modszerrel mar 4 db 
negyedkepernyonyi ablaknal megettuk azt a memot, ami az uj modszernel 
osszesen kell ( felteve, hogy 256 szin, 1 flag = 1byte. persze ezt le 
lehet szoritani 1 bitre, es akkor plane jo, csak nem tudom, hogy a 
bitezgetes mennyit lassit. Majd kiprobalom... ) Ha esetleg van valakinek mas 
otlete, ossza meg velem.

 A memo igenyekrol : ha a hatter eltarolasara szant memot leszamitjuk, 
akkor ablakonkent par szaz byte csupan ( felteve, hogy egyszeru 
objektumaink vannak, amikben nics buffer meg ilyenek ). Ez azert eleg jo, 
ugy hiszem, Az egesz rendszer memo igenye a grafikus reszektol eltekintve
nehany 10K, ugyhogy Microsoft Windoze Sux.

 A konkret asm megvalositasbol igeny eseten kuldok morzsakat. Az 
eszreveteleket ide a listara, vagy az email cimemre kerem.

                                                        Bye...Paf
............................................................................
A bitezesrol:
(Igazabol Strezi utan szabadon :)
Szoval gondolj bele, hogy a bitezes a sebessegen nem ront, csak megirni
macerasabb egy kicsit. Hiszen ha 1 bit 1 keppont, akkor egy 32 bites
compare egyszere 32 keppontrol tudja eldonteni, hogy foglalkozzunk-e vele
vegy se.

Masik otlet:
(Csak ugy magamtol :)
Az is egy lehetoseg lenne, hogy egy olyan maszkot tarolni, amelyik megmondja,
hogy melyik ablakbol vegyuk az adott keppontot...

TomCat/Abaddon
############################################################################
Itt kozlom az ASM'95 eredmenyeit, annak akit erdekel ill. meg nem latta.
A tobbi listaval ellentetben en feltuntettem a 4k introk szerzoit is.
Akit a tobbi kategoria is erdekelne, az megtalalhatja a kov. cimeken:
http://www.icon.fi/assembly95/
http://www.halcyon.com/jasonro/asm95/a95res.html

TomCat/Abaddon

  PC DEMO     
  
      1    10 (3646 POINTS)     NOON "STARS : WONDERS OF THE WORLD"
      2     7 (1482 POINTS)     PSYCHIC LINK "JUICE"
      3    12 (1204 POINTS)     REALTECH "DX PROJECT"
      4     1 (1039 POINTS)     CAPACALA "ZWEILIGHT ZONE"
      5     2  (916 POINTS)     EPICAL "REBEL MIND"
      6     3  (896 POINTS)     MIRACLE "HIGHER DESIRE"
      7    15  (799 POINTS)     ORANGE "TELEVISION"
      8     5  (587 POINTS)     DUBIUS "OPTIMAL TORQUE"
      9     8  (541 POINTS)     KOSMIC "LITTLE GREEN MEN"
     10    13  (372 POINTS)     JAPOTEK "FIGTHING FOR SOMETHING"
     11     4  (224 POINTS)     MASQUE "MYSTERY"
     12     6  (175 POINTS)     TARZAN TUOTANTO "SYLLABIZATION"
     13    11  (153 POINTS)     BLACK RAIN "OVERFLOW"
     14     9  (143 POINTS)     DEUS EX MACHINA "FEVER"
     15    14   (33 POINTS)     SIMPLICITY "ELEGANT"
  
  PC 64K INTRO
  
      1     4 (2750 POINTS)     WILD LIGHT "DRIFT"
      2    10 (1899 POINTS)     COMA "STICKMAN'S WORLD"
      3    15 (1364 POINTS)     COMPLEX "BILL G FORCE"
      4    14 (1219 POINTS)     JAMM "NATION ZERO"
      5     2 (1112 POINTS)     HALCYON "DETOUR"
      6    13 (1041 POINTS)     VALHALLA "BELIEVE"
      7     1  (527 POINTS)     MIST "ALCHYMID"
      8     6  (506 POINTS)     HALO "REALITY IMPACT"
      9     3  (471 POINTS)     SYMPTOM "CAMERA"
     10    11  (364 POINTS)     ABADDON "PIED"
     11     9  (358 POINTS)     EPSILON "DREAM"
     12     7  (271 POINTS)     HAZARD "COCAHOLIC"
     13    12  (225 POINTS)     ANARCHY "TAM"
     14     8  (194 POINTS)     WOODPECKERS FROM MARS "NO CLASS"
     15     5  (185 POINTS)     @ "BYTE ME"
  
  PC 4K INTRO
  
      1     8 (2100 points)     SCHWARTZ "ANIMATE"
      2     9 (1729 points)     BARTI/NOOON "HEAVEN"
      3     2 (1008 points)     J-P/REBELS "CRASHTEST"
      4    13  (948 points)     TOMCAT/ABADDON "CHROME"
      5    12  (836 points)     VICIOUS/EXTREME "HAVOC"
      6     5  (801 points)     CODEX/PARANOIDS "SPEED"
      7    10  (696 points)     BLALA/BYTEAM "COMPEXITY"
      8    15  (608 points)     XTOTO/VALHALLA "DRAGON"
      9     4  (559 points)     EXON/THE BLACK LOTUS "BIT"
     10    11  (430 points)     PASCAL/CUBIC TEAM "LOOP01"
     11    14  (366 points)     CRIMAN/JAMM "AHRUM"
     12     3  (340 points)     LUNATIC "ONLY FOR FEW BYTES"
     13     1  (337 points)     GALVADOS/JAMM "REDRUM"
     14     6  (326 points)     OLPPA/THE EUROPEAN TECHNOLOGY "STRICTLY 4KB"
     15     7  (324 points)     PLOOTU "SHINE"
............................................................................
                                EXE'95 party
                         16.12.95. Budapest/Hungary

        Demo compo:
                1.      239 pont 2. Too complex by Shock!
                2.      166 pont 3. Mindphaser by Enlightenment
                3.      118 pont 1. Frame18

        64K intro compo:
                1.      159 pont 4. Astro by AstroideA
                2.       87 pont 3. Sketch by Syndicate
                3.       29 pont 2. Hysterics by Exhumers

        4K intro compo:
                1.       21 pont 2. Kick by Urinate!
                2.       19 pont 6. Rhapsody by Morgan/Criminal Gang
                3.       16 pont 7. Mask by Exhumers
############################################################################
Amit a 4K introban csinaltal az nagyon szep. (Kar hogy otthon 
nem megy, de mashol lattam.) De azert ezt en nem neveznem 
realtime raytrace-nek. (Vagy definiald mit ertesz realtime alatt!)

Hyp-X /Demons
............................................................................
Persze, de ahhoz, hogy egy partyn jo helyezest erjen el az ember
nem csak a jo kod kell, hanem a fellengzo duma is :))
(Egyebkent az rt rt elerheto valamilyen szinten es majd meg is
mutatom, csak a CHROME-ban a 16 tukrozodo golyo mar tul sok volt,
na meg egy-ket dolgot benan is szamolok benne).
Ha vedekezni akarok, akkor azt is mondhatnam, hogy a kezdokep
kiszamolasa realtime (foleg egy P130-on :), mert amint kiszamol
egy pixelt, az a kepen megjelenik. Persze ez nem 70 frame/sec. :))))

TomCat/Abaddon
............................................................................
Kapok nehany nemzetkozi levelet is az intromrol. Ime egy erdekesebb:

> ok i am an avid fan of demos an di have gotten access to ftp.cdrom.com
> i downloaded youe Chrome 4k intro
> it said realtime raytracing and i thought it was a hoax
> well it was, i know for a fact it is not possible and whats even worse
> your anaimatiom is stolen from someone else's work
> that animation you used was made by Ken Melsha a few years ago
> i dont know how they do things in Hungry but in America thats illegal
> do you make it a point to steal and lie to make work that isn't even yours
> just to let you know a freind of mine, who also happens to be a Hornet sysop
> on cdrom.com will also recieve a letter knowing about this false and illegal dem
>    o
> reply is greatly appreciated
> 

Dear anonymous!

Yes, I have seen the mentioned SP2.ANI for years. Done by Ken Melsha in 1990.
(I think it's a sample anim of Delta Animation Package).

1st
There was not taken any part of SP2.ANI
No code
No anim
No picture
No pixel
No data

2nd
The two things are functionaly different:
CHROME is a program - SP2.ANI is an animation
CHROME done by a coder (programmer) - SP2 done by a 3d artist
CHROME is 4k length - SP2 is 400kb length

3rd
I have never seen the animation package, which was used for SP2
I have never seen of the source file of SP2

4th
The idea? What kind of idea?
These are the basics of raytracing: moving mirroring spheres with
shadows on a plane.

5th
SP2.ANI has no copyright or contact information.

6th
CHROME is not for money and not for commercial use
I haven't got any prize for the 4th place at ASM95 (till now).

7th
Why CHROME is similar to SP2?
Because I wanted it to look similar.
But not because it's a cool thing!
(Nowdays doing animation like SP2 is a big shit!)
But in 1990, yes it was fine and it is a well-known and classic animation.

8th
In the point of Asm95:
The people who voted for CHROME, they did it because of the raytracing
in 4k. Who cares what is on the screen, balls or what? The important
thing is the RAYTRACING in 4KB. And was it! Look out my next intros:
SHELL, HOLE etc. They are all raytracing intros.

9th
Anyway, look at the gfx compos: the 99% of the pictures is a copy.
And the other demos are reusing 3d objects unmodified...

10th
There is no judge on the World, where can I lost with CHROME.

11th
Maybe you are right, I should have mentioned Ken Melsha in the text file,
but not in the 4k intro. Do you know how much is 4k. Look at the length of
this letter (over 4k!).

12th
In Hungary live humans. They eat, work, sleep and they have laws of course.

13th
Who the fuck you are? Why don't you sign your letter?

Kaproncai Tamas
TomCat/Abaddon

PS: The same goes for STACK.GIF (sample file of Vivid 1.0) by Sthephen B. Coy.
............................................................................
Ennek az anonymous faszinak nem sok koze van a dologhoz...

Dobbenetes.

nagyd
............................................................................
Hat nem tudom, ki irhatta ezt a levelet, de mar a hangneme is kiborito!!!
Azt vallom, hogy ha valaki nem ert valamihez, az ne pofazzon bele annak a
dolgaba, aki ert. Nos, Tomcat, en a helyedben kikapnam a Doom-bol minimum
a harmas (duplacsovu) fegyvert, es kepenlonem vele a faszit. Vagy legalabb
elkuldenem neki a golyokat e-mail -en. Udv:
                                                Iron Hawk of Bi0Hazard
############################################################################
DOS alatt tenyleg kiraly gyors a PCI Ark 1000-esem, nagyon expenziv 
kartyakat is lenyomott. (Igaz, hogy a Windows-gyorsitasa nem az igazi, 
TRUE colorban pl. nem is gyorsit, HI-ben is joval lassabb mondjuk egy 
S3868-nal, de ezert olcsobb.) 

                        sTINYO
............................................................................
En ujra csak a SKY-EAGLE(NCR) kartyat tudnam ajanlani, mert DOS-ban
ugyanolyan gyors mint az ARK 1000, de Windows-ban is gyors
(gyorsabb mint egy S3) es kompatibilitasrol annyit, hogy a
megadott ftp serverrol letoltheto hozza mindig a legutolso
driver... (OS/2-hoz tobb driver is van, de X-Win-hez meg nem
neztem...).

TomCat/Abaddon
............................................................................
Nekem is ARK-1000-es chip van a videokartyamban, de elegge inkompatibilis 
a draga. En speciel senkinek sem ajanlom, mert pl. az X-WIN sem ismeri 
fel, az OS/2-hoz pedig csak regi driver van. Egyszoval lehet, hogy 
elterjedt, de nem a szoftvergyarto cegek kozott. Pech. Jobban tudok 
ajanlani egy Cirrus LogyC-ot, az meg olcsobb ... Ja, a videokartyam WD 
Paradise Bali-32!
                                                   Szabo Balazs
                                                       dLux
............................................................................
  Most akarok venni egy olcso local bus-os videokartyat (atmenetileg a 
PCI-isig). En egy a legegyszerubb S3-asra gondoltam (S3-805 semmi gyarto 
megnevezes 1M DRAM, 8500-10000Ft), mivel annak a windows gyorsito resze 
legalabb gyors. De azert elkezdetem tesztelni egy ilyet, nehogy kesobb 
deruljon ki, hogy nem olyan gyors. A tesom ilyen kartyajan mertem 
a karakteres es standard 320x200 256color felbontasu adatatvitelt, ugy 
mint a landmark teszt is, de mivel ez csak 16bit-tel meri, en kiprobaltam 
32bit-tel is (rep stosd), de teljesen erthetetlenul lassabb lett az 
atvitel, pedig azt varnam, hogy kb ugyananyi az ideje a stosd-nak es a 
stosw-nak, es igy az atvitel kozel ketszeres lesz (16bit-tel 16000 Kb/s, 
de a 32bit-tel csak 10000 Kb/s). Termeszetesen az offset mindig 0-tol 
indult, sot ha 32bit-nel 2-tol indul, akkor az atvitel megno a 16bit-es 
atviteli szintre, azaz 1 stosd ideje 2 stosw lesz. A tesztet lefuttatam 
mas videokartyakra is (nem noname S3-ra is!), amlyeken ugyan nem 2x-es, de 
legalabb gyorsabb atvitel volt 32bit-en (pl. 16000 Kb/s -> 24000 Kb/s). 
Kivancsi vagyok ki tudja ezt megmagyarazni. Egyebkent a BME-n a VSZK-ban is 
ilyen kartyak vannak, ott barki utanna jarhat a jelensegnek.

                                                        Picard
............................................................................
A kartya az S3-805 revP csipre epul (a P revizoit az univbe irta ki.)
A csip kisse, bugos, bar ez tobbnyire nem okoz gondot (tudom, nekem is 
ilyen van.)
Mindenesetre nem veletlenul olcso.

Erdekes modon, nalam a kartya 20000 Kb/s -et tud.
(32 bites modban, 14500 Kb/s)
Nem tudom mi az oka, hogy nalam gyorsabb, de a leirt effektus igy is 
bekovetkezik.

Az effekt SVGA modokban nem jelentkezik !!!!!!!!!
A windows gyositora nem tudok tesztadatokat, de asszem a gyorsito
640x480x16M modokban nem mukodik. (Bar en ugyis 1024x768x256 modban 
hasznalom.)

Ez termeszetes, ilyenkor a CPU szettordeli word-re az adatokat.

En asszem, mar nem fogom kicserelni, annyira nem rosz.
Ha nagyon olcso, akkor vehetsz ilyet, de inkabb egy Tseng kartyat nezzel 
az legalabb jo is!
(Ha megis ilyet akarsz venni, akkor azer' meselek meg, ne utana lepodj!)

Szinten BME-n a Doom laborban is ilyen kartya van a gepek felenel.
Ott jol megszopattak oket:
A ceg amelyik a gepeket hozta, bemutatora egy "igazi" S3-as kartyat 
hozott, megmutattak, hoy milyen jo, szuper, aztan a gepeket ilyen 
vackokkal szallitottak. Pedig pl: a monitorok 100Hz-et is tudnanak,
csak hat a kartya nem birja.
(gy.k. Doom labor = V2.103)

Hyp-X /Demons
............................................................................
   Ha videokartyat akarsz venni, akkor en ajanlok egy WD Paradise 
Bali-32-t, aminek az atvitele 17000 cps, ARKLOGIC 1000-es chip van benne, 
amirol azt mondjak, hogy a legjobb ar/teljesitmeny karategoriajaban. Az 
ara itt pesten 14500+AFA, en 12000-ert vettem Pa'pa'-n.  :)
   Az egyetlen hibaja, hogy sem az X-Windows, sem az OS/2 nem szereti ... :(

                                                 dLux
............................................................................
Az ARK PREMIER 1000 13.000+Afa az Erbertben (Bp.), de a napokban 
tesztelgettunk egy ARK 2000-et, ami allitolag nem sokkal dragabb, 
viszont SOKKAL GYORSABB!!! Van egy teszt, biztos ismeritek, nem jut 
eszembe a neve, Arany Aszok feliratokat zoomolgat. Na, ezzel a teszttel 
nezegettunk egy Genoa Phantom 864 S3-at meg az ARK-ot ugyanazon a gepen.
1024*768-ban a Genoaval 16 fps-t mert, az ARK 2000-rel 36 fps-t...
Azert van nemi kulonbseg. (MCGA-ban csak par szazalekkal volt gyorsabb.)

Van egy olyan erzesem, az ARK 2000-t se, bar lehet, hogy csak szar volt 
az NT-driverunk, mindenesetre lassu volt, mint az allat!

        Stinyo
............................................................................
Idezet a SourceCode#1 "Re: 2 STOSW gyorsabb mint egy STOSD" cikkebol:

> 5. A VGA regiszterek allapotai befolyasolhatjak a video memoria elereset.
> Probaim soran 256 szinu uzemmodban csak a Memory Mode Control Register
> (3d4H 04H) volt hatassal a video memoria irasara.
> 
>   A tesztet egy Intel DX2-66-OverDrive procin es egy gyors lokal buszos
> VGA kartyan (SkyEagle az Alaris-tol NCR chipset-tel) probaltam.
>  
> Nalam a futasi eredmenyek atlaga igy nezett ki:
>  
> REP     REP     REP     STOSB   STOSW   STOSD
> STOSB   STOSW   STOSD   STOSB   STOSW   STOSD
> 2077    1337    960     2077    1337    960     Tweaked
> 2077    1040    522     2077    1040    531     Normal
>  
>   Eszembe jutott, hogy mi lenne, ha a DI nem nullarol, hanem
> 1-rol, 2-rol vagy 3-rol indulna. Ezekben az esetekben a
> memoria cimzes kellemetlensegei miatt lassulas volna varhato.
> Am ez csak 'futokod'-os STOSD-nal torntent meg, mely a hozza
> hasonlo STOSW sebessegenek szintjere sullyedt:
>  
> REP     REP     REP     STOSB   STOSW   STOSD
> STOSB   STOSW   STOSD   STOSB   STOSW   STOSD
> 2077    1337    960     2077    1337    1337    Tweaked
> 2077    1040    522     2077    1040    1040    Normal
>  
>   En a 16 szinu uzemmodokat nem mertem le, de azt is erdemes lenne.

Ebbol is latszik, hogy amit P. urnak javasoltam, az hulyeseg, mert
nem befolyasolja a kepreiras sebesseget...

A feljebb emlegetet, s altalam mar agyondicsert VGA chipset:
NCR 77C32BLT

Most egy P90-es gepem van (a bus rendszere egy nagy shit, bar
isa, vesa es pci is van rajta), a VGA-m pedig: PCI SiS 86C201

A gepemen az SC#1 tesztje:

REP     REP     REP     STOSB   STOSW   STOSD
STOSB   STOSW   STOSD   STOSB   STOSW   STOSD
7063    4126    2747    7270    4179    2790    Tweaked
7063    4126    2747    7172    4179    2790    Normal

(Ez nem a VGA kartya miatt ilyen lassu, hanem az Opti alaplap miatt).

Bye, TomCat/Abaddon
............................................................................
Az a teszt a VSPEED nevu progi, egy volt BME-s srac irta. Szerintem a
legjobb video speed tesztelo.

A vspeed nevu VGA speed teszt progi az almoson a /pc/sysinfo-ban van,
vsped123.zip neven. Az alkotot megprobalom bevonni a coder-l-be, nagyon
ert a dologhoz...

nagyd
############################################################################
bar ez nem igazan tartozik a listara, de hogyan lehet
egy bitmap-et ugy rakni html fileba, hogy a hattere a
html background legyen?
remelem vilagos a kerdes. pl. azt akarom, hogy a 0-s
szin helyett a html background-ot jelenitse meg.
koszi.
udv,
rod
............................................................................
Nos tudtommal a gif allomanyokkal lehet ezt megcsinalni, valahol lattam
rola egy url-t, de a hix guru valamelyik nyari szamaban benne van az url.
Keress ra a guru nyari szamaiban mondjuk gif vagy hatter szavakra.

Na itt talalsz html szinkodokat:

http://www.phoenix.net/~jacobson/rgb.html

itt pedig idezet egy levelbol:
---------
>olyan GIF-kepet csinalni, amin keresztul atlatszik a hatter. Nos, ez engem is
>felettebb erdekelne. Gondolom, valamilyen semleges szint kell megadni
>"atlatszo" pixelkent, de hogy ezt hogyan lehet elerni???

erre irodott itt Karlsruheban egy program (giftrans), amelyik normalis
esetben az ftp.rz.uni-karlsruhe.de gepen fellelheto (C-kod).

A GIF89 kepformatumnak azt a tulajdonsagat hasznalja ki a program, hogy
definialhatoak transzparens szinek. Ezt a GIF87 nem tudja, de ez esetben
csinal a program egy konverziot. Tetszoleges szin valaszthato atlatszonak,
de celszeru a #808080 (204,204,204) vagy e koruli szurketonus valasztasa.

hasznalata:

a.out -t #RRGGBB infile.gif > outfile.gif

pelda a vegeredmenyre:

http://www-rpk.mach.uni-karlsruhe.de/public/Mitarbeiter/Pocsai/world.html
-----------------
idezet vege

Home'r
############################################################################
 eeehhhehehe... tomcat ...
 jo fej vagy ... 

"a tomorseg fontosabb mint a rovidseg..."
hehheh....
mert szerintem a sebesseg nem annyira fontos mint a gyorsasag...

 -MonK-
############################################################################
Ez uton szeretnenk megragadni az alkalmat, hogy bemutassuk a vilag elso 
szimbolista koder-et, aki nem mas mint Ady Endre!!!!!
Ez lehet, hogy nehany embert meglepeteskent er, de hogy ezt igazoljuk ime 
itt egy pelda a hires verses alkotasai kozul, amelyben a Schonherz Qpa-t 
reklamozza:
                                        nev: deity
begin 644 ady.zip
M4$L#!!0``@`(``<.0A^82P1]50$``'H"```,````4T-(15A"144N05--;9)/
M;JLP$(?7('&'.4`4M=ONHK9/3ZV42HV:17=#&/%OL"O;(.$=7*"5D@/PX*+/
MA":B22T6P_#-YY\MEH6,B,&DH@[\5.RXC`@BVKGNTKT&_G(L`U^J&&YO;I+`
MUP:5N0O\P/?<^OOUM%I_;MYAY9[MZO5E[9T^O1F%D!,W(E]`07'M"D`+>VU#
M\KP)VJ99)N,*0?]3%2X<KV(R>UL1S-<$/[<&&$6.D0%M.R7J`9(VPP*C3LWA
M[P`9*`RY3Z%"(=!M#J)V4ZZZ=M]K-$;&1\S"D!W%TR9S?H(?!IY\.]WG4D-C
M\H,E0S_%YR`;VS&7XA0@[!F:\83ZU)^[M\B82#[?E!CO[@<W@_\<.)3*2C9@
M)#.R<Y(B+DB[P:L@CW;4E@[5/8A.VU$JVKSYS?T8UT6G(1ET%R*$Q&3:CPOR
M#&^`*2F_3WE,G@)6J*2X@$E$</R%_@-02P,$%``"``@`)UQ%'X6F8D2O`0``
M"P,```H```!$14-/1$4N24Y#35'-CM,P$+Y;\COX3@Y-J+)=;H@%(9"XK-@#
MB(.33.,VCKW8;I3XMGT!D)8'".V+,K$3LK)&\\UXYIL_SN#GB1+NHWZVOH`(
M#2_DY1"Q&D:C>!.-ZS%JZT<I3VKV.BTEEQ&+JQV+A;GC1JN(/_[^]/;+K_MO
MD\5:W;&J3_1^;\&Q#FJ@Y*LS?/FDI`'Y%.E9T5/20CTL]HNL5^D-)0^'XU'7
MW8MD^]?,9ME/5*8&]^R[,!Q+=Y1\/KN`>VTHD5PUO(J.8G#`'IUAWZ>J.*51
MPS7\_$APMO.1M[P:3?#<Y-ATV`>KH*2DXVK>4VCYG>7.Z7IQ547,CYRS<P.9
M2#9[+BBYN\HE-,Q0VDNC;;"YP-I/KOGCP4$,N8UW*2YAZ^R@'$8L$V8I\CUP
MR866ZYCAO"H2]DE8Z7I#=%'RX8\LM/%:NI74>C`@6[!S:IHC]WN_]GG"X]O+
M?PXU6K]P8A%U;I:S;<O-9LJMAW:T:X$")+CSXQ(5>K\/<#KP&SP/B-/:Y[1&
MG.00F]F+))MDBUN\VR'(HI'=BN0UH.0BR4N1I!5BU!GJ'&6;HDQ_.ZPVO7]0
M2P$"%``4``(`"``'#D(?F$L$?54!``!Z`@``#``````````!`"``````````
M4T-(15A"144N05--4$L!`A0`%``"``@`)UQ%'X6F8D2O`0``"P,```H`````
M`````0`@````?P$``$1%0T]$12Y)3D-02P4&``````(``@!R````5@,`````
`
end
############################################################################
peldul hogy szerinted minden VESA 64Kb os lapokat hasznal..?
a granuality mindig mas lehet (4k..64k) de a lapok maguk 
mindig legalabb 64Kb-osak?
MonK/Armageddon 
............................................................................
Amit probaltam (kb.10-15 TrueColor VGA), mind 64Kb-os volt,
es a gran is 64Kb-os volt egy kiveteltol eltekintve: a Cirus-on 4Kb.

Remelem igen, en a tobbit hanyagolom.

TomCat/Abaddon
............................................................................
huh... meg jo
mivel mar a fel kodom ezt feltetelezte...
azert a 4Kb gran. ne hanyagoljuk ... mikor teszteltunk
mindenfele buzznyak ismeretlen gepeken ... eleg sok nem
64K-t hasznalt...
(mindenesetre en barmilyen gran. kezelek..:)
Peldul mikor en is ugygondoltam szarok az egeszre es 
64k/64k lesz es kesz 6 gepbol 5 en nem futott
(az 1 az enyem volt..:) viszont kiralyul bugzott..
(vegul aztan megis futott az univbe betoltese uutan az egyiken az 5
kozul...de meg kell jegyezni hogy univbe nellkul is VESAs volt.
a maradek 4 en meg sehogy se futott...VESA SUX!):

MonK/Armageddon
############################################################################
Az egyik ASM progrmomba bele kene epiteni, hogy egy bill.
megnyomasara tarcsazzon es adott telefonszamra elkuldjon
egy fajlt. Ezt a leheto legkevesebb munkaval szeretnem
elerni. Tehat a kerdesem az, hogy hogyan tudnam egyszeruen
elkuldeni a fajlt es a masik oldalon pedig fogadni, letarolni
azt?
Szerintem talan az lenne a legjobb, ha lenne egy olyan prg,
aminek csak megadom a fajl nevet a tel.szamot es elkuldi a
fajlt (akkor ezt futtatnam az asm-bol), a masik oldalt pedig
egy prg varna azt es elmentene (de melyik ilyen?).
A lenyeg az, hogy a userekre ugy kell tekinteni, mint ha
analfabetak lennenek, szoval fo az automatikus mukodes!

TomCat/Abbadon
............................................................................
Egyszer mar erdeklodtem, de mivel meg senki sem segitett, ezert
megismetlem:
Az ALDRAN kepdigi kartyahoz irtam meg valaha egy keretprogramot
ASM-ban. Most pedig egy biztonsagtechnikai kft. az szeretne
tolem, hogy bovitsem. Azt kene beleteni, hogy amikor bill.
nyomasra kiment a prg egy GIF fajlt, akkor azt egy adott
telefonszamra is elkuldje. Ezt a leheto legkevesebb ido
raforditassal szeretnem megoldani, mivel az ilyen dolog
csak nyug nekem es pup a hatamon. Elveszi az idomet es nem
tudok azzal foglalkozni, ami erdekel (pl rt rt).
Namarmost kerdezem en, aki alig ismeri a modemkezelo programokat,
hogy ismertek-e olyan prg-t, amelyik egy config fajl alapjan
elkuld egy fajlt egy adott telefonszamra es lehetoleg meg a
kepernyore se ir kozben (sot jo lenne, ha rovid fajl lenne).
Ill. kellene egy masik program, amelyik a telefoszam mogott
levo gepen, ezt a GIF fajlt fogadna es letarolna...
Valakitol azt hallottam, hogy a Procom tud ilyesmit (??!?).

TomCat/Abaddon
............................................................................
Ertelmes otletet nam kaptam a listarol ugyan, de volt olyan
aki kivancsi volt, vagyis neki is szuksege volna hasonlora.
Ezert summa:

Navel-cord
----------
Tobb valtozatban letezik butabtol okosabbig.
Mindket oldalon ennek a programnak kell futnia.
Szovegfajlban beallithato az atkuldendo fajl.
De akar a masik gepen akarmit is turkalhatunk a
fajlban leirtak alapjan.
Hardver kulcsos, miskolci ceg forgalmazza.
Telix
-----
Sajat nyelve van az automatizalasra. Ami maradhat szoveg
fajl is a futas soran, de le is fordithato a sajat nyelvere.
A kepernyon megjeleno szovegek nem irtahtok ki.
Az EXE fajl indul el.
Procom
------
Ez is tud ilyet. ill van hozza kisebb (butabb) segedprogramok.
Talan ez jo lesz..
PUMA
----
Ennek parameterkent kell atadni a telefonszamot ill. a fajlnevet.
Nem idozitheto, de az nekem nem is kell. Ez biztos jo lenne, de
meg nem jutottam hozza.

TomCat
............................................................................
 TomCat : A modemes problemadra valami valasz szeru (remelem jol emlexem,
   hogy mi kellett, ha nem pontosits !) : szoval a (COM) port kezelesenek
   terhet leveszi a valadrol egy un. FOSSIL program (pl.: a BNU), ami raul
   az int 14h-ra, es rajta keresztul kuldhetsz ill fogadhatsz uzeneteket.
   ( Hogy pontosan hogy megy azt nem tudom, ha kell megnezem, vagy keresd
     meg a Ralf Brown listaban. ) Tarcsazas : kikuldesz a modemnek egy
     ATZ parancsot ( tehat az A a T es a Z betuket egymas utan a com-ra,
     utana egy cr-t ), ezzel alaphelyzetbe allitod ( ez csak az
     inicializalasnal kell, tehat egyszer a programban ), utana egy
     ATDP 1234567 ( + <cr> ) vagy egy ATDT 1234567 parancsot attol
     fuggoen, hogy _P_ulse vagy _T_one modeban akarsz tarcsazni (1234567
     a telefonszamot jeloli).
     Ezutan, ha a kapcsolat felepult a masik modemmel, akkor visszakapsz
     a modemtol egy CONNECT kezdetu stringet (pl. CONNECT 9600/REL  ==
     2400-es MNP5os kapcsolat).
     Na ezek utan, ha filet akarsz kuldeni, akkor meghivsz egy kulso
     protokoll programot ( javaslom, hogy ZMOdem-et hasznalj, ekkor pl.:
     gsz, vagy dsz.exe ), aminek at kell adni nehany parametert (benne lesz
     a leirasaban), nomeg persze a file nevet, amit kuldeni akarsz.
     Ha vegeztel, akkor kuldesz a modemnek egy ATH parancsot, es mar bont
     is.

      Atleta
............................................................................
En 1 utnak lattam, hogy keresek egy programot ami automatikusan
kepes elkuldeni egy adott fajlt egy adott tel.szamra es ezt az
ASM programombol meghivom. Ha irna kepernyore, akkor pedig meg
az 10H megszakitas rutinjat is magamhoz vennem...
Masik megoldas lett volna, hogy en programozom a COM portot es
a modemet is. Na ezt nem akartam, mert mar szivtam eleget a
COM port programozasaval mas ugyben.

Ehhez kepest nagyon tetszett a kapott tipp, vagyis:
- A COM portot egy FOSSIL feluletet biztosito program kezeli.
- En inicializalom a modemet es tarcsazom a tel.szamot.
- Es a fajl transzfert pedig egy kulso programocska csinalna.
- A fogado oldalon pedig egy akarmilyen modem kezelo prg (pl. Term90)
AutoAnswer modban fogadna az elkuldott fajlt.

Na mar csak a FOSSIL feluletet biztosito prg. es a fajl transzfert
megvalosito programot kene kivalsztanom ill. megszerenem, mert
ilyenem sajnos egy darab sincs...

TomCat/Abaddon
............................................................................
a temahoz nem sokat ertek, de talan ez segit:

darmol.elte.hu:/pub/pc/simtel-93/fossil

Directory PD1:<MSDOS.FOSSIL>
 Filename   Type Length   Date   Description
==============================================
BNU170.ZIP    B   74398  900411  Interrupt-driven serial port 1-8 Fossil 
driver
FOSIL006.ARC  B   10509  891210  Initialize/deinitialize FOSSILs of ports 
1-16
FOSLAUX.ARC   B    9485  890220  Fossil CTTY driver
FOSSILV5.ARC  B   25793  890220  Fossil release 5 specs
HZCOMM31.ARC  B   15001  890220  Fossil for Zenith Z-100
OCOM_531.ZIP  B   36248  921004  OpusComm v5.31 FOSSIL driver for COM1: & 
COM2:
ODEC_501.ARC  B    8408  880906  FOSSIL driver for DEC Rainbow computer
SYOCOM50.ARC  B    4274  890220  Sanyo 555 Fossil Driver
T2000.ARC     B    2889  890220  Fossil driver docs for Tandy 2000
T2KCOM52.ARC  B   55239  890220  Fossil driver for Tandy 2000
VDEC_004.ARC  B    3040  880906  Video FOSSIL for DEC Rainbow
VIBM_110.ZIP  B    3872  900904  FOSSIL which supports color
X00V124.ZIP   B  114161  910318  Interrupt-driven FOSSIL driver for BBS use

udv,
rod
............................................................................
Zoldeket beszelsz ember. Itt tenyleg helyesbitenem kell, mert hibas infokat
kozolsz. A fossil DRIVER-nek semmi koze a modemhez. Fogalma sincs rola,
hogy az milyen (nem azt a szerepet tolti be, mint a VGAknal a VESA).
Ket fossilt hasznalo prg akkor is fog tudni dumcsizni, ha ugynevezett
NULL modemmel van osszekotve a ket gep. A NULL modem nem mas, mint egy
darab kabel a ket vegen ket csatlakozoval (es persze megfeleloen bekotott
vezetekekkel). A fossil nem fog parancsokat kuldeni a modemnek (hacsak te
nem kuldesz rajta keresztul, de o nem tudja, hogy ezek adatok, vagy modem
parancsok). A modemeknek van egy jol definialt parancsnyelvuk (HAYES), ami
megiscsak (ahogy mondtad) tipusfuggo, de ez a modemek kulonbozo kepessegebol
adodik. A kulonbseg a kulonbozo beallitasi lehetosegeknel jon elo. (Pl impulzus
kitoltesi arany, felismerje-e a foglaltsagot -ezek pont szabvanyosak).

Koszonom. Ismerem a temat. Egyszeruen csak nem az volt a celom, hogy
elkapraztassam (osszezavarjam ???) TomCat-et, hanem segiteni akartam.
Ahhoz, hogy hozzakezdjen. OTLET kellett neki. A reszletek reaernek akkor
is, ha eljutott valameddig (egyaltalan tesztett neki a javaslat). A parancsok,
amikrol irsz u.i. NEM nap mint nap hsznalatosak (jo esetben), hanem arra
valok, hogy bekonfigurald a modemet, amit az eltarol es akkor is megtart,
ha kikapcsolod. Az ATZ parancs ezt a beallitast hozza vissza. Egyszerre
(a szabvany szerint) ket konfiguraciot tarolhatsz el, ha a masikat akarod
behozni, akkor ATZ1-et kell irni (utana az elso ATZ0-ra jon vissza, stb).

c> Kiveve, ha kozli, hogy Carrier still high, cannot hang up...

Akkor drop DTR. De mint mondtam, csak az alap otletet mondtam el, a reszletek
raertek volna kesobb is.

       Atleta/InTeam
............................................................................
 Most fejeztem be egy (munkahelyi) project-et, modemmel kellett
felhivni egy host-ot. Tetszik a Fossil-koncepcio (BNU), ha valaki
ilyesmivel vergodik, szoljon csak.
 
ERN0
############################################################################
 Kovetkezzek itt most egy kis info azoknak, akik sajat mouse-driver 
irasara adjak a fejuket. Az alant talalhato dolgok reszben a 
PCGPE1.0-bol, reszben a kisujjambol lettek kiszopva.

 Mostansag 2 fele eger van elterjedve a PC-ken ( tudtommal ). A 2 gombos 
es a 3 gombos. Mindketto egy soros vonalon kommunikal a geppel. Egymastol 
az elkuldott byteok szamaban, es az azokban levo bitmezok jelenteseben 
kulonboznek ( na meg a gombok szamaban, hehe ).

2 gombos mojzi
--------------

Egy mozditas/clickeles hatasara 3 byteot kuld, a formatum a kovetkezo :

 1. byte 01LRXXYY
 2. byte 00XXXXXX
 3. byte 00YYYYYY

 L/R : 1, ha az adott gomb nyomva van. Az elso byteban levo XX es YY bitek 
a teljes 8 bites megvaltozasok 7-6. bitjei. A 2. es 3. byte 6 bites mezoi a 
megvaltozasok 5-0. bitjei. A byteokat egymast koveto megszakitasokon 
keresztul olvashatjuk ki a soros portrol. Ha a beolvasott byte 7-6. 
bitje 01, akkor az elso byteot olvastuk, ekkor celszeru a byte-szamlalot 
nullazni, igy vedekezhetunk a soros atvitel esetleges hibaibol adodo 
szinkronizalasi bugak ellen ( ti. hogy azt hisszuk hogy az 1. byteot 
olvasuk, aztan megsem, szopacs )

3 gombos egerentyu
------------------

 Ez az allatka 5 byteot kuld :

 1. byte : 10000LMR
 2. byte : XXXXXXXX
 3. byte : YYYYYYYY
 4. byte : XXXXXXXX
 5. byte : YYYYYYYY

 L/R/M : 0, ha az adott gomb nyomva van. A 2. es 4. ill. a 3. es 5. 
byteok osszege az X ill. Y megvaltozast adjak. Celszeru itt is 
szinkronizalgatni a fent emlitett okobol, ezt ugy tehetjuk, hogy a 
beolvasott byte 7-6. bitjet figyeljuk. Ha 10, akkor az elso byteot 
olvastuk. Felmerulhet a kerdes, hogy nem lehet-e olyan megvaltozas, ami 
negativ, es igy 10-val kezdodik. Nos, kiserleteim szerint nem, ugyanis 
akarhogy rangattam az egeret, nem sikerult ilyen erteket kicsiholni. 
Szerintem eppen azert kuld az eger ket valtozasi erteket, hogy az ilyen 
nagy valtozasokat is kezelni tudjuk, a kulon-kulon vett ertekek igy vagy 
00-val vagy 11-gyel fognak kezdodni. Ezen tulajdonsag lehetoseget ad 
arra, hogy felkeszitsuk az egerdriverunket az olyan kulonosen perverz 
felhasznalok megmozdulasaira is, akik menet kozben kapcsolgatnak a 2 ill. 
3 gombos uzemmod kozott. Ha ugyanis az olvasott byte 01-gyel kezdodik, 
akkor az a 2 gombos eger 1. byteja, ha 10-val, akkor a 3 gombos eger elso 
byteja.

 Nos, most, hogy ezzel megvolnank, mar nincs is sok hatra. Nyilvan kell 
egy inicializalo resz, meg egy megszakitas resz. Az inicializalast ugy 
celszeru kezdeni, hogy az eredeti egerdrivert reseteljuk ( AX=0h, INT 
033h ), eztan lekerdezzuk, hogy melyik interrupton log a patkany ( 
AX=024h, INT 033h ), eztan lerugjuk a regi drivert a 
megszakitasvektorrol, ratesszuk a mienket, inicializaljuk a belso 
valtozokat ( pl. a byte-szamlalot ) es mar kesz is. 
 A megszakitas meg szepen sorban beolvassa a byteokat, es kiszamitja a 
valtozasokat ill. az uj kordinatakat, esetleg figyeli, hogy ne masszunk 
le a kepernyorol, meghivja az egerkurzor rajzolot, kavet foz, stb...

 Akik megneztek az AsmWin demo-mat, azoknak koszonet es hala, egy kis 
kiigazitas : amikor azt irtam, hogy 'toltogetheti az egerdrivereket, nem 
sok hatasa van' ( vagy vmi hasonlonlo ) ezt nem ugy ertettem, hogy nem 
kell egerdriver, hanem mivel ugyis csak az AX=0h funkciot hasznalja ( 
hasznalta. Amikor a fent idezett levelet irtam, akkor meg nem volt 
com-port detektalas ) tok mindegy, hogy milyen a driver, mert ez az egy 
funkcio ugyis egyforma. 
 Ha valaki kicsit tobbet tokolodott, es mondjuk tobbszor clickelt a WIN 
ikonra, akkor tobb ablak nyilt le ( egymason vannak eredetileg ) es ezek 
kozott kapcsolgatni lehet. Ha lenyitunk joparat es TILE elrendezest 
hasznalva ( picinyeg el kell mozgatni az ablakokat, mert nincs AUTO-TILE ) a 
legalsora bokunk, akkor a folotte levok leradirozodnak, aztan 
ujrarajzolodnak, aztan kirajzolodik a bokott is, mosmar ez lesz az aktiv. 
A dolog persze eleg gyorsan vegbemegy, de szerintetek ez nem zavaro ? ( 
marminthogy nem az, hogy gyorsan vegbemegy, hanem hogy igy ) Egyenlore 
nem talaltam mas megoldast, mert az ablak mogotti teruletek mentesre  
kerulnek, es ezek konzisztenciajat csak igy tudom biztositani. Ha 
esetleg  van valakinek otlete mas algora, szoljon.

                                        Remelem nem gepeltem hiaba...Paf
............................................................................
Kiegeszites az eddig leirt infohoz:

Ha az eger 2 gombos modban van akkor 7
ha 3 gombos modban van akkor 8 bites atvitelre kell a com portot allitani !!!
(Forras: NCC azon belul  Serial settings , vagy valami hasonlo)

Ezekutan erdekelne, hogyan irna valaki olyan egerdrivert ami lekezeli azt 
ha menetkozben atkapcsolod az egeret. (Pedig szep lenne...)

Hyp-X /Demons
############################################################################
Pogi:
 Mit tud ez az Amigo 3D? Fejleszted-e?

Nicke:
 Te is neki kezdtel egy tracernek, ugye? Lett belole valami?

TomCat/Abaddon
............................................................................
OK, ime egy rovid ismerteto:
 Kb. masfel eve valahogy eszembe jotott, hogy meg kene probalni irni egy 
raytracert. Ekkor osszeszedtem hozza 1-2 dolgot, es elkezdtem kepleteket 
irogatni a Velencei to partjan :-). Amikor hazaertem a nyaralasbol, 
nekiestem C-ben kodolni a stuffot. Egy heten belul megvolt az elso valtozat.
Ezt egy ideig meg javitgattam, de aztan elfelejtettem az egeszet. Nemreg 
pedig csinaltam vele egy animot, ami eleg szep lett :-}.
 Mit tud?
  * gomb es sik, valamint minden, ami ezekbol kijon boole algebraval (pl. 
egy kocka az 6 sik AND-je)
  * tukrozodes/fenytores (bar az utobbit kiszedem, mert bugos volt)
  * 3D-s texturak (most csak kockas, meg ilyesmi...)
  * scene file-t olvas... eleg "unuserfriendly", de nem ez benne a lenyeg...
  * antialias (nem adaptive, bar nem lenne nehez belerakni)
 Tehat az a helyzet, hogy ezt csak ugy magamnak irtam, mert unatkoztam... 
es nem is szandekozom fejleszteni. Esetleg majd egy ujat...
Te akarsz Pentiumra tracert irni?

Udv: Pogi
............................................................................
Igen, ill. mar irtam is az volt a fosulin a diplomamunkam (PenTrace 1.0).
Azota mar rengeteg uj otletet hallottam hozza es folyamatosan fejlesztgetem.
Hamarosan kesz lesz a PenTrace 1.1, akkor majd fel teszem a WWW-re:
http://rs3.szif.hu/~tomcat/RayTracing.html

Mit tud ez a PenTrace?
.nff (text) fajlbol szamol
.img (ala Vivid or Alias) fajlt
Arra voltam kivancsi, hogy milyen gyors ez ASM-ban a
Pentium FPU-ja segitsegevel. Tehat en sem egy hasznalhato
alkalmazast fejlesztettem, hanem inkabb egy kiserletnek tekintet
a programom. Persze ez egy altalanos rutin, igy a demokban
alkalmazhato limitaciokbol eredo gyorsitasi lehetosegeket
nem tartalmazza.
A prg ismer:
- tukrozodes
- fenyateresztes
- fenytores
- phog hi-lite
- gomb
- poligon
- bounding gomb
- bounding box
- (poligon patch)
- (shadow cache)
- preview

Aztan irtam meg egy 4k introt amiben 16 tukrozodo golyo porog (CHROME).
De ez is reg volt, s ezert eleg lassunak mondanam manapsag...

Ma a real-time ray-tracing-re torekszem...
(Persze tudom, hogy ez csak nagyon komoly limitaciokkal lehetseges...)
Ezert keresek beszelgeto partnereket a temaban, hogy minel tobb es
tobb otletet ismerjek meg...

Most ennyi...  TomCat/Abaddon
............................................................................
 Nagyon erdeklodtok a raytracer utan! Sajnos ott szurtam el hogy C-ben 
kezdtem neki es az Introduction to Ray Tracing konyvet vissza kellett 
vinnem a konyvtarba. Szoval abbamaradt, rettentoen keveset tud, szar.

                                                Nicke
............................................................................
Nem rossz a C ilyen celra, foleg, ha csak probakeppen irod... a jobb 
tracereket is C-ben irjak, esetleg ASM betettel...

Udv: Pogi
............................................................................
Mi a velemenyed az emlitet konyvrol? (ugy tudom ez _A_ konyv a temaban)
En meg nem lattam, de egy adodo alkalommal megvasarolnam, ha tenyleg jo...

TomCat/Abaddon
............................................................................
 Szerintem vannak benne jo gyakorlati es elmeleti dolgok. De szerintem 
egy csomo dolog ami engem is jobban erdekelne csak elmeleti sikon letezik 
a konyvben bonyolult(?) matekkal. Ha fent jarsz a Schonherz-ben akkor 
majd megmutamom. 
                                                Nicke
............................................................................
Erdekes dolog RayTracert irni, en is probalkoztam (-om) vele !
Szerintem tiszta C-ben raytracer-t irni eleg hulyeseg ...
En a hejedben ASM-ban irnam koproci felhasznalasaval, de persze
egy kis C (esetleg Pascal) is mehetne bele, DE NEM A SEBESSEGRE ERZEKENY 
RESZEKNEL !

LGB / Digital Creatures
............................................................................
        En az irtam, hogy ott szurtam el, hogy c-ben irtam a rt-progit
, es ezzel azt probaltam kifejezni, hogy nem c++-ban vagy hogy nem 
assembly-ben irtam meg. Egyebkent assembly programozokent dolgozom a 
Deity-vel igy azert van egy kis gyakorlatunk, igy nem kene leszolni egy 
kezdo rt programozot....
De azert igazad van a programnyelvvel kapcsoltaban. 
Bocs, de most egy kicsit reszeg vagyok, ha megbantottalak akkor bocsi.

Egyebkent ha rossz algoritmust irsz assembly-ben, akkor az nem 
feltetlenul lassabb mint egy jo C algoritmus.....
En mondjuk CSG-t hasznaltam az object modellezesre, ez szerintem eleg jo 
lenne, ha lenne ertelme az egeszet megprogramozni!

                                                Nicke
............................................................................
Pillanatnyilag elfut 386(+387)-en is. A Pentiumra optimalizalas azt
jelenti, hogy ugy van megirva, hogy Pentiumon ez a leggyorsabb (tolem).
De ha a 486-ra akartam volna irni, akkor mas utasitas sorrend vagy
mas utasitasok kellettek volna a leggyorsabb verziohoz.

> > .nff (text) fajlbol szamol
> Ez kb. hogy nez ki? Tudsz adni peldat?

Netural File Format by Eric Haines. Sok eve keszult,
minimal funkciokat tamogat, rovid (tomor) es raytracerek
valamint 3d-s programok fejlesztesehez hasznaljak...
Rengeteg ftp serveren megtalalhato a formatum leirasa.
Eloszor az MTV raytrcaer hasznalta. Lenyegesebb felhasznalo
program pl. az SPD...

> > - (shadow cache)
> Ez pontosan mit takar?

Csak kb.:
 Amikor inditasz egy shadowray-t es elkezded vizsgalni, hogy az
adott metszespont arnyekban van-e, azaz blokkolja-e a fenyt valamilyen
masik objekt, akkor nem mindegy, hogy milyen sorrendben nezed az
objekteket, mert ha az elozo pixel arnyekba volt, akkor valoszinu,
hogy ez is arnyekba lesz, es ugyanaz az objekt fogja blokkolni a
fenyt. Tehat ha ennel az objektnel kezded vegignezni az objekteket,
akkor egybol veget is er az arnyek vizsgalatod.

                        TomCat/Abaddon
............................................................................
> Majd utananezek, mindenesetre hasznos, hogy nem sajat formatum, igy 
> legalabb vannak utility-k hozza.

Aha csak kar, hogy pont a 3DS2POV nem ismeri, mert 3DS fajlt nem
tudok egybol konvizni (DXF az megy). (Amigas csemege: Sculpt4d2nff).

> Mikorra varhato az uj valtozat ?
Azt hiszem mar csak a shadow-cache-t fejezembe ha lesz egy kis idom,
ja es egy kicsit a truecolor libem tesztelem meg. Gondolkodtam meg a
tengelyiranyu csovek mint objektumok beletetelen, de arrol atmenetileg
letettem.
> Es min torod most a fejed?
Most a PIED intronkban levo rutinom (a csiga) egy uj valtozatat
csinalom meg, mert kivancsi vagyok, hogy az uj otleteimmel mar
menni fog-e real-time (kozel 60fps) a kicsike. (Pentiumon)
A legtobb jo tippet egy new-zeland-i skactol kapom, aki meg
nagyobb megszallott mint en, mert o 486SLC-n probalkozik ilyen
dologgal es most nala 6fps egy 100*100-as kep egy 320*600*256 modex
VGA uzemmodot hasznalva.

TomCat/Abaddon
............................................................................
Csak egy gyorsitasi otlet, hogy ha majd kezel csovet a programom,
akkor a bemeneti fajl elemzoje felismerei, hogy a cso tengelyiranyu-e,
es ha az akkor egy gyorsabb rutinnal teszteli a metszespont keresesnel.

> > TomCat/Abaddon
............................................................................
Nos vegre itt egy ujabb introm: a SHELLS1

Mar a mult hetfon akartam feltenni a listara, de egy csunya
buga, egy allo hetig szivatott...

Lehet tesztelni...
Nalam csak a /n kapcsoloval 60 frames/sec.

RTRT rulez!
FPU rulez!

TomCat/Abaddon
PS: Erdekelne, hogy valakinel mukodott-e a koproci teszt, mert
nalam nem. Na de kicsire nem adunk...
Egyebkent a papir Forraskod c. ujsag 1. szamabol emeltem ki a
tesztet, hat ebbol is latszik mit ert az az ujsag...

begin 644 shells1.zip
M4$L#!`H```````,C71]"<6I"2@```$H````+````1DE,15])1"Y$25H\*CX^
M(%-(14Q,4S$@/#PJ/@T*4F%Y+71R86-I;F<@:6YT<F\-"B8@8F5N8V@M;6%R
M:R!T97-T#0IB>2!4;VU#870O06)A9&1O;E!+`P04``(`"`!]>5T?1$IO6;`.
M``!T#P``"P```%-(14Q,4S$N15A%55=[7!/7\I_=S88E#Q(D8'P$(B)&0$"C
M%H7L;D0IJ,4`/D`LTE8C8@$;@K7:JQ%$T5"D(/BHMB!BL86K4FMY5$E`!44L
M@M<&"8\B:C06\<5;<Z._>S^?WYT_OF=F=F;W?,[LG)GY:(T:(0`!%``LEG=,
M<C(@_99)8.6M5#$GKVH`<`!_)@K)$V>*822K>73F!,C2*2KK0&I9?7D1,O:R
MN/&";=5LI&E*DS@T22W>D)B4LC%.G+`A(4GUE=N;S/:(M+J9V+W,)FVMII=W
MGJ%]T?I0>^OVX]!0[5M/DZ<AZVI6^\OBL:P.&V8-(-*!LKPJ/IB]LLORROGF
MN>]QWGOT?X\?O\>8][CN':J(4[?_7J)^E3PDO2YM?\=>O=WZ;KERNS6]73W^
M'5MSNU4SRE2QK7P*XYW3[5;O`P=C$,TP2ZV6MJ<-HVJ/=W8G5%/?+<?_[P7?
MO5_^ZZ`919,=O0_4)"*E!PRKM(.>+T=>NI\:C3'O_A\C0M7^/_)X5>/_DW??
M[X*]7>9+I6B#YE\08$E)C=::T^KX4EWIM_?MRK"Z+%W987=$U#-L?FJ5K.==
MINT>+<,,$64*ZT%U2'5:@[9!VZPU:?NU0XT8H"P&#N^):4/8(M908@R<"?\A
MJXK%YG#_(RT`>(W8V4D'I)9*S;NGUMBY_,Y'>$CW&034/@`F5XA(4JF^\A*K
MK.';N@$4XJBD%)5XE=\\\7K5)J!YJBE<EHW;F@NV35,J8!FBP7EB70D_Q=ED
M#T&*E8L>2[](V82OQR4PK?W^Y4V\BYP@38`X!0JPH)ZA].MJNS*93Z@:%PSA
MB>.*'+DFWY"SWUDL^#'BCU8ND<//.0A'8#KD(I+,!B7O-YT2<'TW0XDP+R$Q
MM4[5B(`N.H&,:^"?_`')<#_Y;2Z[HF7&U*)B!UKX(S+BS.05\$H\H)+SVE7W
MQ`XEH`)RQ)!ER-)E=6>9A&YO0Q"A.[J`=X97:#-VU65T9*8#'WS"7(-=[5PB
M!1[_<.!NTJT5T!BP5NJHE\J?[6Q8DII)=S%X?`NM/&;-!V1Y6!,_6K8<4L;5
M,TLQEL2%P2S!.&!*GV*"?J@<ATQ1)U?T\ZLMQ>!M)_L\Q2;3[C2V+/KQ69@[
M/!<)!\Y);.XUI@JC*QQP#4BJ&K#9NKZ%E4#U;=J(?(LQK"FX^[$%DI^4WZD0
MP+,*#3K^_K/R*Q4,)@OE/9/2B"X."FRT0W.7OOS9G&C=$0WN`RF,H@+,_<#B
M"3H3ZQQ>F*0>+]O"J+!UO)DB/FQ;,8BQPR&O:++27;N8HRQ:N>*4#\$O.C@#
M(I9G2-LK;)9K&[5G?%MS[SC8HL\06%]G;\=DVY"V"_E/[#/'T6%=CH^<&%57
MG`')%F35GKO?EPL8^P[0ES=CE;;P,JDNIZH)ZVM$T(<:FV,8@#`]7+?7>]#]
M6`ZDQWKO=_H)\[8X;ZOSUH9\P<:<A.9'QU9R/#E3<<3SX&'O--)#XZ5F*W),
MM99(@9W.%AM2-=8IB]%T2PHH,%.UI>=9W:\,99GRYW-YZ-NFE`&G8B>SQPR)
M((>1FT`S\CCZ;D+)*S6$:/"?I]F$1YAV6J+7S&@;)\1-_-ACX_%P4YS%T?0T
MW+%9Z!BV8F1%V#DB;+)MR>_!"M/<@B5O%L3R8YV16,/97F$L$:N]ZOW[M(#A
MMY$[C_LW[^E]NT8$NY`]S6][4#/V>)NECD%7H/:[GH4I5J_*T61,&T.4.(*A
M\),'';(N[1K'/6/Q<H3%*/X!>KIBUDV-C`)HOI+<G-;'QX;U?S&PYW4FY@[`
MGXXQ`C\;(\;XN79C@GN,F,H":RI*+6&K*A6PVMOB5(I%>ML#=LBS'AM*QFC$
MM'XX)JJG1RS5F;X8!AA12MMGZQYNZ?TB(.K+@0,&4+CQ`FR_[/,P-)O1.EU_
M-0,UG$-%S;L]1,W-3]!:'0-77"P/&.C!IC*F3K4#]M0JOMV1P1ZEOH>OM>Y0
MB=U3[G<>SU5>Y@<34'DAN!_"H*J<H<U$JE`V`57.JPH=N>FZ%&[5/?$4[&D)
MD3**JT>SG%WAZD"-`"I$8#HG.#%4J0RJE+!,7P\M?/RH-\8%/ZH4K^S5UBD]
MF8^*&$L7,6\9V2WC;@F)6Z_6H>Q;LWN;G%P=*S`_9X#N%:I//MN4N%&LWI2P
M88&X0?"+LG"UEE[TM,K-35F]?B<.X9TMRL&7RIP[K+W=N`!\?16[:I7I+2DF
MK5&C<Z-\4Y!`;>L\[0/6"D8REQ44CO@L3?9)WO"9=UC%@=G]$#@X;U6XJOZ\
M9S0*WB&SED56S1_L*5ST$=8RWXGIV+>BRWLE!F<]UR"G6]`W8O%\'IO!G6CG
MTH'3-_(#F7Y,7\F/S+;K'3LYQ-"99?P;!,%/__C&..-,A>O6-B)X(A'9FD!X
M">?P#^=Z$6("CTL871/+W(+@3,/-MB;C=<."6\8;FOF&QK:;G8V=]]&.Q(6^
M2R1+!DO]EGS*C'H;RQ0S$S^U76)&.T1T^1LW43!3<?R7`"-W8>A8"D<8S`E7
ME'?JT;:1-K.[`W];R5Q3SXNVM%C1YL[K;;B$]=3INM^<A+OK\?6<>4OC\7B.
MXM%Q9%GGL*OTQ#QAZ8W6OQ<\#";H@;_Z%)_3HG"BA!U.7/P[7*0358DT,D*B
MQG8PKW"8%YEW.7Y]`WBF;Z9?]:1,R1[.`N9VU\QVW*U?(^8:V4+#\^@%`R_\
M9//-`\9I\41I33P1_\$A[D3B5KRX;P")]XV7U+#C_9SBG$1\D1_RN5L`A%9G
M(WS<6I1U:4.+5&I9+ZJ;E)R0-NRBBML]G'ZG@1O+[VZKO38/O6YH8-S@`2/>
M.&P<Z2R('>V8U!%-8/PV_&G+E))H(;$KK4Y,=R0^QX?QX1^YN-[_$2\U=D.5
M!9&[!'?83*>GG]_@Z\]UF_[!=(Q%Y%^.M<%KLAL=&*2/V<!LXM[YTY$Y&^$T
M<W1MHP:[CO"CZPC<Y9^]4;X3>)7,CM7"67J6V##-N^-#OG%:<SC?E@B<83NC
MPX;8-WMH_FI?/!*7N*SVR\Z[M=P>?X#:XWX3N@5@_%`<2J==8Z35!X>D+*O;
MUR9:7:'?V*XW,92*DW^^\L\@#@5"N9YQ/K8\K2_X?$UJZNR.((F1C?L:EQ+A
MB=:?BK^!I=$9O@RBVWJ[NK_GI?XF3(WT#1EY;(P0\M/*^.G\#DY'(,',%P;R
M,?:6OR(@NKEED"`TA[#[1B6!NY>OG:#<F"2,U?>((N-BM^YGQDETC6LE%0^E
MD@;)^(^W!6]YE1VL&>'&YF(!W,BO4^]QXRH,(H/7>OI2!WZ$^*2M;N\0A.1$
M=3&E:L[J7_YHX41P-+V3D4%QC\.4+5,N16@8G?:[VG1[7>T*+%<-NJ?AC=0/
MG9'48=Q#'[XS$V=/T'QSL-O@V*__?JM_.3W_W.2VY_/UCKV.*G<#WJW.=^PG
MPDOVUR7JS8+0T"^99C7AY=F.>VE##C_/T&K8:[8<R-[87FXC$34SC[JOTW+G
M%++]0:W?BFKUO-):HK"9P1-I7F&\`W?U-XC]X]/J&?R]A;M'P47&2\U\8[%,
M.%7XFE6XK]U:<M#LR`_VR8/L]\B'WVCDU@YH9(>\=])6N2YVB_Q:?;P<:`_%
M!KG[\#KYH'Z-O/O,2@0XYQ1RISM+Y6\%'\IGJP`6R@FS3-ZY<[Z<-W.N''T-
MX"N?>-=+?N4/B7SS7V[R-!8HILB_7B*2MQ1,D+_A.`%PLL;)_W#CR7?\P9;C
M681<`$/K\!6+4'G^MK?T,>O5.D3WZ5_0=1/_II?G/:)UO@`]=/13([VF_D\:
MU[?010:`)GH/]SH]%'.%7GFSAAY8`5!-SQNZ2&_]M9QVSOPG?6@'P$_TXK33
M=.')D_2DMN_I&>X`W]$+]Q^F>Y%#=.[!;/K&+(!O:"?3?GKX_%X:/9A&7]H)
MH*&_0G;0;C-2Z)+D)%K:#;")'DM83_M/7D?/>A)%N_P)L()6]"RGV>RE=($B
MB(XK!UQ.7_21T8_J_8YLGT,+8%N0[^>>7K1\AH2^3@*XT6<VB^G59R?32VPG
MT*/;`!QI\QM[^OO#=G3>8C8=80,X0<<;&?0G5Q#^/]Y0`.K\0>KKEN=4K^]3
MJN?<0ZOF5-A?5/(X([7GQ5U*\OPV!8(3W"9JSH<-U.(3=7P>0`WE=;R*J@Z\
M2,W$RZE770!E5%+K&<JVJYA:@)ZD$@(`OJ=<OSE&-;[,I\Q)N=28M8)F4_M.
M9U*\V/V4R\R]E-S:\Z99/Z:A.FRW4XH/U-2N?3@D,H;CJ)+,SZA9=`QU"J4=
MHB)7$([+*9WU!UA",;Y93*UZ25.BE`"J$,#>CUK;(*7RC_A0];L]J<TL3=IT
MXOA4*J[)A;HFF(RR)JN$5.X#P:$$>PU*C;#L*-_?6>K=-M1Z@"@&M7$10F6D
MC9&>)P?(9P#W^\G''YK)Y4T/R,CD;G(MP/QV\@OGNR3?]389&GB3/`VPNY[\
MR%A+7@J_3'KW5I*#``=_)7-7GB>WSRDC'WB>(1.LHU@QN?G30G)-P0FR_-51
MLJ\`8O+)?9TY$M5!\I[UX@8RPY`14)).OM*FDEG67-A%?NKP%;DJ*)F4'$\@
M&P$<XLC9I9^2AO4?D_-DD>0;ED8:D1D<2L[:$4)R;BQ"8<X<FG2I]B=MUGY`
MW@=PDI);S-YDH<&#E':ZDQ\7P*@K:?1QV;-]$OFZ?3QHR&OA`O)@)Y^\N9-+
M[I"R4.",,LGZNQC9=05(:W=S8%0VX^QKV4<#SV3LV">RVP!/>F7"_"Y9]"?W
M9)E+_R6SVD0TRR9O;Y29?K\F8TRNE3UA0?XEH5>E[*GQ@FSKZ7,`LO/[2V6L
M]!+9[B.G9+9U5A=9$>.$K&'M45G"C3Q9]D<Y5DWI@RS9A6^ULI*P#!DV+;T8
M9!M2W6QVRG:*MM6FR^A)!7K#VG3S+.K(\2---Q&QKC256*E;K%E,7ZQF;!5O
M\N?[ZSCY_3]64WY!DL]_XQ]%'A-MT3Y$)2[D=Q?WGX[>FE'D%Z6;?A4GA/T+
MCR^373JRJ2`DE1!?".3LRJNY*V6"Q3I[N:%!J`D!]@NV`Q=M`2[4,/X[D"'_
M!E!+`P04``(`"`!">ET?T,!@#!H$``"E!P``"P```%-(14Q,4S$N3D9/C57;
M;N,V$'T7H'^8?6JRM1W9<8R-@*+5)LH%B1W#4G9[05'0TLAB+7$,DHKK?$<_
MH)_:H>PXV6QZ(6!`Y`S/G#DS',/+E5S%M[=)OP/S#:2B%@9NQ$J3RH2$@Y3J
M,V&!"HCF(L])'?H>?+5F8M.U6F12+4`JJPF$RF&.*BN[M=!+L&CL6Q>_6/V@
M.SCM]D]/3WS/]^Z-6*#O?>>6[^U(PB]'DU]][V@20DZ@R,):2.O"%J3!E@@/
MJ*W,1`4:'2-D%FQ"6.O6;TO"4NMK,HVH>B[:&:E"+AHMK"2UB_JT?&^,->E-
M"+5#LJ50,`J"&]^+QPGD4G/,D,G`JD)A\)WO74SO^0`QQYQW9VYW_&'4&?)O
MBLK*IN[U..RGRRB$M;0E#$Y&P`GT1V/(J")M'*<4LU*UN>1HA:S,*UY;;BDG
M4J,M*0_AY^Z\*0K4R.*+;+D6.@?]7!LG*ILX+*MCJ&I<LH:Y#8+W_9'[C3LP
M&K[:##\$[YD?1](-;NF!:58KTI;!2(7P*4XBF!-',VWATR2>7$*<#H,@./I\
M/.!,I;8-)[)5'(Q\Q'U86,D_T"67NGKE(#2*$%H*P6!OO-"B1N8Z&`:^=S?_
M'3/+NSZ85<GYPA&@R$HHG)?OW<I%V9I];T(AF%+DM.X`RZ!,+8WAM#LL05$Q
MRM,W!W??P'IG3=7V`8>=EJ064#)>Y3#W5J?P)FR[J**%T%S$6F8@E;&Z:8&,
M>S3.?C&]?ZJ2ZR*H*<<JA`M&@1FR*&,^<!V8LR:[]@!:65FS2KGOQ3_&4,@*
M8<4EW<6=WMQ>IS%\"^.9^VB[A2-0J\O+-O&]C!5A7:B&)(TFY]'L'*:SN[/X
M_'X6W<)YE$8?HR1.VN<?:\[A2DB%I@/'YT?Q!CMPK;*>[ZU+R?H:*NR:"]1R
M$0L$:=I7F-%JHYU`KGXJ9YD4S!$:UVX%E[S:,,0!%_A!,C(MOS]TE),5N@1W
M1*\MY+A"E;-RJE7.-6KF>MA![J3L@4MTCL:&OM>%#350B@<$L9>.G;:/RMUP
ME6-?&%\]=G;^^AFW%`8>T(BV)E#));9-.0BV[?\4P#`<)T_%MJ#_-7+:@3(A
MNYM>OA=!W?#]=GJ8BM:HW1W7A=L>81$U-8SIL`V(2J/(-V!*6BO?D^S%I$?#
MY6ZV<JB*=9U*)[:%*!E_<WK"-KC"RDBUE"V!2Y;=T31@Z<O!X7MC4654U9"*
M347:]Z:BJ2#I,4"VG',VOO>B$W;CT8K,<I#B*["D%K(*7_QII*+^R^RG_>7F
M3[W??*3,+-FEZ8UZ^\.K[FDP&#YO[R>7T>PGYK`%ME1GPOY0"V-1]PI:]LJF
M=2:]-VISW#./LGC3U'\V,5NYV,UW^/]K_7G];_]>KU)OSPX(Z/`?+W7?6$1W
MW8/?#KMW1+SSO;\!4$L!`A0`"@```````R-='T)Q:D)*````2@````L`````
M`````0`@`````````$9)3$5?240N1$E:4$L!`A0`%``"``@`?7E='T1*;UFP
M#@``=`\```L````````````@````<P```%-(14Q,4S$N15A%4$L!`A0`%``"
M``@`0GI=']#`8`P:!```I0<```L``````````0`@````3`\``%-(14Q,4S$N
93D9/4$L%!@`````#``,`JP```(\3````````
`
end
............................................................................
Megneztem a shells1-et az edasz-nal :
dx2/66
tvga8900d

ha jol emlekszem, 9.5 koruli frm/s lett rajta.
otthon meg nem sikerult megneznem ( nem a videokartya miatt, hanem mert 
nem vittem haza ( meg be se kapcsoltam , hehe.. )) , majd talan a hetvegen..

szeritem a chrome jobb buli mint a shells , nemcsak az animacio miatt, hanem
gondolj bele:  aki nem tudja pontosan, hogy mukodik a rt, nem igazan 
fogja ertekelni, hogy egy csomo golyot kipakolsz a kepernyore, mivel se 
tukrozodes, se fenytores, se arnyek, nem is igen hasznalod ki a rt-t. 
vegul is azt is gondolhatja  ( es szerintem sokan azt is gondoljak ) hogy 
egy nagyobb golyot kicsinyitgetsz, es pakolod ki. ok, ok van csillanas, 
dehat azert ez megse full rt...

ezzel most nem leszolni akartam, ezt gondolom te is tudod, de mar 
tobbszor elofordult, ( nem pont rad gondoltam ) hogy nem jott elo a kod 
erossege,  mintha ferrrarival varosban cammognal 30-cal...

n.
............................................................................
Igen, az ilyen rkurzio nelkuli raytracinget sokszor nem is raytracing, hanem
raycasting neven emlegetik. Na egyebkent en azert megneznem azt az egyent,
aki egy sprite zoomolgatasanal igy kiszamolja a gombok metszespontjait.

Mivel eloszor az alapdologokat akarom maximalisan felgyorsitani, ezert
eloszor csak azzal foglalkozom. Egyebkent a shells1-t ugyis csak egy
speed tesztnek szantam. BTW: van valaki, akinek a /n kapcsolo nelkul is
60 frames/sec. ???? Masik kerdesem van dLuxon kivul meg valaki, akinek
a VGA kartyajan nem futott rendesen a SHELLS1 ?

Minden valaszt kosz,   TomCat/Abaddon
............................................................................
dx40
s3 (noname)

 8.89 fps (/n nelkul)
10.43 fps (/n kapcsoloval)

Nem lehet Z-bufferrel megcsinalni ? Az nem olyan lassu.

Mindenesetre en ezt 23 sec / frame -nek neveznem. Merhogy egy kepet 
rajzolt ki ennyi ido alatt. Es igenis meglehetne csinalni a fentebb leirt 
modon.

Hyp-X /Demons
............................................................................
Ez meglepoen keves. Valoszinuleg az s3 olyan tetu truecolorban!
Kb. a duplaja itt a suliban egy dx4+cirus konbinacion.

Itt az FPU hasznalata okozza a nagy sebesseg kulonbsegeket.
Egy Pentiumon nem lenne gyorsabb, ha haromszogekre bontva
z-bufferelten phong-shadelve szamolnad a csigat...
(Persze attol is fugg, hogy mennyi haromszogre bontanad a
gombot).

Az egyik szuk keresztmetszett pont a VGA ezert semmikeppen nem
lehet a mert eredmenyt egy kep kiszamolasara vetiteni. Egyebkent
a gombok egyszerre valo kiszamitasa boven 1 sec alatt lenne...

TomCat/Abaddon
............................................................................
Mondom dx40. Nem dx4. (Az 100Mhz ugyhogy 2.5szoros)

Miert kene haromszogekre bontani ? Az tenyleg sokat lassitana.

Ertem azota. Minden fazis utan kirakod az egesz kepet ugye ?

Nem emlekszem ra mar asszem jol, de miert is kellett ehhez truecolor ?
(Azt hogy a chrome-hoz miert kellett azt ertem.)

Lassuk ! (Ez ugye a P5-os gepen 1 sec ? Hany MHz ?)

Egyebkent hany gomb van ? 240 ?

Hyp-X /Demons
............................................................................
A SHELLS1-t nem sebessegtesztkent kritizaltam, hanem mint introt. sorry .
nem olvastam el az info file-t.
mire ez a level elmegy a listara, gondolom HYP-X-nek  TomCat is 
valaszolni fog a 23 sec/frame-re...( kb. = mert ha a vegeredmenyt vesszuk, 
akkor vegul is igaza van, csakhogy a shells1 kirak 240 kepet (mindegyiket 
kulon szamolja, frame 1 = 1 golo, frame 2 = 2 golo.... frame 240 =240 golo)

SUM: szerintem intronak nem annyira meno, a tesztnek meg nem en vagyok 
hasznaloja...

n.
############################################################################
tudja-e valaki, hogy hogyan megy a julia morph
egyszeru fraktal effekt realtime?
azt tudom, hogy a fraktal kezdo parametereit
valtoztatva kapjuk a morph effektet, de ez
meg 16 iteracioval sem igazan 50 fps bizonyos
frame-eknel. pl. a verses fraktal effektje 
nagyon gyors, szerintem 160x200-as es elegge 
realtime. milyen trukkot lehetne hasznalni?
udv,
rod
............................................................................
Szerintem csak ugy mehet realtime, ahogy a CHROME-ban van realtime 
animacio-raytracing. A modszer szerintem csak az lehet, hogy amig egy 
masik partban 1-frames animaciokat csinalsz, vagy pakolgatsz kulonbozo 
feliratokat (Tomcat :). Igy egy animaciot dx2/66-in kb 10 sec alatt le 
lehet generalni. Persze eleg csak a felso felet kiszamolni. A 
gyakorlatban ez elkeszult ZOLA/Dyslexia irasaban. Jobb otletem sajnos 
nincsen.
                                                       dLux
............................................................................
  Nos. Ha mar fraktalok, akkor essen egy-ket szo a fraktal-landscaperol is. 
Az mas kerdes, hogy szerintem egy fractal-landscape-nek nagyon keves koze 
van egy Mandelbrot-halmazhoz, de mind1.
  Mogyan generaljunk fraktal-landscape-t? A feladat az, hogy mondjuk 
adott egy 256x256-os terulet, amit fel kell tolteni mondjuk 0..255 
magassagertekekkel. A most leirando modszert egy rekurziv eljarasbol 
egyszerusitettem vissza, egy picit egyszerubb lett talan, mint az 
eredeti. A sebesseg meg talan a veremmuveletek hianya miatt lett talan 
rovidebb. Egy 256x256-os kep generalasa igy egy pillanat alatt megvan.
  Az algoritmus ugy kezdodik, hogy definialok egy kockat, ami kezdetben 
256 egyseg oldalu. A kocka negy sarka ebben az esetben mindig ugyanaz a 
pont (0,0), mivel a (0,0)=((0+256) and 255,0)=... . Szoval a fraktal az 
vegtelenitett lesz. Ezentul az algoritmus teljesen altalanossa teheto, ha 
adott a negy sarok. Az algoritmus abbol all, hogy a negyzetben 3 pontot 
szamolsz ki osszesen. Az egyik a felso el felezopontja, amit ugy kapsz, 
hogy a ket felso csucsot atlagolod, s hozzaadni/levonni egy 
veletlenszamot 0..C-ig. Ugyanigy megkaphato a negyzet jobb oldalanak 
kozeppontja is, a harmadik pont pedig a negyzet kozepe, amit a negy sarok 
atlagolasabol + veletlen kivonas-osszeadasbol all. Ez utan a kovetkezo 
lepes csak az, hogy a negyzet meretet a felere csokkentjuk, s 
megcsinaljuk az egesz algoritmust ujra a 4 db negyedre. Csokkenteni kell 
a C-t (random generalashoz kell), a negyzet oldalait. A C csokkentese 
lehetoleg ne linearis legyen, de ne is felezodjon mindig. Egyik sem szep. 
Nalam azt hiszem 3/4-re csokken. A 4 negyed utan a 16-odokra, 256-odokra, 
stb is csinaljuk meg, ugyeljunk ra, hogy a sorrend BALROL - JOBBRA, 
FENTROL - LEFELE legyen, igy minden szamolasnak meg lesz adva a negyzet.
  Szamolasnal ugyeljunk meg arra, hogy a lehetseges tulcsordulasokat 
kezeljuk le, kulonben nagyon latszik a haromszogeles a mintaban.

                                                 dLux
............................................................................
A Julia fraktal-al kapcsolatban szeretnek irni par sort, valamenyit 
foglalkoztam (Nicke-vel kozosen). Hat akkor csak annyi, hogy 
eloszor is muveletileg kell optimalizalni a szamolast, minel kevesebb 
szorzas legyen benne, ezt mindenki megteheti, ezek utan mar egy 
viszonylag nagy julia-t is lehet realtime-ban szamolni, most nem 
emlekszem pontosan hany szorzasra lehet lecsokkenteni a muveletigenyt, de 
nem tul sok marad.
 Hasznalni lehet tovabba egy tablazatott, amibe az eppen kiszamitando 
pontbol kiindulva eltaroljuk az erintett pontok koordinatait, es mikor 
megkaptuk a kiindulo pont szinet, akkor ezen tablazaton vegig haladva 
ezeket a pontokat is kiszinezzuk, es csak olyan pontot kezdunk el 
szamolni amelyiknek meg nincs szine. Ha egy olyan pontbol indulunk aminek 
maxiteraco lesz a szine akkor ugye ahhoz kell a legtobb muvelet, a mi 
modellunk szerint viszont ilyenkor nem csak ennek a pontnak a szinet 
szamoljuk ki, hanem meg egy jonehanyet, igy egy-egy pontra csak minimalis 
szamu muvelet jut.
 Ez lehet, hogy elsore nem vilagos, megprobalom jobban elmagyarazni:
A julia az ugy mukodik, hogy elindulunk egy pontbol, aminek a szinere 
vagyunk kivancsiak, es atmegyunk egy masikba a rekurziv keplettel, ha ez 
a pont kivul esik a 2-es sugaru koron akkor a pont szine 1, ha belul van 
akkor ujra atmegyunk egy masik pontba, es ha kivul vagyunk akkor 2,stb...
 A fenti algoritmus ugy mukodik, hogy megjegyzem, hogy milyen pontokat 
erintettem, es mikor kiertem a 2-es korbol akkor az utolso pont szine 1, 
az azelottie 2, stb... mig vissza nem erek a kiindulo ponthoz...
 Ez igy szepen hangzik, sok szorzast megsporol de sajnos nem egeszen 
pontos, illetve nagyon nagy pontossag eseten jo csak...
 En inkabb az eredeti keplet optimalizalt valtozata mellet szavazok es 
esetleg kisebb juliat szamolok, aztan felnagyitom... (igy meg mindig szebb 
mint a tablazatos...)
 Ha valaki tudd olyan modszert ami gyors-is es pontos is,akkor arra en is 
kivancsi lennek...

Deity
............................................................................
 A Cristal Dream II/Triton -ban van egy mandelbrot zoomer, ami eleg 
latvanyos, de ha az ember sokaig nezi, akkor kiderul a turpissag. Nem 
szamolja minden frame-nel ujra az egesz kepet, hanem csak egy reszet, a 
mar meglevot meg bitmap zoomolja. En mintha koncentrikus negyzeteket 
veltem volna felfedezni. Foleg a legelejen lathato, amikor a teljesen 
ures kepre kezd kirajzolni.
 A juliarol tenyleg nem sokat tudok, a mandelbrotnak valami szarmaztatasa 
( javitsatok ki, ha tevedek ) es valami parametert lehet allitani, ha 
igaz. Itt is az lehet a trukk, hogy nem szamoljuk ki egyszerre az 
egeszet, hiszen az egymas utan kovetkezo abrak hasonloak, igy nehezebb 
eszrevenni a csalast.
 Valaki lenyomhatna valami julia pseudo codet, ki szeretnem probalni.

                                                Koszike...Paf
............................................................................
Felesleges szenvedni vele, hiszen ok maguk is bevallottak, hogy nem realtime.

A megoldas: csak nehany fazist szamolsz ki elore (ez le van tarolva)
es ezek kozott zoom-olsz. Ezt sok demo hasznalja, 4k introkban is lattam
(ott persze indulaskor szamoltak) 
Hatranya, hogy amikor a kovetkezo kepre valt, akkor egy latvanyos ugrast
lehet felfedezni. Talan a Crystal Dream volt az egyetlen demo amelyikben nem 
voltak ilyen ugrasok.
Lehet hogy a kepet az elozo letarolt kep nagyitasa, es a kovetkezo 
letarolt kep kicsinyitese kozti atmenetkent szamolja ki. (Ez csak egy 5let)

Hyp-X /Demons
............................................................................
G.O.D: a julia temaban te vagy a szakerto a Perlaval, ugyhogy hozza-
       szolhatnal. Tavaly mar pelda rutint is akartal kuldeni a listara,
       de johet csak az elmelet is...   Es a Perla? Meg nincs a listan,
       szolj mar neki...  Thanks.

TomCat/Abaddon
............................................................................
a tudasom nagyreszt a fractint-bol es a fractal programming in c
konyvbol szarmazik, az utobbi eleg primitiv kodilag, de az
elmeleteket jol elmagyarazza. 

a legtobb fraktal a komplex szamsikon valo buzeralason alapul.
amit mindenki ismer es kiutese van tole, az a mandelbrot fraktal.
kepletileg:
c=pixel
z(n+1)=z(n)^2+c 
tehat magyarul, veszed c-t, mint komplex szamot a pixel koordinataibol,
azaz Re c=x, Im c=y. ez az egesz szamolas utan igy marad.
aztan iteralunk, ismetelgetjuk a leirt kepletet:
az n+1.-et ugy kapjuk meg, hogy az n.-et negyzetre emeljuk es
hozzaadjuk a c konstansot. EZEK MIND KOMPLEX SZAMOK! ezert itt
kicsivel bonyolultabb a szamolas, mint elsore latszik.
ha z(n+1) nagysaga eler egy bizonyos hatart, altalaban 2-t, akkor
a pontot olyan szinure festjuk, ahany lepesben elerte a 2-t.
persze nem nezhetjuk a vegtelensegig, ezert megszabunk egy iteracios
maximumot (128, 256), amit ha eler az ismetlesi szam, akkor a 
pontot feketere festjuk.
gyorsithatjuk a szamolast, ha az iteracios szamot kicsire valasztjuk,
de ilyenkor a fraktal kidolgozottsaga is csokken.
a komplex szam nagysaganal pedig erdemes a koordinatak negyzetosszeget
vizsgalni, hogy elerte a 4-et, mivel ilyenkor nem kell gyokot vonni.

a mandelbrottol a julia annyiban ter el, hogy itt a c-t nem a 
pixel-bol vesszuk, hanem minden pontra ugyanaz, ezt a szamot
valtoztatva a kulonbozo frame-eknel kapjuk a morph hatast.
ez a kis kulonbseg szamolasi idoben jelentos csokkenest jelent.

udv,
rod
............................................................................
A fraktal landscape eleg vonzo temakor, a kozelmultban olvastam egy-ket 
eleg erdekes dolgot errol a temarol. 

Az elozo levelben emlitett algoritmus a koznyelvben plazma-kent, a fraktal
szaknyelvben Midpoint displacemenent neven ismeretes. Elonyei: mint az
bizonyara latszik, az algoritmus eleg gyors. Hatranya, hogy a generalt
gyakran 'tul szabalyos' lesz, azaz eloszeretettel keletkeznek benne hosszu,
egyenes vonalak.

A kovetkezo algoritmus nemileg hasonlit ehhez, de az elobb emlitett
hianyossagokkal mar nem kuszkodik. (Allitolag.) Vegyunk egy 0<r<1 valos
szamot, es egy n x n elembol allo tombot, amit feltoltunk veletlenszamokkal.
Egy lepesben az n x n -es tombot linearis interpolacioval felnagyitjuk egy
N x N -es tombre, ahol N=n/r, majd az OSSZES elemhez veletlenszamokat adunk
(termeszetesen itt kisebbeket). Itt latszik, hogy ha r=0.5-ot valasztunk,
akkor az algoritmust gyorsra lehet kesziteni, de azert erdemes kiprobalni
mas r-ek hatasat is. 

Most kicsit beleastam magam a temaba, szeretnek a BME-n valami TDK-dolgo-
zatot gyartani jovore a temaban, ami tulajdonkeppen egy olyan szoftvert
jelentene, ami alkalmas terep es mas termeszeti objektumok generalasara
es modellezesere, szoval akit erdekel, szivesen dumalnek a temarol. Ja,
es resztvevoket is szivesen latnek a projektbe, akinek ez aktualis.
                                ____________
                               //__/_ _/__
                            __//_/  //
                           /__/__/ //____
............................................................................
[Mas: a VIVA tel.csatornan megy egy klip amiben allati szupi fractal
landscape van...    TomCat/Abaddon]
............................................................................
*Fractal pages with source code*
http://www.teleport.com/~neighbor/semiints.shtml
http://jump.stanford.edu:8080/gforge/ (+10/9/95)

*Quaterion info*
http://www.krs.hia.no/~fgill/quatern.html
http://www.dtek.chalmers.se/Datorsys/Project/qjulia/index.html
http://speedracer.nmsu.edu/~jholder/fractals/keen.html
http://ccrma-www.stanford.edu/~stilti/images/chaotic_attractors/nav.html
http://www.omnigroup.com/People/bungi/julia.html

*Fractal generating programs*
>Fractint 19.2<
ftp://ftp.internexus.net/pub/Graphics/Fractals/frain192.zip
ftp://oak.oakland.edu/SimTel/msdos/graphics/frain192.zip
>PostMan<
ftp://dutepp0.et.tudelft.nl/pub/import/dutecai/PUBLIC/local/postman
>FFFF 2.0 32K color<
http://spanky.triumf.ca/pub/fractals/programs/IBMPC/FFFF20.ZIP
>FracTrue 1.00 Hi/Truecolor<
ftp://ft.cs.tu-berlin.de/pub/msdos/incoming/ftrue100.zip
ftp://ft.cs.tu-berlin.de/pub/msdos/graphics/ftrue100.zip
>CPM (Continous potential method for Mandelbrot set<
http://wwwmath.uni-muenster.de/~gloth
>Other<
http://www.acs.oakland.edu/oak/SimTel/win3/graphics.html
http://spanky.triumf.ca/www/fractint/fractint.html
http://einstein.et.tudelft.nl/~reinoud/

*IFS fractals*
http://www.cosy.sbg.ac.at/rec/ifs
http://www.cg.tuwien.ac.at/research/vis-dyn-syst/nlinifs.xhtml (+12/10/95)

*Fractal images/art*
http://www.swcp.com/artvark/index.html
http://www.primenet.com/~lkmitch/
http://maury.ief-paris-sud.fr:8001/~thierry/welcome.html (+10/5/95)
http://speedracer.nmsu.edu/~jholder (+10/11/95)
http://sprott.physics.wisc.edu/carlson.htm (+10/13/95)
http://www.auckland.ac.nz/arch/pdbourke/fractals/gasket.html (+10/13/95)
ftp://ftp.netcom.com/pub/no/noring/mandel01.gif (+10/13/95)

*Fractint related sources*
>Mapmaker - for maps<
http://users.aol.com/jorman/
>Fractal animation engine (requiers Fractint)<
ftp://spanky.triumf.ca/pub/fractals/programs/ibmpc/fae210b.zip
>Graphic convertors (Fractint GIF)<
http://www.winternet.com/~jasc/index.html (+10/16/95)

*Calculus Web site*
http://www.ozemail.com.au/~dihoyer

rod
............................................................................
Program Plasma;

Uses Crt;

Type
  RGB = Record
    R, G, B  : Byte;
  End;
  Palette = Array[0..255] of RGB; { Structure to hold 768 byte palette }

Var
  XRes,              { X Resolution of the screen, make as big as necessary }
  YRes : Integer;    { Y Resolution of the screen, make as big as necessary }
  D    : Palette;    { Palette used in program                              }


Procedure SetPalette(Var c : Palette);
{ Sets the palette, Really? }

Var
  x : Byte;

Begin
  For x := 0 to 255 do
    Begin
      Port[$3C8] := x;           { Set the DAC register for proper color }
      Port[$3C9] := c[x].R;      { Set th Red value }
      Port[$3C9] := c[x].g;      { Set the green value }
      Port[$3C9] := c[x].b;      { Set the blue value  }
    End;
End;

Procedure CyclePalette(Var TPal : Palette);
{ Cycles the palette }

Var
  Temp : RGB;

Begin
  Temp := TPal[0];                 { Store first color values }
  Move(TPal[1], TPal[0], 768-3);   { shift color values down one }
  TPal[255] := Temp;               { store first color values in last color }
  SetPalette(TPal)
End;

Function GetPixel(x, y : Word) : Byte;

Begin
  GetPixel := Mem[$A000:(y * 320) + x];
End;


Procedure MakePalette(Var Color : Palette);
{ Set up the palette to make colors look OK when cycling }
{ Not really too spectacular, play with this to get the desired }
{ palette cycling }


Var
  x : Integer;

Begin
  For x := 0 to 127 do
    Begin
      Color[x].r := 0;
      Color[x].g := (x div 2);
      Color[x].b := (x div 2);
    End;
  For x := 127 to 255 do
    Begin
      Color[x].r := 0;
      Color[x].g := 127 - (x div 2);
      Color[x].b := 127 - (x div 2);
    End;
End;

Procedure PutPixel(x, y : Word; c : Byte);

Begin
  Mem[$A000:(Y*320)+X] := c;
End;


Procedure NewColor(xa, ya, x, y, xb, yb : Integer);
{ Places a new color on the screen based on the average values }
{ of the surrounding pixels plus a random value                }

Const
  RoughNess = 2.25;  { How rough you want the plasma to be }
                     { 1.00  is very smooth                }
                     { 6.00  is very rough                 }
                     { Play around to get results          }

Var
  color : Integer;

Begin
  color := Abs(xa-xb) + abs(ya-yb);
  color := ((GetPixel(xa,ya) + GetPixel(xb, yb)) Div 2) + Round((Random - 0.5)
             * Color * Roughness);
  if color < 1             { Make sure color stays within 1..255 range }
    then Color := 1
    else if color > 255    { can change 255 to any number to reserve }
      then color := 255;   { for you own purposes, say 224, reserving }
                           { colors 225 to 255 for yourself }
                           { don't forget to change the palette cycling }
                           { procedure though! }
  if getpixel(x, y) = 0        { make sure the screen is clear at that point }
    then PutPixel(x, y, color);
End;

Procedure Iterate(x1, y1, x2, y2 : Integer);
{ Does the actual box seperation }

var
  x, y, color : integer;

Begin
  if not((x2-x1<2) and (y2-y1<2)) then
    begin
      x := (x1 + x2) shr 1;
      y := (y1 + y2) shr 1;
      NewColor(x1, y1, x , y1, x2, y1);
      NewColor(x2, y1, x2, y,  x2, y2);
      NewColor(x1, y2, x,  y2, x2, y2);
      NewColor(x1, y1, x1, y,  x1, y2);
      color := (getpixel(x1, y1) + getpixel(x2, y1) +
                getpixel(x2, y2) + getpixel(x1,y2) + 2) Shr 2;
      PutPixel(x, y, color);
      Iterate(x1,y1,x,y);
      Iterate(x,y1,x2,y);
      Iterate(x,y,x2,y2);
      Iterate(x1,y,x,y2);
    end;
End;


Procedure InitGraph; Assembler;
{ Set Mode 13h, 320x200x256 graphics mode }

Asm
  MOV  AX,$0013
  INT  $10
End;

Begin
  XRes := 320;
  YRes := 200;
  Initgraph;
  MakePalette(D);    { set up palette to be cycled }
  setpalette(D);
  Randomize;

  { Put "SEED" pixels here, can be colors 1 - 255, NOT 0!!! }

  Iterate(0, 0, XRes, YRes);
  repeat
    cyclePalette(D);
    delay(20);       { Cycling without delay is too fast! }
  until keypressed;
  TextMode(co80);
End.
############################################################################
Nekem kicsit kodos az a fogalom, hogy voxel. Gondolom mas is van
igy vele, ugyhogy osszefoglalhatnad egy kicsit, hogy mit is
jelenet ez, es milyen teruleteken lehet (erdemes) hasznalni...

Koszi, TomCat/Abaddon
............................................................................
a voxel a pixel 3 dimenzios megfeleloje, az omd voxel trainerje
szerint ez csak egy teglalap. tudasom szerint landscape-ekre
hasznaljak, de van 3d-s fractal morpher is ami voxeleket rajzol.

udv,
rod
############################################################################
    Nem hallott valaki a PNG formatumrol? Erdekelne a szerkezete, meg a 
leirasa. En azt hallottam, hogy a GIF utodja, mivel a GIF-re szabadlmi 
dijat akar szedni a CompuServe. Nem tudom, hogy igaz-e. Ha valaki tud 
PNG->JPG konvertert, vagy olyat, amivel normalis formaba lehet 
konvertalni, az kozolje. Egyedul eddig szereny tudasom szerint a QPV 1.6 
ismeri, de konvertalni nem tudja. Koszi....

dLux/H2
............................................................................
Az alabbi reszletek a QPV 1.7a verziojaban fellelheto gif2png.doc fajlbol 
szarmaznak. Sajnos ott csak gif->png konverter van, png->gif vagy png->jpeg
konvertert meg nem lattam.

The png sample library is Copyright (c) 1995 Guy Eric Schalnat, Group 42, Inc.
and is available from ftp://ftp.uu.net/graphics/png/code/pnglib*.zip

The zlib compression library is Copyright (C) 1995 Jean-loup Gailly and Mark
Adler and is available from ftp://ftp.uu.net/graphics/png/code/zlib-*.tar.gz

The PNG specification is Copyright 1995, Thomas Boutell and is available
from ftp://ftp.uu.net/graphics/png/documents. Obviously without the PNG effort
this program wouldn't have been possible (or even conceivable).
                         _____________  
                        //__/_ _/__            
                     __//_/  //         Dornbach Peter
                    /__/__/ //____      jet@frey.inf.bme.hu
............................................................................
        Letezik egy olyan progi ami oda vissza tud konvertalni png,gif,jpg,
pcx,.... kozott. A neve: SEA11.ZIP
Megtalalhatod barmely simtel mirroron az msdos/graphics/ directoryban.
Szerintem a kepnezo resze sokkal jobb, mint a QPV. Javaslom mindenkinek.
(Ha erdekel a feltorese, akkor azt is szivesen elkuldom ;-)

Udv, ML1050
............................................................................
Ez igaz, ezert is talaltak ki. No meg elvileg jobb mint a GIF, mert tud 
pl. TRUE color formatumot is. Szoval a PNG (Portable Network Gfx) egy 
olyan formatum, ami kizarolag freeware code-on alapszik, es a mai 
elvarasoknak megfeleloen tudja a LOSSLESS formatumokat.
Esetleg Amigara, van datatype is :)

 Pogi/Myth
............................................................................
Egy nagyon regi kerdesre valaszolok, de valahogy mindig elfelejtettem
elkuldeni a cimet. Ime itt mindent megtallaltok a PNG-rol:
http://quest.jpl.nasa.gov/PNG/   PNG (Portable Network Graphics) Home Page

Udv,  TomCat/Abaddon
############################################################################
Szeretnem megosztani mindenkivel otletemet !
Nevezetesen a MIDI gitar otletet.
Nos. GUS-on digizgetem az elektromos gitarom hangjat.
Gyors fourier analizissel megallapitom, hogy melyik hurt hol fogtam le,
es akkor ezt atalakitom MIDI parancsokka. Ezek utan a gitarommal
akar zongorazhatok is !

Van valakinek otlete, hogy hogyan kell  gyors Fourier analizist irni ?

Thanx : LGB / Creature Design
............................................................................
        A modszer valoban igy mukodik, de azert nem ilyen egyszeru.
        A Fourier analizis utan nem trivialis megkapni a jelbol, hogy
        milyen zenei hangokon szol. 

        Monofonikusan erre a pitch detektalalasra van szoftver a PC-n
        ami wav-bol csinal MIDI uzeneteket. Nyilvan te polifonikusan
        akarod megcsinalni, mivel az akkordokat is szeretned felismerni.
        A kezdeti otlet az lehet, hogy a nagy amplitudoju frekvencia-
        osszetevoket valasztod ki eloszor, valoszinuleg ok az alap-
        harmonikusok. Ez egy eleg egyszeru modszer - nem is mukodik nagyon
        mert nem mindig az alapharmonikus a legnagyobb amplitudoju.

        Jobb, ha felharmonikusokat is keresel, azaz olyan frekvencia-
        osszetevo sorozatot akiknek egesz aranyu a rezgesszama. Ha van
        ilyen sorozat a spektrumban, akkor annak legalso tagja az alap-
        harmonikus. A hangban azonban nagy amplitudoval szerepelnek nem
        harmonikus osszetevok is (partials) ezek kezelese gondot okozhat.
        
        Ha mindig ugyanarra a gitarhangra dolgozol, akkor megnezheted
        egy hur harmonikus osszetetelet, es ezt a mintat kell keresned 
        mindig egy akkord spektrumaban is. Ez a leghatekonyabb modszer.

        Ez idaig mind csak a hangmagassag detektalasa, azaz sima Note On
        uzenetek kuldese, viszont azert jo lenne egyeb parametereket is,
        hangerot, hajlitast stb.-t kuldeni, ez bonyolitja a dolgot.
        Idoben ugyanis nem statikusan a felharmonikusok, hangmagassaguk
        es erejuk is valtozik, igy nem tudsz mindig ugyanarra a mintara
        illeszteni.

        A masik gond valos idoben, hogy az FFT-nek van egy kis kesleltetese,
        nem az algoritmus miatt, hanem azert mert a megfigyelheto 
        frekvenciatartomany es a megfigyelheto idotartomany szorzata
        allando. Ez a Heisenberg-fele hatarozatlansagi relaciohoz hasonlo
        Gabor-fele osszefugges:

                delta t * delta f = 1 
                (informacioelmeleti megfontolasokbol gyakran 2 ez az 1)
        
        Azaz varnod kell, mig bejon x hangminta, hogy x szelessegu frek-
        venciatartomanyrol infot kapjal. Ez az FFT-bol is lathato, x
        minta szukseges x Fourier egyutthatohoz, vagy log, vagy negyzet,
        fejbol nem tudom... 

        A Cooley-Tukey modszer DITR2 algoritmusat el tudom mondani, csak
        utana kell neznem - gyorsabb modszerek Simonyi Erno: Digitalis
        Szurok c. konyveben vannak.

        Ha erdekel a tema, tudok adni ket kontaktot, a Pitch detektalas
        itt a BME Hiradastechnikai tanszeken valakinek az onallo labor
        feladata, ha gondolod, utananezek az email-cimenek.

        Janossy Zoltan foglalkozik itt a BME-n gitarszintezissel, fizikai
        modellezessel, es kozel all ehhez a temahoz, majd az o cimet is
        megkeresem...
                                                                Hotta
............................................................................
Van egy kb. 300K-s doksim PostScript formatumban:
Discrete Fourier Transforms and the Fast Fourier Transform
(FFT) Algorithm by Paul Hackbert 9 Feb. 1995
Ha valakit erdekel elkuldom neki...

TomCat/Abaddon
############################################################################
Ki tudja, hogy melyik a legygyorsabb vonalrajzolo algoritmus ?
A Bresenhalm (jol irtam ?) ? Ennel gyorsabb nincs is ?
Ugyanez a kerdesem lenne a kor kapcsan.

Nemreg irtam egy polygon rajzolo rutint. A mukodese a fentebb emlitett
Bresenhalm algoritmuson nyugszik. Azon alapul a dolog, hogy van ket
tomb, az egyik az adott soron beluli minimalis, a masik a maximalis X-et
jelzi. A feltoltest vegzi a vonalrajzolo algoritmus, meghozza ugy,
hogy a polygon hatarait adom be neki (3-szor kell meghivini)
A kapott ket tomb utan mar egyszeru kirajzoli a polygon-t !
Az a kerdesem lenne meg, hogy tudna-e valaki nekem szolgalni egy
ennel gyorsabb modszerrel ?

Thanx : LGB / Digital Creartures
............................................................................
Nos, szerintem a Bresenham az NEM a leggyorsabb, legalabbis nem az, 
amelyikben van felteteles ugras. Ugyanis en irtam 1-et, es lenyegesen 
lassabb volt annal, amit Picard irt, pedig abban (poliginrajzolo) volt 
egy meredekseg-kiszamolas is. Igaz, hogy a poligonrajzoloba nem a legjobb 
a klasszikus bresenham, mert ha X2-X1>>Y2-Y1 (lenyegesen nagyobb), akkor 
tul sok felesleges pontot szamol. A leggyorsab szerintem a 
meredekseg-szamolas.

dLux
............................................................................
a Bresentham vonalrajzolo eleg jo algoritmus, mert jo tomor, de nem eleg 
gyors, mert van benne feltetelvizsgalat es ugras, ha jol emlekszem minden
pixelre.
Ez a tombos modszer elegge elterjedt a polygonok rajzolasanal, de attol
tartok kicsit lassu. en (+Hyp-X) minden oldalra kiszamoljuk a
az x novekmenyt, azaz mennyit kell lepni x iranyban, ha y iranyban lepsz
egyet lefele. ezutan a 2 aktualis oldalon lepkedsz lefele a legfelso
csucstol es vonalakat huzgalsz. nem lesz annyira attekintheto, mint 
a tombos modszer, de eleg gyors. ha jol emlekszem a belso ciklusban
minden belefert a regiszterekbe.
sajnos haromszognel nagyobb oldalszamu polygonra nem nagyon erdemes
alkalmazni, a sok valtozas teljesen osszezavarja az embert.
udv,
rod
............................................................................
        En is belepofazok, nem mintha ertenek hozza, de nem reg lattam
        egy jo algoritmust vonalrajzolasra. Euler fele LNKO algoritmuson
        alapszik es szerintem nem lassu, de a legjobb az nem a sebessege,
        hanem, hogy feleakkora lett code-olva mint amit a Bresenham felevel
        tsinaltam, pedig semmit se optimalizaltam meg rajta, csak hirtelen
        felindultsaggal elektronra vetettem.
        Ha erdekel az algo vagy a (*) kodom irjal!

        Ui: Ja van egy kis bibije az algo.-nak nem mindig esztetikus a vonal.

          .  DiVeR
............................................................................
Hello fiuk! Minden duma nelkul itt a vonalhuzo rutinom...

;DRAWING LINE 12-24-94 BY TOMCAT/ABADDON
;Based on Bresenham algorithm
;Publised by Paul Heckbert in Graphics Gems
;Modified by Mark morley@camosun.bc.ca
;Translated to Assembly by Tamas Kaproncai tomcat@rs3.szif.hu

DrawLine        MACRO   _Plot,_Color
        LOCAL   _X2,_Y2,_1,_2,_3,_4,_5,_6,_7,_8

                MOV     _X2,SI
                MOV     _Y2,DI
                SUB     SI,CX           ;DX = X2 - X1
                SUB     DI,BP           ;DY = Y2 - Y1
                MOV     DX,SI
                MOV     BX,DI
                SHL     SI,1            ;AX = ABS(DX) * 2
                JNC     _1
                NEG     SI
_1:
                SHL     DI,1            ;AY = ABS(DY) * 2
                JNC     _2
                NEG     DI
_2:
                SAR     DX,16           ;SX = SGN(DX)
                SBB     DX,-1
                SAR     BX,16           ;SY = SGN(DY)
                SBB     BX,-1
                CMP     SI,DI
                JNA     _5              ;IF AX > AY
                MOV     AX,SI           ;  D = AY - AX / 2
                SHR     AX,1
                NEG     AX
                ADD     AX,DI
_3:                                     ;  DO
                _Plot CX,BP,_Color      ;    PLOT(X,Y)
                CMP     CX,_X2
                JE      _8              ;  UNTIL X = X2
                OR      AX,AX
                JS      _4              ;    IF D >= 0
                ADD     BP,BX           ;      Y += SY
                SUB     AX,SI           ;      D -= AX
_4:                                     ;    ENDIF
                ADD     CX,DX           ;    X += SX
                ADD     AX,DI           ;    D += AY
                JMP     _3              ;  ENDDO
        ALIGN 4
_X2             DW      ?
_Y2             DW      ?
_5:                                     ;ELSE
                MOV     AX,DI           ;  D = AX - AY / 2
                SHR     AX,1
                NEG     AX
                ADD     AX,SI
_6:                                     ;  DO
                _Plot CX,BP,_Color      ;    PLOT(X,Y)
                CMP     BP,_Y2
                JE      _8              ;  UNTIL Y = Y2
                OR      AX,AX
                JS      _7              ;    IF D >= 0
                ADD     CX,DX           ;      X += SX
                SUB     AX,DI           ;      D -= AY
_7:                                     ;    ENDIF
                ADD     BP,BX           ;    Y += SY
                ADD     AX,SI           ;    D += AX
                JMP     _6              ;  ENDDO
_8:                                     ;ENDIF
        ENDM
............................................................................
En is meredeksegszamolassal csinalom a fillezest.Ugye kaptunk egy olyan
tablazatunk,hogy (x1,x2) es ha 200 magas a kepernyonk,akkor ez 200szor.
persze ez nincs mindig teljesen feltoltve,na de ha csak mindig meghivjuk
3szor az elkiszamolast,hogy feltoltse a tablazatunkat,akkor amikor a
vizszintes vonalakat rajzoljuk,akkor kell egy osszehasonlitast kell
csinalni,hogy balrol jobbra megy-e az egyenes vonal,vagy jobbrol balra?
(x1<x2?) No mivel a poligont mindig egy koruljarasi irany szerint
taroljuk le,akkor megtehetjuk,hogy egy elnel (x1,y1 tol x2,y2-ig megy)
osszehasonlitjuk y1 nagyobb-e mint y2,ha igen akkor a kapott x-eket x1 soraba
taroljuk le,mert akkor az egy bal oldali el,ha nem nagyobb akkor x2
soraba tarolunk,nert az egy jobb oldali el,es amikor vonalazgatunk,akkor
mar tudjuk hogy mindig balrol jobbra hozzuk azt a vizszintest,es
megsporoltunk egypar felteteles ugrast(annyit-1,ahany pixel magas a
polygonunk).Azt hiszem csak hidden-calculalt polyknal mukodik.
--
                DAB of                          __
............................................................................
A cikkek olvasgatasa kozben ugy tunt, hogy meg 1995 vege fele is
nehany agyban valamifele kod takarja a 3D -szerintem leglenyegesebb-
alaprutinjat a poligon fillezest.
Ezt a fatylat igyekszem fellebenteni mostani leleplezo irasomban.
(ejfel mult 5 perccel, ilyenkor mar nagyon pihent a stilusom ;-)
Kezdenem azzal, hogy mit NEM szabad csinalni poligonfillezzesnel:
 -NEM szabad Bresenham-tipusu algoritmust hasznalni. A vonalhuzoban
  egyebkent kellemes elonyok elvesztik funkcioikat. A bresenham
  celja az osztas es az X-Y leptetes kozotti kulonbseg athidalasa.
  A polyfiller MINDEN esetben az Y-okhoz keresi a megfelelo X-eket,
  igy egyertelmuen a (X2-X1)-et kell osztani (Y2-Y1)-gyel. Celszeru
  szakaszonket elvegezni az egyszeri osztast, mert igy soronkent csak
  egy osszeadast kell elvegeznunk, szemben a bresenhamos ciklusokkal.
 -NEM szabad mindenfele tablazatokat hasznalni. (Ez lehet hogy igy
  kicsit eros - nem celszeru.) Egyreszt zabalja a memoriat, igaz
  abbol van eleg. Masreszt bonyolitja a kodot. Elhiheted, hogy
  tablazat nelkul rovidebb es egyszerubb kodot lehet irni.
 -NEM szabad a sokszogeket haromszogekre bontani! Ez az egyik
  legfontosabb dolog. A haromszogekre bontas a polyfiller halala.
  Igaz, hogy, ha egyben hagyjuk, a kod egy ici-picit hosszabb lesz
  (tenyleg csak egy kicsit), de SOKKAL gyorsabb, foleg minel tobb
  szoggel dolgozunk. Ugyanis a tordelessel lehet, hogy egy, a
  poligonba eso vizszintes szakaszt 8-10 reszletben kell
  kirajzolnunk. Es a vizszintes szakaszok rajzolasa az, aminel a
  legjobban kell vigyazni a sebessegre.

Maga a fillezes az alabbiak szerint alakul (termeszetesen a copyrigth
(c)1993 jogok megsertese nelkul ;-):
Maga a rutin harom reszbol all, azazhogy negybol.
 -A legelso feladat a valtozok, a VGA regiszterek beallitasa, esetleg
  a poligon lathatosag-vizsgalata (ha addig meg nem volt meg) es a
  LEGFELSO pont meghatarozasa. Ugyanis innen haladunk lefele, mindig
  egy sorral lejjebb lepve. (Ez persze, csak akkor igaz, ha tenyleg
  vizszintes vonalakat akarunk majd huzni - de hat ez a legegyszerubb)
 -Ezutan a feladat kettevalik. Kulon kell szamolnunk a BAL oldali
  eleket (2. resz) es a JOBB oldali eleket (3. resz). Ha jol
  emlekszem, az egyik t. codertarsam leveleben (igazan nem akarok
  szemelyeskedni) az okozta a problemat, hogy egy vonalnal minden Y
  ertekhez egy legkisebb es egy legnagyobb X ertek tartozik. Igen am,
  de az egyik Y legnagyobb X-e a kovetkezo Y legkisebb X-e lesz egy
  pixel elteressel. Itt jon be a fizika. (kezdek kavarni... hiaba,
  3/4 egy van emberek) Ezt az egy pixel elteres, foleg, ha majd nagy
  felbontsu kepet rajzolunk ELHANYAGOLHATO. Tehat, ha nekunk az X
  legnagyobb/legkisebb erteke helyet a masik kell, egyszeruen a
  kovetkezo sor X-evel szamolunk.
  Tehat a legfelso ponttol kezdve, mondjuk a BAL oldalon haladva
  eloszor elosztogatjuk az X kulonbseget az Y kulonbseggel, es a
  kovetkezo csucsig ezt adogatjuk hozza az elso lepesben kiszamolt
  kezdeti X ertekhez. A szamolasban tortertekkekkel is szamolni
  kell, peldaul fixpontosan 6-16 bittel. Persze figyelni kell az elso
  es utolso X kozotti kulonbsegre es arra, hogy az oldal dolese
  megfordulhat, azaz az eddig meg esetleg NEGATIV X kulonbseg
  POZITIVRA valthat, mert akkor a legelso X helyett ezutan a
  legutolsot kell hasznalni! (vagy forditva, de mindenkeppen
  megfordul)
  A JOBB oldalt teljesen fuggetlenul kell szamolni a BALtol, a
  csucsok is mas helyen vannak. Ha viszont elertuk a legalso csucsot,
  azaz a BAL es JOBB oldali kezdocsucs megegyezik termeszetesen ki
  kell lepni a fillerbol.
  Szoval miutal nagy nehezen kiszamoltuk a mefelelo Y-hoz a ketoldali
  X koordinatakat, kovetkezik...
 -A negyedik, legutolso szakasz. Ez lenyegeben attol fugg, milyen
  modban vagyunk. Vegyuk a legegyszerubbet, a 13h-t (320x200x256c a
  gyengebbek kedveert). DI-be rakjuk az Y-bol es BAL oldali X-bol
  osszeallitott kezdocimet, CX-be a JOBB es a BAL X kulonbseget es
  STOSB + REP STOSW-val kipakoljuk, de ezt mar biztosan tudjatok.
  Ezutan ujra visszalephetunk a BAL szakaszra.
  (A kilepes a 2. vagy 3. reszben van!)

Hat elso kozelitesben ennyi. Termeszetesen kihagytam negyany apro
gyorsito egyszerusitest, ami csak a megertest zavarna. Akit erdekel
es mar egyebkent keszen van a rutinja, hosszas konyorges es nemi
keszpenz aran szivesen elarulom. ;-)

TomCat:          Orommel nyugtaztam, hogy az en vonalhuzom feltunoen
hasonlit az altalad lekozolttel, habar en a kisujjambol szoptam.
Az enyem az elejen kicsit hosszabb, a vegen kicsit rovidebb, ugyhogy
egal-ban vagyunk. :)
                                     ASH
............................................................................
DAB: igen, az a vonalhuzo, amit a listara feltettem, az normal
     2D-s vonalhuzo volt. Persze, azt aztan konnyu atalakitani
     scanline vonalhuzo rutinna (csak a 'lapos' agon at kell
     helyezni a Pont kitevot a feltetelen belulre). Na persze
     ez igy nem az optimalais megoldas lesz, hiszen igy a
     ciklus tul sokszor fut a 'lapos' agon (helyette egy osztas
     javasolt).

Braseham vagy meredeksegi algoritmust hasznaljunk ?
---------------------------------------------------
(Ha jol gondolom, akkor a meredeksegi algoritmus: ha dx/dy -nak a tort
reszet is kezeljuk, a Braseham algoritmus: dy-bol vonogatjuk ki dx-t).

 Ez egy nagyon fontos kerdes, mert nem csak az elhuzasnal jon elo, hanem
mindenhol, ahol linearis interpolaciora van szukseg, mivel ilyenkor
mindig egy tort szamot kene adogatnunk valamihez (pl. gouraud-, phong
shading, texture mapping, z-buffer, kor es elipszis algoritmusok stb.).

 Szerintem a valasz, elsosorban attol fugg, hogy ki hany regiszterrel es
hany utasitasbol tud kivitelezni egy-egy elet az egyes algoritmusoknal.

Nezzuk ezt nalam:

       Braseham                        Merdeksegi
------------------------        ------------------------
        ...                             ...
        ADD     EDI,EAX                 ADD     EDI,EAX
        JNC     @@1                     JNC     @@1
        ADD     EDI,EBX                 ADD     EDI,EBX
        DEC     EDI             @@1:
@@1:                                    ...
        ...

        A felhasznalt adder regiszterek szama azonos: 2.

                    Az utasitasok szama:              
          2 + 1                             1 + 1

                  Az init rutin idoigenye:

        'lapos' agon 1 db               mindket agon 1 db
         16 bites osztas                 32 bites osztas

 Mivel az egyik rutin itt gyorsabb, a masik rutin meg ott, ezert figyelembe
kell venni, hogy melyik resz hanyszor fut le. Vagyis a peldanknal maradva,
hany darab es milyen hosszu elet szeretnenk huzni. Minel tobb elet huzunk,
annal fontosabb, hogy ezek hosszuak-e vagy rovidek. Ha rovidek, akkor a
Braseham a jobb, ha hosszuak, akkor meg a meredeksegi. En a Braseham rutint
hasznalom mert a 320*200-as kepernyon lehetetlen eleg hosszu vonalakat huzni.


 Ez elozo peldaban a dx/dy erteke mindegy, hogy pozitiv vagy negativ volt.
Viszont abban az esetben, ha errol az adder-rol tudott, hogy csak pozitiv vagy
csak negativ lehet, akkor a ket rutin egyszerusodik. Pl. a csak pozitiv eset:

       Braseham                        Merdeksegi
------------------------        ------------------------
        ...                             ...
        ADD     EDI,EAX                 ADD     EDI,EAX
        JNC     @@1                     ADC     EDI,0
        ADD     EDI,EBX                 ...
@@1:
        ...

           A felhasznalt adder regiszterek szama:

            2                                 1

                    Az utasitasok szama:              
          1 + 1                               2
        ez Pentiumon jobb               ez meg 486-on

                  Az init rutin idoigenye:

        'lapos' agon 1 db               mindket agon 1 db
         16 bites osztas                 32 bites osztas

Itt eleg valtozo, hogy mikor melyik rutint hasznalom.


 Alljon itt egy kis magyarazat a gyengebbek kedveert: A 32-bites regiszterek
also es felso 16 bitje, mas-mas adatot tartalmaz. Pl. az utolso rutinnal:

        ...
        ADD     EDI,EAX
        ADC     EDI,0
        ...

                                EDI (kezdeti ertek)
                    felso 16 bit | also 16 bit
                    --------------------------
                           32768 | y1 * sorhossz + x1

                                EAX
                    felso 16 bit | also 16 bit
                    --------------------------
                dx/dy tort resze | dx/dy egesz resze + sorhossz


 Vegul leirom, hogy en hogy fillezek poligont: Haromszogekre bontas utan:

Haromszog fillezes:
- Y szerint rendezni kell a pontokat -> melyik az also el
- megallapitani, hogy melyik a bal es melyik a jobb oldali el
- adderek inicializalasa
- ciklus a felso ponttol az alsoig
  - fill a bal oldaltol a jobbig
  - bal oldal leptetese
  - bal oldal elerte-e a kozepso pontot?
    - uj baloldali adderek
  - jobb oldal leptetese
  - jobb oldal elerte-e a kozepso pontot?
    - uj jobboldali adderek

                                TomCat/Abaddon

PS: Ja, koproc eseten ez a problema nem is letezik, csak ott meg a
    lebegopontos es a fixpontos formatumok kozotti konverzi eszi meg
    a gepidot...
............................................................................
1> Bresenham

Nem igazan erem mire valo a DEC EDI, szerintem ha az EBX-et eggyel 
kevesebbre veszed, akkor kihagyhato. (Tehat ezt a ciklus elott megteheted.)
Ezzel megkaptuk a masodik rutint ami szerinted a meredeksiegi. :)

2> Meredeksegi

Ennek sok koze nincs a meredeksegi algoritmushoz. Ez elso ranezesre 
latszik, mivel a meredeksegi algoritmus nem tartalmaz ugrast,
amitol lenyegesen gyorsabb. (Kod lasd kesobb)

Ehhez legyszi fuzzel magyarazatot, marminthogy minek a Bresenhamhoz osztas?
Ugyerted hogy a lapos agon meredeksegit hasznalsz helyette ?

1> Bresenham

Az ADD tulcsordulasat kihasznalva a DEC lenyelese mindig elvegezheto, 
lasd a megjegyzesemet az altalanos esetnel.

2> Meredeksegi

Miert ne mukodne negadivra ? Egyszereuen ilyenkor BX negativ szam.

A rutinon gyorsithatsz, ha elore eldontod hogy balra, vagy jobbra fog-e 
esni a kozepso pont. Ezt egyszeruen megteheted 

Vannak dolgok amiket nem erdemes koprocival csinalni.
Azt a szintet amirol te beszeltel mar nem erdemes.

Hyp-X /Demons
............................................................................
Nem, csak az adder egesz reszenek kiszamolasat hulye lennek egy ciklussal
helyetesiteni. Vagyis szerintem a Bresenham arra valo, hogy egy tort resszel
rendelkezo adder (ami osztasbol szarmazhatna) tort reszet kezeljuk. Ez egy
2Ds vonalhuzo rutinnal teljesen kivaltja az osztast(!), de egy scanline vanal-
huzasnal mar van egesz resz is, de attol a tort resz meg kezelheto ugyanugy
Bresenham algoritmussal.

Ezert az initben
1. a 16 bites osztas: |dx|/dy  (a 'meredek' agon ez at is lepheto).
A maradekot a tovabbiakban Bresenhammel kezeljuk.
2. a 32 bites osztas: |dx|*65536/dy
A tortresz EAX also 16 bitjeben kepzodik, EDX maradek pedig nem kell.
(Ez megoldhato lenne 2 db 16 bites osztassal is).

Azert kell a DEC EDI, mert EBX felso 16 bitje nem ures - mivel ott kell
kivonni a dy*2-t a Bresenham algoritmushoz. Kovetkezeskeppen EBX also
16 bitjen nem lehet negativ szam, mert az kellemetlen tulcsordulashoz
vezetne (igaz csak az esetek 25%-ban). Igy BX az 0 vagy +2.

Csak akkor nem tartalmaz, ha elore eldontod, hogy balra vagy jobbra
megy a vonal, akkor meg ket rutin kell!

Ha elore eldontom, hogy merre megy a vonal, akkor 2 peldany (kicsit mas)
kell a rutinbol. De ha hozzagondolom azt is, hogy esetleg ne csak
haromszogre mukodjon a rutin, vagy bele akarok tenni meg egy Gouraud-t,
meg egy Z-puffert, esetleg meg egy texturat, akkor ott megint ujra
linearis interpolacio kell, amit egy tort resszel rendelkezo adder-rel
oldunk meg ismet es ha ekkor ismet elvalasztanam a pozitiv es a negativ
eseteket, akkor mindig 2-szer annyi ujabb rutin kene es ugye a hatvany
fuggveny gyorsan novekszik(!). Szerintem sokkal jobb egy rutinban lekezelni
a negativ es a pozitiv eseteket (igaz vesztunk egy kis idot, de az minimalis
viszont nem keveredunk ossze a kesobbiek soran).

(Azt meg hogy elertunk egy ujabb kozepso pontjat a poligonnak, en ugy
vizsgalom, hogy nem tartom kulon nyilvan, hogy melyik Y-nal tartok, hanem
a DI-t vizsgalom meg, hogy odaert-e az adott ponthoz).

Persze, csak nem egeszen ertem a reagalasod, mert amikor a ket esetet
osszefoglaltam egy rutinban, akkor azt mondtad, valasszam kette...
Most meg amikor szetvalasztottam es ezzel egyszerusitettem oket, akkor
meg ram koppintasz, hogy miert nem 2 regiszterrel (bonyolultabban) es
egy rutinnal oldom meg a peldat...

A felteteles ugrast nem szamoltam, a plusz utan szerepelnek azok az
utasitasok, amik nem mindig futnak le (50% a sansz).

Jo, tessek egy kis gepido elemzes:

_________________________486_P5__  ______________________486_P5__
        ADD     EDI,EAX   1   1         ADD     EDI,EAX   1   1
        JNC     @@1      3/1  0         ADC     EDI,0     1   1
                  (vagy: 4/2  1)
        ADD     EDI,EBX   1   1         ...
@@1:

( 1+1 = 1.5 ciklus, 2 = 2 ciklus ).

Ezzel sem ertek egyet, hiszen az FPU joval gyorsabb mint a CPU (persze
P5 es folott). Gondoljunk csak a szorzasra(!) (az FPU 1 ciklus alatt
osszeszoroz 2 db 80 bit pontossagu szamot(!). Aztan meg ott nem kell kulon
vacakolni a tort meg az egesz resszel. Raadasul meg regisztere is tobb es
jobb van (!). Most gondolj bele, hogy egy Z-bufferelt truecolor Gouraud-hoz
mennyi adatot kene kezelni egesz szamos aritmetikaval, es ez, az FPU
eseten, mind szepen elferne a regiszterekben...

Az FPU gyenge resze a felteteles elagazasok, valamint nehezkesen tud
egyutt dolgozni a CPU-val (itt arra gondolok, hogy nincs olyan utasitas,
ami az FPU regiszterebol egyenesen a CPU egy regiszterebe tenne adatot,
es viszont).

C i a o,              TomCat/Abaddon
............................................................................
Oke ertem hogy ez miert nem a meredeksegi, ami az egyik problemam volt, 
mivel a ket rutin, ha a DEC-et kiveszed, akkor ugyan ugyanaz, de persze 
nem ugyanazt jelentik a regiszterek. (Te erted ezt a mondatot? En mar total 
belezavarodtam.)
Viszont magyarazattol fuggetlenul (azaz hogy mit jelent) a DEC EDI 
kiszedheto ahogy mondtam, mert:
        DEC     EDI
az uganaz mint:
        SUB     EDI,1
ami ugyanaz mint:
        ADD     EDI,-1
az osszeadasok pedig lenni asszociativak, meg assembly-ben is :-)

Ha meg mindig nem erted, akkor elmondom hogy azert mukodik, mert igaz 
hogy tulcsordul, de az EBX is tulcsordul az elejen amikor kivonsz belole 
egyet.

A meredeksegi a algoritmus kb. C ben leirva. (Csak hogy tudjuk hogy 
ugyanarrol beszelunk-e)

 fixed32 d=(x2-x1)/(y2-y1);

 fixed32 x=d/2;
 for(int y=y1;y<=y2;y++)
 {
   y_table[y]=x;
   x+=d;
 }

Elso megoldas (a legegyszerubb, dehat induljunk a kalyhatol)
        EDI = int16(x):frac16(x)
        EAX = int16(d):frac16(d)
akkor a kod:
        ADD     EDI,EAX
egesz jo az egyetlen problema az, hogy ahhoz, hogy az egeszreszt megkapjuk, 
le kell shiftelnunk az egeszet 16 bittel. (Szoval nem jo.)
Felhivnam azert a figyelmet, hogy ha d=-0.5 akkor EAX = 0FFFF8000h 
(ezt most nem tudom miert mondtam talan eszembe jut kesobb.)

Masodik megoldas:
        EDI = frac16(x):int16(x) 
        EAX = frac16(d):       0
        EBX =         0:int16(d)
akkor a helyes kod:
        ADD     EDI,EAX
        ADC     DI,BX
Illetve a majdnem helyes kod:
        ADD     EDI,EAX
        ADC     EDI,EBX
Itt tulcsordulasi problemaink lehetnek, amelyek azonban megoldhatok ugy, 
hogy ha az int16(d) negativ szam akkor az frac16(d)-t csokkentjuk eggyel.
(Mert negativ eseten mindig, pozitiv eseten sosem csordul tul.

Az EBX persze atviheto az EAX-be am ekkor...

Harmadik megoldas:
        EDI = frac16(x):int16(x)
        EAX = frac16(d):int16(d)
es a kod:
        ADD     EDI,EAX
        ADC     EDI,0
Ezt most erdemes meggondolni reszletesen:
 Pozitiv: Az AX>0 igy ez nem szokott tulcsordulni.
          Az ADC ugyse csordul tul.
 Negativ: Az AX<0 igy ez mindig tulcsordul.
          Az ADC ugyse csordul tul.
Tehat EAX felso reszet itt is korigalni kell, azaz ha AX, es ilymodon d 
negativ, akkor csokkenteni kell eggyel.

Megjegyzes: A meredeksegi algoritmusnal ezek a korrekciok nem olyan 
lenyegesek, mint a bresenham eseteben, a gyakorlatban nem jelentenek 
kulonbseget, de azert leirtam, hogy ne lehessen belekotni.

Valoban. Mindennek van elonye es hatranya is. Ha a sebessegre gondolunk 
itt megint a sok/keves iteracio kerdese jon elo. (Amit nem lehet 
altalaban csak az adott program ismereteben megvalaszolni.) Mindenesetre 
ha sokszor fut le a rutin erdemes szetvalasztani a ket esetet.
(Termeszetesen az adder rutin mindket esetben ugyanaz...)

Oke. Az alobb a haromszog esetre valaszoltam.
Tobbszogek eseteben kisse maskepp mukodik a rutin.
(Bar lehet hogy meglehet irni a sokszogeket egyelore pihentettuk :)

Nemtudom feltunt-e de eltertel a tematol.
Ezen rutinok pozitiv-negativ esetszetvalasztvalasztasarol beszelsz en 
pedig arrol beszeltem hogy hova esik a kozepso pont. Ez ket eset, pont.
   1./\           2. /\
    /  \            /  \
    \   \          /   /
      \  \        /  /
        \ \      / /
          \\    //
(Ebbol kiderult hogy nem tudok ASCII ben rajzolni...)

Hehe. Oke ertem hogy felrertettel az elobb.
A vesztunk egy kis idot kerdeset viszont tovabbra is tamadom.
(Feljebb leirtam a kodot AMIVEL tamadom.)

Ez oke bresenham eseteben. (Na talaltam egy elonyet.)
Meredekseginel viszont ezzel ne probalkozz.

Ez nalam igy nez ki:

 _________________________486_P5__      ______________________486_P5__
         ADD     EDI,EAX   1   1  (U)        ADD     EDI,EAX   1   1 (U/V)
         JNC     @@1      3/1 4/0 (V)        ADC     EDI,0     1   1 (V)
         ADD     EDI,EBX   1   1  (U)        ...
 @@1:

A lenyeges kulonbseg a pentiumnal van, mivel nem valoszinu hogy 
eltalalja, hogy kell-e ugrani, es itt a pipeline 1-el hosszabb.
(Forras az intel hogyan optimalizaljunk pentiumra cimu doksija.)

Tehat az elso rutin 486 eseten:
 4 / 3 ciklus, atlag 3.5

Pentium eseten:
 (2/6) / (1/5) ciklus, atlag 3.5  (ez a szep az intel procikban.)
 itt persze felteteleztem hogy 50%-ban talalja el az ugrast, ez a 
 gyakorlatban igaz is lesz. (Ennel a rutinnal.)

Termeszetesen a vegleges kod P5on gyorsabban is futhat, mert az elso rutin
U utasitasa elnyelheti a kovetkezo utasitast ha az nem fugg tole.

Viszont persze a masodik rutin ketszeresere is gyorsulhat hasonlo 
optimalizalas folytan.
 
Ez igazabol csak nagy szamoknal, es/vagy szorzasnal igaz.
Epp az elobb indokoltad meg miert. (Konverzio.) Egyebkent nem tudom miert 
kotottel vele en csak egyetertettem veled :)

Hmmm. En ugy olvastam, az intel doksiban, hogy pipeline-os a proci es 
ennyi a latency azaz ennyi ido mulva kezdheted el a kovetkezo utasitast, 
(ha az nem fugg tole), de az eredmenyet csak kesobb kaphatod meg. Persze 
abban igazad van, hogy ki lehet optimalizalni. (FXCH aktiv hasznalataval)

Mindenesetre a fenti esetekben nem volt szorzas. Osztani meg Pentiumon is 
lassu kiveve ha onmodosito a kod. (Gyk: ellenorizni kell hogy <kritikus> 
erteket erint-e az osztas. Ez persze csak ajanlas (szinten az inteltol))

Kar hogy a konverzio miatt fele olyan gyors... (Marmint P5-on, mert 
486-on a nyomaba se er...)

Ez az intel hulyesege, miert nem lehet az FPU regisztereket kozvetlen 
hasznalni. Eleve hulyeseg hogy miert van meg mindig kulon FPU es CPU.
(Tudom kompatibilitas..... Grrrr)
Peldaul mindketto tud egesz szamokat szorozni, es raadasul kulonbozo 
sebesseggel. (Ez mar csucs !) Persze biztos masik csapat tervezte....

Hyp-X /Demons
............................................................................
Hopp! Na most jon a lenyeg:
B: EBX felso resze nem ures, ott kell levonni dy*2-t, ezert ott nem
   lehet BX elojelenek kiterjesztese. Ha BX=-1 akkor hozzadava EBX-t
   EDI-hez nem sikerul egyet levonni, csak EDI felso reszet barmoljuk el.
M: ott EBX az vagy 1 vagy -1, nyugodtan hozzaadhato EDI-hez.

Na figyi, ezt most nem birtam kihamozni...
Szerintem, ha a meredeksegit ket reszre osztod, akkor a csak pozitiv oldal:
                ADD EDI,EAX
                ADC EDI,0
a csak negativ oldal pedig:
                ADD EDI,EAX
                SBB EDI,0
S most reszletezem a regiszterek tartalmat:
EDI       \                EAX              \
-----------\------------   ------------------\------------------
tort gyujto \ pont helye   |dx|/dy tort resze \ dx/dy egesz resze

Ha jol ertem szerinted, mukodik az
                ADD EDI,EAX
                ADC EDI,0
mindket esetre, de akkor legyszi reszletezd, hogy mik vannak a regiszterekben,
vagy ird meg, hogy en miert gondolom rosszul a negativ oldalt...

Itt ott jon elo a negativ es a pozitiv, hogy a kozepso pont jobbra vagy balra
van-e, mert ettol fuggoen az adder pozitiv vagy negativ.

Ezzel azt akarod mondani, hogy a meredeksegi algoritmus olyan pontatlan,
hogy nem talalja el az e'l vegpontjat ?! akkor az nem is igazan hasznalhato.

Szerintem egy rutinrol targyalunk, csak eloszor leirtam altalanosan, aztan
meg leirtam, hogyha szetvalasztom ket esetre, akkor hogy egyszerusodik a
dolog.

Epp az altalad emlegetet doksi mondja azt, hogy a JNC prefixje miatt
meg egy ciklus kell es az nem 3/1, hanem 4/2 -vel szamol. Akkor az
eredmeny rosszabb. (Lehet, hogy tevedek a doksi illetoen egyeztessunk!
"Optimizations for Intels 32-Bit Processors" by BEV ZAHARIE, Intel 1993?)
50-50 % a JNC kimenete (mert mindenfele iranyba mehet vonal)
igy ez (4+2)/2=3 ciklus

Mi az az (1/5)?

(45 fokos vonalnal mindig teved, fuggoleges v. vizszintesnel soha)

a/ Amikor eltalalja hogy ugorjon vagy se, akkor 0 ciklus az ugras,
itt (2+1)/2=1.5 ciklus

b/ amikor meg rosszul 'tippel', akkor mennyi a buntetes ? (most nem neztem meg)
    (2+b+1+b)/2 ciklus
Vegeredmeny a ketto atlaga.

Az en ervem a VSPEED, ott atkapcsolhatsz stos es movs kozott...

udv, TomCat/Abaddon
............................................................................
1. DEC EDI kiszedes

Most mar kezdem nem tudni hogy mit irjak.
Most ismet leirtad, hogy az EBX felso resze hasznalt, en ezt tudom.
Nem akartam en se elojel kiterjesztesre hasznalni. 
Szerintem a tema nem er meg ennyit.

2. Egesz resz-tort resz.

Te irtad:      EAX :  |dx|/dy tort resz  -  dx/dx egesz resz
 A te rutinjaid valoban ezt hasznaljak.
Nekem viszont: EAX :   dx /dy tort resz  -  dx/dx egesz resz
 Es igy egyszerubb kezelni.

Nem tudom honnan jott neked, hogy abszolut erteket hasznalj, mert az az 
ami, ket esetet eredmenyez.

3. Kozepso pont balra-jobbra

Kar volt felhoznom a temat. Mert nem igazan kapcsolodik a scanline-hoz.
Ha majd azt tisztazzuk (ahogy azt a level elejen felvetetted - igazad 
van) akkor majd megnezzuk mi itt a helyzet.

4. Meredeksegi pontatlansag

Arra akartam celozni hogy:
  ( dx / dy ) * dy  !=  dy
ahol a / egesz osztas. Marmint nem minden esetben.
Ez egy nagy marhasag volt tolem, (bar igaz.)

Csakhogy a ciklus nem x1-tol, hanem x1+0.5 tol indul hogy ne legyen gond, 
hogy kerekitenunk kell, es nem egeszreszt szamolni.
Igy ha dy<32768 akkor az eljaras pontos.
Szoval felejtsd el a megjegyzesemet.

5. JNC prefix

En JNC short-ra gondoltam. Annak tudtommal vedett modban sincs prefixe.
De azert utananezek.

6. Jump pentiumon

A ( 2 / 6 ) / ( 1 / 5 ) azt akarta jelenteni, hogy egyenes futas eseten 2 
vagy 6, ugras eseten 1 vagy 5. A +4 az a penalty ha nem talalta el, es 
azert +4 mert a jump a V pipelineban fut.
(Ha az U ban futna akkor +3 lenne a penalty, de akkor persze +1 ciklus a 
jump, tehat nincs kulonbseg.)

7. Intel doksi

Iratkozz fel az intel levelezesi listajara:
http://www.intel.com/IAL/form/ialapp.html
Kuldenek CD-t fejlesztoi informaciokkal. (Tok ingyen van!)

Az emlitett doksit is ott lattam, valoszinuleg az amelyikrol beszelsz, de 
fejbol nem tudom. (Nincs itt az CD, meg drive sincs a kozelben.)

8. STOS vs. MOVS (486)

Ja az altalam megadott adatok
a) elviek, ha a MOVS memoriabol olvas, akkor konnyen lehet persze lassabb.
b) Intel/AMD-re vonatkozik. Cyrix prociknal az utasitasok nagy reszenek 
mas a vegrahajtasi ideje.

A VSPEED peldaul valoszinuleg olvas a memoriabol.
Egyebkent ha beleondolsz:
                STOSW   MOVSW
486 DX-2  66    33000   44000
486 SX/DX 40    20000   26666
(Az adatok  cpms -ben (Landmark stilus.))

Ha peldaul 486 DX-2 volt neked akkor biztos nem gyorsabb a MOVSW

Hyp-X /Demons
............................................................................
Most megprobalom osszefoglalni, hogy hol is tartunk, csak hogy mindenki
tisztan lathasson...

1. vonalhuzas
   a/ 2D-s haladhatunk X es Y iranyban is
   b/ scanline vonalhuzo: Y iranyban haladunk
      dX/dY egy nem egesz szam, a tort resz is fontos!
      amit kezelhetunk: - lebegopontosan (nem targyaljuk)
                        - fixpontosan
                        - vagy abrazolas helyett a Bresenham modszert alk.
MEGVALOSITAS
1. legegyszerubb
   ADD EAX,EBX
   MOV EDI,EAX
   SHR EDI,16
Itt EBX-ben siman benne van dX/dY fixpontosan. A gond csak az,
hogy a szukseges cim a felso 16-biten keletkezik ezert SHL kell.
(Sterzi: na latod ezert indult ez az egesz ceco).

2. jon Ervin otelete (Imp), csereljuk meg a tort es az egesz reszt!
ilyenkor a tortreszbol kapott tulcsordulas nem adodik automatikusan
az egesz reszhez, de benne lesz a Carry-ben.
   ADD EDI,EAX
   ADC EDI,0
(Ez az amit magyaraztal nekem Hyp-X)
Igy a torteket gyujto regiszter a cel regiszterrel azonos lehet.

(Ervin tovabbi otlete, hogy hasznaljunk csak egy ADC EDI,EAX utasitast.
Ilyenkor a Carry kesik egy pontot. S a ciklus szamlalasa is bezavarhatna,
erre orvossag a ciklus unrollozasa).

3. Az elozo megoldasok egy 32-bites elojeles osztast igenyeletek az initben.
Reszletesebben:
   MOV EAX,<dX>
   MOV EBX,<dY>
   SHL EAX,16
   CDQ
   IDIV EBX
   ROR EAX,16
   ADD EAX,<sorhossz>
Ez kell minden e'l elott, de egy Gouraud-nal minden sor kiirasa elott is.
Na ennek az IDIV-nek az eliminalasara szedtem elo a Bresenham algot.

4. A belso ciklus bonyolodik:
   ADD EDI,EAX
   JNC @1
   SUB EDI,EAX
   INC EDI
@1:
(Hyp-X: Most forditva irtam, de az INC EDI itt kell es punktum!)
Viszont az init gyorsul (bar bonyolultabb):
   MOV EBX,<dY>
   MOV EAX,<dX>
   ADD EBX,EBX
   ADD EAX,EAX
   JNC @1
   NEG EAX
   ADD EBX,20000H
@1:
   XOR EDX,EDX
   CMP EAX,EBX
   JB  @3
   DIV BX
   TEST EBX,20000H
   JZ  @2
   NEG EAX
@2:
   XCHG AX,DX
@3:
   ROR EBX,16
   ADD EAX,<sorhossz>
   SHL EAX,16
   MOV AX,DX
igy az osztas csak a lapos vonal eseten hajtodik vegre, de akkor is
csak egy 16 bites elojel nelkuli es nem pedig egy 32 bites elojeles.

5. Ez trukk hasznalhato mindenhol, ahol linearis interpolacioval van
   dolgunk es a novekmenyt (addert) egy osztasbol nyertuk. Igy peldaul
   az elek menten a z-t is hozhatjuk igy (Z-puffernel) vagy a szineket
   Gouraudnal stb.

Most ki-ki eldonheti, hogy milyen szinten fogja kezelni a problemat...

                                        TomCat/Abaddon
............................................................................
Az elozo punktumos megoldasombol vonulnek, vissza...
Hyp-X, jo leesett a tantusz (meg szerencse, hogy makacs vagy :)
Oke INC-eljuk vagy DEC-eljuk az EBX-t az initben.
Igaz igy a 16 bites es a 32 bites resz osszekeveredhet es igy
mar nem olyan egyertelmu, hogy melyikben mi van, de a dolog
persze attol meg mukodni fog....

Szoval bocsi, de amig meg nem ertek valamit, addig az ugy jo,
ahogyan en gondolom... ;)

Ennek az lesz az eredmenye, hogy a Bresenham-os megoldas tovabb javul...
Es a polyfillnel en mar elotte is ezt hasznaltam...
Hamarosan az egesz polyfillem is 'becsopog' a listara, akkor aztan
a kodoptimalizalasan lehet meg elmelkedni (vitatkozni). Pentium rulez,
vagyis optimalizaljuk 2 pipeline-ra.

udv TomCat/Abaddon
############################################################################
TomCat is behind the keyboard:

************************************************
Strezi, Pogi, Nicke, IronHawk, Ninja - Figyelem!
************************************************

Ha jol tudom a listarol ti vagytok azok, akik ray-tracert fejlesztenek...

Keredezem en, hogy resztvennetek-e egy olyan munkaban, hogy az rt-vel
kapcsolatos dolgokat kozosen, aprolekosan kitargyaljuk. Esetleg egy
kozos programot is irhatnank...

Szeretnek mindent megtargyalni es a leggyorsabb eljarasokat osszegyujteni.

A munka kotott sorrendben menne. Mindenki elmondana a tapasztalatait az
eppen adott temarol. Aztan leszurnenk a tanulsagot egy kozos fajlba.

A dolog eloszor a CODER-L keretein belul lenne, de ha ez nem volna
megfelelo, akkor levalunk a listarol...

Elso feladataink:
- eldonteni ki vesz reszt a munkaban
- osszegyujteni a temakat
- a sorrend korvonalazasa
- megallapodni, hogy kb. mennyi ido jut egy-egy temara (egy het? kevesebb?)

Az ebben a temaban kuldott cikkek subjectjei javaslom, hogy mindig
egy 'RT:'-tal kezdodjenek...

Norbi:
Amig nem tudsz feliratkozni a listara, addigis echo-zom a leveleid.
A temaval kapcsolatos leveleket meg felteszem valamelyik plan fajlomba.


Sorrendbe szedett temajavaslataim (Mi maradt ki?):
--------------------------------------------------
(Aki beszall a buliba, az mind csinaljon egy hasonlot...
vagy javitsa az enyemet, vagy csak a plusz dolgokat irja meg!)

Szemvektorok
- kiszamitasa
  - bemeno adatok
  - transzformacio az origoba
- kilovese
  - tablazatbol
  - rekurzivan
- mozgatasa
  - vektorok mozgatasa
  - objektek inverz mozgatasa

Targyak
- tipusai
  - sik
  - gomb
  - poligon
  - poligonal patch
  - cso
    - tengely-iranyu
    - altalanos
  - kup
  - blob
  - highfield
- tarolasa
  - sorban
  - lancra fuzva
  - faban
- hierarchiaja
  - bounding
  - voxel
  - unio, metszet (CSG)
- mozgatasa
  - transzformacios matrix

Metszespont kereses
- esetei
  - elso talalat
  - arnyek vizsgalat
  - egyeb (tukrozodes, tores)
- sorrend
  - shadow cache
  - elozo fazis

Fenyek
- forrasok
  - pontszeru
  - spotlight
- szamolas
  - ambient
  - szort
  - phong
    - x^y
    - logaritmikus fuggvenyek
    - lookup table
  - tukrozodes
  - ateresztes
    - arnyek vizsgalatnal
  - tores
    - totalis feny visszaverodes
    - tobb kozegbe be-ki
  - kod

Felulet
- textura
  - tipusa
    - checker
    - bitmap
    - fraktalok
  - dimenzioja
    - 2d
    - 3d
- normal vektor
  -bump

Antialias
- elek
  - treshold kuszob
  - pixelenkent tobb szemvektor
  - atlagolas

Mozgatas
- keyframer
- b-spline

Optimalizacio
- Gyokvonasok eliminalasa
- Eredmenyek ujrafelhasznalasa
  - elozo keppont
  - korabbi fazis

Leiro fajl
- definicio
  - objektumok
  - mozgasaik
- masok altal definialtak
  - fontosabbak
    - PovRay 3.0
    - PolyRay 1.8
    - 3D Studio
  - elemzesuk
  - felhasznalasuk
    - teljesen
      - engedely keres
    - reszben
- kovereterek felderitese

Dokumentalas
- ASCII szovegben
  - barki be tud kapcsolodni utolag is a munkaba
- Forraskod
  - magasabb szintu nyelven
    - C
    - C++
  - makrokkal
    - minden platformra sajat macro.lib illeszt az ASM-hoz

Jatekiras
- pacman
- flipper
- faltenisz
............................................................................
  Persze fontos az IO formatumok definialasa, de halottam mar olyat, hogy
valaki nekiallt raytracert irni, par honap alatt szuper grafikus feluletet
csinalt neki, csak eppen a raytracert nem volt kepes megcsinalni...
  Szoval elso az elmelet, masodik az IO kapcsolatok es harmadik a program.
  Az IO formatumoknal pedig az biztos, hogy jobb keresgelni mar egy letezo
jol mukodo formatumot, mint egy sajatot kitalalni.

TomCat/Abaddon
............................................................................
Az kozos elsodleges celunk, hogy egyesitsuk tudasunk,
es azt egy text fajlba osszegezzuk...

Emellett esetleg lehetne mas celunk is pl. egy tracer
kozos megirasa. De mivel mindeki ugy nyilatkozott, hogy
nincs ideje, igy maradjunk inkabb az elmelet kitargyalasa
mellett.

Aztan mindenkinek lehet sajat egyedi celja is, nekem pl.
hogy minel tobb dolgot tudjak real-time megvalositani.
Gregnek pl. hogy 3DS fajlt szeretne real-time lejatszani.

Persze voltak temak, amit kihagytam pl.:
bsp-tree, octree, partial subdivision, vernoi diagrammok,
montecarlo modszerek stb.
Ezek mar egy kisse bonyolutabb dolgok, de mi szerintem eloszor
csak az alap-algoritmust optimalizaljuk...

Hetfore hozom a szemvektorok elmeletet, javaslom mas is irja
le, hogy o hogyan is lotte ki a szemvektorokat...

TomCat
............................................................................
Notes 1, Ray Tracing, 6 Nov 95

******************************************************
 Figyelem, a level tartalmat mashol publikalni reszben
vagy egeszben az engedelyem nelkul szigoruan tilos !!!
******************************************************

,,,,,,,,,,,,,,,,,,,,,,,
S.Z.E.M.V.E.K.T.O.R.O.K
'''''''''''''''''''''''

1. BEMENO ADATOK
----------------

1.1 PenTrace
    _
    From: A nezopont helyvektora.
    _
    At: A nezett pont helyvektora.
    _
    Up: A felfele mutato vektor (aminek segitsegevel pl. fejjel
        lefele allithatunk egy kepet).

    FOV (Field Of View): A vizszintes latoszog.

    Aspect ratio: A vizszintes es a fuggoleges latoszog aranya.

    X resolution: A kiszamolando keppontok szama egy soron belul.

    Y resolution: A kiszamolando sorok szama.

1.2 Pov-Ray
    _             _
    Direction: Az At helyett, nem a nezett pont van definialva,
               hanem a nezzett irany (egy normalt vektor).

1.3 3D-Studio

    Camera: A FOV helyett hasznalja, a kis fenykepezogepek lencseinek
            mereteivel azonos. A pontos osszefugest a FOV es a Camera
            kozott nem ismerem, de egy kozelito megoldast megadok:
            FOV = Camera * 180 / Pi * 2 / Helmholtz, ahol:
            Pi=3.1415926535897932384626 es Helmholtz=0.830875711002375
                   _
    Bank angle: Az Up vektor helyett definialja a kamera elfogatottsagat.
                0 szog a (0,0,1) vektornak felel meg.


2. KISZAMOLASA
--------------

2.1 A kepsik meroleges vektoraival (PenTrace v1.0)
    [Andrew S.Glassner "Ray Tracing for Realism" BYTE 1990]

2.1.1 Abra

      (-1,-1)_______________________________
            |                               |
            |                               |
            |              _       _        |
            |              At      H        |
            |               +-------------->|
            |              /| _             |
            |             / | V             |
            |            /  |               |
            |__________ /___V_______________|
                       /                    (+1,+1)
                      /
                   _ +
                   From

2.1.2 Elokeszites
      _   _    _
      G = At - From
      _   _   _
      X = G x U
      _   _   _
      Y = X x G
      _      _                           _
      H = ( |G| * TAN(Pi*FOV/360) ) * || X ||
      _      _                                          _
      V = ( |G| * TAN(Pi*FOV/360) ) * Aspect ratio * || Y ||

2.1.3 Kiloves

      i: -1, +1, 2 / X resolution

      j: -1, +1, 2 / Y resolution
      _      _       _       _
      S = || G + i * H + j * V ||

2.1.4 Mozgatas
      _  _  _
      G, H, V vektorokat frissitjuk.



2.2 Az elozo szemvektort modosito vektorokkal (PenTrace v1.1)

2.2.1 Abra
             _
      _      Xa                             _
      S(1,1)_______________________________ S(x,1)
           |+->+->+->+->+->+->+->+->+->+->+| _
           |+\----------------------------'| Ya
           |+-\+->+->+->+->+->+->+->+->+->+|
           |+<-\--------------------------'|
           |+->+\>+->+->+->+->+->+->+->+->+|
           |+<---\------------------------'|
           |+->+->\->+->+->+->+->+->+->+->+|
           |+<-----\----------------------'|
      _    |________\ _____________________|_
      S(1,y)         \                      S(x,y)
                      \
                     _ +
                     From

2.2.2 Elokeszites

      A 2.1.2 pont kepletei es
      _        _   _   _
      S(1,1) = G - H - V
      _    _
      Xa = H * 2 / X resolution
      _    _                          _
      Ya = V * 2 / Y resolution - 2 * H

2.2.3 Kiloves

      i: 1, X resolution, 1

      j: 1, Y resolution, 1
      _          _        _
      S(i+1,j) = S(i,j) + Xa
      _          _        _
      S(1,j+1) = S(x,j) + Ya
      _      _
      S = || S(i,j) ||

2.2.4 Mozgatas
      _       _   _
      S(1,1), Xa, Ya vektorokat frissitjuk.



2.3 Tablazatbol (Shells1)
    [Malcolm Taylor]

2.3.1 Abra
      _
      S[1]_______________________
         |\\\\\\\\\\\|///////////|
         |\\\\\\\\\\\|///////////|
         |\\\\\\\\\\\|///////////|
         |\\\\\\\\\\\|///////////|
         |\\\\\\\\\\\|///////////|
         |\\\\\\\\\\\|///////////|
         |_\\\\\\\\\\|//////////_|_
             \\\\\\\\|////////    S[x*y]
               \\\\\\|//////
                 \\\\|////
                   \\|//
                   _ +
                   From

2.3.2 Elokeszites

      A 2.2.2 pont kepletei es

      i: 1, X resolution, 1

      j: 1, Y resolution, 1
      _          _        _
      S(i+1,j) = S(i,j) + Xa
      _          _        _
      S(1,j+1) = S(x,j) + Ya
      _               _
      S[i+j*x-x] = || S(i,j) ||

      (A nagy felbontas eseteben felmerulo nagy memoriaigeny felere csok-
      kentheto, ha duplapontossag helyett csak szimplat hasznalunk).

2.3.3 Kiloves

      n: 1, X resolution * Y resolution, 1
      _   _
      S = S[n]

2.3.4 Mozgatas
         _
      Az S[] vektortablat frissitjuk. Nem kell normalni az uj szemvektorokat !



2.4 Nem sorfolytonos kilovessel

2.4.1 Rekurzivan (terulet-fillezessel)

2.4.1.1 Abra
        _                             _
        S(1,1)_______________________ S(x,1)
             |+                     +|
             | \                   / |
             |  \          _      /  |
             |   \       T At    /   |
             |    \      |      /    |
        _    |,____\ ____|____ /____,|_
        S(1,y) \    \    |    /    /  S(x,y)
                 \   \   |   /   /
                   \  \  |  /  /
                     \ \ | / /
                       \\|//
                       _ +
                       From

2.4.1.2 Kiszamolasa

        IF pontok tavolsaga * keppontok intenzitasanak kulonbsge < kuszobszam

           THEN terulet fillezve az atlag intenzitassal

           ELSE a negy vektor koze kilovunk egy ujat

        A kuszobszam altalaban kb. 0.2, a ket pont tavolsaga >= 1,
        a ket pont intenzitasanak a kulsonbseget pedig:

        dI = 0.299 * dR + 0.587 * dG + 0.114 * dB  [GRAPHICS.FAQ]

        (Ezek az atlagos szemerzekenyseg fiziologiai mereseinek adatai).


2.4.2 Antialias miatt

      A konturoknal szembetuno pixelezettseg eltuntetese vegett, gyakran
      nem sorfolytonosan, es tobb szemvektort lonek ki egy-egy pixelhez.
      Bovebben lasd a megfelelo fejezetben !


2.4.3 Parhuzamositaskor

      A feladatok felosztasa tortenhet ugy is, hogy minden egyseg egy-egy
      keppontot vagy egy-egy sort szamol ki => nem sorfolytonos kiloves.

Folyt.kov.
                           ,,,,,,,,,,,,,,,,,,,
                             Kaproncai Tamas
                             (TomCat/Abaddon)
                            tomcat@rs3.szif.hu
                               1995.11.06.
                           '''''''''''''''''''
............................................................................
Leirom, hogy en hogy is csinalom a BetaTrace-ben:

1. Adott ertekek:
-----------------

        - K  = kezdopont
        - Np = nezopont
        - D  = fokuszpont tavolsag (milyen messzirol egysegnyi az egysegvektor)
        - KepX, KepY  = szamolando kep merete
        - Mx, My = lekepzomatrix merete 
                (az latott terresz merete a kamera fokuszaban)

2. Szamolgatas:
---------------

        - V := Np-K, majd minden komponenset elosztom a hosszaval
                ( egysegvektor)
        - V - re meroleges vektorokat szamolok
                a. V1-et az XZ sikban
                b. V2 := V1 x (Np-K) / vektorialis szorzat !/
        - V1 := V1*Mx/Kepx
          V2 := V2*My/Kepy , meretezzuk oket a virtualis es a valodi kep
                             aranyanak megfeleloen
        - P0 := D * V - (V1*KepX/2) - (V2*KepY/2)
                        a virtualis kep bal-felso sarka
 
bal-felso sarka 3. Sugarkepzes (ciklusok)
-------------------------       

        - I: 0, KepX-1, 1
        - J: 0, KepY-1, 1 
        - VV := P0 + I*V1 + J*V2
                TRACE
        - ciklusok vege

Hat ennyi lenne, szerintem ez eleg egyszeru!
Talan tul is az, gondolo a Te altalad leirtak sokkal jobbak, de
nekem elso olvasasra tul bonyolultak.

                                        MGADUO / Strezi
............................................................................
   Nos a megoldasod az altalam leirtak kozul az elsohoz hasonlit. Kiloveskor
egy adott vektorhoz hozzadadod ket masik vektor valahanyszorosat. A kulonbseg
a megoldasaink kozott az, hogy en a te Mx es My adatod a latoszogbol szamolom
ki valahogy igy:
   _     _
   Mx = |V| * TAN(Pi*FOV/360)
   _       _
   My = ( |V| * TAN(Pi*FOV/360) ) * Aspect ratio

A masik kulonbseg pedig, hogy en nem a bal felso sarokba meno ponthoz adogatom
hozza a V1 es V2 vektorok valahanyszorosat, hanem a V (kozzeppontba) vektorhoz.

   Nezd meg a masik ket megoldasom! Ott a kiloves gyorsabb, mert nincs benne
szorzas es a harmadik megoldasban meg osszeadas sincs.
  (Persze a kiloves felgyorsitasanak leginkabb tobb fazis kiszamolasanal van
szerepe, es nem egy darab allo kepnel).

TomCat/Abaddon
............................................................................
Adva vagyon a kamera (x,y,z) meg az irany hogy merre nez a szerencsetlen
harom szog segitsegevel (alfa,beta,gamma). Szukseg van meg D-re amit a FOV
es a kepernyo meret ismereteben szamolhatunk ki.
tg(FOV/2)=xmax/D    ha a kepernyon xmax..-xmax intervallumban cimezzuk..

A vetiteshez olyan modszert hasznalok, hogy a vetitett kep az X-Y tengelyek
altal kifeszitett sikon van (z=0). Igy:

x'=x/(1+z/d)   es  y'=y/(1+z/d)

Egyenlore ennyi jut az eszembe...legkozelebb jobban keszulok, nem itt
helyben (IQ-bol) irom meg a forradalmi otleteimet :)

Ja! ha szukseg van a kamera 'csavarasara' akkor kell meg egy szog (ami a ti
UPV - up vector - teket helyettesiti).

Az szerintem elegge hasonlit Strezi felfogasahoz, csak en kerulendo a
vektorialis szorzatokat inkabb szogekkel irtam le ua.-t  (szerintem!)

                                                              GREG
............................................................................
raytraceremben nem igazan volt szempont a sebesseg, ezert ugy csinaltam, 
ahogy eloszor eszembejutott... Asszem (0,0,-d) pontbol lottem parameteres 
egyeneseket az (x,y,0) sikra.

 Pogi 
............................................................................
Nos, Tomcat, az a helyzet, hogy en meg abszolute nem foglalkoztam ray-tracerrel
ennek elotte, csak ugy gondoltam, hogy tarthatatlan, hogy csont hulye legyek
hozza, es ezert valasztottam szakdoli temanak. Mindettol fuggetlenul igen
szivesen reszt vennek egy kozos doksi elkesziteseben, csak elotte van egy kis
lemaradasom, amit potolnom kene... Nem tudsz akkor most pontosan, konkretan
textfile-okat, konyveket ajanlani, amit erdemes megnezni? Tudom, par hete
volt nehany ilyen info levelekben, de akkor meg nem volt fontos... (Csak
ket hete lett ez a temam... ) Udv mindenkinek, es jo munkat!

                                        Iron Hawk of Bi0Hazard
............................................................................
Infok nalam: http://rs3.szif.hu/~tomcat/RayTracing.html

A 3 best book:

_A_ Andrew S. Glassner
    Introduction to Ray Tracing
_B_ Christopher D. Watkins and Stephen B. Coy
    Photorealism and Ray Tracing in C
          (M&T Books, Inc.), 1992
          ISBN: 1-55851-247-0
          price: $44.95 U.S.
_C_ Christopher D. Watkins, Vincent Mallette, Stephen R. Marenka, Robert Johnson
    Exploring Ray Tracing and Animation: Photorealism, Fractals and 3-D Modeling
          (Charles River Media), 1995
          ISBN: 1-886801-13-4
          price: $39.95 U.S.

En is RayTracer-t irtam szakdolinak es a kov. irodalmat hasznaltam hozza:

[IA01] DR. KOVACS MAGDA "32 bites mikroprocesszorok 
80386/80486 II." LSI Oktatokozpont, 1994 ISBN 963-577-003-7

[IA02] BEV ZAHARIE "Optimizations for Intels 32-Bit Processors" Intel 
Corporation, 1993

[IA03] STEPHEN S. FRIED "Pentium Optimizations and Numeric 
Performance" Dr. Dobb's Journal, 1995 Januar

[IA04] RAMESH SUBRAMANIAM & KIRAN KUNDARGI 
"Programming the Pentium Processor" Dr. Dobb's Journal, 1993 Junius

[IA05] HARLAN W. STOCKMAN "Optimizing Matrix Math on the 
Pentium" Dr. Dobb's Journal, 1994 Majus

[IA06] MIKE SCHMIT "Optimizing Pentium Code" Dr. Dobb's Journal, 
1994 Januar

[IA07] DICK POUNTAIN "Pentium: More RISC Than CISC" BYTE, 
1993 Szeptember

[IA08] MICHAEL ABRASH "Aiming the 486" PC TECHNIQUES 1992 
Oktober/November

[IA09] MICHAEL ABRASH "80x86 Optimization" Dr. Dobb's Journal 
1991 Marcius

[IA10] MICHAEL ABRASH "Zen of Assembly Language" Glenview, 
1990

[IA11] TOM VERBEURE "Optimizing Vector Transformations on a 
Pentium" DemoNews 1995 Februar 5.

[IA12] MICHEL LESPINASSE "Memory Managment II." IMPHOBIA 
1994 Oktober 14.
 
[RT01] ANDREW S. GLASSNER "Ray Tracing for Realism" BYTE, 
1990 December

[RT02] DOMBI NORBERT "Fotorealisztikus kepgeneralas ray-tracing 
eljarassal" SZIF, 1994 Diplomamunka

[RT03] ALAN WATT & MARK WATT "Advanced Animation and 
Rendering Techniques" ACM Press, 1992 ISBN 0-201-54412-1

[RT04] CHRISTOPHER D. WATKINS "Photorealism and Ray Tracing 
in C" M&T Books,

[RT05] ANDREW GLASSNER "Graphics Gems I." Academic Press, 
1990 ISBN 0-12-286165-5

[RT06] SZEKELY VLADIMIR & POPPE ANDRAS "A szamitogepes 
grafika alapjai" ComputeBooks, 1992 ISBN 963-7642-43-9

[RT07] DREW WELLS & CHRIS YOUNG "Ray Tracing Creations" 
Wait Group Press, 1993 ISBN 1-878739-27-1

[RT08] CRAIG A. LINDLEY "Ray Tracing and the POV-Ray Toolkit" 
Dr. Dobb's Journal, 1994 Julius

[RT09] ALAIN MANGEN "RAY: A Ray-Tracing Program in C++" Dr. 
Dobb's Journal, 1994 Julius

[RT10] JOHN KNIGHT, PAUL GORDON & PHILIP MORRIS "Light 
and Shade" Personal Computer World, 1992 Oktober

[RT11] ERIC HAINES "A Proposal for Standard Graphics Enviroments" 
IEEE CG&A 1987 November

[RT12] PAUL S. HECKBERT "Ray-sphere intersection" comp.graphics 
newsgroup, 1987 Julius 20.

Udv, TomCat/Abaddon
............................................................................
NOS: a kovetkezo temank legyen a metszespont kereses!!!

1. mikor kell metszespontokat keresni, hany esetre celszeru ezt bontani?
2. hogy nez ki ez egy-egy egyszerubb objektumnal (pl. sik es gomb)?
3. es amit meg ti idetartozonak ereztek...

En meg a heten hozom az en verziomat!!!

TomCat/Abaddon
............................................................................

        1. Ezt a felvetest nem igazan ertem.
  Talan arra gondolsz, hogy peldaul meg kell e vizsgalni az utkozest egy
gombbel, ami mogottunk van stb. ?
        2. (ez akkor a kettes pont ?)
  Ezt a vizsgalatot en harom reszre bontom:

     a).: a gomb R nel tavolabb van tolunk, es sugariranyba
          Ekkor ket metszespont szamolhato
     b).: a gomb R nel tavolabb van tolunk, es nincs sugariranyban
          Ekkor nincs egy metszespont sem
     c).: a gomb R nel kozelebb van hozzank
          Ekkor egy metszespont van ( a gombben vagyunk )
                                         _  _ _
  Azt, hogy egy gomb sugariranyban van-e V*(G-K) elojele alapjan
donthetjuk el, ahol:
                _
                V = az aktualis trace vektor
                _
                K = a trace vektor kezdopontja
                _
                G = a vizsgalt gomb pozicioja

                R = a vizsgalt gomb sugara

  En a BetaTrace-ban definialtam specialis, vegtelen sikokat (GROUND),
amelyek vizsgalata igen egyszeru.
  Ha peldaul adott az Y=Y0 egyenletu sik, akkor van dofespont, ha
               _          _
        SGN(Y0-K.Y) = SGN(V.Y)

  Ehhez hasonloan meg ket primitiv sikot adhatunk meg, nem egy nagy durra-
nas, de neha hasznosak lehetnek !

  Altalanos sikokra igaz:

        ((K+Alfa*D)-P0) * N = 0
  ( ez a sik normalegyenlete )
  ahol:
                __
                P0 a sik egy pontja
                _
                N  a sik normalvektora
                a tobbit mar irtam.

  Ezt az egyenletet atrendezve kapjuk az:
                      _ __   _
                      K-P0 * N
                Alfa=--=---=--- egyenletet.
                       D * N
                                   _   _
  Ebbol eloszor ki kell szamolnunk D * N - et,
        <=0 noncs dofespont
        >0 esetben tovabb szamolva a kepletet
           megkaphatjuk Alfa-t, majd a dofespontot

  Haromszog vizsgalatahoz egy haromismeretlenes linearis egyenletrendszert
kell(ene) megoldani, ami valahogy igy irhato fel, meg vektoros alakban:
                __      __      __   _       _
                P0+Alfa*V1+Beta*V2 = K+Gamma*V

  Ahol:
                P0 a haromszog egy csucspontja
                V1 es V2 a csucspontbol (P0) kiindulo ket ele a polynak
                   (ezek nem normaltak, hanem a valodi elek)
                Alfa, Beta, Gamma skalar szamok

  Ezt az egyenletet felirva koordinatankent kapjuk meg a harom egyenletet.
Megoldva az egyenleteket megkapjuk Alfa, Beta, Gamma erteket.

  A kovetkezo lepesben megvizsgaljuk, hogy atment e a sugarunk magan
a haromszogon:
                ha (Alfa>0) es (Beta>0) es ((Alfa+Beta)<=1), akkor
                van dofespont a polyn belul (haromszog !)

  A modszer kibovitheto paralelogrammakra is, ha a feltetelt a ko-
vetkezore modositjuk:
                ha (Alfa>0) es (Beta>0) es (Alfa<=1) es (Beta<=1), akkor
                van dofespont a polyn belul (aralelogramma !)

  Sajnos eddig a pillanatig meg nem oldottam megae fent emlitett egyenlet-
rendszert. Remelem a kesobbi irasokbol kiderul mi is az optimais modszer.

                                        MEGADUO / BioHazard
............................................................................
   Tetszik az otlet, en meg nem gondoltam ra. De ehhez hasonloan specialis
tengelyiranyu csovek definialasra mar en is gondoltam. Az majdnem a gomb
szamitasaval azonos, csak meg joval egyszerubb, mert az egyik koordinata
akarmi lehet.

Ha jol gondolom akkor itt a megoldas a kerdesedre:
(Az en kerdesemre meg te adtad meg a valaszt, mert mar egyszer
feltettem azt a kerdest, hogy mit csinal a kov. rutin:)

/*
An Efficient Ray/Polygon Intersection
by Didier Badouel
from "Graphics Gems", Academic Press, 1990

just code, not a procedure.
*/

/* the value of t is computed.
 * i1 and i2 come from the polygon description.
 * V is the vertex table for the polygon and N the
 * associated normal vectors.
 */
P[0] = ray.O[0] + ray.D[0]*t;
P[1] = ray.O[1] + ray.D[1]*t;
P[2] = ray.O[2] + ray.D[2]*t;

u0 = P[i1] - V[0][i1]; v0 = P[i2] - V[0][i2];

inter = FALSE; i = 2;
do {
    /* The polygon is viewed as (n-2) triangles. */
    u1 = V[i-1][i1] - V[0][i1]; v1 = V[i-1][i2] - V[0][i2];
    u2 = V[i  ][i1] - V[0][i1]; v2 = V[i  ][i2] - V[0][i2];

    if (u1 == 0)    {
        beta = u0/u2;
        if ((beta >= 0.)&&(beta <= 1.)) {
            alpha = (v0 - beta*v2)/v1;
            inter = ((alpha >= 0.)&&(alpha+beta) <= 1.));
        }
    } else {
        beta = (v0*u1 - u0*v1)/(v2*u1 - u2*v1);
        if ((beta >= 0.)&&(beta <= 1.)) {
            alpha = (u0 - beta*u2)/u1;
            inter = ((alpha >= 0)&&((alpha+beta) <= 1.));
        }
    }
} while ((!inter)&&(++i < poly.n));

if (inter) {
    /* Storing the intersection point. */
    ray.P[0] = P[0]; ray.P[1] = P[1]; ray.P[2] = P[2];
    /* the normal vector can be interpolated now or later. */
    if (poly.interpolate) {
        gamma = 1 - (alpha+beta);
        ray.normal[0] = gamma * N[0][0] + alpha * N[i-1][0] + 
                beta * N[i][0];
        ray.normal[1] = gamma * N[0][1] + alpha * N[i-1][1] +
                 beta * N[i][1];
        ray.normal[2] = gamma * N[0][2] + alpha * N[i-1][2] +
                 beta * N[i][2];
    }
}
return (inter);

(i1 es i2 azt mutatja meg, hogy melyik ket tengely sikjaba kell
lekepezni a poligont 3D-bol 2D-be).

   Ezt a rutint is probaltam korabban hasznalni (PenTrace 1.0), de
a specialis esetekkel nem tudtam mit kezdjek (pl. 0-val valo osztas).
A haromszogekre bontast is eleg primitiven oldja meg a fenti kod.
Ezert most egy masik algoritmust hasznalok (PenTrace 1.1):

   Ez az eljaras konkav poligonokra mukodik, ugyhogy haromszogekre
tokeletes. De tobb szog eseten sem szuksege a haromszogekre bontas.
1. A poligont 3D-bol 2D-be vetitem
   - vizsgalom a normal vektorat
     - ha |A| a legnagyobb, akkor xy sikba vetitek, ui=yi, vi=zi
     - ha |B| a legnagyobb, akkor zx sikba vetitek, ui=zi, vi=xi
     - ha |C| a legnagyobb, akkor yz sikba vetitek, ui=xi, vi=yi
   (Ez prekalkulalhato).
2. Az elek egyenese altal kijelolt felsikokat vizsgalom
   - egy el egyenesenek egyenlete: ai*u + bi*v + ci = 0
   - ai,bi es ci ertekei az el 2D-be vetitett csucsaibol kiszamolhatok
     (ez is prekalkulalhato)
   - a metszespontra (ray-plane) megvizsgaljuk az ai*u + bi*v + ci osszeget
     minden elnel, ha a csucsokat (nem osszevissza, hanem) valamelyik
     koruljarasnak megfeleloan adtuk meg es ez az osszeg minden elre azonos
     elojelu, akkor a metszespont benne van a poligonban.
Ez a modszer elenkent 2 szorzast es 2 osztast 'eszik'. Pillanatnyilag jobb
megoldast nem ismerek. A nem konkav poligonokat, meg konkavokra kell bontani.
Csakhogy az egyaltalan nem egyszeru !!!

   A masodik modszer nem alkalmas a poligonaok normaljanak interpolalasara,
mig az elso igen. En jelenleg nem hasznalok poligonal patch-eket, de nagyon
szeretnek, ugyhogy valaki adhatna valamilyen tippet...

                C i a o ,      TomCat/Abaddon
............................................................................
Notes 2, Ray Tracing, 23 Nov 95

******************************************************
 Figyelem, a level tartalmat mashol publikalni reszben
vagy egeszben az engedelyem nelkul szigoruan tilos !!!
******************************************************

,,,,,,,,,,,,,,,,,,,,,
METSZESPONT VIZSGALAT
'''''''''''''''''''''

1. ESETEK
---------
a/ Az elso talalat keresesekor. Ilyenkor a vektoroknak a kezdopontjaik
   azonosak: a szem helyvektora. Ezert minden objektumhoz egyes adatok
   meg az adott kep trace-lese elott kiszamolhatok.
b/ Az arnyek vizsgalatkor: blokkolja-e valamelyik (nem atereszto) targy
   a feny utjat. Ilyenkor a metszespontra nincs szuksegunk csak az a
   kerdes, hogy letezik-e.
c/ A tukrozott vagy tort (ateresztett) sugar vizsgalatanal. Ilyenkor
   a kezdopont nem azonos, tehat egy altalanosabb rutin kell, mint az
   a/ pontnal.


2. TESTEK ADATAI
----------------
a/ bejovo adatok
b/ az osszes fazis elott szamolt adatok
c/ egyes fazisok elott szamolt adatok
d/ fazisok kozben szamolt adatok


3. TESTEK
---------
3.1 sugar (felegyenes)
3.1.1 elmelet
                         _
      - kiindulo pontja: P = (Px,Py,Pz)
                _
      - iranya: D = (Dx,Dy,Dz)  <--  egysegnyi vektor

      - egyenlete: (x,y,z) = (Px + t * Dx, Py + t * Dy, Pz + t * Dz), ha t < 0

3.1.2 adatok
      _______ 1.a ___ 1.b ___ 1.c ___ 2.a ___ 2.b ___ 2.c ___ 2.d _
      _    --------------------------------------------------------
      P    :           +       +       +
      _    --------------------------------------------------------
      D    :   +       +       +       +
           --------------------------------------------------------
      t    :   +               +                               +
      _    --------------------------------------------------------
      M    :   +               +                               +

3.1.3 szamolas
      _   _       _
      M = P + t * D, ha t < 0

      azaz
      _
      M = (Px + t * Dx, Py + t * Dy, Pz + t * Dz), ha t < 0


3.2 sik
3.2.1 elmelet
                        _
      - normal vektora: N = (A,B,C)
                    _
      - egy pontja: Po = (Xo,Yo,Zo)

      - egyenlete: A * x + B * y + C * z + D = 0

3.2.2 adatok
      _______ 1.a ___ 1.b ___ 1.c ___ 2.a ___ 2.b ___ 2.c ___ 2.d _
      _    --------------------------------------------------------
      N    :   +       +       +       +
      _    --------------------------------------------------------
      Po   :                           +
           --------------------------------------------------------
      D    :           +       +               +
           --------------------------------------------------------
      V    :   +                                       +
           --------------------------------------------------------
      d    :   +       +       +                               +
           --------------------------------------------------------
      t    :   +       +       +                               +

3.2.3 szamolas
       
      D = - (A * Xo + B * Yo + C * Zo)

      d = A * Dx + B * Dy + C * Dz

            A * Px + B * Py + C * Pz + D
      t = - ---------------------------- , ha d <> 0
                         d

      V = - (A * Px + B * Py + C * Pz + D)

          V
      t = - , ha d <> 0
          d


3.3 gomb
3.3.1 elmelet
                     _
      - kozeppontja: C = (Cx,Cy,Cz)

      - sugara: r

      - egyenlete: |(Cx - x,Cy - y,Cz - z)| ^ 2 = r ^ 2   <-- r * r

3.3.2 adatok
      _______ 1.a ___ 1.b ___ 1.c ___ 2.a ___ 2.b ___ 2.c ___ 2.d _
      _    --------------------------------------------------------
      C    :           +       +       +
           --------------------------------------------------------
      r    :                           +
           --------------------------------------------------------
      r2   :           +       +               +
      _    --------------------------------------------------------
      V    :   +       +       +                       +       +
           --------------------------------------------------------
      V2   :   +                                       +        
           --------------------------------------------------------
      b    :   +       +       +                               +
           --------------------------------------------------------
      d    :   +       +       +                               +
           --------------------------------------------------------
      t    :   +               +                               +

3.3.3 szamolas

      r2 = r ^ 2
      _   _   _
      V = C - P
          _   _         _     _
      b = V . D    <--  V dot D
                  _   _
      d = b ^ 2 - V . V + r2

      t = b +/- d , ha d <= 0
             _   _
      V2 = - V . V + r2

      d = b ^ 2 + V2

==================
 Kaproncai Tamas
 (TomCat/Abaddon)
tomcat@rs3.szif.hu
   1995.11.23.
==================
############################################################################
- Legujabban GUS MAX-ra valos ideju echo effektet akarok. Ugy gondolom,
  hogy digizek es lejatszok is egyszere, persze kozben kialakitom
  a real-time effektet. Na mostmar. Nem tudod, hogy lehet-e nem DMA-val
  digizni/lejatszni ? Azaz ugy mint SB-n : kuldok/fogadok egy-egy
  byte-ot a portra ...

- LGB
............................................................................
Termeszetesen lehet. (GUS-on mindent lehet!) A megoldas a kovetkezo:
A GUS memoriaba elkezdesz beirni adatokat. (DMA-val, vagy port-osan) es
kozben elinditod a lejatszast. Ha eleg szapora vagy, akkor mindig a 
lejatszas elott megerkezik az adat. Megjegyzem, felejts el az SB-t, meg 
azt a primitiv jelprocijat. A GUS-on sokkal elegansabb megoldasok vannak, 
raadasul nem is viszik a CPU idejet...

Ha TE EN lennek (ajaj!) Akkor az echot igy csinalnam: Elkuldenem a 
hangszert a GUS-memoriajaba. (Ha nem fer bele, akkor a fent emlitetett 
megoldassal reszekben jatszod le) Szoval elinditod, a 0.hangcsatornan. 
Azutan vagy IRQ-val, vagy a PLAYPOSITION port figyelesevel a kivant 
idoben elinditod a 1. csatornan ugyan azt a hangot csak mas hangerovel, 
es/vagy freq-val. Aztan igy tovabb. Igy akarmilyen effectus-t tucc 
generealni, pl. Surround (HOTTA:ugye jol irtam?!).
                                                        Alex
............................................................................
        Ha mar itt tartunk, hadd csinaljak egy kis reklamot a Computer
        Karacsonyra megjeleno konyvunknek a COM-WARE kiado gondozasaban:

                        BORS-BAJUSZ-CSIBRA-HORVATH:

                                A PC-K HANGJA

                       GUS, SB, MIDI, MOD programozas, es
                               minden ami kell

        A szerzokbol amugy a Bajusz Hyp-Xet jelenti a Horvath pedig HoTTa-t,
        azaz engem.
                                                                HoTTa
############################################################################
A kerdes pedig (amire tomor, es ve(g)sokig leegyszerusitett :) ) valaszt
varok: erdemes-e XMode-dal sznvedni/probalkozni egy demo/intro-ban ?
Hoz-e valami sebesseg novekedest (csokkenest), nagyon elbonyolitja-e
a kodot, vagy ellenkezoleg ? (U.i. Mar mind a ketfele ervelest hallottam)
Mar irtam XMode kodot, de abban nem volt semmi 3d, meg fillezes, ezert nem
tudom , hogy ezekhez hogy viszonyul.

    Atleta
............................................................................
A valasz egyszeru: attol fugg... :-)

Az Xmode hasznos ha nagy egyszinu feluleteket akarsz hasznalni, peldaul 
egyszinu vektorok (vagy ilyen a kep letorlese). Itt egy dword-os beirassal 
egyszerre 16 pixelt tudsz kirakni. (Wow!)

Ha olyat akarsz csinalni ahol a pontok szinet szamolod (gouraud, textura, 
..) akkor persze az elozo elony nem hasznalhato. Ilyenkor ket megoldas van:
1. Negyes maradek szerint negy ciklusban rajzolsz (vizszintesen), ez 
marha bonyolult, es pesszimalis. (nem optimalis)
2. Fuggolegesen raszterizalsz es ugy rajzolsz. Hasznos lehet, ha 
egyebkent az algoritmus amugy is fuggolegesen dolgozik (lasd doom falak, 
vagy mars, bar az utobbi nem hasznal xmode-ot.) Nem biztos hogy gyorsabb 
minta dupla puffereles!

Hyp-X /Demons
............................................................................
es meg valamire, ami mostanaban kezd elterjedni. a 320x400-as kepernyon
a rohadt sok szin hasznalatat emulalja egy par demo ugy, hogy egy pixel
szinet 3 egymas alatt levo pixelbol keveri ossze. ezt az Orange talalta
ki es alkalmazta eloszor azt hiszem az X14 nevu demojaban. azota egy
csomo mas helyen is lathato. pl. a bgforce nevu complex introban.
ez szerintem egy nagyon jo effect, ha valamire erdemes x-mode-ot hasznalni,
akkor ez az.
rod
............................................................................
Helyesbitenek, a felbontas 320*480. Es nekem is tetszett az otlet, igy
pl. a SHELLS1 ( a listara is bekuldtem ) introm is ezt hasznalja, ahol
a truecolor nem elerheto.

Xmode pedig igazabol akkor jo, ha egy szegmensnel tobbet szeretnel hasz-
nalni a video memoriabol. Pl. 2 kepernyozni akarsz: hatterben kiszamolni
a kovetkezo fazist (3d-nel ennek inkabb csak akkor van alapja, ha nem
mindig az egesz kepet masolod a vramba).
Vagy nagyobb fizikai v. virtualis felbontast akarsz hasznalni.
Vagy a vizszintes felbontast felere vagy negyedere szeretned csokkenteni.

Viszont ha a REP STOSD idejet vizsgaljuk:
XMODE <= NORMAL (VGA-tol fuggoen)

Szoval tenyleg attol fugg...

TomCat/Abaddon
############################################################################
Meg tudna valaki mondani,hogy hogyan, honnan stb. tudnam megszerezni
a GS hangkeszletet.
            Laci
............................................................................
        A GS a Roland szabvanya, a General MIDI ajanlas bovitese. A GS
        hangkeszlet tulajdonkeppen nem konkret hangmintakbol all, hanem
        egy ajanlas, hogy a MIDI hangminta programokban melyik helyen 
        milyen hangszereket kell megvalositani. 

        Maguknak a hangszereknek a megvalositasa mar a hanggenerator dolga
        (akar FM szintezissel is lehet GS keszletet csinalni, a szintetizalas
        modjat nem szabalyozza a szabvany)

        A GS hangszerkeszletet wavetable kartyak persze hangmintakkal 
        valositjak meg, gondolom erre vagy kivancsi. De itt is valtozo 
        az, hogy milyen minoseguek es hosszuak ezek a mintak. A GS zongora
        lehet 200k-s is, de egy 28 megas zongora patch is lehet, ha komoly
        samplerunk van.

        Nekem van egy GS keszletem az AWE32-hoz, ugy 1.5 mega (GM+ GS 
        kiegeszites) de ez nem tul jo minosegu, es az AWE sbk patch
        formatumaban van. Ha jo minosegu GS keszletet akarsz, akkor vagy
        sample CD-n kell korulnezned, vagy magadnak kell egyeni hangszerekbol
        (innen onnan szerzett dob, gitar, fuvos mintak) osszerakni a 
        keszletet, ezt sokan csinaljak. Arra a legkevesbe se szamits viszont,
        hogy a GS keszletet wav vagy hasonlo formatumban megtalalod, alt.
        hangkartyaspecifikus patch file-okban vannak (van jo konverter, ha
        kell, 2PAT 1.5...)
                                                                Hotta
############################################################################
Tran fele protmode extendert hasznalok,es debugolni szeretnem a SAJAT
codeomat,mert azert mert csak,na ezt hogyan tegyem,Sheep azt hiszem te
tudsz erre felelni,nem.
                             DAB of
............................................................................
Ja a kerdesre felelve: NEM TUDOD debugolni. (bruhuhu)
Ugyhogy most dontsd el tenyeg azt akarod-e hasznalni.
Ha esetleg pmode/w -t hasznalsz akkor ird meg azt lehet (bar bonyolult).

Hyp-X /Demons
............................................................................
Nem tudom milyen az a pmode/w,talan watcom? Pure assemblyt szeretem,
es ha nem a watcom C,akkor meg jo lenne,ha menne os2 meg winfos95 alatt 
is az amit irok.(ez egy 3d jatek lesz,gorod meg texturemappingos,olyan 
mint a Tie Fighter,csak jobb,kulonben mar megirtam 2 honapja hozza a 
gorodot meg a texturet,de a hetvegen ujrakezdtem az egeszet,ami azt 
jelenti,hogy mar irtam vagy 20 sort.)
............................................................................
Nem ismerem a Tran-fele pmode-t, csak kb. annyit hallottam rola, hogy
helyettesiteni tudja a Watcom C 10.0-hoz adott DOS4GW 1.95-ot. 
Fogalmam sincs, hogy ez forditva is igaz-e, de a Watcom Debugger 4.0
(szinten a Watcom C 10.0 resze) egesz kulturalt, es teljesen jol lehet
vele debuggolni a C-ben irt pmode-u programokat. En pure assemblyt nem 
debuggoltam, de azt eszrevettem, hogy a TASM-mal forditott reszeknel nem 
mukodik jol a source-level debugging. Van sajat assemblere is (WASM), 
csak sajnos nem kompatibilis se a MASM-mal, se a TASM-mal, leirast meg 
nem mellekeltek hozza.
                         _____________  
                        //__/_ _/__            
                     __//_/  //         Dornbach Peter
                    /__/__/ //____      jet@frey.inf.bme.hu
............................................................................
En speciel irtam egy kis debug betetet, amit beleforditok a progiba, 
igaz nagyon kezdetleges de a program futasat meg lehet vele szakitani 
a megadott ponton, itt ki irja a regisztrek valamint a stack 
tartalmat ugy, hogy megorzi a VGA szineit, MCGA uzemmodot tamogat.
Az elore megadott pont az a forraskodba beillesztett sor, ami 
meghivja a "DEBUG" reszt. Tehat nem valami USER barat, ui. mindig 
forditgatni kell a progit.

Let'S GoLem/CHEMOTOX
............................................................................
Mar tobb hejen lattam ilyet,es erdekelne a dolog,el tudnad nekem kuldeni?
Persze valami kis peldaprogival!                Koszi:

                DAB of                          __
............................................................................
Attachmentben kovetkezik debug betetem a TRAN fele pmode 1.29-es 
verziojahoz. Tudom, hogy nem a legujabb, de meg nem volt kedvem 
illeszteni a legujabb PM verziohoz.
A debug hatasara a progi futasa felfuggesztodik, kiirja a debug cimet 
azomositokodjat, valamint az ESP a Eregiszterek es a STACK tartakmat
mivel MCGA-hoz irtam ezert F5-tel lehet kapcsolni a debug kep es az 
MCGA kep kozott (azthiszem ilyenkor a szint nem allitja vissza, de a 
debug sor elhagyasa utan visszaallitja az eredeti szineket. ESC-el 
megszakitja a progi futasat es visszater a DOS-ba. Barmelyik 
billenyture tovabbengedi a progit.

Let'S GoLem/CHEMOTOX
............................................................................
        .386p
        jumps
code32  segment para public use32
        assume cs:code32, ds:code32, ss:code32

include pmode.inc
include kb32.inc

public  _main

@debug  macro val
        push &val
        call debug
endm

;                                                                             
; DATA
;                                                                             
_hextbl         db '0123456789ABCDEF'
_deb_str1       db 'Debug break at: '
_topofstack     dd ?
vgasave_o       dw ?
vgasave_s       dw ?

;                                                                             
; CODE
;                                                                             
;-------Debug--------------------------
debug:
        pushfd
        push ebp esp edi esi edx ecx ebx eax
        mov v86r_ax,1c01h
        mov v86r_cx,7
        mov ax,vgasave_s
        mov v86r_es,ax
        mov bx,vgasave_o
        mov v86r_bx,bx
        mov al,10h
        int 33h
        mov al,10h
        mov v86r_ax,3
        int 33h
        cli
        @rlp edi,0b8000h+2*160
        mov ebx,offset _hextbl
        mov ebp,8
        cld
        lea esi,_deb_str1
        mov ah,0dh
        mov ecx,0ch
str1l:
        lodsb
        stosw
        loop str1l
        mov edx,[esp+40]
        mov cl,8
        mov ah,0eh
        call debput
        mov cl,4
        mov ah,0dh
strl2:
        lodsb
        stosw
        loop strl2
        mov esi,esp
        add edi,160-2*21
        mov cl,8
        mov edx,[esi+36]
        mov ah,0fh
        call debput
        mov cx,19
        mov edx,[esi+32]
        rol edx,13
        mov ah,0ch
flagloop:
        rol edx,1
        setc al
        or al,30h
        stosw
        loop flagloop
        add edi,92
debl0:
        mov edx,[esi]
        add esi,4
        mov ah,0ah
        mov cl,8
        call debput
        dec ebp
        jnz debl0
        mov ebp,_topofstack
        add esi,12
debf0:
        mov edx,[esi]
        add esi,4
        mov cl,8
        mov ah,0ch
        call debput
        cmp esi,ebp
        jb debf0
        jmp gout
debput:
        rol edx,4
        mov al,dl
        and al,0fh
        xlat
        stosw
        loop debput
        mov al,' '
        stosw
        stosw
        ret
gout:
        sti
        call _getch
        cmp al,0eh
        je _exit
        cmp al,05
        je xch
        mov v86r_ax,1c02h
        mov v86r_cx,7
        mov ax,vgasave_s
        mov v86r_es,ax
        mov bx,vgasave_o
        mov v86r_bx,bx
        mov al,10h
        int 33h
        pop eax ebx ecx edx esi edi esp ebp
        popfd
        ret 4
xch:
        xor v86r_ax,10h
        or v86r_ax,80h
        mov al,10h
        int 33h
        jmp gout

;-----------------------------------------------------------------------------
_init_debug:
        mov eax,3c0h
        call _getlomem
        add eax,_code32a
        ror eax,4
        mov vgasave_s,ax
        rol eax,4
        and eax,0fh
        mov vgasave_o,ax
        mov _topofstack,esp
        mov ebp,esp
        ret
;-----------------------------------------------------------------------------
;-----------------------------------------------------------------------------
_main:
        call _init_debug
        call _init_kb
        sti
;Here comes your code
mov eax,1
mov ebx,2
mov ecx,3
mov edx,4
mov esi,5
mov edi,6
@debug 0a01f0h  ;this is the DEBUG line with a parameter to identify
        call _reset_kb
        jmp _exit

;                                                                             
; In:
; Out:
;                                                                             

;                                                                             
; In:
; Out:
;                                                                             

code32  ends
        end
............................................................................
PM debug ugyben : ha nem penzes progit irtok (nem kerestej vele), akkor
hasznalhatnatok a PMode/W-t, a PMode Watcom C-hez igazitott valtozatat
(nekem szimptaikusabb - tobbet tud - mint a mezei pmode), es akkor mar
csak egy watcom c-re, ill. annak a debuggerere van szuksegetek, azzal
lehet debugni a pm-ben futo pmode/w-s (ill. dos4gw-s) progikat.

     Atleta
............................................................................
haloooo mindenki : ES HA PENZES PROGIT IROK???
es tortenetesen megis protected modeban szeretnem.. 
akkor mit hasznalhat a szegeny penzehes programozo? :)
szoval arra lennek kivancsi hogy van e egyaltalan es ki milyent tud
olan total freeware meg "eztfellehethasznalni-penzesprogyban is"
stilusu kutyuket ... ugymint protectedmode manager + protected 
musicplayer..
(azseolyan nagy baj ha valmiert %ot kernek csak aztnemszeretem ha oda 
van irva hogy 3000$/kiadott program mert annyit az egesz 
programert se kapok :) aztan veszteseges programot irni + nincs 
kedvem..:)
    C-MonK
............................................................................
Akkor PMode, de no debug, vagy dos32 (pillanatny verzio 3.2). A dos32
csomagjaban van debugger, meg exaplek, csak valoszinuleg kicsit lassabb,
mint a pmode/w, mert kezeli az exeptionoket is. Viszont ingye' hasznalhatod,
es vannak benne 32bites DOS hivasok (ami a pmode-ban nincs, csak a
Pmode/w-ben. ). Tenyleg, nem tudja valaki, hogy hogyan oldjak meg az ilyen
32 bites regisztereket hasznalo dos hivasokat ? Visszamasolja a conv
memo ba a parameter puffert, es ugy hivja a dost (pl File open-nel a
file nevet), vagy ujra megirtak ???

Hat igen... Nagyon megtetszett a pmode/w a leirasa alapjan, csak ugye az
az 500$/program nem eppen kifizetheto ar erte. (Maga a Watcom C csak
200-250 dolcsi lenne, vagy a 10.5os kb 460$.) Persze a pmode/w doksija
alapjan - ha sokan akarnank hasznalni - a pmode-ra illeszthetnenk egy
interfacet, hogy ugyanazt tudja, mint a /w ...

      Atleta
............................................................................
 Nekem nincs tapasztalatom mas extenderekkel, mert a sajatomat hasznalom. 
Debuggert meg nem irtam, bar szukseg lenne ra...
 A dos-os hivasokrol : az en extenderem bizonyos dos funkciokat 32 
biteskent emulal. Ez annyit jelent, hogy pl az open fn nem dx-ben, hanem 
EDX-ben varja a file nevet, a read fn hasonlokepp, ecx adja a hosszat. Az 
emulacio ugy mukodik, hogy az also 640k-ban van egy buffer, amibe a dos 
fele a 16bites rutinok irnak ( vagy olvasnak ) es aztan innen atmasolom a 
megfelelo 32 bites cimre. 
 Esetleg lehetne egy ossznepi debugger projectet inditani, bar igy a 
vizsgaidoszakhoz kozeledve nem tudom, kinek mennyi ideje van. Ahogy most 
elkepzelem, az lenne a cel, hogy konnyen egy adott extenderhez lehessen 
igazitani. Ami szerintem a legnagyobb szivas, az a disasm megirasa. Egy 
olyan rutinra lenne szukseg alapvetoen, aminek egy cimet adunk, es egy 
bufferben visszaad egy sort disasm-elve, meg hogy hany byte volt az utasitas.
E kore mar mindenki epitgethet.
 Debugger nelkul is lehet persze hibat keresni, csak kicsit nehezebb. En 
ugy csinalom, hogy a hiba sejtett helyere beteszek egy kis dumpolo 
rutint, aztan vagy megvan a hiba, vagy nem. Ezen utobbi szomoru esetben 
uj helyre teszem a dumpolot, es nekiesek ujra. Sajnos igy eleg lassan halad.
 Arrol van elkepzelesem, hogy hogyan lehetne disasm-et irni, azt viszont 
nem tudom, hogy a kepernyo csereberelest hogy lehet hatekonyan es 
helyesen megoldani. Ha van valakinek tapasztalata, otlete, megsughatna.

                                                        Hat ennyi...Paf
............................................................................
Nem rossz otlet Mr. pesti Tomcat,ennek van egy otltem amit meg nem 
pobaltam ki,es fogalmam sincs,hogy mukodne-e. A dolog lenyege,hogy a 
debugger ugy nezni ki,amit akar meg pascalban is meg lehet irni,hogy a 
forrasunk minden sora utan berakna egy call Protdebug sort,es az 
assembler ezt forditana le,majd ezt futtatnank,na a Protdebug 
proceduraban meg annyi lenne,hogy elmentene a flageket,meg kiirna a 
regisztereket,meg visszatoltene a flageket,tehat nem ken 
dizassemblalni,es a forras szintu sorokat a .asm file-bol kivehetne,ha 
valaki meg tudja mondani,hogy ez miert nemn jo,vagy meg tudja 
csinalni,gyakorlatilag van ra ideje,akkor irjon!!!

                DAB of                          __
............................................................................
Azt hiszem, hogy az nagyon le lassitana a program futasat, ha minden 
programsort egy debughivas kovetne. Az valoban jo otlet, hogy az .asm 
forrasbol is szedhetnenk a disasm sorokat, ha sajat fejlesztesu 
progit debugolunk, ellenben mi van akkor ha nem all rendelkezesunkre 
a forras. Azt hiszem jo lenne egy disasm procedurt irni, es 
kihasznalni a 386 adta debuglehetosegeket. Azt hiszen az utobbiban 
benne lennek.

Let'S GoLem/CHEMOTOX
............................................................................
Nem ertem mi a bajod a call-os,sot egyaltalan barmely debugolas 
gyorsasagaval,amikor azt ugyis k. lassan tudod csinalni,vagyis en csak ugy.
Ovastam egyszer a debug regiszterekbol abban a valamilyen nonek a 
konyveben,valami intel 386-486 a cime,de akkor meg nem volt gepem se,a 
konyv meg nincs meg,szoval kuldhetnel valamit ezekrol,meg a crX-es regekrol,
ja a masok kodjanak debugolasarol nincs egy jo velemenyem,az egyszeruen 
lopas,es kesz,az a szep a programozasban,hogy magadtol jossz ra a 
dolgokra,ha meg nem jossz ra,akkor megkerdezed valakitol,es ha meg 
mondja,akkor fasza gyerek,es altalaban megmondja (nekem pl.Alma,Strezi, 
Tomcat).Ezert siman lehetne olyat irni,ami csak nekunk,es ha valakinek kell,
akkor eladjuk,jo lenne egy cegnek,de ezek elerhetetlen almok.

                DAB of                          __
............................................................................
Nos ezzel a modszerrel annyi a gond, hogy ott is adna debugot ahol 
mondjuk nem lenne szukseged ra, pl.: egy ujabb reszet akarod 
tesztelni a proginak. Mondjuk ezt at lehetne hidalni a debug sor 
hagyasaval, vagy a debug inteligensebbe tetelevel.

Ovastam egyszer a debug regiszterekbol abban a valamilyen nonek a 
konyveben,valami intel 386-486 a cime,de akkor meg nem volt gepem se,a 
konyv meg nincs meg,szoval kuldhetnel valamit ezekrol,meg a crX-es regekrol,

ez a bizonyos konyv nekem meg van (csak sajna nem itt, hanem otthon) 
es erre epitve mondtam a degub regegek kihasznalasat, bar ez meg sok 
kiserlettel jar.

Let'S GoLem/CHEMOTOX
............................................................................
Igen ha jol emlekszem a tranos pmode is a konvencionalis memoriat 
hasznalja ilyen celra,ott van a buffer! Tenyleg a tranosra kellene 
irni,mert az legalabb nem kerul penzbe.En most a bennmaradasomert 
kuzdok,ugyhogy ennem vallalom egyenlore a projectben valo reszvetelt,majd 
februar 5. utan,ha akkor jelentkezem,akkor atmentem a vizsgakon!

                DAB of                          __
############################################################################
Csa Fiuk. Latom, a jovo ray-tracerenek alapkovei formalodnak a kezeitekben.
En ugyan abszolute nem ertek az ilyesmihez, de azert lenne egy otletem
szamotokra. Itt a BME-n kezd formalodni egy projekt a kovektezo korvonalakkal:

'Egy olyan szoftver, amely alkalmas termesztben elofordulo dolgokrol profi
kepeket krealni.'

A profi azt jelenti, hogy olyan minosegu, amit adatbazisokban, multimedia
celokra, jatekokban, esetleg filmben hasznalni lehet.

A jelenleg ismert ray-tracing szoftverek eleg jok arra, amire terveztek oket,
azaz hogy text=A3razott poligonokbol, gombokbol, stb. tukrozodesekkel, arnye-
kokkal tuzdelt kepeket. Viszont kevesse alkalmasak olyan dolgok abrazolasara,
amit egyaltalan nem, vagy csak nagyon sok ilyen elembol lehet felepiteni.
Ilyen dolgok a termeszetben gyakran fordulnak elo, pl. hegyek, felhok, fak.

Az otlet tehat az, hogy egy olyan szoftvert kellene csinalni, ami:
* alkalmas a fent nevezett dolgok generalasara, szerkesztesere,
* ezekrol profi minosegu kepet tud csinalni,
* az egyes dolgok rugalmasan szedhetok ossze egy kepre.

A szoftver az elkepzeleseim szerint tobb reszbol allna, mindegyiket kb. egy-
valaki irna meg. Mindegyik reszprogram alkalmas arra, hogy az altala valasz-
tott objektumfelesegeket veletelenszeruen generalni, szerkeszteni lehessen.
Ezen tul kepes az objektumot renderelni, azaz kepet gyartani belole.

Lenne egy sajat formatum, ami a renderelt kepet tarolna. Az alapotlet az,
hogy minden pixelhez taroljuk el a szine mellett a zbuffer erteket is (vagyis,
hogy milyen messze van a nezoponttol). Ezaltal a sok program altal keszitett
kepet viszonylag egyszeruen ossze lehetne mixelni egyetlen keppe. Meg lehet
oldani azt is, hogy az objektumok arnyekot vessenek egymasra, stb.

A lehetseges reszprogramok:
* Terep (landscape) folyokkal, novenyzet-texturaval, telepules-texturaval
* Felho, kod, fust
* Novenyek, fak
* Objektumok solid texture-val (*)
* Objektumok importalasa
* .. amit meg kitalaltok.

(*) A solid texture egy specialis technika marvany, tuz, hullamok, stb.
letrehozasara. Akit erdekel, van nalam egy cikk rola.

A szoftver PC-n csak LINUX + X alatt futna. Terveim szerint az egesz Gnu C++
forditoval keszulne, es futnia kene mas UNIX-okon is. (frey, indigo2, stb.)

A projekt a jovo evi TDK palyazatra lenne kesz.

Ui. Azota kiderult, hogy valoszinuleg lesz DOS es/vagy Windoz ala is.

Naszoval, mit szolnatok hozza, hogyha a ti ray-traceretek is tamogatna a
fent emlegetett kozos kepformatumot. (Persze ez itt csak az alapotlet, meg
kidolgozasra szorul a tema.) Szerintem megerne, baromi jo lenne, ha lehetne
atjaras a ket proggy kozott. Persze, ha van jobb otletetek, szivesen varom.
                         _____________ 
                        //__/_ _/__           
                     __//_/  //         Dornbach Peter
                    /__/__/ //____      jet@frey.inf.bme.hu
............................................................................
  A z-pufferelt kepformatum egy jo otlet, csak ugye pontosan specifikalni
kene. Ket kep osszegzesekor gond lehet, ha a ket kep nezopontja kulonbozo,
ha a z ertekek nagysagrendje mas.
  A projekthez pedig figyelmetekbe ajanlom a mar letezo es hasonlo programokat:
KPT-Bryce
VistaPro 3.
  Mint olvashattad egyelore nem lesz kozos RT program, igy aztan nincs mi
tamogassa a kepformatumot.
  Egy biztos egy ilyen levelezesi listan keszulo kozos programnak, nem szabad
tul nagy celt kituzni, mert eleg lassan halad a munka...
############################################################################
        Apro kerdesem lenne. Hogyan lehetne megoldani azt, hogy egy
   adott poligonra a perspektiva figyelembevetelevel keruljon fel a 
   bitmap es ne kelljen hozza nagyon komoly muveleteket elvegezni ?
        Gondolok itt pl. a DESCENT -ben lathato falakra. Az a legnagyobb
   gondom, hogy, ha szepen hozzarendelem a poligon csucsaihoz, a bitmap
   bizonyos pontjait, majd az elek, utana pedig a scanline-ok menten
   linearis transzformaciot hajtok vegre (a koordinataparokon), akkor
   pont azt kapom, mintha szembol latnam a poligont (mintha minden 
   koordinataja ugyanazzal a Z tavolsaggal rendelkezne).
        A macska (cats rule) ott van elasva, hogy egy harom dimenzios pont
   transzformalasa ket dimenziosra, Z-vel valo osztassal tortenik.
   Az f(z)=d/Z fuggvenyt kiszamolni, pedig idoigenyes dolog...

                                                TE'EM the Cat
............................................................................
                  Egy cipoben jarunk. En honapokkal ezelott hosszas
vizsgalodast ill. levelezest folytattam az Interneten, mindenfele
gurukkal, hires es hirhedt programok iroival targyaltam ez ugyben.
MEG NEM SZULETETT TOKELETES MEGOLDAS. Meg nincs megoldas arra, hogy
hogyan lehetne kiszamolni osztas nelkul az f(z)=d/Z fuggvenyt, ahol
Z folyamatosan valtozik. Vannak rosszabb es kevesbe rossz kozelito
eljarasok, de egyik sem az igazi, es az igazat megvalva nem volt
turelmem levezetni oket. Bar allitolag egesz komoly realtime
programok is kozelitest hasznalnak.
                                                Ash of himself
............................................................................
DESCENT info:

Talan eszrevetted, hogy a descentben a perspektivikus mellett az altalad 
leirt linearis is meg van csinalva. (Ha leveszed a wall detailt lathatod.)

Altalaban:
A problemanak kozismerten tobb megoldasa van:

1. Subdivide (kb. reszekre osztas.)

Az altalad emlitett fuggvenyt csak bizonyos egysegenkent szamolod ki, 
aztan azok kozott linerisan kozelitesz. Sokkal gyorsabb lesz mintha 
mindig osztogatnal, es ennek ellenere egesz jol nez ki.
Ezt hasznalja a Descent is, vizszintesen minden 16-ik pixelnel szamolja 
ki a pontos erteket.

2. Masodfoku kozelites

Szerintem kitalalod mire gondolok. Meg nem csinaltam ilyet, nem tudom 
milyen jo. Arrol se tudok hasznaltak-e mar. (Valoszinuleg PC-n nem.)

3. Constant Z mapping. (kb. egyenlo tavolsag modszer.)

A lenyeg az hogy a kepernyon meghatarozod azt az iranyt, amelybe eso 
egyenesek menten levo pontok tavolsaga (Z koordinataja) egyenlo. (Huhh!)
Ezen egyenesek menten mar valoban linearisan kezelheted a texturat.
Ez azt jelenti, hogy nem vizszintes vonalankent (scanline) rajzolsz, hanem 
szukseg szerinti vonalankent. (A Doom-ban pl. vizszintes es fuggoleges 
iranyu megjelenitessel kell dolgozni.) Ez a leggyorsabb, de eleg 
bonyolult, nem tudok rola, hogy megcsinaltak volna.

Hyp-X /Demons
############################################################################
============================================================================
CODER-L levelezesi lista gyakran ismetelt kerdesei (FAQ), ver.:1.20
Irta Kaproncai Tamas aljas TomCat/Abaddon, aki a lista tulajdonosa.
----------------------------------------------------------------------------
 1. Hogy lehet feliratkozni a listara?
 2. Hogy kell leiratkoznom a listarol?
 3. Miert nem tudok irni levelet a listara?
 4. Miert nem kapom meg a sajat leveleimet?
 5. Megvaltozott a cimem, mit tegyek?
 6. Itt a nyar es nem ferek hozza a levelesladamhoz, mit tegyek?
 7. Hol talalhatok meg a regi levelek?
 8. A sok levelbol a fele se erdekel, leiratkozzam a listarol?
 9. Mi tartozik a listara?
10. Mi NEM tartozik a listara?
11. Kik a lista olvasoi?
 
============================================================================
 1. Hogy lehet feliratkozni a listara?
----------------------------------------------------------------------------
  Irni kell egy levelet a listservernek. A listserver felelos nyilvantartani
a coder-l olvasoit. A listserver cime:   listserver@d6.szif.hu.
A level targya (subject) barmi lehet. A level testebe (body) kerulhetnek a
paranacsok, minden sorba egy. Pelda:   subscribe coder-l TomCat Abaddon
Ez a parancs bejegyzi az olvasok taboraba azt a cimet, ahonnet a level
erkezett es TomCat/Abaddon neven fogja nyilvantartani az olvasot.
 
============================================================================
 2. Hogy kell leiratkoznom a listarol?
----------------------------------------------------------------------------
  A leiratkozas parancsa: unsubscribe coder-l (vagy uns coder-l).
(Hogy hova keruljon a parancs, azt lasd az 1. pontban!)
 
============================================================================
 3. Miert nem tudok irni levelet a listara?
----------------------------------------------------------------------------
  Altalaban azert, mert nem arrol a cimrol irtal a coder-l@d6.szif.hu cimre,
ahonnet feliratkoztal. Onnet probald meg kuldeni a levelet, ahonnet felirat-
koztal!  De ha megis a masik cimrol szeretnel irni, akkor vagy csereled le a
cimed (ld. 5. pont), vagy iratkozz le a korabbi cimedrol es iratkozz fel az
uj cimeddel! (ld. 1. es 2. pont).

  Masik lehetoseg, hogy a felado neve vagy a level targya gyanus. Ez azt
jelenti, hogy a listserver altal nem kivanatos szavak szerepelnek benne.
Peldaul: daemon.

  Harmadik lehetoseg, hogy tudsz te irni, csak azt hiszed, hogy nem tudsz
(ld. 4. pont).
 
============================================================================
 4. Miert nem kapom meg a sajat leveleimet?
----------------------------------------------------------------------------
  Ez olvasonkent hangolhato. Most az alapertelmezes az, hogy a sajat leveled
te nem kapod meg. Ha ez nem felel meg, akkor ad ki a kov. paranacsot:
set coder-l mail ack  Ha kesobb megsem akarod a sajat leveleidet olvasni:
set coder-l mail noack
 
============================================================================
 5. Megvaltozott a cimem, mit tegyek?
----------------------------------------------------------------------------
  Ha masik accountot kaptal, vagy a rendszer adminisztrator addig varialt,
hogy a cimed mar nem mukodik, akkor mar semmilyen parancsot sem tudsz kiadni
a listservernek. Csak ekkor irj a lista tulajdonosanak: tomcat@rs1.szif.hu !

  Ha regi cimed is el, akkor hasznald a megfelelo parancsot a regi cimrol:
set coder-l address spam tomcat@rs1.szif.hu (persze a te jelszavaddal es a
te uj E-mail cimeddel).
 
============================================================================
 6. Itt a nyar es nem ferek hozza a levelesladamhoz, mit tegyek?
----------------------------------------------------------------------------
  Ha azt szeretned, hogy a cimed ne vesszen el, vagyis a listserver tovabbra
is tudjon rolad, akkor ne iratkozz le, csak a kovetkezo parancsot ad ki:
set coder-l mail postpone  Amikor ujra keszenallsz fogadni a leveleket,
akkor adj ki egy set coder-l mail ack  vagy egy  set coder-l mail noack
parancsot (ld. 4. pont)!
 
============================================================================
 7. Hol talalhatok meg a regi levelek?
----------------------------------------------------------------------------
  Nezz korul a lista kezdolapjan (http://rs1.szif.hu/~tomcat/coder-l.html)!
Az ujabb levelek egy nagy textfajlkent (folderkent) letolthetok. A regebbi
levelek pedig a SourceCode nevu diszkmagazinokban megtalalhatok. A koztes
levelek viszont (a nagy szamuk miatt) sajnos pillanatnyilag nem elerhetok.
 
============================================================================
 8. A sok levelbol a fele se erdekel, leiratkozzam a listarol?
----------------------------------------------------------------------------
  A leiratkozast csak a legvegso esetben javaslom! Ha csak ritkan jutsz a
levelesladad kozelebe, akkor mindenkeppen allitsd be, hogy csak osszesitett
leveleket kapjal tartalomjegyzekkel egyutt: set coder-l mail digest
Igy amennyiben mindenki beszedes cimeket haszanal, akkor a tartalomjegyzek
atfutasaval konnyen meg fogod talalni a teged erdeklo temat (ld. 9. pont).
Ha megis ujra kulon-kulon szeretned a leveleket kapni, akkor egy
set coder-l mail ack  vagy egy  set coder-l mail noack parancsot kell
kiadnod (ld. 4. pont).
 
============================================================================
 9. Mi tartozik a listara?
----------------------------------------------------------------------------
  Mindenkinek nyomatekosan felhivom a figyelemet, hogy hasznalja a level
cimeben a temacsoportokat jelolo 2 betut!!! A temacsoportok megiseresevel a
listara valo levelek targya is vilagos lesz...

A fobb temak:
2D: 2D-s rajzolgatas vonal, kor, elipszis stb.
3D: 3D engine programozasa.
CO: Code Optimizing, kodoptimalizalas.
DE: Demo Effektek kitargyalasa. Aki mar megcsinalt valamit es mar unja, hogy
    minden demoban visszakoszon, akkor inkabb ismertesse az rutint es mas mar
    ne kuzdjon vele (fejlodjon a magyar demoscene!).
EG: Egerkezelesebol adodo problemak.
FF: FajlFormatum leirasa.
FR: Fraktalok (IFS, stb.).
HT: HyperText, HTML programozas.
HW: Egyeb hardver programozasa (pl. soros, parhuzamos port, HD, timer stb.)
IP: Image Processing, kepmanipulacio, bitmap transzformaciok.
ME: Memoriakezeles (pl. XMS, EMS stb.).
MA: Matematikai problemak (pl. gyokvonas, veletlenszam stb.)
PM: ProtectedMode es FlatRealMode programozas.
RT: RayTracing, sugarkovetes.
GS: GUS es egyeb hangkartyak programozasa.
VG: VGA kartya programozas, VESA programozas.
WI: Windows Interface, ablakozos keretrendszer.

Informaciok:
!!: ANNOUNCEMENT. Valamilyen munkad elkeszult es szeretned terjeszteni.
    Tesztelesre korbeadni.
UP: Ftpszerverekre feltoltott fajlok listaja (Ez ftp.szif.hu, ftp.vein.hu
    vagy dlux.sch.bme.hu)
LI: A listaval kapcsolatos informaciok (pl. bemutatkozasok).
PI: Partikkal kapcsolatos informaciok.
SI: A scenevel kapcsolatos informaciok.

Egyeb:
??: Egy kerdes vagy segitseg kerese, AMI IGAZABOL NEM A LISTARA VALO,
    de megis ezeknek az emberkeknek szeretned feltenni.
    Peldaul alaplapot szeretnel venni, de nem tudod milyen chipset legyen
    rajta (benchmarking stb.). EZEKRE A KERDESEKRE MAGANLEVELEKBEN ILLIK
    VALASZOLNI!!!
++: Egy korabbi kerdesre erkezett VALASZOKAT OSSZEGEZHETJUK ezekben a
    levelekben (pl. ami ??:-es volt).
 
============================================================================
10. Mi NEM tartozik a listara?
----------------------------------------------------------------------------
  Avagy hogyan erhetjuk el, hogy kizarjanak a listarol? Eleg sok fekete pont
osszegyujtesevel. Fekete pontok megszerzesenek lehetosegei:
Fobbenjaro bunek: A listara olyan level kuldese,
1. amely nem tartalmaz technikai iformaciot. Idezet egy ilyen levelbol: "Amit
   leirtal az baromsag! Hulye lamer! Anyad! ...".
2. amelynek nincs cime (subject).
3. amely hosszu dokumentumot (s foleg ha angol nyelvut) tartalmaz.
Kisebb vetkek: A listara olyan level kuldese,
1. amely cime nem tartalmaz temacsoportot, vagy a temacsoport megteveszto.
2. amely a binaris fajlt MIME formatumban hozza, UUENCODE helyett.
 
============================================================================
11. Kik a lista olvasoi?
----------------------------------------------------------------------------
  A listservertol lekerheto a mar feliratkozott olvasok listaja. A megfelelo
parancs: rev coder-l.  Ha azonban valaki szeretne titokban tartani, hogy o a
lista tagja, akkor a kovetkezo parancsot adhatja ki: set coder-l conceal yes