Bu  yazda  basit  gei  (transition)   efektlerinden  biri  olan  "fade"   den
bahsedeceim. Efekt birden  fazla yntemle yaplabilir.  Detaya girmeden  yazda
anlatlacak yntemlere bir bakalm :

1) Frame Buffer ile Blending. (Opengl ve fixed pipe ile)
2) Render to Texture (Opengl ve fixed pipe ile)
3) Pixel Shader (Direct3D ve programlanabilir pipe ile)

Grld gibi  herkes  iin  bieyler var  (  sensei  iin bile  hehe  :)  )  .
Tutorial populer  grafik  api   lar  ile  tecrbesi olan  (ileri  seviye  bilgi
gerekmiyor)  coder   lar  dnlerek   hazrland.  Yeri   gelmiken   sylemek
istediim birey var. Yazda ok miktarda ingilizce kelime (ou  teknik  terim)
olabilir. Grafik programlama terminolojisini bilenler iin sorun  olmaz  sanrm
ama trkeletirme iin ekstra efor sarfetmicem. Yani gidipte texture  map  iin
doku elemi falan  demicem ama gereken  yerlerde de terimler/kavramlar  hakknda
gerekli aklamalar yapacam.

Birisi Fade in mi dedi ?? 

Ne  anlattmz  detaylca  aklamann  vakti  geldi.  Farz  edelim  bi  demo
yapyorsunuz.  Sahneler  (yada  part  lar  m  diyelim..)  aras  geilerin  de
yumuak olmasn  istiyorsunuz..  Yani  ani ,  ktk  gibi  geiler  olmayacak.
Mesela ekrann  yavaca  kararmas yada  kararm  bir ekrandan  sahnenin  yava
yava  grnr  hale  gelmesi   gibi  eylerden  bahsediyorum.  Sanrm   yapmak
istediimiz ey anlalyor. imdi gerekli tanmlar yapalm : 

Fade in  :  Gsterilmek  istenen  sahnenin yava  yava  grnr  hale  gelmesi.
Genellikle siyah ekrandan balanr  ve sahne zamanla  grnr hale gelir. Siyah
renk zorunluluk deil tabii ki. stediiniz renkten balayabilirsiniz.

Fade out  : Sahnenin  yava  yava gzden  kaybolmas durumu.  Genellikle siyah
renge  doru  gidip  ekran  karartrz.  Siyah  dndaki  renklere  de  gitmek
mmkn.

Tamam imdi bu iki efekti nasl yapabiliriz ona bakalm. 

1) Frame Buffer ile Blending Yntemi

Bu  yntem  iin   yaplmas  gerekenleri   ksaca  bir   sralayalm  ,   sonra
detaylarna girecez.

- Sahnenizi normalce izdirin.
- Depth Test i kapatn.                                                        
                
- Orthografik projeksiyona gein.                                              
        
- Alpha Blending i aktif hale getirin.                                         
         
-   Screen   Alingned   Quad    (Tm   ekran   kaplayan   drtgen)    izdirin.
- Alpha Blending i kapatn.                                                    
            
- Tm izdirim ilemlerini bitirin.                                            
            

Bu yntem  full -  screen alpha  blending kullanyor.  nce sahneniz  neyse  onu
izdiriyorsunuz , ondan  sonra orthografik  projeksiyon moduna  geip tam  ekran
bir drtgen izdiriyorsunuz.  Drtgeni izdirirken ,  drtgeni oluturan  vertex
lerdeki alpha deerlerini  zamanla 0 dan  1 e yada  1 den 0  a doru  ekiyoruz.

Frame Buffer ile Blending ve Doru Blending Faktrlerini Semek

