DGL • Thema anzeigen - Per-Pixel Lighting

Per-Pixel Lighting

Moderator: DGL-Team

Seite 1 von 1

[ 6 Beiträge ]

Vorheriges Thema | Nächstes Thema

Autor

Nachricht

Finalspace

Betreff des Beitrags: Per-Pixel Lighting

Verfasst: Do Sep 18, 2003 12:48

DGL Member

Registriert: Mi Okt 16, 2002 15:06
Beiträge: 1012

Tach,

ich bin momentan dabei meine engine mit Per-Pixel Licht und später Diffuse/Specular Bumpmapping auszuschatten.
Als ersten Schritt möchte ich erstmal nur das licht ohne bumpmapping.

Das hatte ich schon auch schon teilweise hingekriegt, teilweise deshalb weil es beim lars (ATI Radeon 9800 pro) funktioniert und bei mir nicht (GeForce1/GeForce4 Ti 4200).

Ich benutze aber keinerlei Extensions die über der GeForce1 liegen.
Es werden nur diese extensions benutzt:
GL_ARB_multitexture
GL_ARB_texture_env_combine
GL_ARB_texture_cube_map

Aber jetzt erstmal erklär ich mal wie Per-Pixel licht funktioniert, so wie ichs verstanden habe *g*:::

Erstmal die Formel:

Code:

 
Ambient + [ Attenuation * Decal ]
 
Umgebungsfarbe (meistens schwarz) + Für Jedes Licht[ Lichtintensität * Standardtexture ]

- Ambient = Welt mit Umgebungsfarbe zeichnen (0,0,0)
- Attentuation = Lichtintensität, setzt sich zusammen aus einer 3D Texture, bzw 1D+2D Texture, wird einmal vorberechnet am anfang.
- Decal = Welt mit basistexture zeichnen

In Jedem pass muss die gesamte Welt gezeichnet werden, natürlich kann man optimieren beim licht, das man nicht belichtete polys auslässt oder über Occlusion Culling optimieren, aber das ist zum testen nicht wichtig.

hier jetzt mal code zum richtigen verständnis aus meiner engine:

r3d_world.pas

Code:

 
// Hier wird alles gerendert,
procedure TR3DWorld.Render;
var
  I : Integer;
begin
  // Ambiente und Tiefe zechnen
  DrawAmbientLightAndDepth;
 
  // Lichter Zeichnen
  if (fDrawPointLights) then
    For I := 0 to High(fPointLights) do
      DrawLight(r3d_PointLightIntoLight(fPointLights[I]));
 
  {
  if (fDrawSpotLights) then
    For I := 0 to High(fSpotLights) do
      DrawLight(r3d_SpotLightIntoLight(fSpotLights[I]));
  }
 
  //reset polygon mode to fill
  glPolygonMode(GL_FRONT, GL_FILL);
 
  glDepthFunc(GL_LESS);
  glDisable(GL_STENCIL_TEST);
end;
 
procedure TR3DWorld.DrawAmbientLightAndDepth;
begin
  // Stencil Deaktivieren
  glDisable(GL_STENCIL_TEST);
 
  // Tiefentest einstellen
  glDepthFunc(GL_LESS);
  glEnable(GL_DEPTH_TEST);
 
  // Alpha Kanal ersetzten
  glBlendFunc(GL_ONE, GL_ZERO);
  glEnable(GL_BLEND);
 
  glClearColor(0, 0, 0, 1);
  glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
 
  // Umgebungsfarbe
  if (fAmbientEnable) then
    glColor4f(fAmbient, fAmbient, fAmbient, 1)
  else
    glColor4f(0,0,0,1);
 
  // Welt mit Basis texturen zeichnen
  DrawWorld(cWLM_Base);
end;
 
