Cg: Unterschied zwischen den Versionen

Aus DGL Wiki
Wechseln zu: Navigation, Suche
K (Die Seite wurde neu angelegt: == Allgemein == C for Graphics (Abkürzung: Cg) ist eine von NVIDIA begründete Shader-Hochsprache zum Schreiben von Vertex-Shader- und Fragment-Shader-Programmen. Eine...)
 
K (Der Ausdruck ''<pascal>(.*?)</pascal>'' wurde ersetzt mit ''<source lang="pascal">$1</source>''.)
 
(Eine dazwischenliegende Version von einem anderen Benutzer wird nicht angezeigt)
Zeile 7: Zeile 7:
  
 
Zunächst muss ein entsprechender Shadersystem Kontext erstellt werden:
 
Zunächst muss ein entsprechender Shadersystem Kontext erstellt werden:
−
<pascal>
+
<source lang="pascal">
 
var
 
var
 
   FContext: PCGContext;
 
   FContext: PCGContext;
  
 
   FContext := cgCreateContext;
 
   FContext := cgCreateContext;
−
</pascal>
+
</source>
  
 
=== Laden des Programmes ===
 
=== Laden des Programmes ===
  
 
Danach muss dass entsprechende Programm hereingeladen und kompiliert werden. Hierbei sollte noch das beste verfügbare Shaderprofil auslesen. Zudem ist zu entscheiden, ob man einen Vertex- oder eine Fragmentshader laden möchte:
 
Danach muss dass entsprechende Programm hereingeladen und kompiliert werden. Hierbei sollte noch das beste verfügbare Shaderprofil auslesen. Zudem ist zu entscheiden, ob man einen Vertex- oder eine Fragmentshader laden möchte:
−
<pascal>
+
<source lang="pascal">
 
var
 
var
 
   FProgram: PCGProgram;
 
   FProgram: PCGProgram;
Zeile 38: Zeile 38:
 
   cgGLSetOptimalOptions(FProfile);
 
   cgGLSetOptimalOptions(FProfile);
  
−
   //Programm laden und compilieren - ABuf bezeichnet einen PChar, der den Programmquelltext oder den Programmobjectcode enthält, AProgramName den Namen der Hauptfunktion des Shaderprogrammes
+
   //Programm laden und compilieren - ABuf bezeichnet einen PChar, der  
 +
  //den Programmquelltext oder den Programmobjectcode enthält,  
 +
  //AProgramName den Namen der Hauptfunktion des Shaderprogrammes
 
   FProgram := cgCreateProgram(FContext, srctype, ABuf,
 
   FProgram := cgCreateProgram(FContext, srctype, ABuf,
 
     FProfile, AProgramName, nil);   
 
     FProfile, AProgramName, nil);   
−
</pascal>
+
</source>
  
 
=== Fehlerabfrage ===
 
=== Fehlerabfrage ===
  
 
Nun sollte man abfragen ob es beim Compilieren Fehler gegeben hat. Mit der Folgenden Prozedur ist dies ein leichtes:
 
Nun sollte man abfragen ob es beim Compilieren Fehler gegeben hat. Mit der Folgenden Prozedur ist dies ein leichtes:
−
<pascal>
+
<source lang="pascal">
 
procedure GetCGError;
 
procedure GetCGError;
 
var
 
var
Zeile 69: Zeile 71:
 
     MessageBox(buf);
 
     MessageBox(buf);
 
end;
 
end;
−
</pascal>
+
</source>
  
 
=== Laden des Programms ===
 
=== Laden des Programms ===
  
 
Im nächsten Schritt wird das Programm geladen:
 
Im nächsten Schritt wird das Programm geladen:
−
<pascal>
+
<source lang="pascal">
 
   cgGLLoadProgram(FProgram);
 
   cgGLLoadProgram(FProgram);
−
</pascal>
+
</source>
  
 
=== Binden und Entbinden ===
 
=== Binden und Entbinden ===
  
 
Möchten wir nun den Shader anwenden, so müssen wir diesen an das oben erzeugte Profil Binden und das Profil aktivieren:
 
Möchten wir nun den Shader anwenden, so müssen wir diesen an das oben erzeugte Profil Binden und das Profil aktivieren:
−
<pascal>
+
<source lang="pascal">
 
   cgGLEnableProfile(FProfile);
 
   cgGLEnableProfile(FProfile);
 
   cgGLBindProgram(FProgram);
 
   cgGLBindProgram(FProgram);
−
</pascal>
+
</source>
  
 
Sind wir mit dem Zeichnen fertig, so müssen wir den Shader wieder entbinden und das Profil deaktivieren:
 
Sind wir mit dem Zeichnen fertig, so müssen wir den Shader wieder entbinden und das Profil deaktivieren:
−
<pascal>
+
<source lang="pascal">
 
   cgGLDisableProfile(FProfile);
 
   cgGLDisableProfile(FProfile);
 
   cgGLUnbindProgram(FProfile);
 
   cgGLUnbindProgram(FProfile);
