DGL • Thema anzeigen - So wenig Varying-floats?

So wenig Varying-floats?

Moderator: DGL-Team

Seite 1 von 3

[ 39 Beiträge ]

Gehe zu Seite 1, 2, 3 Nächste

Druckansicht

Vorheriges Thema | Nächstes Thema

Autor

Nachricht

Thmfrnk

Betreff des Beitrags: So wenig Varying-floats?

Verfasst: Mi Okt 20, 2010 14:57

DGL Member

Registriert: Do Apr 22, 2010 17:17
Beiträge: 543

Moin,
aalso ich bin noch beim Shaderoptimieren. Ich denke wenn ich alles richtig verstanden habe wird der Fragmentshader für jeden "Pixel" und der Vertex-Shader für jeden Vertex. D.h. das der Fragmentshader um ein vielfaches öfters durchlaufen wird als der Vertex. Darum sollte man ja so viel wie möglich schon im Vertex-Shader rechnen.. Bis dahin korrekt?

Bei mir ist es nun so das ich mit meinem Projektionsshader für mehrere Projektoren ein wenig probleme bekomme meine berechneten texturkoordinaten an den fragmentshader zu bekommen.. Aktuell hab ich das alles so begrenzt das ich max. 7 Projektoren rendern kann. Das ergibt dann 30 varying floats. Meine Karte sagt mir zwar das ich 60 davon nutzen kann, doch wie siehts bei anderen Grakas aus? Ich hab schon manche Berechnungen in den Fragmentshader übernommenm um auf die geringe anzahl von Varyings zu kommen.. Doch warum ist das so dolle limitiert? Gibts vielleicht irgendeinen anderen Trick die Daten in den FS zu bekommen?

Grüße
Thomas

Nach oben

mrtrain

Betreff des Beitrags: Re: So wenig Varying-floats?

Verfasst: Mi Okt 20, 2010 15:31

DGL Member

Registriert: Di Okt 13, 2009 17:25
Beiträge: 365
Programmiersprache: C++

Thmfrnk hat geschrieben:

Kommt immer drauf an. In der Regel trifft das zu. Bei Grafikchips der DirectX9/OpenGL2-Generation war es noch so, dass Fragment- und Vertexshader wirklich von unterschiedlichen Rechenwerken ausgeführt wurden. D.h. man hatte ein festes Verhältnis zwischen Vertexshader- und Fragmentshaderleistung. Auf solcher Hardware kann es auch leicht dazu kommen, dass der Vertexshader den Fragmentshader ausbremst. Bei neueren Grafikkarten kann der Treiber entscheiden, wie viele Shaderunits er wofür einsetzt - so ist es z.B. auch möglich alle Rechenwerke für universelle Berechnungen zu nutzen. Bei Nvidia gibt es eine interessante Präsentation dazu (auch als Video). Wie gut aktuelle Treiber das bei all den reinspielenden Faktoren entscheiden kann, weiß ich nicht.

Thmfrnk hat geschrieben:

Bei mir ist es nun so das ich mit meinem Projektionsshader für mehrere Projektoren ein wenig probleme bekomme meine berechneten texturkoordinaten an den fragmentshader zu bekommen.. Aktuell hab ich das alles so begrenzt das ich max. 7 Projektoren rendern kann. Das ergibt dann 30 varying floats. Meine Karte sagt mir zwar das ich 60 davon nutzen kann, doch wie siehts bei anderen Grakas aus? Ich hab schon manche Berechnungen in den Fragmentshader übernommenm um auf die geringe anzahl von Varyings zu kommen.. Doch warum ist das so dolle limitiert? Gibts vielleicht irgendeinen anderen Trick die Daten in den FS zu bekommen?

Tricks gibt es fast immer - man muss nur drauf kommen. :wink:

Laut GLSL-Tutorial muss jede GLSL-fähige Grafikkarte mindestens 32 varying floats unterstützen. Vielleicht postest du mal etwas Code, damit man ein bessere Chance hat, um auf Optimierungsideen zu kommen?

Zuletzt geändert von mrtrain am Mi Aug 31, 2011 20:53, insgesamt 1-mal geändert.

Nach oben

Thmfrnk

Betreff des Beitrags: Re: So wenig Varying-floats?

Verfasst: Mi Okt 20, 2010 16:06

DGL Member

Registriert: Do Apr 22, 2010 17:17
Beiträge: 543

ich bastel den Shader grad noch bissl um, werde ihn dann man hier reinstellen, dann könnt ihr mal drüber gucken was man noch machen kann..