Yntemin ismine frame  buffer ile  blending dedim.  Peki nedir  fame buffer  ile
blending? OpenGL  yada Direct3D  ile alrken  texture stage  ler arasnda  da
(multi-texturing yaptnz  dnn)  blending  yapabilirsiniz.  Texture  lari
oluturan texeller blending hesaplamalarina girerler ve oluan  texel  deerleri
dier pipeline seviyelerine  (esasnda eer  varsa  per  fragment  operations a,
yoksa frame buffer  a)  yollanr  . Frame  buffer ile blending  de ise  blending
hesaplamalar frame buffer da  yazl olan  pixel   deerleri (destination, dst)
ile  pipeline  dan  gelen  (rasterizasyon  ve  texture  mapping  sonucu   oluan
pixeller) yeni pixel  deerleri (source  , src) arasnda  olur. Bu  hesaplamalar
OpenGL pipeline nn  en sonunda  "per fragment operations"  denen ksmda  olur
ve alpha blending olarak bilinir. Alpha blending ilemi frame  buffer  okumalar
(destination pixellerin  de hesaba  katldn unutmayn)  da ierdiinden  ok
sk yaplmas nerilmez. Bizim yntemimizde viewport taki tm  pixellerle  alpha
blending yapacaz.  Performans  bakmndan  gnmz  kartlar  iin  pek  fazla
sorun yok esasnda.
Source  ve  destination  pixeller  anlaldysa  blending  faktrlerinin   nasl
seildiine bakalm:

OpenGL de Alpha  Blending yaparken nce  Blending state ini glEnable(GL_BLEND);
ile aktif hale getiririz.
Sonra glBlendFunc(srcfactor,dstfactor); ile  de source  ve destination  pixeller
iin blending faktrlerini ayarlarz.

Not : glBlendFunc a  argman olarak srcfactor ve  dstfactor yazdm. Bunu  sadece
ilk argmann  source pixeller  iin ,  dierinin de  destination pixeller  iin
olduunu belirtmek iin  yaptm. Bu  argmanlar GL_ONE,GL_SRC_COLOR   vs..  gibi
OpenGL de  tanml  sabitler  olacak.  Bu sabitlerin  tam  listesi  iin  OpenGL
referanslarna bakn.

in  matematiine   gemeden  nce   belirtmem   gereken  biey   var.   Burada
bahsedeceim blending yntemi additive blending diye bilinen  yntemdir.  OpenGL
spesifikasyonu sadece  bir blending  yntemi tanmlar.  O da  additive  blending
dir.  Additive   blending   dndaki   yntemler  :   subtractive   (   reverse
subtractive) ve  min-max blending  yntemleridir. Direct3D  de de  bu  yntemler
tanmldr.  Mesela  aadaki  kod  paras  kullanlacak  blend   operasyonunu
subtractive olarak seer.

device->SetRenderState(D3DRS_BLENDOP,D3DBLENDOP_SUBTRACT);

Direct3D iin  SDK  da D3DBLENDOP  Enumerated  Type isimli  ksma  bakarak  daha
fazla bilgi  edinebilirsiniz.  OpenGL  e  geri dnersek  ,  OpenGL  de  additive
blending   dndaki   yntemler    extension   mekanizmasyla    programclarn
kullanmna sunulmutur.
Genel blending yntemlerini yle zetleyelim :

Kullanacam notasyon yle olacak :

Cf --> Blending operasyonlar sonucu oluan renk (final color value)
Cs --> Source pixel in rengi
Cd --> destination pixel in rengi
S --> Source pixelin blend faktr
D --> Destination pixelin blend faktr

 Additive Blending :

Cf  = Cs * S + Cd * D    olur ve 

if ( Cf > 1.0 )
        Cf = 1.0
else if(Cf <= 1.0)
        Cf = Cf 

Yukardaki if - else blouyla ilemin saturated olduunu  anlatmak  istedim. Yani
oluan renk deerleri 1.0 n zerine kamaz.

 Subtractive Blending :

Cf = Cs * S - Cd * D olur ve 

if ( Cf < 0.0 )
         Cf = 0.0
else if (Cf >= 0.0)
         Cf = Cf 

OpenGL iin GL_EXT_blend_subtract extension na bakn.

 Reverse Subtractive Blending :

Cf = Cd * D - Cs * S olur ve 

if ( Cf < 0.0 )
         Cf = 0.0
else if (Cf >= 0.0)
         Cf = Cf 

ve yine GL_EXT_blend_subtract extension na bakn.