−
</pascal>
+
</source>
  
 
=== Finalisierung ===
 
=== Finalisierung ===
 
Sind wir mit der Verwendung unseres Shaderobjektes fertig, so müssen wir es zerstören:
 
Sind wir mit der Verwendung unseres Shaderobjektes fertig, so müssen wir es zerstören:
−
<pascal>
+
<source lang="pascal">
 
   if FProgram <> nil then
 
   if FProgram <> nil then
 
     cgDestroyProgram(FProgram);
 
     cgDestroyProgram(FProgram);
−
</pascal>
+
</source>
  
 
Am Ende unserer Anwendung sollte auch das Cg Shadersystem freigegeben werden:
 
Am Ende unserer Anwendung sollte auch das Cg Shadersystem freigegeben werden:
−
<pascal>
+
<source lang="pascal">
 
   if FContext <> nil then
 
   if FContext <> nil then
 
     cgDestroyContext(FContext);
 
     cgDestroyContext(FContext);
−
</pascal>
+
</source>
  
 
== Links ==
 
== Links ==

Aktuelle Version vom 10. März 2009, 19:03 Uhr

Allgemein

C for Graphics (Abkürzung: Cg) ist eine von NVIDIA begründete Shader-Hochsprache zum Schreiben von Vertex-Shader- und Fragment-Shader-Programmen. Eine Besonderheit von Cg ist die Plattform- und Grafikbibliothekunabhängigkeit: Somit kann ein Cg-Programm sowohl mit Direct3D als auch OpenGL verwendet werden.

Grundlegende Verwendung in einem OpenGL Programm

Initialisierung

Zunächst muss ein entsprechender Shadersystem Kontext erstellt werden: 

var
  FContext: PCGContext;

  FContext := cgCreateContext;

Laden des Programmes

Danach muss dass entsprechende Programm hereingeladen und kompiliert werden. Hierbei sollte noch das beste verfügbare Shaderprofil auslesen. Zudem ist zu entscheiden, ob man einen Vertex- oder eine Fragmentshader laden möchte: 

var
  FProgram: PCGProgram;
  FProfile: TCGProfile;
  srctype: Cardinal;

  //Entsprechenden Typus für die Quelle auswählen  
  case ASourceType of
    assSource: srctype := CG_SOURCE;
    assCompiled: srctype := CG_OBJECT;
  end;

  //Bestes Profil für den gewählten Shadertyp wählen  
  case AShaderType of
    astVertex: FProfile := cgGLGetLatestProfile(CG_GL_VERTEX);
    astFragment: FProfile := cgGLGetLatestProfile(CG_GL_FRAGMENT);
  end;

  //Beste optionen für das Profil setzten
  cgGLSetOptimalOptions(FProfile);

  //Programm laden und compilieren - ABuf bezeichnet einen PChar, der 
  //den Programmquelltext oder den Programmobjectcode enthält, 
  //AProgramName den Namen der Hauptfunktion des Shaderprogrammes
  FProgram := cgCreateProgram(FContext, srctype, ABuf,
    FProfile, AProgramName, nil);

Fehlerabfrage

Nun sollte man abfragen ob es beim Compilieren Fehler gegeben hat. Mit der Folgenden Prozedur ist dies ein leichtes: 

procedure GetCGError;
var
  error: CGError;
  str: PChar;
  buf: string;
begin
  buf := '';
  str := cgGetLastErrorString(@error);

  if (error <> CG_NO_ERROR) then
  begin
    if (error = CG_COMPILER_ERROR) then
      buf := 
        'Compiler error ' + #13#10 +
        cgGetLastListing(FSystem.Context)
    else
      buf := 'CG Runtime error' + str;
  end;

  if buf <> '' then
    MessageBox(buf);
end;

Laden des Programms

Im nächsten Schritt wird das Programm geladen: 

  cgGLLoadProgram(FProgram);

Binden und Entbinden

Möchten wir nun den Shader anwenden, so müssen wir diesen an das oben erzeugte Profil Binden und das Profil aktivieren: 

  cgGLEnableProfile(FProfile);
  cgGLBindProgram(FProgram);

Sind wir mit dem Zeichnen fertig, so müssen wir den Shader wieder entbinden und das Profil deaktivieren: 

  cgGLDisableProfile(FProfile);
  cgGLUnbindProgram(FProfile);

Finalisierung

Sind wir mit der Verwendung unseres Shaderobjektes fertig, so müssen wir es zerstören: 

  if FProgram <> nil then
    cgDestroyProgram(FProgram);

Am Ende unserer Anwendung sollte auch das Cg Shadersystem freigegeben werden: 

  if FContext <> nil then
    cgDestroyContext(FContext);

Links

http://de.wikipedia.org/wiki/C_for_graphics
http://developer.nvidia.com/page/cg_main.html
http://http.developer.nvidia.com/CgTutorial/cg_tutorial_chapter01.html

Siehe auch

Shader, GLSL

Abgerufen von „https://wiki.delphigl.com/index.php?title=Cg&oldid=22866“