procedure TR3DWorld.DrawLight(const _Light : TR3DLight);
begin
  gActiveLight := _Light;
 
  // Light und HalfAngle Vector berechnen
  //UpdatePolygons;
 
  if (fShadowsEnable) then
  begin
  end;
 
  glDepthFunc(GL_EQUAL);
  glDepthMask(False);
 
  // add diffues lighting if enabled
  if (fDiffuseEnable) then
  begin
    gActiveLight.beginAlphaDiffuseIntensity;
      DrawWorld(cWLM_AlphaDiffuseIntensity);
    gActiveLight.endAlphaDiffuseIntensity;
 
    gActiveLight.beginDiffuse;
      DrawWorld(cWLM_Diffuse);
    gActiveLight.endDiffuse;
  end;
 
  glDepthFunc(GL_LESS);
  glDepthMask(True);
end;
 
procedure TR3DWorld.DrawPolygon(const _FaceIndex, _ObjIndex : Integer; _LightMode : Integer);
var
  Face         : TR3DFace;
  Obj          : TR3DObject;
  Poly         : TR3DPolygon;
  Plane        : TR3DPlane;
  Shader       : TR3DShader;
  Vertice      : TR3DVertex;
  PolyCoord    : TR3DTexcoordArray;
 
  I,
  VecIndex     : Integer;
  HasNoTexture : Boolean;
 
  procedure BindTextureFromShaderProg(const _ShaderProg : TR3DShaderProg; const _MultiTexIndex : Integer);
  var
    ShaderStage,
    TexIdx       : Integer;
 
    procedure SetNoTexture(const _TexName : String);
    begin
      PolyCoord := r3d_TexcoordCalculate(Poly, Poly.Normal, 0, False, False, 1, 1);
      TexIdx := fTextures.IndexOf(_TexName);
      if (TexIdx > -1) then
        fTextures.Textures[TexIdx].BindMultiTexture(_MultiTexIndex)
      else
        glBindTexture(GL_TEXTURE_2D, 0);
      HasNoTexture := True;
    end;
 
  begin
    ShaderStage := r3d_IndexFromProgInShader(_ShaderProg, Shader);
    if (ShaderStage > -1) then
    begin
      TexIdx := Shader.Stages[ShaderStage].TextureIDX;
      if (TexIdx > -1) then
        fTextures.Textures[TexIdx].BindMultiTexture(_MultiTexIndex)
      else
        SetNoTexture('common\texnotfound');
    end
    else
      SetNoTexture('common\shadernotfound');
  end;
begin
  Face := fFaces[_FaceIndex];
  Obj := fObjects[_ObjIndex];
  Poly := GetPolyFromFace(Face, Obj);
  Plane := r3d_PlaneConstruct(Poly);
  Shader := GetShaderFromFace(Face);
  HasNoTexture := False;
 
  case _LightMode of
    cWLM_Base: BindTextureFromShaderProg(r3d_shaderprog_decal, 0);
    cWLM_AlphaDiffuse: BindTextureFromShaderProg(r3d_shaderprog_diffuse, 0);
    cWLM_Diffuse: BindTextureFromShaderProg(r3d_shaderprog_decal, 0);
  end;
 
  // draw the surface
  glBegin(GL_TRIANGLE_STRIP);
    VecIndex := 0;
    For I := Face.VerticeIndex to Face.VerticeIndex + 2 do
    begin
      Vertice := fVertices[I];
 
      case _LightMode of
 
        cWLM_Base: // Decal
        begin
          // Vertex Normale
          Vertice.Normal.SetNormal;
 
          // Texture Koordinaten
          if HasNoTexture then PolyCoord[VecIndex].SetMultiTexcoord(0)
          else Vertice.Texcoords[0].SetMultiTexcoord(0);
 
          // Vertex
          Vertice.Position.SetVertex;
        end;
 
        cWLM_AlphaDiffuseIntensity: // Lichtintensität 3D Texture
        begin
          gActiveLight.processAlphaDiffuseIntensityVertex(Vertice.Position, Vertice.Light);
        end;
 
        cWLM_AlphaDiffuse: // AlphaDiffuse,  Diffuse Bumpmapping (unwichtig)
        begin
          gActiveLight.processAlphaDiffuseVertex(Vertice.Position, Vertice.Texcoords[0], Vertice.Light);
        end;
 
        cWLM_Diffuse: // Standard Texture
        begin
          gActiveLight.processDiffuseVertex(Vertice.Position, Vertice.Texcoords[0]);
        end;
 
      end;
      Inc(VecIndex);
    end;
  glEnd;