MinMax Blending :

minimum iin : 

Cf = min ( Cs , Cd )  olur.

Sonu  source ve destination  piksellerin  minimumudur.. Tabii bu  ilemin  renk
bileenleri (RGBA) baznda yapldn unutmayn. 

maksimum iin : 

Cf = max ( Cs , Cd) olur.

GL_EXT_blend_minmax  extension na bakn.

 

Bu hatrlatmadan  sonra esas  konumuza geri  dnelim. Additive  Blending  ilemi
matematiksel olarak  arlkl  toplamadan  (weighted sum)  baka  biey  deil.
Matematii ise yle:

Rs,Gs,Bs ,As --> Tek bir source pixel i belirtren 4 l olsun.
Rd,Gd,Bd,Ad --> Tek bir destination pixel i belirten 4 l olsun.

Sr,Sg,Sb,Sa ---> Tek bir source pixel in blend faktrlerini belirtsin
(arlk parametreleri)
Dr,Dg,Db,Da ---> Tek bir destination pixel in blend faktrlerini belirtsin
(arlk parametreleri) 

Blending sonucu oluan renk:
color = (Rs * Sr + Rd  * Dr) , (Gs * Sg + Gd * Dg) ,  (Bs * Sb + Bd * Db) ,  (As
* Sa + Ad * Da)

final RGBA deeri yukarda grlyor. imdi bu bilgi iimize nasl yarayacak?

Not : 
Alpha deerinin 1 olmas opaklk durumudur.
Alpha deerinin 0 olmas transparanlk durumudur.

Fade in  durumunu  ele alalm.  Sahnemiz  siyah ekrandan  grnr  hale  gelsin.
imdi byle bir senaryoda  ekrana izdireceimiz quad  n renginin siyah  olmas
, alpha deerinin de 1  den 0 a gitmesi  gerekir (nedeni aada detayl  olarak
anlatlacak..). nk byle bir durumda :

 Sahne --------> Destination
 Quad  --------> Source olur   ve 

blending faktrleri  de GL_SRC_ALPHA  ile GL_ONE_MINUS_SRC_ALPHA  seilir.  Yani
Sr,Sg,Sb,Sa 1  den  0  a gider  (Quad  n  alpha  sn 1  den  0  a  gtryoduk
unutmayn..) , Dr,Dg,Db,Da 0 dan 1 e gider nk bunlara 1 - Quad  Alpha  deeri
atanr.

Snr koullar iin  (Quad alpha deerinin  1 ve 0  olduu durumlar)  yukardaki
blending eitliini yazarsak :
Quad Alphas = 1 (source pixellerin alphas = 1 ) iin , Sr = Sg = Sb  = Sa  = 1
dir ve Dr = Dg = Db = Da = 0 dr.

color = (Rs) , (Gs), (Bs) , (As) olur. Quad  grrz.

Quad Alphas = 0 iin Sr = Sg = Sb = Sa = 0 dr ve Dr = Dg = Db = Da = 1 dir.

color = (Rd) , (Gd) , (Bd) , (Ad) olur ve sahneyi grrz.

Benzer ekilde  Fade out  iinse  Quad n  alpha deerinin  zamanla  0 dan  1  e
gitmesi gerekir. 

 

2) Render To Texture Yntemi : 

      Bu  yntemin bir  kstlamas  var. Sadece  siyah  renk iin  fade  in/out
yapabiliyoruz (yani tm  ekrann siyaha gitmesi  yada siyahtan sahnenin  grnr
hale gelmesi gibi..).

    Yntemi anlatabilmek iin  OpenGL texturing fonksiyonlar  hakknda bir  ka
ey sylemem lazm. Texture mapping yaparken texture u  uygulayacanz  yzeyin
rengini tamamen ihmal  edebilirisiniz bylece yzeyin  rengi sadece texture  map
den gelir. Ayrca bir   yzeyin rengini texture  map den gelen renklerle  modle
( arpma  )  edebilirsiniz. Standart  OpenGL  size 4  tane  dokulama  fonksiyonu
sunar. Bunlar GL_DECAL , GL_REPLACE , GL_MODULATE  ve GL_BLEND. Bu  fonksiyonlar
glTexEnv{if}(......)  komutu  ile   aktif  hale  getirilirler.     Bu   yntemde
GL_MODULATE i kullanacaz.

