Files |  Tutorials |  Articles |  Links |  Home |  Team |  Forum |  Wiki |  Impressum

Aktuelle Zeit: Fr Jul 18, 2025 11:19

Foren-Übersicht » Programmierung » OpenGL 		Unbeantwortete Themen | Aktive Themen


Ein neues Thema erstellen Auf das Thema antworten  Seite 2 von 3
  [ 37 Beiträge ]  Gehe zu Seite Vorherige  1, 2, 3  Nächste
  Vorheriges Thema | Nächstes Thema 
Autor Nachricht
olee
 Betreff des Beitrags:
BeitragVerfasst: So Feb 22, 2009 16:18 
Offline
DGL Member
Benutzeravatar

Registriert: Do Feb 21, 2008 22:10
Beiträge: 89
Wohnort: Boppard
Neues Problem:

ich habe bisher nur eine Lichtquelle benutzt.

Wenn ich jetzt wieder auf OpenGl-Licht umstelle (zum test wegen fehlern) und meine einstellungen auf Light1 statt Light0
anwende, sehe ich kein Licht.

Nebenbei: Ambiente-Lichteinstellungen funktionieren.
Nach oben
 Profil  
Mit Zitat antworten  
olee
 Betreff des Beitrags:
BeitragVerfasst: So Feb 22, 2009 16:43 
Offline
DGL Member
Benutzeravatar

Registriert: Do Feb 21, 2008 22:10
Beiträge: 89
Wohnort: Boppard
Hat sich erledigt warn blöder fehler. :lol:


Zuletzt geändert von olee am So Feb 22, 2009 16:52, insgesamt 1-mal geändert.

Nach oben
 Profil  
Mit Zitat antworten  
Coolcat
 Betreff des Beitrags:
BeitragVerfasst: So Feb 22, 2009 16:52 
Offline
DGL Member
Benutzeravatar

Registriert: Do Dez 29, 2005 12:28
Beiträge: 2249
Wohnort: Düsseldorf
Programmiersprache: C++, C#, Java
Zitat:
Ich kapiers nicht.
Ich habe auch glEnable(GL_LIGHT1) aufgerufen.


Schau dir einfach deinen Shader an und verstehe was der da rechnet.....Stichwort gl_LightSource[0].

Wenn du mehr Lichtquellen willst, brauchst du ne Schleife über die Lichtquellen. Der Vorteil der Shader ist eben, du hast alle Freiheiten, der Nachteil du musst alles selbst machen....

_________________
Yeah! :mrgreen:
Nach oben
 Profil  
Mit Zitat antworten  
Flash
 Betreff des Beitrags:
BeitragVerfasst: So Feb 22, 2009 17:41 
Offline
Guitar Hero
Benutzeravatar

Registriert: Do Sep 25, 2003 15:56
Beiträge: 7810
Wohnort: Sachsen - ERZ / C
Programmiersprache: Java (, Pascal)
@olee: Ist deine Version eine Verbesserung des Shaders im Wiki bzw. eine Anpassung die dafür sorgt, dass er in mehr Fällen funktioniert?
Wenn ja, kannst du den Shaderartikel im Wiki bitte ergänzen? Du weißt schon: Wer was nimmt und was zurückgeben kann der sollte das auch machen. ;)

@Coolcat: Super shader. Und sogar einer, der SM4 einsetzt.

_________________
Blog: kevin-fleischer.de und fbaingermany.com
Nach oben
 Profil  
Mit Zitat antworten  
olee
 Betreff des Beitrags:
BeitragVerfasst: So Feb 22, 2009 17:56 
Offline
DGL Member
Benutzeravatar

Registriert: Do Feb 21, 2008 22:10
Beiträge: 89
Wohnort: Boppard
Hab den Shader nochmal sehr verbessert :mrgreen:

Jetzt ist er bereit für Sammlung:

Der Shader...
- behandelt jetzt sogar die Distanz zur Lichtquelle für eine Abswächung der Lichtintesität.
- bearbeitet aktuell 2 Lichtquellen, was sich aber ohne Beschränkung auf n-Lichtquellen erweitern lässt.