end;
 
procedure TR3DWorld.DrawWorld(_Lightmode : Integer);
var
  I, J    : Integer;
  ObjAABB : TR3DAxisAlignBoundingBox;
begin
  For I := 0 to High(fObjects) do
  begin
    if (fFrustumCulling) then
    begin
      if (fObjects[I].AABBIndex > -1) then
      begin
        ObjAABB := fAABBs[fObjects[I].AABBIndex];
        if (not fFrustum.IsAABBWithin(ObjAABB)) then Continue;
      end;
    end;
 
    if (fCameraClipping) then
    begin
      if (fObjects[I].AABBIndex > -1) then
      begin
        ObjAABB := fAABBs[fObjects[I].AABBIndex];
        if (not r3d_AABBInAABBIntersection(CameraAABB, ObjAABB)) then Continue;
      end;
    end;
 
    For J := fObjects[I].StartFaceIndex to fObjects[I].EndFaceIndex do
      DrawPolygon(J, I, _Lightmode);
  end;
end;
 

r3d_light.pas

Code:

 
procedure SetTextureStageRGB(param1, op, param2 : Integer);
begin
  glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_COMBINE_EXT);
  glTexEnvi(GL_TEXTURE_ENV,GL_COMBINE_RGB_EXT,op);
 
  glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE0_RGB_EXT,param1);
  glTexEnvi(GL_TEXTURE_ENV,GL_OPERAND0_RGB_EXT,GL_SRC_COLOR);
 
  glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE1_RGB_EXT,param2);
  glTexEnvi(GL_TEXTURE_ENV,GL_OPERAND1_RGB_EXT,GL_SRC_COLOR);
 
  glTexEnvi(GL_TEXTURE_ENV,GL_RGB_SCALE_EXT,1);
end;
 
procedure SetTextureStageAlpha(param1, op, param2 : Integer);
begin
  glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_COMBINE_EXT);
  glTexEnvi(GL_TEXTURE_ENV,GL_COMBINE_ALPHA_ARB,op);
 
  glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE0_ALPHA_ARB,param1);
  glTexEnvi(GL_TEXTURE_ENV,GL_OPERAND0_ALPHA_ARB,GL_SRC_ALPHA);
 
  glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE1_ALPHA_ARB,param2);
  glTexEnvi(GL_TEXTURE_ENV,GL_OPERAND1_ALPHA_ARB,GL_SRC_ALPHA);
 
  glTexEnvi(GL_TEXTURE_ENV,GL_ALPHA_SCALE,1);
end;
 
procedure ResetTextureStage(mode : Integer);
begin
  glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,mode);
  glTexEnvi(GL_TEXTURE_ENV,GL_RGB_SCALE_EXT,1);
  glTexEnvi(GL_TEXTURE_ENV,GL_ALPHA_SCALE,1);
end;
 