Cf   ---> sonu renk deeri
Cs  ---> yzeyin rengi
Ct   ---> texture map de tutulan renk

Cf = Cs * Ct GL_MODULATE in yapaca ilem bu. Bu bilgiyi yle kullanacaz : 

- Tm sahne bir texture a izilecek. Yukardaki eitlikteki Ct deeri bu.
- Bir  nceki admda  sahnenin  izildii texture,  bir  screen  aligned  quad a
uygulanacak. Screen aligned quad Cs verisini tutuyor.
-  Mapping  yaplrken  glTexEnvf  (  GL_TEXTURE_ENV  ,  GL_TEXTURE_ENV_MODE   ,
GL_MODULATE); komutu kullanlacak ve yzeyin rengi :

Fade  in       iin  : 0  dan  1  e
Fade out  iin : 1  den  0 a   zamanla ekilecek.

Daha ak yazarsak yle bir ilem uygulanyor : 

(Rt,Gt,Bt) ---> Texture un rengi. (izdirdiiniz sahne)
(Rs,Gs,Bs) ---> Texture u uyguladnz full - screen Quad n rengi.

Color = (Rt * Rs) , (Gt * Gs) , (Bt * Bs)

Snr deerler iin yukardaki eitlii incelersek :
(Rs , Gs, Bs)  ---> (0.0,0.0,0.0) iin :
Color = (0.0) , (0.0) , (0.0)  (siyah ekran)

(Rs,Gs,Bs)  ---> (1.0,1.0,1.0) iin :
Color = (Rt) , (Gt) , (Bt)       (sahne)

olur.

Quad  n  rengini  mesela  fade  in  iin  u  ekilde:  glColor3f(t,t,t);    (t
deikeni zamanla 0 dan 1 e gtrlerek) ayarlanabilir. 

Peki render to texture admn nasl yapabiliriz ? 
Opengl bize 3 farkl seenek sunuyor.
1) glCopyTexImage  yntemi  :  Sahne  backbuffer a  izdirilir  ,  backbuffer  a
izdirilen sahne   glCopyTexImage    ile bir  texture a  kopyalanr.  Backbuffer
tekrar temizlenir (glClear  (GL_COLOR_BUFFER_BIT); ) .  Sonra yukarda  anlatlan
yntemler uygulanarak elde edilen texture screen aligned  quad a  uygulanr. (En
yava yntem budur.)

2)  PBuffer  (Pixel  Buffer)  yntemi  kullanlabilir.  Bu  yntemde  pencerenin
kullandnn dnda  farkl  bir  render context  yaratlr  ve  sahne  buraya
izdirlir.  Sonra  wglARBRenderTexture  extension     kullanlarak  bu   render
context  in  ierii  texture  olarak  kullanlabilir.  Pbuffer  lar   kurmann
karmakl yznden  ve  de  render  context  switching  hakkndaki  trickleri
bilmiyorsanz ( her frame de render context switcing  var :   pbuffer --> window
-->pbuffer...  GeForce  3 , Radeon  8500 alt kartlarda  srnrsnz)   PBuffer
ile render to  texture dan  uzak durun. Pbuffer  lar bal  bana bir  tutorial
konusu olabilir. Bu yzden burda kesiyorum.

3) EXT_framebuffer_object  extension  nn  kullanabilirsiniz.  Gerek  kullanm
kolayl ve hz asndan  en uygun yntem bu  bence. Fakat detaya  girmiyorum.
Bu da kendi iinde bir tutorial olabilir. 
  
 

3) Pixel Shader Yntemi : 