Vertexshader:
Code:
  1.  
  2. varying vec3 vert;
  3. varying vec3 normal;
  4. varying vec3 lightvec0;
  5. varying vec3 lightvec1;
  6.  
  7. varying vec4 IAmbient;
  8.  
  9. uniform int EnableLighting;
  10.  
  11. void main(void)
  12. {
  13.   gl_Position    = gl_ModelViewProjectionMatrix * gl_Vertex;
  14.   gl_FrontColor   = gl_Color;
  15.   gl_TexCoord[0] = gl_MultiTexCoord0;
  16.  
  17.   if (EnableLighting==1)
  18.   {
  19.     normal              = normalize(gl_NormalMatrix * gl_Normal);
  20.     vert                = vec3(gl_ModelViewMatrix * gl_Vertex);
  21.  
  22.     lightvec0           = gl_LightSource[0].position.xyz;
  23.     if (gl_LightSource[0].position.w != 0)
  24.       lightvec0         = lightvec0 - vert;
  25.     lightvec0           = normalize(lightvec0);
  26.  
  27.     lightvec1           = gl_LightSource[1].position.xyz;
  28.     if (gl_LightSource[1].position.w != 0)
  29.       lightvec1         = lightvec1 - vert;
  30.     lightvec1           = normalize(lightvec1);
  31.  
  32.     IAmbient    = gl_LightSource[0].ambient +
  33.         gl_LightSource[1].ambient;
  34.   }
  35. }
  36.  



Fragmentshader:
Code:
  1.  
  2. varying vec3 vert;
  3. varying vec3 normal;
  4. varying vec3 lightvec0;
  5. varying vec3 lightvec1;
  6. varying vec3 lightvec2;
  7.  
  8. uniform sampler2D Texture0;
  9. uniform int EnableLighting;
  10.  
  11. varying vec4 IAmbient;
  12.  
  13. void main(void)
  14. {
  15.   if (EnableLighting==1)
  16.   {
  17.     vec3 Eye        = normalize(-vert);
  18.  
  19.     float d0 = 1;
  20.     if (gl_LightSource[0].position.w != 0)
  21.     {
  22.       d0    = distance(gl_LightSource[0].position.xyz,vert);
  23.       d0    = 1 / ( gl_LightSource[0].constantAttenuation +
  24.         gl_LightSource[0].linearAttenuation*d0 +
  25.         gl_LightSource[0].quadraticAttenuation*d0*d0);      
  26.     }
  27.     float d1 = 1;
  28.     if (gl_LightSource[1].position.w != 0)
  29.     {
  30.       d1    = distance(gl_LightSource[1].position.xyz,vert);
  31.       d1    = 1 / ( gl_LightSource[1].constantAttenuation +
  32.         gl_LightSource[1].linearAttenuation*d1 +
  33.         gl_LightSource[1].quadraticAttenuation*d1*d1);
  34.     }
  35.  
  36.     vec4 IDiffuse   = gl_LightSource[0].diffuse * max(dot(normal, lightvec0), 0.0) * d0 +
  37.         gl_LightSource[1].diffuse * max(dot(normal, lightvec1), 0.0) * d1;  
  38.    
  39.     vec4 ISpecular  = gl_LightSource[0].specular*
  40.         pow(max(dot(normalize(reflect( -lightvec0, normal)), Eye), 0.0), gl_FrontMaterial.shininess)  * d0+
  41.         gl_LightSource[1].specular*
  42.         pow(max(dot(normalize(reflect( -lightvec1, normal)), Eye), 0.0), gl_FrontMaterial.shininess) * d1;
  43.  
  44.     gl_FragColor     = vec4(    (gl_FrontLightModelProduct.sceneColor + IAmbient + IDiffuse) *
  45.             texture2D(Texture0, vec2(gl_TexCoord[0])) + ISpecular*gl_FrontMaterial.specular)  *
  46.         gl_Color;
  47.   }
  48.   else
  49.     gl_FragColor   = texture2D(Texture0, vec2(gl_TexCoord[0]))  * gl_Color;
  50. }
  51.  