Passt hier vielleicht nicht ganz aber, kurze Frage am Rande:
wenn ich in einer Schleife eine Variable deklariere, wird diese im jeden durchlauf erneut reserviert oder einfach überschrieben?

Code:

for....do {
 vec4 MeineVar := xxxx;
}

//oder besser
vec4 MeineVar;
for...do {
 MeineVar = xxx;
}

Nach oben

mrtrain

Betreff des Beitrags: Re: So wenig Varying-floats?

Verfasst: Mi Okt 20, 2010 16:23

DGL Member

Registriert: Di Okt 13, 2009 17:25
Beiträge: 365
Programmiersprache: C++

Ich glaube, die Compiler von ATI und Nvidia sind da ziemlich gut. Ich meine einmal in einem Paper von Nvidia gelesen zu haben, dass man ruhig das Ergebnis jeder Zeile in einer neuen Variable speichern soll, wenn es einem übersichtlicher erscheint. Der Compiler würde sich schon drum kümmern, dass nicht mehr Register gebraucht werden als nötig. Aber auf der sicheren Seite ist man natürlich, wenn man die Variable außerhalb der Schleife deklariert.

Zuletzt geändert von mrtrain am Mi Aug 31, 2011 20:54, insgesamt 1-mal geändert.

Nach oben

Thmfrnk

Betreff des Beitrags: Re: So wenig Varying-floats?

Verfasst: Mi Okt 20, 2010 17:32

DGL Member

Registriert: Do Apr 22, 2010 17:17
Beiträge: 543

soo hier meine beiden Shader. Funktionieren tun die Super. Sieht hammergeil aus. Doch sobald ich ca 30 Lampen drin hab (in mehreren Pässen) und mal näher an die geometrie gehe, gehen meine beiden CPU Kerne auf 100% und die FPS geht unter 20..

Vertex:

Code:

#version 120
const int max_lights = 7;

uniform mat4 TexGenMats[max_lights];
uniform mat4 InvViewMat;

varying vec4 projCoord[max_lights];
varying vec3 normal;
varying vec4 posEye;
varying vec3 globalLightVec;

void main()
{    
 posEye =  gl_ModelViewMatrix * gl_Vertex;
 normal = normalize(gl_NormalMatrix * gl_Normal);  
 
 globalLightVec =  normalize(gl_LightSource[0].position.xyz - posEye.xyz);
 vec4 posWorld = InvViewMat * posEye;  
  
   for (int i=0; i < max_lights; ++i) {  
     projCoord[i] = TexGenMats[i] * posWorld;               
   }   
   
   gl_TexCoord[0] = gl_MultiTexCoord0;      
   gl_Position = ftransform();      
}

Fragment:

Code:

#version 120
const int max_lights = 7;

uniform sampler2D projMap0;
uniform sampler2D projMap1;
uniform sampler2D projMap2;
uniform sampler2D projMap3;
uniform sampler2D projMap4;
uniform sampler2D projMap5;
uniform sampler2D projMap6;
uniform sampler2D projMap7;
uniform sampler2D Texture0;

uniform vec4 LampColors[max_lights];       //Lichtfarbe und intensität
uniform int GoboIndex[max_lights];          //gibt an welcher Gobo Sampler projeziert werden soll
uniform int GlobalLight;                //gibt an ob globales Punktlicht verwendet werden soll
uniform vec4 LightPos[max_lights];          //Lampenpositionen für evtl. weitere Berechnungen

//MAX 32 FLOATS!!
varying vec4 projCoord[max_lights];         
varying vec3 normal;
varying vec4 posEye;
varying vec3 globalLightVec;
  