Huh , imdiden  baya uzun  bir  tutorial oldu. Bu  ksm  okuyacak  arkadalarn
direct3d   ile  tecrbesi olduunu  varsayyorum.  Yani en  azndan  burada  api
detaylarna girmicem. Mesela  texture nasl  yklenir yada  .fx dosyalar  nasl
hazrlanr gibi.. nk bunlar baka bir tutorial konusu olabilir. 
Shader lar ile  fazla har neir olmam scener  lar iin  bu  shader  konusuna
ok ksa bir giri yapalm.
Demolar (ve  bilgisayar  oyunlar)  gerek  zamanl  bilgisayar  grafikleri  ile
ilgili olduundan , bizim  shader diyince anlamamz gereken  ey u olmal :  3D
ihattn (pipeline)  modifiye  eden  programlar.  Bu  programlar  GPU  zerinde
(vertex ve pixel  processor ler)  alr. Gnmz  GPU teknolojisinde  pipeline
nn belli ksmlar  programlanabilir haldedir  ve pipeline nn  kabaca iki  ana
hattan olutuunu syleyebiliriz : Vertex hatt ve pixel hatt.

Yukarda yazlanlara gre baz tanmlar yapabiliriz:

Vertex Shader  : Pipeline  a giren  her vertex  zerinde alan  programlardr.
Vertex shader ile  GPU nun  vertex processor denen  donanm ksm  programlanr.
Vertex shader  lar  girdi  olarak  (dolaysyla  vertex  processor)herhangi  bir
geometrik  dnme  uramam  vertex  ler  (object  space  de  tanml)  ,  bu
vertexlerle ilikilendirilmi renk  , doku koordinat  , normal vektrleri  vs..
gibi verileri  alrlar. kt  olarak  ise clip  space de  vertex  koordinatlar
(rasterizer a  gitmeden  nce, vertex  shader  dan sonra  arada  baka  pipeline
seviyeri var  ,  mesela  backface  culling yada  homojen  divide  gibi..  bunlar
programlanamaz)  ve  rasterizer    besliyecek   her   trl   veriyi  (modifiye
ettikleri doku  koordinatlar  , normaller  vs..)  verirler. Vertex   shader lar
yeni vertex ler retemezler , var olan vertexleri modifiye ederler.

Pixel  Shader  :  Rasterizasyon  sonucu   oluan  her  pixel  zerinde   alan
programlardr. Pixel  shader  ile  pixel processor  programlanr.  Input  olarak
rasterizer dan gelen verileri alrlar ve kt olarak da color ve  depth  buffer
a hesapladklar piksel  deerlerini yazabilirler. Piksel  shader dan sonra  son
pipeline seviyesi  olan per  fragment operations  (yeni gelen  piksel  deerleri
ile frame buffer da  yazl olan piksel deerleri  ile ilgili her trl  ilemin
yapld ksm.. depth test , alpha test , alpha blending fog vs..) gelir.

Esas konumuza  geri dnersek.  Fade In/out  ilemi bir  post processing  ilemi.
Yine sahnemizi bir texture a  izdirecez ve bu texture  u alp bir quad  zerine
map  edeceiz.  Pixel  shader  piksel  deerlerine  dorudan  eriemedii   iin
texture lookup yapacaz.  Bu yzden  her frame texture  a izdiriliyor(Render  to
Texture). Tutorial  yeterince uzadndan  nasl  screen alingned  quad  izilir
yada render  to  texture nasl  yaplr  o  konulara girmicem  ,  sadece  shader
lardan bahdisecem. 

Fade In/Out iin pixel  shader da lineer  interpolasyon yapacaz. lk  anlattm
ynteme (Frame Buffer  ile blending) dikkatle   bakarsanz lineer  interpolasyon
formunda olduunu grrsnz. Bildiimiz iki deer arasndaki  deerleri  bulmak
iin interpolasyon kullanrz. imdi lineer interpolasyonu bi anlayalm.
Mesela x ekseninde, x1 koordinatndan x2 koordinatna gidecez :

LERP = x1 + (x2 - x1) * t 


dediimiz  zaman  x1  ve   x2  nin  arasndaki  her   deeri  t  yi   kullanarak
bulabiliriz. t nin izin verilen deer aral [0,1] dir.  t = 0 iin x1 , t =  1
iin x2 deyiz. Interpolasyon bilgisayar grafiklerinde, zellikle animasyonda ok
kullanlan matematiksel bir aratr. Lineer in dnda eitli  spline  erileri
kullanan interpolatrler de vardr.

