Tags:    delphi
Phong Shading

Phong er nok den mest kendte reflektions model. Phong shadingen bruger Lambert modellen til at beregne diffuse farven. Phong vil derfor få overfladerne i scene til at se blanke ud. Tilføj følgende Phong funktion til renderings klassen og brug den i stedet for Lambert funktionen. Her er den matematiske formel for Phong reflektions model:



Her er koden:

//Denne funktion vil beregne Phong reflektions model
function TRENDER.Phong( RayNear, RayFar, Ray : TVECTOR; V1, V2, V3 : TVERTEX; Geometry : TGeometry; Light : TLIGHT ) : TLIGHTCOLOR;
var
  N, V, L, R : TVECTOR;
  Diffuse, Specular : Double;
begin
  //Diffuse: Lambert

  //Interpolerer vertex normalerne for vores trekant
  N := Geometry.InterpolateNormals( Ray, V1, V2, V3 );
  N.Normalize;

  //Find vores fragment
  V := TVECTOR.Create;
  V.FollowLine( RayNear, RayFar, Ray.Z );

  //Find vores lys vektor og normalisér den
  L := Light.Position.Sub( V );
  L.Normalize;

  //Find intensiteten ved at tage prik produktet af vores lys vektor og normal
  Diffuse := L.Dot( N );

  //Specular: Phong reflektions model

  //Lav en reflektions
  R := TVECTOR.Create;
  R.X := 2.0 * N.X * Diffuse - L.X;
  R.Y := 2.0 * N.Y * Diffuse - L.Y;
  R.Z := 2.0 * N.Z * Diffuse - L.Z;

  V.X := -V.X;
  V.Y := -V.Y;
  V.Z := -V.Z;
  V.Normalize;

  Specular := R.Dot( V );

  if ( Specular > 1 )  then
  Specular := 1
  else
    if ( Specular < 0 ) then
    Specular := 0;

  // 32 = Alpha * Shininess
  Specular := Power( Specular, 32 );

  //Gem Diffuse of Specular farverne
  Result := TLIGHTCOLOR.Create;
  Result.Diffuse.SetValues( Diffuse * Light.Color.Diffuse.R, Diffuse * Light.Color.Diffuse.G, Diffuse * Light.Color.Diffuse.B );
  Result.Specular.SetValues( Specular * Light.Color.Specular.R, Specular * Light.Color.Specular.G, Specular * Light.Color.Specular.B );

  //Husk at afklippe vores farve værdier mellem 0 og 1
  Result.Diffuse.Clamp( 0, 1 );
  Result.Specular.Clamp( 0, 1 );

  //Frigør middlertidige klasser fra hukommelsen!
  N.Free;
  V.Free;
  L.Free;
  R.Free;
end;

Renderingen vil nu se således ud



Du har sikkert bemærket at teksturen er meget pixeleret. Det skyldes vores meget simple måde at aflæse vores pixels i teksturen. Der er findes forskellige måder at lave en mere detaljeret aflæsning af teksturen. Bilineær aflæsning er nok den mest kendte af dem alle. Den er utrolig let at implementere, så jeg har faktisk allerede gjort det i vores GetPixel funktion i TGA klassen. I stedet for kun at aflæse én bestemt pixel i teksturen vil bilineær algoritmen også aflæse alle omkring liggende pixels og finde gennemsnits farven af dem. Du kan lave en bilineær aflæsning ved at sætte parameteren: BilinearFilter, til True når du kalder TGA klassens GetPixel funktion fra renderings klassens: ShadePixel, funktion. Renderingen vil se således ud med bilineær tekstur aflæsning:



Der er utrolig meget at fortælle endnu omkring Raytracing. Vi har slet ikke diskuteret algoritmer for optimering af Raytracing. Renderingstiden er forholdsvis acceptabel for små simple scener som denne artikel har behandlet. Hvis du ønsker at rendere mere komplekse scener vil du opleve en utrolig lang vente tid. Raytracing kan blive optimeret meget uden forringelse af billedekvaliteten. Der er en god stykke vej endnu til at få en professionel software rendering ud af det kode denne artikel har introduceret. Der er en masse visuelle effekter der vil være interessant og sjov at implementere. Det mest utrolige ved software rendering, er, at du slet ikke bruger grafikkortet. Det hele bliver udregnet at computerens CPU. Det betyder at du har 100% frihed til dine renderinger. Forhåbenligt har denne artikel givet dig et lille indblik i Raytracing og givet dig lyst til at gå videre med din helt egen software rendering. Måske en dag vil dit renderingsprogram være det software alle de profesionelle animatorer vælger at bruge i fremtiden.

Denne artikel har fungeret som en slags appetitvækker. Vi har med hast været inde på nogle store og meget komplekse områder. Det er helt klart anbefalsværdigt at du på egen hånd går disse emner helt i bund. Her er en liste over interessante emner der kan udvide din rendering og gøre dit software mere attraktiv:

Rendering af flere typer lyskilder: Spotlight, Directional Light!
Rendering af flere lyskilder.
Rendering af skygger.
Rendering af reflektioner og refraktioner.
Tilføjelse af Anti-aliasing.
Flere reflektions modeller: Blinn, Metal, Plastic, Velvet osv.
Rendering af bumpmaps eller normalmaps.
Rotering af geometri: Matrix bereging.
Og til sidst men ikke mindst: Optimering af renderingen.

Listen kunne sagtens udvides men de nævnte emner vil nok være mest naturligt at gå i gang med efter denne artikel.

Hvad synes du om denne artikel? Giv din mening til kende ved at stemme via pilene til venstre og/eller lægge en kommentar herunder.

Del også gerne artiklen med dine Facebook venner:  

Karma barometer (30 dage)

IT jobs | Kontakt | Om Udvikleren.dk | Om karma | IT nyheds arkiv | Annoncering

X