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

Aktuelle Zeit: Mo Jul 14, 2025 23:56

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


Ein neues Thema erstellen Auf das Thema antworten  Seite 1 von 1
  [ 9 Beiträge ] 
  Vorheriges Thema | Nächstes Thema 
Autor Nachricht
Finalspace
 Betreff des Beitrags:
BeitragVerfasst: Mo Jun 30, 2003 22:07 
Offline
DGL Member

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

ich bin momentan fleissig am engine schreiben, bloss leider sind mir jetzt einige sachen klar geworden die mich nen bissel ärgern.

Hab ja vor kurzem erst ne Statische Lichtberechnung hinbekommen mittels radiosity. Nebenbei zieh ich mir immer gern neue Engine demos die so art doom3 grafik clone sind.

Muss sagen die sehen schon echt gut aus, aber wenn ich mir den source dazu anguck wird mir schlecht... um das ganze zu verstehen müsste man sich erst in 100 cpp files einarbeiten und ich hab echt voll die probleme cpp syntax zu lesen :(

naja egal... auf jedem fall... bin zur erkenntniss gekommen das statische lichtberechnung durch Pixel Shader+Attenuation maps echt für die katz is... und gerade bei Bumpmapping absolut unbrauchbar...

Jetzt ist meine frage, wie fängt man überhaupt damit an... ich hab eine einfache Welt Struktur die auf einer ähnlichen Shaderbasis wie Q3A basiert bloss ohne Scripting :(

Ich hab momentan folgende struktur:

shader:

Code:
  1.  
  2.   TR3DShaderProg = (r3d_shaderprog_none,
  3.                     r3d_shaderprog_mapping,
  4.                     r3d_shaderprog_lightmapping
  5.                     );
  6.  
  7.   TR3DShaderStage = record
  8.     Prog     : TR3DShaderProg;
  9.     Texture  : String[60];
  10.   end;
  11.  
  12.   TR3DShader = record
  13.     ID     : String[60];
  14.     Stages : array of TR3DShaderStage;
  15.   end;
  16.  
  17.   TR3DShaders = array of TR3DShader;
  18.  


world:

Code:
  1.  
  2.   // ************************************************************
  3.   // Ein Vertex, bestehend aus Welt Position, einem Normal vector
  4.   // und einem array aus Texture koordinaten und
  5.   // Lichtmap Texture koordinaten
  6.   // ************************************************************
  7.   TR3DVertex = record
  8.     Position,
  9.     Normal           : TR3DVector;
  10.     Texcoords        : array of TR3DTexcoord;
  11.     LightmapTexcoord : TR3DTexcoord;
  12.     Selected         : Boolean;
  13.     SelectID,
  14.     DisplayList      : Cardinal;
  15.   end;
  16.  
  17.   // ************************************************
  18.   // Daten für Objekt, Rotation, Position, Skalierung
  19.   // FaceIndex Start und Ende
  20.   // ************************************************
  21.   TR3DObject = record
  22.     StartFaceIndex,
  23.     EndFaceIndex : Integer;
  24.     Position,
  25.     Rotation,
  26.     Scale        : TR3DVector;
  27.     Selected     : Boolean;
  28.     SelectID     : Integer;
  29.     DisplayList  : Cardinal;
  30.   end;
  31.  
  32.   // *************************************************************
  33.   // Ein Index für unseren ersten Vertice, end = Index + 2
  34.   // Ein Index für unsere Lightmap
  35.   // Ein Name für unseren Shader
  36.   // *************************************************************
  37.   TR3DFace = record
  38.     VerticeIndex,
  39.     LightmapIndex : Integer;
  40.     ShaderID      : String;
  41.     Selected      : Boolean;
  42.     SelectID      : Integer;
  43.     DisplayList   : Cardinal;
  44.   end;
  45.  
  46.   // ******************
  47.   // Unsere Welt Klasse
  48.   // ******************
  49.   TR3DWorld = class(TObject)
  50.   private
  51.     fSelectMode   : TR3DSelectMode;
  52.     fShaders      : array of TR3DShader;      // Shaders
  53.     fVertices     : array of TR3DVertex;      // Vertices (Vectors)
  54.     fFaces        : array of TR3DFace;        // Faces
  55.     fObjects      : array of TR3DObject;      // Objekte
  56.     fLightmaps    : array of TR3DTexture;     // Lightmaps (Nur Texturen)
  57.     fTextures     : TR3DTextureManager;       // Texture Library
  58.     fStaticLights : array of TR3DStaticLight; // Statische Lichtquellen
  59.  


Procedure zum rendern eines Faces:

Code:
  1.  
  2. procedure TR3DWorld.RenderFace(const _Index : Integer; const _Obj : TR3DObject);
  3. var
  4.   I,
  5.   J,
  6.   Pass          : Integer;
  7.   Vec, Nrm      : TR3DVector;
  8.   Polygon       : TR3DPolygon;
  9.   PolygonCoords : TR3DPolygonTexcoord;
  10.   Face          : TR3DFace;
  11.   Shader        : TR3DShader;
  12.   TextureIndex,
  13.   VerticeIndex,
  14.   ShaderIndex   : Integer;
  15.   LastTexIdx,
  16.   TexIDX        : Integer;
  17.   Texcoord      : TR3DTexcoord;
  18. begin
  19.   Face := fFaces[_Index];
  20.   ShaderIndex := IndexOfShaders(Face.ShaderID);
  21.   r3d_ClearShader(Shader);
  22.  &nbsp;if (ShaderIndex <> -1) then Shader := fShaders[ShaderIndex];
  23.  
  24.  &nbsp;glPushMatrix;
  25.  
  26.  &nbsp; &nbsp;// Erstmal komplett Texturen abschalten
  27.  &nbsp; &nbsp;r3d_DisableMultiTexturing;
  28.  
  29.  &nbsp; &nbsp;// Pass 1, Normale Texturen zu erst rendern
  30.  &nbsp; &nbsp;Pass := 0;
  31.  &nbsp; &nbsp;For J := 0 to High(Shader.Stages) do
  32.  &nbsp; &nbsp;begin
  33.  &nbsp; &nbsp; &nbsp;// Prüfen ob Texture überhaupt existiert
  34.  &nbsp; &nbsp; &nbsp;TextureIndex := fTextures.IndexOf(Shader.Stages[J].Texture);
  35.  &nbsp; &nbsp; &nbsp;if (TextureIndex <> -1) then
  36.  &nbsp; &nbsp; &nbsp;begin
  37.  
  38.  &nbsp; &nbsp; &nbsp; &nbsp;// Normale Texturen als Shader Programm nehmen
  39.  &nbsp; &nbsp; &nbsp; &nbsp;case Shader.Stages[J].Prog of
  40.  &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;r3d_shaderprog_mapping:
  41.  &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;begin
  42.  &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;fTextures.Textures[TextureIndex].BindMultiTexture(Pass);
  43.  &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;inc(Pass);
  44.  &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;end;
  45.  &nbsp; &nbsp; &nbsp; &nbsp;end;
  46.  
  47.  &nbsp; &nbsp; &nbsp;end;
  48.  &nbsp; &nbsp;end;
  49.  
  50.  &nbsp; &nbsp;// Pass 2, Lightmap Texturen
  51.  &nbsp; &nbsp;For J := 0 to High(Shader.Stages) do
  52.  &nbsp; &nbsp;begin
  53.  &nbsp; &nbsp; &nbsp;// Normale Texturen als Shader Programm nehmen
  54.  &nbsp; &nbsp; &nbsp;case Shader.Stages[J].Prog of
  55.  &nbsp; &nbsp; &nbsp; &nbsp;r3d_shaderprog_lightmapping:
  56.  &nbsp; &nbsp; &nbsp; &nbsp;begin
  57.  &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;if (Face.LightmapIndex > -1) and (Face.LightmapIndex < Length(fLightmaps)) then
  58.  &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;begin
  59.  &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;fLightmaps[Face.LightmapIndex].BindMultiTexture(Pass);
  60.  &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;inc(Pass);
  61.  &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;end;
  62.  &nbsp; &nbsp; &nbsp; &nbsp;end;
  63.  &nbsp; &nbsp; &nbsp;end;
  64.  &nbsp; &nbsp;end;
  65.  
  66.  &nbsp; &nbsp;// Ersten Normal Vector holen
  67.  &nbsp; &nbsp;Nrm := fVertices[Face.VerticeIndex].Normal;
  68.  &nbsp; &nbsp;Nrm.SetNormal;
  69.  
  70.  &nbsp; &nbsp;// Kein Shader gefunden, also notfound Texture anzeigen
  71.  &nbsp; &nbsp;if (ShaderIndex = -1) or (Pass = 0) then
  72.  &nbsp; &nbsp;begin
  73.  &nbsp; &nbsp; &nbsp;VerticeIndex := 0;
  74.  &nbsp; &nbsp; &nbsp;For I := Face.VerticeIndex to Face.VerticeIndex + 2 do
  75.  &nbsp; &nbsp; &nbsp;begin
  76.  &nbsp; &nbsp; &nbsp; &nbsp;Vec.Assign(fVertices[I].Position);
  77.  &nbsp; &nbsp; &nbsp; &nbsp;Polygon.Vecs[VerticeIndex].Assign(Vec);
  78.  &nbsp; &nbsp; &nbsp; &nbsp;Inc(VerticeIndex);
  79.  &nbsp; &nbsp; &nbsp;end;
  80.  &nbsp; &nbsp; &nbsp;PolygonCoords := r3d_CalculateTexcoord(Polygon,
  81.  &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; Nrm,
  82.  &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; 0,
  83.  &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; False,
  84.  &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; False,
  85.  &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; 1,
  86.  &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; 1
  87.  &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; );
  88.  
  89.  &nbsp; &nbsp; &nbsp;TexIDX := fTextures.IndexOf('common&#092;shadernotfound');
  90.  &nbsp; &nbsp; &nbsp;if TexIDX <> -1 then
  91.  &nbsp; &nbsp; &nbsp; &nbsp;fTextures.Textures[TexIDX].BindMultiTexture(Pass);
  92.  &nbsp; &nbsp;end;
  93.  
  94.  
  95.  &nbsp; &nbsp;glColor3f(1.0,1.0,1.0);
  96.  &nbsp; &nbsp;glBegin(GL_TRIANGLE_STRIP);
  97.  &nbsp; &nbsp; &nbsp;VerticeIndex := 0;
  98.  &nbsp; &nbsp; &nbsp;For I := Face.VerticeIndex to Face.VerticeIndex + 2 do
  99.  &nbsp; &nbsp; &nbsp;begin
  100.  
  101.  &nbsp; &nbsp; &nbsp; &nbsp;// Normale Texturen
  102.  &nbsp; &nbsp; &nbsp; &nbsp;LastTexIdx := 0;
  103.  &nbsp; &nbsp; &nbsp; &nbsp;For J := 0 to High(fVertices[I].Texcoords) do
  104.  &nbsp; &nbsp; &nbsp; &nbsp;begin
  105.  &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;Texcoord.Assign(fVertices[I].Texcoords[J]);
  106.  &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;Texcoord.SetMultiTexcoord(J);
  107.  &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;Inc(LastTexIdx);
  108.  &nbsp; &nbsp; &nbsp; &nbsp;end;
  109.  
  110.  &nbsp; &nbsp; &nbsp; &nbsp;// Kein Shader gefunden, dann Texture Koordinaten generieren
  111.  &nbsp; &nbsp; &nbsp; &nbsp;if (ShaderIndex = -1) or (Pass = 0) then
  112.  &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;PolygonCoords[VerticeIndex].SetMultiTexcoord(Pass);
  113.  
  114.  &nbsp; &nbsp; &nbsp; &nbsp;// Lightmap Texture Koordinante (Immer als letztes)
  115.  &nbsp; &nbsp; &nbsp; &nbsp;if r3d_IsProgInShader(r3d_shaderprog_lightmapping, Shader) then
  116.  &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;fVertices[I].LightmapTexcoord.SetMultiTexcoord(LastTexIdx);
  117.  
  118.  &nbsp; &nbsp; &nbsp; &nbsp;// Vector daten
  119.  &nbsp; &nbsp; &nbsp; &nbsp;Vec.Assign(fVertices[I].Position);
  120.  
  121.  &nbsp; &nbsp; &nbsp; &nbsp;// Transformieren
  122.  &nbsp; &nbsp; &nbsp; &nbsp;Vec.Rotate(_Obj.Rotation);
  123.  &nbsp; &nbsp; &nbsp; &nbsp;Vec.Multiply(_Obj.Scale);
  124.  &nbsp; &nbsp; &nbsp; &nbsp;Vec.Add(_Obj.Position);
  125.  
  126.  &nbsp; &nbsp; &nbsp; &nbsp;Vec.SetVertex;
  127.  &nbsp; &nbsp; &nbsp; &nbsp;Inc(VerticeIndex);
  128.  &nbsp; &nbsp; &nbsp;end;
  129.  &nbsp; &nbsp;glEnd;
  130.  
  131.  &nbsp;glPopMatrix;
  132. end;
  133.  


Ich nehme mal an für Reales Pixelshader Bumpmapping kann ich wohl meine Lightmaps in de tonne kippen :(
Wie fang ich jetzt am besten damit an ? Ich hab überhaupt kein peil wie ich überhaupt anfang, am liebsten wäre es mir mit einer technik anzufangen die man fürs Bumpmapping braucht... z.b. dynamische lichter, dies und das.... cube maps brauch man ja wie ich in vielen engine sources gesehen habe...
Ich will wirklich jetzt erstmal klein anfangen... und ein einfachen würfel mit guten Vertice Werten sollte für den Anfang ausreichen um das alles zu verstehen.


So, dat wars... hoffe ma irgendjemand hat das gelesen... wenn ja, thx ;)
eigentlich sollte das ne PM für lars werden aber da ich glaube das andere DGL´ler auch was lernen wollen hab ichs halt in Allgemein gepostet.



matane,
Final
Nach oben
 Profil  
Mit Zitat antworten  
LarsMiddendorf
 Betreff des Beitrags:
BeitragVerfasst: Di Jul 01, 2003 15:52 
Offline
DGL Member
Benutzeravatar

Registriert: Sa Dez 28, 2002 11:13
Beiträge: 2244
Ich würde zuerst mal nur mit dynamischem Licht ohne Bumpmapping anfangen. Das kann auch schon gut aussehen.

Dazu würde ich die Shader zuerst mal vereinfachen:
Code:
  1.  
  2. TR3DShader = record
  3.    ID     : String[60];
  4.    Basis:TR3DShaderStage;
  5.    Diffuse:TR3DShaderStage;
  6.  end;
  7.  

Nacher kann man ja dann die Variablen immer noch durch Arrays ersetzen.

Die Basistexture entspricht dann dem GL_EMISSION Parameter und ist die Grundhelligkeit einer Fläche ohne irgendein Licht. Die meisten Flächen werden hier vermutlich keine Texture angegeben haben und deshalb schwarz gezeichnet werden.
Die diffuse Texture ist die normale Texture einer Fläche und wird vom Licht beinflußt. Zum Anfang kann man sich auf die Lichtintensität beschränken. Die Helligkeit hängt also nur von der Entfernung von der Lichtquelle ab.

Zuerst zeichnet man die ganze sichtbare Szene mit der Basistexture oder eben in schwarz.
Danach stellt man additives Blending ein und addiert alle Lichter nacheinander auf die Szene auf. Auf Radeon Karten sollte man nie gl_equal verwenden, weil dieser Modus nicht mit dem hierachischen ZBuffer der Karte zusammenarbeitet. Deshalb ist gl_lequal besser.

1. GF3/4
Man erstellt sich eine 3D Texture, die in der Mitte ganz weiß ist und zu dem Rand hin immer dunkler wird. Diese 3D Texture kann für alle Lichter verwendet werden und braucht nur einmal erstellt zu werden. Diese Texture wird einfach mit der diffusen Texture aus dem Shader multipliziert.
Dabei stellt man die 3D Texturekoordinaten folgendermaßen ein:
r=(Vertex.x-Licht.x)/LichtIntensität+0.5
t=(Vertex.y-Licht.y)/LichtIntensität+0.5
s=(Vertex.z-Licht.z)/LichtIntensität+0.5

Man kann mit den TextureEnv Funktionen auch noch einstellen, daß das ganze auch noch mit der Lichtfarbe multipliziert wird.

2.GFFX/Radeon 9500+
Die Lichtintensität kann man im Fragment Program direkt berechen. Dazu übergibt man im Vertex Program den Vektor vom Vertex zum Licht als Texturekoordinate. invLightSize ist der Kehrwert der Lichtintensität und ein lokaler Parameter. Da Skalarprodukt quadriert die Entfernung und mit dem ADD Befehl wird sie dann von 1 abgezogen.

Code:
  1.  
  2. MUL temp,fragment.texcoord[1],,invlightsize;
  3. DP3 temp,temp,temp;
  4. ADD temp,1.0,-temp;
  5. TEX diffuse,fragment.texcoord[0],texture[0], 2D;
  6. MUL temp,temp,lightcolor;
  7. MUL fragment.color,diffuse,temp;
  8.  


Da im Fragmentprogram jeder Farbkanal auf der Radeon 24 Bit hat, wird das sehr viel genauer berechnet, als mit einer 3D Texture.
Das der temp Wert auch negativ werden kann, stört hier nicht, weil der Farbwert bei der Ausgabe auf 0..1 begrenzt wird. Darauf sollte man aber achten, wenn man z.B. in einen PBuffer rendert, oder das Ergebnis noch weiter verwenden möchte.

Die Lichtberechnung mit 1-(Entfernung zum Quadrat) ist deshalb notwendig, weil man sichergehen muß, daß die Lichthelligkeit irgendwann man 0 erreicht, damit man das Licht auf einen Berecih begrenzen kann. Würde man die eigentlich bessere Gleichung Helligkeit=1/(Entfernung zum Quadrat) nehmen, wäre das nie der Fall.

Humus hat auf seiner Seite ein sehr gutes Tutorial zur Lichtberechnung mit Hilfe von Vertex und Fragment Shadern als PDF Dokument. Leider für D3D, er hat aber auch viele Beispiele mit OpenGL. Da sich die Vertex/Fragment Shader und Programme aber nicht so viel unterscheiden, ist das trotzdem sehr hilfreich.
<a href='http://esprit.campus.luth.se/~humus/' target='_blank'>http://esprit.campus.luth.se/~humus/</a>
Nach oben
 Profil  
Mit Zitat antworten  
Finalspace
 Betreff des Beitrags:
BeitragVerfasst: Di Jul 01, 2003 16:12 
Offline
DGL Member

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

also damit die mal nen bild verschaffen kannst wies überhaupt steht:
Läuft sogar hier im geschäft auf ner Voodoo3 ;)

<a href='http://encorex.no-ip.com/hosted_sites/radical3d/?page=download&did=12' target='_blank'>radical3D Game Template 0.09 Alpha</a>

und hier nen screenshot:

<a href='http://encorex.no-ip.com/hosted_sites/radical3d/shared/graphics/pictures/in/radical3d_0.09alpha_game_template.jpg' target='_blank'>Bild</a>

Also Dynamische Lichter OK... wäre nen anfang... am liebsten wären mir solche lichter wie das licht von der "Humus Game Engine". Aber bitte nix mit Fragment Shader, da ich immer nur noch ne GeForce 4 Ti 4200 habe . Hardware mässig will ich ab GeForce 3 Beginnen.

Also das Array für die Shaderstages hab ich ja dafür das ich theoretisch unlimitiert Texturen über ein face legen kann. Nicht jedes Face brauch Bumpmapping, Lightmapping und das ganze zeugs... Deswegen hab ich ja das so gemacht... wenn ich dann Diffuse reinsetzen will... würd ich einfach das Program erweitern...
und dann prüfen beim rendern ob nen Diffuse vorhanden ist... usw.

saug dir am besten mal das template und spiel am nen bissel damit rum... hab sogar ne Docu geschrieben für :D

matane,
Final
Nach oben
 Profil  
Mit Zitat antworten  
LarsMiddendorf
 Betreff des Beitrags:
BeitragVerfasst: Di Jul 01, 2003 17:10 
Offline
DGL Member
Benutzeravatar

Registriert: Sa Dez 28, 2002 11:13
Beiträge: 2244
Ich würde auf jeden Fall die Beleuchtung einheitlich machen. Denn wie soll eine Fläche dann beleuchtet werden, wenn nicht durch Bumpmapping? Das fällt auf jeden Fall auf und sieht nicht gut aus. Bei der GF4 ist es am besten die Methode mit der 3D Texture zu verwenden. Das Problem ist, daß sich das nicht so ohne weiteres in verschiedene Renderschritte unterteilen läßt. Für das diffuse Bumpmapping werden die diffuse Texture und die Bumpmap/Normalmap in einem Schritt benötigt. Für das specular Bumpmapping entsprechend die specular Texture und die Bumpmap.
Das heißt eine Texture wird für mehrere Renderschritte benötigt und umgekehrt.

EinShader könnte dann z.B. so aussehen.

Code:
  1.  
  2. {
  3.  &nbsp;// Daten
  4.  &nbsp;id ("base&#092;wall")
  5.  &nbsp;{
  6.  &nbsp; &nbsp;program ("bumpmapping")
  7.  &nbsp; &nbsp;texture ("base&#092;wall")
  8.  &nbsp; &nbsp;normalmap("base&#092;wall_n")
  9.  &nbsp; &nbsp;specularmap("base&#092;wall_s")
  10.  &nbsp;}
  11. }
  12.  
Nach oben
 Profil  
Mit Zitat antworten  
lithander
 Betreff des Beitrags:
BeitragVerfasst: Di Jul 01, 2003 19:27 
Offline
DGL Member
Benutzeravatar

Registriert: Mo Mai 06, 2002 20:27
Beiträge: 479
Wohnort: Bremen
Lars, deine Ausführungen über das dynamisch Lightning waren sehr interessant. Das einzige, was ich mich frage ist allerdings ob es nicht auch für GF3 u GF4 ne möglichkeit gibt das mit Pixelshadern zu machen. Immerhin haben die doch auch welche, oder?

Und was ist mit den Karten ohne Shader? Gf2 z.B. wie bekommt man da Licht in die Szene?

_________________
Selber Denken macht klug!
Nach oben
 Profil  
Mit Zitat antworten  
Finalspace
 Betreff des Beitrags:
BeitragVerfasst: Di Jul 01, 2003 20:21 
Offline
DGL Member

Registriert: Mi Okt 16, 2002 15:06
Beiträge: 1012
Also hatte gerade ne längere Diskusion mit einem Kolleg von mir bei dem ich die ganze zeit hocke.
Wir hattens von 3D Engines da ich ja momentan ne Engine schreibe... und er meinte die sollte später auch auf ältere rechner TNT2-Voodoo3 laufen aber auch heutige Grafik Standards nutzen... also auch Pixel Shader/Bumpmapping usw.

Dann hab ich ihm versucht zu erklären welche technicken es für verschiedene Grafische dingen gibt, wobei ich selbst gemerkt habe das ich überhaupt keine ahnung habe.
Jetzt kommt meine frage:

Was für Technicken gibt es für folgende Grafische dinge:

- Schatten
- Licht
- Partikel
- Flüssigkeiten
- Specialeffekte (Bumpmapping, Environmentmapping, Lensflare) usw.

Was für Weltformate:

- BSP ?
- Octree ?
- Terrain ?
- Mischung aus den allen ?
- Eigenes ?



Danke,
Final
Nach oben
 Profil  
Mit Zitat antworten  
LarsMiddendorf
 Betreff des Beitrags:
BeitragVerfasst: Di Jul 01, 2003 20:24 
Offline
DGL Member
Benutzeravatar

Registriert: Sa Dez 28, 2002 11:13
Beiträge: 2244
Bei GF1 und GF2 Karten kann man die Lichtintensität durch 2 Texturen berechnen.
In der 3D Texture steht für XYZ: 1-(x^2+y^2+z^2)
Die erste Texture liefert x^2+y^2 und die zweite z^2 zurück. Mit den Register Combinern kann man die Summe noch von 1 abziehen und hat dann das gleiche Ergebnis.
Nach oben
 Profil  
Mit Zitat antworten  
Sascha Willems
 Betreff des Beitrags:
BeitragVerfasst: Di Jul 01, 2003 21:09 
Offline
DGL Member
Benutzeravatar

Registriert: Mo Sep 23, 2002 19:27
Beiträge: 5812
Programmiersprache: C++
Alle Techniken kann ich natürlich nicht aufzählen, da es ja jede Menge verschiedenster Techniken für die von dir aufgelisteten Dinge gibt, aber ich tu mal mein Bestes :

- Schatten
- Statische Shadowmaps (in die statischen Lightmaps mit hinein berechnet)
- Projezierte Shadowmaps (dynamisch, z.B. für bewegliche Objekte wie Spieler, siehe auch projektives Texturemapping)
- Harte Schatten via Stencilpuffer (siehe DOOMIII)
Hier würde ich mich (momentan) auf jeden Fall für Variante 2 zusammen mit Variante 1 entscheiden, da Stencilschatten sehr füllratenintensiv sind, und auch hart sind.Weiche Kanten erfordern sehr viele Renderpässe und sind auf momentaner Hardware ein Luxus.

- Licht
- OpenGLs Beleuchtungsmethoden (alt, einfach, primitiv)
- Statische Lightmaps (Vorberechnet)
- Dynamische Lightmaps (Rechenintensiv, siehe Render-To-Texture)
- Per-Pixel (auf Karten ab GF3 mittels Fragmentshader (unter D3D heissen die Pixelshader), mit GF2 und GF1 mittels Texture-Combiner (auch Per-Pixel)
- Per-Vertex (via Vertexprogramm, allerdings kaum besser als OpenGLs Standard-Beleuchtung)
Mein Favorit ist hier ne Kombination aus Nummer 2 und Nummer 3.Dynamisches Licht sollte man immer nur dann verwenden, wenn man es auch mit dynamischen Objekten zu tun hat.

- Partikel
Hier gibts ja eigentlich keine Techniken, mal abgesehen von der Physik die du in dein Partikelsystem einbinden musst.Einzige hier verwendete Technik ist dann jawohl das Billboarding.Auf GF-Karten die Pointsprites unterstützen, kannst du diese auch zur Vereinfachung nutzen.

- Flüssigkeiten
Das ist ein sehr sehr komplexes Gebiet, das sehr viel mathematische Kenntnisse voraussetzt.Fourier und Co. sollten hier gute Ansätze liefern.

- Specialeffekte (Bumpmapping, Environmentmapping, Lensflare) usw.
Auch hier iss mir irgendwie nicht klar was du mit "Techniken" meinst.Hier gibts allerhöchstens verschiedene Implementationsmöglichkeiten.Beim Bumpmapping wären das z.B. DOT3, Emboss und EMBM.


Zitat:
Was für Weltformate:

- BSP ?
- Octree ?
- Terrain ?
- Mischung aus den allen ?
- Eigenes ?

Die Dinge passen weder zusammen (Terrain, BSP) in eine Gruppe, noch stellen sie irgendwelche "Weltformate" dar.BSP und Octree (und Portale) sind z.B. keine Weltformate, sondern mehr oder weniger intelligente Raumunterteilungstechniken, deren Technik ja bereits durch ihre Bezeichnung vorgegeben wird (BSP = Binary Space Partitioning).
Zum Thema Terrain gibst ja dutzende (oder noch mehr) verschiedene Techniken, z.B. ROAM, CLOD, Geo-MipMapping, Roettger, usw...

_________________
www.SaschaWillems.de | GitHub | Twitter | GPU Datenbanken (Vulkan, GL, GLES)
Nach oben
 Profil  
Mit Zitat antworten  
LarsMiddendorf
 Betreff des Beitrags:
BeitragVerfasst: Di Jul 01, 2003 21:14 
Offline
DGL Member
Benutzeravatar

Registriert: Sa Dez 28, 2002 11:13
Beiträge: 2244
Die FAQ des "graphics programming and theory forum" von gamedev.net hat eine gute Übersicht über all diese Techniken.

<a href='http://www.gamedev.net/community/forums/showfaq.asp?forum_id=12' target='_blank'>http://www.gamedev.net/community/forums/sh...asp?forum_id=12</a>
Nach oben
 Profil  
Mit Zitat antworten  
Beiträge der letzten Zeit anzeigen:  Sortiere nach  
Ein neues Thema erstellen Auf das Thema antworten  Seite 1 von 1
  [ 9 Beiträge ] 
Foren-Übersicht » Programmierung » Allgemein


Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 9 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:  
cron
  Powered by phpBB® Forum Software © phpBB Group
Deutsche Übersetzung durch phpBB.de
[ Time : 0.010s | 15 Queries | GZIP : On ]