Leider habe ich noch keinen Wiki-Account sonst würde ich den Shader einbringen.
@Flash: Du könntest das ja machen^^.

Nebenbei bemerkt habe ich heute erst meinen ersten Shader geschrieben :mrgreen: :shock: .

Ich könnte aber noch ein paar experimentelle Shader, die ich getestet habe, zur Sammlung hinzufügen wie Normalmaps, usw.

EDIT:
Auf den Bildern ist eine Scene mit 2Lichtquellen
-> eine unendlich weit weg (Mondlicht))
-> die andere ist gelb und neben einem
Leider erkennt man auf den Bildern nicht soo gut den Effekt und Unterschied, da sich der Mond in meiner App bewegt und ich so in beiden
Bildern unterschiedliche Lichtverhältnisse habe.


MFG


Du hast keine ausreichende Berechtigung, um die Dateianhänge dieses Beitrags anzusehen.

Nach oben
 Profil  
Mit Zitat antworten  
Flash
 Betreff des Beitrags:
BeitragVerfasst: So Feb 22, 2009 19:11 
Offline
Guitar Hero
Benutzeravatar

Registriert: Do Sep 25, 2003 15:56
Beiträge: 7810
Wohnort: Sachsen - ERZ / C
Programmiersprache: Java (, Pascal)
Ist es möglich den Shader auf beliebig viele Lichtquellen zu erweitern? So, dass man ihn nicht per codeeingriff anpassen muss? Geht sowas überhaupt performant?

@Gruppenverwaltung: Kann jemand olee fürs Wiki freischalten? Ich bin der Woche über in Intranets gefangen. ;)

_________________
Blog: kevin-fleischer.de und fbaingermany.com
Nach oben
 Profil  
Mit Zitat antworten  
olee
 Betreff des Beitrags:
BeitragVerfasst: So Feb 22, 2009 20:00 
Offline
DGL Member
Benutzeravatar

Registriert: Do Feb 21, 2008 22:10
Beiträge: 89
Wohnort: Boppard
Also jein ^^

Man kann den Code durch Strg+C und das einsetzen von Zahlen erweitern (was auffallen sollte, wenn man sich ihn anguckt)

aber das ganze lässt sich noch durch eine Schleife ersetzen.
Jedoch denke ich ist eine statische Funktion ohne Schleife schneller, wenn man auch wirklich immer alle Quellen nutzt.

Aber ich hätte noch eine Frage: Gibts eine möglichkeit, Werte direkt von Vertex an Fragmentshader zu
übermitteln, ohne dass diese interpoliert werden (also nicht über "varying")?

@Flash: Ich habe vorhin schon eine Anfrage auf Wiki-Rechte gestellt :mrgreen: .
Nach oben
 Profil  
Mit Zitat antworten  
Coolcat
 Betreff des Beitrags:
BeitragVerfasst: So Feb 22, 2009 20:08 
Offline
DGL Member
Benutzeravatar

Registriert: Do Dez 29, 2005 12:28
Beiträge: 2249
Wohnort: Düsseldorf
Programmiersprache: C++, C#, Java
Zitat:
Jedoch denke ich ist eine statische Funktion ohne Schleife schneller, wenn man auch wirklich immer alle Quellen nutzt.

Nicht unbedingt. Keine Schleife heißt auch das mehr Programmzeilen verarbeitet werden müssen, dafür benötigt man mehr Speicher, was wieder langsamer ist. Eine Schleife mit konstanten (!) Grenzen dürfte am schnellsten sein, da der Compiler entscheiden kann was er macht. Wenn es Sinn macht wird die Schleife vom Compiler dann einfach "ausgerollt". In jedem Fall wird der Quellcode übersichtlicher. :)

Edit: Übrigens, was sicher mehr Sinn macht als diese Schleifen Überlegungen ist der Einsparen von unnötigen normalize und distance, da steckt nämlich ne Wurzel drin. Ich würde z.B. die Lichtquelle einfach als normalisiert annehmen. Spart dann auch gleich das varying lightvec aus dem Vertexshader.

