DGL Wiki - Benutzerbeiträge [de]

Team

2012-01-11T14:36:34Z

Skeptiker: Impressum Link war tot

= Vorwort =

Auf dieser Seite befindet sich eine Auflistung der Personen, die momentan aktiv daran arbeiten, dass DGL Euch wie gewohnt im Netz mit Informationen versorgt. Bitte beachtet, dass die meisten der Personen nur einen begrenzten Vorrat an Zeit haben. Überlegt daher bitte sorgsam, an wen Ihr Euch wendet.

Im unteren Teil dieser Seite sind die verschiedenen Bereiche von DGL und deren Betreuer aufgelistet. Bitte wendet auch an den passenden Ansprechpartner.

Diese Seite ersetzt nicht das '''[http://www.delphigl.com/impressum.php IMPRESSUM]'''.

= Das Team im Ganzen =
In diesen Abschnitt ist aufgelistet '''wer''' bei [[DelphiGL]] Verantwortung für einen Teil übernommen hat, und '''was''' genau er macht.
== Moderatoren ==
<div align="center">
{|{{Prettytable_B1}} width="80%"
!width="20%"|Forumsname
!width="30%"|Email
!width="50%"|Aufgabenbereich
|-
|[[Benutzer:Phobeus|Phobeus]]
|{{eMail|Phobeus|delphigl.com}}
|
*Technische Pflege des Wikis (Wartung/Updates)
*Betreuung der Hardware
*Freischalten von Usern für das Forum
*Freischalten von Usern für das Wiki
*''News eintragen''
*''allgemeine inhaltliche Kontrolle''
*"der Boss"
|-
|[[Benutzer:Flash|Flash]]
|{{eMail|Flash|delphigl.com}}
|
*Inhaltliche Pflege/Koordination des Wikis
*Community-Aktionen
*Tutorial Lektor
*DGL-Poll pflegen
*News eintragen
*allgemeine inhaltliche Kontrolle im Forum
|-
|[[Benutzer:Frase|Frase]]
|{{eMail|Frase|delphigl.com}}
|
*Technische Unterstützung für Phobeus
*Tutorial Lektor
*News eintragen
*allgemeine inhaltliche Kontrolle im Forum
|-
|[[Benutzer:Delphic|Delphic]]
|{{eMail|delphic|delphigl.com}}
|
*Freischalten von Usern für das Forum
*News eintragen
*allgemeine inhaltliche Kontrolle
|-
|[[Benutzer:Flo|Flo]]
|{{eMail|Flo|DelphiGL.com}}
|
*DGL-Wiki-Bot Manager
*Freischalten von Usern für das Wiki
*Tutorial Lektor
*News eintragen
*allgemeine inhaltliche Kontrolle
|-
|[[Benutzer:I0n0s|i0n0s]]
|{{eMail|i0n0s|DelphiGL.com}}
|
* DGLSDK
* Freischalten von Usern für das Forum
* Freischalten von Usern für das Wiki
* Tutorial Lektor
* News eintragen
* allgemeine inhaltliche Kontrolle
|-
|[[Benutzer:Sascha Willems|Sascha Willems]]
|{{eMail|webmaster|delphigl.de}}
|
*News eintragen
*allgemeine inhaltliche Kontrolle
*Freischalten von Usern für das Wiki
|-
|[[Benutzer:Lord_Horazont|Lord Horazont]]
|{{eMail|lord_horazont|DelphiGL.com}}
|
*SVN/WebSVN Betreuung
*News eintragen
*allgemeine inhaltliche Kontrolle
*Freischalten von Usern für das Forum
*Freischalten von Usern für das Wiki
|-
|}
</div>

= Gruppen =
In diesem Teil findet ihr detailierte Informationen, wer für welchen Bereich zuständig ist.
== DGLSDK ==
<div align="center">
{|{{Prettytable_B1}} width="80%"
!width="20%"|Forumsname
!width="30%"|Email
!width="50%"|Aufgabenbereich
|-
|[[Benutzer:I0n0s|i0n0s]]
|{{eMail|i0n0s|DelphiGL.com}}
|
|-
|}
</div>

== DGLOpenGL.pas ==
<div align="center">
{|{{Prettytable_B1}} width="80%"
!width="20%"|Forumsname
!width="30%"|Email
!width="50%"|Aufgabenbereich
|-
|[[Benutzer:Sascha Willems|Sascha Willems]]
|{{eMail|webmaster|delphigl.de}}
|
*Weiterentwicklung, Debugging
|-
|}
</div>

== Webseite ==
<div align="center">
{|{{Prettytable_B1}} width="80%"
!width="20%"|Forumsname
!width="30%"|Email
!width="50%"|Aufgabenbereich
|-
|[[Benutzer:Phobeus|Phobeus]]
|{{eMail|Phobeus|delphigl.com}}
|
*Technische Pflege der Seite (Wartung/Updates)
*Coding (Integrieren von Neuerungen)
|-
|[[Benutzer:Lord_Horazont|Lord Horazont]]
|{{eMail|lord_horazont|DelphiGL.com}}
|
*PHP
|-
|[[Benutzer:Flash|Flash]]
|{{eMail|Flash|delphigl.com}}
|
*DGL-Poll pflegen
|-
|Alle Anderen
|(siehe oben)
|
*News
*Sorgen für angemessene Umgangsformen
|-
|}
</div>