Bizde  pixel   shader  da   texture  ile   fade  rengi   arasnda  lerp   ilemi
uygulayacaz.

Not : Lineer interpolasyon lerp olarak da bilinir.

Daha nceden yazdm .fx dosyasna bakalm ve en azndan shaderlara  bir  para
kendimizi altralm. 

ilk olarak  uniform deikenler  karmza kacak.  Uniform deikenler  shader
n etkiledii  her pixel  yada  vertex iin  ayn kalan  deikenlerdir.  Mesela
burada mWorldViewProjection,  transformasyon  matrisidir.  (object  space  ---->
clip space e) Shader n etkiledii geometrideki her vertex iin  ayndr. t  ise
lineer interpolasyonda  kullanlan  parametredir  ve  her  pixel  iin  ayndr.
width ve  height vertex  shader da  doku koordinatlar  iin   offset  deerleri
hesaplanmasnda kullanlr. nk direct3d sampling kurallarna  gre  ekrandaki
pikseller ile  texturdaki  texellerin  1:1  elemesi  iin  doku  koordinatlar
(u,v) yerine : u+ = offset_u , ve v+ = offset_v olmaldr.

offset_u = (1.0/2.0 ) * (1.0/width) // width : screen width
offset_v = (1.0/2.0) * (1.0/height) // height : screen height

Esasnda  HLSL   de  uniform   keyword   u  uniform   deikenleri   belirtmekte
kullanlr. Fakat  global  deikenlerde (shader  kodlar  gvdelerinde  olmayan
deikenler) buna gerek  yok , global deikenler uniformdur..  Genelde  uniform
deikenler uygulamadan shader a  gnderilen deikenlerdir .   Her vertex  yada
her pixel iin ayrca hesaplanmazlar. 

float4x4 mWorldViewProj;
float t;
float width,height;

.fx dosyalarnn bir gzellii  de texture address  ve filtreleme modlarnn  bu
dosyalar iersinde tanmlanabilmesidir. t0 pixel shader n  kullanaca  texture
u belirtir. s0  ise pixel  shader n  bizim texture  umuza eriirken    (look up
iin) kulland sampler dr. 

texture t0;
sampler2D s0 = sampler_state
{
  Texture = (t0);
  AddressU = CLAMP;
  AddressV = CLAMP;
  MagFilter = LINEAR;
  MinFilter = LINEAR;
  MipFilter = NONE;
};

Bu ksmda  ise  piksel  ve  vertex  shader  larn  kulland  veri  yaplarn
gryoruz. C structlarndan  pek bir fark  yok. Gze arpan  tek fark  deiken
isimleri yanndaki kolonlar ve baz keywordler. Bu keywordlere  semantics  denir
ve  grevleri  ise  pipeline  dan  gelen  verilerle  ilgili  GPU  registerlarn
birbirlerine  elemektir.  VS_IN  struct  na  bakarsak  pos  deikeni  homojen
koordinatlarda (x,y,z,w) bir noktay  temsil eder ve  vertex processor un  input
registerlarna (position  register ,  v0) alnaca  POSITION0 semantic  i  ile
belirtilir.  VS_OUT  a   da  baktnzda    pos  deikeni,  vertex  shader  da
transform edilmi  bir  noktay  temsil  eder  ve  vertex  processor  un  output
register  na  (output   position  register,oPos)   alnaca  yine   POSITION0
semantici i  ile belirtilir.   HLSL  de input   ve  output registerlarnn  ayn
semanticlerle belirtildiini grebilirsiniz.

struct VS_IN
{
  float4 pos : POSITION0;
     float2 uv0 : TEXCOORD0;
};

struct VS_OUT
{
   float4 pos : POSITION0;
   float2 uv0 : TEXCOORD0;
};

