szintetikus k‚pgener l s - avagy hogyan s–rĄtsnk 4m textŁr t egy 64kintroba
 (v zlat a 'coderl night'-on tartand˘ textŁragener l s el“ad shoz)
 blala/byteam (k“m–ves bal zs)

 - copyright license :))
    - a mell‚kelt _szĄnes_ k‚pek csak a leĄrt algoritmusok demonstr l sa 
      c‚lj b˘l vannak, azokat b rmi m˘don felhaszn lni, sokszorosĄtani,
      nyilv nosan mutogatni, etc, etc... a szerz“ Ąr sos enged‚lye n‚lkl
      _tilos_; a mell‚kelt forr sokkal/fekete-feh‚r k‚pekkel azt csin ltok
      amit akartok :)
      az egyetlen kiv‚tel az eg‚sz csomag (alk”nyvt rak meg minden :)
      _m˘dosĄt s n‚lkl_, elektronikus Łton val˘ terjeszt‚se..
      (hadd ”rljetek j˘l:)

 - mi is az a textŁra?
    - k‚tv ltoz˘s fggv‚ny:
       - color(x,y)
       - ‚rtelmez‚si tartom ny ‚s ‚rt‚kk‚szlet is [0..1] val˘s
         (gyakorlati alkalmaz sokn l persze  ltal ban [0..255] eg‚sz :)
       - lehet monokr˘m vagy truecolor
          - f(x,y) -> ennek nagy el“nye, hogy ut na szabadon lehet hozz 
            palett t rakni, ‚s mivel a paletta hossza a textŁr ‚hoz 
            k‚pest elhanyagolhat˘, ak r le is lehet t rolni, ‚s ezzel
            el‚g sz‚p dolgokat lehet el‚rni..
          - r(x,y), g(x,y), b(x,y) 
            (esetleg az ‚rt‚kk‚szlet nem skal r, hanem egy (r,g,b) vektor,
            de ez csak form lis probl‚ma :)
            persze a palett hoz hasonl˘ stuffot itt is bele lehet ‚pĄteni
            a 3 fggv‚nybe; egy-egy r'(col), g'(col), b'(col) fggv‚nnyel,
            ‚s akkor Łgy fog kin‚zni, hogy r'(r(x,y), stb..
            v‚glis a paletta is csak egy fggv‚ny :))
 - n‚h ny  ltalam ismert/alkalmazott m˘dszer
    - ugyan a fggv‚nyt ritk n szoktuk direktbe, 'k‚plettel' megadni, de
      ezt is lehet: pl egy id“ben el‚g sokat kĄs‚rleteztem azzal, hogy
      csin ltam egy programot, ami gener lt egy csom˘ random fggv‚nyt
      (ilyen sin(x*0.23+cos(y*1.67+x^2*log((y+x)*5.42*sin(...))) tĄpusŁt:)
      ‚s ut na lesz moltattam mindet, ‚s kiv logattam n‚h nyat..
      erre l that˘ n‚h ny k‚sz k‚p a .\func k”nyvt rban 
    - noise ‚s turbulence
       - ezeket a fggv‚nyeket (f(x,y[,z], skal rt ad vissza) egy Perlin 
         nev– Łriember tal lta ki, ‚s valamikor 1985 k”rl publik lta, hogy 
         ilyesmire (textŁragener l s) lehetne “ket haszn lni..
         “ azt mondta, hogy a noise pl az‚rt j˘, mert
          - forgat s ‚s eltol s hat s ra l‚nyeg‚ben nem v ltozik
          - ‚s a frekvenci ja egy adott z rt intervallumon bell van
         ellenben ‚n, mint democoder, azt mondom, hogy az‚rt j˘k ezek
         a fggv‚nyek, mert mindenf‚le, egym st˘l teljesen kl”nb”z“
         nagyon sz‚p textŁr t lehet vele csinalni.. :)
       - na akkor a noise l‚nyege, hogy egy n‚gyzetr cs pontjaira random
         sz mokat Ąrunk (mondjuk a [0..1] intervallumban:), ‚s k”zte
         interpol lunk.  ltal ban line risan (okos emberek k”rlj rt k a
         probl‚m t, ‚s v‚gl arra a k”vetkeztet‚sre jutottak, hogy a
         nem line ris interpol ci˘s technik k ebben az esetben nem
         vezetnek annyi (vizu lis 'sz‚ps‚gben' jelentkez“) el“nyh”z, hogy
         ‚rdemes legyen szenvedni velk :))
         vannak pascal p‚ldaprogramok a .\noise\source k”nyvt rban, forr ssal..
       - a turbulence szint‚n nem bonyolult:
                        inf  noise(x*(2^i))
         turbulence(x) = ä (ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ)
                        i=0     2^(i+1)
         ebben az a vicces, hogy
          - ha a noise [0..1]-ben volt, akkor a turbulence is ilyen lesz
          - ha belezoomolunk, akkor olyan lesz, mint az eredeti, csak 
            kisebb frekvenci val
          - a szumm z st gyakorlatban nem kell a v‚gtelenig csin lni
            (el‚g neh‚z is volna :), hanem el‚g k-ig, ahol 1/(2^(k+1))
            kisebb mint egy pixel m‚rete..
          - sz‚p :)
         ezenkĄvl, ha intelligensen csinaljuk (a noise-ot mod n r cson,
         ‚s nem sim n:) akkor m‚g 'k”rbe‚r“s' is lesz (tulajdonk‚ppen a
         turbulence-t nem csak noise-ra lehet r ereszteni, csak arra
         szoktul :) - sz˘val b rmilyen 'k”rbe‚r“s' fggv‚nyre (k‚pre)
         engedjk r , 'k”rbe‚r“s' lesz az eredm‚ny is.
         erre is van pascal p‚ldaprogram a .\noise\source k”nyvt rban,
         meg van egy szeml‚ltet“program is, ami szeml‚lteti, hogy 
         gyakorlatilag mit jelent az a szumma ott fentebb..
       - nos, a turbulence m r ”nmag ban is sz‚p, de mindenf‚l‚re lehet
         ezek ut n meg haszn lni..
          - a legtipikusabb p‚lda a m rv ny:
            itt egy sin(x) fggv‚nyt modul lunk a turbulence-szel:
            marble(x,y) = (sin(x*c1+turbulence(x,y)*c2)+1)/2
            ahol c1 meg c2 alkalmasan megv lasztott konstansok..
            p‚ldaprogram szint‚n a .\noise\source k”nyvt rban;
            a noise-ra, turbulence-re ‚s erre a m rv nyra p‚ldak‚pek is 
            vannak a .\noise k”nyvt rban..
            (marble1.gif a modul latlan,  marble2.gif a v‚glegesebb)
          - hasonl˘an lehet f t is gener lni; ugye a fa l‚nyeg‚ben
            koncentrikus k”r”kb“l  ll, csak nem teljesen szab lyos..
            a wood1(x,y) = (sin(ű(x^2+y^2)*c1)+1)/2 
            az alapfggv‚nynk, ami m‚g teljesen szab lyos; ezt egyszer–en
            modul lhatjuk megint egy turbulence-szel:
            wood2(x,y) = (sin(ű(x^2+y^2)*c1+turbulence(x,y)*c2)+1)/2
            ‚s r”gt”n sokkal szebb :)
            persze a f nak is meg a m rv nynak is kell m‚g palett t adni
            a v‚g‚n, de ezt m r r tok bĄzom.. :)
            (.\noise\wood.gif, .\noise\source\wood.pas)
          - szint‚n nagyon sz‚p, de m r kiss‚ elvontabb eredm‚nyt ad,
            ha a turbulence-et ”nmag val modul ljuk, pl .\noise\hrdcore*.gif
          - a tov bbi lehet“s‚gek sz ma v‚gtelen :)
            (m‚g n‚h ny turbulence-szel k‚szlt k‚p tal lhat˘ a .\turb 
            k”nyvt rban)
    - ismert demoeffektek haszn lata textŁragener l shoz..
       - bump (falbump:)
          - mindenki kedvenc demoeffektje, de jol haszn lhat˘ 
            textŁragener l shoz...
            b rmit lebumpolhatunk, ami a keznk gy‚be kerl; pl az eddig
            'tanult' :) m˘dszerekkel gener lt k‚peket is (pl .\bump\bump*.gif);
            de ak r gener lhatunk pl random vonalakat is (.\bump\ize.*) :)
            vagy b rmi m st..
            majd ezeket kombin lhatjuk m sik k‚ppel/k‚pekkel..
            (ez ut˘bbira p‚ld k: .\bump\_*.tga - ezek a .\other\a.gif ‚s
            a .\other\b.gif meg vmi bumpolt dolog kombin ci˘j val
            k‚szltek)
       - mindenf‚le k‚pmorphol˘s effektek 
          - fog az ember egy p r ilyen 'egyszer–bb' textŁr t, mindegyiknek
            ad egy palett t, mindre r ereszt egy-egy kl”nb”z“ egyszer–
            k‚pmorphol˘ effektet, ‚s v‚gl az eg‚szet ”sszekombin lja 
            egy truecolor k‚pp‚..
            (ilyen m‚g a 'jizz' nev– k”zismert introban is van.. :)
            juteszembe az abban lev“ textŁr kat az ember a /pandora param‚ter
            megad s val kimentheti f jlba, ‚s azokon is tanulm nyozhatja az
            itt leĄrtakhoz hasonl˘ algoritmusok haszn lat t)
       - legegyszer–bb random+soften algoritmus
          - ez az amit mindenki ismer: minden pixelre egy random szĄnt 
            gener lunk, azt n p rszor elmossuk az eg‚szet :)
            de ezzel is biztos lehet sz‚pet csin lni :)
            (.\other\rnd?soft.gif)
       - lehet egyszer–en 3 kl”nb”z“ k‚pet az red, green illetve blue
         komponenseknek tekinteni, ‚s van egy textŁr nk..
         persze ez nem mindig ad sz‚p eredm‚nyt, de legal bb szĄnes lesz.. :)
         (.\other\hardcore.gif)

 - nos, ez az eg‚sz csak egy kis, felszĄnes ĄzelĄt“ akart lenni
   (10perces el“ad s rulezik :) - nem gy“z“m hangsŁlyozni: a lehet“s‚gek
   v‚gtelenek..