void main (void)
{
 vec4  ProjMapColor = vec4(0.0, 0.0, 0.0, 0.0);  
 vec4  backgroundColor; 
 vec4  global_color;
 vec3  lightDir, L;
 
 float d, att, lambertTerm;
 //Hintergrund Farbe 
 if (gl_FrontMaterial.ambient.a > 0.0) {
  //keine Textur 
    backgroundColor = gl_FrontMaterial.ambient;
  } else  
    backgroundColor = texture2D(Texture0, gl_TexCoord[0].xy);
 
 
 
 //Globales Punktlicht
  if (GlobalLight>0) {
    vec3 Eye = normalize(-posEye.xyz);   
    vec3 Reflected = normalize(reflect( -globalLightVec, normal));  
    vec4 IAmbient  = gl_LightSource[0].ambient * gl_FrontMaterial.ambient;
    vec4 IDiffuse  = gl_LightSource[0].diffuse * max(dot(normal, globalLightVec), 0.0) * gl_FrontMaterial.diffuse;
    vec4 ISpecular = gl_LightSource[0].specular * pow(max(dot(Reflected, Eye), 0.0), gl_FrontMaterial.shininess) * gl_FrontMaterial.specular;

    global_color = vec4((gl_FrontLightModelProduct.sceneColor + IAmbient + IDiffuse) * backgroundColor + ISpecular);
    }
    
 vec4 final_color;
 
 //Projektion für jede Lampe  
   for (int i=0; i < max_lights; ++i) 
    if (GoboIndex[i]<max_lights)
   {        
      //verhindert Rückprojektion
      if(projCoord[i].q<0.0) {    
           
       if (GoboIndex[i]==0) { 
               ProjMapColor = texture2DProj(projMap0, projCoord[i]);
               }   else
       if (GoboIndex[i]==1) {       
               ProjMapColor = texture2DProj(projMap1, projCoord[i]);
               } else              
       if (GoboIndex[i]==2) {
               ProjMapColor = texture2DProj(projMap2, projCoord[i]);
               } else             
       if (GoboIndex[i]==3) {
               ProjMapColor = texture2DProj(projMap3, projCoord[i]);
               } else
       if (GoboIndex[i]==4) {
               ProjMapColor = texture2DProj(projMap4, projCoord[i]);
               } else
       if (GoboIndex[i]==5) {
               ProjMapColor = texture2DProj(projMap5, projCoord[i]);
               } else
       if (GoboIndex[i]==6) {
               ProjMapColor = texture2DProj(projMap6, projCoord[i]);
               } else
       if (GoboIndex[i]==7) {
               ProjMapColor = texture2DProj(projMap7, projCoord[i]);
               }       
            
    
   lightDir = vec3(LightPos[i].xyz - posEye.xyz);    
   d = length(lightDir);   
   att = 1.0 / ( gl_LightSource[1].constantAttenuation + 
   (gl_LightSource[1].linearAttenuation*d) + 
   (gl_LightSource[1].quadraticAttenuation*d*d) );    
   
   L = normalize(lightDir);
     lambertTerm = dot(normal, L);       
   if (lambertTerm > 0) {       
      final_color += ProjMapColor * LampColors[i] * lambertTerm * att;     
    }
    }
  } 
  
  gl_FragColor = (final_color * backgroundColor) + global_color;   
}

Nach oben

Coolcat

Betreff des Beitrags: Re: So wenig Varying-floats?

Verfasst: Mi Okt 20, 2010 18:16

DGL Member

Registriert: Do Dez 29, 2005 12:28
Beiträge: 2249
Wohnort: Düsseldorf
Programmiersprache: C++, C#, Java

Zitat:

Bis dahin korrekt?

Zitat:

Doch warum ist das so dolle limitiert?

Jede Instanz braucht ihrere eigenen Varyings. Es gibt zwei Möglichkeiten:
1. Jede Shaderunit hat lokal ihren eigenen Speicher direkt auf dem Chip integriert. Speicher braucht viel Fläche, daher ist der Speicher klein, weil dann eben mehr Shader-Units auf den Chip passen.
2. Die Shaderunits teilen sich einen gemeinsamen Speicher. Hier wird irgendwann der Speicher voll sein und es können nicht mehr alle Shaderunits gleichzeitig arbeiten (=> ab diesem Punkt wird es rapide langsamer.)

=> Warum legst du nicht einfach diese Schleife in den Fragmentshader:

Code:

for (int i=0; i < max_lights; ++i) { 
     projCoord[i] = TexGenMats[i] * posWorld;              
}

Dann wäre das varying-Problem gelöst.
Eine Multiplikation Matrix*Vektor ist jetzt nichts was man nicht auch im Fragmentshader machen könnte. Für die Grafikkarte sind das gerade mal vier Operationen, ist ja ein Vektorprozessor der vec4 am Stück bearbeiten kann. => 4 mal dot-Produkt.
Des weiteren brauchst du nur drei der vier Werte die da berechnet werden, also 3 dot-Produkte. Eigentlich sollte eine mat4x3 als Texturmatrix reichen.

_________________
Yeah! :mrgreen:

Nach oben

mrtrain

Betreff des Beitrags: Re: So wenig Varying-floats?

Verfasst: Mi Okt 20, 2010 18:47

DGL Member