Aada VS isimli vertex  shader mza bakalm.  mul intrinsic (shader  compiler
na gml  fonksiyonlardr)   fonksiyondur.  Matris  arpmlarnda  kullanlr.
Shader  larda   ilemler   vektrel   yapldndan   (x,y,z,w   yada   r,g,b,a)
komponentleri aka  yazmanza  gerek  yok.  In.pos  vertex  buffer  dan  gelen
koordinat bilgilerini tar  ve her  bir vertex  in koordinatlar  WorldViewProj
matrisi ile arplr ,  clip space deki konumlar  bulunur. Bu vertex shader  da
gelen  doku  koordinatlar  zerinde   de  modifikasyon  yapyoruz.  Daha   nce
bahsettiim nedenden dolay offset deerlerini ekliyoruz.

VS_OUT VS(VS_IN In)
{
  VS_OUT Out; 
  Out.pos = mul(In.pos,mWorldViewProj);



//offset
  Out.uv0.x = In.uv0.x + 0.5 * (1.0/width);
  Out.uv0.y = In.uv0.y + 0.5 * (1.0/height);

  return Out;
}

imdi  esas   aksiyonun  olduu   ksma  geldik.   PS  fade   in/out  efektini
gerekletiren piksel shader mz.
Bu shader da yaplan i u :

Color = Texture + (FadeColor - Texture) * t

t uygulamadan ayarlanyor(  Herhalde bir timer  class nz falan  vardr ha?  Ne
biliyim ite t 5 saniye iersinde  1 den 0 a yada belki  0 dan 1 e gitsin  tarz
eyler programlamanz gerekecek de) . t uniform deiken.  0 dan 1 e  gtrrsek
fade  out   ,   1   den   0   a   gtrrsek   fade   in   efekti   gerekleir.
Shader da tex2D  intrinsic fonksiyonu ile  texture a eriip  look up  yapyoruz.
Grld gibi argman  olarak bir  sampler ve  texture koordinatlarn  alyor.
Bu eritiimiz  texture  un gstermek  istediimiz  sahnemiz olduunu  bir  kere
daha hatrlatyim. Fade color iin ben bu shader da beyaz  rengini  (istediiniz
rengi semekte serbestsiniz)  setim ve  float4(1.0,1.0,1.0,1.0) ile  ayarladm.
Bu  vektrel  bir  veri  tipi  ve  RGBA  rengi  temsil  ediyor.  C++  tipi   bir
constructor ile  initialize  ettim.   Yukardaki  interpolasyon  eitliini  lerp
intrinsic fonksiyonu  hesaplyor.  Son  olarak piksel  shader  hesaplad  renk
verisini ilgili register a (COLOR0) yolluyor.

float4 PS(VS_OUT In):COLOR0
{
     float4   color  =   lerp(tex2D(s0,In.uv0),   float4(1.0,1.0,1.0,1.0),   t);
   return color;
} 

Aadaki  ksm   ise   hazrladmz  efektle   ilgili   bilgiler   ieriyor.
Uygulamadan bu efekte FadeinOut ismi ile eriebiliriz. Tekniin  ismi  FadeinOut
ve tek pass den  oluuyor. Ayrca baz render  state leride bu teknik  iersinde
ayarladm.  (Tm  direct3d   state  lerine  .fx   dosyalar  iersinden   eriip
ayarlayabiliriz.). Son  satrlar  ise  yazdmz  shaderlarn  shader  compiler
tarafndan hangi  shader  profiline  gre derleneceini  belirtiyor.  Burada  VS
vertex shader 1.1 e gre , PS de piksel shader 1.1 e gre derleniyorlar.

technique FadeinOut
{
  pass p0
 {
   Lighting = FALSE;  
   CullMode = NONE;
   VertexShader = compile vs_1_1 VS();
   PixelShader = compile ps_1_1 PS();
 }
}

 

Huh , bu tutorial burada biter , scg de yataa gider.

 

Not : tutorial ile ilgili  her trl  sorun iin  (eksik , yanl , anlalmayan
yerler vs..) beni rahatsz etmeyin, forumlar kullann puhaaaaaa ...

[b] Sinan "scg" anga [/b] 