blala/byteam
blala@eo.battanet.hu
http://eo.battanet.hu/byteam/
ftp://eo.battanet.hu/pub/byteam/

ize, idekopiztam a mellekelt forrasokat, hogy oruljel

---------------------------------> cut here <---------------------------------

program noise_demonstration;
var i,j,k,l,m,n,o,p:integer;
    randomtable:array[0..15,0..15] of real;

procedure initnoise;
var i,j:integer;
begin
 randomize;
 for i:=0 to 15 do for j:=0 to 15 do randomtable[i,j]:=random;
end;

function noise(x,y:real):real;
var p,q,r,s,t,u,v:real;
begin
 p:=randomtable[(trunc(x*16)+0) mod 16,(trunc(y*16)+0) mod 16];
 q:=randomtable[(trunc(x*16)+1) mod 16,(trunc(y*16)+0) mod 16];
 r:=randomtable[(trunc(x*16)+0) mod 16,(trunc(y*16)+1) mod 16];
 s:=randomtable[(trunc(x*16)+1) mod 16,(trunc(y*16)+1) mod 16];
 t:=(q-p)*frac(x*16)+p;
 u:=(s-r)*frac(x*16)+r;
 v:=(u-t)*frac(y*16)+t;
 noise:=v;
end;

begin
 initnoise;
 inline($b8/$13/$00/$cd/$10);
 port[$3c8]:=0;
 for i:=0 to 255 do begin
  port[$3c9]:=(i div 4);
  port[$3c9]:=(i div 4);
  port[$3c9]:=(i div 4);
 end;
 for i:=0 to 199 do begin
  for j:=0 to 319 do begin
   mem[$a000:j+i*320]:=round(noise(j/320,i/200)*255);
  end;
 end;
 inline($b8/$00/$00/$cd/$16);
 inline($b8/$03/$00/$cd/$10);