Registriert: Di Okt 13, 2009 17:25
Beiträge: 365
Programmiersprache: C++

Also eins vorweg: Ich bin kein Shader Pro und mit Projektion habe ich auch noch nicht viel am Hut gehabt. Also sehe ich bestimmt höchstens die Hälfte der Verbesserungsmöglichkeiten. Und wie ich sehe, hat Coolcat ja auch schon was aus der eben erwähnten Kopfbedeckung gezaubert. :wink:

Hier meine Verbesserungsvorschläge:

Im Fragmentshader solltest du v.a. die vielen if-Tests vermeiden. Der Fall, dass keine "Hintergrund"textur vorkommt, dürfte doch ziemlich selten sein, oder? Falls nicht, kann man notfalls auch einfach eine weiße 2x2 Textur binden. Auch das if(GlobalLight>0) sehe ich skeptisch. Vielleicht lieber zwei verschiedene Shader (einen mit und einen ohne GlobalLight) nehmen. Das 8-fache if-else in deiner for-Schleife ist meiner Ansicht nach ein hammermäßiger Performanceschlucker. Wäre es nicht möglich, auf Programmebene dafür zu sorgen, dass das erste light immer zu projMap0 gehört? Dann könntest du dir die sogar die for-Schleife sparen.

Übrigens, bist du sicher, dass

Code:

const int max_lights = 7;

richtig ist? Wenn du willst, was ich denke was du willst, muss da 8 hin. :wink:

Zuletzt geändert von mrtrain am Mi Aug 31, 2011 20:54, insgesamt 1-mal geändert.

Nach oben

Coolcat

Betreff des Beitrags: Re: So wenig Varying-floats?

Verfasst: Mi Okt 20, 2010 19:47

DGL Member

Registriert: Do Dez 29, 2005 12:28
Beiträge: 2249
Wohnort: Düsseldorf
Programmiersprache: C++, C#, Java

Die große if-Abfrage ist notwendig da man Sampler leider nicht in ein Array packen kann. Man könnte ggf. ein switch benutzen, dass kann der Compiler möglicherweise besser optimieren. Ein "switch(i)" lässt sich nämlich ersetzen durch "goto(StartZeile + 2 * i)", wenn wie hier jeder Fall genau zwei Zeilen braucht. Das ist auch der Grund warum man bei switch ein break nach jedem Fall benötigt: Da wird ein goto gebraucht. Ob der Compiler so was drauf hat weiß ich aber natürlich nicht.

Der Sinn von GoboIndex[i] ist wohl das man für jedes gerenderte Objekt die Texturen einzeln setzen kann ohne die Texturen neu binden zu müssen. Musst du probieren ob das langsamer ist, schneller ist oder ggf. auch gar nichts ausmacht

Als weitere Optimierung könntest du die Textur nur dann abfragen, wenn du sie auch wirklich benötigst, sprich wenn

Code:

if (any(LampColors[i] * lambertTerm * att >= 1.0/255.0)) { ...

(Hinweis: ein LampColors[i] >= 1.0 gibt ein bvec4, also ein bool-vector. Die Funktion "any" gibt true, wenn einer der vier Werte true ist.)

_________________
Yeah! :mrgreen:

Nach oben

Thmfrnk

Betreff des Beitrags: Re: So wenig Varying-floats?

Verfasst: Do Okt 21, 2010 09:17

DGL Member

Registriert: Do Apr 22, 2010 17:17
Beiträge: 543

Code:

if (any(LampColors[i] * lambertTerm * att >= 1.0)) { ...

das geht leider nich durch den compiler.. bzw hab ich das /255 weggelassen weil ich nicht weiß wofür?!

Zitat:

0(74) : error C1020: invalid operands to ">="
0(74) : error C1115: unable to find compatible overloaded function "any(error)"

den rest bearbeite ich gerade. Werde dann mal testen und die verbesserte Variante reinsetzen. Verbrauchen IFs denn soviel performance?

Nach oben

Coolcat

Betreff des Beitrags: Re: So wenig Varying-floats?

Verfasst: Do Okt 21, 2010 09:42

DGL Member

Registriert: Do Dez 29, 2005 12:28
Beiträge: 2249
Wohnort: Düsseldorf
Programmiersprache: C++, C#, Java

Zitat:

bzw hab ich das /255 weggelassen weil ich nicht weiß wofür?!

Du hast 256 Farben pro Kanal...also 1.0/255.0 ist die dunkelste Farbe die irgendeinen Unterschied macht. Gut genau genommen 0.5/255.0, aber das sieht man eh nich.

Zitat:

das geht leider nich durch den compiler..

Sorry, mein Fehler. Versuchs mit:

Code:

vec4 lightColor = LampColors[i] * lambertTerm * att;
if (any(greaterThanEqual(lightColor, vec4(1,1,1,1)/255.0))) {
    final_color += ProjMapColor * lightColor;
}

_________________
Yeah! :mrgreen:

Nach oben

Thmfrnk

Betreff des Beitrags: Re: So wenig Varying-floats?

Verfasst: Do Okt 21, 2010 10:24

DGL Member

Registriert: Do Apr 22, 2010 17:17
Beiträge: 543

hier nun meine bearbeitete Version. Doch im Vergleich zu vorher ist diese Version nur schneller (ca +3-4 fps) wenn ich weit von der Geometrie weg bin. Sowie ich nah dran bin (was häufiger vorkommt) ist der neue Shader ca 4-8 fps schlechter..

Code:

#version 120
const int max_lights = 7;

uniform sampler2D projMap0;
uniform sampler2D projMap1;
uniform sampler2D projMap2;
uniform sampler2D projMap3;
uniform sampler2D projMap4;
uniform sampler2D projMap5;
uniform sampler2D projMap6;
uniform sampler2D projMap7;
uniform sampler2D Texture0;

uniform vec4 LampColors[max_lights];       //Lichtfarbe und intensität
uniform int GoboIndex[max_lights];          //gibt an welcher Gobo Sampler projeziert werden soll
uniform int GlobalLight;                //gibt an ob globales Punktlicht verwendet werden soll
uniform vec4 LightPos[max_lights];          //Lampenpositionen für evtl. weitere Berechnungen
uniform mat4 TexGenMats[max_lights];      //Texturprojektionsmatrix

//MAX 32 FLOATS!!
varying vec4 posWorld;      
varying vec3 normal;
varying vec4 posEye;
varying vec3 globalLightVec;
  
void main (void)
{
 vec4  ProjMapColor = vec4(0.0, 0.0, 0.0, 0.0);  
 vec4  backgroundColor, projColor; 
 vec4  global_color, projCoord;
 vec3  lightDir, L;
 
  
 float d, att, lambertTerm;
 //Hintergrund Farbe 
 if (gl_FrontMaterial.ambient.a > 0.0) {
  //keine Textur 
    backgroundColor = gl_FrontMaterial.ambient;
  } else  
    backgroundColor = texture2D(Texture0, gl_TexCoord[0].xy);
 
 
 
 //Globales Punktlicht
  if (GlobalLight>0) {
    vec3 Eye = normalize(-posEye.xyz);   
    vec3 Reflected = normalize(reflect( -globalLightVec, normal));  
    vec4 IAmbient  = gl_LightSource[0].ambient * gl_FrontMaterial.ambient;
    vec4 IDiffuse  = gl_LightSource[0].diffuse * max(dot(normal, globalLightVec), 0.0) * gl_FrontMaterial.diffuse;
    vec4 ISpecular = gl_LightSource[0].specular * pow(max(dot(Reflected, Eye), 0.0), gl_FrontMaterial.shininess) * gl_FrontMaterial.specular;

    global_color = vec4((gl_FrontLightModelProduct.sceneColor + IAmbient + IDiffuse) * backgroundColor + ISpecular);
    }
    
 vec4 final_color;
 
 //Projektion für jede Lampe  
   for (int i=0; i < max_lights; ++i) 
    if (GoboIndex[i]<=max_lights)   
    {        
     projCoord = TexGenMats[i] * posWorld;   
      if(projCoord.q<0.0) {        
      lightDir = vec3(LightPos[i].xyz - posEye.xyz);    
      d = length(lightDir);   
      att = 1.0 / ( gl_LightSource[1].constantAttenuation + 
      (gl_LightSource[1].linearAttenuation*d) + 
      (gl_LightSource[1].quadraticAttenuation*d*d) );    
      
      L = normalize(lightDir);
      lambertTerm = dot(normal, L);       
      projColor = LampColors[i] * lambertTerm * att;
      
       if (any(greaterThanEqual(projColor, vec4(1,1,1,1)/255.0))) {
           
       if (GoboIndex[i]==0) { 
               ProjMapColor = texture2DProj(projMap0, projCoord);
               }   else
       if (GoboIndex[i]==1) {       
               ProjMapColor = texture2DProj(projMap1, projCoord);
               } else              
       if (GoboIndex[i]==2) {
               ProjMapColor = texture2DProj(projMap2, projCoord);
               } else             
       if (GoboIndex[i]==3) {
               ProjMapColor = texture2DProj(projMap3, projCoord);
               } else
       if (GoboIndex[i]==4) {
               ProjMapColor = texture2DProj(projMap4, projCoord);
               } else
       if (GoboIndex[i]==5) {
               ProjMapColor = texture2DProj(projMap5, projCoord);
               } else
       if (GoboIndex[i]==6) {
               ProjMapColor = texture2DProj(projMap6, projCoord);
               } else
       if (GoboIndex[i]==7) {
               ProjMapColor = texture2DProj(projMap7, projCoord);
               }                    
   
      final_color += ProjMapColor * projColor;
    }
    }
  } 
  
  gl_FragColor = (final_color * backgroundColor) + global_color;   
}

Code:

#version 120

uniform mat4 InvViewMat;

varying vec4 posWorld;
varying vec3 normal;
varying vec4 posEye;
varying vec3 globalLightVec;


void main()
{    
 posEye =  gl_ModelViewMatrix * gl_Vertex;
 normal = normalize(gl_NormalMatrix * gl_Normal);  
 
 globalLightVec =  normalize(gl_LightSource[0].position.xyz - posEye.xyz);
 posWorld = InvViewMat * posEye;  
  

   
   gl_TexCoord[0] = gl_MultiTexCoord0;      
   gl_Position = ftransform();      
}

Nach oben

Coolcat

Betreff des Beitrags: Re: So wenig Varying-floats?

Verfasst: Do Okt 21, 2010 10:34

DGL Member

Registriert: Do Dez 29, 2005 12:28
Beiträge: 2249
Wohnort: Düsseldorf
Programmiersprache: C++, C#, Java

Wie wäre es einen Teil der Projektionen (eben soviel wie machbar) im Vertexshader zu machen und den Rest im Fragmentshader?

_________________
Yeah! :mrgreen:

Nach oben

Thmfrnk

Betreff des Beitrags: Re: So wenig Varying-floats?

Verfasst: Do Okt 21, 2010 10:55

DGL Member

Registriert: Do Apr 22, 2010 17:17
Beiträge: 543

Coolcat hat geschrieben:

Wie wäre es einen Teil der Projektionen (eben soviel wie machbar) im Vertexshader zu machen und den Rest im Fragmentshader?

wie meinst du das? Dann hab ich doch wieder das problem mit den Varyings..

Nach oben

Coolcat

Betreff des Beitrags: Re: So wenig Varying-floats?

Verfasst: Do Okt 21, 2010 11:14

DGL Member

Registriert: Do Dez 29, 2005 12:28
Beiträge: 2249
Wohnort: Düsseldorf
Programmiersprache: C++, C#, Java

Also du sagst du hast maximal 32 floats. Davon gehen 12 floats hierfür drauf:

Code:

varying vec4 posWorld;      // <--- hier reicht ein vec3!
varying vec3 normal;
varying vec4 posEye;   // <--- hier reicht ein vec3!
varying vec3 globalLightVec;

Damit hast du noch 20 floats übrig, das reicht für die ersten 6 Texturprojektionen, wenn das jeweils ein vec3 ist. Die restlichen Projektionen machst du dann eben im Fragmentshader.

_________________
Yeah! :mrgreen:

Nach oben

Thmfrnk

Betreff des Beitrags: Re: So wenig Varying-floats?

Verfasst: Do Okt 21, 2010 13:19

DGL Member

Registriert: Do Apr 22, 2010 17:17
Beiträge: 543

du sprichst von projectionen, ich kann doch nur die Texturmatrix berechnung im Vertexshader machen (so wie ichs vorher hatte..)?
Ich hab eben mal ein paar Tests gemacht, also ob ich nun 30 Lampen mit einem Shaderdurchgang rendere oder 5x 6 Lampen Rendere. Das ändert kaum was. Was in meinem Code sind denn die größten Bremsen? Die ifs? Später soll auch noch eine Shattenberechnung mit rein, also brauch dann auch noch platz für die Tiefentexturen der einzelnen Lampen. Also quasi 3x Projektionstextur und 3x Tiefentextur.. Damit sollte ich dann wohl immer 3 Lampen mit einemmal Rendern können..

Nach oben

Seite 1 von 3

[ 39 Beiträge ]

Gehe zu Seite 1, 2, 3 Nächste

Foren-Übersicht » Programmierung » Shader

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.