_________________
Yeah! :mrgreen:
Nach oben
 Profil  
Mit Zitat antworten  
olee
 Betreff des Beitrags:
BeitragVerfasst: So Feb 22, 2009 21:05 
Offline
DGL Member
Benutzeravatar

Registriert: Do Feb 21, 2008 22:10
Beiträge: 89
Wohnort: Boppard
Könntest du vllt. eine optimierte Variante hier posten?
Je nach dem auch mit Schleife?

Immerhin habe ich heute meinen ersten Shader geschrieben. ^^
Nach oben
 Profil  
Mit Zitat antworten  
Coolcat
 Betreff des Beitrags:
BeitragVerfasst: So Feb 22, 2009 22:50 
Offline
DGL Member
Benutzeravatar

Registriert: Do Dez 29, 2005 12:28
Beiträge: 2249
Wohnort: Düsseldorf
Programmiersprache: C++, C#, Java
So, hier mal meine Variante. Ich habe das ganze aber nicht getestet....habe gerade keine Umgebung wo ich das mal schnell einbauen könnte. Hier sollten jetzt auch Ambient+Diffuse Materialfarben berücksichtigt werden.

Edit: Direktionale Lichtquellen müssen normalisiert sein!

Vertexshader:
Code:
  1. varying vec3 position;
  2. varying vec3 normal;
  3.  
  4. void main() {
  5.     gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
  6.     gl_FrontColor = gl_Color;
  7.     gl_TexCoord[0] = gl_MultiTexCoord0;
  8.  
  9.     normal = normalize(gl_NormalMatrix * gl_Normal);
  10.     position = vec3(gl_ModelViewMatrix * gl_Vertex);
  11. }
  12.  



Fragmentshader:
Code:
  1. uniform sampler2D texture0;
  2. uniform int activeLights;
  3.  
  4. varying vec3 position;
  5. varying vec3 normal;
  6.  
  7. void main() {
  8.     normal = normalize(normal);
  9.     float attenuation;
  10.     vec3 lightDir;
  11.     vec3 eyeDir = normalize(-position); // camera is at (0,0,0) in ModelView space
  12.     vec4 lightAmbientDiffuse = vec4(0,0,0,0);
  13.     vec4 lightSpecular = vec4(0,0,0,0);
  14.  
  15.     // iterate all lights
  16.     for (int i=0; i<activeLights; ++i) {
  17.         // attenuation and light direction
  18.         if (gl_LightSource[i].position.w != 0.0) {
  19.             // positional light source
  20.             float dist = distance(gl_LightSource[i].position.xyz, position);
  21.             attenuation = 1.0 / (  gl_LightSource[i].constantAttenuation
  22.                                  + gl_LightSource[i].linearAttenuation * dist
  23.                                  + gl_LightSource[i].quadraticAttenuation * dist * dist );
  24.             lightDir = normalize(gl_LightSource[i].position.xyz - position);
  25.         }
  26.         else {
  27.             // directional light source
  28.             attenuation = 1.0;
  29.             lightDir = gl_LightSource[i].position.xyz;
  30.         }
  31.  
  32.         // ambient + diffuse
  33.         lightAmbientDiffuse +=
  34.             attenuation * (gl_FrontLightProduct[i].ambient + gl_FrontLightProduct[i].diffuse * max(dot(normal, lightDir), 0.0));
  35.  
  36.         // specular
  37.         vec3 r = normalize(reflect(-lightDir, normal));
  38.         lightSpecular +=
  39.             attenuation * gl_FrontLightProduct[i].specular * pow(max(dot(r, eyeDir), 0.0), gl_FrontMaterial.shininess);
  40.     }
  41.  
  42.     // compute final color
  43.     vec4 texColor = gl_Color * texture2D(texture0, gl_TexCoord[0].xy);
  44.     gl_FragColor = texColor * (gl_FrontLightModelProduct.sceneColor + lightAmbientDiffuse) + lightSpecular;
  45. }

_________________
Yeah! :mrgreen:


Zuletzt geändert von Coolcat am So Feb 22, 2009 23:26, insgesamt 4-mal geändert.

Nach oben
 Profil  
Mit Zitat antworten  
Coolcat
 Betreff des Beitrags:
BeitragVerfasst: So Feb 22, 2009 22:57 
Offline
DGL Member
Benutzeravatar

Registriert: Do Dez 29, 2005 12:28
Beiträge: 2249
Wohnort: Düsseldorf
Programmiersprache: C++, C#, Java
Übrigens, so wirklich viel optimiert ist da nicht....jetzt mal von der Schleife abgesehen. Vermutlich wird man bei der Performance auf aktuelle Hardware keinen Unterschied merken. Ich habe im wesentlichen nur den Code (meiner Meinung nach) etwas ordentlicher geschrieben, kommentiert usw.

_________________
Yeah! :mrgreen:
Nach oben
 Profil  
Mit Zitat antworten  
olee
 Betreff des Beitrags:
BeitragVerfasst: So Feb 22, 2009 23:08 
Offline
DGL Member
Benutzeravatar

Registriert: Do Feb 21, 2008 22:10
Beiträge: 89
Wohnort: Boppard
Es funktioniert noch nicht ganz.

Ich werde sehen, ob ich den Fehler finde.

Aber ich habe ein Problem mit
Code:
  1. lightDir = normalize(gl_LightSource[i].position.xyz - position);

das ist etwas unnötig oder nicht?
Ich hatte das im VS...

MFG
Nach oben
 Profil  
Mit Zitat antworten  
olee
 Betreff des Beitrags:
BeitragVerfasst: So Feb 22, 2009 23:14 
Offline
DGL Member
Benutzeravatar

Registriert: Do Feb 21, 2008 22:10
Beiträge: 89
Wohnort: Boppard
Habe den Fehler gefunden in der Zeile
Code:
  1. vec3 dist       = distance(gl_LightSource[i].position.xyz, position);
  2.  

musste stattdessen
Code:
  1. float dist      = distance(gl_LightSource[i].position.xyz, position);
  2.  
hin.
Nach oben
 Profil  
Mit Zitat antworten  
Coolcat
 Betreff des Beitrags:
BeitragVerfasst: So Feb 22, 2009 23:15 
Offline
DGL Member
Benutzeravatar

Registriert: Do Dez 29, 2005 12:28
Beiträge: 2249
Wohnort: Düsseldorf
Programmiersprache: C++, C#, Java
Fehler: attenuation vergessen, habs oben editiert.

Zitat:
das ist etwas unnötig oder nicht?

Nun, es vereinfacht die Sache etwas, da du sonst variabel viele lightDir's aus dem VS übergeben musst, was nicht geht. Zudem ist das natürlich die korrekte Berechnung, wenn man wirklich per-pixel haben will.

_________________
Yeah! :mrgreen:
Nach oben
 Profil  
Mit Zitat antworten  
Coolcat
 Betreff des Beitrags:
BeitragVerfasst: So Feb 22, 2009 23:22 
Offline
DGL Member
Benutzeravatar

Registriert: Do Dez 29, 2005 12:28
Beiträge: 2249
Wohnort: Düsseldorf
Programmiersprache: C++, C#, Java
Die Normale muss im Fragmentshader erneut normalisiert werden, ansonsten könnte die Farbe verfälscht werden.

Edit: Alle bisher genannten Fehler oben korrigiert.

_________________
Yeah! :mrgreen:
Nach oben
 Profil  
Mit Zitat antworten  
Beiträge der letzten Zeit anzeigen:  Sortiere nach  
Ein neues Thema erstellen Auf das Thema antworten  Seite 2 von 3
  [ 37 Beiträge ]  Gehe zu Seite Vorherige  1, 2, 3  Nächste
Foren-Übersicht » Programmierung » OpenGL


Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 19 Gäste

Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.

Suche nach:
Gehe zu:  
  Powered by phpBB® Forum Software © phpBB Group
Deutsche Übersetzung durch phpBB.de
[ Time : 0.011s | 15 Queries | GZIP : On ]