end.

---------------------------------> cut here <---------------------------------

program turbulence_demonstration;
var i,j,k,l,m,n,o,p:integer;
    randomtable:array[0..15,0..15] of real;

procedure initnoise;
var i,j:integer;
begin
 randomize;
 for i:=0 to 15 do for j:=0 to 15 do randomtable[i,j]:=random;
end;

function noise(x,y:real):real;
var p,q,r,s,t,u,v:real;
begin
 p:=randomtable[(trunc(x*16)+0) mod 16,(trunc(y*16)+0) mod 16];
 q:=randomtable[(trunc(x*16)+1) mod 16,(trunc(y*16)+0) mod 16];
 r:=randomtable[(trunc(x*16)+0) mod 16,(trunc(y*16)+1) mod 16];
 s:=randomtable[(trunc(x*16)+1) mod 16,(trunc(y*16)+1) mod 16];
 t:=(q-p)*frac(x*16)+p;
 u:=(s-r)*frac(x*16)+r;
 v:=(u-t)*frac(y*16)+t;
 noise:=v;
end;

function turbulence(x,y:real):real;
var p,q:real;
    i,j:integer;
begin
 p:=0; q:=1;
 for i:=1 to 9 do begin
  p:=p+noise(x*q,y*q)/(2*q);
  q:=q*2
 end;
 turbulence:=p;
end;

begin
 initnoise;
 inline($b8/$13/$00/$cd/$10);
 port[$3c8]:=0;
 for i:=0 to 255 do begin
  port[$3c9]:=(i div 4);
  port[$3c9]:=(i div 4);
  port[$3c9]:=(i div 4);
 end;
 for i:=0 to 199 do begin
  for j:=0 to 319 do begin
   mem[$a000:j+i*320]:=round(turbulence(j/320,i/200)*255);
  end;
 end;
 inline($b8/$00/$00/$cd/$16);
 inline($b8/$03/$00/$cd/$10);