procedure TR3DLight.beginAlphaDiffuseIntensity;
begin
  // Nur Alpha Kanal nehmen
  glColorMask(False,False,False,True);
 
  // Alpha Kanal überschreiben
  glBlendFunc(GL_ONE, GL_ZERO);
  glDisable(GL_BLEND);
 
  //active texture 1 (the 1D radial ramp texture)
  gTextureAtt1D.BindMultiTexture(1);
  glDisable(GL_TEXTURE_CUBE_MAP_ARB);
  glDisable(GL_TEXTURE_2D);
 
  //active texture 0 (the 2D radial map texture)
  gTextureAtt2D.BindMultiTexture(0);
 
  glActiveTextureARB(GL_TEXTURE0_ARB);
  SetTextureStageAlpha(GL_PRIMARY_COLOR_EXT,GL_SUBTRACT,GL_TEXTURE);
 
  glActiveTextureARB(GL_TEXTURE1_ARB);
  SetTextureStageAlpha(GL_PREVIOUS_EXT,GL_SUBTRACT,GL_TEXTURE);
end;
 
procedure TR3DLight.processAlphaDiffuseIntensityVertex(const _Vertex : TR3DVector; const _Light : TR3DVector);
var
  texCoords   : TR3DVector;
  versuborig  : TR3DVector;
begin
  //adjust tex coords according to brightness (this could also be moved into the texture matricies)
  versuborig := r3d_VectorSub(_Vertex, Position);
  texCoords := r3d_VectorDiv(versuborig, Radius * 2.0);
  texCoords.Add(0.5);
 
  glMultiTexCoord2fARB(GL_TEXTURE0_ARB, texCoords.x, texCoords.y);
  glMultiTexCoord1fARB(GL_TEXTURE1_ARB, texCoords.z);
  glVertex3fv(@_Vertex);
end;
 
procedure TR3DLight.endAlphaDiffuseIntensity;
begin
  //turn texture unit 1 off
  glActiveTextureARB(GL_TEXTURE1_ARB);
  glDisable(GL_TEXTURE_1D);
  glActiveTextureARB(GL_TEXTURE0_ARB);
 
  glActiveTextureARB(GL_TEXTURE1_ARB);
  ResetTextureStage(GL_MODULATE);
 
  glActiveTextureARB(GL_TEXTURE0_ARB);
  ResetTextureStage(GL_MODULATE);
 
  //remove the write masks
  glColorMask(True,True,True,True);
end;
 
procedure TR3DLight.beginDiffuse;
begin
  glBlendFunc(GL_DST_ALPHA, GL_one);
  glEnable(GL_BLEND);
 
  glActiveTextureARB(GL_TEXTURE1_ARB);
  glDisable(GL_TEXTURE_2D);
 
  glActiveTextureARB(GL_TEXTURE0_ARB);
  glEnable(GL_TEXTURE_2D);
 
  Color.SetColor;
end;
 
procedure TR3DLight.processDiffuseVertex(const _Vertex : TR3DVector; const _Texcoord : TR3DTexcoord);
begin
  glMultiTexCoord2fvARB(GL_TEXTURE0_ARB, @_Texcoord);
  glVertex3fv(@_Vertex);
end;
 
procedure TR3DLight.endDiffuse;
begin
  glActiveTextureARB(GL_TEXTURE0_ARB);
  glColor3f(1,1,1);
end;
 

Damit sollte das verständnis wesentlich klarer sein

TR3DLight ist nen record, gActiveLight ist immer das aktuelle licht was zwischengespeichert wird.

Hier jetzt mal nen paar screens:

So siehts ohne Licht aus (mit Umgebungsfarbe 1,1,1):
Bild

So siehts mit Licht bei mir aus (GeForce 256):
Bild

So siehts mit Licht bei Lars Middendorf aus (ATI Radeon 9800 Pro):
Bild

Ich kann nun nicht verstehen, wieso es bei lars funktioniert und bei mir alles gelb wird obwohl ich keine Nvidia oder ATI spezifischen Extensions benutzt habe

Und das Program selbst gibts hier:
http://www.xenorate.com/Template.zip

Bitte testet es mal bei wem das Licht funktioniert, und bei wem alles gelb ist, postet auch bitte die grafikkarte dazu !

Ich danke schonmal fürs mühselige durchlesen und natürlich für antworten

Mfg,
Final[/b]

Nach oben

Magellan

Betreff des Beitrags:

Verfasst: Do Sep 18, 2003 13:24

DGL Member

Registriert: Di Nov 26, 2002 22:12
Beiträge: 259
Wohnort: Dresden

Also auf meiner Geforce2MX 400 ist ebenfalls alles gelb.
Woran das allerdings liegt, kann ich nicht sagen, da ich mich mit dem Thema noch nicht weiter auseinander gesetzt habe.

_________________
Nichts auf der Welt ist so gerecht verteilt wie der Verstand. Denn jederman ist überzeugt, dass er genug davon habe.
Rene Descartes, frz. Mathematiker u. Philosoph, 1596-1650

Nach oben

Sascha Willems

Betreff des Beitrags:

Verfasst: Do Sep 18, 2003 15:23

DGL Member

Registriert: Mo Sep 23, 2002 19:27
Beiträge: 5812
Programmiersprache: C++

Ich habs grad mal auf meinen beiden Rechnern ausprobiert, und wie zu erwarten war hat auf meiner Radeon9700 alles ohne Probleme funktioniert, während es auf der GeForce4-Ti4400 so aussieht wie auf deiner GeForce256.

Ich hab allerdings noch nie was mit Cubemaps gemacht, weshalb ich nur mal vermuten kann das NVidia-Karten Probleme beim Lookup haben und dir irgendwie nen falschen Wert zurückgeben.
Alternativ könnte dein Problem auch daher rühren, das die NVidia-Karten bestimmte Kombinationsoperationen (von denen du ja reichlich Gebrauch machst) nicht unterstüzten und das Bild deshalb so fehlerhaft aussieht.
Auf mich machts allerdings den Eindruck das ersteres der Fall ist, und du evtl. mal ein kleines Beispiel zusammenschrauben solltest (ohne den Engine-Kram runderum).Das könnt ich dann bei mir zu Hause bequem auf beiden Rechnern testen und auch debuggen.

_________________
www.SaschaWillems.de | GitHub | Twitter | GPU Datenbanken (Vulkan, GL, GLES)

Nach oben

Thunderman

Betreff des Beitrags:

Verfasst: Do Sep 18, 2003 15:25

DGL Member

Registriert: Sa Okt 26, 2002 17:14
Beiträge: 188
Wohnort: Hannover/Lüneburg

Also ich habe eine Radeon 8500, und auf dieser läuft das Programm einwandfrei (etwa 32 FPS).

_________________
Thunderman
Bei schwierigen Problemen entscheiden wir uns einfach für die richtige Lösung. Klar?

Nach oben

Dark Avenger

Betreff des Beitrags:

Verfasst: Do Sep 18, 2003 17:40

DGL Member

Registriert: Sa Aug 30, 2003 22:23
Beiträge: 36
Wohnort: Hamburg

bei mir läufts gar nicht.. bekomm permanent zugriffsverletzungen.

Ich hab aber keine ahnung ob meine kyroII überhaupt die GL_ARB... extrension unterstützt..

_________________
<< Ich werde Ewig leben oder beim Versuch dies zu erreichen, sterben! >>

Nach oben

Finalspace

Betreff des Beitrags:

Verfasst: Fr Sep 19, 2003 09:45

DGL Member

Registriert: Mi Okt 16, 2002 15:06
Beiträge: 1012

Cubemaps werden gar nicht benutzt, das ist es ja.
Es werden für die Lichtintensität nur 1D+2D = 3D Texture benutzt.
Die Cubemap hab ich nur mal vor initialisiert wenn ich später die Normalization Cubemap brauch für Diffuse/Specular Bumpmapping.

Und die Spotlight Cubemap wird auch nicht benutzt, da ich spotlights momentan eh deaktiviert habe.

Das Sample werd ich aber mal schnell machen

matane,
Final

Nach oben

Seite 1 von 1

[ 6 Beiträge ]

Foren-Übersicht » Programmierung » OpenGL

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 7 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.