== Wiki ==
<div align="center">
{|{{Prettytable_B1}} width="80%"
!width="20%"|Forumsname
!width="30%"|Email
!width="50%"|Aufgabenbereich
|-
|[[Benutzer:Flash|Flash]]
|{{eMail|Flash|delphigl.com}}
|
*Inhaltliche Pflege des Wikis
*Koordinierung
|-
|[[Benutzer:Phobeus|Phobeus]]
|{{eMail|Phobeus|delphigl.com}}
|
*Technische Pflege des Wikis (Wartung/Updates)
*Betreuung der Hardware
|-
|[[Benutzer:I0n0s|i0n0s]]
|{{eMail|i0n0s|DelphiGL.com}}
|
*Filesektion
|-
|[[Benutzer:Lord_Horazont|Lord Horazont]]
|{{eMail|lord_horazont|DelphiGL.com}}
|
*Filesektion (SVN Betreuung)
|-
|}

Diskussion:VBO ohne glInterleavedArrays

2010-03-25T23:13:01Z

Skeptiker: Die Seite wurde neu angelegt: „Ich bin jetzt ein wenig verwirrt, ich hatte hier (http://delphigl.com/forum/viewtopic.php?f=2&t=8880) gefragt, ob VBOs die einzige Möglichkeit seien in OpenGL 3.…“

Ich bin jetzt ein wenig verwirrt, ich hatte hier (http://delphigl.com/forum/viewtopic.php?f=2&t=8880) gefragt, ob VBOs die einzige Möglichkeit seien in OpenGL 3.x geringe Geometriedaten an die Grafikkarte zu schicken, die Antwort war, dass es auch über Vertex Arrays geht. Somit wäre die Aussage das VBOs die einzige Möglichkeit sind falsch. --[[Benutzer:Skeptiker|Skeptiker]] 00:13, 26. Mär. 2010 (CET)

Diskussion:shader blur2

2009-12-23T23:43:51Z

Skeptiker:

Da an dem anderen Blur Shader scheinbar seit Ewigkeiten nichtsmehr gemacht wird hab ich einfach mal diesen hier erstellt.
Fragen, Anregungen, Verbesserungsvorschläge? --[[Benutzer:Skeptiker|Skeptiker]] 22:25, 22. Dez. 2009 (CET)
:Der Shader ist sehr gut, bei meinem Vorschlag [http://www.delphigl.com/forum/viewtopic.php?f=20&p=76150 in diesem Thread] habe ich nämlich nicht berücksichtigt, dass die Convolution-Operation kommutativ und assoziativ ist. Der Gauss-Filter ist deshalb nämlich separierbar. Wenn man Rundungsfehler vernachlässigt spielt es beim Ergebnis keine Rolle, ob man einen 2D-Gauss anwendet oder die Operation zweimal mit einem horizontalen bzw. vertikalen 1D-Gauss durchführt. Die zweite Variante spart aber eine große Menge an Texturzugriffen. In diesem Fall 7*7=49 Zugriffe beim 2D-Gauss gegen 2*7=14 Texturzugriffe beim zweimaligen 1D-Gauss. Das macht um so mehr aus, je größer der Filter ist. Eigentlich sollte ich solche Dinge besser wissen.<br />Ok, was zu meckern habe ich natürlich auch ;)
:* Du musst die Ränder der Textur in irgendeiner Form korrekt behandeln. Das kann beispielsweise dadurch geschehen das man <tt>GL_TEXTURE_WRAP_*</tt> auf <tt>GL_CLAMP_TO_EDGE</tt> oder <tt>GL_CLAMP_TO_BORDER</tt> setzt. Sollte man vielleicht erwähnen.
:* Das Array gaussFilter sollte <tt>const</tt> sein, ich bin mir nicht sicher ob der Shader-Compiler so schlau ist selbst zu bemerken, dass er nur einmal Speicher reservieren muss.
:* Ansonsten kann man, wie du schon selbst sagst, an der Fallunterscheidung natürlich noch etwas feilen, aber dann wäre der Shader wahrscheinlich nicht mehr so leicht zu lesen.
:--[[Benutzer:Coolcat|Coolcat]] 11:06, 23. Dez. 2009 (CET)

:Sollte es nicht <tt>float(i - 3)</tt> sein? Der Index i läuft von 0 bis 6, damit läuft i-4 von -4 bis 2. Oder habe ich gerade nen Knoten drin? --[[Benutzer:Coolcat|Coolcat]] 15:56, 23. Dez. 2009 (CET)

:Du hast mit allem recht ;-). Ich mach mich nachher ran und füge das noch mit in die Beschreibung ein. Und jau, es sollte durchaus i - 3 und nicht i - 4 heißen ;-). --[[Benutzer:Skeptiker|Skeptiker]] 16:40, 23. Dez. 2009 (CET)

:Ok, meine optimierte Variante die ich für UC übernommen habe sieht nun wie folgt aus. Ich habe die Fallunterscheidung entfernt und durch die Uniform <tt>uShift</tt> ersetzt. Da die GPU Vektoraddition im Schlaf beherrscht sollte das die beste Lösung sein. Insbesondere ist die Texturgröße darin gleich integriert. Für einen horizontalen Filter setzt man also <tt>uShift</tt> auf <tt>vec2(1.0/textureWidth, 0.0)</tt>. Um bei gleicher Geschwindigkeit den Filter zu verstärken kann auch so etwas wie <tt>1.6/textureWidth</tt> versuchen. Auf diese Weise sind natürlich auch diagonale Filter möglich. Außerdem habe ich die Gauss-Funktion (im Array) vergrößert und stärker abgeschnitten. Texel die nur zu einem 64stel in die Berechnung eingehen lohnen den Aufwand nicht wirklich.
<source lang="glsl">uniform sampler2D uScene;
uniform vec2 uShift;

varying vec2 vTexCoord;

const int gaussRadius = 11;
const float gaussFilter[gaussRadius] = float[gaussRadius](
0.0402,0.0623,0.0877,0.1120,0.1297,0.1362,0.1297,0.1120,0.0877,0.0623,0.0402
);

void main() {
vec2 texCoord = vTexCoord - float(int(gaussRadius/2)) * uShift;
vec3 color = vec3(0.0, 0.0, 0.0);
for (int i=0; i<gaussRadius; ++i) {
color += gaussFilter[i] * texture2D(uScene, texCoord).xyz;
texCoord += uShift;
}
gl_FragColor = vec4(color,1.0);
}</source>
: --[[Benutzer:Coolcat|Coolcat]] 19:18, 23. Dez. 2009 (CET)

:Sieht gut aus, habs für mich auch direkt mal so übernommen. Wäre vermutlich auch Sinnvoll, wenn du die Version mit in den Artikel schreibst, damit es nicht auf der Diskussionsseite untergeht (oder den alten Shader gleich komplett ersetzt - wie auch immer es sinnvoller ist). --[[Benutzer:Skeptiker|Skeptiker]] 00:43, 24. Dez. 2009 (CET)

shader blur2

2009-12-23T23:33:49Z

Skeptiker: Verhalten an Rändern eingefügt, Array konstant gemacht.

=Blur=
Zurück zur [[Shadersammlung]]
{|{{Prettytable_B1}} width=100%
!width=60%|Beschreibung
!width=20%|Autor
!width=20%|Version
|-
|Post-Processing-Shader zum verwischen der Szene.
|Skeptiker
|1.0
|}

==Bilder==
{|
|[[Bild:Shader_blur_seerose.png|framed|Vorher]]
|-
|[[Bild:Shader_blur_seerose_blured.png|framed|Nachher]]
|}

==Beschreibung==
Dieser Shader verwischt die Szene.

''textureWidth'' gibt die Breite der Textur an.<br>
''textureHeight'' gibt die Höhe der Textur an.<br>
''horizontal'' true wenn horizontal verwischt werden soll, false wenn vertikal verwischt werden soll.<br><br>
''texture0'' muss in der Regel nicht explizit angegeben werden.

Der Shader wurde bewusst einfach gehalten, mit einigen kniffen kann man hier mit Sicherheit mehr Performance rausholen.

Da der Shader für jedes Texel der Textur die unmittelbaren nachbar Texel abtastet muss das Verhalten an den Rändern der Textur definiert werden, hier empfiehlt sich die Einstellung GL_CLAMP_TO_EDGE oder GL_CLAMP_TO_BORDER.

==Besondere Vorraussetzungen==
Es handelt sich um einen Post-Processing-Shader, die Szene muss daher vorher in eine Textur gerendert werden. Anschließend muss diese Textur gebunden werden und als Fullscreen-Quad mit diesem Shader gerendert werden. Hier bietet sich ein FrameBufferObject an.

==Code==
Vertex Shader
<source lang="glsl">
#version 120

void main() {

gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
}
</source>

Fragment Shader
<source lang="glsl">
#version 120

uniform sampler2D texture0;
uniform int textureWidth;
uniform int textureHeight;
uniform bool horizontal;

const float gaussFilter[7] = float[7](
0.015625,
0.09375,
0.234375,
0.3125,
0.234375,
0.09375,
0.015625
);

void main() {

vec4 color = vec4(0.0, 0.0, 0.0, 0.0);

for (int i = 0; i < 7; i++) {

vec2 texCoord;

if (horizontal) {

texCoord = vec2(gl_TexCoord[0].x + float(i - 3) / float(textureWidth), gl_TexCoord[0].y);
} else {

texCoord = vec2(gl_TexCoord[0].x, gl_TexCoord[0].y + float(i - 3) / float(textureHeight));
}

color += texture2D(texture0, texCoord) * gaussFilter[i];
}

gl_FragColor = color;
}
</source>

shader blur2

2009-12-23T15:45:11Z

Skeptiker:

=Blur=
Zurück zur [[Shadersammlung]]
{|{{Prettytable_B1}} width=100%
!width=60%|Beschreibung
!width=20%|Autor
!width=20%|Version
|-
|Post-Processing-Shader zum verwischen der Szene.
|Skeptiker
|1.0
|}

==Bilder==
{|
|[[Bild:Shader_blur_seerose.png|framed|Vorher]]
|-
|[[Bild:Shader_blur_seerose_blured.png|framed|Nachher]]
|}

==Beschreibung==
Dieser Shader verwischt die Szene.

''textureWidth'' gibt die Breite der Textur an.<br>
''textureHeight'' gibt die Höhe der Textur an.<br>
''horizontal'' true wenn horizontal verwischt werden soll, false wenn vertikal verwischt werden soll.<br><br>
''texture0'' muss in der Regel nicht explizit angegeben werden.

Der Shader wurde bewusst einfach gehalten, mit einigen kniffen kann man hier mit Sicherheit mehr Performance rausholen.

==Besondere Vorraussetzungen==
Es handelt sich um einen Post-Processing-Shader, die Szene muss daher vorher in eine Textur gerendert werden. Anschließend muss diese Textur gebunden werden und als Fullscreen-Quad mit diesem Shader gerendert werden. Hier bietet sich ein FrameBufferObject an.

==Code==
Vertex Shader
<source lang="glsl">
#version 120

void main() {

gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
}
</source>

Fragment Shader
<source lang="glsl">
#version 120

uniform sampler2D texture0;
uniform int textureWidth;
uniform int textureHeight;
uniform bool horizontal;

float gaussFilter[7] = float[7](
0.015625,
0.09375,
0.234375,
0.3125,
0.234375,
0.09375,
0.015625
);

void main() {

vec4 color = vec4(0.0, 0.0, 0.0, 0.0);

for (int i = 0; i < 7; i++) {

vec2 texCoord;

if (horizontal) {

texCoord = vec2(gl_TexCoord[0].x + float(i - 3) / float(textureWidth), gl_TexCoord[0].y);
} else {

texCoord = vec2(gl_TexCoord[0].x, gl_TexCoord[0].y + float(i - 3) / float(textureHeight));
}

color += texture2D(texture0, texCoord) * gaussFilter[i];
}

gl_FragColor = color;
}
</source>

Diskussion:shader blur2

2009-12-23T15:40:53Z

Skeptiker:

Diskussion:shader blur2

2009-12-22T21:25:13Z

Skeptiker: Die Seite wurde neu angelegt: „Da an dem anderen Blur Shader scheinbar seit Ewigkeiten nichtsmehr gemacht wird hab ich einfach mal diesen hier erstellt. Fragen, Anregungen, Verbesserungsvorschl…“

shader blur2

2009-12-22T21:24:03Z

Skeptiker: Die Seite wurde neu angelegt: „=Blur= Zurück zur Shadersammlung {|{{Prettytable_B1}} width=100% !width=60%|Beschreibung !width=20%|Autor !width=20%|Version |- |Post-Processing-Shader zum v…“

=Blur=
Zurück zur [[Shadersammlung]]
{|{{Prettytable_B1}} width=100%
!width=60%|Beschreibung
!width=20%|Autor
!width=20%|Version
|-
|Post-Processing-Shader zum verwischen der Szene.
|Skeptiker
|1.0
|}

==Bilder==
{|
|[[Bild:Shader_blur_seerose.png|framed|Vorher]]
|-
|[[Bild:Shader_blur_seerose_blured.png|framed|Nachher]]
|}

==Beschreibung==
Dieser Shader verwischt die Szene.

''textureWidth'' gibt die Breite der Textur an.<br>
''textureHeight'' gibt die Höhe der Textur an.<br>
''horizontal'' true wenn horizontal verwischt werden soll, false wenn vertikal verwischt werden soll.<br><br>
''texture0'' muss in der Regel nicht explizit angegeben werden.

Der Shader wurde bewusst einfach gehalten, mit einigen kniffen kann man hier mit Sicherheit mehr Performance rausholen.

==Besondere Vorraussetzungen==
Es handelt sich um einen Post-Processing-Shader, die Szene muss daher vorher in eine Textur gerendert werden. Anschließend muss diese Textur gebunden werden und als Fullscreen-Quad mit diesem Shader gerendert werden. Hier bietet sich ein FrameBufferObject an.

==Code==
Vertex Shader
<source lang="glsl">
#version 120

void main() {

gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
}
</source>

Fragment Shader
<source lang="glsl">
#version 120

uniform sampler2D texture0;
uniform int textureWidth;
uniform int textureHeight;
uniform bool horizontal;

float gaussFilter[7] = float[7](
0.015625,
0.09375,
0.234375,
0.3125,
0.234375,
0.09375,
0.015625
);

void main() {

vec4 color = vec4(0.0, 0.0, 0.0, 0.0);

for (int i = 0; i < 7; i++) {

vec2 texCoord;

if (horizontal) {

texCoord = vec2(gl_TexCoord[0].x + float(i - 4) / float(textureWidth), gl_TexCoord[0].y);
} else {

texCoord = vec2(gl_TexCoord[0].x, gl_TexCoord[0].y + float(i - 4) / float(textureHeight));
}

color += texture2D(texture0, texCoord) * gaussFilter[i];
}

gl_FragColor = color;
}
</source>

Datei:Shader blur seerose blured.png

2009-12-22T21:23:37Z

Skeptiker: Zeigt eine verwischte Seerose.

Zeigt eine verwischte Seerose.

Datei:Shader blur seerose.png

2009-12-22T21:22:28Z

Skeptiker: Zeigt eine nicht verwischte Seerose.

Zeigt eine nicht verwischte Seerose.

Kugel

2009-07-12T20:13:00Z

Skeptiker: Link korrigiert

==Variante 1==
Der nachfolgende Code ist ein Port von [http://local.wasp.uwa.edu.au/~pbourke/miscellaneous/sphere_cylinder/index.html http://local.wasp.uwa.edu.au/~pbourke/miscellaneous/sphere_cylinder/index.html].

Neben den Vertexpositionen werden die Normalen und Texturkoordinaten berechnet.

{{Hinweis|TVector3f ist ein einfaches Feld mit 3 Floats. (array[0..2] of float)}}

<source lang="pascal">procedure CreateSphere(c: TVector3f; r: Single; n: Integer);
const
TWOPI = PI*2;
PID2 = PI/2;
var
i,j: Integer;
theta1,theta2,theta3: Single;
e,p:TVector3f;
begin
if (r < 0) then r := -r;
if (n < 0) then n := -n;
if (n < 4) or (r <= 0) then
begin
glBegin(GL_POINTS);
glVertex3f(c[0],c[1],c[2]);
glEnd;
exit;
end;

for j:=0 to n div 2 do
begin
theta1 := j * TWOPI / n - PID2;
theta2 := (j + 1) * TWOPI / n - PID2;

glBegin(GL_QUAD_STRIP);
for i:=0 to n do
begin
theta3 := i * TWOPI / n;

e[0] := cos(theta2) * cos(theta3);
e[1] := sin(theta2);
e[2] := cos(theta2) * sin(theta3);
p[0] := c[0] + r * e[0];
p[1] := c[1] + r * e[1];
p[2] := c[2] + r * e[2];

glNormal3f(e[0],e[1],e[2]);
glTexCoord2f(i/n,2*(j+1)/n);
glVertex3f(p[0],p[1],p[2]);

e[0] := cos(theta1) * cos(theta3);
e[1] := sin(theta1);
e[2] := cos(theta1) * sin(theta3);
p[0] := c[0] + r * e[0];
p[1] := c[1] + r * e[1];
p[2] := c[2] + r * e[2];

glNormal3f(e[0],e[1],e[2]);
glTexCoord2f(i/n,2*j/n);
glVertex3f(p[0],p[1],p[2]);
end;
glEnd;
end;
end;</source>

==Variante 2==
'''Der nachfolgende Code ist selbst geschrieben (MatReno)'''

Er ermöglicht das Zeichnen einer Kugel, oder beliebigen Halbkugel, mit
Texturkoordinaten und Normalen.

===Benötigte Typen===

<source lang="pascal">
TVector2f : Array [0..1] of Single;
TVector3f : Array [0..2] of Single;
TVector4i : Array [0..3] of Integer;
</source>

===Zusätzlich benötigte Methoden===

<source lang="pascal">
Function VectorAdd(const vector: TVector3f; Value: Single): TVector3f;
Begin
Result[0] := vector[0] + Value;
Result[1] := vector[1] + Value;
Result[2] := vector[2] + Value;
End;
</source>

<source lang="pascal">
Function VectorMult(const vector: TVector3f; Value: Single): TVector3f;
Begin
Result[0] := vector[0] * Value;
Result[1] := vector[1] * Value;
Result[2] := vector[2] * Value;
End;
</source>

<source lang="pascal">
Function ToVector2f(x, y: Single): TVector2f;
Begin
Result[0] := x;
Result[1] := y;
End;
</source>

<source lang="pascal">
Function ToVector3f(x, y, z: Single): TVector3f;
Begin
Result[0] := x;
Result[1] := y;
Result[2] := z;
End;
</source>

<source lang="pascal">
Function ToVector4i(x, y, z, w: Integer): TVector4i;
Begin
Result[0] := x;
Result[1] := y;
Result[2] := z;
Result[3] := w;
End;
</source>

===Parametererklärung und Prozedur===

radius: Radius der Kugel in OGL-Units

n: Genauigkeit

typ: Art (siehe Procedure Kommentar)

inverted:

= false -> FrontFace aussen

= true -> FrontFace innen

voffset: Vektor (X, Y, Z) um den die Kugel verschoben wird

toffset: Vektor (U, V) um den die Textur verschoben wird

tscale: Textur-skalierung

<source lang="pascal">
Procedure DrawSphereObject(radius: Single; n: word;
typ: byte; inverted: boolean;
voffset: TVector3f; toffset, tscale: TVector2f);
Var alpha : TVector2f; // i*beta around x axis
SinAlpha: TVector2f; // sin(alpha)
CosAlpha: TVector2f; // cos(alpha)
beta : Single; // DegToRad(360° / n)
delta : Single; // j*beta around z axis
SinDelta: Single; // sin(delta)
CosDelta: Single; // cos(delta)
h, q : word; // half, quarter
v : TVector3f; // vector for normal and vertex
border : TVector4i; // for-loop borders
i, j : Integer;
k : Byte;
Begin
radius := abs(radius);

If (n < 4) Or (Odd(n)) Or (radius = 0) Then Exit;

h := n div 2;
q := n div 4;
If (Odd(h)) Then inc(q);

Case typ of
0: border := ToVector4i( -h, h-1, -q, q); // sphere
1: border := ToVector4i( -h, h-1, -q, 0); // hemisphere x-
2: border := ToVector4i( -h, h-1, 0, q); // hemisphere x+
3: border := ToVector4i(-h-q, -h+q-1, -q, q); // hemisphere y-
4: border := ToVector4i( -q, q-1, -q, q); // hemisphere y+
5: border := ToVector4i( -h, -1, -q, q); // hemisphere z-
6: border := ToVector4i( 0, h-1, -q, q); // hemisphere z+
else Exit;
End;

beta := 2*PI / n;

For i:=border[0] to border[1] do Begin
alpha := ToVector2f(i*beta, (i+1)*beta);

SinAlpha := ToVector2f(sin(alpha[0]), sin(alpha[1]));
CosAlpha := ToVector2f(cos(alpha[0]), cos(alpha[1]));

glBegin(GL_TRIANGLE_STRIP);
For j:=border[2] to border[3] do Begin
delta := j*beta;

SinDelta := sin(delta);
CosDelta := cos(delta);

If (inverted) Then
For k:=1 downto 0 do Begin
v := ToVector3f(-SinDelta, -CosAlpha[k]*CosDelta, -SinAlpha[k]*CosDelta);
glNormal3fv(@v);
v := VectorAdd(VectorMult(v, -radius), voffset);
glTexCoord2f((j/n + 0.25)*tscale[0] + toffset[0], ((i+k)/n)*tscale[1] + toffset[1]);
glvertex3fv(@v);
End;

If (not inverted) Then
For k:=0 to 1 do Begin
v := ToVector3f(SinDelta, CosAlpha[k]*CosDelta, SinAlpha[k]*CosDelta);
glNormal3fv(@v);
v := VectorAdd(VectorMult(v, radius), voffset);
glTexCoord2f((j/n + 0.25)*tscale[0] + toffset[0], ((i+k)/n)*tscale[1] + toffset[1]);
glvertex3fv(@v);
End
End;
glEnd;
End;
End;
</source>

===Beispielaufruf===

<source lang="pascal">
Const
ONE_VECTOR_2f : TVector2f = (1, 1);
NULL_VECTOR_2f : TVector2f = (0, 0);
NULL_VECTOR_3f : TVector3f = (0, 0, 0);
</source>

Um eine Kugel zu rendern muss man z.B. folgendes aufrufen:
<source lang="pascal">
DrawSphereObject(5,
32,
0,
false,
NULL_VECTOR_3f,
NULL_VECTOR_2f,
ONE_VECTOR_2f);
</source>

== Alternative ==

Als Alternative zu selbstgeschrieben Code bieten sich die [[Quadrik|Quadriken]] an, mit denen sich mit verhältnissmäßig wenigen Aufrufen verschiedene Formen erzeugen lassen.

[[Kategorie:Technik_oder_Algorithmus]] [[Kategorie:Anleitung]]

Diskussion:gluQuadricOrientation

2009-05-24T14:46:52Z

Skeptiker:

Sind die Bilder okay? Kann der Hinweis auf Verdeutlichung durch Bilder entfernt werden?
--[[Benutzer:Skeptiker|Skeptiker]] 12:23, 24. Mai 2009 (UTC)

Ich hätte da ne andere Idee.
Mach eine Quadric die mittels einer Clipping Plane aufgeschnitten ist. So dass man innen und Außenseite gleichzeitig sehen kann. (wie bei [[glClipPlane#Beispiel]])
Dann kann man sehen, was der Unterschied ist.
Manche wollen je eine Kugel auch von innen nutzen. z.B. als Skydome.
Auch interessant ist die Frage, ob sich Backfaceculling auf das Ergebnis dann auswirkt.
Vieleicht einen 4er Satz machen. 2x mit BFCulling und 2x ohne. Natürlich nur, wenn es einen Einfluss hat. --[[Benutzer:Flash|Flash]] 13:38, 24. Mai 2009 (UTC)

Ich hab mal versucht deine Vorschläge umzusetzen, ist wohl leider nicht das schönste Beispiel, aber es sollte seinen Zweck erfüllen. Für Verbesserungsvorschläge bin ich natürlich offen :). Wieder die Frage: Reichen die Bilde um den Hinweis zu entfernen? --[[Benutzer:Skeptiker|Skeptiker]] 14:46, 24. Mai 2009 (UTC)

gluQuadricOrientation

2009-05-24T14:45:00Z

Skeptiker:

{{Bildwunsch|Bild welches den Unterschied verdeutlicht.}}
= gluQuadricOrientation =

== Name ==
'''gluQuadricOrientation''' - gibt an, wie die [[Normalen]] für ein Quadrik-Objekte berechnet werden sollen.

== Delphi-Spezifikation ==
'''procedure''' gluQuadricOrientation(''quadObject'': PGLUquadric; ''orientation'': TGLEnum);

== Parameter ==
[[Bild:Gluquadricorientation_outside.png|right|thumb|300px|Vergleich der Kugeln mit deaktiviertem (links) und aktiviertem (rechts) Backface Culling. Die Kugeln wurden durch aktivieren einer benutzerdefinierten Clippingplane aufgeschnitten. Die Orientierung wurde auf GLU_OUTSIDE gesetzt.]]
[[Bild:Gluquadricorientation_inside.png|right|thumb|300px|Vergleich der Kugeln mit deaktiviertem (links) und aktiviertem (rechts) Backface Culling. Die Kugeln wurden durch aktivieren einer benutzerdefinierten Clippingplane aufgeschnitten. Die Orientierung wurde auf GLU_INSIDE gesetzt.]]

{| border="1" rules="all"
! ''quadObject''
| Gibt das Quadrik-Objekt an (erstellt mit [[gluNewQuadric]])
|-
! ''orientation''
| Gibt an in welche Richtung die Normalen der Quadric zeigen sollen. <br>
Akzeptiert werden '''GLU_OUTSIDE''' und '''GLU_INSIDE'''.
|}

== Beschreibung ==

'''gluQuadricOrientation''' gibt an, in welche Richtung die Normalen des [[Quadrik]]-Objekt ''quadObject'' zeigen sollen. ''orientation'' kann dabei folgende Werte zugewiesen bekommen:

'''GLU_OUTSIDE'''
:Die Normalen zeigen nach aussen. (Weg vom inneren)

'''GLU_INSIDE'''
:Die Normalen zeigen nach innen.

Standard ist '''GLU_OUTSIDE'''.
<br>
== Hinweise ==
Was Innen- und was Aussenseite ist, hängt vom übergebenen Quadrik-Objekt ab.

== Siehe auch ==
[[gluNewQuadric]], [[gluQuadricDrawStyle]], [[gluQuadricNormals]], [[gluQuadricTexture]]

Hintergrundwissen: [[Normalen]], [[Quadrik]]

[[Kategorie:GLU|QuadricOrientation]]

Datei:Gluquadricorientation inside.png

2009-05-24T14:39:15Z

Skeptiker: gluQuadricOrientation auf GL_INSIDE. Vergleich Backfaceculling Aktiv/Inaktiv.

gluQuadricOrientation auf GL_INSIDE. Vergleich Backfaceculling Aktiv/Inaktiv.

Datei:Gluquadricorientation outside.png

2009-05-24T14:39:13Z

Skeptiker: gluQuadricOrientation auf GL_OUTSIDE. Vergleich Backfaceculling Aktiv/Inaktiv.

gluQuadricOrientation auf GL_OUTSIDE. Vergleich Backfaceculling Aktiv/Inaktiv.

gluQuadricTexture

2009-05-24T12:35:33Z

Skeptiker:

= gluQuadricTexture =

== Name ==
[[Bild:Glquadrictexture_false.png|right|thumb|300px|Keine Berechnung der Texturkoordinaten durch gluQuadricTexture.]]
[[Bild:Glquadrictexture_true.png|right|thumb|300px|Berechnung der Texturkoordinaten durch gluQuadricTexture.]]

'''gluQuadricTexture''' - gibt an, ob für ein Quadrik-Objekte Texturkoordinaten erzeugt werden sollen.

== Delphi-Spezifikation ==
'''procedure''' gluQuadricTexture(''quadObject'': PGLUquadric; ''textureCoords'': TGLboolean);

== Parameter ==

{| border="1" rules="all"
! ''quadObject''
| Gibt das Quadrik-Objekt an (erstellt mit [[gluNewQuadric]])
|-
! ''textureCoords''
| Gibt an ob Texturkoordinaten erstellt werden sollen oder nicht.
|}

== Beschreibung ==
'''gluQuadricTexture''' bestimmt, ob für das [[Quadrik]]-Objekt ''quadObject'' Texturekoordinaten generiert werden sollen oder nicht.

Wenn ''textureCoords'' '''GL_TRUE''' übergeben wurde, werden Texturkoordinaten generiert. Wenn '''GL_FALSE''' übergeben wurde entsprechend nicht.

Standardwert für ''textureCoords'' ist '''GL_FALSE'''.
<br>
== Hinweise ==
Die Art und Weise wie die Texturkoordinaten erzeugt werden, hängt von der übergebenen Quadric ab.
<br>
== Siehe auch ==
[[gluNewQuadric]], [[gluQuadricDrawStyle]], [[gluQuadricNormals]]

[[Kategorie:GLU|QuadricTexture]]

Datei:Glquadrictexture true.png

2009-05-24T12:31:24Z

Skeptiker: gluQuadricTexture auf GL_TRUE, Berechnung der Texturkoordinaten.

gluQuadricTexture auf GL_TRUE, Berechnung der Texturkoordinaten.

Datei:Glquadrictexture false.png

2009-05-24T12:30:49Z

Skeptiker: gluQuadricTexture auf GL_FALSE, keine Berechnung der Texturkoordinaten.

gluQuadricTexture auf GL_FALSE, keine Berechnung der Texturkoordinaten.

Diskussion:gluQuadricOrientation

2009-05-24T12:23:01Z

Skeptiker: Die Seite wurde neu angelegt: „Sind die Bilder okay? Kann der Hinweis auf Verdeutlichung durch Bilder entfernt werden? --~~~~“

Sind die Bilder okay? Kann der Hinweis auf Verdeutlichung durch Bilder entfernt werden?
--[[Benutzer:Skeptiker|Skeptiker]] 12:23, 24. Mai 2009 (UTC)

gluQuadricOrientation

2009-05-24T12:20:24Z

Skeptiker:

{{Bildwunsch|Bild welches den Unterschied verdeutlicht.}}
= gluQuadricOrientation =

== Name ==
'''gluQuadricOrientation''' - gibt an, wie die [[Normalen]] für ein Quadrik-Objekte berechnet werden sollen.

== Delphi-Spezifikation ==
'''procedure''' gluQuadricOrientation(''quadObject'': PGLUquadric; ''orientation'': TGLEnum);

== Parameter ==
[[Bild:Glu_inside.png|right|thumb|300px|Lichtverhalten durch setzen von GLU_INSIDE, die Normalen zeigen zum Mittelpunkt.]]
[[Bild:Glu_outside.png|right|thumb|300px|Lichtverhalten durch setzen von GLU_OUTSIDE, die Normalen zeigen vom Mittelpunkt weg.]]

{| border="1" rules="all"
! ''quadObject''
| Gibt das Quadrik-Objekt an (erstellt mit [[gluNewQuadric]])
|-
! ''orientation''
| Gibt an in welche Richtung die Normalen der Quadric zeigen sollen. <br>
Akzeptiert werden '''GLU_OUTSIDE''' und '''GLU_INSIDE'''.
|}

== Beschreibung ==

'''gluQuadricOrientation''' gibt an, in welche Richtung die Normalen des [[Quadrik]]-Objekt ''quadObject'' zeigen sollen. ''orientation'' kann dabei folgende Werte zugewiesen bekommen:

'''GLU_OUTSIDE'''
:Die Normalen zeigen nach aussen. (Weg vom inneren)

'''GLU_INSIDE'''
:Die Normalen zeigen nach innen.

Standard ist '''GLU_OUTSIDE'''.
<br>
== Hinweise ==
Was Innen- und was Aussenseite ist, hängt vom übergebenen Quadrik-Objekt ab.

== Siehe auch ==
[[gluNewQuadric]], [[gluQuadricDrawStyle]], [[gluQuadricNormals]], [[gluQuadricTexture]]

Hintergrundwissen: [[Normalen]], [[Quadrik]]

[[Kategorie:GLU|QuadricOrientation]]

Datei:Glu outside.png

2009-05-24T12:14:58Z

Skeptiker: Verhalten des Lichts bei Normalenberechnung durch gluQuadricOrientation auf GLU_OUTSIDE.

Verhalten des Lichts bei Normalenberechnung durch gluQuadricOrientation auf GLU_OUTSIDE.

Datei:Glu inside.png

2009-05-24T12:14:03Z

Skeptiker: Verhalten des Lichts bei Normalenberechnung durch gluQuadricOrientation auf GLU_INSIDE.

Verhalten des Lichts bei Normalenberechnung durch gluQuadricOrientation auf GLU_INSIDE.

Flat Shading

2009-03-23T22:57:25Z

Skeptiker: /* Flat Shading */

In OpenGL uterscheidet man 2 verschiedene Methoden um die Farben von Flächen zu berechnen:

==Flat Shading==
Flat Shading ist die schnellere aber im Ergebnis auch unspektakulärere Methode. Als Farbe für die gesamte Fläche, wird die Farbe des letzten [[Vertex]] der Fläche benutzt. Alle anderen Farbinformationen der anderen Vertices werden ingnoriert. Dadurch entsteht eine gleichmäßig gefärbte Fläche.

<div align="center">
{|{{Prettytable}}
| glShadeModel(GL_FLAT);
glBegin(GL_QUADS);
glColor3f(1, 0, 0); glVertex3f(0, 0, 0);
glColor3f(0, 1, 0); glVertex3f(1, 0, 0);
glColor3f(0, 0, 1); glVertex3f(1, 1, 0);
glColor3f(1, 1, 0); glVertex3f(0, 1, 0);
glEnd;
|[[Bild:GlShadeModel_FLAT.jpg|center]]
|}</div>

==Smooth Shading==
Smooth Shading erzeugt einen Farbverlauf zwischen den Farbinformationen der Eckpunkte über die gesamte Fläche. Jeder Farbwert geht in die Berechnung ein. Zwischen Vertices wird die Farbe durch lineare Interpolation bestimmt. Dieses Vorgehen erfordert allerdings mehr Zeit als bei der Flat Shading Methode nötig wäre.

<div align="center">
{|{{Prettytable}}
| glShadeModel(GL_SMOOTH);
glBegin(GL_QUADS);
glColor3f(1, 0, 0); glVertex3f(0, 0, 0);
glColor3f(0, 1, 0); glVertex3f(1, 0, 0);
glColor3f(0, 0, 1); glVertex3f(1, 1, 0);
glColor3f(1, 1, 0); glVertex3f(0, 1, 0);
glEnd;
|[[Bild:GlShadeModel_SMOOTH.jpg|center]]
|}</div>

==Siehe Auch==
[[glShadeModel]], [[Feste_Funktionspipeline#Flat_Shading]]