end.

---------------------------------> cut here <---------------------------------

program marble_demonstration;
var i,j,k,l,m,n,o,p:integer;
    randomtable:array[0..15,0..15] of real;

procedure initnoise;
var i,j:integer;
begin
 randomize;
 for i:=0 to 15 do for j:=0 to 15 do randomtable[i,j]:=random;
end;

function noise(x,y:real):real;
var p,q,r,s,t,u,v:real;
begin
 p:=randomtable[(trunc(x*16)+0) mod 16,(trunc(y*16)+0) mod 16];
 q:=randomtable[(trunc(x*16)+1) mod 16,(trunc(y*16)+0) mod 16];
 r:=randomtable[(trunc(x*16)+0) mod 16,(trunc(y*16)+1) mod 16];
 s:=randomtable[(trunc(x*16)+1) mod 16,(trunc(y*16)+1) mod 16];
 t:=(q-p)*frac(x*16)+p;
 u:=(s-r)*frac(x*16)+r;
 v:=(u-t)*frac(y*16)+t;
 noise:=v;
end;

function turbulence(x,y:real):real;
var p,q:real;
    i,j:integer;
begin
 p:=0; q:=1;
 for i:=1 to 9 do begin
  p:=p+noise(x*q,y*q)/(2*q);
  q:=q*2
 end;
 turbulence:=p;
end;

function marble(x,y:real):real;
var p,q,r:real;
begin
 r:=turbulence(x/4,y/4)*17;
 p:=(1+sin(x*39+r))*0.35;
 q:=(1+sin(x*67+2+r))*0.15;
 marble:=(p+q)*(p+q);
end;

begin
 initnoise;
 inline($b8/$13/$00/$cd/$10);
 port[$3c8]:=0;
 for i:=0 to 255 do begin
  port[$3c9]:=(i div 4);
  port[$3c9]:=(i div 4);
  port[$3c9]:=(i div 4);
 end;
 for i:=0 to 199 do begin
  for j:=0 to 319 do begin
   mem[$a000:j+i*320]:=round(marble(j/320,i/200)*255);
  end;
 end;
 inline($b8/$00/$00/$cd/$16);
 inline($b8/$03/$00/$cd/$10);
end.

---------------------------------> cut here <---------------------------------

program wood_demonstration;
var i,j,k,l,m,n,o,p:integer;
    randomtable:array[0..15,0..15] of real;

procedure initnoise;
var i,j:integer;
begin
 randomize;
 for i:=0 to 15 do for j:=0 to 15 do randomtable[i,j]:=random;
end;

function noise(x,y:real):real;
var p,q,r,s,t,u,v:real;
begin
 p:=randomtable[(trunc(x*16)+0) mod 16,(trunc(y*16)+0) mod 16];
 q:=randomtable[(trunc(x*16)+1) mod 16,(trunc(y*16)+0) mod 16];
 r:=randomtable[(trunc(x*16)+0) mod 16,(trunc(y*16)+1) mod 16];
 s:=randomtable[(trunc(x*16)+1) mod 16,(trunc(y*16)+1) mod 16];
 t:=(q-p)*frac(x*16)+p;
 u:=(s-r)*frac(x*16)+r;
 v:=(u-t)*frac(y*16)+t;
 noise:=v;
end;

function turbulence(x,y:real):real;
var p,q:real;
    i,j:integer;
begin
 p:=0; q:=1;
 for i:=1 to 9 do begin
  p:=p+noise(x*q,y*q)/(2*q);
  q:=q*2
 end;
 turbulence:=p;
end;

function wood(x,y:real):real;
var p,q,r:real;
begin
 r:=turbulence(x*0.7,y*0.7)*7;
 p:=(1+cos(sqrt(sqr(x-0.5)+sqr(y-0.5))*43+r))/2;
 wood:=p;
end;

begin
 initnoise;
 inline($b8/$13/$00/$cd/$10);
 port[$3c8]:=0;
 for i:=0 to 255 do begin
  port[$3c9]:=(i div 4);
  port[$3c9]:=(i div 4);
  port[$3c9]:=(i div 4);
 end;
 for i:=0 to 199 do begin
  for j:=0 to 319 do begin
   mem[$a000:j+i*320]:=round(wood(j/320,i/200)*255);
  end;
 end;
 inline($b8/$00/$00/$cd/$16);
 inline($b8/$03/$00/$cd/$10);
end.

---------------------------------> cut here <---------------------------------