DGL Wiki - Benutzerbeiträge [de]

Kamera (1)

2022-01-30T11:59:27Z

Andyh:

==Danke==
Nachdem ich viel Zeit damit verbracht habe, eine funktionierende Kamera zu bauen und es nun endlich geschafft habe, wollte ich diese Funktionalität auch Anderen zur Verfügung stellen.
Da mir schon viel geholfen wurde, kann ich so einen Teil meiner "Schuld" zurückzahlen.

Bitte seht ab und zu mal hier nach, ob es für diese Kamera Updates gibt. Sollte es so sein, habe ich das im Code ([[Kamera (2)]]) vermerkt. Ladet in diesem Fall bitte den Source Code der Kamera und(!) die Utilities herunter.

==Meine Kamera==
Die wie folgend beschriebene Kamera kann sich um alle drei Achsen drehen und sich in allen Ebenen bewegen. Der Drehpunkt um den sich die Kamera dreht wird mit dem Aufruf der Prozedur PositionCamera festgelegt. Sollte man diesen Drehpunkt benötigen (z.B. zum Anzeigen eines Koordinatenkreuzes, ...), so kann man auf die Property PointOfRotation zugreifen (read only).

Die Kamera kann bis zu zehn Positionen speichern und auch wiederherstellen. (SavePosition, RestorePosition)

Die Kamera kann sich selber zu jeder Zeit unter Beibehaltung der aktuellen Position senkrecht zur Welt ausrichten. (Adjust)

Um sicher zu sein, dass auch alle nötigen Definitionen und Funktionen zur Verfügung stehen, habe ich einfach mal einen Großteil meiner Funktionssammlung beigefügt ([[Kamera (3)]]). Diese Funktionen/Prozeduren werden so oder in leicht abgeänderter Form wohl bei jedem OpenGL Programmierer existieren.

Sollte es noch irgendwelche Fragen zu diesem Modul geben, so stehe ich gerne zur Verfügung.

==Gebrauch der Funktionen:==

Die hier vorzufindende Beschreibung stellt keine komplette Anleitung für die Verwendung der Kamera dar. Um bis in die "Tiefen" des Objekts hinabzusteigen seht Euch bitte das von mir bereit gestellte Beispielprogramm an ([[Kamera]]). Wenn Ihr das herunterladet habt Ihr auch auf jeden Fall die neueste Version der Sourcen, die ich zuletzt am 26.12.2007 aktualisert habe. Diese Sourcen vereinfachen die Verarbeitung von Tastatur- und Mausevents. Die u.a. Anleitung entspricht daher nicht mehr dem aktuellen Vorgehen, kann aber auch weiterhin so angewendet werden.

1.
PositionCamera mit Vektoren für Position, Blickpunkt und Ausrichtung aufrufen. Die Blickrichtung gibt auch gleichzeitig den Drehpunkt der Szene an, um den dann mit RotateCamera gedreht werden kann. PositionCamera positioniert den angegebenen Blickpunkt in der Mitte des Bildschirms. PositionCamera sollte nur zur Positionierung der Kamera benutzt werden, also einmal am Anfang. Alle weiteren Kameraveränderungen sollten mit den zur Verfügung gestellten Methoden durchgeführt werden.

2.
Aufruf der Funktionen RotateCamera und TranslateCamera um die Ausrichtung/Lage der Kamera zu verändern. Um das unten angegebene Beispiel implementieren zu können, müssen folgende Variablen im aktuellen Modul definiert werden:

FMousePosX, FMousePosY,
FMousePressX, FMousePressY,
FRightMousePressed, FLeftMousePressed,
FxDelta, FyDelta, FxStart, FyStart,
FxRot und FyRot (sind alle als var im aktuellen Modul definiert)

FRightMousePressed und FLeftMousePressed müssen in der Prozedur MouseDown/MouseUp gesetzt werden.

FxRot und FyRot müssen mit 0 initialisiert werden.

<source lang="pascal">
unit Example;

interface

uses
Windows, ...

type
TFExample = class(TForm)
.
.
.
private
FCamera: TCamera;

FglDC: HDC; // device context der aktuellen komponente
FglRC: HGLRC; // rendering kontext der aktuellen komponente

ClearAlpha: GLclampd; // alpha wert der hintergrundfarbe
ClearRed: GLclampd; // rotanteil der hintergrundfarbe
ClearGreen: GLclampd; // grünanteil der hintergrundfarbe
ClearBlue: GLclampd; // blauanteil der hintergrundfarbe
public
.
.
.
published
.
.
.

var
FExample: TFExample;

FxStart, // berechnung der mausbewegungen.
FxDelta, // delta = aktuelle position minus start
FyStart, // start wird erfasst sobald eine maustaste
FyDelta:integer; // gedrückt wird.

FxRot, // umrechnung von delta in rotation wenn
FyRot:double; // drehung gewünscht ist (je nach taste)

FMousePressX, // aktuelle mausposition, wenn maustaste gedrückt wird
FMousePressY: integer;
FMousePosX, // aktuelle mausposition
FMousePosY: integer;

//mausaktivität überprüfen
FRightMousePressed:boolean; // ist die rechte maustaste gedrückt?
FLeftMousePressed:boolean; // ist die linke maustaste gedrückt?

const
crCursorMove = 1;
crCursorRotate = 2;
crCursorSelect = 3;

implementation

uses ...

{$R *.dfm}
{$R cursors.res}
</source>
<source lang="pascal">
procedure TFExample.FormMouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer);
begin
// mausposition merken
FMousePosX := X;
FMousePosY := Y;

//das Ziehen der Szene kann nur bei gedrückter Maustaste passieren
if not (FRightMousePressed or FLeftMousePressed) then exit;

//ausrechenen um wieviel der Mauszeiger bewegt wurde
FxDelta := FxStart-X;
FyDelta := FyStart-Y;

//Rotation anpassen, damit es nicht zu schnell wird
FxRot := FxRot - FyDelta/20;
Fyrot := FyRot - FxDelta/20;

//das naechste mal ist das hier unser startpunkt:
FxStart := X;
FyStart := Y;

if FRightMousePressed then
begin
if FxRot <> 0 then FCamera.RotateCamera (FxRot, 0, 0);
if FyRot <> 0 then FCamera.RotateCamera (0, FyRot, 0);
end;
if FLeftMousePressed then
begin
if FxRot <> 0 then FCamera.TranslateCamera (FxRot, 0, 0);
if FyRot <> 0 then FCamera.TranslateCamera (0, FyRot, 0);
end;
Paint;

FxRot := 0;
FyRot := 0;
end;
</source>
<source lang="pascal">
procedure TFExample.FormMouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
begin
if Button = mbRight then
begin
//rechte maustaste gedrückt
FRightMousePressed:=true;
//Startposition merken
FxStart:=X;
FyStart:=Y;
Screen.Cursor := crCursorRotate;
end
else if Button = mbLeft then
begin
//rechte maustaste gedrückt
FLeftMousePressed:=true;
//Startposition merken
FxStart:=X;
FyStart:=Y;
Screen.Cursor := crCursorMove;
end;
// aktuelle Mouseposition festhalten. so kann z.B. überprüft werden
// welches Objekt an der aktuellen Mausposition liegt
FMousePressX := X;
FMousePressY := Y;
end;
</source>
<source lang="pascal">
procedure TFExample.FormMouseUp(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
begin
if Button = mbRight then
begin
FRightMousePressed:=false;
end;
if Button = mbLeft then
begin
FLeftMousePressed:=false;
end;
if not (FRightMousePressed or FLeftMousePressed) then
Screen.Cursor := crCursorSelect;
end;
</source>
<source lang="pascal">
procedure TFExample.FormCreate(Sender: TObject);
resourcestring
ResStrRCfailed = 'CreateRenderingContext failed ';
ResStrWGLfailed = 'wglMakeCurrent failed ';
begin
inherited;

// wenn das grafiksystem von OpenGL nicht aktiviert werden kann,
// müssen wir das programm beenden
if not InitOpenGL then
begin
raise Exception.Create('InitOpenGL failed '+IntToStr(GetLastError));
halt (100);
end;

FglDC := getDC(self.WindowHandle);
FglRC := CreateRenderingContext(FglDC,
[opDoubleBuffered],
32, 24, 0,0,0,0);

if FglRC=0 then
begin
raise Exception.Create(ResStrRCfailed + IntToStr(GetLastError));
halt (100);
end;

if not wglMakeCurrent(FglDC, FglRC) then
raise Exception.Create(ResStrWGLfailed + IntToStr(GetLastError));

FxRot:=0;
FyRot:=0;

FRightMousePressed := false;
FLeftMousePressed := false;

Screen.Cursors[crCursorMove] := LoadCursor(HInstance,'MOVE');
Screen.Cursors[crCursorRotate] := LoadCursor(HInstance,'ROTATE');
Screen.Cursors[crCursorSelect] := LoadCursor(HInstance,'SELECT');
Screen.Cursor := crCursorSelect;

ClearAlpha := 1; // bildschirm immer mit weiß löschen
ClearRed:= 1; // bildschirm immer mit weiß löschen
ClearGreen:= 1; // bildschirm immer mit weiß löschen
ClearBlue:= 1; // bildschirm immer mit weiß löschen

FCamera := TCamera.Create;
end;
</source>

Das mit den unterschiedlichen Cursordarstellungen habe ich nur als Hinweis gelassen. Diese Anweisungen müsst Ihr rausnehmen es sei denn, dass Ihr eine Resourcendatei mit drei unterschiedlichen Cursorarten erstellt und sie unter "Cursors.res" abspeichert.

Dieses Beispiel ist vereinfacht dargestellt und es ist sehr wahrscheinlich, dass Ihr daran noch etwas herumspielen müsst. Ich habe noch das Mausrad eingesetzt um in den Bildschirm hinein- oder aus ihm herauszuzoomen (TranslateCamera(0,0,?)).
Durch modifizieren der Geschwindigkeit (+/-) für die einzelnen Achsen, die an die Prozeduren TranslateCamera und RotateCamera übergeben werden kann man entweder die Szene oder die Kamera bewegen.

3. Szene zeichnen:

Lichteigenschaften setzen

Materialeigenschaften setzen

... (die üblichen Vorbereitungen treffen)

FCamera.Apply

Szene zeichnen

wenn Terrain gewünscht:
FCamera.ApplyForTerrain
Terrain zeichnen
ende wenn

Swapbuffers...

usw.

<source lang="pascal">
procedure TFExample.Render; // wird aus der Methode Paint aufgerufen
resourcestring
RestStrWGLfailed = 'TFExample.Render: wglMakeCurrent failed with ';
begin
// da mehrere fenster möglich sind, muss immer der aktuelle
// ausgabekontext ausgewählt werden
if wglMakeCurrent(FglDC,FglRC) then
begin
glMatrixMode (GL_MODELVIEW);

glClearColor(ClearRed, ClearGreen, ClearBlue, ClearAlpha);
glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);

// View setzen

Camera1.Apply;

// Szene jetzt zeichnen

glFlush; // bearbeitung der GL-befehle beginnen
glFinish; // warten bis alle befehle ausgeführt sind

SwapBuffers(FglDC); // flackern verhindern
end
else
begin
raise Exception.Create(RestStrWGLfailed + IntToStr(GetLastError));
end;
end;
</source>

Den Kameracode findet ihr unter [[Kamera (2)]]. 
Die verwendete Toolsammlung findet ihr unter [[Kamera (3)]].

[[Kategorie:Anleitung]]

Kamera (1)

2011-03-22T16:37:27Z

Andyh: /* Gebrauch der Funktionen: */

==Danke==
Nachdem ich viel Zeit damit verbracht habe, eine funktionierende Kamera zu bauen und es nun endlich geschafft habe, wollte ich diese Funktionalität auch Anderen zur Verfügung stellen.
Da mir schon viel geholfen wurde, kann ich so einen Teil meiner "Schuld" zurück zahlen.

Bitte seht ab und zu mal hier nach, ob es für diese Kamera Updates gibt. Sollte es so sein, habe ich das im Code ([[Kamera (2)]]) vermerkt. Ladet in diesem Fall bitte den Source Code der Kamera und(!) die Utilities herunter.

==Meine Kamera==
Die wie folgend beschriebene Kamera kann sich um alle drei Achsen drehen und sich in allen Ebenen bewegen. Der Drehpunkt um den sich die Kamera dreht wird mit dem Aufruf der Prozedur PositionCamera festgelegt. Sollte man diesen Drehpunkt benötigen (z.B. zum Anzeigen eines Koordinatenkreuzes, ...), so kann man auf die Property PointOfRotation zugreifen (read only).

Die Kamera kann bis zu zehn Positionen speichern und auch wiederherstellen. (SavePosition, RestorePosition)

Die Kamera kann sich selber zu jeder Zeit unter Beibehaltung der aktuellen Position senkrecht zur Welt ausrichten. (Adjust)

Um sicher zu sein, dass auch alle nötigen Definitionen und Funktionen zur Verfügung stehen, habe ich einfach mal einen Großteil meiner Funktionssammlung beigefügt ([[Kamera (3)]]). Diese Funktionen/Prozeduren werden so oder in leicht abgeänderter Form wohl bei jedem OpenGL Programmierer existieren.

Sollte es noch irgendwelche Fragen zu diesem Modul geben, so stehe ich gerne zur Verfügung.

==Gebrauch der Funktionen:==

Die hier vorzufindende Beschreibung stellt keine komplette Anleitung für die Verwendung der Kamera dar. Um bis in die "Tiefen" des Objekts hinabzusteigen seht Euch bitte das von mir bereit gestellte Beispielprogramm an ([[Kamera]]). Wenn Ihr das herunterladet habt Ihr auch auf jeden Fall die neueste Version der Sourcen, die ich zuletzt am 26.12.2007 aktualisert habe. Diese Sourcen vereinfachen die Verarbeitung von Tastatur- und Mausevents. Die u.a. Anleitung entspricht daher nicht mehr dem aktuellen Vorgehen, kann aber auch weiterhin so angewendet werden.

1.
PositionCamera mit Vektoren für Position, Blickpunkt und Ausrichtung aufrufen. Die Blickrichtung gibt auch gleichzeitig den Drehpunkt der Szene an, um den dann mit RotateCamera gedreht werden kann. PositionCamera positioniert den angegebenen Blickpunkt in der Mitte des Bildschirms. PositionCamera sollte nur zur Positionierung der Kamera benutzt werden, also einmal am Anfang. Alle weiteren Kameraveränderungen sollten mit den zur Verfügung gestellten Methoden durchgeführt werden.

2.
Aufruf der Funktionen RotateCamera und TranslateCamera um die Ausrichtung/Lage der Kamera zu verändern. Um das unten angegebene Beispiel implementieren zu können, müssen folgende Variablen im aktuellen Modul definiert werden:

FMousePosX, FMousePosY,
FMousePressX, FMousePressY,
FRightMousePressed, FLeftMousePressed,
FxDelta, FyDelta, FxStart, FyStart,
FxRot und FyRot (sind alle als var im aktuellen Modul definiert)

FRightMousePressed und FLeftMousePressed müssen in der Prozedur MouseDown/MouseUp gesetzt werden.

FxRot und FyRot müssen mit 0 initialisiert werden.

<source lang="pascal">
unit Example;

interface

uses
Windows, ...

type
TFExample = class(TForm)
.
.
.
private
FCamera: TCamera;

FglDC: HDC; // device context der aktuellen komponente
FglRC: HGLRC; // rendering kontext der aktuellen komponente

ClearAlpha: GLclampd; // alpha wert der hintergrundfarbe
ClearRed: GLclampd; // rotanteil der hintergrundfarbe
ClearGreen: GLclampd; // grünanteil der hintergrundfarbe
ClearBlue: GLclampd; // blauanteil der hintergrundfarbe
public
.
.
.
published
.
.
.

var
FExample: TFExample;

FxStart, // berechnung der mausbewegungen.
FxDelta, // delta = aktuelle position minus start
FyStart, // start wird erfasst sobald eine maustaste
FyDelta:integer; // gedrückt wird.

FxRot, // umrechnung von delta in rotation wenn
FyRot:double; // drehung gewünscht ist (je nach taste)

FMousePressX, // aktuelle mausposition, wenn maustaste gedrückt wird
FMousePressY: integer;
FMousePosX, // aktuelle mausposition
FMousePosY: integer;

//mausaktivität überprüfen
FRightMousePressed:boolean; // ist die rechte maustaste gedrückt?
FLeftMousePressed:boolean; // ist die linke maustaste gedrückt?

const
crCursorMove = 1;
crCursorRotate = 2;
crCursorSelect = 3;

implementation

uses ...

{$R *.dfm}
{$R cursors.res}
</source>
<source lang="pascal">
procedure TFExample.FormMouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer);
begin
// mausposition merken
FMousePosX := X;
FMousePosY := Y;

//das Ziehen der Szene kann nur bei gedrückter Maustaste passieren
if not (FRightMousePressed or FLeftMousePressed) then exit;

//ausrechenen um wieviel der Mauszeiger bewegt wurde
FxDelta := FxStart-X;
FyDelta := FyStart-Y;

//Rotation anpassen, damit es nicht zu schnell wird
FxRot := FxRot - FyDelta/20;
Fyrot := FyRot - FxDelta/20;

//das naechste mal ist das hier unser startpunkt:
FxStart := X;
FyStart := Y;

if FRightMousePressed then
begin
if FxRot <> 0 then FCamera.RotateCamera (FxRot, 0, 0);
if FyRot <> 0 then FCamera.RotateCamera (0, FyRot, 0);
end;
if FLeftMousePressed then
begin
if FxRot <> 0 then FCamera.TranslateCamera (FxRot, 0, 0);
if FyRot <> 0 then FCamera.TranslateCamera (0, FyRot, 0);
end;
Paint;

FxRot := 0;
FyRot := 0;
end;
</source>
<source lang="pascal">
procedure TFExample.FormMouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
begin
if Button = mbRight then
begin
//rechte maustaste gedrückt
FRightMousePressed:=true;
//Startposition merken
FxStart:=X;
FyStart:=Y;
Screen.Cursor := crCursorRotate;
end
else if Button = mbLeft then
begin
//rechte maustaste gedrückt
FLeftMousePressed:=true;
//Startposition merken
FxStart:=X;
FyStart:=Y;
Screen.Cursor := crCursorMove;
end;
// aktuelle Mouseposition festhalten. so kann z.B. überprüft werden
// welches Objekt an der aktuellen Mausposition liegt
FMousePressX := X;
FMousePressY := Y;
end;
</source>
<source lang="pascal">
procedure TFExample.FormMouseUp(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
begin
if Button = mbRight then
begin
FRightMousePressed:=false;
end;
if Button = mbLeft then
begin
FLeftMousePressed:=false;
end;
if not (FRightMousePressed or FLeftMousePressed) then
Screen.Cursor := crCursorSelect;
end;
</source>
<source lang="pascal">
procedure TFExample.FormCreate(Sender: TObject);
resourcestring
ResStrRCfailed = 'CreateRenderingContext failed ';
ResStrWGLfailed = 'wglMakeCurrent failed ';
begin
inherited;

// wenn das grafiksystem von OpenGL nicht aktiviert werden kann,
// müssen wir das programm beenden
if not InitOpenGL then
begin
raise Exception.Create('InitOpenGL failed '+IntToStr(GetLastError));
halt (100);
end;

FglDC := getDC(self.WindowHandle);
FglRC := CreateRenderingContext(FglDC,
[opDoubleBuffered],
32, 24, 0,0,0,0);

if FglRC=0 then
begin
raise Exception.Create(ResStrRCfailed + IntToStr(GetLastError));
halt (100);
end;

if not wglMakeCurrent(FglDC, FglRC) then
raise Exception.Create(ResStrWGLfailed + IntToStr(GetLastError));

FxRot:=0;
FyRot:=0;

FRightMousePressed := false;
FLeftMousePressed := false;

Screen.Cursors[crCursorMove] := LoadCursor(HInstance,'MOVE');
Screen.Cursors[crCursorRotate] := LoadCursor(HInstance,'ROTATE');
Screen.Cursors[crCursorSelect] := LoadCursor(HInstance,'SELECT');
Screen.Cursor := crCursorSelect;

ClearAlpha := 1; // bildschirm immer mit weiß löschen
ClearRed:= 1; // bildschirm immer mit weiß löschen
ClearGreen:= 1; // bildschirm immer mit weiß löschen
ClearBlue:= 1; // bildschirm immer mit weiß löschen

FCamera := TCamera.Create;
end;
</source>

Das mit den unterschiedlichen Cursordarstellungen habe ich nur als Hinweis gelassen. Diese Anweisungen müsst Ihr rausnehmen es sei denn, dass Ihr eine Resourcendatei mit drei unterschiedlichen Cursorarten erstellt und sie unter "Cursors.res" abspeichert.

Dieses Beispiel ist vereinfacht dargestellt und es ist sehr wahrscheinlich, dass Ihr daran noch etwas herumspielen müsst. Ich habe noch das Mausrad eingesetzt um in den Bildschirm hinein- oder aus ihm herauszuzoomen (TranslateCamera(0,0,?)).
Durch modifizieren der Geschwindigkeit (+/-) für die einzelnen Achsen, die an die Prozeduren TranslateCamera und RotateCamera übergeben werden kann man entweder die Szene oder die Kamera bewegen.

3. Szene zeichnen:

Lichteigenschaften setzen

Materialeigenschaften setzen

... (die üblichen Vorbereitungen treffen)

FCamera.Apply

Szene zeichnen

wenn Terrain gewünscht:
FCamera.ApplyForTerrain
Terrain zeichnen
ende wenn

Swapbuffers...

usw.

<source lang="pascal">
procedure TFExample.Render; // wird aus der Methode Paint aufgerufen
resourcestring
RestStrWGLfailed = 'TFExample.Render: wglMakeCurrent failed with ';
begin
// da mehrere fenster möglich sind, muss immer der aktuelle
// ausgabekontext ausgewählt werden
if wglMakeCurrent(FglDC,FglRC) then
begin
glMatrixMode (GL_MODELVIEW);

glClearColor(ClearRed, ClearGreen, ClearBlue, ClearAlpha);
glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);

// View setzen

Camera1.Apply;

// Szene jetzt zeichnen

glFlush; // bearbeitung der GL-befehle beginnen
glFinish; // warten bis alle befehle ausgeführt sind

SwapBuffers(FglDC); // flackern verhindern
end
else
begin
raise Exception.Create(RestStrWGLfailed + IntToStr(GetLastError));
end;
end;
</source>

Den Kameracode findet ihr unter [[Kamera (2)]]. 
Die verwendete Toolsammlung findet ihr unter [[Kamera (3)]].

[[Kategorie:Anleitung]]

Kamera

2010-07-24T06:39:39Z

Andyh: Links zu Homepage haben sich geändert, habe ich angepasst

Andyh beschreibt in den Artikeln:
*[[Kamera (1)]]
*[[Kamera (2)]]
*[[Kamera (3)]]
wie man eine Kamara realisiert.

{{ZitatVon|Andyh|
Nachdem ich viel Zeit damit verbracht habe eine funktionierende Kamera
zu bauen und es nun endlich geschafft habe, wollte ich diese Funktionalität
auch anderen zur Verfügung stellen.
Da mir schon viel geholfen wurde, kann ich so einen Teil meiner "Schuld"
zurück zahlen.
}}
Die folgend beschriebene Kamera kann sich um alle drei Achsen drehen und sich
in allen Ebenen bewegen. Der Drehpunkt um den sich die Kamera dreht wird mit
dem Aufruf der Prozedur PositionCamera festgelegt. Sollte man diesen Drehpunkt
benötigen (z.B. zum anzeigen eines Koordinatenkreuzes, ...) so kann man auf
die Property PointOfRotation zugreifen (read only).

Die Kamera kann bis zu zehn Positionen speichern und auch wieder herstellen.
(SavePosition, RestorePosition)

Die Kamera kann sich selber zu jeder Zeit unter Beibehaltung der aktuellen
Position senkrecht zur Welt ausrichten.
(Adjust)

Um sicher zu sein, dass auch alle nötigen Definitionen und Funktionen zur
Verfügung stehen habe ich einfach mal einen Großteil meiner Funktionssammlung
beigefügt (Util.pas). Diese Funktionen/Prozeduren werden so oder in leicht
abgeänderter Form wohl bei jedem OpenGL Programmierer existieren.

...

Bisher glaubte ich, dass man mit der von mir erstellten Kurzanleitung auskommt, habe jetzt aber doch noch ein Beispielprogramm erstellt. Nach mehrmaligem Studium meiner Kurzanleitung bin ich nämlich zu dem Schluss gekommen, dass man mit diesem Programmierbeispiel nicht zu dem von mir beabsichtigten Ergebnis kommen kann. Das Beispielprogramm, welches die Funktionen der Kamera veranschaulicht, wurde mit Delphi 2005 entwickelt. Wenn Ihr über eine ältere Delphiversion verfügt nehmt einfach die DPR Datei oder erstellt ein neues Projekt mit Euerem Compiler und bindet die benötigten Dateien ein.

Ich habe noch einiges mehr an Code reingepackt als unbedingt nötig, um der Sache optisch ein Mindestmaß an Anspruch zu verleihen. Deswegen können aus diesem Beispielprogramm noch die eine oder andere Komponente entnommen werden (wenn nicht schon vorhanden). Dies sind z.B. Komponenten für Licht, Material, zur Textdarstellung, eine Skybox und zur Handhabung von Grafikdateien (die ist allerdings nicht auf meinem Mist gewachsen). Zusätzlich habe ich noch den Memory Manager FastMM4 beigepackt und eingebunden. Mit diesem kann man sehr schön (besser als mit den von Delphi bereitgestellten Möglichkeiten) nicht freigegebene Resourcen aufspüren. Ich war überrascht was ich alles nicht freigegeben hatte, als ich den zum ersten mal eingesetzt habe.

{{ArchivLink|file=kamera_heyroth‎‎|text=Das Beispielprogramm findet Ihr hier}}. Dieses Programm habe ich am 26.12.2007 aktualisiert um die Steuerung per Tastatur und Maus zu vereinfachen. Die bisher in den das Modul benutzenden Methoden KeyDown, KeyUp, ModeDown, MouseUp usw. nötigen Tätigkeiten habe ich in Kameramethoden ausgelagert. Dadurch kann mit einem einzigen Aufruf dieser Methode(n) die nötige Arbeit abgerufen werden.

Aussehen sollte es nach dem Aufruf so:

[[Bild:CameraExample.jpg]]

...

Ein weiteres Projekt habe ich auf meiner Homepage veröffentlicht. Es ist ein simples Spiel, welches mit verschiedenen Kameraeinstellungen arbeitet. Dadurch kann man einiges über die Kamera erfahren. Die letzten Entwicklungen sind nur hier eingeflossen. Das Projekt auf dieser Seite werde ich nicht mehr aktualisieren. Wollt Ihr also den neuesten Source Code, dann schaut Euch auf meiner Homepage entweder das neueste [http://www.heyroth.biz/main.html?src=%2F#2,5 Kamerabeispiel] oder [http://www.heyroth.biz/main.html?src=%2F#2,6 Spiel] an.

Sollte es noch irgendwelche Fragen zu diesen Modulen geben, so stehe ich gerne
zur Verfügung (Andree Heyroth, Alias: AndyH).

[[Kategorie:Technik_oder_Algorithmus]]

Kamera

2009-10-31T06:52:16Z

Andyh:

Andyh beschreibt in den Artikeln:
*[[Kamera (1)]]
*[[Kamera (2)]]
*[[Kamera (3)]]
wie man eine Kamara realisiert.

{{ZitatVon|Andyh|
Nachdem ich viel Zeit damit verbracht habe eine funktionierende Kamera
zu bauen und es nun endlich geschafft habe, wollte ich diese Funktionalität
auch anderen zur Verfügung stellen.
Da mir schon viel geholfen wurde, kann ich so einen Teil meiner "Schuld"
zurück zahlen.
}}
Die folgend beschriebene Kamera kann sich um alle drei Achsen drehen und sich
in allen Ebenen bewegen. Der Drehpunkt um den sich die Kamera dreht wird mit
dem Aufruf der Prozedur PositionCamera festgelegt. Sollte man diesen Drehpunkt
benötigen (z.B. zum anzeigen eines Koordinatenkreuzes, ...) so kann man auf
die Property PointOfRotation zugreifen (read only).

Die Kamera kann bis zu zehn Positionen speichern und auch wieder herstellen.
(SavePosition, RestorePosition)

Die Kamera kann sich selber zu jeder Zeit unter Beibehaltung der aktuellen
Position senkrecht zur Welt ausrichten.
(Adjust)

Um sicher zu sein, dass auch alle nötigen Definitionen und Funktionen zur
Verfügung stehen habe ich einfach mal einen Großteil meiner Funktionssammlung
beigefügt (Util.pas). Diese Funktionen/Prozeduren werden so oder in leicht
abgeänderter Form wohl bei jedem OpenGL Programmierer existieren.

...

Bisher glaubte ich, dass man mit der von mir erstellten Kurzanleitung auskommt, habe jetzt aber doch noch ein Beispielprogramm erstellt. Nach mehrmaligem Studium meiner Kurzanleitung bin ich nämlich zu dem Schluss gekommen, dass man mit diesem Programmierbeispiel nicht zu dem von mir beabsichtigten Ergebnis kommen kann. Das Beispielprogramm, welches die Funktionen der Kamera veranschaulicht, wurde mit Delphi 2005 entwickelt. Wenn Ihr über eine ältere Delphiversion verfügt nehmt einfach die DPR Datei oder erstellt ein neues Projekt mit Euerem Compiler und bindet die benötigten Dateien ein.

Ich habe noch einiges mehr an Code reingepackt als unbedingt nötig, um der Sache optisch ein Mindestmaß an Anspruch zu verleihen. Deswegen können aus diesem Beispielprogramm noch die eine oder andere Komponente entnommen werden (wenn nicht schon vorhanden). Dies sind z.B. Komponenten für Licht, Material, zur Textdarstellung, eine Skybox und zur Handhabung von Grafikdateien (die ist allerdings nicht auf meinem Mist gewachsen). Zusätzlich habe ich noch den Memory Manager FastMM4 beigepackt und eingebunden. Mit diesem kann man sehr schön (besser als mit den von Delphi bereitgestellten Möglichkeiten) nicht freigegebene Resourcen aufspüren. Ich war überrascht was ich alles nicht freigegeben hatte, als ich den zum ersten mal eingesetzt habe.

Das Beispielprogramm findet Ihr unter [http://files.delphigl.com/Download/kamera_heyroth.zip Download]. Dieses Programm habe ich am 26.12.2007 aktualisiert um die Steuerung per Tastatur und Maus zu vereinfachen. Die bisher in den das Modul benutzenden Methoden KeyDown, KeyUp, ModeDown, MouseUp usw. nötigen Tätigkeiten habe ich in Kameramethoden ausgelagert. Dadurch kann mit einem einzigen Aufruf dieser Methode(n) die nötige Arbeit abgerufen werden.

Aussehen sollte es nach dem Aufruf so:

[[Bild:CameraExample.jpg]]

...

Ein weiteres Projekt habe ich auf meiner Homepage veröffentlicht. Es ist ein simples Spiel, welches mit verschiedenen Kameraeinstellungen arbeitet. Dadurch kann man einiges über die Kamera erfahren. Die letzten Entwicklungen sind nur hier eingeflossen. Das Projekt auf dieser Seite werde ich nicht mehr aktualisieren. Wollt Ihr also den neuesten Source Code, dann schaut Euch auf meiner Homepage entweder das neueste [http://www.heyroth.biz/main.html?src=%2F#2,2 Kamerabeispiel] oder [http://www.heyroth.biz/main.html?src=%2F#2,3 Spiel] an.

Sollte es noch irgendwelche Fragen zu diesen Modulen geben, so stehe ich gerne
zur Verfügung (Andree Heyroth, Alias: AndyH).

[[Kategorie:Technik_oder_Algorithmus]]

Kamera

2009-10-31T06:51:42Z

Andyh:

Andyh beschreibt in den Artikeln:
*[[Kamera (1)]]
*[[Kamera (2)]]
*[[Kamera (3)]]
wie man eine Kamara realisiert.

{{ZitatVon|Andyh|
Nachdem ich viel Zeit damit verbracht habe eine funktionierende Kamera
zu bauen und es nun endlich geschafft habe, wollte ich diese Funktionalität
auch anderen zur Verfügung stellen.
Da mir schon viel geholfen wurde, kann ich so einen Teil meiner "Schuld"
zurück zahlen.
}}
Die folgend beschriebene Kamera kann sich um alle drei Achsen drehen und sich
in allen Ebenen bewegen. Der Drehpunkt um den sich die Kamera dreht wird mit
dem Aufruf der Prozedur PositionCamera festgelegt. Sollte man diesen Drehpunkt
benötigen (z.B. zum anzeigen eines Koordinatenkreuzes, ...) so kann man auf
die Property PointOfRotation zugreifen (read only).

Die Kamera kann bis zu zehn Positionen speichern und auch wieder herstellen.
(SavePosition, RestorePosition)

Die Kamera kann sich selber zu jeder Zeit unter Beibehaltung der aktuellen
Position senkrecht zur Welt ausrichten.
(Adjust)

Um sicher zu sein, dass auch alle nötigen Definitionen und Funktionen zur
Verfügung stehen habe ich einfach mal einen Großteil meiner Funktionssammlung
beigefügt (Util.pas). Diese Funktionen/Prozeduren werden so oder in leicht
abgeänderter Form wohl bei jedem OpenGL Programmierer existieren.

...

Bisher glaubte ich, dass man mit der von mir erstellten Kurzanleitung auskommt, habe jetzt aber doch noch ein Beispielprogramm erstellt. Nach mehrmaligem Studium meiner Kurzanleitung bin ich nämlich zu dem Schluss gekommen, dass man mit diesem Programmierbeispiel nicht zu dem von mir beabsichtigten Ergebnis kommen kann. Das Beispielprogramm, welches die Funktionen der Kamera veranschaulicht, wurde mit Delphi 2005 entwickelt. Wenn Ihr über eine ältere Delphiversion verfügt nehmt einfach die DPR Datei oder erstellt ein neues Projekt mit Euerem Compiler und bindet die benötigten Dateien ein.

Ich habe noch einiges mehr an Code reingepackt als unbedingt nötig, um der Sache optisch ein Mindestmaß an Anspruch zu verleihen. Deswegen können aus diesem Beispielprogramm noch die eine oder andere Komponente entnommen werden (wenn nicht schon vorhanden). Dies sind z.B. Komponenten für Licht, Material, zur Textdarstellung, eine Skybox und zur Handhabung von Grafikdateien (die ist allerdings nicht auf meinem Mist gewachsen). Zusätzlich habe ich noch den Memory Manager FastMM4 beigepackt und eingebunden. Mit diesem kann man sehr schön (besser als mit den von Delphi bereitgestellten Möglichkeiten) nicht freigegebene Resourcen aufspüren. Ich war überrascht was ich alles nicht freigegeben hatte, als ich den zum ersten mal eingesetzt habe.

Das Beispielprogramm findet Ihr unter [http://files.delphigl.com/Download/kamera_heyroth.zip Download]. Dieses Programm habe ich am 26.12.2007 aktualisiert um die Steuerung per Tastatur und Maus zu vereinfachen. Die bisher in den das Modul benutzenden Methoden KeyDown, KeyUp, ModeDown, MouseUp usw. nötigen Tätigkeiten habe ich in Kameramethoden ausgelagert. Dadurch kann mit einem einzigen Aufruf dieser Methode(n) die nötige Arbeit abgerufen werden.

Aussehen sollte es nach dem Aufruf so:

[[Bild:CameraExample.jpg]]

...

Ein weiteres Projekt habe ich auf meiner Homepage veröffentlicht. Es ist ein simples Spiel, welches mit verschiedenen Kameraeinstellungen arbeitet. Dadurch kann einiges über die Kamera erfahren. Die letzten Entwicklungen sind nur hier eingeflossen. Das Projekt auf dieser Seite werde ich nicht mehr aktualisieren. Wollt Ihr also den neuesten Source Code, dann schaut Euch auf meiner Homepage entweder das neueste [http://www.heyroth.biz/main.html?src=%2F#2,2 Kamerabeispiel] oder [http://www.heyroth.biz/main.html?src=%2F#2,3 Spiel] an.

Sollte es noch irgendwelche Fragen zu diesen Modulen geben, so stehe ich gerne
zur Verfügung (Andree Heyroth, Alias: AndyH).

[[Kategorie:Technik_oder_Algorithmus]]

Kamera

2009-10-27T08:04:31Z

Andyh:

Andyh beschreibt in den Artikeln:
*[[Kamera (1)]]
*[[Kamera (2)]]
*[[Kamera (3)]]
wie man eine Kamara realisiert.

{{ZitatVon|Andyh|
Nachdem ich viel Zeit damit verbracht habe eine funktionierende Kamera
zu bauen und es nun endlich geschafft habe, wollte ich diese Funktionalität
auch anderen zur Verfügung stellen.
Da mir schon viel geholfen wurde, kann ich so einen Teil meiner "Schuld"
zurück zahlen.
}}
Die folgend beschriebene Kamera kann sich um alle drei Achsen drehen und sich
in allen Ebenen bewegen. Der Drehpunkt um den sich die Kamera dreht wird mit
dem Aufruf der Prozedur PositionCamera festgelegt. Sollte man diesen Drehpunkt
benötigen (z.B. zum anzeigen eines Koordinatenkreuzes, ...) so kann man auf
die Property PointOfRotation zugreifen (read only).

Die Kamera kann bis zu zehn Positionen speichern und auch wieder herstellen.
(SavePosition, RestorePosition)

Die Kamera kann sich selber zu jeder Zeit unter Beibehaltung der aktuellen
Position senkrecht zur Welt ausrichten.
(Adjust)

Um sicher zu sein, dass auch alle nötigen Definitionen und Funktionen zur
Verfügung stehen habe ich einfach mal einen Großteil meiner Funktionssammlung
beigefügt (Util.pas). Diese Funktionen/Prozeduren werden so oder in leicht
abgeänderter Form wohl bei jedem OpenGL Programmierer existieren.

...

Bisher glaubte ich, dass man mit der von mir erstellten Kurzanleitung auskommt, habe jetzt aber doch noch ein Beispielprogramm erstellt. Nach mehrmaligem Studium meiner Kurzanleitung bin ich nämlich zu dem Schluss gekommen, dass man mit diesem Programmierbeispiel nicht zu dem von mir beabsichtigten Ergebnis kommen kann. Das Beispielprogramm, welches die Funktionen der Kamera veranschaulicht, wurde mit Delphi 2005 entwickelt. Wenn Ihr über eine ältere Delphiversion verfügt nehmt einfach die DPR Datei oder erstellt ein neues Projekt mit Euerem Compiler und bindet die benötigten Dateien ein.

Ich habe noch einiges mehr an Code reingepackt als unbedingt nötig, um der Sache optisch ein Mindestmaß an Anspruch zu verleihen. Deswegen können aus diesem Beispielprogramm noch die eine oder andere Komponente entnommen werden (wenn nicht schon vorhanden). Dies sind z.B. Komponenten für Licht, Material, zur Textdarstellung, eine Skybox und zur Handhabung von Grafikdateien (die ist allerdings nicht auf meinem Mist gewachsen). Zusätzlich habe ich noch den Memory Manager FastMM4 beigepackt und eingebunden. Mit diesem kann man sehr schön (besser als mit den von Delphi bereitgestellten Möglichkeiten) nicht freigegebene Resourcen aufspüren. Ich war überrascht was ich alles nicht freigegeben hatte, als ich den zum ersten mal eingesetzt habe.

Das Beispielprogramm findet Ihr unter [http://files.delphigl.com/Download/kamera_heyroth.zip Download]. Dieses Programm habe ich am 26.12.2007 aktualisiert um die Steuerung per Tastatur und Maus zu vereinfachen. Die bisher in den das Modul benutzenden Methoden KeyDown, KeyUp, ModeDown, MouseUp usw. nötigen Tätigkeiten habe ich in Kameramethoden ausgelagert. Dadurch kann mit einem einzigen Aufruf dieser Methode(n) die nötige Arbeit abgerufen werden.

Aussehen sollte es nach dem Aufruf so:

[[Bild:CameraExample.jpg]]

...

Ein weiteres Projekt habe ich auf meiner Homepage veröffentlicht. Es ist ein simples Spiel. das mit verschiedenen Kameraeinstellungen spielt. Man kann einiges über die Kamera erfahren. Die letzten Entwicklungen sind nur hier eingeflossen. Das Projekt auf dieser Seite werde ich niht mehr aktualisieren. Wollt Ihr also den neuesten Source Code, dann schaut Euch auf meiner Homepage entweder das neueste [http://www.heyroth.biz/main.html?src=%2F#2,2 Kamerabeispiel] oder [http://www.heyroth.biz/main.html?src=%2F#2,3 Spiel] an.

Sollte es noch irgendwelche Fragen zu diesen Modulen geben, so stehe ich gerne
zur Verfügung (Andree Heyroth, Alias: AndyH).

[[Kategorie:Technik_oder_Algorithmus]]

Kamera

2009-08-10T03:35:57Z

Andyh:

Andyh beschreibt in den Artikeln:
*[[Kamera (1)]]
*[[Kamera (2)]]
*[[Kamera (3)]]
wie man eine Kamara realisiert.

{{ZitatVon|Andyh|
Nachdem ich viel Zeit damit verbracht habe eine funktionierende Kamera
zu bauen und es nun endlich geschafft habe, wollte ich diese Funktionalität
auch anderen zur Verfügung stellen.
Da mir schon viel geholfen wurde, kann ich so einen Teil meiner "Schuld"
zurück zahlen.
}}
Die folgend beschriebene Kamera kann sich um alle drei Achsen drehen und sich
in allen Ebenen bewegen. Der Drehpunkt um den sich die Kamera dreht wird mit
dem Aufruf der Prozedur PositionCamera festgelegt. Sollte man diesen Drehpunkt
benötigen (z.B. zum anzeigen eines Koordinatenkreuzes, ...) so kann man auf
die Property PointOfRotation zugreifen (read only).

Die Kamera kann bis zu zehn Positionen speichern und auch wieder herstellen.
(SavePosition, RestorePosition)

Die Kamera kann sich selber zu jeder Zeit unter Beibehaltung der aktuellen
Position senkrecht zur Welt ausrichten.
(Adjust)

Um sicher zu sein, dass auch alle nötigen Definitionen und Funktionen zur
Verfügung stehen habe ich einfach mal einen Großteil meiner Funktionssammlung
beigefügt (Util.pas). Diese Funktionen/Prozeduren werden so oder in leicht
abgeänderter Form wohl bei jedem OpenGL Programmierer existieren.

...

Bisher glaubte ich, dass man mit der von mir erstellten Kurzanleitung auskommt, habe jetzt aber doch noch ein Beispielprogramm erstellt. Nach mehrmaligem Studium meiner Kurzanleitung bin ich nämlich zu dem Schluss gekommen, dass man mit diesem Programmierbeispiel nicht zu dem von mir beabsichtigten Ergebnis kommen kann. Das Beispielprogramm, welches die Funktionen der Kamera veranschaulicht, wurde mit Delphi 2005 entwickelt. Wenn Ihr über eine ältere Delphiversion verfügt nehmt einfach die DPR Datei oder erstellt ein neues Projekt mit Euerem Compiler und bindet die benötigten Dateien ein.

Ich habe noch einiges mehr an Code reingepackt als unbedingt nötig, um der Sache optisch ein Mindestmaß an Anspruch zu verleihen. Deswegen können aus diesem Beispielprogramm noch die eine oder andere Komponente entnommen werden (wenn nicht schon vorhanden). Dies sind z.B. Komponenten für Licht, Material, zur Textdarstellung, eine Skybox und zur Handhabung von Grafikdateien (die ist allerdings nicht auf meinem Mist gewachsen). Zusätzlich habe ich noch den Memory Manager FastMM4 beigepackt und eingebunden. Mit diesem kann man sehr schön (besser als mit den von Delphi bereitgestellten Möglichkeiten) nicht freigegebene Resourcen aufspüren. Ich war überrascht was ich alles nicht freigegeben hatte, als ich den zum ersten mal eingesetzt habe.

Das Beispielprogramm findet Ihr unter [[http://files.delphigl.com/Download/kamera_heyroth.zip
]]. Dieses Programm habe ich am 26.12.2007 aktualisiert um die Steuerung per Tastatur und Maus zu vereinfachen. Die bisher in den das Modul benutzenden Methoden KeyDown, KeyUp, ModeDown, MouseUp usw. nötigen Tätigkeiten habe ich in Kameramethoden ausgelagert. Dadurch kann mit einem einzigen Aufruf dieser Methode(n) die nötige Arbeit abgerufen werden.

Aussehen sollte es nach dem Aufruf so:

[[Bild:CameraExample.jpg]]

...

Sollte es noch irgendwelche Fragen zu diesem Modul geben so stehe ich gerne
zur Verfügung (Andree Heyroth, Alias: AndyH).}}

[[Kategorie:Technik_oder_Algorithmus]]

Kamera

2008-02-08T08:40:10Z

Andyh:

Andyh beschreibt in den Artikeln:
*[[Kamera (1)]]
*[[Kamera (2)]]
*[[Kamera (3)]]
wie man eine Kamara realisiert.

{{ZitatVon|Andyh|
Nachdem ich viel Zeit damit verbracht habe eine funktionierende Kamera
zu bauen und es nun endlich geschafft habe, wollte ich diese Funktionalität
auch anderen zur Verfügung stellen.
Da mir schon viel geholfen wurde, kann ich so einen Teil meiner "Schuld"
zurück zahlen.

Die folgend beschriebene Kamera kann sich um alle drei Achsen drehen und sich
in allen Ebenen bewegen. Der Drehpunkt um den sich die Kamera dreht wird mit
dem Aufruf der Prozedur PositionCamera festgelegt. Sollte man diesen Drehpunkt
benötigen (z.B. zum anzeigen eines Koordinatenkreuzes, ...) so kann man auf
die Property PointOfRotation zugreifen (read only).

Die Kamera kann bis zu zehn Positionen speichern und auch wieder herstellen.
(SavePosition, RestorePosition)

Die Kamera kann sich selber zu jeder Zeit unter Beibehaltung der aktuellen
Position senkrecht zur Welt ausrichten.
(Adjust)

Um sicher zu sein, dass auch alle nötigen Definitionen und Funktionen zur
Verfügung stehen habe ich einfach mal einen Großteil meiner Funktionssammlung
beigefügt (Util.pas). Diese Funktionen/Prozeduren werden so oder in leicht
abgeänderter Form wohl bei jedem OpenGL Programmierer existieren.

...

Bisher glaubte ich, dass man mit der von mir erstellten Kurzanleitung auskommt, habe jetzt aber doch noch ein Beispielprogramm erstellt. Nach mehrmaligem Studium meiner Kurzanleitung bin ich nämlich zu dem Schluss gekommen, dass man mit diesem Programmierbeispiel nicht zu dem von mir beabsichtigten Ergebnis kommen kann. Das Beispielprogramm, welches die Funktionen der Kamera veranschaulicht, wurde mit Delphi 2005 entwickelt. Wenn Ihr über eine ältere Delphiversion verfügt nehmt einfach die DPR Datei oder erstellt ein neues Projekt mit Euerem Compiler und bindet die benötigten Dateien ein.

Ich habe noch einiges mehr an Code reingepackt als unbedingt nötig, um der Sache optisch ein Mindestmaß an Anspruch zu verleihen. Deswegen können aus diesem Beispielprogramm noch die eine oder andere Komponente entnommen werden (wenn nicht schon vorhanden). Dies sind z.B. Komponenten für Licht, Material, zur Textdarstellung, eine Skybox und zur Handhabung von Grafikdateien (die ist allerdings nicht auf meinem Mist gewachsen). Zusätzlich habe ich noch den Memory Manager FastMM4 beigepackt und eingebunden. Mit diesem kann man sehr schön (besser als mit den von Delphi bereitgestellten Möglichkeiten) nicht freigegebene Resourcen aufspüren. Ich war überrascht was ich alles nicht freigegeben hatte, als ich den zum ersten mal eingesetzt habe.

Das Beispielprogramm findet Ihr unter [[http://files.delphigl.com/Download/kamera_heyroth.zip
]]. Dieses Programm habe ich am 26.12.2007 aktualisiert um die Steuerung per Tastatur und Maus zu vereinfachen. Die bisher in den das Modul benutzenden Methoden KeyDown, KeyUp, ModeDown, MouseUp usw. nötigen Tätigkeiten habe ich in Kameramethoden ausgelagert. Dadurch kann mit einem einzigen Aufruf dieser Methode(n) die nötige Arbeit abgerufen werden.

Aussehen sollte es nach dem Aufruf so:

[[Bild:CameraExample.jpg]]

...

Sollte es noch irgendwelche Fragen zu diesem Modul geben so stehe ich gerne
zur Verfügung (Andree Heyroth, Alias: AndyH).}}

[[Kategorie:Technik_oder_Algorithmus]]

Kamera (3)

2008-02-05T05:04:25Z

Andyh:

Eine Beschreibung findet ihr unter [[Kamera (1)]]. 
Den Kameracode findet ihr unter [[Kamera (2)]].

Ich habe einfach alle Funktionen meiner Toolsammlung hierhin kopiert. Ich wollte jetzt nicht offline etwas weglöschen was vielleicht benötigt wird. Ihr findet also hier einen ganzen Wust von Funktionen, der zum Betrieb der Kamera nicht benötigt wird. Vielleicht könnt Ihr das eine oder andere aber brauchen...

<pascal>
{******************************************************************}
(*
Released as part of the camera example program
Visit us @ http://www.delphigl.com
Maintained by Florian Sievert (Phobeus)
Phobeus@DelphiGL.com
-------------------------------------------------------------------
License
-------
Copyright (C) 2007 Andree Heyroth

This license applies to everything on www.delphigl.com, except where
otherwise noted.

This software is provided 'as-is', without any express or implied warranty.
In no event will the authors be held liable for any damages arising from
the use of this software.

Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software in a
product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.

Description
-----------
Include file which contains common functions to perform OpenGL specific tasks
like rotating a point around a specific axis or invert matrices or calculate
a vectors normal or calculate a cross product or ...

Requirements
------------
- SDL 1.2 (http://www.libsdl.org/download-1.2.php or your distribution)
- Borland Delphi version 5.0 and above

History
-------
-

Contact
-------
I created this source code in my spare time. If you find a bug or just
wanna say hello, feel free to write to the contributor:

Andree Heyroth (AndyH)
email : heyroth@syncro-concept.de
Visit: http://www.delphigl.com

*******************************************************************************)
unit Util;

interface

uses DglOpenGL, Math, Windows, Graphics, SysUtils, Dialogs{, glBmp};

type
TProjection=(Frustum, Orthographic, Perspective);

TGLPlace=packed record
X,Y,Z: GLdouble;
end;

TScale=packed record
X,Y,Z: GLdouble;
end;

TGLPosition=packed record
X,Y,Z,W: GLdouble;
end;

TPosition = packed record
X,Y,Z,W: GLdouble;
end;

TGLVector = packed record
X,Y,Z: GLdouble;
end;
TPGLvector=^TGLvector;

TTextureCoord=record
X, Y, Z: GLdouble;
end;

TTextureCoordArray = array of TTextureCoord;
TGLvectorArray = array of TGLvector;
TGLdoubleArray = array of GLdouble;
TGLfloatArray = array of GLfloat;

TGKVector = packed record
X,Y,Z: GLdouble;
end;

TAngle = packed record
X,Y,Z: GLdouble;
end;

TGLColor=record
red,green,blue,alpha: GLclampf;
end;

TRotation = packed record
angle, x, y, z: GLdouble;
end;

TTextureInfo = packed record
BitmapName: string;
TextureNum: GLUint;
//theBmp: TGLbmp;
end;
TTextureList = array of TTextureInfo;

TMatrix = array [0..3,0..3] of GLdouble;
TArrMatrix = array [0..15] of GLdouble;
TFrustum = array [0..5,0..3] of GLdouble;
TArrVector = array [0..3] of GLdouble;

function GetMatrixX (matrix: TArrMatrix): TGLvector;
function GetMatrixY (matrix: TArrMatrix): TGLvector;
function GetMatrixZ (matrix: TArrMatrix): TGLvector;
function GetMatrixPos (matrix: TArrMatrix): TGLvector;
procedure SetMatrixX (var matrix: TArrMatrix; v: TGLvector);
procedure SetMatrixY (var matrix: TArrMatrix; v: TGLvector);
procedure SetMatrixZ (var matrix: TArrMatrix; v: TGLvector);
procedure SetMatrixPos (var matrix: TArrMatrix; v: TGLvector);
function Multiply (Color: TGLcolor; m: GLdouble): TGLcolor;overload;
function Multiply (V1, V2: TGLVector): TGLVector;overload;
function Multiply (M1, M2: TArrMatrix): TArrMatrix;overload;
function Divide (V1, V2: TGLVector): TGLVector;overload;
function Divide (V1: TGLVector; d: GLdouble): TGLVector;overload;
function MakeVector(X,Y,Z:GLdouble):TArrVector;overload;
function MakeVector(X,Y,Z,W:GLdouble):TArrVector;overload;
function Normalize(aVector:TArrVector):TArrVector;overload;
function Normalize(aVector:TGLVector):TGLVector;overload;
function GetIdentity(Matrix:TMatrix):TMatrix;overload;
function GetIdentity(Matrix:TArrMatrix):TArrMatrix;overload;
function MatrixTranspose(const M:TMatrix):TMatrix;register;
function NearestPoint(Axis, Point: TGLVector): TGLVector;
function VectorRotateX(v:TArrVector;a:GLdouble):TArrVector;overload;
function VectorRotateY(v:TArrVector;a:GLdouble):TArrVector;overload;
function VectorRotateZ(v:TArrVector;a:GLdouble):TArrVector;overload;
function VectorRotateX(v:TGLVector;a:GLdouble):TGLVector;overload;
function VectorRotateY(v:TGLVector;a:GLdouble):TGLVector;overload;
function VectorRotateZ(v:TGLVector;a:GLdouble):TGLVector;overload;
function VectorRotateX(v,c:TGLvector;a:GLdouble):TGLVector;overload;
function VectorRotateY(v,c:TGLvector;a:GLdouble):TGLVector;overload;
function VectorRotateZ(v,c:TGLvector;a:GLdouble):TGLVector;overload;
function VectorRotateX(v1,v2,v3,v4:TGLVector;a:GLdouble):TGLVector;overload;
function VectorRotateY(v1,v2,v3,v4:TGLVector;a:GLdouble):TGLVector;overload;
function VectorRotateZ(v1,v2,v3,v4:TGLVector;a:GLdouble):TGLVector;overload;

function AxisXRotation (V1, V2: TGLvector): GLdouble;
function AxisYRotation (V1, V2: TGLvector): GLdouble;
function AxisZRotation (V1, V2: TGLvector): GLdouble;

function GL2GKVector (V: TGLVector): TGKVector;
function GK2GLVector (V: TGKVector): TGLVector;
function GL2WinColor (GLcol: TGLcolor): TColor;
function Win2GLColor (WinCol: Tcolor): TGLcolor;
function CalcNormale (V1, V2, V3: TGLVector): TGLVector;
function CrossProduct(V1, V2: TGLVector): TGLVector;
function DotProduct (V1, V2: TGLVector): GLdouble;
function LoadTexture(Filename: String; var Texture: GLuint): Boolean;
function Magnitude(V1: TGLVector): GLdouble;overload;
function Magnitude(X, Y: GLdouble): GLdouble;overload;
function ScalarProduct (V1, V2: TGLVector): GLdouble;
function MinVector (V1, V2: TGLvector): TGLvector;
function MaxVector (V1, V2: TGLvector): TGLvector;
function SubtractVector (Vec1, Vec2: TGLVector): TGLVector;overload;
function SubtractVector (Vec: TGLVector; X, Y, Z: GLdouble): TGLVector;overload;
function AddVector (Vec1, Vec2: TGLVector): TGLVector;overload;
function AddVector (Vec: TGLVector; X, Y, Z: GLdouble): TGLVector;overload;
function ForceForegroundWindow(hwnd: THandle): Boolean;
function ValidTexture (tex: GLUint; ErrStr: string): boolean;
procedure ResetGLErrorFlags;
procedure InitGLEnv (dc: HDC; rc: HGLRC; hndl: THandle);// pixelformat setzen
procedure CopyVector (FromVektor: TGLVector; var ToVektor: TGLVector);
procedure InitVector (var V1: TGLVector; x, y, z: GLdouble);overload;
procedure InitVector (var V1: TGKVector; x, y, z: GLdouble);overload;
procedure InitVector (var V1: TArrVector; x, y, z: GLdouble);overload;
procedure InitScale (var S1: TScale; x, y, z: GLdouble);
procedure LoadBitmap(Filename: String;
out Width: Cardinal;
out Height: Cardinal;
out pData: Pointer);
procedure GetRotation (V1, V2: TGLVector;
var Rotation: TRotation);
function MakeTextureFromBitmap (Bitmap: string;
var BitmapList: TTextureList): GLenum;
procedure EnableTexture (Texture: GLenum; TextureTiled: boolean);
procedure DisableTexture;
function TextToGLVector (VTxt: string): TGLVector;
function TextToGKVector (VTxt: string): TGKVector;
function GKVectorToText (V1: TGKVector): string;overload;
function GKVectorToText (V1: TGKVector; digits, decimals: byte): string;overload;
function GLVectorToText (V1: TGLVector): string;overload;
function GLVectorToText (V1: TGLVector; digits, decimals: byte): string;overload;
function MatrixToText (M: TArrMatrix): string;
function CheckFormat (number: string; digits, decimals: byte): string;
function MyCone (Start, Ende: TGLVector;
RadiusStart, RadiusEnde: GLdouble;
Slices: integer; TileX, TileY: GLdouble): boolean;
function InvertMatrix (src: TArrMatrix; var inverse: TArrMatrix): boolean;
function ExePath: string;

const
C_X = 0;
C_Y = 1;
C_Z = 2;
C_W = 3;
C_EPS:GLdouble=0.01;
C_DEGTORAD:GLdouble=3.1412/180;
C_RADTODEG:GLdouble=180/3.1412;
C_LAMBDA_INCREMENT:GLdouble=0.01;
C_PI=3.1415926535;
C_PI_DIV_180=C_PI/180;

implementation

uses Forms, {KanalUtil,} OGLinclude, Controls;

function MyPower (Base: extended; Exp: integer): extended;
//var
// i: integer;
begin
// result := Base;
// for i := 2 to Exp do
// result := result * Base;

result := Base * Base;
end;

procedure CopyVector (FromVektor: TGLVector; var ToVektor: TGLVector);
begin
ToVektor.X := FromVektor.X;
ToVektor.Y := FromVektor.Y;
ToVektor.Z := FromVektor.Z;
end;

function GetMatrixX (matrix: TArrMatrix): TGLvector;
// holt den X-vektor aus matrix und gibt ihn zurück
begin
result.X := matrix[00];
result.Y := matrix[01];
result.Z := matrix[02];
end;

function GetMatrixY (matrix: TArrMatrix): TGLvector;
// holt den Y-vektor aus matrix und gibt ihn zurück
begin
result.X := matrix[04];
result.Y := matrix[05];
result.Z := matrix[06];
end;

function GetMatrixZ (matrix: TArrMatrix): TGLvector;
// holt den Z-vektor aus matrix und gibt ihn zurück
begin
result.X := matrix[08];
result.Y := matrix[09];
result.Z := matrix[10];
end;

function GetMatrixPos (matrix: TArrMatrix): TGLvector;
// holt den Position-vektor aus matrix und gibt ihn zurück
begin
result.X := matrix[12];
result.Y := matrix[13];
result.Z := matrix[14];
end;

procedure SetMatrixX (var matrix: TArrMatrix; v: TGLvector);
// setzt den durch v bestimmten X-vektor in matrix
begin
matrix[00] := v.X;
matrix[01] := v.Y;
matrix[02] := v.Z;
end;

procedure SetMatrixY (var matrix: TArrMatrix; v: TGLvector);
// setzt den durch v bestimmten Y-vektor in matrix
begin
matrix[04] := v.X;
matrix[05] := v.Y;
matrix[06] := v.Z;
end;

procedure SetMatrixZ (var matrix: TArrMatrix; v: TGLvector);
// setzt den durch v bestimmten Z-vektor in matrix
begin
matrix[08] := v.X;
matrix[09] := v.Y;
matrix[10] := v.Z;
end;

procedure SetMatrixPos (var matrix: TArrMatrix; v: TGLvector);
// setzt den durch v bestimmten Position-vektor in matrix
begin
matrix[12] := v.X;
matrix[13] := v.Y;
matrix[14] := v.Z;
end;

function MinVector (V1, V2: TGLvector): TGLvector;
// gibt den Vector mit der geringeren Länge zurück
begin
result := V1;
if Magnitude (V1) > Magnitude (V2) then
result := V2;
end;

function MaxVector (V1, V2: TGLvector): TGLvector;
// gibt den Vector mit der größeren Länge zurück
begin
result := V1;
if Magnitude (V1) < Magnitude (V2) then
result := V2;
end;

function SubtractVector (Vec1, Vec2: TGLVector): TGLVector;
// subtrahiert Vec2 von vec1 und gibt das ergebnis in vec3 zurück
var
Vec3: TGLVector;
begin
Vec3 .X := Vec1.X - Vec2.X;
Vec3 .Y := Vec1.Y - Vec2.Y;
Vec3 .Z := Vec1.Z - Vec2.Z;
result := Vec3;
end;

function SubtractVector (Vec: TGLVector; X, Y, Z: GLdouble): TGLVector;
// subtrahiert X, Y, Z von vec.x, vec.y, vec.z und gibt das
// ergebnis zurück
begin
Vec .X := Vec.X - X;
Vec .Y := Vec.Y - Y;
Vec .Z := Vec.Z - Z;
result := Vec;
end;

function AddVector (Vec1, Vec2: TGLVector): TGLVector;
// addiert Vec2 auf vec1 und gibt das ergebnis in vec3 zurück
var
Vec3: TGLVector;
begin
Vec3 .X := Vec1.X + Vec2.X;
Vec3 .Y := Vec1.Y + Vec2.Y;
Vec3 .Z := Vec1.Z + Vec2.Z;
result := Vec3;
end;

function AddVector (Vec: TGLVector; X, Y, Z: GLdouble): TGLVector;
// addiert X, Y, Z auf vec.x, vec.y, vec.z und gibt das
// ergebnis zurück
begin
Vec .X := Vec.X + X;
Vec .Y := Vec.Y + Y;
Vec .Z := Vec.Z + Z;
result := Vec;
end;

function Magnitude(V1: TGLVector): GLdouble;
var
Ergebnis: GLdouble;
begin
// gibt die länge des vektors im dreidimensionalen raum zurück
Ergebnis := MyPower(V1.X,2)+MyPower(V1.Y,2)+MyPower(V1.Z,2);
try
result := sqrt(Ergebnis);
except
result := 0;
end;
end;

function Magnitude(X, Y: GLdouble): GLdouble;
var
Ergebnis: GLdouble;
begin
// gibt die länge des vektors im zweidimensionalen raum zurück
Ergebnis := MyPower(X,2)+MyPower(Y,2);
try
result := sqrt(Ergebnis);
except
result := 0;
end;
end;

function DotProduct (V1, V2: TGLVector): GLdouble;
// errechnet den winkel zwischen zwei vektoren
var
len1, len2: GLdouble;
Ergebnis: GLdouble;
begin
//len1 := MyPower(V1.X,2)+MyPower(V1.Y,2)+MyPower(V1.Z,2);
//len2 := MyPower(V2.X,2)+MyPower(V2.Y,2)+MyPower(V2.Z,2);
len1 := Magnitude (V1);
len2 := Magnitude (V2);
Ergebnis := ScalarProduct (V1, V2);
Ergebnis := arccos (Ergebnis / (len1 * len2));
result := radtodeg (Ergebnis) * 2.0;
end;

function CrossProduct(V1, V2: TGLVector): TGLVector;
var
CrossVec: TGLVector;
begin
//CrossVec.X := +((V1.Y*V2.Z) - (V1.Z*V2.Y));
//CrossVec.Y := -((V1.X*V2.Z) - (V1.Z*V2.X));
//CrossVec.Z := +((V1.X*V2.Y) - (V1.Y*V2.X));
CrossVec.X := ((V1.Y*V2.Z) - (V1.Z*V2.Y));
CrossVec.Y := ((V1.Z*V2.X) - (V1.X*V2.Z));
CrossVec.Z := ((V1.X*V2.Y) - (V1.Y*V2.X));
result := CrossVec;
end;

function CalcNormale (V1, V2, V3: TGLVector): TGLVector;
var
Kreuz: TGLvector;
V1V2, V1V3: TGLvector;
begin
// zum testen:
InitVector (result, 0, 0, 0);
// gibt die normale von 3 vektoren zurück (die senkrechte auf die
// durch die drei vektoren gebildete ebene)
V1V2 := SubtractVector (V2, V1);
V1V3 := SubtractVector (V3, V1);

Kreuz := CrossProduct (V1V2, V1V3);

result := Normalize (Kreuz);
end;

procedure InitVector (var V1: TGLVector; x, y, z: GLdouble);
begin
V1.x := x;
V1.y := y;
V1.z := z;
end;

procedure InitVector (var V1: TGKVector; x, y, z: GLdouble);
begin
V1.x := x;
V1.y := y;
V1.z := z;
end;

procedure InitVector (var V1: TArrVector; x, y, z: GLdouble);
begin
V1[C_X] := x;
V1[C_Y] := y;
V1[C_Z] := z;
end;

procedure InitScale (var S1: TScale; x, y, z: GLdouble);
begin
S1.x := x;
S1.y := y;
S1.z := z;
end;

function Multiply (V1, V2: TGLVector): TGLVector;
var
ret: TGLVector;
begin
// zwei vektoren miteinander multiplizieren
ret.X := V1.X * V2.X;
ret.Y := V1.Y * V2.Y;
ret.Z := V1.Z * V2.Z;
result := ret;
end;

function Divide (V1, V2: TGLVector): TGLVector;
var
ret: TGLVector;
begin
// zwei vektoren miteinander multiplizieren
ret.X := V1.X / V2.X;
ret.Y := V1.Y / V2.Y;
ret.Z := V1.Z / V2.Z;
result := ret;
end;

function ScalarProduct (V1, V2: TGLVector): GLdouble;
begin
// die summe der potenzen der einzelnen achsen von zwei vektoren errechnen
result := (V1.X*V2.X +
V1.Y*V2.Y +
V1.Z*V2.Z);
end;

function LoadTexture(Filename: String; var Texture: GLuint): Boolean;
resourcestring
Res_LoadUnable = 'Unable to load ';
Res_LoadingTex = 'Loading Textures';
var
pData: Pointer;
Width: Cardinal;
Height: Cardinal;
newTexture: GLint;
begin
pData :=nil;
LoadBitmap(Filename, Width, Height, pData);

if (Assigned(pData)) then
Result := True
else
begin
Result := False;
MessageBox(0, PChar(Res_LoadUnable + filename),
pchar (Res_LoadingTex), MB_OK);
exit;
end;

glGenTextures(1, @NewTexture);
glBindTexture(GL_TEXTURE_2D, NewTexture);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); {Texture blends with object background}

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); { only first two can be used }
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); { all of the above can be used }

gluBuild2DMipmaps(GL_TEXTURE_2D, 3, Width, Height, GL_RGB, GL_UNSIGNED_BYTE, pData);

Texture := newTexture;
end;

procedure LoadBitmap(Filename: String;
out Width: Cardinal;
out Height: Cardinal;
out pData: Pointer);
resourcestring
Res_ReadErr = 'Error reading palette';
Res_OpenErr = 'Error opening: ';
Res_BitmapDataErr = 'Error reading bitmap data';
Res_BmpUnit = 'BMP Unit';
var
FileHeader: BITMAPFILEHEADER;
InfoHeader: BITMAPINFOHEADER;
Palette: array of RGBQUAD;
BitmapFile: THandle;
BitmapLength: Cardinal;
PaletteLength: Cardinal;
ReadBytes: Cardinal;
Front: ^Byte;
Back: ^Byte;
Temp: Byte;
I : Cardinal;
begin
BitmapFile := CreateFile(PChar(Filename), GENERIC_READ, FILE_SHARE_READ, nil, OPEN_EXISTING, 0, 0);
if (BitmapFile = INVALID_HANDLE_VALUE) then begin
MessageBox(0, PChar(Res_OpenErr+Filename), PChar(Res_BmpUnit), MB_OK);
Exit;
end;

// Get header information
ReadFile(BitmapFile, FileHeader, SizeOf(FileHeader), ReadBytes, nil);
ReadFile(BitmapFile, InfoHeader, SizeOf(InfoHeader), ReadBytes, nil);

// Get palette
PaletteLength := InfoHeader.biClrUsed;
SetLength(Palette, PaletteLength);
ReadFile(BitmapFile, Palette, PaletteLength, ReadBytes, nil);
if (ReadBytes <> PaletteLength) then begin
MessageBox(0, PChar(Res_ReadErr), PChar(Res_BmpUnit), MB_OK);
CloseHandle(BitmapFile);
Exit;
end;

Width := InfoHeader.biWidth;
Height := InfoHeader.biHeight;
BitmapLength := InfoHeader.biSizeImage;
if BitmapLength = 0 then
BitmapLength := Width * Height * InfoHeader.biBitCount Div 8;

// Get the actual pixel data
GetMem(pData, BitmapLength);
ReadFile(BitmapFile, pData^, BitmapLength, ReadBytes, nil);
if (ReadBytes <> BitmapLength) then begin
MessageBox(0, PChar(Res_BitmapDataErr), PChar(Res_BmpUnit), MB_OK);
CloseHandle(BitmapFile);
Exit;
end;
CloseHandle(BitmapFile);

// Bitmaps are stored BGR and not RGB, so swap the R and B bytes.
for I :=0 to Width * Height - 1 do
begin
Front := Pointer(Cardinal(pData) + I*3);
Back := Pointer(Cardinal(pData) + I*3 + 2);
Temp := Front^;
Front^ := Back^;
Back^ := Temp;
end;
end;

function GK2GLVector (V: TGKVector): TGLVector;
// ändert Gauss-Krüger Koordinaten in OpenGL Koordinaten um
begin
result.X := V.X;
result.Y := V.Z;
result.Z := V.Y;
end;

function GL2GKVector (V: TGLVector): TGKVector;
// ändert OpenGL Koordinaten in Gauss-Krüger Koordinaten um
begin
result.X := V.X;
result.Y := V.Z;
result.Z := V.Y;
end;

function Win2GLColor (WinCol: TColor): TGLcolor;
begin
result.Red := GetRValue (WinCol) / 255;
result.Green := GetGValue (WinCol) / 255;
result.Blue := GetBValue (WinCol) / 255;
result.Alpha := 0.0;
end;

function GL2WinColor (GLcol: TGLcolor): TColor;
begin
result := Rgb (StrToInt (FloatToStr (int (GLcol.Red * 255))),
StrToInt (FloatToStr (int (GLcol.Green * 255))),
StrToInt (FloatToStr (int (GLcol.Blue * 255))));
end;

procedure GetRotation (V1, V2: TGLVector;
var Rotation: TRotation);
var
tmpCyl, tmpZiel, nullVec: TGLVector;
normale, ResultLen: TGLVector;
VectorLength: GLdouble;
begin
// temporäre vektoren initialisieren
InitVector (nullVec, 0,0,0);
InitVector (tmpCyl, 0,0,0);

// länge des zu drehenden objekts ermitteln
ResultLen := SubtractVector (V2, V1);
VectorLength := Magnitude (ResultLen);

// vektoren zur bildung der dreiecksfläche bilden.
// die schenkel schneiden sich im nullpunkt
// der Cylinder läuft immer entlang der Z-Achse
tmpCyl.Z := VectorLength;
tmpZiel := SubtractVector (V2, V1);
tmpZiel.Z := tmpZiel.Z + VectorLength;

// senkrechte zu den beiden vektoren bilden
// (um diese achse soll nachher gedreht werden)
// drehachse für späteren gebrauch speichern
normale := CalcNormale (tmpCyl, tmpZiel, nullVec);

// um "Angle" Grad soll nachher gedreht werden
Rotation.Angle := DotProduct(tmpCyl, tmpZiel);
Rotation.X := normale.X;
Rotation.Y := normale.Y;
Rotation.Z := normale.Z;
end;

function MakeTextureFromBitmap (Bitmap: string;
var BitmapList: TTextureList): GLenum;
// die funktion lädt die in Bitmap übergebene Grafik und gibt die Textturnummer
// zurück. ist das bitmap schon im array BitmapList enthalten, wird die bereits
// vergeben nummer zurückgegeben.
resourcestring
Res_TextureNotFound = 'Texturdatei nicht gefunden: ';
Res_Error = 'Error';
var
i, Laenge: integer;
begin
result := 0;
if length (trim (Bitmap)) = 0 then
exit;

BitMap := uppercase (BitMap); // wegen dem folgenden vergleich

// suchen, ob die textur schon geladen wurde
Laenge := length (BitmapList);
if Laenge > 0 then
for i := low (BitMapList) to high (BitMapList) do
begin
if (BitmapList[i].BitmapName = Bitmap) and
//(glIsTexture (BitmapList[i].TextureNum)) then
(BitmapList[i].TextureNum > 0) then
result := BitmapList[i].TextureNum;
end;

if result = 0 then
begin
if not fileexists (Bitmap) then
begin
MessageBox (0, PChar (Res_TextureNotFound+Bitmap),
pchar (Res_Error), MB_OK or MB_ICONERROR);
exit;
end;
end;

if (result = 0) then
begin
setlength (BitmapList, Laenge+1);
BitmapList[Laenge].BitmapName := Bitmap;
BitmapList[Laenge].TextureNum := 0;
{
BitMapList[Laenge].theBmp := TglBmp.Create;
if BitMapList[Laenge].theBmp.LoadImage (BitMap) then
begin
BitMapList[Laenge].theBmp.SetTextureWrap(GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE);
BitMapList[Laenge].theBmp.GenTexture (false, false);
result := BitmapList[Laenge].theBmp.TextureID;
BitmapList[Laenge].TextureNum := BitmapList[Laenge].theBmp.TextureID;
end;
}
end;
end;

procedure EnableTexture (Texture: GLenum; TextureTiled: boolean);
begin
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, Texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
if TextureTiled then
begin
glTexparameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexparameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
end
else
begin
glTexparameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexparameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
end;
end;

procedure DisableTexture;
begin
glDisable(GL_TEXTURE_2D);
end;

function TextToGLVector (VTxt: string): TGLVector;
const
subdelim: char = '/';
var
posi: integer;
V1: TGLVector;
begin
InitVector (V1,0,0,0);
posi := pos (subdelim, VTxt);
if posi > 0 then
begin
V1.X := StrToFloat (copy (VTxt, 1, posi-1));
VTxt := copy (VTxt, posi+1, length (VTxt));
posi := pos (subdelim, VTxt);
end;
if posi > 0 then
begin
V1.Y := StrToFloat (copy (VTxt, 1, posi-1));
VTxt := copy (VTxt, posi+1, length (VTxt));
end;
if length (VTxt) > 0 then V1.Z := StrToFloat (VTxt);

result := V1;
end;

function TextToGKVector (VTxt: string): TGKVector;
const
subdelim: char = '/';
var
posi: integer;
V1: TGKVector;
begin
InitVector (V1,0,0,0);
posi := pos (subdelim, VTxt);
if posi > 0 then
begin
V1.X := StrToFloat (copy (VTxt, 1, posi-1));
VTxt := copy (VTxt, posi+1, length (VTxt));
posi := pos (subdelim, VTxt);
end;
if posi > 0 then
begin
V1.Y := StrToFloat (copy (VTxt, 1, posi-1));
VTxt := copy (VTxt, posi+1, length (VTxt));
end;
if length (VTxt) > 0 then V1.Z := StrToFloat (VTxt);

result := V1;
end;

function GKVectorToText (V1: TGKVector): string;
const
subdelim: char = '/';
var
VTxt: string;
begin
VTxt := FloatToStr (V1.X) + subdelim;
VTxt := VTxt + FloatToStr (V1.Y) + subdelim;
VTxt := VTxt + FloatToStr (V1.Z);
result := VTxt;
end;

function GKVectorToText (V1: TGKVector; digits, decimals: byte): string;
const
subdelim: char = '/';
var
VTxt, frmt, sX, sY, sZ: string;
begin
{
VTxt := Format('%*.*f', [digits, decimals, V1.X]) + subdelim;
VTxt := VTxt + Format('%*.*f', [digits, decimals, V1.Y]) + subdelim;
VTxt := VTxt + Format('%*.*f', [digits, decimals, V1.Z]);
}
frmt := '%'+IntToStr(digits)+'.'+IntToStr(decimals)+'f';

sX := Format(frmt, [V1.X]);
sY := Format(frmt, [V1.Y]);
sZ := Format(frmt, [V1.Z]);
//sX := FloatToStrF(V1.X, fffixed, digits, decimals);
//sY := FloatToStrF(V1.Y, fffixed, digits, decimals);
//sZ := FloatToStrF(V1.Z, fffixed, digits, decimals);

sX := trim (sX);
sY := trim (sY);
sZ := trim (sZ);

sX := CheckFormat (sX, digits, decimals);
sY := CheckFormat (sY, digits, decimals);
sZ := CheckFormat (sZ, digits, decimals);

VTxt := sX + subdelim + sY + subdelim + sZ;

result := VTxt;
end;

function GLVectorToText (V1: TGLVector): string;
const
subdelim: char = '/';
var
VTxt: string;
begin
VTxt := FloatToStr (V1.X) + subdelim;
VTxt := VTxt + FloatToStr (V1.Y) + subdelim;
VTxt := VTxt + FloatToStr (V1.Z);
result := VTxt;
end;

function GLVectorToText (V1: TGLVector; digits, decimals: byte): string;
const
subdelim: char = '/';
var
VTxt, frmt, sX, sY, sZ: string;
begin
{
VTxt := Format('%*.*f', [digits, decimals, V1.X]) + subdelim;
VTxt := VTxt + Format('%*.*f', [digits, decimals, V1.Y]) + subdelim;
VTxt := VTxt + Format('%*.*f', [digits, decimals, V1.Z]);
}
frmt := '%'+IntToStr(digits)+'.'+IntToStr(decimals)+'f';

sX := Format(frmt, [V1.X]);
sY := Format(frmt, [V1.Y]);
sZ := Format(frmt, [V1.Z]);
//sX := FloatToStrF(V1.X, fffixed, digits, decimals);
//sY := FloatToStrF(V1.Y, fffixed, digits, decimals);
//sZ := FloatToStrF(V1.Z, fffixed, digits, decimals);

sX := trim (sX);
sY := trim (sY);
sZ := trim (sZ);

sX := CheckFormat (sX, digits, decimals);
sY := CheckFormat (sY, digits, decimals);
sZ := CheckFormat (sZ, digits, decimals);

VTxt := sX + subdelim + sY + subdelim + sZ;

result := VTxt;
end;

function MatrixToText (M: TArrMatrix): string;
const
subdelim: char = '/';
var
VTxt: string;
i: integer;
begin
VTxt := '';
for i := low (M) to high(M) do
begin
VTxt := VTxt + Format('%14.6f', [M[i]]);
if i < high (M) then
VTxt := VTxt + subdelim;
end;

result := VTxt;
end;

function MyCone (Start, Ende: TGLVector;
RadiusStart, RadiusEnde: GLdouble;
Slices: integer; TileX, TileY: GLdouble): boolean;
var
Slice: Integer;
Laenge, xdelta, zdelta: GLdouble;
V1, V2, V3, V4: TGLvector;
A, B: double;
//tmpVec: TGLvector;
begin
result := true;

// laenge des kegels berechnen
// hierbei wird davon ausgegangen, dass der kegel senkrecht steht
Laenge := Ende.y - Start.y;

// die folgende längenberechnung stimmt nicht mit der senkrechten
// verbindungslinie der beiden konusebenen überein, wenn die radien
// sich unterscheiden, da sich dann ein schiefer vektor ergibt. der
// ist natürlich länger als die senkrechte.
//tmpVec := SubtractVector (Start, Ende);
//Laenge := Magnitude (tmpVec);

// radiusdifferenz der oberen und unteren ebene des konus berechnen
xdelta := Start.x - Ende.x;
zdelta := Start.z - Ende.z;
xdelta := -xdelta;
//zdelta := zdelta;

glBegin (GL_TRIANGLE_STRIP);
// der kegel wird entlang der z-achse gezeichnet
V1.z := 0;
V2.z := 0;
V3.z := Laenge;
V4.z := Laenge;
// immer ein dreieck an das andere: mit zwei punkten des oberen
// radius und einem des unteren bzw. einem des oberen und zwei des
// unteren ein dreieck zeichnen. mit dem nächsten neu errechneten punkt
// und den zwei vorhergehenden haben wir immer das nächste dreieck.
// so viele dreiecke wie pizzastücke (slices) gewünscht.
for Slice := 1 to Slices do begin
A := 2 * PI * Slice / Slices;
B := 2 * PI * (Slice+1) / Slices;
V1.x := sin(A)*RadiusStart;
V1.y := cos(A)*RadiusStart;
V2.x := sin(B)*RadiusStart;
V2.y := cos(B)*RadiusStart;
// umsetzung von y nach z-achse
V3.x := (sin(B)*RadiusEnde)+xdelta;
V3.y := (cos(B)*RadiusEnde)+zdelta;
V4.x := (sin(A)*RadiusEnde)+xdelta;
V4.y := (cos(A)*RadiusEnde)+zdelta;
//Normale := CalcNormale (V1, V3, V2);
//glNormal3fv(@Normale);
if Slice = 1 then
begin
glTexCoord2d(1*TileX,0); glVertex3dv(@V1);
glTexCoord2d(1*TileX,1*TileY); glVertex3dv(@V4);
glTexCoord2d(1*TileX-Slice/Slices*TileX,0); glVertex3dv(@V2);
glTexCoord2d(1*TileX-Slice/Slices*TileX,1*TileY); glVertex3dv(@V3);
end
else
begin
glTexCoord2d(1*TileX-Slice/Slices*TileX,0); glVertex3dv(@V2);
glTexCoord2d(1*TileX-Slice/Slices*TileX,1*TileX); glVertex3dv(@V3);
end;
// so hatte ich mir das zuerst gedacht:
// aktuellen und nächsten punkt des kreises (oben und unten)
// nehmen und ein rechteck zeichnen. alle rechtecke zusammen sollten
// einen geschlossenen kegel ergeben.
//glBegin(GL_QUADS);
// glNormal3dv(@Normale);
// glTexCoord2d(0,0); glVertex3dv(@V2);
// glTexCoord2d(1,0); glVertex3dv(@V1);
// glTexCoord2d(1,1); glVertex3dv(@V4);
// glTexCoord2d(0,1); glVertex3dv(@V3);
//glEnd;
end;
glEnd; // (GL_TRIANGLE_STRIP)
end;

{-----------------------------------------------------------------------------}
{----------------------------- für TRUVCamera --------------------------------}
{-----------------------------------------------------------------------------}

function Multiply(M1, M2: TArrMatrix): TArrMatrix;
// multiplies two 4x4 matrices
var
ret: TArrMatrix;
begin
glPushMatrix();
glLoadMatrixd(@M1);
glMultMatrixd(@M2);
glGetDoublev(GL_MODELVIEW_MATRIX,@ret);
glPopMatrix();
result := ret;
end;

function MakeVector(X,Y,Z:GLdouble):TArrVector;
begin
result[0]:=x;
result[1]:=y;
result[2]:=z;
end;

function MakeVector(X,Y,Z,W:GLdouble):TArrVector;
begin
result[0]:=x;
result[1]:=y;
result[2]:=z;
result[3]:=w;
end;

function Normalize(aVector:TArrVector):TArrVector;overload;
var
d:double;
begin
InitVector (result,1,1,1);
d:=Sqrt(Sqr(aVector[C_X])+Sqr(aVector[C_Y])+Sqr(aVector[C_Z]));
if d=0 then
begin
//raise exception.Create('Zero length vector(Normalize 1)');
exit;
end;
result[C_X]:=aVector[C_X]/d;
result[C_Y]:=aVector[C_Y]/d;
result[C_Z]:=aVector[C_Z]/d;
end;

function Normalize(aVector:TGLVector):TGLVector;overload;
var
d:double;
begin
InitVector (result,1,1,1);
d:=Sqrt(Sqr(aVector.X)+Sqr(aVector.Y)+Sqr(aVector.Z));
if d=0 then
begin
//raise exception.Create('Zero length vector(Normalize 2)');
exit;
end;
result.X:=aVector.X/d;
result.Y:=aVector.Y/d;
result.Z:=aVector.Z/d;
end;

function GetIdentity(Matrix:TMatrix):TMatrix;
begin
result[0,0]:=1.0;result[0,1]:=0.0;result[0,2]:=0.0;result[0,3]:=0.0;
result[1,0]:=0.0;result[1,1]:=1.0;result[1,2]:=0.0;result[1,3]:=0.0;
result[2,0]:=0.0;result[2,1]:=0.0;result[2,2]:=1.0;result[2,3]:=0.0;
result[3,0]:=0.0;result[3,1]:=0.0;result[3,2]:=0.0;result[3,3]:=1.0;
end;

function GetIdentity(Matrix:TArrMatrix):TArrMatrix;
begin
result[0]:=1.0;result[1]:=0.0;result[2]:=0.0;result[3]:=0.0;
result[4]:=0.0;result[5]:=1.0;result[6]:=0.0;result[7]:=0.0;
result[8]:=0.0;result[9]:=0.0;result[10]:=1.0;result[11]:=0.0;
result[12]:=0.0;result[13]:=0.0;result[14]:=0.0;result[15]:=1.0;
end;

function MatrixTranspose(const M:TMatrix):TMatrix;register;
var
i,j:integer;
begin
for i:=0 to 3 do
for j:=0 to 3 do
result[i,j]:=M[j,i];
end;

function VectorRotateX(v:TArrVector;a:GLdouble):TArrVector;
var
temp: TArrVector;
sine,cosine:GLdouble;
begin
a:=a*C_DEGTORAD;
sine:=Sin(a);
cosine:=Cos(a);

temp[C_X] := v[C_x];
temp[C_Y] := (v[C_Y] * cosine) + (v[C_Z] * -sine);
temp[C_Z] := (v[C_Y] * sine) + (v[C_Z] * cosine);
result := temp;
end;

function VectorRotateY(v: TArrVector;a:GLdouble):TArrVector;
var
temp: TArrVector;
sine,cosine:GLdouble;
begin
a:=a*C_DEGTORAD;
sine:=Sin(a);
cosine:=Cos(a);

temp[C_x] := (v[C_x] * cosine) + (v[C_z] * sine);
temp[C_y] := v[C_y];
temp[C_z] := (v[C_x] * -sine) + (v[C_z] * cosine);
result := temp;
end;

function VectorRotateZ(v: TArrVector; a: GLdouble):TArrVector;
var
temp: TArrVector;
sine,cosine:GLdouble;
begin
a:=a*C_DEGTORAD;
sine:=Sin(a);
cosine:=Cos(a);
temp[C_x] := (v[C_x] * cosine) + (v[C_y] * -sine);
temp[C_y] := (v[C_x] * sin(a)) + (v[C_y] * cosine);
temp[C_z] := v[C_z];
result := temp;
end;

function VectorRotateX(v:TGLVector;a:GLdouble):TGLVector;
var
temp: TGLVector;
sine,cosine:GLdouble;
begin
a:=a*C_DEGTORAD;
sine:=Sin(a);
cosine:=Cos(a);

temp.X := v.x;
temp.Y := (v.Y * cosine) + (v.Z * -sine);
temp.Z := (v.Y * sine) + (v.Z * cosine);

result := temp;
end;

function VectorRotateY(v: TGLVector;a:GLdouble):TGLVector;
var
temp: TGLVector;
sine,cosine:GLdouble;
begin
a:=a*C_DEGTORAD;
sine:=Sin(a);
cosine:=Cos(a);

temp.x := (v.x * cosine) + (v.z * sine);
temp.y := v.y;
temp.z := (v.X * -sine) + (v.z * cosine);
result := temp;
end;

function VectorRotateZ(v: TGLVector; a: GLdouble):TGLVector;
var
temp: TGLVector;
sine,cosine:GLdouble;
begin
a:=a*C_DEGTORAD;
sine:=Sin(a);
cosine:=Cos(a);

temp.x := (v.x * cosine) + (v.y * -sine);
temp.y := (v.x * sin(a)) + (v.y * cosine);
temp.z := v.z;
result := temp;
end;

function VectorRotateX(v,c: TGLvector;a: GLdouble):TGLVector;
// v: zu drehender punkt
// c: zentrum
// a: winkel
var
temp, temp2: TGLVector;
begin
// das übergebene zentrum in den nullpunkt holen
temp2 := SubtractVector (v, c);

// jetzt so drehen, als ob alles um den nullpunkt angeordnet wäre
temp := VectorRotateX (temp2, a);

// und das ergebnis wieder in den ausgangspunkt zurück verschieben
result := AddVector (temp, c);
end;

function VectorRotateY(v,c: TGLvector;a: GLdouble):TGLVector;
// v: zu drehender punkt
// c: zentrum
// a: winkel
var
temp, temp2: TGLVector;
begin
// das übergebene zentrum in den nullpunkt holen
temp2 := SubtractVector (v, c);

// jetzt so drehen, als ob alles um den nullpunkt angeordnet wäre
temp := VectorRotateY (temp2, a);

// und das ergebnis wieder in den ausgangspunkt zurück verschieben
result := AddVector (temp, c);
end;

function VectorRotateZ(v,c: TGLvector; a: GLdouble):TGLVector;
// v: zu drehender punkt
// c: zentrum
// a: winkel
var
temp, temp2: TGLVector;
begin
// das übergebene zentrum in den nullpunkt holen
temp2 := SubtractVector (v, c);

// jetzt so drehen, als ob alles um den nullpunkt angeordnet wäre
temp := VectorRotateZ (temp2, a);

// und das ergebnis wieder in den ausgangspunkt zurück verschieben
result := AddVector (temp, c);
end;

function VectorRotateX(v1,v2,v3,v4:TGLVector;a:GLdouble):TGLVector;
// v1: zu drehender punkt
// v2, v3, v4: vektoren die zusammen mit v1 eine fläche beschreiben,
// durch welche die drehachse läuft.
// a: drehwinkel
var
PlaneVec, PlaneCenter: TGLvector;
begin
// zuerst das zentrum der vektoren herausfinden
PlaneCenter.X := (v1.X+v2.X+v3.X+v4.X) / 4;
PlaneCenter.Y := (v1.Y+v2.Y+v3.Y+v4.Y) / 4;
PlaneCenter.Z := (v1.Z+v2.Z+v3.Z+v4.Z) / 4;

// den zu drehenden vector in den nullpunkt holen
PlaneVec := SubtractVector (v1, PlaneCenter);

// jetzt um die gewünschte achse drehen
PlaneVec := VectorRotateX (PlaneVec, a);

// die drehung auf den eigentlichen vector aufaddieren
// und zurückgeben
result := AddVector (PlaneVec, PlaneCenter);

result := VectorRotateX (v1, PlaneCenter, a);
end;

function VectorRotateY(v1,v2,v3,v4:TGLvector;a:GLdouble):TGLVector;
// v: zu drehender punkt
// v2, v3, v4: vektoren die zusammen mit v1 eine fläche beschreiben,
// durch welche die drehachse läuft.
// a: drehwinkel
var
PlaneVec, PlaneCenter: TGLvector;
begin
// zuerst das zentrum der vektoren herausfinden
PlaneCenter.X := (v1.X+v2.X+v3.X+v4.X) / 4;
PlaneCenter.Y := (v1.Y+v2.Y+v3.Y+v4.Y) / 4;
PlaneCenter.Z := (v1.Z+v2.Z+v3.Z+v4.Z) / 4;

// den zu drehenden vector in den nullpunkt holen
PlaneVec := SubtractVector (v1, PlaneCenter);

// jetzt um die gewünschte achse drehen
PlaneVec := VectorRotateY (PlaneVec, a);

// die drehung auf den eigentlichen vector aufaddieren
// und zurückgeben
result := AddVector (PlaneVec, PlaneCenter);

result := VectorRotateY (v1, PlaneCenter, a);
end;

function VectorRotateZ(v1,v2,v3,v4:TGLvector;a:GLdouble):TGLVector;
// v: zu drehender punkt
// v2, v3, v4: vektoren die zusammen mit v1 eine fläche beschreiben,
// durch welche die drehachse läuft.
// a: drehwinkel
var
PlaneVec, PlaneCenter: TGLvector;
begin
// zuerst das zentrum der vektoren herausfinden
PlaneCenter.X := (v1.X+v2.X+v3.X+v4.X) / 4;
PlaneCenter.Y := (v1.Y+v2.Y+v3.Y+v4.Y) / 4;
PlaneCenter.Z := (v1.Z+v2.Z+v3.Z+v4.Z) / 4;

// den zu drehenden vector in den nullpunkt holen
PlaneVec := SubtractVector (v1, PlaneCenter);

// jetzt um die gewünschte achse drehen
PlaneVec := VectorRotateZ (PlaneVec, a);

// die drehung auf den eigentlichen vector aufaddieren
// und zurückgeben
result := AddVector (PlaneVec, PlaneCenter);

result := VectorRotateZ (v1, PlaneCenter, a);
end;

{ Finds the point on the axis, closest to the
source vector }
function NearestPoint(Axis, Point: TGLVector): TGLVector;
var
temp: double;
begin
temp := DotProduct(Axis, Point) / DotProduct(Axis, Axis);
Axis.X := Axis.X * temp;
Axis.Y := Axis.Y * temp;
Axis.Z := Axis.Z * temp;
Result := Axis;
end;

{-----------------------------------------------------------------------------}
{-------------------------------- allgemein ----------------------------------}
{-----------------------------------------------------------------------------}

function InvertMatrix (src: TArrMatrix; var inverse: TArrMatrix): boolean;
var
t: GLdouble;
i, j, k, swap: integer;
tmp: TMatrix;
begin
result := false;
inverse := GetIdentity(inverse);

for i := 0 to 3 do
begin
for j := 0 to 3 do
begin
tmp[i][j] := src[i*4+j];
end;
end;

for i := 0 to 3 do
begin
// look for largest element in column.
swap := i;
for j := i+1 to 3 do
begin
if abs(tmp[j][i]) > abs(tmp[i][i]) then
begin
swap := j;
end;
end;

if not (swap = i) then
begin
// swap rows.
for k := 0 to 3 do
begin
t := tmp[i][k];
tmp[i][k] := tmp[swap][k];
tmp[swap][k] := t;

t := inverse[i*4+k];
inverse[i*4+k] := inverse[swap*4+k];
inverse[swap*4+k] := t;
end;
end;

if tmp[i][i] = 0 then
begin
{ no non-zero pivot. the matrix is singular, which
shouldn't happen. This means the user gave us a bad
matrix. }
exit;
end;

t := tmp[i][i];
for k := 0 to 3 do
begin
tmp[i][k] := tmp[i][k]/t;
inverse[i*4+k] := inverse[i*4+k]/t;
end;

for j := 0 to 3 do
begin
if not (j = i) then
begin
t := tmp[j][i];
for k := 0 to 3 do
begin
tmp[j][k] := tmp[j][k]-tmp[i][k]*t;
inverse[j*4+k] := inverse[j*4+k]-inverse[i*4+k]*t;
end;
end;
end;
end;
result := true;
end;

function Multiply (Color: TGLcolor; m: GLdouble): TGLcolor;
var
ret: TGLcolor;
begin
ret.red := Color.red * m;
ret.green := Color.green * m;
ret.blue := Color.blue * m;
result := ret;
end;

function Divide (V1: TGLvector; d: GLdouble): TGLvector;
var
ret: TGLvector;
begin
ret.x := V1.x / d;
ret.y := V1.y / d;
ret.z := V1.z / d;
result := ret;
end;

function ForceForegroundWindow(hwnd: THandle): Boolean;
{
Manchmal funktioniert die SetForeGroundWindow Funktion
nicht so, wie sie sollte; besonders unter Windows 98/2000,
wenn ein anderes Fenster den Fokus hat.
ForceForegroundWindow ist eine "verbesserte" Version von
der SetForeGroundWindow API-Funktion, um ein Fenster in
den Vordergrund zu bringen.
}
const
SPI_GETFOREGROUNDLOCKTIMEOUT = $2000;
SPI_SETFOREGROUNDLOCKTIMEOUT = $2001;
var
ForegroundThreadID: DWORD;
ThisThreadID: DWORD;
timeout: DWORD;
begin
if IsIconic(hwnd) then ShowWindow(hwnd, SW_RESTORE);

if GetForegroundWindow = hwnd then Result := True
else
begin
// Windows 98/2000 doesn't want to foreground a window when some other
// window has keyboard focus

if ((Win32Platform = VER_PLATFORM_WIN32_NT) and (Win32MajorVersion > 4)) or
((Win32Platform = VER_PLATFORM_WIN32_WINDOWS) and
((Win32MajorVersion > 4) or ((Win32MajorVersion = 4) and
(Win32MinorVersion > 0)))) then
begin
// Code from Karl E. Peterson, www.mvps.org/vb/sample.htm
// Converted to Delphi by Ray Lischner
// Published in The Delphi Magazine 55, page 16

Result := False;
ForegroundThreadID := GetWindowThreadProcessID(GetForegroundWindow, nil);
ThisThreadID := GetWindowThreadPRocessId(hwnd, nil);
if AttachThreadInput(ThisThreadID, ForegroundThreadID, True) then
begin
BringWindowToTop(hwnd); // IE 5.5 related hack
SetForegroundWindow(hwnd);
AttachThreadInput(ThisThreadID, ForegroundThreadID, False);
Result := (GetForegroundWindow = hwnd);
end;
if not Result then
begin
// Code by Daniel P. Stasinski
SystemParametersInfo(SPI_GETFOREGROUNDLOCKTIMEOUT, 0, @timeout, 0);
SystemParametersInfo(SPI_SETFOREGROUNDLOCKTIMEOUT, 0, TObject(0),
SPIF_SENDCHANGE);
BringWindowToTop(hwnd); // IE 5.5 related hack
SetForegroundWindow(hWnd);
SystemParametersInfo(SPI_SETFOREGROUNDLOCKTIMEOUT, 0, TObject(timeout), SPIF_SENDCHANGE);
end;
end
else
begin
BringWindowToTop(hwnd); // IE 5.5 related hack
SetForegroundWindow(hwnd);
end;

Result := (GetForegroundWindow = hwnd);
end;
end; { ForceForegroundWindow }

procedure InitGLEnv (dc: HDC; rc: HGLRC; hndl: THandle);
resourcestring
Res_ChooseFailed = 'ChoosePixelFormat failed with ';
var
pfd: TPixelFormatDescriptor;
PixelFormat: TGLUint;
pFlags: TPFDFlags;
flags: word absolute pFlags;
StencilBits,
ColorBits,
DepthBits: integer;
begin
pflags := [];
include (pflags, DoubleBuffer);
include (pflags, Stereo);
include (pflags, Draw_To_Window);
include (pflags, Draw_To_Bitmap);
include (pflags, Support_GDI);
include (pflags, Support_OpenGL);
include (pflags, Generic_Format);
include (pflags, Need_Palette);
include (pflags, Need_System_Palette);
include (pflags, Swap_Exchange);
include (pflags, Swap_Copy);
include (pflags, Swap_Layer_Buffers);
include (pflags, Generic_Accelerated);

ColorBits := 24;
DepthBits := 32;
StencilBits := 0;

with TWinControl(hndl) do
begin
fillchar(pfd,SizeOf(pfd),0);
with pfd do
begin
nSize := SizeOf(pfd);
nVersion := 1;
dwFlags := flags or
PFD_DRAW_TO_WINDOW
or PFD_SUPPORT_OPENGL
or PFD_DOUBLEBUFFER;
iPixelType := PFD_TYPE_RGBA;
cColorBits := ColorBits;
cDepthBits := DepthBits;
cStencilBits := StencilBits;
iLayerType := PFD_MAIN_PLANE;
cRedBits := 0;
cRedShift := 0;
cGreenBits := 0;
cBlueBits := 0;
cBlueShift := 0;
cAlphaBits := 0;
cAlphaShift := 0;
cAccumBits := 0;
cAccumRedBits := 0;
cAccumGreenBits := 0;
cAccumBlueBits := 0;
cAccumAlphaBits := 0;
cAuxBuffers := 0;
bReserved := 0;
dwLayerMask := 0;
dwVisibleMask := 0;
dwDamageMask := 0;
end; {with}

PixelFormat := ChoosePixelFormat(dc, @pfd);
if PixelFormat=0 then
raise Exception.Create(Res_ChooseFailed+IntToStr(GetLastError));

//if not SetPixelFormat(FglDC, PixelFormat, @pfd) then
// raise Exception.Create('SetPixelFormat failed with '+
// IntToStr(GetLastError));
end;
end;

function CheckFormat (number: string; digits, decimals: byte): string;
// wandelt ein mögliches dezimalkomma in einen punkt um
// beschneidet den übergebenen zahlenstring auf die gewünschten
// vorkomma- und nachkommastellen
// der übergebene zahlenstring darf keine tausender-kommas
// oder punkte enthalten!
var
sdigits, sdecimals, temp: string;
posi: integer;
begin
if digits+decimals = 0 then
begin
temp := '';
end
else
begin
sdigits := '';
sdecimals := '';
posi := pos (',', number);
if posi = 0 then
posi := pos ('.', number);
if posi > 0 then
sdigits := copy (number, 1, posi-1);
if length (number) > posi then
sdecimals := copy (number, posi+1);
if length (sdigits) > digits then
sdigits := copy (sdigits, length (sdigits)-(digits-1));
if length (sdecimals) > decimals then
sdecimals := copy (sdecimals, 1, decimals);
temp := sdigits + '.' + sdecimals;
end;
result := temp;
end;

procedure ResetGLErrorFlags;
var
err: GLenum;
begin
repeat
err := glGetError;
until err = GL_NO_ERROR;
end;

function ValidTexture (tex: GLUint; ErrStr: string): boolean;
var
error: GLenum;
begin
result := true;

ResetGLErrorFlags;
if not glIsTexture (tex) then
begin
error := glGetError;
Application.MessageBox(pChar ('Textur wurde nicht erkannt!'+chr(13)+chr(10)+
ErrStr+chr(13)+chr(10)+
'Fehler: '+IntToStr (error)),
'Fehler',
0);
result := false;
end;
end;

function AxisXRotation (V1, V2: TGLvector): GLdouble;
begin
V1.Z := 0;
V2.Z := 0;
result := DotProduct (V1, V2);
end;

function AxisYRotation (V1, V2: TGLvector): GLdouble;
begin
V1.Z := 0;
V2.Z := 0;
result := DotProduct (V1, V2);
end;

function AxisZRotation (V1, V2: TGLvector): GLdouble;
begin
V1.Y := 0;
V2.Y := 0;
result := DotProduct (V1, V2);
end;

function ExePath: string;
var
pfad: string;
begin
pfad := ExtractFilePath (Application.Exename);
if copy (pfad, length (pfad), 1) <> '\' then
pfad := pfad + '\';
result := pfad;
end;

end.
</pascal>
[[Kategorie:Anleitung]]

Kamera (2)

2008-02-05T05:00:37Z

Andyh:

Eine Beschreibung findet ihr unter [[Kamera (1)]]. 
Die verwendete Toolsammlung findet ihr unter [[Kamera (3)]].

<pascal>
{******************************************************************}
(*
Released as part of the camera example program
Visit us @ http://www.delphigl.com
Maintained by Florian Sievert (Phobeus)
Phobeus@DelphiGL.com
-------------------------------------------------------------------
License
-------
Copyright (C) 2007 Andree Heyroth

This license applies to everything on www.delphigl.com, except where
otherwise noted.

This software is provided 'as-is', without any express or implied warranty.
In no event will the authors be held liable for any damages arising from
the use of this software.

Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software in a
product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.

Description
-----------
Component containing methods and properties which are useful for moving and
rotating an existing scene in any dimension (yaw, pitcxh and roll/vertical,
horizontal and depth).

Requirements
------------
- SDL 1.2 (http://www.libsdl.org/download-1.2.php or your distribution)
- Borland Delphi version 5.0 and above

History
-------
see below (unfortunately in german)

Contact
-------
I created this source code in my spare time. If you find a bug or just
wanna say hello, feel free to write to the contributor:

Andree Heyroth (AndyH)
email : heyroth@syncro-concept.de
Visit: http://www.delphigl.com

*******************************************************************************)

// Wie ich selber immer wieder merken muss, ist eine Software anscheinend
// nie fertig. Immer moechte man etwas verbessern oder neue Features
// einbauen.
// Sollte also jemand Änderungs- oder Verbesserungsvorschläge haben oder
// neue Ideen einbringen wollen, oder sollten Verstaendnisfragen bestehen,
// so mailt bitte an
//
// heyroth@syncro-concept.de
//
// Danke.
//
// Updates:
//
// 06.11.2005
// Die Deklaration der DESTROY Methode war falsch. Das fuehrte dazu,
// dass in der Methode CREATE erzeugte Objekte nicht richtig frei-
// gegeben wurden und es zu EAccessViolations kam. Die Methode wird
// jetzt in der PUBLIC Section mit der Direktive OVERRIDE aufgerufen.
//
// 11.11.2005
// Die Positionierung funktioniert jetzt.
// Wegen eines Verstaendnisproblems wurden die Positionen immer auf den
// Kamerapunkt aufaddiert. Das bedeutete, dass die Positionierung aus
// dem Ruder lief wenn sie nicht im Nullpunkt stattfand. Je groesser die
// gewuenschte Position war um so groesser war die Abweichung von der
// Darstellung.
// Ich habe nicht bedacht, dass bei einer "Kamera"-bewegung und -drehung
// ja eigentlich die Szene bewegt und gedreht wird. Deswegen wurden nach
// einer Positionierung die folgenden Projektionen immer basierend auf der
// danach gueltigen Kameraposition gemacht.
// Jetzt wird die Position so gesetzt, dass die gewuenschte Kameraposition
// immer vor dem Betrachter steht.
//
// 23.11.2005
// Neues Flag (FFixedAxis) zur Entscheidung zwischen angepasster und realer
// Drehung. Dadurch wird das Bewegungsmodell angepasst. Siehe Methode Offset,
// bzw. UpdateMatrixOffset.
//
// 10.12.2005
// Property PointOfRotation ist jetzt nicht mehr ReadOnly.
// Der Blickpunkt bzw. Rotationspunkt kann jetzt direkt verändert werden.
// So kann eine neue Blickrichtung angenommen werden ohne vorher die Kamera-
// eigenschaften zu sichern und nach einem PositionCamera wieder zu setzen.
//
// 19.12.2005
// Neue Methode PositionCross.
// Die Methode PositionCross schiebt das Fadenkreuz in den angegebenen Punkt
// ohne die Lage der Szene zu verändern. Diese Funktionalitaet ist anders als
// ein neues Setzen der Property FPointOfRotation weil dabei die Szene in das
// Koordinatenkreuz geschoben wird.
//
// 31.01.2006
// Umstellung auf genaueres Zahlenformat
// Da die Darstellung von Szenen ausserhalb des Bereichs von FLOAT-Zahlen
// nicht funktioniert, muss alles auf DOUBLE umgestellt werden. Dazu gehört
// das Ersetzen von Datentypen und der Aufruf der entsprechenden GL-Funktionen.
//
// 24.09.2007
// Um den Einstieg zu erleichtern habe ich die ganzen Steuerfunktionen in die
// Kamera verlegt. Die "normalen" Funktionen wie Drehen und Verschieben werden
// jetzt durch Weitergabe der Tastendrücke und Mauseigenschaften an die
// Kamera abgearbeitet. Die Auswertung erfolgt dort. Sollten andere Tasten
// als die von mir vorgesehenen gewünscht sein, muss dies in der Kamera
// geändert werden.

unit Camera;

interface

Uses
DglOpenGL,
Util,
Windows,
Classes,
Messages,
Controls;

type
TCameraMatrix=Class
StackMatrix: array [0..9] of TArrMatrix;
StackCtr: integer;
Matrix: TArrMatrix;
InverseMatrix: TArrMatrix;
constructor Create;
//destructor destroy;
procedure Identity;
procedure Push;
procedure Pop;
procedure Load(M: TArrMatrix);
end;

TCamera=Class
Enabled: boolean;
function UpVector: TGLvector;
procedure RestorePosition(pos: integer);
procedure SavePosition(pos: integer);
function GiveStoredPosition(pos: integer): TGLvector;
procedure RotateCamera(ix, iy, iz: GLdouble);
procedure TranslateCamera(ix, iy, iz: GLdouble);
procedure CameraHome;
procedure PositionCamera(PositionVec: TGLvector; ViewVec: TGLvector; upVec: TGLvector);
procedure Adjust;
procedure Apply;
procedure ApplyForTerrain;
private
// Dreh- und Bewegungsrichtung festlegen (in Mousedown).
// Pfeil hoch : Szene nach oben
// Pfeil runter: Szene nach unten
// Pfeil rechts: Szene nach rechts
// Pfeil links : Szene nach links
// Page Up : Szene in den Bildschirm schieben (verkleinern)
// Page Down : Szene aus dem Bildschirm schieben (vergrößern)
//
// Wird FDir auf true gesetzt ist die Tastenfunktion jeweils umgekehrt.
// so verschiebt sich entweder die szene oder das objekt.
FDir: boolean;
FPosition: TGLvector;
FViewDirection: TGLvector;

FAltPressed,
FShiftPressed,
FCtrlPressed: boolean;

FRightMousePressed: boolean;
FLeftMousePressed: boolean;

FSpeedMultiplier: double;

FxStart, // berechnung der mausbewegungen.
FxDelta, // delta = aktuelle position minus start
FyStart, // start wird erfasst sobald eine maustaste
FyDelta:integer; // gedrückt wird.
FxRot, // umrechnung von delta in rotation wenn
FyRot:double; // drehung gewünscht ist (je nach taste)

FPointOfRotation: TGLvector;
HomeMatrix: TCameraMatrix;
CameraMatrix: TCameraMatrix;
Initiated: boolean;
PosArray: array [0..9] of TCameraMatrix;
RotArray: array [0..9] of TGLvector;
FFixedAxis: boolean;
procedure Debug (Text: string);
function UpdateMatrixOffset(newMatrix: TArrMatrix): TArrMatrix;
function GetViewDirection: TGLvector;
procedure SetViewDirection (View: TGLvector);
procedure Initiate;
function GetPosition: TGLvector;
procedure SetPosition (Pos: TGLvector);
procedure Identity;
procedure Offset(x, y, z: GLdouble);
procedure RotateRoundAxis(rx, ry, rz: GLdouble);
procedure SetPointOfRotation (NewPoint: TGLvector);
function ProcessArrowKeys (Key: integer; Shift: TShiftState): boolean;
function GiveSpeed: TGLdouble;
procedure RotateScene(Direction: byte; Geschwindigkeit: GLdouble);
procedure MoveScene (Direction: byte; Geschwindigkeit: GLdouble);
public
constructor Create;
destructor Destroy;override;
function InverseMatrix: TArrMatrix;
procedure ApplyInvers;
procedure PositionCross(CrossVec: TGLvector);
function HandleKeyboardInput (Key: Word; Shift: TShiftState): boolean;
procedure KeyUp(Sender: TObject; var Key: Word; Shift: TShiftState);
function KeyDown(Sender: TObject; var Key: Word; Shift: TShiftState): boolean;
procedure MouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
procedure MouseUp(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
function MouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer): boolean;
function MouseWheel(Sender: TObject; Shift: TShiftState; WheelDelta: Integer; MousePos: TPoint; var Handled: Boolean): boolean;
procedure MouseEnter(var msg:TMessage);
procedure MouseLeave(var msg: TMessage);
published
property PointOfRotation: TGLvector read FPointOfRotation write SetPointOfRotation;
property Position: TGLvector read GetPosition write SetPosition;
property ViewDirection: TGLvector read GetViewDirection write SetViewDirection;
property FixedAxis: boolean read FFixedAxis write FFixedAxis;
property SpeedMultiplier: double read FSpeedMultiplier write FSpeedMultiplier;
end;
TPCamera=^TCamera;

var
FDebugFile: Textfile;
FDebugFileName: string;
FDebugOn: boolean;

const
VK_0 = $30;
VK_1 = $31;
VK_2 = $32;
VK_3 = $33;
VK_4 = $34;
VK_5 = $35;
VK_6 = $36;
VK_7 = $37;
VK_8 = $38;
VK_9 = $39;

VK_A = $41;
VK_B = $42;
VK_C = $43;
VK_D = $44;
VK_E = $45;
VK_F = $46;
VK_G = $47;
VK_H = $48;
VK_I = $49;
VK_J = $4A;
VK_K = $4B;
VK_L = $4C;
VK_M = $4D;
VK_N = $4E;
VK_O = $4F;
VK_P = $50;
VK_Q = $51;
VK_R = $52;
VK_S = $53;
VK_T = $54;
VK_U = $55;
VK_V = $56;
VK_W = $57;
VK_X = $58;
VK_Y = $59;
VK_Z = $5A;

// Standard-Keycodes für Tastatureingaben definieren
CKeyCameraHome = VK_0;
CKeyCameraAdjust = VK_A;

DIR_HORIZONTAL: byte = 1;
DIR_VERTIKAL: byte = 2;
DIR_ZENTRAL: byte = 3;

implementation

uses SysUtils;

constructor TCameraMatrix.Create;
begin
inherited create;
StackCtr := 0;
end;

procedure TCameraMatrix.Push;
begin
if (StackCtr > -1) and (StackCtr < 10) then begin
StackMatrix[StackCtr] := Matrix;
inc (StackCtr);
end;
end;

procedure TCameraMatrix.Pop;
begin
if (StackCtr > 0) and (StackCtr < 11) then begin
dec (StackCtr);
Load (StackMatrix[StackCtr]);
end;
end;

procedure TCameraMatrix.Identity;
// GetIdentity: aus OpenGL.pas
// initialisiert die CameraMatrix mit der Identitaetsmatrix
begin
Matrix := GetIdentity(Matrix);
InverseMatrix := GetIdentity(InverseMatrix);
end;

procedure TCameraMatrix.Load(M: TArrMatrix);
// die Matrix mit den Werten einer beliebigen anderen matrix fuellen
var
i: integer;
begin
for i:=0 to 15 do
Matrix[i]:=M[i];
// die invertierte Matrix kann benutzt werden um Objkekte z.B.
// immer zum Benutzer auszurichten
InvertMatrix (M, InverseMatrix);
end;

constructor TCamera.Create;
var
i: integer;
begin
inherited create;

// Initiated wird gebraucht um einmal alle Positionsspeicher
// mit der Anfangsposition zu belegen
Initiated := false;

// Kameramatrix anlegen
CameraMatrix := TCameraMatrix.Create;

// Matrix der letzten Position von PositionCamera anlegen
HomeMatrix := TCameraMatrix.Create;

// Positionsspeicher anlegen
for i := 0 to 9 do
PosArray[i] := TCameraMatrix.Create;

// standardmaessig immer entlang der bildschirmachsen verschieben
FFixedAxis := true;

// flags für die tasten alt, ctrl und shift initialisieren
FAltPressed := false;
FCtrlPressed := false;
FShiftPressed := false;

// normalerweise wird die geschwindigkeit nicht verändert
FSpeedMultiplier := 1.0;

// normale bildschirmbewegung
FDir := false;
end;

destructor TCamera.Destroy;
// alle in create belegten Resourcen wieder freigeben
var
i: integer;
begin
FreeAndNil (CameraMatrix);
FreeAndNil (HomeMatrix);
for i := 0 to 9 do
FreeAndNil (PosArray[i]);

inherited destroy;
end;

procedure TCamera.RotateRoundAxis(rx, ry, rz: GLdouble);
// hier drehen wir jetzt um die einzelnen Achsen.
// die Parameter geben die "Drehgeschwindigkeit" vor.
var
newMatrix: TArrMatrix;
tempX, tempY, tempZ: TGLvector;
begin
glMatrixMode (GL_MODELVIEW);
glPushMatrix();

// aktuelle Position und Lage der Kamera herstellen
glLoadMatrixd(@CameraMatrix.Matrix);

if FFixedAxis then begin
// über die bildschirmachsen drehen
tempX := GetMatrixX (CameraMatrix.InverseMatrix);
tempY := GetMatrixY (CameraMatrix.InverseMatrix);
tempZ := GetMatrixZ (CameraMatrix.InverseMatrix);
// wenn gewuenscht um die X-Achse drehen
if(rx <> 0) then
glRotated(rx,tempX.X,tempX.Y,tempX.Z);

// wenn gewuenscht um die Y-Achse drehen
if(ry <> 0) then
glRotated(ry,tempY.X,tempY.Y,tempY.Z);

// wenn gewuenscht um die Z-Achse drehen
if(rz <> 0) then
glRotated(rz,tempZ.X,tempZ.Y,tempZ.Z);
end
else begin
// über die achsen des koordinatenkreuzes drehen
// wenn gewuenscht um die X-Achse drehen
if(rx <> 0) then
glRotated(rx,1,0,0);

// wenn gewuenscht um die Y-Achse drehen
if(ry <> 0) then
glRotated(ry,0,1,0);

// wenn gewuenscht um die Z-Achse drehen
if(rz <> 0) then
glRotated(rz,0,0,1);
end;

// die neu erzeugte Matrix auslesen
glGetDoublev(GL_MODELVIEW_MATRIX, @newMatrix);

glPopMatrix();

// und in die Kameramatrix sichern
CameraMatrix.Load(newMatrix);
end;

procedure TCamera.Identity;
begin
CameraMatrix.Identity;
HomeMatrix.Identity;

Enabled := true;
end;

procedure TCamera.Offset(x, y, z: GLdouble);
// verschieben der Kamera auf einer beliebigen Achse
var
newMatrix: TArrMatrix;
//OldView: TGLvector;
begin
Debug ('- Offset - Start --------------------------------------------------');
glMatrixMode (GL_MODELVIEW);

glPushMatrix();
glLoadIdentity;
glTranslated(x,y,z);
glGetDoublev(GL_MODELVIEW_MATRIX, @newMatrix);
glPopMatrix();

Debug ('Position: '+GLvectorToText (GetMatrixPos (newMatrix)));
newMatrix := UpdateMatrixOffset (newMatrix);
CameraMatrix.Load(newMatrix);
Debug ('- Offset - Ende- --------------------------------------------------');
end;

procedure TCamera.PositionCamera(PositionVec: TGLvector;
ViewVec: TGLvector;
upVec: TGLvector);
var
newMatrix: TArrMatrix;
i: integer;
P, V, U: TGLvector;
Laenge: GLdouble;
begin
Debug ('- PositionCamera - Start ------------------------------------------');
// die gewuenschte konstruktion immer auf die Z-ebene projizieren.
// zuerst die position in den nullpunkt holen
InitVector (P, 0, 0, 0);
// jetzt den viewpoint um den gleichen betrag reduzieren, damit
// die gerade parallel verschoben wird.
V := SubtractVector (ViewVec, PositionVec);
// U ist halt schneller geschrieben als upVec...
U := upVec;

// den betrag ermitteln, um den die kamera nachher auf der Z-Achse
// verschoben werden muss
Laenge := Magnitude (SubtractVector (P, V));

Identity;

glMatrixMode (GL_MODELVIEW);
glPushMatrix;
glLoadIdentity;

// glulookat wird die matrix parallel zur Z-achse ausrichten
gluLookAt (P.X, P.Y, P.Z, V.X, V.Y, V.Z, U.X, U.Y, U.Z);
glGetDoublev(GL_MODELVIEW_MATRIX, @newMatrix);
glPopMatrix;

CameraMatrix.Load(newMatrix);
HomeMatrix.Load(newMatrix);

// da wir uns jetzt am zielpunkt befinden, müssen wir auf der Z-achse
// wieder zurueck zur kameraposition
Offset (0, 0, -Laenge);

// alle positionsspeicher mit der Kameraposition, Blickrichtung
// und dem upVector belegen. Nur beim ersten Aufruf von
// PositionCamera
if not Initiated then
Initiate;

FPointOfRotation := ViewVec;
Debug ('PointOfRotation: '+GLvectorToText (FPointOfRotation));
Debug ('- PositionCamera - Ende -------------------------------------------');
end;

procedure TCamera.PositionCross (CrossVec: TGLvector);
// diese prozedur verschiebt, im gegensatz zu einem verändern von
// PointOfRotation, das Koordinatenkreuz und nicht die Szene.
var
newMatrix: TArrMatrix;
PosDiff: TGLvector;
begin
Debug ('- PositionCross - Start -------------------------------------------');

PosDiff := SubtractVector (FPointOfRotation, CrossVec);

// Szene in das koordinatenkreuz verschieben
FPointOfRotation := CrossVec;

// jetzt die Szene wieder um den gleichen betrag zurückverschieben
// das sieht dann so aus, als ob das koordinatenkreuz verschoben
// worden wäre
// zuerst die aktuelle neue Situation herstellen
// (mit neuem FPointOfRotation)
Apply;

// jetzt um den Differenzbetrag des alten und neuen
// Rotationspunkts zurück verschieben
glTranslated (-PosDiff.X, 0, 0);
glTranslated (0, -PosDiff.Y, 0);
glTranslated (0, 0, -PosDiff.Z);

// jetzt vom neuen Rotationspunktes zurück ins Zentrum, damit beim
// nächsten Apply das glTranslatef (-FPointOfRotation, ...) klappt
glTranslated (CrossVec.X, 0, 0);
glTranslated (0, CrossVec.Y, 0);
glTranslated (0, 0, CrossVec.Z);

// aktuelle Matrix holen...
glGetDoublev(GL_MODELVIEW_MATRIX, @newMatrix);

// und als Kameramatrix abspeichern
CameraMatrix.Load(newmatrix);
Debug ('- PositionCross - Ende --------------------------------------------');
end;

procedure TCamera.CameraHome;
// Kamera in die beim letzten Aufruf von PositionCamera uebergebene
// Position/Lage bringen
begin
CameraMatrix.Load(HomeMatrix.Matrix);
end;

procedure TCamera.SavePosition (pos: integer);
// wie der Prozedurname schon sagt...
begin
if (pos < 0) or (pos > 9) then
exit;

PosArray[pos].Load(CameraMatrix.Matrix);
RotArray[pos] := FPointOfRotation;
end;

procedure TCamera.RestorePosition (pos: integer);
// wie der Prozedurname schon sagt...
begin
if (pos < 0) or (pos > 9) then
exit;

CameraMatrix.Load(PosArray[pos].Matrix);
FPointOfRotation := RotArray[pos];
end;

function TCamera.GiveStoredPosition (pos: integer): TGLvector;
// gibt den Inhalt des durch pos bestimmten
// Positionsspecihers zurueck
begin
if (pos < 0) or (pos > 9) then
exit;

result := GetMatrixPos (PosArray[pos].Matrix);
end;

procedure TCamera.TranslateCamera(ix, iy, iz: GLdouble);
// vom Benutzer aufzurufende Methode um eine Verschiebung
// durchzufuehren
begin
Offset (ix, iy, iz);
end;

procedure TCamera.RotateCamera(ix, iy, iz: GLdouble);
// vom Benutzer aufzurufende Methode um eine Drehung
// durchzufuehren
begin
RotateRoundAxis (-iy, -ix, -iz);
end;

procedure TCamera.Apply;
// hier wird die Kamera eingeschaltet. Nach dem Aufruf dieser Prozedur
// sollte die Szene mit allen benoetigten Drehungen, Verschiebungen
// gezeichnet werden.
begin
if not Enabled then
exit;

glMatrixMode (GL_MODELVIEW);
glLoadMatrixd(@CameraMatrix.Matrix);
glTranslated (-FPointOfRotation.X,
-FPointOfRotation.y,
-FPointOfRotation.Z);
end;

procedure TCamera.ApplyForTerrain;
// hier wird wie in Apply die Kamera eingeschaltet. da man um ein terrain
// (skycube, ...) anzuzeigen aber immer die gleiche entfernung zur welt
// einhalten muss, wird hier nur gedreht und nicht verschoben.
var
pos: TGLvector;
begin
if not Enabled then
exit;

glMatrixMode (GL_MODELVIEW);
// für das Terrain nur die Drehung ausführen
glLoadMatrixd(@CameraMatrix.Matrix);
// deswegen jetzt die verschiebung zurücknehmen
Pos := GetMatrixPos (CameraMatrix.InverseMatrix);
glTranslated (Pos.X, Pos.Y, Pos.Z);
end;

function TCamera.GetPosition: TGLvector;
// diese Property-Funktion fragt die aktuelle Position der Kamera ab
begin
// position: letzte Spalte der Matrix
result := AddVector (GetMatrixPos (CameraMatrix.InverseMatrix), FPointOfRotation);
end;

procedure TCamera.SetPosition (Pos: TGLvector);
// diese Property-Funktion setzt eine neue Position der Kamera
var
m: TArrMatrix;
begin
// position: letzte Spalte der Matrix
m := CameraMatrix.Matrix;
SetMatrixPos (m, SubtractVector (Pos, FPointOfRotation));
CameraMatrix.Load (m);
end;

function TCamera.GetViewDirection: TGLvector;
// mit dieser Funktion kann die aktuelle Blickrichtung der Kamera
// abgefragt werden
var
return: TGLvector;
begin
// view direction: dritte Spalte der Matrix (Z-Achse)
result := GetMatrixZ (CameraMatrix.InverseMatrix);
end;

procedure TCamera.SetViewDirection (View: TGLvector);
// mit dieser Funktion kann die aktuelle Blickrichtung der Kamera
// gesetzt werden
begin
// view direction: dritte Spalte der Matrix (Z-Achse)
SetMatrixZ (CameraMatrix.InverseMatrix, View);
end;

function TCamera.UpVector: TGLvector;
// mit dieser Funktion kann die aktuelle Ausrichtung der Kamera
// abgefragt werden
var
return: TGLvector;
begin
// upVector: zweite Spalte der Matrix (Y-Achse)
result := GetMatrixY (CameraMatrix.InverseMatrix);
end;

procedure TCamera.Adjust;
// mit dieser Prozedur kann die Kamera zu jeder Zeit, unabhaengig
// von Drehung und Position, zur Y-Achse ausgerichtet werden.
// Die aktuelle Position wird dabei beibehalten.
var
m: TArrMatrix;
v: TGLvector;
begin
// position aus der aktuellen cameramatrix holen
v := GetMatrixPos (CameraMatrix.Matrix);
// m mit identitätsmatrix initialisieren
m := GetIdentity(m);
// die position aus der aktuellen cameramatrix in m speichern
SetMatrixPos (m, v);
// m als aktuelle cameramatrix speichern
CameraMatrix.Load(m);
end;

function TCamera.InverseMatrix: TArrMatrix;
begin
result := CameraMatrix.InverseMatrix;
end;

procedure TCamera.Initiate;
var
i: integer;
begin
for i := 0 to 9 do
SavePosition (i);
Initiated := true;
end;

function TCamera.UpdateMatrixOffset (newMatrix: TArrMatrix): TArrMatrix;
begin
// wenn ich mit Multiply (FixedAxis) arbeite, wird die zeichnung immer
// entlang der bildschirmachsen verschoben. wenn ich Multiply, version 2
// nehme, wird sie auf den errechneten achsen verschoben.
if FFixedAxis then begin
result := Multiply (newMatrix, CameraMatrix.Matrix);
end
else begin
result := Multiply (CameraMatrix.Matrix, newMatrix);
end;
end;

procedure TCamera.SetPointOfRotation (NewPoint: TGLvector);
// setzt den viewpoint oder rotationpoint ohne die anderen parameter zu
// veraendern. so kann man z.B. eine Kamerafahrt in immer der gleichen
// position simulieren.
begin
FPointOfRotation := NewPoint;
end;

procedure TCamera.Debug (Text: string);
begin
if not FDebugOn then
exit;
writeln (FDebugFile, DateToStr (date) + ' | ' +
TimeToStr (time) + ' | ' +
Text);
end;

procedure TCamera.ApplyInvers;
var
M: TArrMatrix;
begin
// Um Objekte immer zum benutzer ausrichten, darf nur die drehung angewendet
// werden und nicht die verschiebung. Verschiebung wird hier zurückgenommen.
// Vorher muss die Kamera angewendet und die nötigen Verschiebungen/
// Drehungen ausgeführt werden.
M := InverseMatrix;
M[12] := 0;
M[13] := 0;
M[14] := 0;
M[15] := 1;
glMultMatrixd(@M);
end;

function TCamera.HandleKeyboardInput (Key: Word; Shift: TShiftState): boolean;
// diese funktion sollte zur steuerung des bildschirmablaufs gewählt werden,
// wenn nicht auf die tasteneingabe gewartet wird (bildschirmaufbau nach
// timer-event).
// in der Timermethode zB.:
// if FCamera.HandleDeviceInput then
// Render; // oder wie die routine bei euch heißt ...
begin
result := false;

if not FAltPressed then FAltPressed := ssAlt in Shift;
if not FCtrlPressed then FCtrlPressed := ssCtrl in Shift;
// das mit Key=16 ist ´ne krücke, aber sendmessage mit VK_SHIFT klappt
// bei mir nicht!
if not FShiftPressed then FShiftPressed := (ssShift in Shift) or (Key = 16);

case Key of
CKeyCameraHome: // (ausgangsposition)
begin
if not (FAltPressed or FCtrlPressed or FShiftPressed) then begin
CameraHome;
result := true;
end;
end;

CKeyCameraAdjust:
begin // (ausrichten)
Adjust;
result := true;
end;

VK_PRIOR, VK_NEXT, VK_UP, VK_DOWN, VK_LEFT, VK_RIGHT:
result := ProcessArrowKeys (Key, Shift);
else // case
if (Key > $29) and (Key < $40) then begin // 0 - 9
if FAltPressed then begin // position speichern?
SavePosition(Key-48);
result := true;
end;
if FShiftPressed then begin
RestorePosition(Key-48);
result := true;
end;
end;
end;

end;

function TCamera.ProcessArrowKeys (Key: integer; Shift: TShiftState): boolean;
// arbeitet die für die jeweiligen kameraaktionen definierten tastendrücke
// ab. hierbei werden wie gewünscht die kameraeigenschaften geändert:
// lage, position, ...
var
POR: TGLVector;
nDir: double;
begin
result := false;

nDir := 1.0*FSpeedMultiplier;
if FDir then
nDir := -1.0;

case Key of
VK_UP: // Szene aus dem Drehpunkt entlang der vertikalen
begin // verschieben
if ssShift in Shift then begin
RotateScene (DIR_HORIZONTAL, GiveSpeed*-1.0);
end else begin
POR := PointOfRotation;
POR.Y := POR.Y + nDir;
PointOfRotation := POR;
end;
result := true;
end;
VK_DOWN: // Szene aus dem Drehpunkt entlang der vertikalen
begin // verschieben
if ssShift in Shift then begin
RotateScene (DIR_HORIZONTAL, GiveSpeed);
end else begin
POR := PointOfRotation;
POR.Y := POR.Y - nDir;
PointOfRotation := POR;
end;
result := true;
end;
VK_LEFT: // Szene aus dem Drehpunkt entlang der horizontalen
begin // verschieben
if ssShift in Shift then begin
RotateScene (DIR_VERTIKAL, GiveSpeed*-1.0);
end else begin
POR := PointOfRotation;
POR.X := POR.X - nDir;
PointOfRotation := POR;
end;
result := true;
end;
VK_RIGHT: // Szene aus dem Drehpunkt entlang der horizontalen
begin // verschieben
if ssShift in Shift then begin
RotateScene (DIR_VERTIKAL, GiveSpeed);
end else begin
POR := PointOfRotation;
POR.X := POR.X + nDir;
PointOfRotation := POR;
end;
result := true;
end;
VK_PRIOR: // Szene aus dem Drehpunkt entlang der Bildschirmachse
begin // verschieben
if ssShift in Shift then begin
RotateScene (DIR_ZENTRAL, GiveSpeed*-1.0);
end else begin
POR := PointOfRotation;
POR.Z := POR.Z - nDir;
PointOfRotation := POR;
end;
result := true;
end;
VK_NEXT: // Szene aus dem Drehpunkt entlang der Bildschirmachse
begin // verschieben
if ssShift in Shift then begin
RotateScene (DIR_ZENTRAL, GiveSpeed);
end else begin
POR := PointOfRotation;
POR.Z := POR.Z + nDir;
PointOfRotation := POR;
end;
result := true;
end;
end;
end;

procedure TCamera.KeyUp(Sender: TObject; var Key: Word; Shift: TShiftState);
// überprüfen ob eine sondertaste wieder losgelassen wurde
begin
if not (ssAlt in Shift) then
FAltPressed := false;
if not (ssCtrl in Shift) then
FCtrlPressed := false;
if not (ssAlt in Shift) then
FShiftPressed := false;
end;

function TCamera.KeyDown(Sender: TObject; var Key: Word;
Shift: TShiftState): boolean;
var
POR: TGLVector;
begin
// hier werden die aktionen für die angezeigten tastenbelegungen
// umgesetzt
result := false;

// wie bei den maustasten: merken, ob eine sondertaste gedrückt
// wurde um feststellen zu können ob diese gehalten wird. in
// KeyUp wird der zustand entsprechend zurückgesetzt.
if not FAltPressed then FAltPressed := ssAlt in Shift;
if not FCtrlPressed then FCtrlPressed := ssCtrl in Shift;
if not FShiftPressed then FShiftPressed := (ssShift in Shift);

case key of
ord ('A'): // Szene zum Benutzer ausrichten. Position wird
begin // nicht verändert
Adjust;
result := true;
end;
VK_PRIOR, VK_NEXT, VK_UP, VK_DOWN, VK_LEFT, VK_RIGHT:
result := ProcessArrowKeys (Key, Shift);
ord('0'): // den Drehpunkt in den Nullpunkt schieben. Die
begin // Kameraposition bleibt unverändert.
InitVector (POR, 0, 0, 0);
PointOfRotation := POR;
result := true;
end;
ord('I'): // Dreh- und Bewegungsrichtung umschalten
begin
FDir := not FDir;
result := true;
end;
ord('U'): // Umschalten zwischen Drehung/Bewegung entlang der
begin // angezeigten Achsen bzw. Bildschirmachsen
FixedAxis := not FixedAxis;
result := true;
end;
end;
end;

procedure TCamera.MouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
// hier merken wir uns, welche Maustaste gedrückt wurde. Solange die
// Tastenvariable true ist, kann abgeprüft werden ob die Taste gedrückt
// ist. In MouseUp wird die entsprechende Variable wieder auf false
// gesetzt.
begin
if Button = mbRight then begin
//rechte maustaste gedrückt
FRightMousePressed:=true;
end else if Button = mbLeft then begin
//rechte maustaste gedrückt
FLeftMousePressed:=true;
end;
//Startposition für die Mausbewegung merken
FxStart := X;
FyStart := Y;
end;

procedure TCamera.MouseUp(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
// eine maustaste wurde losgelassen. mal sehen, ob eine aktion
// unterbunden werden muss.
begin
if Button = mbRight then begin
FRightMousePressed:=false;
end else if Button = mbLeft then begin
FLeftMousePressed:=false;
end;
end;

function TCamera.MouseMove(Sender: TObject; Shift: TShiftState; X,
Y: Integer): boolean;
begin
result := false;
//Verschieben und Drehen funktioniert nur, wenn eine Maustaste
// gedrückt ist
if not (FRightMousePressed or FLeftMousePressed) then
exit;

//berechnen, wie weit die Maus verschoben wurde
FxDelta := FxStart-X;
FyDelta := FyStart-Y;

//anpassen, damit es nicht zu schnell geht
FxRot := FxRot - FyDelta;
Fyrot := FyRot - FxDelta;

//Startpunkt für den nächsten Aufruf festlegen
FxStart := X;
FyStart := Y;

// Rechte Maustaste:
// Kamera drehen (vertikal bei Maus hoch/runter,
// horizontal bei Maus links/rechts
// um die Bildschirmachse bei Mausrad oder wenn shift)
if FRightMousePressed then begin
if FShiftPressed then begin
// wenn kein mausrad vorhanden ist, soll das ja auch gehen
if FyRot+FxRot <> 0 then begin
RotateScene (DIR_ZENTRAL, (FyRot+FxRot)*GiveSpeed);
end;
end
else begin
if FxRot <> 0 then begin
RotateScene (DIR_HORIZONTAL, FxRot*GiveSpeed);
end;
if FyRot <> 0 then begin
RotateScene (DIR_VERTIKAL, FyRot*GiveSpeed);
end;
end;
end;

// Linke Maustaste:
// Kamera bewegen (vertikal bei Maus hoch/runter,
// horizontal bei Maus links/rechts
// entlang der Bildschirmachse bei Mausrad oder wenn shift)
if FLeftMousePressed then begin
if FShiftPressed then begin
// wenn kein mausrad vorhanden ist, soll das ja auch gehen
if FyRot+FxRot <> 0 then begin
MoveScene (DIR_ZENTRAL, (FyRot+FxRot)*GiveSpeed);
end
end
else begin
if FxRot <> 0 then begin
MoveScene (DIR_HORIZONTAL, FxRot*GiveSpeed);
end;
if FyRot <> 0 then begin
MoveScene (DIR_VERTIKAL, -FyRot*GiveSpeed);
end;
end;
end;

FxRot := 0;
FyRot := 0;

result := true;
end;

procedure TCamera.RotateScene (Direction: byte;
Geschwindigkeit: GLdouble);
begin
if Direction = DIR_HORIZONTAL then // um die X-Achse drehenx
begin
RotateCamera(0, Geschwindigkeit, 0);
end
else if Direction = DIR_VERTIKAL then // um die y-Achse drehen
begin
RotateCamera (Geschwindigkeit, 0, 0);
end
else if Direction = DIR_ZENTRAL then // um die z-Achse drehen
begin
RotateCamera(0, 0, Geschwindigkeit);
end;
end;

function TCamera.GiveSpeed: TGLdouble;
begin
// Initiale Geschwindigkeit
result := 1;

// wenn die Geschwindigkeit für eine Mausbewegung oder -drehung ist, soll
// es nicht so schnell gehen
if FRightMousePressed or FLeftMousePressed then begin
result := result / 20;
end;

// wenn die alt-taste gedrückt wurde, soll es ja schneller gehen
if FAltPressed then begin
result := (result * 60.0);
end;

// jetzt mit dem individuellen speemultiplier multiplizieren
result := result * FSpeedMultiplier;

// wenn die drehrichtung umgeschaltet wurde, hier auch
// umschalten
if FDir then begin
result := -result;
end;
end;

procedure TCamera.MoveScene (Direction: byte; Geschwindigkeit: GLdouble);
begin
if Direction = DIR_VERTIKAL then begin
TranslateCamera (Geschwindigkeit, 0, 0);
end;
if Direction = DIR_HORIZONTAL then begin
TranslateCamera (0, Geschwindigkeit, 0);
end;
if Direction = DIR_ZENTRAL then begin
TranslateCamera (0, 0, Geschwindigkeit);
end;
end;

function TCamera.MouseWheel(Sender: TObject; Shift: TShiftState;
WheelDelta: Integer; MousePos: TPoint; var Handled: Boolean): boolean;
begin
if FRightMousePressed then begin
RotateScene (DIR_ZENTRAL, (WheelDelta/10)*GiveSpeed);
end
else begin
MoveScene (DIR_ZENTRAL, (WheelDelta/360)*GiveSpeed);
end;
result := true;
end;

procedure TCamera.MouseEnter(var msg:TMessage);
begin
FRightMousePressed:=false;
FLeftMousePressed:=false;
end;

procedure TCamera.MouseLeave(var msg: TMessage);
begin
FRightMousePressed:=false;
FLeftMousePressed:=false;
FAltPressed := false;
FCtrlPressed := false;
FShiftPressed := false;
end;

Initialization
FDebugOn := false; // auf true setzen, wenn debug infos gewünscht sind
FDebugFileName := ExePath + 'SKANAL3D_CAMERA.DBG';
if FDebugOn then begin
AssignFile (FDebugFile, FDebugFileName);
Rewrite (FDebugFile);
end;

finalization
if FDebugOn then begin
CloseFile (FDebugFile);
FDebugFileName := '';
end;

end.
</pascal>
[[Kategorie:Anleitung]]

Kamera (1)

2008-02-05T04:51:40Z

Andyh:

==Danke==
Nachdem ich viel Zeit damit verbracht habe, eine funktionierende Kamera zu bauen und es nun endlich geschafft habe, wollte ich diese Funktionalität auch Anderen zur Verfügung stellen.
Da mir schon viel geholfen wurde, kann ich so einen Teil meiner "Schuld" zurück zahlen.

Bitte seht ab und zu mal hier nach, ob es für diese Kamera Updates gibt. Sollte es so sein, habe ich das im Code ([[Kamera (2)]]) vermerkt. Ladet in diesem Fall bitte den Source Code der Kamera und(!) die Utilities herunter.

==Meine Kamera==
Die wie folgend beschriebene Kamera kann sich um alle drei Achsen drehen und sich in allen Ebenen bewegen. Der Drehpunkt um den sich die Kamera dreht wird mit dem Aufruf der Prozedur PositionCamera festgelegt. Sollte man diesen Drehpunkt benötigen (z.B. zum Anzeigen eines Koordinatenkreuzes, ...), so kann man auf die Property PointOfRotation zugreifen (read only).

Die Kamera kann bis zu zehn Positionen speichern und auch wiederherstellen. (SavePosition, RestorePosition)

Die Kamera kann sich selber zu jeder Zeit unter Beibehaltung der aktuellen Position senkrecht zur Welt ausrichten. (Adjust)

Um sicher zu sein, dass auch alle nötigen Definitionen und Funktionen zur Verfügung stehen, habe ich einfach mal einen Großteil meiner Funktionssammlung beigefügt ([[Kamera (3)]]). Diese Funktionen/Prozeduren werden so oder in leicht abgeänderter Form wohl bei jedem OpenGL Programmierer existieren.

Sollte es noch irgendwelche Fragen zu diesem Modul geben, so stehe ich gerne zur Verfügung.

==Gebrauch der Funktionen:==

Die hier vorzufindende Beschreibung stellt keine komplette Anleitung für die Verwendung der Kamera dar. Um bis in die "Tiefen" des Objekts hinabzusteigen seht Euch bitte das von mir bereit gestellte Beispielprogramm an ([[Kamera]]). Wenn Ihr das herunterladet habt Ihr auch auf jeden Fall die neueste Version der Sourcen, die ich zuletzt am 26.12.2007 aktualisert habe. Diese Sourcen vereinfachen die Verarbeitung von Tastatur- und Mausevents. Die u.a. Anleitung entspricht daher nicht mehr dem aktuellen vorgehen, kann aber auch weiterhin so angewendet werden.

1.
PositionCamera mit Vektoren für Position, Blickpunkt und Ausrichtung aufrufen. Die Blickrichtung gibt auch gleichzeitig den Drehpunkt der Szene an, um den dann mit RotateCamera gedreht werden kann. PositionCamera positioniert den angegebenen Blickpunkt in der Mitte des Bildschirms. PositionCamera sollte nur zur Positionierung der Kamera benutzt werden, also einmal am Anfang. Alle weiteren Kameraveränderungen sollten mit den zur Verfügung gestellten Methoden durchgeführt werden.

2.
Aufruf der Funktionen RotateCamera und TranslateCamera um die Ausrichtung/Lage der Kamera zu verändern. Um das unten angegebene Beispiel implementieren zu können, müssen folgende Variablen im aktuellen Modul definiert werden:

FMousePosX, FMousePosY,
FMousePressX, FMousePressY,
FRightMousePressed, FLeftMousePressed,
FxDelta, FyDelta, FxStart, FyStart,
FxRot und FyRot (sind alle als var im aktuellen Modul definiert)

FRightMousePressed und FLeftMousePressed müssen in der Prozedur MouseDown/MouseUp gesetzt werden.

FxRot und FyRot müssen mit 0 initialisiert werden.

<pascal>
unit Example;

interface

uses
Windows, ...

type
TFExample = class(TForm)
.
.
.
private
FCamera: TCamera;

FglDC: HDC; // device context der aktuellen komponente
FglRC: HGLRC; // rendering kontext der aktuellen komponente

ClearAlpha: GLclampd; // alpha wert der hintergrundfarbe
ClearRed: GLclampd; // rotanteil der hintergrundfarbe
ClearGreen: GLclampd; // grünanteil der hintergrundfarbe
ClearBlue: GLclampd; // blauanteil der hintergrundfarbe
public
.
.
.
published
.
.
.

var
FExample: TFExample;

FxStart, // berechnung der mausbewegungen.
FxDelta, // delta = aktuelle position minus start
FyStart, // start wird erfasst sobald eine maustaste
FyDelta:integer; // gedrückt wird.

FxRot, // umrechnung von delta in rotation wenn
FyRot:double; // drehung gewünscht ist (je nach taste)

FMousePressX, // aktuelle mausposition, wenn maustaste gedrückt wird
FMousePressY: integer;
FMousePosX, // aktuelle mausposition
FMousePosY: integer;

//mausaktivität überprüfen
FRightMousePressed:boolean; // ist die rechte maustaste gedrückt?
FLeftMousePressed:boolean; // ist die linke maustaste gedrückt?

const
crCursorMove = 1;
crCursorRotate = 2;
crCursorSelect = 3;

implementation

uses ...

{$R *.dfm}
{$R cursors.res}
</pascal>
<pascal>
procedure TFExample.FormMouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer);
begin
// mausposition merken
FMousePosX := X;
FMousePosY := Y;

//das Ziehen der Szene kann nur bei gedrückter Maustaste passieren
if not (FRightMousePressed or FLeftMousePressed) then exit;

//ausrechenen um wieviel der Mauszeiger bewegt wurde
FxDelta := FxStart-X;
FyDelta := FyStart-Y;

//Rotation anpassen, damit es nicht zu schnell wird
FxRot := FxRot - FyDelta/20;
Fyrot := FyRot - FxDelta/20;

//das naechste mal ist das hier unser startpunkt:
FxStart := X;
FyStart := Y;

if FRightMousePressed then
begin
if FxRot <> 0 then FCamera.RotateCamera (FxRot, 0, 0);
if FyRot <> 0 then FCamera.RotateCamera (0, FyRot, 0);
end;
if FLeftMousePressed then
begin
if FxRot <> 0 then FCamera.TranslateCamera (FxRot, 0, 0);
if FyRot <> 0 then FCamera.TranslateCamera (0, FyRot, 0);
end;
Paint;

FxRot := 0;
FyRot := 0;
end;
</pascal>
<pascal>
procedure TFExample.FormMouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
begin
if Button = mbRight then
begin
//rechte maustaste gedrückt
FRightMousePressed:=true;
//Startposition merken
FxStart:=X;
FyStart:=Y;
Screen.Cursor := crCursorRotate;
end
else if Button = mbLeft then
begin
//rechte maustaste gedrückt
FLeftMousePressed:=true;
//Startposition merken
FxStart:=X;
FyStart:=Y;
Screen.Cursor := crCursorMove;
end;
// aktuelle Mouseposition festhalten. so kann z.B. überprüft werden
// welches Objekt an der aktuellen Mausposition liegt
FMousePressX := X;
FMousePressY := Y;
end;
</pascal>
<pascal>
procedure TFExample.FormMouseUp(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
begin
if Button = mbRight then
begin
FRightMousePressed:=false;
end;
if Button = mbLeft then
begin
FLeftMousePressed:=false;
end;
if not (FRightMousePressed or FLeftMousePressed) then
Screen.Cursor := crCursorSelect;
end;
</pascal>
<pascal>
procedure TFExample.FormCreate(Sender: TObject);
resourcestring
ResStrRCfailed = 'CreateRenderingContext failed ';
ResStrWGLfailed = 'wglMakeCurrent failed ';
begin
inherited;

// wenn das grafiksystem von OpenGL nicht aktiviert werden kann,
// müssen wir das programm beenden
if not InitOpenGL then
begin
raise Exception.Create('InitOpenGL failed '+IntToStr(GetLastError));
halt (100);
end;

FglDC := getDC(self.WindowHandle);
FglRC := CreateRenderingContext(FglDC,
[opDoubleBuffered],
32, 24, 0,0,0,0);

if FglRC=0 then
begin
raise Exception.Create(ResStrRCfailed + IntToStr(GetLastError));
halt (100);
end;

if not wglMakeCurrent(FglDC, FglRC) then
raise Exception.Create(ResStrWGLfailed + IntToStr(GetLastError));

FxRot:=0;
FyRot:=0;

FRightMousePressed := false;
FLeftMousePressed := false;

Screen.Cursors[crCursorMove] := LoadCursor(HInstance,'MOVE');
Screen.Cursors[crCursorRotate] := LoadCursor(HInstance,'ROTATE');
Screen.Cursors[crCursorSelect] := LoadCursor(HInstance,'SELECT');
Screen.Cursor := crCursorSelect;

ClearAlpha := 1; // bildschirm immer mit weiß löschen
ClearRed:= 1; // bildschirm immer mit weiß löschen
ClearGreen:= 1; // bildschirm immer mit weiß löschen
ClearBlue:= 1; // bildschirm immer mit weiß löschen

FCamera := TCamera.Create;
end;
</pascal>

Das mit den unterschiedlichen Cursordarstellungen habe ich nur als Hinweis gelassen. Diese Anweisungen müsst Ihr rausnehmen es sei denn, dass Ihr eine Resourcendatei mit drei unterschiedlichen Cursorarten erstellt und sie unter "Cursors.res" abspeichert.

Dieses Beispiel ist vereinfacht dargestellt und es ist sehr wahrscheinlich, dass Ihr daran noch etwas herumspielen müsst. Ich habe noch das Mausrad eingesetzt um in den Bildschirm hinein- oder aus ihm herauszuzoomen (TranslateCamera(0,0,?)).
Durch modifizieren der Geschwindigkeit (+/-) für die einzelnen Achsen, die an die Prozeduren TranslateCamera und RotateCamera übergeben werden kann man entweder die Szene oder die Kamera bewegen.

3. Szene zeichnen:

Lichteigenschaften setzen

Materialeigenschaften setzen

... (die üblichen Vorbereitungen treffen)

FCamera.Apply

Szene zeichnen

wenn Terrain gewünscht:
FCamera.ApplyForTerrain
Terrain zeichnen
ende wenn

Swapbuffers...

usw.

<pascal>
procedure TFExample.Render; // wird aus der Methode Paint aufgerufen
resourcestring
RestStrWGLfailed = 'TFExample.Render: wglMakeCurrent failed with ';
begin
// da mehrere fenster möglich sind, muss immer der aktuelle
// ausgabekontext ausgewählt werden
if wglMakeCurrent(FglDC,FglRC) then
begin
glMatrixMode (GL_MODELVIEW);

glClearColor(ClearRed, ClearGreen, ClearBlue, ClearAlpha);
glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);

// View setzen

Camera1.Apply;

// Szene jetzt zeichnen

glFlush; // bearbeitung der GL-befehle beginnen
glFinish; // warten bis alle befehle ausgeführt sind

SwapBuffers(FglDC); // flackern verhindern
end
else
begin
raise Exception.Create(RestStrWGLfailed + IntToStr(GetLastError));
end;
end;
</pascal>

Den Kameracode findet ihr unter [[Kamera (2)]]. 
Die verwendete Toolsammlung findet ihr unter [[Kamera (3)]].

[[Kategorie:Anleitung]]

Kamera

2008-02-05T04:43:29Z

Andyh:

Andyh beschreibt in den Artikeln:
*[[Kamera (1)]]
*[[Kamera (2)]]
*[[Kamera (3)]]
wie man eine Kamara realisiert.

{{ZitatVon|Andyh|
Nachdem ich viel Zeit damit verbracht habe eine funktionierende Kamera
zu bauen und es nun endlich geschafft habe, wollte ich diese Funktionalität
auch anderen zur Verfügung stellen.
Da mir schon viel geholfen wurde, kann ich so einen Teil meiner "Schuld"
zurück zahlen.

Die folgend beschriebene Kamera kann sich um alle drei Achsen drehen und sich
in allen Ebenen bewegen. Der Drehpunkt um den sich die Kamera dreht wird mit
dem Aufruf der Prozedur PositionCamera festgelegt. Sollte man diesen Drehpunkt
benötigen (z.B. zum anzeigen eines Koordinatenkreuzes, ...) so kann man auf
die Property PointOfRotation zugreifen (read only).

Die Kamera kann bis zu zehn Positionen speichern und auch wieder herstellen.
(SavePosition, RestorePosition)

Die Kamera kann sich selber zu jeder Zeit unter Beibehaltung der aktuellen
Position senkrecht zur Welt ausrichten.
(Adjust)

Um sicher zu sein, dass auch alle nötigen Definitionen und Funktionen zur
Verfügung stehen habe ich einfach mal einen Großteil meiner Funktionssammlung
beigefügt (Util.pas). Diese Funktionen/Prozeduren werden so oder in leicht
abgeänderter Form wohl bei jedem OpenGL Programmierer existieren.

...

Bisher glaubte ich, dass man mit der von mir erstellten Kurzanleitung auskommt, habe jetzt aber doch noch ein Beispielprogramm erstellt. Nach mehrmaligem Studium meiner Kurzanleitung bin ich nämlich zu dem Schluss gekommen, dass man mit diesem Programmierbeispiel nicht zu dem von mir beabsichtigten Ergebnis kommen kann. Das Beispielprogramm, welches die Funktionen der Kamera veranschaulicht, wurde mit Delphi 2005 entwickelt. Wenn Ihr über eine ältere Delphiversion verfügt nehmt einfach die DPR Datei oder erstellt ein neues Projekt mit Euerem Compiler und bindet die benötigten Dateien ein.

Ich habe noch einiges mehr an Code reingepackt als unbedingt nötig, um der Sache optisch ein Mindestmaß an Anspruch zu verleihen. Deswegen können aus diesem Beispielprogramm noch die eine oder andere Komponente entnommen werden (wenn nicht schon vorhanden). Dies sind z.B. Komponenten für Licht, Material, zur Textdarstellung, eine Skybox und zur Handhabung von Grafikdateien (die ist allerdings nicht auf meinem Mist gewachsen). Zusätzlich habe ich noch den Memory Manager FastMM4 beigepackt und eingebunden. Mit diesem kann man sehr schön (besser als mit den von Delphi bereitgestellten Möglichkeiten) nicht freigegebene Resourcen aufspüren. Ich war überrascht was ich alles nicht freigegeben hatte, als ich den zum ersten mal eingesetzt habe.

Das Beispielprogramm findet Ihr unter [[http://files.delphigl.com/Download/kamera_heyroth.zip
]]. Dieses Programm habe ich am 26.12.2007 aktualisiert um die Steuerung per Tastatur und Maus zu vereinfachen. Die bisher in den das Modul benutzenden Methoden KeyDown, KeyUp, ModeDown, MouseUp usw. nötigen Tätigkeiten habe ich in Kameramethoden ausgelagert. Dadurch kann mit einem einzigen Aufruf dieser Methode(n) die nötige Arbeit abgerufen werden.

Aussehen sollte es nach dem Aufruf so:

[[Bild:CameraExample.jpg]]

...

Sollte es noch irgendwelche Fragen zu diesem Modul geben so stehe ich gerne
zur Verfügung (AndyH).}}

[[Kategorie:Technik_oder_Algorithmus]]

Kamera (2)

2007-08-20T08:52:34Z

Andyh:

Eine Beschreibung findet ihr unter [[Kamera (1)]]. 
Die verwendete Toolsammlung findet ihr unter [[Kamera (3)]].

<pascal>
// Wie ich selber immer wieder merken muss, ist eine Software anscheinend
// nie fertig. Immer moechte man etwas verbessern oder neue Features
// einbauen.
// Sollte also jemand Änderungs- oder Verbesserungsvorschläge haben oder
// neue Ideen einbringen wollen, oder sollten Verstaendnisfragen bestehen,
// so mailt bitte an
//
// SpamAndi@gmx.de
//
// Danke.
//
// Updates:
//
// 06.11.2005
// Die Deklaration der DESTROY Methode war falsch. Das fuehrte dazu,
// dass in der Methode CREATE erzeugte Objekte nicht richtig frei-
// gegeben wurden und es zu EAccessViolations kam. Die Methode wird
// jetzt in der PUBLIC Section mit der Direktive OVERRIDE aufgerufen.
//
// 11.11.2005
// Die Positionierung funktioniert jetzt.
// Wegen eines Verstaendnisproblems wurden die Positionen immer auf den
// Kamerapunkt aufaddiert. Das bedeutete, dass die Positionierung aus
// dem Ruder lief wenn sie nicht im Nullpunkt stattfand. Je groesser die
// gewuenschte Position war um so groesser war die Abweichung von der
// Darstellung.
// Ich habe nicht bedacht, dass bei einer "Kamera"-bewegung und -drehung
// ja eigentlich die Szene bewegt und gedreht wird. Deswegen wurden nach
// einer Positionierung die folgenden Projektionen immer basierend auf der
// danach gueltigen Kameraposition gemacht.
// Jetzt wird die Position so gesetzt, dass die gewuenschte Kameraposition
// immer vor dem Betrachter steht.
//
// 23.11.2005
// Neues Flag (FFixedAxis) zur Entscheidung zwischen angepasster und realer
// Drehung. Dadurch wird das Bewegungsmodell angepasst. Siehe Methode Offset,
// bzw. UpdateMatrixOffset.
//
// 10.12.2005
// Property PointOfRotation ist jetzt nicht mehr ReadOnly.
// Der Blickpunkt bzw. Rotationspunkt kann jetzt direkt verändert werden.
// So kann eine neue Blickrichtung angenommen werden ohne vorher die Kamera-
// eigenschaften zu sichern und nach einem PositionCamera wieder zu setzen.
//
// 19.12.2005
// Neue Methode PositionCross.
// Die Methode PositionCross schiebt das Fadenkreuz in den angegebenen Punkt
// ohne die Lage der Szene zu verändern. Diese Funktionalitaet ist anders als
// ein neues Setzen der Property FPointOfRotation weil dabei die Szene in das
// Koordinatenkreuz geschoben wird.
//
// 31.01.2006
// Umstellung auf genaueres Zahlenformat
// Da die Darstellung von Szenen ausserhalb des Bereichs von FLOAT-Zahlen
// nicht funktioniert, muss alles auf DOUBLE umgestellt werden. Dazu gehört
// das Ersetzen von Datentypen und der Aufruf der entsprechenden GL-Funktionen.
//
unit Camera;

interface

Uses DglOpenGL, Util, Windows, Classes;

type
TCameraMatrix=Class
StackMatrix: array [0..9] of TArrMatrix;
StackCtr: integer;
Matrix: TArrMatrix;
InverseMatrix: TArrMatrix;
constructor Create;
//destructor destroy;
procedure Identity;
procedure Push;
procedure Pop;
procedure Load(M: TArrMatrix);
end;

TCamera=Class
Enabled: boolean;
function UpVector: TGLvector;
procedure RestorePosition(pos: integer);
procedure SavePosition(pos: integer);
function GiveStoredPosition(pos: integer): TGLvector;
procedure RotateCamera(ix, iy, iz: GLdouble);
procedure TranslateCamera(ix, iy, iz: GLdouble);
procedure CameraHome;
procedure PositionCamera(PositionVec: TGLvector; ViewVec: TGLvector; upVec: TGLvector);
procedure Adjust;
procedure Apply;
procedure ApplyForTerrain;
private
FPosition: TGLvector;
FViewDirection: TGLvector;
FPointOfRotation: TGLvector;
HomeMatrix: TCameraMatrix;
CameraMatrix: TCameraMatrix;
Initiated: boolean;
PosArray: array [0..9] of TCameraMatrix;
RotArray: array [0..9] of TGLvector;
FFixedAxis: boolean;
procedure Debug (Text: string);
function UpdateMatrixOffset(newMatrix: TArrMatrix): TArrMatrix;
function GetViewDirection: TGLvector;
procedure SetViewDirection (View: TGLvector);
procedure Initiate;
function GetPosition: TGLvector;
procedure SetPosition (Pos: TGLvector);
procedure Identity;
procedure Offset(x, y, z: GLdouble);
procedure RotateRoundAxis(rx, ry, rz: GLdouble);
procedure SetPointOfRotation (NewPoint: TGLvector);
public
constructor Create;
destructor Destroy;override;
function InverseMatrix: TArrMatrix;
procedure ApplyInvers;
procedure PositionCross(CrossVec: TGLvector);
published
property PointOfRotation: TGLvector read FPointOfRotation write SetPointOfRotation;
property Position: TGLvector read GetPosition write SetPosition;
property ViewDirection: TGLvector read GetViewDirection write SetViewDirection;
property FixedAxis: boolean read FFixedAxis write FFixedAxis;
end;
TPCamera=^TCamera;

var
FDebugFile: Textfile;
FDebugFileName: string;
FDebugOn: boolean;

implementation

uses SysUtils;

constructor TCameraMatrix.Create;
begin
inherited create;
StackCtr := 0;
end;
{
destructor TCameraMatrix.Destroy;
begin
inherited destroy;
end;
}

procedure TCameraMatrix.Push;
begin
if (StackCtr > -1) and (StackCtr < 10) then
begin
StackMatrix[StackCtr] := Matrix;
inc (StackCtr);
end;
end;

procedure TCameraMatrix.Pop;
begin
if (StackCtr > 0) and (StackCtr < 11) then
begin
dec (StackCtr);
Load (StackMatrix[StackCtr]);
end;
end;

procedure TCameraMatrix.Identity;
// GetIdentity: aus OpenGL.pas
// initialisiert die CameraMatrix mit der Identitaetsmatrix
begin
Matrix := GetIdentity(Matrix);
InverseMatrix := GetIdentity(InverseMatrix);
end;

procedure TCameraMatrix.Load(M: TArrMatrix);
// die Matrix mit den Werten einer beliebigen anderen matrix fuellen
var
i: integer;
begin
for i:=0 to 15 do
Matrix[i]:=M[i];
// die invertierte Matrix kann benutzt werden um Objkekte z.B.
// immer zum Benutzer auszurichten
InvertMatrix (M, InverseMatrix);
end;

constructor TCamera.Create;
var
i: integer;
begin
inherited create;

// Initiated wird gebraucht um einmal alle Positionsspeicher
// mit der Anfangsposition zu belegen
Initiated := false;

// Kameramatrix anlegen
CameraMatrix := TCameraMatrix.Create;

// Matrix der letzten Position von PositionCamera anlegen
HomeMatrix := TCameraMatrix.Create;

// Positionsspeicher anlegen
for i := 0 to 9 do
PosArray[i] := TCameraMatrix.Create;

// standardmaessig immer entlang der bildschirmachsen verschieben
FFixedAxis := true;
end;

destructor TCamera.Destroy;
// alle in create belegten Resourcen wieder freigeben
var
i: integer;
begin
FreeAndNil (CameraMatrix);
FreeAndNil (HomeMatrix);
for i := 0 to 9 do
FreeAndNil (PosArray[i]);

inherited destroy;
end;

procedure TCamera.RotateRoundAxis(rx, ry, rz: GLdouble);
// hier drehen wir jetzt um die einzelnen Achsen.
// die Parameter geben die "Drehgeschwindigkeit" vor.
var
newMatrix: TArrMatrix;
tempX, tempY, tempZ: TGLvector;
begin
glMatrixMode (GL_MODELVIEW);
glPushMatrix();

// aktuelle Position und Lage der Kamera herstellen
glLoadMatrixd(@CameraMatrix.Matrix);

if FFixedAxis then
begin
// über die bildschirmachsen drehen
tempX := GetMatrixX (CameraMatrix.InverseMatrix);
tempY := GetMatrixY (CameraMatrix.InverseMatrix);
tempZ := GetMatrixZ (CameraMatrix.InverseMatrix);
// wenn gewuenscht um die X-Achse drehen
if(rx <> 0) then
glRotated(rx,tempX.X,tempX.Y,tempX.Z);

// wenn gewuenscht um die Y-Achse drehen
if(ry <> 0) then
glRotated(ry,tempY.X,tempY.Y,tempY.Z);

// wenn gewuenscht um die Z-Achse drehen
if(rz <> 0) then
glRotated(rz,tempZ.X,tempZ.Y,tempZ.Z);
end
else
begin
// über die achsen des koordinatenkreuzes drehen
// wenn gewuenscht um die X-Achse drehen
if(rx <> 0) then
glRotated(rx,1,0,0);

// wenn gewuenscht um die Y-Achse drehen
if(ry <> 0) then
glRotated(ry,0,1,0);

// wenn gewuenscht um die Z-Achse drehen
if(rz <> 0) then
glRotated(rz,0,0,1);
end;

// die neu erzeugte Matrix auslesen
glGetDoublev(GL_MODELVIEW_MATRIX, @newMatrix);

glPopMatrix();

// und in die Kameramatrix sichern
CameraMatrix.Load(newMatrix);
end;

procedure TCamera.Identity;
begin
CameraMatrix.Identity;
HomeMatrix.Identity;

Enabled := true;
end;

procedure TCamera.Offset(x, y, z: GLdouble);
// verschieben der Kamera auf einer beliebigen Achse
var
newMatrix: TArrMatrix;
//OldView: TGLvector;
begin
Debug ('- Offset - Start --------------------------------------------------');
glMatrixMode (GL_MODELVIEW);

glPushMatrix();
glLoadIdentity;
glTranslated(x,y,z);
glGetDoublev(GL_MODELVIEW_MATRIX, @newMatrix);
glPopMatrix();

Debug ('Position: '+GLvectorToText (GetMatrixPos (newMatrix)));
newMatrix := UpdateMatrixOffset (newMatrix);
CameraMatrix.Load(newMatrix);
Debug ('- Offset - Ende- --------------------------------------------------');
end;

procedure TCamera.PositionCamera(PositionVec: TGLvector;
ViewVec: TGLvector;
upVec: TGLvector);
var
newMatrix: TArrMatrix;
i: integer;
P, V, U: TGLvector;
Laenge: GLdouble;
begin
Debug ('- PositionCamera - Start ------------------------------------------');
// die gewuenschte konstruktion immer auf die Z-ebene projizieren.
// zuerst die position in den nullpunkt holen
InitVector (P, 0, 0, 0);
// jetzt den viewpoint um den gleichen betrag reduzieren, damit
// die gerade parallel verschoben wird.
V := SubtractVector (ViewVec, PositionVec);
// U ist halt schneller geschrieben als upVec...
U := upVec;

// den betrag ermitteln, um den die kamera nachher auf der Z-Achse
// verschoben werden muss
Laenge := Magnitude (SubtractVector (P, V));

Identity;

glMatrixMode (GL_MODELVIEW);
glPushMatrix;
glLoadIdentity;

// glulookat wird die matrix parallel zur Z-achse ausrichten
gluLookAt (P.X, P.Y, P.Z, V.X, V.Y, V.Z, U.X, U.Y, U.Z);
glGetDoublev(GL_MODELVIEW_MATRIX, @newMatrix);
glPopMatrix;

CameraMatrix.Load(newMatrix);
HomeMatrix.Load(newMatrix);

// da wir uns jetzt am zielpunkt befinden, müssen wir auf der Z-achse
// wieder zurueck zur kameraposition
Offset (0, 0, -Laenge);

// alle positionsspeicher mit der Kameraposition, Blickrichtung
// und dem upVector belegen. Nur beim ersten Aufruf von
// PositionCamera
if not Initiated then
Initiate;

FPointOfRotation := ViewVec;
Debug ('PointOfRotation: '+GLvectorToText (FPointOfRotation));
Debug ('- PositionCamera - Ende -------------------------------------------');
end;

procedure TCamera.PositionCross (CrossVec: TGLvector);
// diese prozedur verschiebt, im gegensatz zu einem verändern von
// PointOfRotation, das Koordinatenkreuz und nicht die Szene.
var
newMatrix: TArrMatrix;
PosDiff: TGLvector;
begin
Debug ('- PositionCross - Start -------------------------------------------');

PosDiff := SubtractVector (FPointOfRotation, CrossVec);

// Szene in das koordinatenkreuz verschieben
FPointOfRotation := CrossVec;

// jetzt die Szene wieder um den gleichen betrag zurückverschieben
// das sieht dann so aus, als ob das koordinatenkreuz verschoben
// worden wäre
// zuerst die aktuelle neue Situation herstellen
// (mit neuem FPointOfRotation)
Apply;

// jetzt um den Differenzbetrag des alten und neuen
// Rotationspunkts zurück verschieben
glTranslated (-PosDiff.X, 0, 0);
glTranslated (0, -PosDiff.Y, 0);
glTranslated (0, 0, -PosDiff.Z);

// jetzt vom neuen Rotationspunktes zurück ins Zentrum, damit beim
// nächsten Apply das glTranslatef (-FPointOfRotation, ...) klappt
glTranslated (CrossVec.X, 0, 0);
glTranslated (0, CrossVec.Y, 0);
glTranslated (0, 0, CrossVec.Z);

// aktuelle Matrix holen...
glGetDoublev(GL_MODELVIEW_MATRIX, @newMatrix);

// und als Kameramatrix abspeichern
CameraMatrix.Load(newmatrix);
Debug ('- PositionCross - Ende --------------------------------------------');
end;

procedure TCamera.CameraHome;
// Kamera in die beim letzten Aufruf von PositionCamera uebergebene
// Position/Lage bringen
begin
CameraMatrix.Load(HomeMatrix.Matrix);
end;

procedure TCamera.SavePosition (pos: integer);
// wie der Prozedurname schon sagt...
begin
if (pos < 0) or (pos > 9) then
exit;

PosArray[pos].Load(CameraMatrix.Matrix);
RotArray[pos] := FPointOfRotation;
end;

procedure TCamera.RestorePosition (pos: integer);
// wie der Prozedurname schon sagt...
begin
if (pos < 0) or (pos > 9) then
exit;

CameraMatrix.Load(PosArray[pos].Matrix);
FPointOfRotation := RotArray[pos];
end;

function TCamera.GiveStoredPosition (pos: integer): TGLvector;
// gibt den Inhalt des durch pos bestimmten
// Positionsspecihers zurueck
begin
if (pos < 0) or (pos > 9) then
exit;

result := GetMatrixPos (PosArray[pos].Matrix);
end;

procedure TCamera.TranslateCamera(ix, iy, iz: GLdouble);
// vom Benutzer aufzurufende Methode um eine Verschiebung
// durchzufuehren
begin
Offset (ix, iy, iz);
end;

procedure TCamera.RotateCamera(ix, iy, iz: GLdouble);
// vom Benutzer aufzurufende Methode um eine Drehung
// durchzufuehren
begin
RotateRoundAxis (-iy, -ix, -iz);
end;

procedure TCamera.Apply;
// hier wird die Kamera eingeschaltet. Nach dem Aufruf dieser Prozedur
// sollte die Szene mit allen benoetigten Drehungen, Verschiebungen
// gezeichnet werden.
begin
if not Enabled then
exit;

glMatrixMode (GL_MODELVIEW);
glLoadMatrixd(@CameraMatrix.Matrix);
glTranslated (-FPointOfRotation.X,
-FPointOfRotation.y,
-FPointOfRotation.Z);
end;

procedure TCamera.ApplyForTerrain;
// hier wird wie in Apply die Kamera eingeschaltet. da man um ein terrain
// (skycube, ...) anzuzeigen aber immer die gleiche entfernung zur welt
// einhalten muss, wird hier nur gedreht und nicht verschoben.
var
pos: TGLvector;
begin
if not Enabled then
exit;

glMatrixMode (GL_MODELVIEW);
// für das Terrain nur die Drehung ausführen
glLoadMatrixd(@CameraMatrix.Matrix);
// deswegen jetzt die verschiebung zurücknehmen
Pos := GetMatrixPos (CameraMatrix.InverseMatrix);
glTranslated (Pos.X, Pos.Y, Pos.Z);
end;

function TCamera.GetPosition: TGLvector;
// diese Property-Funktion fragt die aktuelle Position der Kamera ab
begin
// position: letzte Spalte der Matrix
result := AddVector (GetMatrixPos (CameraMatrix.InverseMatrix), FPointOfRotation);
end;

procedure TCamera.SetPosition (Pos: TGLvector);
// diese Property-Funktion setzt eine neue Position der Kamera
var
m: TArrMatrix;
begin
// position: letzte Spalte der Matrix
m := CameraMatrix.Matrix;
SetMatrixPos (m, SubtractVector (Pos, FPointOfRotation));
CameraMatrix.Load (m);
end;

function TCamera.GetViewDirection: TGLvector;
// mit dieser Funktion kann die aktuelle Blickrichtung der Kamera
// abgefragt werden
var
return: TGLvector;
begin
// view direction: dritte Spalte der Matrix (Z-Achse)
result := GetMatrixZ (CameraMatrix.InverseMatrix);
end;

procedure TCamera.SetViewDirection (View: TGLvector);
// mit dieser Funktion kann die aktuelle Blickrichtung der Kamera
// gesetzt werden
begin
// view direction: dritte Spalte der Matrix (Z-Achse)
SetMatrixZ (CameraMatrix.InverseMatrix, View);
end;

function TCamera.UpVector: TGLvector;
// mit dieser Funktion kann die aktuelle Ausrichtung der Kamera
// abgefragt werden
var
return: TGLvector;
begin
// upVector: zweite Spalte der Matrix (Y-Achse)
result := GetMatrixY (CameraMatrix.InverseMatrix);
end;

procedure TCamera.Adjust;
// mit dieser Prozedur kann die Kamera zu jeder Zeit, unabhaengig
// von Drehung und Position, zur Y-Achse ausgerichtet werden.
// Die aktuelle Position wird dabei beibehalten.
var
m: TArrMatrix;
v: TGLvector;
begin
// position aus der aktuellen cameramatrix holen
v := GetMatrixPos (CameraMatrix.Matrix);
// m mit identitätsmatrix initialisieren
m := GetIdentity(m);
// die position aus der aktuellen cameramatrix in m speichern
SetMatrixPos (m, v);
// m als aktuelle cameramatrix speichern
CameraMatrix.Load(m);
end;

function TCamera.InverseMatrix: TArrMatrix;
begin
result := CameraMatrix.InverseMatrix;
end;

procedure TCamera.Initiate;
var
i: integer;
begin
for i := 0 to 9 do
SavePosition (i);
Initiated := true;
end;

function TCamera.UpdateMatrixOffset (newMatrix: TArrMatrix): TArrMatrix;
begin
// wenn ich mit Multiply (FixedAxis) arbeite, wird die zeichnung immer
// entlang der bildschirmachsen verschoben. wenn ich Multiply, version 2
// nehme, wird sie auf den errechneten achsen verschoben.
if FFixedAxis then
begin
result := Multiply (newMatrix, CameraMatrix.Matrix);
end
else
begin
result := Multiply (CameraMatrix.Matrix, newMatrix);
end;
end;

procedure TCamera.SetPointOfRotation (NewPoint: TGLvector);
// setzt den viewpoint oder rotationpoint ohne die anderen parameter zu
// veraendern. so kann man z.B. eine Kamerafahrt in immer der gleichen
// position simulieren.
begin
FPointOfRotation := NewPoint;
end;

procedure TCamera.Debug (Text: string);
begin
if not FDebugOn then
exit;
writeln (FDebugFile, DateToStr (date) + ' | ' +
TimeToStr (time) + ' | ' +
Text);
end;

procedure TCamera.ApplyInvers;
var
M: TArrMatrix;
begin
// Um Objekte immer zum benutzer ausrichten, darf nur die drehung angewendet
// werden und nicht die verschiebung. Verschiebung wird hier zurückgenommen.
// Vorher muss die Kamera angewendet und die nötigen Verschiebungen/
// Drehungen ausgeführt werden.
M := InverseMatrix;
M[12] := 0;
M[13] := 0;
M[14] := 0;
M[15] := 1;
glMultMatrixd(@M);
end;

Initialization
FDebugOn := false;
FDebugFileName := ExePath + 'SKANAL3D_CAMERA.DBG';
if FDebugOn then
begin
AssignFile (FDebugFile, FDebugFileName);
Rewrite (FDebugFile);
end;

finalization
if FDebugOn then
begin
CloseFile (FDebugFile);
FDebugFileName := '';
end;

end.
</pascal>
[[Kategorie:Anleitung]]

Kamera

2007-04-01T01:41:19Z

Andyh:

Andyh beschreibt in den Artikeln:
*[[Kamera (1)]]
*[[Kamera (2)]]
*[[Kamera (3)]]
wie man eine Kamara realisiert.

{{ZitatVon|Andyh|
Nachdem ich viel Zeit damit verbracht habe eine funktionierende Kamera
zu bauen und es nun endlich geschafft habe, wollte ich diese Funktionalität
auch anderen zur Verfügung stellen.
Da mir schon viel geholfen wurde, kann ich so einen Teil meiner "Schuld"
zurück zahlen.

Die folgend beschriebene Kamera kann sich um alle drei Achsen drehen und sich
in allen Ebenen bewegen. Der Drehpunkt um den sich die Kamera dreht wird mit
dem Aufruf der Prozedur PositionCamera festgelegt. Sollte man diesen Drehpunkt
benötigen (z.B. zum anzeigen eines Koordinatenkreuzes, ...) so kann man auf
die Property PointOfRotation zugreifen (read only).

Die Kamera kann bis zu zehn Positionen speichern und auch wieder herstellen.
(SavePosition, RestorePosition)

Die Kamera kann sich selber zu jeder Zeit unter Beibehaltung der aktuellen
Position senkrecht zur Welt ausrichten.
(Adjust)

Um sicher zu sein, dass auch alle nötigen Definitionen und Funktionen zur
Verfügung stehen habe ich einfach mal einen Großteil meiner Funktionssammlung
beigefügt (Util.pas). Diese Funktionen/Prozeduren werden so oder in leicht
abgeänderter Form wohl bei jedem OpenGL Programmierer existieren.

...

Bisher glaubte ich, dass man mit der von mir erstellten Kurzanleitung auskommt, habe jetzt aber doch noch ein Beispielprogramm erstellt. Nach mehrmaligem Studium meiner Kurzanleitung bin ich nämlich zu dem Schluss gekommen, dass man mit diesem Programmierbeispiel nicht zu dem von mir beabsichtigten Ergebnis kommen kann. Das Beispielprogramm, welches die Funktionen der Kamera veranschaulicht, wurde mit Delphi 2005 entwickelt. Wenn Ihr über eine ältere Delphiversion verfügt nehmt einfach die DPR Datei oder erstellt ein neues Projekt mit Euerem Compiler und bindet die benötigten Dateien ein.

Ich habe noch einiges mehr an Code reingepackt als unbedingt nötig, um der Sache optisch ein Mindestmaß an Anspruch zu verleihen. Deswegen können aus diesem Beispielprogramm noch die eine oder andere Komponente entnommen werden (wenn nicht schon vorhanden). Dies sind z.B. Komponenten für Licht, Material, zur Textdarstellung, eine Skybox und zur Handhabung von Grafikdateien (die ist allerdings nicht auf meinem Mist gewachsen). Zusätzlich habe ich noch den Memory Manager FastMM4 beigepackt und eingebunden. Mit diesem kann man sehr schön (besser als mit den von Delphi bereitgestellten Möglichkeiten) nicht freigegebene Resourcen aufspüren. Ich war überrascht was ich alles nicht freigegeben hatte, als ich den zum ersten mal eingesetzt habe.

Das Beispielprogramm findet Ihr unter [[http://files.delphigl.com/Download/kamera_heyroth.zip
]].

Aussehen sollte es nach dem Aufruf so:

[[Bild:CameraExample.jpg]]

...

Sollte es noch irgendwelche Fragen zu diesem Modul geben so stehe ich gerne
zur Verfügung (AndyH).}}

[[Kategorie:Technik_oder_Algorithmus]]

Kamera (1)

2006-11-28T12:45:59Z

Andyh:

==Danke==
Nachdem ich viel Zeit damit verbracht habe, eine funktionierende Kamera zu bauen und es nun endlich geschafft habe, wollte ich diese Funktionalität auch Anderen zur Verfügung stellen.
Da mir schon viel geholfen wurde, kann ich so einen Teil meiner "Schuld" zurück zahlen.

Bitte seht ab und zu mal hier nach, ob es für diese Kamera Updates gibt. Sollte es so sein, habe ich das im Code ([[Kamera (2)]]) vermerkt. Ladet in diesem Fall bitte den Source Code der Kamera und(!) die Utilities herunter.

==Meine Kamera==
Die wie folgend beschriebene Kamera kann sich um alle drei Achsen drehen und sich in allen Ebenen bewegen. Der Drehpunkt um den sich die Kamera dreht wird mit dem Aufruf der Prozedur PositionCamera festgelegt. Sollte man diesen Drehpunkt benötigen (z.B. zum Anzeigen eines Koordinatenkreuzes, ...), so kann man auf die Property PointOfRotation zugreifen (read only).

Die Kamera kann bis zu zehn Positionen speichern und auch wiederherstellen. (SavePosition, RestorePosition)

Die Kamera kann sich selber zu jeder Zeit unter Beibehaltung der aktuellen Position senkrecht zur Welt ausrichten. (Adjust)

Um sicher zu sein, dass auch alle nötigen Definitionen und Funktionen zur Verfügung stehen, habe ich einfach mal einen Großteil meiner Funktionssammlung beigefügt ([[Kamera (3)]]). Diese Funktionen/Prozeduren werden so oder in leicht abgeänderter Form wohl bei jedem OpenGL Programmierer existieren.

Sollte es noch irgendwelche Fragen zu diesem Modul geben, so stehe ich gerne zur Verfügung.

==Gebrauch der Funktionen:==

Die hier vorzufindende Beschreibung stellt keine komplette Anleitung für die Verwendung der Kamera dar. Um bis in die "Tiefen" des Objekts hinabzusteigen seht Euch bitte das von mir bereit gestellte Beispielprogramm an ([[Kamera]]). Wenn Ihr das herunterladet habt Ihr auch auf jeden Fall die neueste Version der Sourcen.

1.
PositionCamera mit Vektoren für Position, Blickpunkt und Ausrichtung aufrufen. Die Blickrichtung gibt auch gleichzeitig den Drehpunkt der Szene an, um den dann mit RotateCamera gedreht werden kann. PositionCamera positioniert den angegebenen Blickpunkt in der Mitte des Bildschirms. PositionCamera sollte nur zur Positionierung der Kamera benutzt werden, also einmal am Anfang. Alle weiteren Kameraveränderungen sollten mit den zur Verfügung gestellten Methoden durchgeführt werden.

2.
Aufruf der Funktionen RotateCamera und TranslateCamera um die Ausrichtung/Lage der Kamera zu verändern. Um das unten angegebene Beispiel implementieren zu können, müssen folgende Variablen im aktuellen Modul definiert werden:

FMousePosX, FMousePosY,
FMousePressX, FMousePressY,
FRightMousePressed, FLeftMousePressed,
FxDelta, FyDelta, FxStart, FyStart,
FxRot und FyRot (sind alle als var im aktuellen Modul definiert)

FRightMousePressed und FLeftMousePressed müssen in der Prozedur MouseDown/MouseUp gesetzt werden.

FxRot und FyRot müssen mit 0 initialisiert werden.

<pascal>
unit Example;

interface

uses
Windows, ...

type
TFExample = class(TForm)
.
.
.
private
FCamera: TCamera;

FglDC: HDC; // device context der aktuellen komponente
FglRC: HGLRC; // rendering kontext der aktuellen komponente

ClearAlpha: GLclampd; // alpha wert der hintergrundfarbe
ClearRed: GLclampd; // rotanteil der hintergrundfarbe
ClearGreen: GLclampd; // grünanteil der hintergrundfarbe
ClearBlue: GLclampd; // blauanteil der hintergrundfarbe
public
.
.
.
published
.
.
.

var
FExample: TFExample;

FxStart, // berechnung der mausbewegungen.
FxDelta, // delta = aktuelle position minus start
FyStart, // start wird erfasst sobald eine maustaste
FyDelta:integer; // gedrückt wird.

FxRot, // umrechnung von delta in rotation wenn
FyRot:double; // drehung gewünscht ist (je nach taste)

FMousePressX, // aktuelle mausposition, wenn maustaste gedrückt wird
FMousePressY: integer;
FMousePosX, // aktuelle mausposition
FMousePosY: integer;

//mausaktivität überprüfen
FRightMousePressed:boolean; // ist die rechte maustaste gedrückt?
FLeftMousePressed:boolean; // ist die linke maustaste gedrückt?

const
crCursorMove = 1;
crCursorRotate = 2;
crCursorSelect = 3;

implementation

uses ...

{$R *.dfm}
{$R cursors.res}
</pascal>
<pascal>
procedure TFExample.FormMouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer);
begin
// mausposition merken
FMousePosX := X;
FMousePosY := Y;

//das Ziehen der Szene kann nur bei gedrückter Maustaste passieren
if not (FRightMousePressed or FLeftMousePressed) then exit;

//ausrechenen um wieviel der Mauszeiger bewegt wurde
FxDelta := FxStart-X;
FyDelta := FyStart-Y;

//Rotation anpassen, damit es nicht zu schnell wird
FxRot := FxRot - FyDelta/20;
Fyrot := FyRot - FxDelta/20;

//das naechste mal ist das hier unser startpunkt:
FxStart := X;
FyStart := Y;

if FRightMousePressed then
begin
if FxRot <> 0 then FCamera.RotateCamera (FxRot, 0, 0);
if FyRot <> 0 then FCamera.RotateCamera (0, FyRot, 0);
end;
if FLeftMousePressed then
begin
if FxRot <> 0 then FCamera.TranslateCamera (FxRot, 0, 0);
if FyRot <> 0 then FCamera.TranslateCamera (0, FyRot, 0);
end;
Paint;

FxRot := 0;
FyRot := 0;
end;
</pascal>
<pascal>
procedure TFExample.FormMouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
begin
if Button = mbRight then
begin
//rechte maustaste gedrückt
FRightMousePressed:=true;
//Startposition merken
FxStart:=X;
FyStart:=Y;
Screen.Cursor := crCursorRotate;
end
else if Button = mbLeft then
begin
//rechte maustaste gedrückt
FLeftMousePressed:=true;
//Startposition merken
FxStart:=X;
FyStart:=Y;
Screen.Cursor := crCursorMove;
end;
// aktuelle Mouseposition festhalten. so kann z.B. überprüft werden
// welches Objekt an der aktuellen Mausposition liegt
FMousePressX := X;
FMousePressY := Y;
end;
</pascal>
<pascal>
procedure TFExample.FormMouseUp(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
begin
if Button = mbRight then
begin
FRightMousePressed:=false;
end;
if Button = mbLeft then
begin
FLeftMousePressed:=false;
end;
if not (FRightMousePressed or FLeftMousePressed) then
Screen.Cursor := crCursorSelect;
end;
</pascal>
<pascal>
procedure TFExample.FormCreate(Sender: TObject);
resourcestring
ResStrRCfailed = 'CreateRenderingContext failed ';
ResStrWGLfailed = 'wglMakeCurrent failed ';
begin
inherited;

// wenn das grafiksystem von OpenGL nicht aktiviert werden kann,
// müssen wir das programm beenden
if not InitOpenGL then
begin
raise Exception.Create('InitOpenGL failed '+IntToStr(GetLastError));
halt (100);
end;

FglDC := getDC(self.WindowHandle);
FglRC := CreateRenderingContext(FglDC,
[opDoubleBuffered],
32, 24, 0,0,0,0);

if FglRC=0 then
begin
raise Exception.Create(ResStrRCfailed + IntToStr(GetLastError));
halt (100);
end;

if not wglMakeCurrent(FglDC, FglRC) then
raise Exception.Create(ResStrWGLfailed + IntToStr(GetLastError));

FxRot:=0;
FyRot:=0;

FRightMousePressed := false;
FLeftMousePressed := false;

Screen.Cursors[crCursorMove] := LoadCursor(HInstance,'MOVE');
Screen.Cursors[crCursorRotate] := LoadCursor(HInstance,'ROTATE');
Screen.Cursors[crCursorSelect] := LoadCursor(HInstance,'SELECT');
Screen.Cursor := crCursorSelect;

ClearAlpha := 1; // bildschirm immer mit weiß löschen
ClearRed:= 1; // bildschirm immer mit weiß löschen
ClearGreen:= 1; // bildschirm immer mit weiß löschen
ClearBlue:= 1; // bildschirm immer mit weiß löschen

FCamera := TCamera.Create;
end;
</pascal>

Das mit den unterschiedlichen Cursordarstellungen habe ich nur als Hinweis gelassen. Diese Anweisungen müsst Ihr rausnehmen es sei denn, dass Ihr eine Resourcendatei mit drei unterschiedlichen Cursorarten erstellt und sie unter "Cursors.res" abspeichert.

Dieses Beispiel ist vereinfacht dargestellt und es ist sehr wahrscheinlich, dass Ihr daran noch etwas herumspielen müsst. Ich habe noch das Mausrad eingesetzt um in den Bildschirm hinein- oder aus ihm herauszuzoomen (TranslateCamera(0,0,?)).
Durch modifizieren der Geschwindigkeit (+/-) für die einzelnen Achsen, die an die Prozeduren TranslateCamera und RotateCamera übergeben werden kann man entweder die Szene oder die Kamera bewegen.

3. Szene zeichnen:

Lichteigenschaften setzen

Materialeigenschaften setzen

... (die üblichen Vorbereitungen treffen)

FCamera.Apply

Szene zeichnen

wenn Terrain gewünscht:
FCamera.ApplyForTerrain
Terrain zeichnen
ende wenn

Swapbuffers...

usw.

<pascal>
procedure TFExample.Render; // wird aus der Methode Paint aufgerufen
resourcestring
RestStrWGLfailed = 'TFExample.Render: wglMakeCurrent failed with ';
begin
// da mehrere fenster möglich sind, muss immer der aktuelle
// ausgabekontext ausgewählt werden
if wglMakeCurrent(FglDC,FglRC) then
begin
glMatrixMode (GL_MODELVIEW);

glClearColor(ClearRed, ClearGreen, ClearBlue, ClearAlpha);
glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);

// View setzen

Camera1.Apply;

// Szene jetzt zeichnen

glFlush; // bearbeitung der GL-befehle beginnen
glFinish; // warten bis alle befehle ausgeführt sind

SwapBuffers(FglDC); // flackern verhindern
end
else
begin
raise Exception.Create(RestStrWGLfailed + IntToStr(GetLastError));
end;
end;
</pascal>

Den Kameracode findet ihr unter [[Kamera (2)]]. 
Die verwendete Toolsammlung findet ihr unter [[Kamera (3)]].

[[Kategorie:Anleitung]]

Kamera

2006-11-12T04:56:35Z

Andyh: Schreibfehler beseitigt

Andyh beschreibt in den Aritikeln:
*[[Kamera (1)]]
*[[Kamera (2)]]
*[[Kamera (3)]]
wie man eine Kamara realisiert.

Andyh:
{{Zitat|
Nachdem ich viel Zeit damit verbracht habe eine funktionierende Kamera
zu bauen und es nun endlich geschafft habe, wollte ich diese Funktionalität
auch anderen zur Verfügung stellen.
Da mir schon viel geholfen wurde, kann ich so einen Teil meiner "Schuld"
zurück zahlen.

Die folgend beschriebene Kamera kann sich um alle drei Achsen drehen und sich
in allen Ebenen bewegen. Der Drehpunkt um den sich die Kamera dreht wird mit
dem Aufruf der Prozedur PositionCamera festgelegt. Sollte man diesen Drehpunkt
benötigen (z.B. zum anzeigen eines Koordinatenkreuzes, ...) so kann man auf
die Property PointOfRotation zugreifen (read only).

Die Kamera kann bis zu zehn Positionen speichern und auch wieder herstellen.
(SavePosition, RestorePosition)

Die Kamera kann sich selber zu jeder Zeit unter Beibehaltung der aktuellen
Position senkrecht zur Welt ausrichten.
(Adjust)

Um sicher zu sein, dass auch alle nötigen Definitionen und Funktionen zur
Verfügung stehen habe ich einfach mal einen Großteil meiner Funktionssammlung
beigefügt (Util.pas). Diese Funktionen/Prozeduren werden so oder in leicht
abgeänderter Form wohl bei jedem OpenGL Programmierer existieren.

...

Nachdem ich bis jetzt glaubte, dass man mit der von mir erstellten Kurzanleitung auskommt, habe ich doch noch ein Beispielprogramm erstellt. Nach mehrmaligem Studium meiner Kurzanleitung bin ich nämlich zu dem Schluss gekommen, dass man mit diesem Programmierbeispiel nicht zu dem von mir beabsichtigten Ergebnis kommen kann. Das Beispielprogramm, welches die Funktionen der Kamera veranschaulicht, wurde mit Delphi 2005 entwickelt. Wenn Ihr über eine ältere Delphiversion verfügt nehmt einfach die DPR Datei oder erstellt ein neues Projekt mit Euerem Compiler und bindet die benötigten Dateien ein.

Ich habe noch einiges mehr an Code reingepackt als unbedingt nötig, um der Sache optisch ein Mindestmaß an Anspruch zu verleihen. Deswegen können aus diesem Beispielprogramm noch die eine oder andere Komponente entnommen werden (wenn nicht schon vorhanden). Dies sind z.B. Komponenten für Licht, Material, zur Textdarstellung, eine Skybox und zur Handhabung von Grafikdateien (die ist allerdings nicht auf meinem Mist gewachsen). Zusätzlich habe ich noch den Memory Manager FastMM4 beigepackt und eingebunden. Mit diesem kann man sehr schön (besser als mit den von Delphi bereitgestellten Möglichkeiten) nicht freigegebene Resourcen aufspüren. Ich war überrascht was ich alles nicht freigegeben hatte, als ich den zum ersten mal eingesetzt habe.

Das Beispielprogramm findet Ihr unter [[http://files.delphigl.com/Download/kamera_heyroth.zip
]].

Aussehen sollte es nach dem Aufruf so:

[[Bild:CameraExample.jpg]]

...

Sollte es noch irgendwelche Fragen zu diesem Modul geben so stehe ich gerne
zur Verfügung (AndyH).}}

[[Kategorie:Technik_oder_Algorithmus]]

Kamera

2006-10-17T03:56:52Z

Andyh: Link zum Beispielprogramm eingefügt

Andyh beschreibt in den Aritikeln:
*[[Kamera (1)]]
*[[Kamera (2)]]
*[[Kamera (3)]]
wie man eine Kamara realisiert.

Andyh:
{{Zitat|
Nachdem ich viel Zeit damit verbracht habe eine funktionierende Kamera
zu bauen und es nun endlich geschafft habe, wollte ich diese Funktionalität
auch anderen zur Verfügung stellen.
Da mir schon viel geholfen wurde, kann ich so einen Teil meiner "Schuld"
zurück zahlen.

Die folgend beschriebene Kamera kann sich um alle drei Achsen drehen und sich
in allen Ebenen bewegen. Der Drehpunkt um den sich die Kamera dreht wird mit
dem Aufruf der Prozedur PositionCamera festgelegt. Sollte man diesen Drehpunkt
benötigen (z.B. zum anzeigen eines Koordinatenkreuzes, ...) so kann man auf
die Property PointOfRotation zugreifen (read only).

Die Kamera kann bis zu zehn Positionen speichern und auch wieder herstellen.
(SavePosition, RestorePosition)

Die Kamera kann sich selber zu jeder Zeit unter Beibehaltung der aktuellen
Position senkrecht zur Welt ausrichten.
(Adjust)

Um sicher zu sein, dass auch alle nötigen Definitionen und Funktionen zur
Verfügung stehen habe ich einfach mal einen Großteil meiner Funktionssammlung
beigefügt (Util.pas). Diese Funktionen/Prozeduren werden so oder in leicht
abgeänderter Form wohl bei jedem OpenGL Programmierer existieren.

...

Nachdem ich bis jetzt glaubte, dass man mit der von mir erstellten Kurzanleitung auskommt, habe ich doch noch ein Beispielprogramm erstellt. Nach mehrmaligem Studium meiner Kurzanleitung bin ich nämlich zu dem Schluss gekommen, dass man mit diesem Programmierbeispiel nicht zu dem von mir beabsichtigten Ergebnis kommen kann. Das Beispielprogramm, welches die Funktionen der Kamera veranschaulicht, wurde mit Delphi 2005 entwickelt. Wenn Ihr über eine ältere Delphiversion verfügt nehmt einfach die DPR Datei oder erstellt ein neues Projekt mit Euerem Compiler und bindet die benötigten Dateien ein.

Ich habe noch einiges mehr an Code reingepackt als unbedint nötig, um der Sache optisch ein Mindestmaß an Anspruch zu verleihen. Deswegen können aus diesem Beispielprogramm noch die eine oder andere Komponente entnommen werden (wenn nicht schon vorhanden). Dies sind z.B. Komponenten für Licht, Material, zur Textdarstellung, eine Skybox und zur Handhabung von Grafikdateien (die ist allerdings nicht auf meinem Mist gewachsen). Zusätzlich habe ich noch den Memory Manager FastMM4 beigepackt und eingebunden. Mit diesem kann man sehr schön (besser als mit den von Delphi bereitgestellten Möglichkeiten) nicht freigegebene Resourcen aufspüren. Ich war überrascht was ich alles nicht freigegeben hatte, als ich den zum ersten mal eingesetzt habe.

Das Beispielprogramm findet Ihr unter [[http://files.delphigl.com/Download/kamera_heyroth.zip
]].

Aussehen sollte es nach dem Aufruf so:

[[Bild:CameraExample.jpg]]

...

Sollte es noch irgendwelche Fragen zu diesem Modul geben so stehe ich gerne
zur Verfügung (AndyH).}}

[[Kategorie:Technik_oder_Algorithmus]]

Kamera

2006-10-12T07:37:08Z

Andyh: Dateinamen OpenGLUtil.pas -> Util.pas

Andyh beschreibt in den Aritikeln:
*[[Kamera (1)]]
*[[Kamera (2)]]
*[[Kamera (3)]]
wie man eine Kamara realisiert.

Andyh:
{{Zitat|
Nachdem ich viel Zeit damit verbracht habe eine funktionierende Kamera
zu bauen und es nun endlich geschafft habe, wollte ich diese Funktionalität
auch anderen zur Verfügung stellen.
Da mir schon viel geholfen wurde, kann ich so einen Teil meiner "Schuld"
zurück zahlen.

Die folgend beschriebene Kamera kann sich um alle drei Achsen drehen und sich
in allen Ebenen bewegen. Der Drehpunkt um den sich die Kamera dreht wird mit
dem Aufruf der Prozedur PositionCamera festgelegt. Sollte man diesen Drehpunkt
benötigen (z.B. zum anzeigen eines Koordinatenkreuzes, ...) so kann man auf
die Property PointOfRotation zugreifen (read only).

Die Kamera kann bis zu zehn Positionen speichern und auch wieder herstellen.
(SavePosition, RestorePosition)

Die Kamera kann sich selber zu jeder Zeit unter Beibehaltung der aktuellen
Position senkrecht zur Welt ausrichten.
(Adjust)

Um sicher zu sein, dass auch alle nötigen Definitionen und Funktionen zur
Verfügung stehen habe ich einfach mal einen Großteil meiner Funktionssammlung
beigefügt (Util.pas). Diese Funktionen/Prozeduren werden so oder in leicht
abgeänderter Form wohl bei jedem OpenGL Programmierer existieren.

...

Nachdem ich bis jetzt glaubte, dass man mit der von mir erstellten Kurzanleitung auskommt, habe ich doch noch ein Beispielprogramm erstellt. Nach mehrmaligem Studium meiner Kurzanleitung bin ich nämlich zu dem Schluss gekommen, dass man mit diesem Programmierbeispiel nicht zu dem von mir beabsichtigten Ergebnis kommen kann. Das Beispielprogramm, welches die Funktionen der Kamera veranschaulicht, wurde mit Delphi 2005 entwickelt. Wenn Ihr über eine ältere Delphiversion verfügt nehmt einfach die DPR Datei oder erstellt ein neues Projekt mit Euerem Compiler und bindet die benötigten Dateien ein.

Ich habe noch einiges mehr an Code reingepackt als unbedint nötig, um der Sache optisch ein Mindestmaß an Anspruch zu verleihen. Deswegen können aus diesem Beispielprogramm noch die eine oder andere Komponente entnommen werden (wenn nicht schon vorhanden). Dies sind z.B. Komponenten für Licht, Material, zur Textdarstellung, eine Skybox und zur Handhabung von Grafikdateien (die ist allerdings nicht auf meinem Mist gewachsen). Zusätzlich habe ich noch den Memory Manager FastMM4 beigepackt und eingebunden. Mit diesem kann man sehr schön (besser als mit den von Delphi bereitgestellten Möglichkeiten) nicht freigegebene Resourcen aufspüren. Ich war überrascht was ich alles nicht freigegeben hatte, als ich den zum ersten mal eingesetzt habe.

Das Beispielprogramm findet Ihr unter [[Kamera (1)]].

Aussehen sollte es nach dem Aufruf so:

[[Bild:CameraExample.jpg]]

...

Sollte es noch irgendwelche Fragen zu diesem Modul geben so stehe ich gerne
zur Verfügung (AndyH).}}

[[Kategorie:Technik_oder_Algorithmus]]

Kamera

2006-10-09T17:02:12Z

Andyh:

Andyh beschreibt in den Aritikeln:
*[[Kamera (1)]]
*[[Kamera (2)]]
*[[Kamera (3)]]
wie man eine Kamara realisiert.

Andyh:
{{Zitat|
Nachdem ich viel Zeit damit verbracht habe eine funktionierende Kamera
zu bauen und es nun endlich geschafft habe, wollte ich diese Funktionalität
auch anderen zur Verfügung stellen.
Da mir schon viel geholfen wurde, kann ich so einen Teil meiner "Schuld"
zurück zahlen.

Die folgend beschriebene Kamera kann sich um alle drei Achsen drehen und sich
in allen Ebenen bewegen. Der Drehpunkt um den sich die Kamera dreht wird mit
dem Aufruf der Prozedur PositionCamera festgelegt. Sollte man diesen Drehpunkt
benötigen (z.B. zum anzeigen eines Koordinatenkreuzes, ...) so kann man auf
die Property PointOfRotation zugreifen (read only).

Die Kamera kann bis zu zehn Positionen speichern und auch wieder herstellen.
(SavePosition, RestorePosition)

Die Kamera kann sich selber zu jeder Zeit unter Beibehaltung der aktuellen
Position senkrecht zur Welt ausrichten.
(Adjust)

Um sicher zu sein, dass auch alle nötigen Definitionen und Funktionen zur
Verfügung stehen habe ich einfach mal einen Großteil meiner Funktionssammlung
beigefügt (OpenGLUtil.pas). Diese Funktionen/Prozeduren werden so oder in leicht
abgeänderter Form wohl bei jedem OpenGL Programmierer existieren.

...

Nachdem ich bis jetzt glaubte, dass man mit der von mir erstellten Kurzanleitung auskommt, habe ich doch noch ein Beispielprogramm erstellt. Nach mehrmaligem Studium meiner Kurzanleitung bin ich nämlich zu dem Schluss gekommen, dass man mit diesem Programmierbeispiel nicht zu dem von mir beabsichtigten Ergebnis kommen kann. Das Beispielprogramm, welches die Funktionen der Kamera veranschaulicht, wurde mit Delphi 2005 entwickelt. Wenn Ihr über eine ältere Delphiversion verfügt nehmt einfach die DPR Datei oder erstellt ein neues Projekt mit Euerem Compiler und bindet die benötigten Dateien ein.

Ich habe noch einiges mehr an Code reingepackt als unbedint nötig, um der Sache optisch ein Mindestmaß an Anspruch zu verleihen. Deswegen können aus diesem Beispielprogramm noch die eine oder andere Komponente entnommen werden (wenn nicht schon vorhanden). Dies sind z.B. Komponenten für Licht, Material, zur Textdarstellung, eine Skybox und zur Handhabung von Grafikdateien (die ist allerdings nicht auf meinem Mist gewachsen). Zusätzlich habe ich noch den Memory Manager FastMM4 beigepackt und eingebunden. Mit diesem kann man sehr schön (besser als mit den von Delphi bereitgestellten Möglichkeiten) nicht freigegebene Resourcen aufspüren. Ich war überrascht was ich alles nicht freigegeben hatte, als ich den zum ersten mal eingesetzt habe.

Das Beispielprogramm findet Ihr unter [[Kamera (1)]].

Aussehen sollte es nach dem Aufruf so:

[[Bild:CameraExample.jpg]]

...

Sollte es noch irgendwelche Fragen zu diesem Modul geben so stehe ich gerne
zur Verfügung (AndyH).}}

[[Kategorie:Technik_oder_Algorithmus]]

Kamera

2006-10-09T16:48:36Z

Andyh: Benutzeradresse eingefügt

Andyh beschreibt in den Aritikeln:
*[[Kamera (1)]]
*[[Kamera (2)]]
*[[Kamera (3)]]
wie man eine Kamara realisiert.

Andyh:
{{Zitat|
Nachdem ich viel Zeit damit verbracht habe eine funktionierende Kamera
zu bauen und es nun endlich geschafft habe, wollte ich diese Funktionalität
auch anderen zur Verfügung stellen.
Da mir schon viel geholfen wurde, kann ich so einen Teil meiner "Schuld"
zurück zahlen.

Die folgend beschriebene Kamera kann sich um alle drei Achsen drehen und sich
in allen Ebenen bewegen. Der Drehpunkt um den sich die Kamera dreht wird mit
dem Aufruf der Prozedur PositionCamera festgelegt. Sollte man diesen Drehpunkt
benötigen (z.B. zum anzeigen eines Koordinatenkreuzes, ...) so kann man auf
die Property PointOfRotation zugreifen (read only).

Die Kamera kann bis zu zehn Positionen speichern und auch wieder herstellen.
(SavePosition, RestorePosition)

Die Kamera kann sich selber zu jeder Zeit unter Beibehaltung der aktuellen
Position senkrecht zur Welt ausrichten.
(Adjust)

Um sicher zu sein, dass auch alle nötigen Definitionen und Funktionen zur
Verfügung stehen habe ich einfach mal einen Großteil meiner Funktionssammlung
beigefügt (OpenGLUtil.pas). Diese Funktionen/Prozeduren werden so oder in leicht
abgeänderter Form wohl bei jedem OpenGL Programmierer existieren.

...

Nachdem ich bis jetzt glaubte, dass man mit der von mir erstellten Kurzanleitung auskommt, habe ich doch noch ein Beispielprogramm erstellt. Nach mehrmaligem Studium meiner Kurzanleitung bin ich nämlich zu dem Schluss gekommen, dass man mit diesem Programmierbeispiel nicht zu dem von mir beabsichtigten Ergebnis kommen kann. Das Beispielprogramm, welches die Funktionen der Kamera veranschaulicht, wurde mit Delphi 2005 entwickelt. Wenn Ihr über eine ältere Delphiversion verfügt nehmt einfach die DPR Datei oder erstellt ein neues Projekt mit Euerem Compiler und bindet die benötigten Dateien ein.

Ich habe noch einiges mehr an Code reingepackt als unbedint nötig, um der Sache optisch ein Mindestmaß an Anspruch zu verleihen. Deswegen können aus diesem Beispielprogramm noch die eine oder andere Komponente entnommen werden (wenn nicht schon vorhanden). Dies sind z.B. Komponenten für Licht, Material, zur Textdarstellung, eine Skybox und zur Handhabung von Grafikdateien (die ist allerdings nicht auf meinem Mist gewachsen). Zusätzlich habe ich noch den Memory Manager FastMM4 beigepackt und eingebunden. Mit diesem kann man sehr schön (besser als mit den von Delphi bereitgestellten Möglichkeiten) nicht freigegebene Resourcen aufspüren. Ich war überrascht was ich alles nicht freigegeben hatte, als ich den zum ersten mal eingesetzt habe.

Das Beispielprogramm findet Ihr unter [[Kamera (1)]].

Aussehen sollte es nach dem Aufruf so:

[[Bild:CameraExample.jpg]]

...

Sollte es noch irgendwelche Fragen zu diesem Modul geben so stehe ich gerne
zur Verfügung ([[Benutzer:AndyH|Andree Heyroth]]).}}

[[Kategorie:Technik_oder_Algorithmus]]

Techniken und Algorithmen

2006-10-07T14:00:45Z

Andyh:

Die Artikel dieses Wiki-Abschnittes sind im Gegensatz zu den [[Tutorial]]s meist kürzer. Dafür enthalten sie mitunter sehr viel Code der direkt verwendet werden, oder als Grundlage für die eigene Arbeit dienen kann.

== Was hier hinein gehört ==
Hier kommen, wie der Name vermuten lässt '''Erklärungen''' zu, in der 3D-Echtzeitprogrammierung verwendeten, '''Techniken''' hin. Z.B. verschiedene Schattentechniken, Bump-Mapping, etc.

[[Hintergrundwissen]] gehört hier nicht rein. Sachen wie ''"was ist ein Tiefenpuffer und wofür ist er gut"'' haben hier nichts zu suchen. 
Sollte es für eine Technik/Thematik (siehe unten für Beispiel) mehrere "Lösungswege" geben, sollte eine kleine Überschrift eingefügt werden.

Wenn ihr einen Technik oder Alorithmus Artikel erstellt, so solltet ihr unter den Artikel ein
<nowiki>[[Kategorie:Technik_oder_Algorithmus]]</nowiki>
stellen. Damit wird der Artikel der [[:Kategorie:Technik_oder_Algorithmus]] zugeordnet.
Falls dieser Artikel nicht nur erklärt was der Begriff bedeutet, sondern auch noch eine Anleitung ist, wie man die entsprechende Technik realisiert, so könnt ihr den Artikel auch noch der Kategorie [[:Kategorie:Anleitung|Anleitung]] zuweisen.

== Übersicht ==
=== Nützliche Helfer ===
In dieser Rubrik findet sich all das, was ein OpenGL/Graphikprogrammierer immer brauch oder schnell mal zur Hand haben muss:
* [[Framecounter]] (Wie schnell läuft mein Programm?)
* [[Texture Loader]] (Laden und verwalten von Texturen)
* [[Model Loader]] (Laden von Modellen die mit Programmen wie 3D Studio Max, Lightwave, Milkshape usw. erstellt wurden.)
* Eine Möglichkeit zum [[Text ausgeben]]
* [[Kamera]]
** [[Kamera (1)]] (Szene in drei Ebenen verschieben und drehen, jetzt mit Beispielprogramm)
** [[Kamera (2)]] (Kamera Source, letztes Update 1.10.2006)
** [[Kamera (3)]] (Für die Kamera benötigte Utilities)
* [[Extensionausgabe]] (Ausgabe der unterstützten Extensions und sonstiger Eigenschaften)

=== Geometrie Objekte ===
In dieser Rubrik findet ihr Code zum erzeugen von komplexen geometrischen Objekten, denn nicht immer ist die Kapselung die z.B. eine [[Quadrik]] bietet das was man sucht.

* [[Kreis]]
* [[Kuchenstück]]
* [[Kugel]]
* [[Scheibe]]
* [[Würfel]]
* [[Zylinder]]

=== Licht und Schatten ===
Das Beleuchtungsmodell von OpenGL besitzt von Haus aus keine Möglichkeit zur Darstellung von Schatten (nicht zuletzt weil es dafür immernoch keine einheitliche Methode gibt), allerdings haben sich über die Jahre hinweg einige Techniken mehr oder weniger durchgesetzt : <ul>
<li>[[Lightmaps]]</li>
<li>[[Projezierte Shadowmaps]] / [[Projezierte Textur]]en</li>
<li>[[Volumetrische Stencilschatten]]{{excIcon}}</li>
<li>[[Silhouette]] {{icpIcon}}</li>
<li>[[Bloom(pseudo-HDR)]] {{icpIcon}}</li></ul>

=== Statische Umgebungen ===
Besonders in Aussenszenen ist es oft nötig dem Betrachter den Eindruck zu vermitteln, er befinde sich in einer unendlich großen Umgebung. Da man dies jedoch schlecht über speziell dafür erstellte Geometrie lösen kann (weil das schlichtweg zu viel Aufwand und zu leistungsintensiv wäre), haben sich einige Techniken eingebürgert, mit denen man dem Betrachter eine solche unendliche Landschaft mit wenig Geometrie und einigen Tricks vorgaugeln kann : <ul>
<li>[[Skyboxen]]</li>
<li>[[Skydome]]</li>
<li>[[Skysphere]]</li>
</ul>

=== Dynamische Effekte ===
Das Auge ißt bekanntlich mit. Auch bei 3D Anwendungen, vor allem in der Unterhaltungsindustrie, spielen gigantische Effekte, die dem User ein "Ohhh" und "Ahhh" und vor allem "Wow!" entlocken eine immer größere Rolle. Wie man solche Effekte am besten implementiert finden Sie in den Artikeln dieses Abschnitts. 
(Befassen Sie sich zuerst mit den Grundlagen von [[Partikelsysteme|Partikelsystemen]].)
<ul>
<li>[[Explosionen]] (Allseits gern gesehen. Außer in direkter Nachbarschaft)</li>
<li>[[Lichtsäulen]] (Bekannt für die magischen Momente in diversen Rollenspielen.) </li>
<li>[[Partikelsysteme]] {{excIcon}} (Grundlage für viele Effekte) </li>
</ul>

=== Natürliche Phänomene ===
Ziel vieler Echtzeit 3D-Anwendung (auch wenn genau der gegenteilige Trend manchmal interessant sein dürfte) ist eine zumindest optische Annäherung an die Realität, also Szenen möglichst "naturgetreu" (auch urbane Szenen können "naturgetreu" sein, auch wenn diese wenig natürlich sind) darzustellen. Dazu gehören auch natürliche Phänomene, wie z.B. realistisch spiegelndes Wasser, Wetterbedingungen (Regen, Schnee, Nebel), Feuer, etc. Oft gibt es für ein natürliches Phänomen recht fortgeschrittene Umsetzungsmöglichkeiten, manchmal liegt die Lösung aber auch recht nahe : <ul>
<li>[[Prozeduale Bäume|Bäume]]</li>
<li>[[Blitz]]</li>
<li>[[Feuer]]</li>
<li>[[Himmel]]</li>
<li>[[Nebel]]</li>
<li>[[Staub]]</li>
<li>[[Wasser]]</li>
<li>[[Wettereffekt]]e (Regen, Schnee)</li>
<li>[[Wolken]] (als Ergänzung zu den statischen Umgebungen)</li>
</ul>

=== Raumunterteilungstechniken ===
Moderne 3D-Anwendungen müssen immer größere und komplexere 3D-Umgebungen darstellen, wobei oft jedoch große Teile eben dieser nicht sichtbar sind, aber ohne entsprechende Optimierungen trotzdem über den Datenbus geschoben (und von der Grafikkarte geclippt) werden müssen. Deshalb finden diverse Raumunterteilungstechniken (die u.a. aus anderen Bereichen stammen) in modernen 3D-Programmen Anwendung : 
<ul>
<li>[[BSP-Bäume]] (Binary Space Partitioning = Binäre Raumunterteilung)</li>
<li>[[Octree]]s (Dreidimensionale Erweiterung eines Quadtrees)</li>
<li>[[Portal]]e (Logische Sichtbegrenzung an Durchgängen)</li>
<li>[[PVS]] (Potentially Visible Sets = Mögliche sichtbare Sets)</li>
</ul>

=== Terrain Darstellung ===
In vielen 3D Anwendungen, vom Flugsimulator über Egoshooter bis zum Strategiespiel, muss die Umgebung visualisiert werden. Welche Techniken bei der Speicherung (siehe auch '''Raumunterteilungstechniken'''), Bildaufbau und Texturierung zum Einsatz kommen, findet ihr hier: 
:'''[[LOD|Level of Detail]] Algorithmen für Landschaften'''

*[[VDPM]] ('''V'''iew-'''D'''ependent '''P'''rogressive '''M'''eshes)
*[[ROAM]] ('''R'''eal-time '''O'''ptimally '''A'''dapting '''M'''eshes)
*[[Tutorial_Terrain3|Röttger Algorithmus]]
*[[Geometrical Mipmapping]]
*[[VIPMs]] ('''V'''iew '''I'''ndependent '''P'''rogressive '''M'''eshe'''s''')

:'''Texturierung'''

*[[Texture Splatting]] (Kombination von Texturen mittels [[Blenden|Blending]] und [[Multitexturing]])
*[[Texture Backing]] (Dynamisches erstellen von Texturen)

=== Prozeduale Grafiken ===
Prozeduale Grafiken werden häufig verwendet um
*eine vielfältige Umgebung zu gewährleisten
*Speicherplatz auf der Festplatte zu sparen
*den Grafikern die Arbeit zu erleichtern (und teilweise sogar erst zu ermöglichen)
Die Algorithmen und Möglichkeiten die sich dabei bieten sind hier aufgelistet: <ul>
<li>[[Perlin Noise]] {{excIcon}} (Algorithmus für Texturen, Landschaft und vieles mehr)</li>
<li>[[L-Systems]] (aus wenig mach viel, Landschaftsgenerierung, Baumgenerierung, ...)</li>
<li>[[Fault Formation]] (primär zur Landschaftsgenerierung)</li>
<li>[[Prozeduale Landschaft]] (Spezielle Hinweise und Techniken zur Landschaftsgenerierung</li>
<li>[[Midpoint Displacement]] (primär zur Landschaftsgenerierung)</li>
<li>[[Hügel_Algorithmen]] (primär zur Landschaftsgenerierung)</li>
<li>[[Prozeduale Bäume]] (Techniken und Algorithmen speziell zur Baumgenerierung)</li>
<li>[[Prozeduale Texturen]] (Spezielle Hinweise zu Wasser, Lava und ähnliches)</li>
</ul>

=== Pathfinding ===
Pathfinding ist einer der grundlegenden Bereiche der Künstlichen Intelligenz, und aus diesem Grund für Spiele mit Computergegnern meistens unumgänglich.
<ul>
<li>[[Tiefensuche]]</li>
<li>[[Breitensuche]]</li>
<li>[[A-Stern]]</li>
<li>[[Dijkstra]]</li>
<li>[[Floyd Warshall]]</li>
<li>[[Navigation Meshes]]</li>
<li>[[Pathfinding-Level of Detail]]</li>
</ul>

=== Sonstiges ===
<ul>
<li>[[Screenshot]]s von OpenGL Ausgaben</li>
<li>[[Interpolation]]</li>
<li>[[Bilder als Ressourcen]] speichern und laden</li>
<li>[[Tesselierung|Polygone tesselieren]] </li>
<li>[[Blenderscript|Exportscript für Blender]]</li>
<li>[[Blenderexporter|Blenderexport ausführliche Anleitung]]</li>
</ul>

== Externe Links ==
Weitere Links zum Thema "Effekte unter OpenGL" findet ihr in der [[Link]]-Sammlung unter [[Link#Effekte_und_Techniken_mit_OpenGL|Effekte und Techniken mit OpenGL]].

Kamera

2006-10-07T07:27:54Z

Andyh:

Andyh beschreibt in den Aritikeln:
*[[Kamera (1)]]
*[[Kamera (2)]]
*[[Kamera (3)]]
wie man eine Kamara realisiert.

Andyh:
{{Zitat|
Nachdem ich viel Zeit damit verbracht habe eine funktionierende Kamera
zu bauen und es nun endlich geschafft habe, wollte ich diese Funktionalität
auch anderen zur Verfügung stellen.
Da mir schon viel geholfen wurde, kann ich so einen Teil meiner "Schuld"
zurück zahlen.

Die folgend beschriebene Kamera kann sich um alle drei Achsen drehen und sich
in allen Ebenen bewegen. Der Drehpunkt um den sich die Kamera dreht wird mit
dem Aufruf der Prozedur PositionCamera festgelegt. Sollte man diesen Drehpunkt
benötigen (z.B. zum anzeigen eines Koordinatenkreuzes, ...) so kann man auf
die Property PointOfRotation zugreifen (read only).

Die Kamera kann bis zu zehn Positionen speichern und auch wieder herstellen.
(SavePosition, RestorePosition)

Die Kamera kann sich selber zu jeder Zeit unter Beibehaltung der aktuellen
Position senkrecht zur Welt ausrichten.
(Adjust)

Um sicher zu sein, dass auch alle nötigen Definitionen und Funktionen zur
Verfügung stehen habe ich einfach mal einen Großteil meiner Funktionssammlung
beigefügt (OpenGLUtil.pas). Diese Funktionen/Prozeduren werden so oder in leicht
abgeänderter Form wohl bei jedem OpenGL Programmierer existieren.

...

Nachdem ich bis jetzt glaubte, dass man mit der von mir erstellten Kurzanleitung auskommt, habe ich doch noch ein Beispielprogramm erstellt. Nach mehrmaligem Studium meiner Kurzanleitung bin ich nämlich zu dem Schluss gekommen, dass man mit diesem Programmierbeispiel nicht zu dem von mir beabsichtigten Ergebnis kommen kann. Das Beispielprogramm, welches die Funktionen der Kamera veranschaulicht, wurde mit Delphi 2005 entwickelt. Wenn Ihr über eine ältere Delphiversion verfügt nehmt einfach die DPR Datei oder erstellt ein neues Projekt mit Euerem Compiler und bindet die benötigten Dateien ein.

Ich habe noch einiges mehr an Code reingepackt als unbedint nötig, um der Sache optisch ein Mindestmaß an Anspruch zu verleihen. Deswegen können aus diesem Beispielprogramm noch die eine oder andere Komponente entnommen werden (wenn nicht schon vorhanden). Dies sind z.B. Komponenten für Licht, Material, zur Textdarstellung, eine Skybox und zur Handhabung von Grafikdateien (die ist allerdings nicht auf meinem Mist gewachsen). Zusätzlich habe ich noch den Memory Manager FastMM4 beigepackt und eingebunden. Mit diesem kann man sehr schön (besser als mit den von Delphi bereitgestellten Möglichkeiten) nicht freigegebene Resourcen aufspüren. Ich war überrascht was ich alles nicht freigegeben hatte, als ich den zum ersten mal eingesetzt habe.

Das Beispielprogramm findet Ihr unter [[Kamera (1)]].

Aussehen sollte es nach dem Aufruf so:

[[Bild:CameraExample.jpg]]

...

Sollte es noch irgendwelche Fragen zu diesem Modul geben so stehe ich gerne
zur Verfügung (Andyh).}}

[[Kategorie:Technik_oder_Algorithmus]]

Kamera

2006-10-07T05:34:45Z

Andyh:

Andyh beschreibt in den Aritikeln:
*[[Kamera (1)]]
*[[Kamera (2)]]
*[[Kamera (3)]]
wie man eine Kamara realisiert.

Andyh:
{{Zitat|
Nachdem ich viel Zeit damit verbracht habe eine funktionierende Kamera
zu bauen und es nun endlich geschafft habe, wollte ich diese Funktionalität
auch anderen zur Verfügung stellen.
Da mir schon viel geholfen wurde, kann ich so einen Teil meiner "Schuld"
zurück zahlen.

Die folgend beschriebene Kamera kann sich um alle drei Achsen drehen und sich
in allen Ebenen bewegen. Der Drehpunkt um den sich die Kamera dreht wird mit
dem Aufruf der Prozedur PositionCamera festgelegt. Sollte man diesen Drehpunkt
benötigen (z.B. zum anzeigen eines Koordinatenkreuzes, ...) so kann man auf
die Property PointOfRotation zugreifen (read only).

Die Kamera kann bis zu zehn Positionen speichern und auch wieder herstellen.
(SavePosition, RestorePosition)

Die Kamera kann sich selber zu jeder Zeit unter Beibehaltung der aktuellen
Position senkrecht zur Welt ausrichten.
(Adjust)

Um sicher zu sein, dass auch alle nötigen Definitionen und Funktionen zur
Verfügung stehen habe ich einfach mal einen Großteil meiner Funktionssammlung
beigefügt (OpenGLUtil.pas). Diese Funktionen/Prozeduren werden so oder in leicht
abgeänderter Form wohl bei jedem OpenGL Programmierer existieren.

...

Nachdem ich bis jetzt glaubte, dass man mit der von mir erstellten Krzanleitung auskommt, hab eich doch noch ein Beispielprogramm erstellt. Nach mehrmaligem Studium meiner Kurzanleitung bin ich nämlich zu dem Schluss gekommen, dass man mit diesem Programmierbeispiel nicht zu dem von mir beabsichtigten Ergebnis kommen kann. Das Beispielprogramm, welches die Funktionen der Kamera veranschaulicht, wurde mit Delphi 2005 entwickelt. Wenn Ihr über eine ältere Delphiversion verfügt, nehmet einfach die DPR Datei oder erstellt ein neues Projekt mit Euerem Compiler und bindet die benötigten Dateien ein.

Ich habe noch einiges mehr an Code reingepackt als unbedint nötig, um der Sache optisch ein Mindestmaß an Anspruch zu verleihen. Deswegen können aus diesem Beispielprogramm noch die eine oder andere Komponente entnommen werden (wenn nicht schon vorhanden). Dies sind z.B. Komponenten für Licht, Material, eine Skybox und zur Handhabung von Grafikdateien (die ist allerdings nicht auf meinem Mist gewachsen). Zusätlich habe ich noch den memory Manager FastMM4 beigepackt und eingebunden. Mit diesem kann man sehr schön (besser als mit den von Delphi bereitgestellten Möglichkeiten) nicht freigegebene Resourcen aufspüren. Ich war überrascht was ich alles nicht freigegeben hatte, als ich den zume rsten mal eingesetzt habe.

Das Beispielprogramm findet Ihr unter [[Kamera (1)]].

Aussehen sollte es nach dem Aufruf so:

[[Bild:CameraExample.jpg]]

...

Sollte es noch irgendwelche Fragen zu diesem Modul geben so stehe ich gerne
zur Verfügung (Andyh).}}

[[Kategorie:Technik_oder_Algorithmus]]

Datei:CameraExample.jpg

2006-10-07T05:31:23Z

Andyh: Screenshot des Beispielprogramms

Screenshot des Beispielprogramms

Kamera

2006-10-07T05:26:09Z

Andyh:

Andyh beschreibt in den Aritikeln:
*[[Kamera (1)]]
*[[Kamera (2)]]
*[[Kamera (3)]]
wie man eine Kamara realisiert.

Andyh:
{{Zitat|
Nachdem ich viel Zeit damit verbracht habe eine funktionierende Kamera
zu bauen und es nun endlich geschafft habe, wollte ich diese Funktionalität
auch anderen zur Verfügung stellen.
Da mir schon viel geholfen wurde, kann ich so einen Teil meiner "Schuld"
zurück zahlen.

Die folgend beschriebene Kamera kann sich um alle drei Achsen drehen und sich
in allen Ebenen bewegen. Der Drehpunkt um den sich die Kamera dreht wird mit
dem Aufruf der Prozedur PositionCamera festgelegt. Sollte man diesen Drehpunkt
benötigen (z.B. zum anzeigen eines Koordinatenkreuzes, ...) so kann man auf
die Property PointOfRotation zugreifen (read only).

Die Kamera kann bis zu zehn Positionen speichern und auch wieder herstellen.
(SavePosition, RestorePosition)

Die Kamera kann sich selber zu jeder Zeit unter Beibehaltung der aktuellen
Position senkrecht zur Welt ausrichten.
(Adjust)

Um sicher zu sein, dass auch alle nötigen Definitionen und Funktionen zur
Verfügung stehen habe ich einfach mal einen Großteil meiner Funktionssammlung
beigefügt (OpenGLUtil.pas). Diese Funktionen/Prozeduren werden so oder in leicht
abgeänderter Form wohl bei jedem OpenGL Programmierer existieren.

...

Nachdem ich bis jetzt glaubte, dass man mit der von mir erstellten Krzanleitung auskommt, hab eich doch noch ein Beispielprogramm erstellt. Nach mehrmaligem Studium meiner Kurzanleitung bin ich nämlich zu dem Schluss gekommen, dass man mit diesem Programmierbeispiel nicht zu dem von mir beabsichtigten Ergebnis kommen kann. Das Beispielprogramm, welches die Funktionen der Kamera veranschaulicht, wurde mit Delphi 2005 entwickelt. Wenn Ihr über eine ältere Delphiversion verfügt, nehmet einfach die DPR Datei oder erstellt ein neues Projekt mit Euerem Compiler und bindet die benötigten Dateien ein.

Ich habe noch einiges mehr an Code reingepackt als unbedint nötig, um der Sache optisch ein Mindestmaß an Anspruch zu verleihen. Deswegen können aus diesem Beispielprogramm noch die eine oder andere Komponente entnommen werden (wenn nicht schon vorhanden). Dies sind z.B. Komponenten für Licht, Material, eine Skybox und zur Handhabung von Grafikdateien (die ist allerdings nicht auf meinem Mist gewachsen). Zusätlich habe ich noch den memory Manager FastMM4 beigepackt und eingebunden. Mit diesem kann man sehr schön (besser als mit den von Delphi bereitgestellten Möglichkeiten) nicht freigegebene Resourcen aufspüren. Ich war überrascht was ich alles nicht freigegeben hatte, als ich den zume rsten mal eingesetzt habe.

Das Beispielprogramm findet Ihr unter [[Kamera (1)]].

...

Sollte es noch irgendwelche Fragen zu diesem Modul geben so stehe ich gerne
zur Verfügung (Andyh).}}

[[Kategorie:Technik_oder_Algorithmus]]

Kamera (3)

2006-10-07T05:18:50Z

Andyh:

Eine Beschreibung findet ihr unter [[Kamera (1)]]. 
Den Kameracode findet ihr unter [[Kamera (2)]].

Ich habe einfach alle Funktionen meiner Toolsammlung hierhin kopiert. Ich wollte jetzt nicht offline etwas weglöschen was vielleicht benötigt wird. Ihr findet also hier einen ganzen Wust von Funktionen, der zum Betrieb der Kamera nicht benötigt wird. Vielleicht könnt Ihr das eine oder andere aber brauchen...

<pascal>
unit Util;

interface

uses DglOpenGL, Math, Windows, Graphics, SysUtils, Dialogs{, glBmp};

type
TProjection=(Frustum, Orthographic, Perspective);

TGLPlace=packed record
X,Y,Z: GLdouble;
end;

TScale=packed record
X,Y,Z: GLdouble;
end;

TGLPosition=packed record
X,Y,Z,W: GLdouble;
end;

TPosition = packed record
X,Y,Z,W: GLdouble;
end;

TGLVector = packed record
X,Y,Z: GLdouble;
end;
TPGLvector=^TGLvector;

TTextureCoord=record
X, Y, Z: GLdouble;
end;

TTextureCoordArray = array of TTextureCoord;
TGLvectorArray = array of TGLvector;
TGLdoubleArray = array of GLdouble;
TGLfloatArray = array of GLfloat;

TGKVector = packed record
X,Y,Z: GLdouble;
end;

TAngle = packed record
X,Y,Z: GLdouble;
end;

TGLColor=record
red,green,blue,alpha: GLclampf;
end;

TRotation = packed record
angle, x, y, z: GLdouble;
end;

TTextureInfo = packed record
BitmapName: string;
TextureNum: GLUint;
//theBmp: TGLbmp;
end;
TTextureList = array of TTextureInfo;

TMatrix = array [0..3,0..3] of GLdouble;
TArrMatrix = array [0..15] of GLdouble;
TFrustum = array [0..5,0..3] of GLdouble;
TArrVector = array [0..3] of GLdouble;

function GetMatrixX (matrix: TArrMatrix): TGLvector;
function GetMatrixY (matrix: TArrMatrix): TGLvector;
function GetMatrixZ (matrix: TArrMatrix): TGLvector;
function GetMatrixPos (matrix: TArrMatrix): TGLvector;
procedure SetMatrixX (var matrix: TArrMatrix; v: TGLvector);
procedure SetMatrixY (var matrix: TArrMatrix; v: TGLvector);
procedure SetMatrixZ (var matrix: TArrMatrix; v: TGLvector);
procedure SetMatrixPos (var matrix: TArrMatrix; v: TGLvector);
function Multiply (Color: TGLcolor; m: GLdouble): TGLcolor;overload;
function Multiply (V1, V2: TGLVector): TGLVector;overload;
function Multiply (M1, M2: TArrMatrix): TArrMatrix;overload;
function Divide (V1, V2: TGLVector): TGLVector;overload;
function Divide (V1: TGLVector; d: GLdouble): TGLVector;overload;
function MakeVector(X,Y,Z:GLdouble):TArrVector;overload;
function MakeVector(X,Y,Z,W:GLdouble):TArrVector;overload;
function Normalize(aVector:TArrVector):TArrVector;overload;
function Normalize(aVector:TGLVector):TGLVector;overload;
function GetIdentity(Matrix:TMatrix):TMatrix;overload;
function GetIdentity(Matrix:TArrMatrix):TArrMatrix;overload;
function MatrixTranspose(const M:TMatrix):TMatrix;register;
function NearestPoint(Axis, Point: TGLVector): TGLVector;
function VectorRotateX(v:TArrVector;a:GLdouble):TArrVector;overload;
function VectorRotateY(v:TArrVector;a:GLdouble):TArrVector;overload;
function VectorRotateZ(v:TArrVector;a:GLdouble):TArrVector;overload;
function VectorRotateX(v:TGLVector;a:GLdouble):TGLVector;overload;
function VectorRotateY(v:TGLVector;a:GLdouble):TGLVector;overload;
function VectorRotateZ(v:TGLVector;a:GLdouble):TGLVector;overload;
function VectorRotateX(v,c:TGLvector;a:GLdouble):TGLVector;overload;
function VectorRotateY(v,c:TGLvector;a:GLdouble):TGLVector;overload;
function VectorRotateZ(v,c:TGLvector;a:GLdouble):TGLVector;overload;
function VectorRotateX(v1,v2,v3,v4:TGLVector;a:GLdouble):TGLVector;overload;
function VectorRotateY(v1,v2,v3,v4:TGLVector;a:GLdouble):TGLVector;overload;
function VectorRotateZ(v1,v2,v3,v4:TGLVector;a:GLdouble):TGLVector;overload;

function AxisXRotation (V1, V2: TGLvector): GLdouble;
function AxisYRotation (V1, V2: TGLvector): GLdouble;
function AxisZRotation (V1, V2: TGLvector): GLdouble;

function GL2GKVector (V: TGLVector): TGKVector;
function GK2GLVector (V: TGKVector): TGLVector;
function GL2WinColor (GLcol: TGLcolor): TColor;
function Win2GLColor (WinCol: Tcolor): TGLcolor;
function CalcNormale (V1, V2, V3: TGLVector): TGLVector;
function CrossProduct(V1, V2: TGLVector): TGLVector;
function DotProduct (V1, V2: TGLVector): GLdouble;
function LoadTexture(Filename: String; var Texture: GLuint): Boolean;
function Magnitude(V1: TGLVector): GLdouble;overload;
function Magnitude(X, Y: GLdouble): GLdouble;overload;
function ScalarProduct (V1, V2: TGLVector): GLdouble;
function MinVector (V1, V2: TGLvector): TGLvector;
function MaxVector (V1, V2: TGLvector): TGLvector;
function SubtractVector (Vec1, Vec2: TGLVector): TGLVector;overload;
function SubtractVector (Vec: TGLVector; X, Y, Z: GLdouble): TGLVector;overload;
function AddVector (Vec1, Vec2: TGLVector): TGLVector;overload;
function AddVector (Vec: TGLVector; X, Y, Z: GLdouble): TGLVector;overload;
function ForceForegroundWindow(hwnd: THandle): Boolean;
function ValidTexture (tex: GLUint; ErrStr: string): boolean;
procedure ResetGLErrorFlags;
procedure InitGLEnv (dc: HDC; rc: HGLRC; hndl: THandle);// pixelformat setzen
procedure CopyVector (FromVektor: TGLVector; var ToVektor: TGLVector);
procedure InitVector (var V1: TGLVector; x, y, z: GLdouble);overload;
procedure InitVector (var V1: TGKVector; x, y, z: GLdouble);overload;
procedure InitVector (var V1: TArrVector; x, y, z: GLdouble);overload;
procedure InitScale (var S1: TScale; x, y, z: GLdouble);
procedure LoadBitmap(Filename: String;
out Width: Cardinal;
out Height: Cardinal;
out pData: Pointer);
procedure GetRotation (V1, V2: TGLVector;
var Rotation: TRotation);
function MakeTextureFromBitmap (Bitmap: string;
var BitmapList: TTextureList): GLenum;
procedure EnableTexture (Texture: GLenum; TextureTiled: boolean);
procedure DisableTexture;
function TextToGLVector (VTxt: string): TGLVector;
function TextToGKVector (VTxt: string): TGKVector;
function GKVectorToText (V1: TGKVector): string;overload;
function GKVectorToText (V1: TGKVector; digits, decimals: byte): string;overload;
function GLVectorToText (V1: TGLVector): string;overload;
function GLVectorToText (V1: TGLVector; digits, decimals: byte): string;overload;
function MatrixToText (M: TArrMatrix): string;
function CheckFormat (number: string; digits, decimals: byte): string;
function MyCone (Start, Ende: TGLVector;
RadiusStart, RadiusEnde: GLdouble;
Slices: integer; TileX, TileY: GLdouble): boolean;
function InvertMatrix (src: TArrMatrix; var inverse: TArrMatrix): boolean;
function ExePath: string;

const
C_X = 0;
C_Y = 1;
C_Z = 2;
C_W = 3;
C_EPS:GLdouble=0.01;
C_DEGTORAD:GLdouble=3.1412/180;
C_RADTODEG:GLdouble=180/3.1412;
C_LAMBDA_INCREMENT:GLdouble=0.01;
C_PI=3.1415926535;
C_PI_DIV_180=C_PI/180;

HORIZONTAL: byte = 1;
VERTIKAL: byte = 2;
ZENTRAL: byte = 3;

implementation

uses Forms, {KanalUtil,} OGLinclude, Controls;

function MyPower (Base: extended; Exp: integer): extended;
//var
// i: integer;
begin
// result := Base;
// for i := 2 to Exp do
// result := result * Base;

result := Base * Base;
end;

procedure CopyVector (FromVektor: TGLVector; var ToVektor: TGLVector);
begin
ToVektor.X := FromVektor.X;
ToVektor.Y := FromVektor.Y;
ToVektor.Z := FromVektor.Z;
end;

function GetMatrixX (matrix: TArrMatrix): TGLvector;
// holt den X-vektor aus matrix und gibt ihn zurück
begin
result.X := matrix[00];
result.Y := matrix[01];
result.Z := matrix[02];
end;

function GetMatrixY (matrix: TArrMatrix): TGLvector;
// holt den Y-vektor aus matrix und gibt ihn zurück
begin
result.X := matrix[04];
result.Y := matrix[05];
result.Z := matrix[06];
end;

function GetMatrixZ (matrix: TArrMatrix): TGLvector;
// holt den Z-vektor aus matrix und gibt ihn zurück
begin
result.X := matrix[08];
result.Y := matrix[09];
result.Z := matrix[10];
end;

function GetMatrixPos (matrix: TArrMatrix): TGLvector;
// holt den Position-vektor aus matrix und gibt ihn zurück
begin
result.X := matrix[12];
result.Y := matrix[13];
result.Z := matrix[14];
end;

procedure SetMatrixX (var matrix: TArrMatrix; v: TGLvector);
// setzt den durch v bestimmten X-vektor in matrix
begin
matrix[00] := v.X;
matrix[01] := v.Y;
matrix[02] := v.Z;
end;

procedure SetMatrixY (var matrix: TArrMatrix; v: TGLvector);
// setzt den durch v bestimmten Y-vektor in matrix
begin
matrix[04] := v.X;
matrix[05] := v.Y;
matrix[06] := v.Z;
end;

procedure SetMatrixZ (var matrix: TArrMatrix; v: TGLvector);
// setzt den durch v bestimmten Z-vektor in matrix
begin
matrix[08] := v.X;
matrix[09] := v.Y;
matrix[10] := v.Z;
end;

procedure SetMatrixPos (var matrix: TArrMatrix; v: TGLvector);
// setzt den durch v bestimmten Position-vektor in matrix
begin
matrix[12] := v.X;
matrix[13] := v.Y;
matrix[14] := v.Z;
end;

function MinVector (V1, V2: TGLvector): TGLvector;
// gibt den Vector mit der geringeren Länge zurück
begin
result := V1;
if Magnitude (V1) > Magnitude (V2) then
result := V2;
end;

function MaxVector (V1, V2: TGLvector): TGLvector;
// gibt den Vector mit der größeren Länge zurück
begin
result := V1;
if Magnitude (V1) < Magnitude (V2) then
result := V2;
end;

function SubtractVector (Vec1, Vec2: TGLVector): TGLVector;
// subtrahiert Vec2 von vec1 und gibt das ergebnis in vec3 zurück
var
Vec3: TGLVector;
begin
Vec3 .X := Vec1.X - Vec2.X;
Vec3 .Y := Vec1.Y - Vec2.Y;
Vec3 .Z := Vec1.Z - Vec2.Z;
result := Vec3;
end;

function SubtractVector (Vec: TGLVector; X, Y, Z: GLdouble): TGLVector;
// subtrahiert X, Y, Z von vec.x, vec.y, vec.z und gibt das
// ergebnis zurück
begin
Vec .X := Vec.X - X;
Vec .Y := Vec.Y - Y;
Vec .Z := Vec.Z - Z;
result := Vec;
end;

function AddVector (Vec1, Vec2: TGLVector): TGLVector;
// addiert Vec2 auf vec1 und gibt das ergebnis in vec3 zurück
var
Vec3: TGLVector;
begin
Vec3 .X := Vec1.X + Vec2.X;
Vec3 .Y := Vec1.Y + Vec2.Y;
Vec3 .Z := Vec1.Z + Vec2.Z;
result := Vec3;
end;

function AddVector (Vec: TGLVector; X, Y, Z: GLdouble): TGLVector;
// addiert X, Y, Z auf vec.x, vec.y, vec.z und gibt das
// ergebnis zurück
begin
Vec .X := Vec.X + X;
Vec .Y := Vec.Y + Y;
Vec .Z := Vec.Z + Z;
result := Vec;
end;

function Magnitude(V1: TGLVector): GLdouble;
var
Ergebnis: GLdouble;
begin
// gibt die länge des vektors im dreidimensionalen raum zurück
Ergebnis := MyPower(V1.X,2)+MyPower(V1.Y,2)+MyPower(V1.Z,2);
try
result := sqrt(Ergebnis);
except
result := 0;
end;
end;

function Magnitude(X, Y: GLdouble): GLdouble;
var
Ergebnis: GLdouble;
begin
// gibt die länge des vektors im zweidimensionalen raum zurück
Ergebnis := MyPower(X,2)+MyPower(Y,2);
try
result := sqrt(Ergebnis);
except
result := 0;
end;
end;

function DotProduct (V1, V2: TGLVector): GLdouble;
// errechnet den winkel zwischen zwei vektoren
var
len1, len2: GLdouble;
Ergebnis: GLdouble;
begin
//len1 := MyPower(V1.X,2)+MyPower(V1.Y,2)+MyPower(V1.Z,2);
//len2 := MyPower(V2.X,2)+MyPower(V2.Y,2)+MyPower(V2.Z,2);
len1 := Magnitude (V1);
len2 := Magnitude (V2);
Ergebnis := ScalarProduct (V1, V2);
Ergebnis := arccos (Ergebnis / (len1 * len2));
result := radtodeg (Ergebnis) * 2.0;
end;

function CrossProduct(V1, V2: TGLVector): TGLVector;
var
CrossVec: TGLVector;
begin
//CrossVec.X := +((V1.Y*V2.Z) - (V1.Z*V2.Y));
//CrossVec.Y := -((V1.X*V2.Z) - (V1.Z*V2.X));
//CrossVec.Z := +((V1.X*V2.Y) - (V1.Y*V2.X));
CrossVec.X := ((V1.Y*V2.Z) - (V1.Z*V2.Y));
CrossVec.Y := ((V1.Z*V2.X) - (V1.X*V2.Z));
CrossVec.Z := ((V1.X*V2.Y) - (V1.Y*V2.X));
result := CrossVec;
end;

function CalcNormale (V1, V2, V3: TGLVector): TGLVector;
var
Kreuz: TGLvector;
V1V2, V1V3: TGLvector;
begin
// zum testen:
InitVector (result, 0, 0, 0);
// gibt die normale von 3 vektoren zurück (die senkrechte auf die
// durch die drei vektoren gebildete ebene)
V1V2 := SubtractVector (V2, V1);
V1V3 := SubtractVector (V3, V1);

Kreuz := CrossProduct (V1V2, V1V3);

result := Normalize (Kreuz);
end;

procedure InitVector (var V1: TGLVector; x, y, z: GLdouble);
begin
V1.x := x;
V1.y := y;
V1.z := z;
end;

procedure InitVector (var V1: TGKVector; x, y, z: GLdouble);
begin
V1.x := x;
V1.y := y;
V1.z := z;
end;

procedure InitVector (var V1: TArrVector; x, y, z: GLdouble);
begin
V1[C_X] := x;
V1[C_Y] := y;
V1[C_Z] := z;
end;

procedure InitScale (var S1: TScale; x, y, z: GLdouble);
begin
S1.x := x;
S1.y := y;
S1.z := z;
end;

function Multiply (V1, V2: TGLVector): TGLVector;
var
ret: TGLVector;
begin
// zwei vektoren miteinander multiplizieren
ret.X := V1.X * V2.X;
ret.Y := V1.Y * V2.Y;
ret.Z := V1.Z * V2.Z;
result := ret;
end;

function Divide (V1, V2: TGLVector): TGLVector;
var
ret: TGLVector;
begin
// zwei vektoren miteinander multiplizieren
ret.X := V1.X / V2.X;
ret.Y := V1.Y / V2.Y;
ret.Z := V1.Z / V2.Z;
result := ret;
end;

function ScalarProduct (V1, V2: TGLVector): GLdouble;
begin
// die summe der potenzen der einzelnen achsen von zwei vektoren errechnen
result := (V1.X*V2.X +
V1.Y*V2.Y +
V1.Z*V2.Z);
end;

function LoadTexture(Filename: String; var Texture: GLuint): Boolean;
resourcestring
Res_LoadUnable = 'Unable to load ';
Res_LoadingTex = 'Loading Textures';
var
pData: Pointer;
Width: Cardinal;
Height: Cardinal;
newTexture: GLint;
begin
pData :=nil;
LoadBitmap(Filename, Width, Height, pData);

if (Assigned(pData)) then
Result := True
else
begin
Result := False;
MessageBox(0, PChar(Res_LoadUnable + filename),
pchar (Res_LoadingTex), MB_OK);
exit;
end;

glGenTextures(1, @NewTexture);
glBindTexture(GL_TEXTURE_2D, NewTexture);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); {Texture blends with object background}

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); { only first two can be used }
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); { all of the above can be used }

gluBuild2DMipmaps(GL_TEXTURE_2D, 3, Width, Height, GL_RGB, GL_UNSIGNED_BYTE, pData);

Texture := newTexture;
end;

procedure LoadBitmap(Filename: String;
out Width: Cardinal;
out Height: Cardinal;
out pData: Pointer);
resourcestring
Res_ReadErr = 'Error reading palette';
Res_OpenErr = 'Error opening: ';
Res_BitmapDataErr = 'Error reading bitmap data';
Res_BmpUnit = 'BMP Unit';
var
FileHeader: BITMAPFILEHEADER;
InfoHeader: BITMAPINFOHEADER;
Palette: array of RGBQUAD;
BitmapFile: THandle;
BitmapLength: Cardinal;
PaletteLength: Cardinal;
ReadBytes: Cardinal;
Front: ^Byte;
Back: ^Byte;
Temp: Byte;
I : Cardinal;
begin
BitmapFile := CreateFile(PChar(Filename), GENERIC_READ, FILE_SHARE_READ, nil, OPEN_EXISTING, 0, 0);
if (BitmapFile = INVALID_HANDLE_VALUE) then begin
MessageBox(0, PChar(Res_OpenErr+Filename), PChar(Res_BmpUnit), MB_OK);
Exit;
end;

// Get header information
ReadFile(BitmapFile, FileHeader, SizeOf(FileHeader), ReadBytes, nil);
ReadFile(BitmapFile, InfoHeader, SizeOf(InfoHeader), ReadBytes, nil);

// Get palette
PaletteLength := InfoHeader.biClrUsed;
SetLength(Palette, PaletteLength);
ReadFile(BitmapFile, Palette, PaletteLength, ReadBytes, nil);
if (ReadBytes <> PaletteLength) then begin
MessageBox(0, PChar(Res_ReadErr), PChar(Res_BmpUnit), MB_OK);
CloseHandle(BitmapFile);
Exit;
end;

Width := InfoHeader.biWidth;
Height := InfoHeader.biHeight;
BitmapLength := InfoHeader.biSizeImage;
if BitmapLength = 0 then
BitmapLength := Width * Height * InfoHeader.biBitCount Div 8;

// Get the actual pixel data
GetMem(pData, BitmapLength);
ReadFile(BitmapFile, pData^, BitmapLength, ReadBytes, nil);
if (ReadBytes <> BitmapLength) then begin
MessageBox(0, PChar(Res_BitmapDataErr), PChar(Res_BmpUnit), MB_OK);
CloseHandle(BitmapFile);
Exit;
end;
CloseHandle(BitmapFile);

// Bitmaps are stored BGR and not RGB, so swap the R and B bytes.
for I :=0 to Width * Height - 1 do
begin
Front := Pointer(Cardinal(pData) + I*3);
Back := Pointer(Cardinal(pData) + I*3 + 2);
Temp := Front^;
Front^ := Back^;
Back^ := Temp;
end;
end;

function GK2GLVector (V: TGKVector): TGLVector;
// ändert Gauss-Krüger Koordinaten in OpenGL Koordinaten um
begin
result.X := V.X;
result.Y := V.Z;
result.Z := V.Y;
end;

function GL2GKVector (V: TGLVector): TGKVector;
// ändert OpenGL Koordinaten in Gauss-Krüger Koordinaten um
begin
result.X := V.X;
result.Y := V.Z;
result.Z := V.Y;
end;

function Win2GLColor (WinCol: TColor): TGLcolor;
begin
result.Red := GetRValue (WinCol) / 255;
result.Green := GetGValue (WinCol) / 255;
result.Blue := GetBValue (WinCol) / 255;
result.Alpha := 0.0;
end;

function GL2WinColor (GLcol: TGLcolor): TColor;
begin
result := Rgb (StrToInt (FloatToStr (int (GLcol.Red * 255))),
StrToInt (FloatToStr (int (GLcol.Green * 255))),
StrToInt (FloatToStr (int (GLcol.Blue * 255))));
end;

procedure GetRotation (V1, V2: TGLVector;
var Rotation: TRotation);
var
tmpCyl, tmpZiel, nullVec: TGLVector;
normale, ResultLen: TGLVector;
VectorLength: GLdouble;
begin
// temporäre vektoren initialisieren
InitVector (nullVec, 0,0,0);
InitVector (tmpCyl, 0,0,0);

// länge des zu drehenden objekts ermitteln
ResultLen := SubtractVector (V2, V1);
VectorLength := Magnitude (ResultLen);

// vektoren zur bildung der dreiecksfläche bilden.
// die schenkel schneiden sich im nullpunkt
// der Cylinder läuft immer entlang der Z-Achse
tmpCyl.Z := VectorLength;
tmpZiel := SubtractVector (V2, V1);
tmpZiel.Z := tmpZiel.Z + VectorLength;

// senkrechte zu den beiden vektoren bilden
// (um diese achse soll nachher gedreht werden)
// drehachse für späteren gebrauch speichern
normale := CalcNormale (tmpCyl, tmpZiel, nullVec);

// um "Angle" Grad soll nachher gedreht werden
Rotation.Angle := DotProduct(tmpCyl, tmpZiel);
Rotation.X := normale.X;
Rotation.Y := normale.Y;
Rotation.Z := normale.Z;
end;

function MakeTextureFromBitmap (Bitmap: string;
var BitmapList: TTextureList): GLenum;
// die funktion lädt die in Bitmap übergebene Grafik und gibt die Textturnummer
// zurück. ist das bitmap schon im array BitmapList enthalten, wird die bereits
// vergeben nummer zurückgegeben.
resourcestring
Res_TextureNotFound = 'Texturdatei nicht gefunden: ';
Res_Error = 'Error';
var
i, Laenge: integer;
begin
result := 0;
if length (trim (Bitmap)) = 0 then
exit;

BitMap := uppercase (BitMap); // wegen dem folgenden vergleich

// suchen, ob die textur schon geladen wurde
Laenge := length (BitmapList);
if Laenge > 0 then
for i := low (BitMapList) to high (BitMapList) do
begin
if (BitmapList[i].BitmapName = Bitmap) and
//(glIsTexture (BitmapList[i].TextureNum)) then
(BitmapList[i].TextureNum > 0) then
result := BitmapList[i].TextureNum;
end;

if result = 0 then
begin
if not fileexists (Bitmap) then
begin
MessageBox (0, PChar (Res_TextureNotFound+Bitmap),
pchar (Res_Error), MB_OK or MB_ICONERROR);
exit;
end;
end;

if (result = 0) then
begin
setlength (BitmapList, Laenge+1);
BitmapList[Laenge].BitmapName := Bitmap;
BitmapList[Laenge].TextureNum := 0;
{
BitMapList[Laenge].theBmp := TglBmp.Create;
if BitMapList[Laenge].theBmp.LoadImage (BitMap) then
begin
BitMapList[Laenge].theBmp.SetTextureWrap(GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE);
BitMapList[Laenge].theBmp.GenTexture (false, false);
result := BitmapList[Laenge].theBmp.TextureID;
BitmapList[Laenge].TextureNum := BitmapList[Laenge].theBmp.TextureID;
end;
}
end;
end;

procedure EnableTexture (Texture: GLenum; TextureTiled: boolean);
begin
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, Texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
if TextureTiled then
begin
glTexparameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexparameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
end
else
begin
glTexparameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexparameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
end;
end;

procedure DisableTexture;
begin
glDisable(GL_TEXTURE_2D);
end;

function TextToGLVector (VTxt: string): TGLVector;
const
subdelim: char = '/';
var
posi: integer;
V1: TGLVector;
begin
InitVector (V1,0,0,0);
posi := pos (subdelim, VTxt);
if posi > 0 then
begin
V1.X := StrToFloat (copy (VTxt, 1, posi-1));
VTxt := copy (VTxt, posi+1, length (VTxt));
posi := pos (subdelim, VTxt);
end;
if posi > 0 then
begin
V1.Y := StrToFloat (copy (VTxt, 1, posi-1));
VTxt := copy (VTxt, posi+1, length (VTxt));
end;
if length (VTxt) > 0 then V1.Z := StrToFloat (VTxt);

result := V1;
end;

function TextToGKVector (VTxt: string): TGKVector;
const
subdelim: char = '/';
var
posi: integer;
V1: TGKVector;
begin
InitVector (V1,0,0,0);
posi := pos (subdelim, VTxt);
if posi > 0 then
begin
V1.X := StrToFloat (copy (VTxt, 1, posi-1));
VTxt := copy (VTxt, posi+1, length (VTxt));
posi := pos (subdelim, VTxt);
end;
if posi > 0 then
begin
V1.Y := StrToFloat (copy (VTxt, 1, posi-1));
VTxt := copy (VTxt, posi+1, length (VTxt));
end;
if length (VTxt) > 0 then V1.Z := StrToFloat (VTxt);

result := V1;
end;

function GKVectorToText (V1: TGKVector): string;
const
subdelim: char = '/';
var
VTxt: string;
begin
VTxt := FloatToStr (V1.X) + subdelim;
VTxt := VTxt + FloatToStr (V1.Y) + subdelim;
VTxt := VTxt + FloatToStr (V1.Z);
result := VTxt;
end;

function GKVectorToText (V1: TGKVector; digits, decimals: byte): string;
const
subdelim: char = '/';
var
VTxt, frmt, sX, sY, sZ: string;
begin
{
VTxt := Format('%*.*f', [digits, decimals, V1.X]) + subdelim;
VTxt := VTxt + Format('%*.*f', [digits, decimals, V1.Y]) + subdelim;
VTxt := VTxt + Format('%*.*f', [digits, decimals, V1.Z]);
}
frmt := '%'+IntToStr(digits)+'.'+IntToStr(decimals)+'f';

sX := Format(frmt, [V1.X]);
sY := Format(frmt, [V1.Y]);
sZ := Format(frmt, [V1.Z]);
//sX := FloatToStrF(V1.X, fffixed, digits, decimals);
//sY := FloatToStrF(V1.Y, fffixed, digits, decimals);
//sZ := FloatToStrF(V1.Z, fffixed, digits, decimals);

sX := trim (sX);
sY := trim (sY);
sZ := trim (sZ);

sX := CheckFormat (sX, digits, decimals);
sY := CheckFormat (sY, digits, decimals);
sZ := CheckFormat (sZ, digits, decimals);

VTxt := sX + subdelim + sY + subdelim + sZ;

result := VTxt;
end;

function GLVectorToText (V1: TGLVector): string;
const
subdelim: char = '/';
var
VTxt: string;
begin
VTxt := FloatToStr (V1.X) + subdelim;
VTxt := VTxt + FloatToStr (V1.Y) + subdelim;
VTxt := VTxt + FloatToStr (V1.Z);
result := VTxt;
end;

function GLVectorToText (V1: TGLVector; digits, decimals: byte): string;
const
subdelim: char = '/';
var
VTxt, frmt, sX, sY, sZ: string;
begin
{
VTxt := Format('%*.*f', [digits, decimals, V1.X]) + subdelim;
VTxt := VTxt + Format('%*.*f', [digits, decimals, V1.Y]) + subdelim;
VTxt := VTxt + Format('%*.*f', [digits, decimals, V1.Z]);
}
frmt := '%'+IntToStr(digits)+'.'+IntToStr(decimals)+'f';

sX := Format(frmt, [V1.X]);
sY := Format(frmt, [V1.Y]);
sZ := Format(frmt, [V1.Z]);
//sX := FloatToStrF(V1.X, fffixed, digits, decimals);
//sY := FloatToStrF(V1.Y, fffixed, digits, decimals);
//sZ := FloatToStrF(V1.Z, fffixed, digits, decimals);

sX := trim (sX);
sY := trim (sY);
sZ := trim (sZ);

sX := CheckFormat (sX, digits, decimals);
sY := CheckFormat (sY, digits, decimals);
sZ := CheckFormat (sZ, digits, decimals);

VTxt := sX + subdelim + sY + subdelim + sZ;

result := VTxt;
end;

function MatrixToText (M: TArrMatrix): string;
const
subdelim: char = '/';
var
VTxt: string;
i: integer;
begin
VTxt := '';
for i := low (M) to high(M) do
begin
VTxt := VTxt + Format('%14.6f', [M[i]]);
if i < high (M) then
VTxt := VTxt + subdelim;
end;

result := VTxt;
end;

function MyCone (Start, Ende: TGLVector;
RadiusStart, RadiusEnde: GLdouble;
Slices: integer; TileX, TileY: GLdouble): boolean;
var
Slice: Integer;
Laenge, xdelta, zdelta: GLdouble;
V1, V2, V3, V4: TGLvector;
A, B: double;
//tmpVec: TGLvector;
begin
result := true;

// laenge des kegels berechnen
// hierbei wird davon ausgegangen, dass der kegel senkrecht steht
Laenge := Ende.y - Start.y;

// die folgende längenberechnung stimmt nicht mit der senkrechten
// verbindungslinie der beiden konusebenen überein, wenn die radien
// sich unterscheiden, da sich dann ein schiefer vektor ergibt. der
// ist natürlich länger als die senkrechte.
//tmpVec := SubtractVector (Start, Ende);
//Laenge := Magnitude (tmpVec);

// radiusdifferenz der oberen und unteren ebene des konus berechnen
xdelta := Start.x - Ende.x;
zdelta := Start.z - Ende.z;
xdelta := -xdelta;
//zdelta := zdelta;

glBegin (GL_TRIANGLE_STRIP);
// der kegel wird entlang der z-achse gezeichnet
V1.z := 0;
V2.z := 0;
V3.z := Laenge;
V4.z := Laenge;
// immer ein dreieck an das andere: mit zwei punkten des oberen
// radius und einem des unteren bzw. einem des oberen und zwei des
// unteren ein dreieck zeichnen. mit dem nächsten neu errechneten punkt
// und den zwei vorhergehenden haben wir immer das nächste dreieck.
// so viele dreiecke wie pizzastücke (slices) gewünscht.
for Slice := 1 to Slices do begin
A := 2 * PI * Slice / Slices;
B := 2 * PI * (Slice+1) / Slices;
V1.x := sin(A)*RadiusStart;
V1.y := cos(A)*RadiusStart;
V2.x := sin(B)*RadiusStart;
V2.y := cos(B)*RadiusStart;
// umsetzung von y nach z-achse
V3.x := (sin(B)*RadiusEnde)+xdelta;
V3.y := (cos(B)*RadiusEnde)+zdelta;
V4.x := (sin(A)*RadiusEnde)+xdelta;
V4.y := (cos(A)*RadiusEnde)+zdelta;
//Normale := CalcNormale (V1, V3, V2);
//glNormal3fv(@Normale);
if Slice = 1 then
begin
glTexCoord2d(1*TileX,0); glVertex3dv(@V1);
glTexCoord2d(1*TileX,1*TileY); glVertex3dv(@V4);
glTexCoord2d(1*TileX-Slice/Slices*TileX,0); glVertex3dv(@V2);
glTexCoord2d(1*TileX-Slice/Slices*TileX,1*TileY); glVertex3dv(@V3);
end
else
begin
glTexCoord2d(1*TileX-Slice/Slices*TileX,0); glVertex3dv(@V2);
glTexCoord2d(1*TileX-Slice/Slices*TileX,1*TileX); glVertex3dv(@V3);
end;
// so hatte ich mir das zuerst gedacht:
// aktuellen und nächsten punkt des kreises (oben und unten)
// nehmen und ein rechteck zeichnen. alle rechtecke zusammen sollten
// einen geschlossenen kegel ergeben.
//glBegin(GL_QUADS);
// glNormal3dv(@Normale);
// glTexCoord2d(0,0); glVertex3dv(@V2);
// glTexCoord2d(1,0); glVertex3dv(@V1);
// glTexCoord2d(1,1); glVertex3dv(@V4);
// glTexCoord2d(0,1); glVertex3dv(@V3);
//glEnd;
end;
glEnd; // (GL_TRIANGLE_STRIP)
end;

{-----------------------------------------------------------------------------}
{----------------------------- für TRUVCamera --------------------------------}
{-----------------------------------------------------------------------------}

function Multiply(M1, M2: TArrMatrix): TArrMatrix;
// multiplies two 4x4 matrices
var
ret: TArrMatrix;
begin
glPushMatrix();
glLoadMatrixd(@M1);
glMultMatrixd(@M2);
glGetDoublev(GL_MODELVIEW_MATRIX,@ret);
glPopMatrix();
result := ret;
end;

function MakeVector(X,Y,Z:GLdouble):TArrVector;
begin
result[0]:=x;
result[1]:=y;
result[2]:=z;
end;

function MakeVector(X,Y,Z,W:GLdouble):TArrVector;
begin
result[0]:=x;
result[1]:=y;
result[2]:=z;
result[3]:=w;
end;

function Normalize(aVector:TArrVector):TArrVector;overload;
var
d:double;
begin
InitVector (result,1,1,1);
d:=Sqrt(Sqr(aVector[C_X])+Sqr(aVector[C_Y])+Sqr(aVector[C_Z]));
if d=0 then
begin
//raise exception.Create('Zero length vector(Normalize 1)');
exit;
end;
result[C_X]:=aVector[C_X]/d;
result[C_Y]:=aVector[C_Y]/d;
result[C_Z]:=aVector[C_Z]/d;
end;

function Normalize(aVector:TGLVector):TGLVector;overload;
var
d:double;
begin
InitVector (result,1,1,1);
d:=Sqrt(Sqr(aVector.X)+Sqr(aVector.Y)+Sqr(aVector.Z));
if d=0 then
begin
//raise exception.Create('Zero length vector(Normalize 2)');
exit;
end;
result.X:=aVector.X/d;
result.Y:=aVector.Y/d;
result.Z:=aVector.Z/d;
end;

function GetIdentity(Matrix:TMatrix):TMatrix;
begin
result[0,0]:=1.0;result[0,1]:=0.0;result[0,2]:=0.0;result[0,3]:=0.0;
result[1,0]:=0.0;result[1,1]:=1.0;result[1,2]:=0.0;result[1,3]:=0.0;
result[2,0]:=0.0;result[2,1]:=0.0;result[2,2]:=1.0;result[2,3]:=0.0;
result[3,0]:=0.0;result[3,1]:=0.0;result[3,2]:=0.0;result[3,3]:=1.0;
end;

function GetIdentity(Matrix:TArrMatrix):TArrMatrix;
begin
result[0]:=1.0;result[1]:=0.0;result[2]:=0.0;result[3]:=0.0;
result[4]:=0.0;result[5]:=1.0;result[6]:=0.0;result[7]:=0.0;
result[8]:=0.0;result[9]:=0.0;result[10]:=1.0;result[11]:=0.0;
result[12]:=0.0;result[13]:=0.0;result[14]:=0.0;result[15]:=1.0;
end;

function MatrixTranspose(const M:TMatrix):TMatrix;register;
var
i,j:integer;
begin
for i:=0 to 3 do
for j:=0 to 3 do
result[i,j]:=M[j,i];
end;

function VectorRotateX(v:TArrVector;a:GLdouble):TArrVector;
var
temp: TArrVector;
sine,cosine:GLdouble;
begin
a:=a*C_DEGTORAD;
sine:=Sin(a);
cosine:=Cos(a);

temp[C_X] := v[C_x];
temp[C_Y] := (v[C_Y] * cosine) + (v[C_Z] * -sine);
temp[C_Z] := (v[C_Y] * sine) + (v[C_Z] * cosine);
result := temp;
end;

function VectorRotateY(v: TArrVector;a:GLdouble):TArrVector;
var
temp: TArrVector;
sine,cosine:GLdouble;
begin
a:=a*C_DEGTORAD;
sine:=Sin(a);
cosine:=Cos(a);

temp[C_x] := (v[C_x] * cosine) + (v[C_z] * sine);
temp[C_y] := v[C_y];
temp[C_z] := (v[C_x] * -sine) + (v[C_z] * cosine);
result := temp;
end;

function VectorRotateZ(v: TArrVector; a: GLdouble):TArrVector;
var
temp: TArrVector;
sine,cosine:GLdouble;
begin
a:=a*C_DEGTORAD;
sine:=Sin(a);
cosine:=Cos(a);
temp[C_x] := (v[C_x] * cosine) + (v[C_y] * -sine);
temp[C_y] := (v[C_x] * sin(a)) + (v[C_y] * cosine);
temp[C_z] := v[C_z];
result := temp;
end;

function VectorRotateX(v:TGLVector;a:GLdouble):TGLVector;
var
temp: TGLVector;
sine,cosine:GLdouble;
begin
a:=a*C_DEGTORAD;
sine:=Sin(a);
cosine:=Cos(a);

temp.X := v.x;
temp.Y := (v.Y * cosine) + (v.Z * -sine);
temp.Z := (v.Y * sine) + (v.Z * cosine);

result := temp;
end;

function VectorRotateY(v: TGLVector;a:GLdouble):TGLVector;
var
temp: TGLVector;
sine,cosine:GLdouble;
begin
a:=a*C_DEGTORAD;
sine:=Sin(a);
cosine:=Cos(a);

temp.x := (v.x * cosine) + (v.z * sine);
temp.y := v.y;
temp.z := (v.X * -sine) + (v.z * cosine);
result := temp;
end;

function VectorRotateZ(v: TGLVector; a: GLdouble):TGLVector;
var
temp: TGLVector;
sine,cosine:GLdouble;
begin
a:=a*C_DEGTORAD;
sine:=Sin(a);
cosine:=Cos(a);

temp.x := (v.x * cosine) + (v.y * -sine);
temp.y := (v.x * sin(a)) + (v.y * cosine);
temp.z := v.z;
result := temp;
end;

function VectorRotateX(v,c: TGLvector;a: GLdouble):TGLVector;
// v: zu drehender punkt
// c: zentrum
// a: winkel
var
temp, temp2: TGLVector;
begin
// das übergebene zentrum in den nullpunkt holen
temp2 := SubtractVector (v, c);

// jetzt so drehen, als ob alles um den nullpunkt angeordnet wäre
temp := VectorRotateX (temp2, a);

// und das ergebnis wieder in den ausgangspunkt zurück verschieben
result := AddVector (temp, c);
end;

function VectorRotateY(v,c: TGLvector;a: GLdouble):TGLVector;
// v: zu drehender punkt
// c: zentrum
// a: winkel
var
temp, temp2: TGLVector;
begin
// das übergebene zentrum in den nullpunkt holen
temp2 := SubtractVector (v, c);

// jetzt so drehen, als ob alles um den nullpunkt angeordnet wäre
temp := VectorRotateY (temp2, a);

// und das ergebnis wieder in den ausgangspunkt zurück verschieben
result := AddVector (temp, c);
end;

function VectorRotateZ(v,c: TGLvector; a: GLdouble):TGLVector;
// v: zu drehender punkt
// c: zentrum
// a: winkel
var
temp, temp2: TGLVector;
begin
// das übergebene zentrum in den nullpunkt holen
temp2 := SubtractVector (v, c);

// jetzt so drehen, als ob alles um den nullpunkt angeordnet wäre
temp := VectorRotateZ (temp2, a);

// und das ergebnis wieder in den ausgangspunkt zurück verschieben
result := AddVector (temp, c);
end;

function VectorRotateX(v1,v2,v3,v4:TGLVector;a:GLdouble):TGLVector;
// v1: zu drehender punkt
// v2, v3, v4: vektoren die zusammen mit v1 eine fläche beschreiben,
// durch welche die drehachse läuft.
// a: drehwinkel
var
PlaneVec, PlaneCenter: TGLvector;
begin
// zuerst das zentrum der vektoren herausfinden
PlaneCenter.X := (v1.X+v2.X+v3.X+v4.X) / 4;
PlaneCenter.Y := (v1.Y+v2.Y+v3.Y+v4.Y) / 4;
PlaneCenter.Z := (v1.Z+v2.Z+v3.Z+v4.Z) / 4;

// den zu drehenden vector in den nullpunkt holen
PlaneVec := SubtractVector (v1, PlaneCenter);

// jetzt um die gewünschte achse drehen
PlaneVec := VectorRotateX (PlaneVec, a);

// die drehung auf den eigentlichen vector aufaddieren
// und zurückgeben
result := AddVector (PlaneVec, PlaneCenter);

result := VectorRotateX (v1, PlaneCenter, a);
end;

function VectorRotateY(v1,v2,v3,v4:TGLvector;a:GLdouble):TGLVector;
// v: zu drehender punkt
// v2, v3, v4: vektoren die zusammen mit v1 eine fläche beschreiben,
// durch welche die drehachse läuft.
// a: drehwinkel
var
PlaneVec, PlaneCenter: TGLvector;
begin
// zuerst das zentrum der vektoren herausfinden
PlaneCenter.X := (v1.X+v2.X+v3.X+v4.X) / 4;
PlaneCenter.Y := (v1.Y+v2.Y+v3.Y+v4.Y) / 4;
PlaneCenter.Z := (v1.Z+v2.Z+v3.Z+v4.Z) / 4;

// den zu drehenden vector in den nullpunkt holen
PlaneVec := SubtractVector (v1, PlaneCenter);

// jetzt um die gewünschte achse drehen
PlaneVec := VectorRotateY (PlaneVec, a);

// die drehung auf den eigentlichen vector aufaddieren
// und zurückgeben
result := AddVector (PlaneVec, PlaneCenter);

result := VectorRotateY (v1, PlaneCenter, a);
end;

function VectorRotateZ(v1,v2,v3,v4:TGLvector;a:GLdouble):TGLVector;
// v: zu drehender punkt
// v2, v3, v4: vektoren die zusammen mit v1 eine fläche beschreiben,
// durch welche die drehachse läuft.
// a: drehwinkel
var
PlaneVec, PlaneCenter: TGLvector;
begin
// zuerst das zentrum der vektoren herausfinden
PlaneCenter.X := (v1.X+v2.X+v3.X+v4.X) / 4;
PlaneCenter.Y := (v1.Y+v2.Y+v3.Y+v4.Y) / 4;
PlaneCenter.Z := (v1.Z+v2.Z+v3.Z+v4.Z) / 4;

// den zu drehenden vector in den nullpunkt holen
PlaneVec := SubtractVector (v1, PlaneCenter);

// jetzt um die gewünschte achse drehen
PlaneVec := VectorRotateZ (PlaneVec, a);

// die drehung auf den eigentlichen vector aufaddieren
// und zurückgeben
result := AddVector (PlaneVec, PlaneCenter);

result := VectorRotateZ (v1, PlaneCenter, a);
end;

{ Finds the point on the axis, closest to the
source vector }
function NearestPoint(Axis, Point: TGLVector): TGLVector;
var
temp: double;
begin
temp := DotProduct(Axis, Point) / DotProduct(Axis, Axis);
Axis.X := Axis.X * temp;
Axis.Y := Axis.Y * temp;
Axis.Z := Axis.Z * temp;
Result := Axis;
end;

{-----------------------------------------------------------------------------}
{-------------------------------- allgemein ----------------------------------}
{-----------------------------------------------------------------------------}

function InvertMatrix (src: TArrMatrix; var inverse: TArrMatrix): boolean;
var
t: GLdouble;
i, j, k, swap: integer;
tmp: TMatrix;
begin
result := false;
inverse := GetIdentity(inverse);

for i := 0 to 3 do
begin
for j := 0 to 3 do
begin
tmp[i][j] := src[i*4+j];
end;
end;

for i := 0 to 3 do
begin
// look for largest element in column.
swap := i;
for j := i+1 to 3 do
begin
if abs(tmp[j][i]) > abs(tmp[i][i]) then
begin
swap := j;
end;
end;

if not (swap = i) then
begin
// swap rows.
for k := 0 to 3 do
begin
t := tmp[i][k];
tmp[i][k] := tmp[swap][k];
tmp[swap][k] := t;

t := inverse[i*4+k];
inverse[i*4+k] := inverse[swap*4+k];
inverse[swap*4+k] := t;
end;
end;

if tmp[i][i] = 0 then
begin
{ no non-zero pivot. the matrix is singular, which
shouldn't happen. This means the user gave us a bad
matrix. }
exit;
end;

t := tmp[i][i];
for k := 0 to 3 do
begin
tmp[i][k] := tmp[i][k]/t;
inverse[i*4+k] := inverse[i*4+k]/t;
end;

for j := 0 to 3 do
begin
if not (j = i) then
begin
t := tmp[j][i];
for k := 0 to 3 do
begin
tmp[j][k] := tmp[j][k]-tmp[i][k]*t;
inverse[j*4+k] := inverse[j*4+k]-inverse[i*4+k]*t;
end;
end;
end;
end;
result := true;
end;

function Multiply (Color: TGLcolor; m: GLdouble): TGLcolor;
var
ret: TGLcolor;
begin
ret.red := Color.red * m;
ret.green := Color.green * m;
ret.blue := Color.blue * m;
result := ret;
end;

function Divide (V1: TGLvector; d: GLdouble): TGLvector;
var
ret: TGLvector;
begin
ret.x := V1.x / d;
ret.y := V1.y / d;
ret.z := V1.z / d;
result := ret;
end;

function ForceForegroundWindow(hwnd: THandle): Boolean;
{
Manchmal funktioniert die SetForeGroundWindow Funktion
nicht so, wie sie sollte; besonders unter Windows 98/2000,
wenn ein anderes Fenster den Fokus hat.
ForceForegroundWindow ist eine "verbesserte" Version von
der SetForeGroundWindow API-Funktion, um ein Fenster in
den Vordergrund zu bringen.
}
const
SPI_GETFOREGROUNDLOCKTIMEOUT = $2000;
SPI_SETFOREGROUNDLOCKTIMEOUT = $2001;
var
ForegroundThreadID: DWORD;
ThisThreadID: DWORD;
timeout: DWORD;
begin
if IsIconic(hwnd) then ShowWindow(hwnd, SW_RESTORE);

if GetForegroundWindow = hwnd then Result := True
else
begin
// Windows 98/2000 doesn't want to foreground a window when some other
// window has keyboard focus

if ((Win32Platform = VER_PLATFORM_WIN32_NT) and (Win32MajorVersion > 4)) or
((Win32Platform = VER_PLATFORM_WIN32_WINDOWS) and
((Win32MajorVersion > 4) or ((Win32MajorVersion = 4) and
(Win32MinorVersion > 0)))) then
begin
// Code from Karl E. Peterson, www.mvps.org/vb/sample.htm
// Converted to Delphi by Ray Lischner
// Published in The Delphi Magazine 55, page 16

Result := False;
ForegroundThreadID := GetWindowThreadProcessID(GetForegroundWindow, nil);
ThisThreadID := GetWindowThreadPRocessId(hwnd, nil);
if AttachThreadInput(ThisThreadID, ForegroundThreadID, True) then
begin
BringWindowToTop(hwnd); // IE 5.5 related hack
SetForegroundWindow(hwnd);
AttachThreadInput(ThisThreadID, ForegroundThreadID, False);
Result := (GetForegroundWindow = hwnd);
end;
if not Result then
begin
// Code by Daniel P. Stasinski
SystemParametersInfo(SPI_GETFOREGROUNDLOCKTIMEOUT, 0, @timeout, 0);
SystemParametersInfo(SPI_SETFOREGROUNDLOCKTIMEOUT, 0, TObject(0),
SPIF_SENDCHANGE);
BringWindowToTop(hwnd); // IE 5.5 related hack
SetForegroundWindow(hWnd);
SystemParametersInfo(SPI_SETFOREGROUNDLOCKTIMEOUT, 0, TObject(timeout), SPIF_SENDCHANGE);
end;
end
else
begin
BringWindowToTop(hwnd); // IE 5.5 related hack
SetForegroundWindow(hwnd);
end;

Result := (GetForegroundWindow = hwnd);
end;
end; { ForceForegroundWindow }

procedure InitGLEnv (dc: HDC; rc: HGLRC; hndl: THandle);
resourcestring
Res_ChooseFailed = 'ChoosePixelFormat failed with ';
var
pfd: TPixelFormatDescriptor;
PixelFormat: TGLUint;
pFlags: TPFDFlags;
flags: word absolute pFlags;
StencilBits,
ColorBits,
DepthBits: integer;
begin
pflags := [];
include (pflags, DoubleBuffer);
include (pflags, Stereo);
include (pflags, Draw_To_Window);
include (pflags, Draw_To_Bitmap);
include (pflags, Support_GDI);
include (pflags, Support_OpenGL);
include (pflags, Generic_Format);
include (pflags, Need_Palette);
include (pflags, Need_System_Palette);
include (pflags, Swap_Exchange);
include (pflags, Swap_Copy);
include (pflags, Swap_Layer_Buffers);
include (pflags, Generic_Accelerated);

ColorBits := 24;
DepthBits := 32;
StencilBits := 0;

with TWinControl(hndl) do
begin
fillchar(pfd,SizeOf(pfd),0);
with pfd do
begin
nSize := SizeOf(pfd);
nVersion := 1;
dwFlags := flags or
PFD_DRAW_TO_WINDOW
or PFD_SUPPORT_OPENGL
or PFD_DOUBLEBUFFER;
iPixelType := PFD_TYPE_RGBA;
cColorBits := ColorBits;
cDepthBits := DepthBits;
cStencilBits := StencilBits;
iLayerType := PFD_MAIN_PLANE;
cRedBits := 0;
cRedShift := 0;
cGreenBits := 0;
cBlueBits := 0;
cBlueShift := 0;
cAlphaBits := 0;
cAlphaShift := 0;
cAccumBits := 0;
cAccumRedBits := 0;
cAccumGreenBits := 0;
cAccumBlueBits := 0;
cAccumAlphaBits := 0;
cAuxBuffers := 0;
bReserved := 0;
dwLayerMask := 0;
dwVisibleMask := 0;
dwDamageMask := 0;
end; {with}

PixelFormat := ChoosePixelFormat(dc, @pfd);
if PixelFormat=0 then
raise Exception.Create(Res_ChooseFailed+IntToStr(GetLastError));

//if not SetPixelFormat(FglDC, PixelFormat, @pfd) then
// raise Exception.Create('SetPixelFormat failed with '+
// IntToStr(GetLastError));
end;
end;

function CheckFormat (number: string; digits, decimals: byte): string;
// wandelt ein mögliches dezimalkomma in einen punkt um
// beschneidet den übergebenen zahlenstring auf die gewünschten
// vorkomma- und nachkommastellen
// der übergebene zahlenstring darf keine tausender-kommas
// oder punkte enthalten!
var
sdigits, sdecimals, temp: string;
posi: integer;
begin
if digits+decimals = 0 then
begin
temp := '';
end
else
begin
sdigits := '';
sdecimals := '';
posi := pos (',', number);
if posi = 0 then
posi := pos ('.', number);
if posi > 0 then
sdigits := copy (number, 1, posi-1);
if length (number) > posi then
sdecimals := copy (number, posi+1);
if length (sdigits) > digits then
sdigits := copy (sdigits, length (sdigits)-(digits-1));
if length (sdecimals) > decimals then
sdecimals := copy (sdecimals, 1, decimals);
temp := sdigits + '.' + sdecimals;
end;
result := temp;
end;

procedure ResetGLErrorFlags;
var
err: GLenum;
begin
repeat
err := glGetError;
until err = GL_NO_ERROR;
end;

function ValidTexture (tex: GLUint; ErrStr: string): boolean;
var
error: GLenum;
begin
result := true;

ResetGLErrorFlags;
if not glIsTexture (tex) then
begin
error := glGetError;
Application.MessageBox(pChar ('Textur wurde nicht erkannt!'+chr(13)+chr(10)+
ErrStr+chr(13)+chr(10)+
'Fehler: '+IntToStr (error)),
'Fehler',
0);
result := false;
end;
end;

function AxisXRotation (V1, V2: TGLvector): GLdouble;
begin
V1.Z := 0;
V2.Z := 0;
result := DotProduct (V1, V2);
end;

function AxisYRotation (V1, V2: TGLvector): GLdouble;
begin
V1.Z := 0;
V2.Z := 0;
result := DotProduct (V1, V2);
end;

function AxisZRotation (V1, V2: TGLvector): GLdouble;
begin
V1.Y := 0;
V2.Y := 0;
result := DotProduct (V1, V2);
end;

function ExePath: string;
var
pfad: string;
begin
pfad := ExtractFilePath (Application.Exename);
if copy (pfad, length (pfad), 1) <> '\' then
pfad := pfad + '\';
result := pfad;
end;

end.
</pascal>
[[Kategorie:Anleitung]]

Kamera (2)

2006-10-07T05:17:51Z

Andyh:

Eine Beschreibung findet ihr unter [[Kamera (1)]]. 
Die verwendete Toolsammlung findet ihr unter [[Kamera (3)]].

<pascal>
// Wie ich selber immer wieder merken muss, ist eine Software anscheinend
// nie fertig. Immer moechte man etwas verbessern oder neue Features
// einbauen.
// Sollte also jemand Änderungs- oder Verbesserungsvorschläge haben oder
// neue Ideen einbringen wollen, oder sollten Verstaendnisfragen bestehen,
// so mailt bitte an
//
// Andree.Heyroth@t-online.de
//
// Danke.
//
// Updates:
//
// 06.11.2005
// Die Deklaration der DESTROY Methode war falsch. Das fuehrte dazu,
// dass in der Methode CREATE erzeugte Objekte nicht richtig frei-
// gegeben wurden und es zu EAccessViolations kam. Die Methode wird
// jetzt in der PUBLIC Section mit der Direktive OVERRIDE aufgerufen.
//
// 11.11.2005
// Die Positionierung funktioniert jetzt.
// Wegen eines Verstaendnisproblems wurden die Positionen immer auf den
// Kamerapunkt aufaddiert. Das bedeutete, dass die Positionierung aus
// dem Ruder lief wenn sie nicht im Nullpunkt stattfand. Je groesser die
// gewuenschte Position war um so groesser war die Abweichung von der
// Darstellung.
// Ich habe nicht bedacht, dass bei einer "Kamera"-bewegung und -drehung
// ja eigentlich die Szene bewegt und gedreht wird. Deswegen wurden nach
// einer Positionierung die folgenden Projektionen immer basierend auf der
// danach gueltigen Kameraposition gemacht.
// Jetzt wird die Position so gesetzt, dass die gewuenschte Kameraposition
// immer vor dem Betrachter steht.
//
// 23.11.2005
// Neues Flag (FFixedAxis) zur Entscheidung zwischen angepasster und realer
// Drehung. Dadurch wird das Bewegungsmodell angepasst. Siehe Methode Offset,
// bzw. UpdateMatrixOffset.
//
// 10.12.2005
// Property PointOfRotation ist jetzt nicht mehr ReadOnly.
// Der Blickpunkt bzw. Rotationspunkt kann jetzt direkt verändert werden.
// So kann eine neue Blickrichtung angenommen werden ohne vorher die Kamera-
// eigenschaften zu sichern und nach einem PositionCamera wieder zu setzen.
//
// 19.12.2005
// Neue Methode PositionCross.
// Die Methode PositionCross schiebt das Fadenkreuz in den angegebenen Punkt
// ohne die Lage der Szene zu verändern. Diese Funktionalitaet ist anders als
// ein neues Setzen der Property FPointOfRotation weil dabei die Szene in das
// Koordinatenkreuz geschoben wird.
//
// 31.01.2006
// Umstellung auf genaueres Zahlenformat
// Da die Darstellung von Szenen ausserhalb des Bereichs von FLOAT-Zahlen
// nicht funktioniert, muss alles auf DOUBLE umgestellt werden. Dazu gehört
// das Ersetzen von Datentypen und der Aufruf der entsprechenden GL-Funktionen.
//
unit Camera;

interface

Uses DglOpenGL, Util, Windows, Classes;

type
TCameraMatrix=Class
StackMatrix: array [0..9] of TArrMatrix;
StackCtr: integer;
Matrix: TArrMatrix;
InverseMatrix: TArrMatrix;
constructor Create;
//destructor destroy;
procedure Identity;
procedure Push;
procedure Pop;
procedure Load(M: TArrMatrix);
end;

TCamera=Class
Enabled: boolean;
function UpVector: TGLvector;
procedure RestorePosition(pos: integer);
procedure SavePosition(pos: integer);
function GiveStoredPosition(pos: integer): TGLvector;
procedure RotateCamera(ix, iy, iz: GLdouble);
procedure TranslateCamera(ix, iy, iz: GLdouble);
procedure CameraHome;
procedure PositionCamera(PositionVec: TGLvector; ViewVec: TGLvector; upVec: TGLvector);
procedure Adjust;
procedure Apply;
procedure ApplyForTerrain;
private
FPosition: TGLvector;
FViewDirection: TGLvector;
FPointOfRotation: TGLvector;
HomeMatrix: TCameraMatrix;
CameraMatrix: TCameraMatrix;
Initiated: boolean;
PosArray: array [0..9] of TCameraMatrix;
RotArray: array [0..9] of TGLvector;
FFixedAxis: boolean;
procedure Debug (Text: string);
function UpdateMatrixOffset(newMatrix: TArrMatrix): TArrMatrix;
function GetViewDirection: TGLvector;
procedure SetViewDirection (View: TGLvector);
procedure Initiate;
function GetPosition: TGLvector;
procedure SetPosition (Pos: TGLvector);
procedure Identity;
procedure Offset(x, y, z: GLdouble);
procedure RotateRoundAxis(rx, ry, rz: GLdouble);
procedure SetPointOfRotation (NewPoint: TGLvector);
public
constructor Create;
destructor Destroy;override;
function InverseMatrix: TArrMatrix;
procedure ApplyInvers;
procedure PositionCross(CrossVec: TGLvector);
published
property PointOfRotation: TGLvector read FPointOfRotation write SetPointOfRotation;
property Position: TGLvector read GetPosition write SetPosition;
property ViewDirection: TGLvector read GetViewDirection write SetViewDirection;
property FixedAxis: boolean read FFixedAxis write FFixedAxis;
end;
TPCamera=^TCamera;

var
FDebugFile: Textfile;
FDebugFileName: string;
FDebugOn: boolean;

implementation

uses SysUtils;

constructor TCameraMatrix.Create;
begin
inherited create;
StackCtr := 0;
end;
{
destructor TCameraMatrix.Destroy;
begin
inherited destroy;
end;
}

procedure TCameraMatrix.Push;
begin
if (StackCtr > -1) and (StackCtr < 10) then
begin
StackMatrix[StackCtr] := Matrix;
inc (StackCtr);
end;
end;

procedure TCameraMatrix.Pop;
begin
if (StackCtr > 0) and (StackCtr < 11) then
begin
dec (StackCtr);
Load (StackMatrix[StackCtr]);
end;
end;

procedure TCameraMatrix.Identity;
// GetIdentity: aus OpenGL.pas
// initialisiert die CameraMatrix mit der Identitaetsmatrix
begin
Matrix := GetIdentity(Matrix);
InverseMatrix := GetIdentity(InverseMatrix);
end;

procedure TCameraMatrix.Load(M: TArrMatrix);
// die Matrix mit den Werten einer beliebigen anderen matrix fuellen
var
i: integer;
begin
for i:=0 to 15 do
Matrix[i]:=M[i];
// die invertierte Matrix kann benutzt werden um Objkekte z.B.
// immer zum Benutzer auszurichten
InvertMatrix (M, InverseMatrix);
end;

constructor TCamera.Create;
var
i: integer;
begin
inherited create;

// Initiated wird gebraucht um einmal alle Positionsspeicher
// mit der Anfangsposition zu belegen
Initiated := false;

// Kameramatrix anlegen
CameraMatrix := TCameraMatrix.Create;

// Matrix der letzten Position von PositionCamera anlegen
HomeMatrix := TCameraMatrix.Create;

// Positionsspeicher anlegen
for i := 0 to 9 do
PosArray[i] := TCameraMatrix.Create;

// standardmaessig immer entlang der bildschirmachsen verschieben
FFixedAxis := true;
end;

destructor TCamera.Destroy;
// alle in create belegten Resourcen wieder freigeben
var
i: integer;
begin
FreeAndNil (CameraMatrix);
FreeAndNil (HomeMatrix);
for i := 0 to 9 do
FreeAndNil (PosArray[i]);

inherited destroy;
end;

procedure TCamera.RotateRoundAxis(rx, ry, rz: GLdouble);
// hier drehen wir jetzt um die einzelnen Achsen.
// die Parameter geben die "Drehgeschwindigkeit" vor.
var
newMatrix: TArrMatrix;
tempX, tempY, tempZ: TGLvector;
begin
glMatrixMode (GL_MODELVIEW);
glPushMatrix();

// aktuelle Position und Lage der Kamera herstellen
glLoadMatrixd(@CameraMatrix.Matrix);

if FFixedAxis then
begin
// über die bildschirmachsen drehen
tempX := GetMatrixX (CameraMatrix.InverseMatrix);
tempY := GetMatrixY (CameraMatrix.InverseMatrix);
tempZ := GetMatrixZ (CameraMatrix.InverseMatrix);
// wenn gewuenscht um die X-Achse drehen
if(rx <> 0) then
glRotated(rx,tempX.X,tempX.Y,tempX.Z);

// wenn gewuenscht um die Y-Achse drehen
if(ry <> 0) then
glRotated(ry,tempY.X,tempY.Y,tempY.Z);

// wenn gewuenscht um die Z-Achse drehen
if(rz <> 0) then
glRotated(rz,tempZ.X,tempZ.Y,tempZ.Z);
end
else
begin
// über die achsen des koordinatenkreuzes drehen
// wenn gewuenscht um die X-Achse drehen
if(rx <> 0) then
glRotated(rx,1,0,0);

// wenn gewuenscht um die Y-Achse drehen
if(ry <> 0) then
glRotated(ry,0,1,0);

// wenn gewuenscht um die Z-Achse drehen
if(rz <> 0) then
glRotated(rz,0,0,1);
end;

// die neu erzeugte Matrix auslesen
glGetDoublev(GL_MODELVIEW_MATRIX, @newMatrix);

glPopMatrix();

// und in die Kameramatrix sichern
CameraMatrix.Load(newMatrix);
end;

procedure TCamera.Identity;
begin
CameraMatrix.Identity;
HomeMatrix.Identity;

Enabled := true;
end;

procedure TCamera.Offset(x, y, z: GLdouble);
// verschieben der Kamera auf einer beliebigen Achse
var
newMatrix: TArrMatrix;
//OldView: TGLvector;
begin
Debug ('- Offset - Start --------------------------------------------------');
glMatrixMode (GL_MODELVIEW);

glPushMatrix();
glLoadIdentity;
glTranslated(x,y,z);
glGetDoublev(GL_MODELVIEW_MATRIX, @newMatrix);
glPopMatrix();

Debug ('Position: '+GLvectorToText (GetMatrixPos (newMatrix)));
newMatrix := UpdateMatrixOffset (newMatrix);
CameraMatrix.Load(newMatrix);
Debug ('- Offset - Ende- --------------------------------------------------');
end;

procedure TCamera.PositionCamera(PositionVec: TGLvector;
ViewVec: TGLvector;
upVec: TGLvector);
var
newMatrix: TArrMatrix;
i: integer;
P, V, U: TGLvector;
Laenge: GLdouble;
begin
Debug ('- PositionCamera - Start ------------------------------------------');
// die gewuenschte konstruktion immer auf die Z-ebene projizieren.
// zuerst die position in den nullpunkt holen
InitVector (P, 0, 0, 0);
// jetzt den viewpoint um den gleichen betrag reduzieren, damit
// die gerade parallel verschoben wird.
V := SubtractVector (ViewVec, PositionVec);
// U ist halt schneller geschrieben als upVec...
U := upVec;

// den betrag ermitteln, um den die kamera nachher auf der Z-Achse
// verschoben werden muss
Laenge := Magnitude (SubtractVector (P, V));

Identity;

glMatrixMode (GL_MODELVIEW);
glPushMatrix;
glLoadIdentity;

// glulookat wird die matrix parallel zur Z-achse ausrichten
gluLookAt (P.X, P.Y, P.Z, V.X, V.Y, V.Z, U.X, U.Y, U.Z);
glGetDoublev(GL_MODELVIEW_MATRIX, @newMatrix);
glPopMatrix;

CameraMatrix.Load(newMatrix);
HomeMatrix.Load(newMatrix);

// da wir uns jetzt am zielpunkt befinden, müssen wir auf der Z-achse
// wieder zurueck zur kameraposition
Offset (0, 0, -Laenge);

// alle positionsspeicher mit der Kameraposition, Blickrichtung
// und dem upVector belegen. Nur beim ersten Aufruf von
// PositionCamera
if not Initiated then
Initiate;

FPointOfRotation := ViewVec;
Debug ('PointOfRotation: '+GLvectorToText (FPointOfRotation));
Debug ('- PositionCamera - Ende -------------------------------------------');
end;

procedure TCamera.PositionCross (CrossVec: TGLvector);
// diese prozedur verschiebt, im gegensatz zu einem verändern von
// PointOfRotation, das Koordinatenkreuz und nicht die Szene.
var
newMatrix: TArrMatrix;
PosDiff: TGLvector;
begin
Debug ('- PositionCross - Start -------------------------------------------');

PosDiff := SubtractVector (FPointOfRotation, CrossVec);

// Szene in das koordinatenkreuz verschieben
FPointOfRotation := CrossVec;

// jetzt die Szene wieder um den gleichen betrag zurückverschieben
// das sieht dann so aus, als ob das koordinatenkreuz verschoben
// worden wäre
// zuerst die aktuelle neue Situation herstellen
// (mit neuem FPointOfRotation)
Apply;

// jetzt um den Differenzbetrag des alten und neuen
// Rotationspunkts zurück verschieben
glTranslated (-PosDiff.X, 0, 0);
glTranslated (0, -PosDiff.Y, 0);
glTranslated (0, 0, -PosDiff.Z);

// jetzt vom neuen Rotationspunktes zurück ins Zentrum, damit beim
// nächsten Apply das glTranslatef (-FPointOfRotation, ...) klappt
glTranslated (CrossVec.X, 0, 0);
glTranslated (0, CrossVec.Y, 0);
glTranslated (0, 0, CrossVec.Z);

// aktuelle Matrix holen...
glGetDoublev(GL_MODELVIEW_MATRIX, @newMatrix);

// und als Kameramatrix abspeichern
CameraMatrix.Load(newmatrix);
Debug ('- PositionCross - Ende --------------------------------------------');
end;

procedure TCamera.CameraHome;
// Kamera in die beim letzten Aufruf von PositionCamera uebergebene
// Position/Lage bringen
begin
CameraMatrix.Load(HomeMatrix.Matrix);
end;

procedure TCamera.SavePosition (pos: integer);
// wie der Prozedurname schon sagt...
begin
if (pos < 0) or (pos > 9) then
exit;

PosArray[pos].Load(CameraMatrix.Matrix);
RotArray[pos] := FPointOfRotation;
end;

procedure TCamera.RestorePosition (pos: integer);
// wie der Prozedurname schon sagt...
begin
if (pos < 0) or (pos > 9) then
exit;

CameraMatrix.Load(PosArray[pos].Matrix);
FPointOfRotation := RotArray[pos];
end;

function TCamera.GiveStoredPosition (pos: integer): TGLvector;
// gibt den Inhalt des durch pos bestimmten
// Positionsspecihers zurueck
begin
if (pos < 0) or (pos > 9) then
exit;

result := GetMatrixPos (PosArray[pos].Matrix);
end;

procedure TCamera.TranslateCamera(ix, iy, iz: GLdouble);
// vom Benutzer aufzurufende Methode um eine Verschiebung
// durchzufuehren
begin
Offset (ix, iy, iz);
end;

procedure TCamera.RotateCamera(ix, iy, iz: GLdouble);
// vom Benutzer aufzurufende Methode um eine Drehung
// durchzufuehren
begin
RotateRoundAxis (-iy, -ix, -iz);
end;

procedure TCamera.Apply;
// hier wird die Kamera eingeschaltet. Nach dem Aufruf dieser Prozedur
// sollte die Szene mit allen benoetigten Drehungen, Verschiebungen
// gezeichnet werden.
begin
if not Enabled then
exit;

glMatrixMode (GL_MODELVIEW);
glLoadMatrixd(@CameraMatrix.Matrix);
glTranslated (-FPointOfRotation.X,
-FPointOfRotation.y,
-FPointOfRotation.Z);
end;

procedure TCamera.ApplyForTerrain;
// hier wird wie in Apply die Kamera eingeschaltet. da man um ein terrain
// (skycube, ...) anzuzeigen aber immer die gleiche entfernung zur welt
// einhalten muss, wird hier nur gedreht und nicht verschoben.
var
pos: TGLvector;
begin
if not Enabled then
exit;

glMatrixMode (GL_MODELVIEW);
// für das Terrain nur die Drehung ausführen
glLoadMatrixd(@CameraMatrix.Matrix);
// deswegen jetzt die verschiebung zurücknehmen
Pos := GetMatrixPos (CameraMatrix.InverseMatrix);
glTranslated (Pos.X, Pos.Y, Pos.Z);
end;

function TCamera.GetPosition: TGLvector;
// diese Property-Funktion fragt die aktuelle Position der Kamera ab
begin
// position: letzte Spalte der Matrix
result := AddVector (GetMatrixPos (CameraMatrix.InverseMatrix), FPointOfRotation);
end;

procedure TCamera.SetPosition (Pos: TGLvector);
// diese Property-Funktion setzt eine neue Position der Kamera
var
m: TArrMatrix;
begin
// position: letzte Spalte der Matrix
m := CameraMatrix.Matrix;
SetMatrixPos (m, SubtractVector (Pos, FPointOfRotation));
CameraMatrix.Load (m);
end;

function TCamera.GetViewDirection: TGLvector;
// mit dieser Funktion kann die aktuelle Blickrichtung der Kamera
// abgefragt werden
var
return: TGLvector;
begin
// view direction: dritte Spalte der Matrix (Z-Achse)
result := GetMatrixZ (CameraMatrix.InverseMatrix);
end;

procedure TCamera.SetViewDirection (View: TGLvector);
// mit dieser Funktion kann die aktuelle Blickrichtung der Kamera
// gesetzt werden
begin
// view direction: dritte Spalte der Matrix (Z-Achse)
SetMatrixZ (CameraMatrix.InverseMatrix, View);
end;

function TCamera.UpVector: TGLvector;
// mit dieser Funktion kann die aktuelle Ausrichtung der Kamera
// abgefragt werden
var
return: TGLvector;
begin
// upVector: zweite Spalte der Matrix (Y-Achse)
result := GetMatrixY (CameraMatrix.InverseMatrix);
end;

procedure TCamera.Adjust;
// mit dieser Prozedur kann die Kamera zu jeder Zeit, unabhaengig
// von Drehung und Position, zur Y-Achse ausgerichtet werden.
// Die aktuelle Position wird dabei beibehalten.
var
m: TArrMatrix;
v: TGLvector;
begin
// position aus der aktuellen cameramatrix holen
v := GetMatrixPos (CameraMatrix.Matrix);
// m mit identitätsmatrix initialisieren
m := GetIdentity(m);
// die position aus der aktuellen cameramatrix in m speichern
SetMatrixPos (m, v);
// m als aktuelle cameramatrix speichern
CameraMatrix.Load(m);
end;

function TCamera.InverseMatrix: TArrMatrix;
begin
result := CameraMatrix.InverseMatrix;
end;

procedure TCamera.Initiate;
var
i: integer;
begin
for i := 0 to 9 do
SavePosition (i);
Initiated := true;
end;

function TCamera.UpdateMatrixOffset (newMatrix: TArrMatrix): TArrMatrix;
begin
// wenn ich mit Multiply (FixedAxis) arbeite, wird die zeichnung immer
// entlang der bildschirmachsen verschoben. wenn ich Multiply, version 2
// nehme, wird sie auf den errechneten achsen verschoben.
if FFixedAxis then
begin
result := Multiply (newMatrix, CameraMatrix.Matrix);
end
else
begin
result := Multiply (CameraMatrix.Matrix, newMatrix);
end;
end;

procedure TCamera.SetPointOfRotation (NewPoint: TGLvector);
// setzt den viewpoint oder rotationpoint ohne die anderen parameter zu
// veraendern. so kann man z.B. eine Kamerafahrt in immer der gleichen
// position simulieren.
begin
FPointOfRotation := NewPoint;
end;

procedure TCamera.Debug (Text: string);
begin
if not FDebugOn then
exit;
writeln (FDebugFile, DateToStr (date) + ' | ' +
TimeToStr (time) + ' | ' +
Text);
end;

procedure TCamera.ApplyInvers;
var
M: TArrMatrix;
begin
// Um Objekte immer zum benutzer ausrichten, darf nur die drehung angewendet
// werden und nicht die verschiebung. Verschiebung wird hier zurückgenommen.
// Vorher muss die Kamera angewendet und die nötigen Verschiebungen/
// Drehungen ausgeführt werden.
M := InverseMatrix;
M[12] := 0;
M[13] := 0;
M[14] := 0;
M[15] := 1;
glMultMatrixd(@M);
end;

Initialization
FDebugOn := false;
FDebugFileName := ExePath + 'SKANAL3D_CAMERA.DBG';
if FDebugOn then
begin
AssignFile (FDebugFile, FDebugFileName);
Rewrite (FDebugFile);
end;

finalization
if FDebugOn then
begin
CloseFile (FDebugFile);
FDebugFileName := '';
end;

end.
</pascal>
[[Kategorie:Anleitung]]

Kamera

2006-10-07T05:16:29Z

Andyh:

Andyh beschreibt in den Aritikeln:
*[[Kamera (1)]]
*[[Kamera (2)]]
*[[Kamera (3)]]
wie man eine Kamara realisiert.

Andyh:
{{Zitat|
Nachdem ich viel Zeit damit verbracht habe eine funktionierende Kamera
zu bauen und es nun endlich geschafft habe, wollte ich diese Funktionalität
auch anderen zur Verfügung stellen.
Da mir schon viel geholfen wurde, kann ich so einen Teil meiner "Schuld"
zurück zahlen.

Die folgend beschriebene Kamera kann sich um alle drei Achsen drehen und sich
in allen Ebenen bewegen. Der Drehpunkt um den sich die Kamera dreht wird mit
dem Aufruf der Prozedur PositionCamera festgelegt. Sollte man diesen Drehpunkt
benötigen (z.B. zum anzeigen eines Koordinatenkreuzes, ...) so kann man auf
die Property PointOfRotation zugreifen (read only).

Die Kamera kann bis zu zehn Positionen speichern und auch wieder herstellen.
(SavePosition, RestorePosition)

Die Kamera kann sich selber zu jeder Zeit unter Beibehaltung der aktuellen
Position senkrecht zur Welt ausrichten.
(Adjust)

Um sicher zu sein, dass auch alle nötigen Definitionen und Funktionen zur
Verfügung stehen habe ich einfach mal einen Großteil meiner Funktionssammlung
beigefügt (OpenGLUtil.pas). Diese Funktionen/Prozeduren werden so oder in leicht
abgeänderter Form wohl bei jedem OpenGL Programmierer existieren.

...

Nachdem ich bis jetzt glaubte, dass man mit der von mir erstellten Krzanleitung auskommt, hab eich doch noch ein Beispielprogramm erstellt. Nach mehrmaligem Studium meiner Kurzanleitung bin ich nämlich zu dem Schluss gekommen, dass man mit diesem Programmierbeispiel nicht zu dem von mir beabsichtigten Ergebnis kommen kann. Das Beispielprogramm, welches die Funktionen der Kamera veranschaulicht, wurde mit Delphi 2005 entwickelt. Wenn Ihr über eine ältere Delphiversion verfügt, nehmet einfach die DPR Datei oder erstellt ein neues Projekt mit Euerem Compiler und bindet die benötigten Dateien ein.

Ich habe noch einiges mehr an Code reingepackt als unbedint nötig, um der Sache optisch ein Mindestmaß an Anspruch zu verleihen. Deswegen können aus diesem Beispielprogramm noch die eine oder andere Komponente entnommen werden (wenn nicht schon vorhanden). Dies sind z.B. Komponenten für Licht, Material, eine Skybox und zur Handhabung von Grafikdateien (die ist allerdings nicht auf meinem Mist gewachsen). Zusätlich habe ich noch den memory Manager FastMM4 beigepackt und eingebunden. Mit diesem kann man sehr schön (besser als mit den von Delphi bereitgestellten Möglichkeiten) nicht freigegebene Resourcen aufspüren. Ich war überrascht was ich alles nicht freigegeben hatte, als ich den zume rsten mal eingesetzt habe.

...

Sollte es noch irgendwelche Fragen zu diesem Modul geben so stehe ich gerne
zur Verfügung (Andyh).}}

[[Kategorie:Technik_oder_Algorithmus]]

Kamera (1)

2006-05-21T06:33:03Z

Andyh:

==Danke==
Nachdem ich viel Zeit damit verbracht habe, eine funktionierende Kamera zu bauen und es nun endlich geschafft habe, wollte ich diese Funktionalität auch Anderen zur Verfügung stellen.
Da mir schon viel geholfen wurde, kann ich so einen Teil meiner "Schuld" zurück zahlen.

Bitte seht ab und zu mal hier nach, ob es für diese Kamera Updates gibt. Sollte es so sein, habe ich das im Code ([[Kamera (2)]]) vermerkt. Ladet in diesem Fall bitte den Source Code der Kamera und(!) die Utilities herunter.

==Meine Kamera==
Die wie folgend beschriebene Kamera kann sich um alle drei Achsen drehen und sich in allen Ebenen bewegen. Der Drehpunkt um den sich die Kamera dreht wird mit dem Aufruf der Prozedur PositionCamera festgelegt. Sollte man diesen Drehpunkt benötigen (z.B. zum Anzeigen eines Koordinatenkreuzes, ...), so kann man auf die Property PointOfRotation zugreifen (read only).

Die Kamera kann bis zu zehn Positionen speichern und auch wiederherstellen. (SavePosition, RestorePosition)

Die Kamera kann sich selber zu jeder Zeit unter Beibehaltung der aktuellen Position senkrecht zur Welt ausrichten. (Adjust)

Um sicher zu sein, dass auch alle nötigen Definitionen und Funktionen zur Verfügung stehen, habe ich einfach mal einen Großteil meiner Funktionssammlung beigefügt ([[Kamera (3)]]). Diese Funktionen/Prozeduren werden so oder in leicht abgeänderter Form wohl bei jedem OpenGL Programmierer existieren.

Sollte es noch irgendwelche Fragen zu diesem Modul geben, so stehe ich gerne zur Verfügung.

==Gebrauch der Funktionen:==

1.
PositionCamera mit Vektoren für Position, Blickpunkt und Ausrichtung aufrufen. Die Blickrichtung gibt auch gleichzeitig den Drehpunkt der Szene an, um den dann mit RotateCamera gedreht werden kann. PositionCamera positioniert den angegebenen Blickpunkt in der Mitte des Bildschirms. PositionCamera sollte nur zur Positionierung der Kamera benutzt werden, also einmal am Anfang. Alle weiteren Kameraveränderungen sollten mit den zur Verfügung gestellten Methoden durchgeführt werden.

2.
Aufruf der Funktionen RotateCamera und TranslateCamera um die Ausrichtung/Lage der Kamera zu verändern. Um das unten angegebene Beispiel implementieren zu können, müssen folgende Variablen im aktuellen Modul definiert werden:

FMousePosX, FMousePosY,
FMousePressX, FMousePressY,
FRightMousePressed, FLeftMousePressed,
FxDelta, FyDelta, FxStart, FyStart,
FxRot und FyRot (sind alle als var im aktuellen Modul definiert)

FRightMousePressed und FLeftMousePressed müssen in der Prozedur MouseDown/MouseUp gesetzt werden.

FxRot und FyRot müssen mit 0 initialisiert werden.

<pascal>
unit Example;

interface

uses
Windows, ...

type
TFExample = class(TForm)
.
.
.
private
FCamera: TCamera;

FglDC: HDC; // device context der aktuellen komponente
FglRC: HGLRC; // rendering kontext der aktuellen komponente

ClearAlpha: GLclampd; // alpha wert der hintergrundfarbe
ClearRed: GLclampd; // rotanteil der hintergrundfarbe
ClearGreen: GLclampd; // grünanteil der hintergrundfarbe
ClearBlue: GLclampd; // blauanteil der hintergrundfarbe
public
.
.
.
published
.
.
.

var
FExample: TFExample;

FxStart, // berechnung der mausbewegungen.
FxDelta, // delta = aktuelle position minus start
FyStart, // start wird erfasst sobald eine maustaste
FyDelta:integer; // gedrückt wird.

FxRot, // umrechnung von delta in rotation wenn
FyRot:double; // drehung gewünscht ist (je nach taste)

FMousePressX, // aktuelle mausposition, wenn maustaste gedrückt wird
FMousePressY: integer;
FMousePosX, // aktuelle mausposition
FMousePosY: integer;

//mausaktivität überprüfen
FRightMousePressed:boolean; // ist die rechte maustaste gedrückt?
FLeftMousePressed:boolean; // ist die linke maustaste gedrückt?

const
crCursorMove = 1;
crCursorRotate = 2;
crCursorSelect = 3;

implementation

uses ...

{$R *.dfm}
{$R cursors.res}
</pascal>
<pascal>
procedure TFExample.FormMouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer);
begin
// mausposition merken
FMousePosX := X;
FMousePosY := Y;

//das Ziehen der Szene kann nur bei gedrückter Maustaste passieren
if not (FRightMousePressed or FLeftMousePressed) then exit;

//ausrechenen um wieviel der Mauszeiger bewegt wurde
FxDelta := FxStart-X;
FyDelta := FyStart-Y;

//Rotation anpassen, damit es nicht zu schnell wird
FxRot := FxRot - FyDelta/20;
Fyrot := FyRot - FxDelta/20;

//das naechste mal ist das hier unser startpunkt:
FxStart := X;
FyStart := Y;

if FRightMousePressed then
begin
if FxRot <> 0 then FCamera.RotateCamera (FxRot, 0, 0);
if FyRot <> 0 then FCamera.RotateCamera (0, FyRot, 0);
end;
if FLeftMousePressed then
begin
if FxRot <> 0 then FCamera.TranslateCamera (FxRot, 0, 0);
if FyRot <> 0 then FCamera.TranslateCamera (0, FyRot, 0);
end;
Paint;

FxRot := 0;
FyRot := 0;
end;
</pascal>
<pascal>
procedure TFExample.FormMouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
begin
if Button = mbRight then
begin
//rechte maustaste gedrückt
FRightMousePressed:=true;
//Startposition merken
FxStart:=X;
FyStart:=Y;
Screen.Cursor := crCursorRotate;
end
else if Button = mbLeft then
begin
//rechte maustaste gedrückt
FLeftMousePressed:=true;
//Startposition merken
FxStart:=X;
FyStart:=Y;
Screen.Cursor := crCursorMove;
end;
// aktuelle Mouseposition festhalten. so kann z.B. überprüft werden
// welches Objekt an der aktuellen Mausposition liegt
FMousePressX := X;
FMousePressY := Y;
end;
</pascal>
<pascal>
procedure TFExample.FormMouseUp(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
begin
if Button = mbRight then
begin
FRightMousePressed:=false;
end;
if Button = mbLeft then
begin
FLeftMousePressed:=false;
end;
if not (FRightMousePressed or FLeftMousePressed) then
Screen.Cursor := crCursorSelect;
end;
</pascal>
<pascal>
procedure TFExample.FormCreate(Sender: TObject);
resourcestring
ResStrRCfailed = 'CreateRenderingContext failed ';
ResStrWGLfailed = 'wglMakeCurrent failed ';
begin
inherited;

// wenn das grafiksystem von OpenGL nicht aktiviert werden kann,
// müssen wir das programm beenden
if not InitOpenGL then
begin
raise Exception.Create('InitOpenGL failed '+IntToStr(GetLastError));
halt (100);
end;

FglDC := getDC(self.WindowHandle);
FglRC := CreateRenderingContext(FglDC,
[opDoubleBuffered],
32, 24, 0,0,0,0);

if FglRC=0 then
begin
raise Exception.Create(ResStrRCfailed + IntToStr(GetLastError));
halt (100);
end;

if not wglMakeCurrent(FglDC, FglRC) then
raise Exception.Create(ResStrWGLfailed + IntToStr(GetLastError));

FxRot:=0;
FyRot:=0;

FRightMousePressed := false;
FLeftMousePressed := false;

Screen.Cursors[crCursorMove] := LoadCursor(HInstance,'MOVE');
Screen.Cursors[crCursorRotate] := LoadCursor(HInstance,'ROTATE');
Screen.Cursors[crCursorSelect] := LoadCursor(HInstance,'SELECT');
Screen.Cursor := crCursorSelect;

ClearAlpha := 1; // bildschirm immer mit weiß löschen
ClearRed:= 1; // bildschirm immer mit weiß löschen
ClearGreen:= 1; // bildschirm immer mit weiß löschen
ClearBlue:= 1; // bildschirm immer mit weiß löschen

FCamera := TCamera.Create;
end;
</pascal>

Das mit den unterschiedlichen Cursordarstellungen habe ich nur als Hinweis gelassen. Diese Anweisungen müsst Ihr rausnehmen es sei denn, dass Ihr eine Resourcendatei mit drei unterschiedlichen Cursorarten erstellt und sie unter "Cursors.res" abspeichert.

Dieses Beispiel ist vereinfacht dargestellt und es ist sehr wahrscheinlich, dass Ihr daran noch etwas herumspielen müsst. Ich habe noch das Mausrad eingesetzt um in den Bildschirm hinein- oder aus ihm herauszuzoomen (TranslateCamera(0,0,?)).
Durch modifizieren der Geschwindigkeit (+/-) für die einzelnen Achsen, die an die Prozeduren TranslateCamera und RotateCamera übergeben werden kann man entweder die Szene oder die Kamera bewegen.

3. Szene zeichnen:

Lichteigenschaften setzen

Materialeigenschaften setzen

... (die üblichen Vorbereitungen treffen)

FCamera.Apply

Szene zeichnen

wenn Terrain gewünscht:
FCamera.ApplyForTerrain
Terrain zeichnen
ende wenn

Swapbuffers...

usw.

<pascal>
procedure TFExample.Render; // wird aus der Methode Paint aufgerufen
resourcestring
RestStrWGLfailed = 'TFExample.Render: wglMakeCurrent failed with ';
begin
// da mehrere fenster möglich sind, muss immer der aktuelle
// ausgabekontext ausgewählt werden
if wglMakeCurrent(FglDC,FglRC) then
begin
glMatrixMode (GL_MODELVIEW);

glClearColor(ClearRed, ClearGreen, ClearBlue, ClearAlpha);
glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);

// View setzen

Camera1.Apply;

// Szene jetzt zeichnen

glFlush; // bearbeitung der GL-befehle beginnen
glFinish; // warten bis alle befehle ausgeführt sind

SwapBuffers(FglDC); // flackern verhindern
end
else
begin
raise Exception.Create(RestStrWGLfailed + IntToStr(GetLastError));
end;
end;
</pascal>

Den Kameracode findet ihr unter [[Kamera (2)]]. 
Die verwendete Toolsammlung findet ihr unter [[Kamera (3)]].

[[Kategorie:Anleitung]]

Kamera (1)

2006-05-21T06:30:51Z

Andyh:

==Danke==
Nachdem ich viel Zeit damit verbracht habe, eine funktionierende Kamera zu bauen und es nun endlich geschafft habe, wollte ich diese Funktionalität auch Anderen zur Verfügung stellen.
Da mir schon viel geholfen wurde, kann ich so einen Teil meiner "Schuld" zurück zahlen.

Bitte seht ab und zu mal hier nach, ob es für diese Kamera Updates gibt. Sollte es so sein, habe ich das im Code ([[Kamera (2)]]) vermerkt. Ladet in diesem Fall bitte den Source Code der Kamera und(!) die Utilities herunter.

==Meine Kamera==
Die wie folgend beschriebene Kamera kann sich um alle drei Achsen drehen und sich in allen Ebenen bewegen. Der Drehpunkt um den sich die Kamera dreht wird mit dem Aufruf der Prozedur PositionCamera festgelegt. Sollte man diesen Drehpunkt benötigen (z.B. zum Anzeigen eines Koordinatenkreuzes, ...), so kann man auf die Property PointOfRotation zugreifen (read only).

Die Kamera kann bis zu zehn Positionen speichern und auch wiederherstellen. (SavePosition, RestorePosition)

Die Kamera kann sich selber zu jeder Zeit unter Beibehaltung der aktuellen Position senkrecht zur Welt ausrichten. (Adjust)

Um sicher zu sein, dass auch alle nötigen Definitionen und Funktionen zur Verfügung stehen, habe ich einfach mal einen Großteil meiner Funktionssammlung beigefügt ([[Kamera (3)]]). Diese Funktionen/Prozeduren werden so oder in leicht abgeänderter Form wohl bei jedem OpenGL Programmierer existieren.

Sollte es noch irgendwelche Fragen zu diesem Modul geben, so stehe ich gerne zur Verfügung.

==Gebrauch der Funktionen:==

1.
PositionCamera mit Vektoren für Position, Blickpunkt und Ausrichtung aufrufen. Die Blickrichtung gibt auch gleichzeitig den Drehpunkt der Szene an, um den dann mit RotateCamera gedreht werden kann. PositionCamera positioniert den angegebenen Blickpunkt in der Mitte des Bildschirms. PositionCamera sollte nur zur Positionierung der Kamera benutzt werden, also einmal am Anfang. Alle weiteren Kameraveränderungen sollten mit den zur Verfügung gestellten Methoden durchgeführt werden.

2.
Aufruf der Funktionen RotateCamera und TranslateCamera um die Ausrichtung/Lage der Kamera zu verändern. Um das unten angegebene Beispiel implementieren zu können, müssen folgende Variablen im aktuellen Modul definiert werden:

FMousePosX, FMousePosY,
FMousePressX, FMousePressY,
FRightMousePressed, FLeftMousePressed,
FxDelta, FyDelta, FxStart, FyStart,
FxRot und FyRot (sind alle als var im aktuellen Modul definiert)

FRightMousePressed und FLeftMousePressed müssen in der Prozedur MouseDown/MouseUp gesetzt werden.

FxRot und FyRot müssen mit 0 initialisiert werden.

<pascal>
unit Example;

interface

uses
Windows, ...

type
TFExample = class(TForm)
.
.
.
private
FCamera: TCamera;

FglDC: HDC; // device context der aktuellen komponente
FglRC: HGLRC; // rendering kontext der aktuellen komponente

ClearAlpha: GLclampd; // alpha wert der hintergrundfarbe
ClearRed: GLclampd; // rotanteil der hintergrundfarbe
ClearGreen: GLclampd; // grünanteil der hintergrundfarbe
ClearBlue: GLclampd; // blauanteil der hintergrundfarbe
public
.
.
.
published
.
.
.

var
FExample: TFExample;

FxStart, // berechnung der mausbewegungen.
FxDelta, // delta = aktuelle position minus start
FyStart, // start wird erfasst sobald eine maustaste
FyDelta:integer; // gedrückt wird.

FxRot, // umrechnung von delta in rotation wenn
FyRot:double; // drehung gewünscht ist (je nach taste)

FMousePressX, // aktuelle mausposition, wenn maustaste gedrückt wird
FMousePressY: integer;
FMousePosX, // aktuelle mausposition
FMousePosY: integer;

//mausaktivität überprüfen
FRightMousePressed:boolean; // ist die rechte maustaste gedrückt?
FLeftMousePressed:boolean; // ist die linke maustaste gedrückt?

const
crCursorMove = 1;
crCursorRotate = 2;
crCursorSelect = 3;

implementation

uses ...

{$R *.dfm}
{$R cursors.res}
</pascal>
<pascal>
procedure TFExample.FormMouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer);
begin
// mausposition merken
FMousePosX := X;
FMousePosY := Y;

//das Ziehen der Szene kann nur bei gedrückter Maustaste passieren
if not (FRightMousePressed or FLeftMousePressed) then exit;

//ausrechenen um wieviel der Mauszeiger bewegt wurde
FxDelta := FxStart-X;
FyDelta := FyStart-Y;

//Rotation anpassen, damit es nicht zu schnell wird
FxRot := FxRot - FyDelta/20;
Fyrot := FyRot - FxDelta/20;

//das naechste mal ist das hier unser startpunkt:
FxStart := X;
FyStart := Y;

if FRightMousePressed then
begin
if FxRot <> 0 then FCamera.RotateCamera (FxRot, 0, 0);
if FyRot <> 0 then FCamera.RotateCamera (0, FyRot, 0);
end;
if FLeftMousePressed then
begin
if FxRot <> 0 then FCamera.TranslateCamera (FxRot, 0, 0);
if FyRot <> 0 then FCamera.TranslateCamera (0, FyRot, 0);
end;
Paint;

FxRot := 0;
FyRot := 0;
end;
</pascal>
<pascal>
procedure TFExample.FormMouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
begin
if Button = mbRight then
begin
//rechte maustaste gedrückt
FRightMousePressed:=true;
//Startposition merken
FxStart:=X;
FyStart:=Y;
Screen.Cursor := crCursorRotate;
end
else if Button = mbLeft then
begin
//rechte maustaste gedrückt
FLeftMousePressed:=true;
//Startposition merken
FxStart:=X;
FyStart:=Y;
Screen.Cursor := crCursorMove;
end;
// aktuelle Mouseposition festhalten. so kann z.B. überprüft werden
// welches Objekt an der aktuellen Mausposition liegt
FMousePressX := X;
FMousePressY := Y;
end;
</pascal>
<pascal>
procedure TFExample.FormMouseUp(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
begin
if Button = mbRight then
begin
FRightMousePressed:=false;
end;
if Button = mbLeft then
begin
FLeftMousePressed:=false;
end;
Screen.Cursor := crCursorSelect;
end;
</pascal>
<pascal>
procedure TFExample.FormCreate(Sender: TObject);
resourcestring
ResStrRCfailed = 'CreateRenderingContext failed ';
ResStrWGLfailed = 'wglMakeCurrent failed ';
begin
inherited;

// wenn das grafiksystem von OpenGL nicht aktiviert werden kann,
// müssen wir das programm beenden
if not InitOpenGL then
begin
raise Exception.Create('InitOpenGL failed '+IntToStr(GetLastError));
halt (100);
end;

FglDC := getDC(self.WindowHandle);
FglRC := CreateRenderingContext(FglDC,
[opDoubleBuffered],
32, 24, 0,0,0,0);

if FglRC=0 then
begin
raise Exception.Create(ResStrRCfailed + IntToStr(GetLastError));
halt (100);
end;

if not wglMakeCurrent(FglDC, FglRC) then
raise Exception.Create(ResStrWGLfailed + IntToStr(GetLastError));

FxRot:=0;
FyRot:=0;

FRightMousePressed := false;
FLeftMousePressed := false;

Screen.Cursors[crCursorMove] := LoadCursor(HInstance,'MOVE');
Screen.Cursors[crCursorRotate] := LoadCursor(HInstance,'ROTATE');
Screen.Cursors[crCursorSelect] := LoadCursor(HInstance,'SELECT');
Screen.Cursor := crCursorSelect;

ClearAlpha := 1; // bildschirm immer mit weiß löschen
ClearRed:= 1; // bildschirm immer mit weiß löschen
ClearGreen:= 1; // bildschirm immer mit weiß löschen
ClearBlue:= 1; // bildschirm immer mit weiß löschen

FCamera := TCamera.Create;
end;
</pascal>

Das mit den unterschiedlichen Cursordarstellungen habe ich nur als Hinweis gelassen. Diese Anweisungen müsst Ihr rausnehmen es sei denn, dass Ihr eine Resourcendatei mit drei unterschiedlichen Cursorarten erstellt und sie unter "Cursors.res" abspeichert.

Dieses Beispiel ist vereinfacht dargestellt und es ist sehr wahrscheinlich, dass Ihr daran noch etwas herumspielen müsst. Ich habe noch das Mausrad eingesetzt um in den Bildschirm hinein- oder aus ihm herauszuzoomen (TranslateCamera(0,0,?)).
Durch modifizieren der Geschwindigkeit (+/-) für die einzelnen Achsen, die an die Prozeduren TranslateCamera und RotateCamera übergeben werden kann man entweder die Szene oder die Kamera bewegen.

3. Szene zeichnen:

Lichteigenschaften setzen

Materialeigenschaften setzen

... (die üblichen Vorbereitungen treffen)

FCamera.Apply

Szene zeichnen

wenn Terrain gewünscht:
FCamera.ApplyForTerrain
Terrain zeichnen
ende wenn

Swapbuffers...

usw.

<pascal>
procedure TFExample.Render; // wird aus der Methode Paint aufgerufen
resourcestring
RestStrWGLfailed = 'TFExample.Render: wglMakeCurrent failed with ';
begin
// da mehrere fenster möglich sind, muss immer der aktuelle
// ausgabekontext ausgewählt werden
if wglMakeCurrent(FglDC,FglRC) then
begin
glMatrixMode (GL_MODELVIEW);

glClearColor(ClearRed, ClearGreen, ClearBlue, ClearAlpha);
glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);

// View setzen

Camera1.Apply;

// Szene jetzt zeichnen

glFlush; // bearbeitung der GL-befehle beginnen
glFinish; // warten bis alle befehle ausgeführt sind

SwapBuffers(FglDC); // flackern verhindern
end
else
begin
raise Exception.Create(RestStrWGLfailed + IntToStr(GetLastError));
end;
end;
</pascal>

Den Kameracode findet ihr unter [[Kamera (2)]]. 
Die verwendete Toolsammlung findet ihr unter [[Kamera (3)]].

[[Kategorie:Anleitung]]

Kamera (1)

2006-05-21T06:27:35Z

Andyh:

==Danke==
Nachdem ich viel Zeit damit verbracht habe, eine funktionierende Kamera zu bauen und es nun endlich geschafft habe, wollte ich diese Funktionalität auch Anderen zur Verfügung stellen.
Da mir schon viel geholfen wurde, kann ich so einen Teil meiner "Schuld" zurück zahlen.

Bitte seht ab und zu mal hier nach, ob es für diese Kamera Updates gibt. Sollte es so sein, habe ich das im Code ([[Kamera (2)]]) vermerkt. Ladet in diesem Fall bitte den Source Code der Kamera und(!) die Utilities herunter.

==Meine Kamera==
Die wie folgend beschriebene Kamera kann sich um alle drei Achsen drehen und sich in allen Ebenen bewegen. Der Drehpunkt um den sich die Kamera dreht wird mit dem Aufruf der Prozedur PositionCamera festgelegt. Sollte man diesen Drehpunkt benötigen (z.B. zum Anzeigen eines Koordinatenkreuzes, ...), so kann man auf die Property PointOfRotation zugreifen (read only).

Die Kamera kann bis zu zehn Positionen speichern und auch wiederherstellen. (SavePosition, RestorePosition)

Die Kamera kann sich selber zu jeder Zeit unter Beibehaltung der aktuellen Position senkrecht zur Welt ausrichten. (Adjust)

Um sicher zu sein, dass auch alle nötigen Definitionen und Funktionen zur Verfügung stehen, habe ich einfach mal einen Großteil meiner Funktionssammlung beigefügt ([[Kamera (3)]]). Diese Funktionen/Prozeduren werden so oder in leicht abgeänderter Form wohl bei jedem OpenGL Programmierer existieren.

Sollte es noch irgendwelche Fragen zu diesem Modul geben, so stehe ich gerne zur Verfügung.

==Gebrauch der Funktionen:==

1.
PositionCamera mit Vektoren für Position, Blickpunkt und Ausrichtung aufrufen. Die Blickrichtung gibt auch gleichzeitig den Drehpunkt der Szene an, um den dann mit RotateCamera gedreht werden kann. PositionCamera positioniert den angegebenen Blickpunkt in der Mitte des Bildschirms. PositionCamera sollte nur zur Positionierung der Kamera benutzt werden, also einmal am Anfang. Alle weiteren Kameraveränderungen sollten mit den zur Verfügung gestellten Methoden durchgeführt werden.

2.
Aufruf der Funktionen RotateCamera und TranslateCamera um die Ausrichtung/Lage der Kamera zu verändern. Um das unten angegebene Beispiel implementieren zu können, müssen folgende Variablen im aktuellen Modul definiert werden:

FMousePosX, FMousePosY,
FMousePressX, FMousePressY,
FRightMousePressed, FLeftMousePressed,
FxDelta, FyDelta, FxStart, FyStart,
FxRot und FyRot (sind alle als var im aktuellen Modul definiert)

FRightMousePressed und FLeftMousePressed müssen in der Prozedur MouseDown/MouseUp gesetzt werden.

FxRot und FyRot müssen mit 0 initialisiert werden.

<pascal>
unit Example;

interface

uses
Windows, ...

type
TFExample = class(TForm)
.
.
.
private
FCamera: TCamera;

FglDC: HDC; // device context der aktuellen komponente
FglRC: HGLRC; // rendering kontext der aktuellen komponente

ClearAlpha: GLclampd; // alpha wert der hintergrundfarbe
ClearRed: GLclampd; // rotanteil der hintergrundfarbe
ClearGreen: GLclampd; // grünanteil der hintergrundfarbe
ClearBlue: GLclampd; // blauanteil der hintergrundfarbe
public
.
.
.
published
.
.
.

var
FExample: TFExample;

FxStart, // berechnung der mausbewegungen.
FxDelta, // delta = aktuelle position minus start
FyStart, // start wird erfasst sobald eine maustaste
FyDelta:integer; // gedrückt wird.

FxRot, // umrechnung von delta in rotation wenn
FyRot:double; // drehung gewünscht ist (je nach taste)

FMousePressX, // aktuelle mausposition, wenn maustaste gedrückt wird
FMousePressY: integer;
FMousePosX, // aktuelle mausposition
FMousePosY: integer;

//mausaktivität überprüfen
FRightMousePressed:boolean; // ist die rechte maustaste gedrückt?
FLeftMousePressed:boolean; // ist die linke maustaste gedrückt?

const
crCursorMove = 1;
crCursorRotate = 2;
crCursorSelect = 3;

implementation

uses ...

{$R *.dfm}
{$R cursors.res}
</pascal>
<pascal>
procedure TFExample.FormMouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer);
begin
// mausposition merken
FMousePosX := X;
FMousePosY := Y;

//das Ziehen der Szene kann nur bei gedrückter Maustaste passieren
if not (FRightMousePressed or FLeftMousePressed) then exit;

//ausrechenen um wieviel der Mauszeiger bewegt wurde
FxDelta := FxStart-X;
FyDelta := FyStart-Y;

//Rotation anpassen, damit es nicht zu schnell wird
FxRot := FxRot - FyDelta/20;
Fyrot := FyRot - FxDelta/20;

//das naechste mal ist das hier unser startpunkt:
FxStart := X;
FyStart := Y;

if FRightMousePressed then
begin
if FxRot <> 0 then FCamera.RotateCamera (FxRot, 0, 0);
if FyRot <> 0 then FCamera.RotateCamera (0, FyRot, 0);
end;
if FLeftMousePressed then
begin
if FxRot <> 0 then FCamera.TranslateCamera (FxRot, 0, 0);
if FyRot <> 0 then FCamera.TranslateCamera (0, FyRot, 0);
end;
Paint;

FxRot := 0;
FyRot := 0;
end;
</pascal>
<pascal>
procedure TFExample.FormMouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
begin
if Button = mbRight then
begin
//rechte maustaste gedrückt
FRightMousePressed:=true;
//Startposition merken
FxStart:=X;
FyStart:=Y;
Screen.Cursor := crCursorRotate;
end
else if Button = mbLeft then
begin
//rechte maustaste gedrückt
FLeftMousePressed:=true;
//Startposition merken
FxStart:=X;
FyStart:=Y;
Screen.Cursor := crCursorMove;
end;
// aktuelle Mouseposition festhalten. so kann z.B. überprüft werden
// welches Objekt an der aktuellen Mausposition liegt
FMousePressX := X;
FMousePressY := Y;
end;
</pascal>
<pascal>
procedure TFExample.FormMouseUp(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
begin
if Button = mbRight then
begin
FRightMousePressed:=false;
end;
if Button = mbLeft then
begin
FLeftMousePressed:=false;
end;
Screen.Cursor := crCursorSelect;
end;
</pascal>
<pascal>
procedure TFExample.FormCreate(Sender: TObject);
resourcestring
ResStrRCfailed = 'CreateRenderingContext failed ';
ResStrWGLfailed = 'wglMakeCurrent failed ';
begin
inherited;

// wenn das grafiksystem von OpenGL nicht aktiviert werden kann,
// müssen wir das programm beenden
if not InitOpenGL then
begin
raise Exception.Create('InitOpenGL failed '+IntToStr(GetLastError));
halt (100);
end;

FglDC := getDC(self.WindowHandle);
FglRC := CreateRenderingContext(FglDC,
[opDoubleBuffered],
32, 24, 0,0,0,0);

if FglRC=0 then
begin
raise Exception.Create(ResStrRCfailed + IntToStr(GetLastError));
halt (100);
end;

if not wglMakeCurrent(FglDC, FglRC) then
raise Exception.Create(ResStrWGLfailed + IntToStr(GetLastError));

FxRot:=0;
FyRot:=0;

FRightMousePressed := false;
FLeftMousePressed := false;

Screen.Cursors[crCursorMove] := LoadCursor(HInstance,'MOVE');
Screen.Cursors[crCursorRotate] := LoadCursor(HInstance,'ROTATE');
Screen.Cursors[crCursorSelect] := LoadCursor(HInstance,'SELECT');
Screen.Cursor := crCursorSelect;

ClearAlpha := 1; // bildschirm immer mit weiß löschen
ClearRed:= 1; // bildschirm immer mit weiß löschen
ClearGreen:= 1; // bildschirm immer mit weiß löschen
ClearBlue:= 1; // bildschirm immer mit weiß löschen

FCamera := TCamera.Create;
end;
</pascal>

Das mit den unterschiedlichen Cursordarstellungen habe ich nur als Hinweis gelassen. Diese Anweisungen müsst Ihr rausnehmen es sei denn, dass Ihr eine Resourcendatei mit drei unterschiedlichen Cursorarten erstellt und sie unter "Cursors.res" abspeichert.

Dieses Beispiel ist vereinfacht dargestellt und es ist sehr wahrscheinlich, dass Ihr daran noch etwas herumspielen müsst. Ich habe noch das Mausrad eingesetzt um in den Bildschirm hinein- oder aus ihm herauszuzoomen (TranslateCamera(0,0,?)).
Durch modifizieren der Geschwindigkeit (+/-) für die einzelnen Achsen, die an die Prozeduren TranslateCamera und RotateCamera übergeben werden kann man entweder die Szene oder die Kamera bewegen.

3. Szene zeichnen:

Lichteigenschaften setzen

Materialeigenschaften setzen

... (die üblichen Vorbereitungen treffen)

FCamera.Apply

Szene zeichnen

wenn Terrain gewünscht:
FCamera.ApplyForTerrain
Terrain zeichnen
ende wenn

Swapbuffers...

usw.

<pascal>
procedure TFExample.Render; // wird aus der Methode Paint aufgerufen
resourcestring
RestStrWGLfailed = 'TFKanal3D.Render: wglMakeCurrent failed with ';
var
pDir: TGKvector;
begin
// da mehrere fenster möglich sind, muss immer der aktuelle
// ausgabekontext ausgewählt werden
if wglMakeCurrent(FglDC,FglRC) then
begin
glMatrixMode (GL_MODELVIEW);

glClearColor(ClearRed, ClearGreen, ClearBlue, ClearAlpha);
glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);

// View setzen

Camera1.Apply;

// Szene jetzt zeichnen

glFlush; // bearbeitung der GL-befehle beginnen
glFinish; // warten bis alle befehle ausgeführt sind

SwapBuffers(FglDC); // flackern verhindern
end
else
begin
raise Exception.Create(RestStrWGLfailed + IntToStr(GetLastError));
end;
end;
</pascal>

Den Kameracode findet ihr unter [[Kamera (2)]]. 
Die verwendete Toolsammlung findet ihr unter [[Kamera (3)]].

[[Kategorie:Anleitung]]

Kamera (1)

2006-05-21T06:06:19Z

Andyh:

==Danke==
Nachdem ich viel Zeit damit verbracht habe, eine funktionierende Kamera zu bauen und es nun endlich geschafft habe, wollte ich diese Funktionalität auch Anderen zur Verfügung stellen.
Da mir schon viel geholfen wurde, kann ich so einen Teil meiner "Schuld" zurück zahlen.

Bitte seht ab und zu mal hier nach, ob es für diese Kamera Updates gibt. Sollte es so sein, habe ich das im Code ([[Kamera (2)]]) vermerkt. Ladet in diesem Fall bitte den Source Code der Kamera und(!) die Utilities herunter.

==Meine Kamera==
Die wie folgend beschriebene Kamera kann sich um alle drei Achsen drehen und sich in allen Ebenen bewegen. Der Drehpunkt um den sich die Kamera dreht wird mit dem Aufruf der Prozedur PositionCamera festgelegt. Sollte man diesen Drehpunkt benötigen (z.B. zum Anzeigen eines Koordinatenkreuzes, ...), so kann man auf die Property PointOfRotation zugreifen (read only).

Die Kamera kann bis zu zehn Positionen speichern und auch wiederherstellen. (SavePosition, RestorePosition)

Die Kamera kann sich selber zu jeder Zeit unter Beibehaltung der aktuellen Position senkrecht zur Welt ausrichten. (Adjust)

Um sicher zu sein, dass auch alle nötigen Definitionen und Funktionen zur Verfügung stehen, habe ich einfach mal einen Großteil meiner Funktionssammlung beigefügt ([[Kamera (3)]]). Diese Funktionen/Prozeduren werden so oder in leicht abgeänderter Form wohl bei jedem OpenGL Programmierer existieren.

Sollte es noch irgendwelche Fragen zu diesem Modul geben, so stehe ich gerne zur Verfügung.

==Gebrauch der Funktionen:==

1.
PositionCamera mit Vektoren für Position, Blickpunkt und Ausrichtung aufrufen. Die Blickrichtung gibt auch gleichzeitig den Drehpunkt der Szene an, um den dann mit RotateCamera gedreht werden kann. PositionCamera positioniert den angegebenen Blickpunkt in der Mitte des Bildschirms. PositionCamera sollte nur zur Positionierung der Kamera benutzt werden, also einmal am Anfang. Alle weiteren Kameraveränderungen sollten mit den zur Verfügung gestellten Methoden durchgeführt werden.

2.
Aufruf der Funktionen RotateCamera und TranslateCamera um die Ausrichtung/Lage der Kamera zu verändern. Um das unten angegebene Beispiel implementieren zu können, müssen folgende Variablen im aktuellen Modul definiert werden:

FMousePosX, FMousePosY,
FMousePressX, FMousePressY,
FRightMousePressed, FLeftMousePressed,
FxDelta, FyDelta, FxStart, FyStart,
FxRot und FyRot (sind alle als var im aktuellen Modul definiert)

FRightMousePressed und FLeftMousePressed müssen in der Prozedur MouseDown/MouseUp gesetzt werden.

FxRot und FyRot müssen mit 0 initialisiert werden.

<pascal>
unit Example;

interface

uses
Windows, ...

type
TFExample = class(TForm)
.
.
.
private
.
.
.
public
.
.
.
published
.
.
.

var
FExample: TFExample;

FxStart, // berechnung der mausbewegungen.
FxDelta, // delta = aktuelle position minus start
FyStart, // start wird erfasst sobald eine maustaste
FyDelta:integer; // gedrückt wird.

FxRot, // umrechnung von delta in rotation wenn
FyRot:double; // drehung gewünscht ist (je nach taste)

FMousePressX, // aktuelle mausposition, wenn maustaste gedrückt wird
FMousePressY: integer;
FMousePosX, // aktuelle mausposition
FMousePosY: integer;

//mausaktivität überprüfen
FRightMousePressed:boolean; // ist die rechte maustaste gedrückt?
FLeftMousePressed:boolean; // ist die linke maustaste gedrückt?

const
crCursorMove = 1;
crCursorRotate = 2;
crCursorSelect = 3;

implementation

uses ...

{$R *.dfm}
{$R cursors.res}
</pascal>
<pascal>
procedure TFExample.FormMouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer);
begin
// mausposition merken
FMousePosX := X;
FMousePosY := Y;

//das Ziehen der Szene kann nur bei gedrückter Maustaste passieren
if not (FRightMousePressed or FLeftMousePressed) then exit;

//ausrechenen um wieviel der Mauszeiger bewegt wurde
FxDelta := FxStart-X;
FyDelta := FyStart-Y;

//Rotation anpassen, damit es nicht zu schnell wird
FxRot := FxRot - FyDelta/20;
Fyrot := FyRot - FxDelta/20;

//das naechste mal ist das hier unser startpunkt:
FxStart := X;
FyStart := Y;

if FRightMousePressed then
begin
if FxRot <> 0 then FCamera.RotateCamera (FxRot, 0, 0);
if FyRot <> 0 then FCamera.RotateCamera (0, FyRot, 0);
end;
if FLeftMousePressed then
begin
if FxRot <> 0 then FCamera.TranslateCamera (FxRot, 0, 0);
if FyRot <> 0 then FCamera.TranslateCamera (0, FyRot, 0);
end;
Paint;

FxRot := 0;
FyRot := 0;
end;
</pascal>
<pascal>
procedure TFExample.FormMouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
begin
if Button = mbRight then
begin
//rechte maustaste gedrückt
FRightMousePressed:=true;
//Startposition merken
FxStart:=X;
FyStart:=Y;
Screen.Cursor := crCursorRotate;
end
else if Button = mbLeft then
begin
//rechte maustaste gedrückt
FLeftMousePressed:=true;
//Startposition merken
FxStart:=X;
FyStart:=Y;
Screen.Cursor := crCursorMove;
end;
// aktuelle Mouseposition festhalten. so kann z.B. überprüft werden
// welches Objekt an der aktuellen Mausposition liegt
FMousePressX := X;
FMousePressY := Y;
end;
</pascal>
<pascal>
procedure TFExample.FormMouseUp(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
begin
if Button = mbRight then
begin
FRightMousePressed:=false;
end;
if Button = mbLeft then
begin
FLeftMousePressed:=false;
end;
Screen.Cursor := crCursorSelect;
end;
</pascal>
<pascal>
procedure TFExample.FormCreate(Sender: TObject);
begin
inherited;

FxRot:=0;
FyRot:=0;

FRightMousePressed := false;
FLeftMousePressed := false;

Screen.Cursors[crCursorMove] := LoadCursor(HInstance,'MOVE');
Screen.Cursors[crCursorRotate] := LoadCursor(HInstance,'ROTATE');
Screen.Cursors[crCursorSelect] := LoadCursor(HInstance,'SELECT');
Screen.Cursor := crCursorSelect;
end;
</pascal>

Das mit den unterschiedlichen Cursordarstellungen habe ich nur als Hinweis gelassen. Diese Anweisungen müsst Ihr rausnehmen es sei denn, dass Ihr eine Resourcendatei mit drei unterschiedlichen Cursorarten erstellt und sie unter "Cursors.res" abspeichert.

Dieses Beispiel ist vereinfacht dargestellt und es ist sehr wahrscheinlich, dass Ihr daran noch etwas herumspielen müsst. Ich habe noch das Mausrad eingesetzt um in den Bildschirm hinein- oder aus ihm herauszuzoomen (TranslateCamera(0,0,?)).
Durch modifizieren der Geschwindigkeit (+/-) für die einzelnen Achsen, die an die Prozeduren TranslateCamera und RotateCamera übergeben werden kann man entweder die Szene oder die Kamera bewegen.

3. Szene zeichnen:

Lichteigenschaften setzen

Materialeigenschaften setzen

... (die üblichen Vorbereitungen treffen)

FCamera.Apply

Szene zeichnen

wenn Terrain gewünscht:
FCamera.ApplyForTerrain
Terrain zeichnen
ende wenn

Swapbuffers...

usw.

Den Kameracode findet ihr unter [[Kamera (2)]]. 
Die verwendete Toolsammlung findet ihr unter [[Kamera (3)]].

[[Kategorie:Anleitung]]

Kamera (1)

2006-05-21T06:00:06Z

Andyh:

==Danke==
Nachdem ich viel Zeit damit verbracht habe, eine funktionierende Kamera zu bauen und es nun endlich geschafft habe, wollte ich diese Funktionalität auch Anderen zur Verfügung stellen.
Da mir schon viel geholfen wurde, kann ich so einen Teil meiner "Schuld" zurück zahlen.

Bitte seht ab und zu mal hier nach, ob es für diese Kamera Updates gibt. Sollte es so sein, habe ich das im Code ([[Kamera (2)]]) vermerkt. Ladet in diesem Fall bitte den Source Code der Kamera und(!) die Utilities herunter.

==Meine Kamera==
Die wie folgend beschriebene Kamera kann sich um alle drei Achsen drehen und sich in allen Ebenen bewegen. Der Drehpunkt um den sich die Kamera dreht wird mit dem Aufruf der Prozedur PositionCamera festgelegt. Sollte man diesen Drehpunkt benötigen (z.B. zum Anzeigen eines Koordinatenkreuzes, ...), so kann man auf die Property PointOfRotation zugreifen (read only).

Die Kamera kann bis zu zehn Positionen speichern und auch wiederherstellen. (SavePosition, RestorePosition)

Die Kamera kann sich selber zu jeder Zeit unter Beibehaltung der aktuellen Position senkrecht zur Welt ausrichten. (Adjust)

Um sicher zu sein, dass auch alle nötigen Definitionen und Funktionen zur Verfügung stehen, habe ich einfach mal einen Großteil meiner Funktionssammlung beigefügt ([[Kamera (3)]]). Diese Funktionen/Prozeduren werden so oder in leicht abgeänderter Form wohl bei jedem OpenGL Programmierer existieren.

Sollte es noch irgendwelche Fragen zu diesem Modul geben, so stehe ich gerne zur Verfügung.

==Gebrauch der Funktionen:==

1.
PositionCamera mit Vektoren für Position, Blickpunkt und Ausrichtung aufrufen. Die Blickrichtung gibt auch gleichzeitig den Drehpunkt der Szene an, um den dann mit RotateCamera gedreht werden kann. PositionCamera positioniert den angegebenen Blickpunkt in der Mitte des Bildschirms. PositionCamera sollte nur zur Positionierung der Kamera benutzt werden, also einmal am Anfang. Alle weiteren Kameraveränderungen sollten mit den zur Verfügung gestellten Methoden durchgeführt werden.

2.
Aufruf der Funktionen RotateCamera und TranslateCamera um die Ausrichtung/Lage der Kamera zu verändern. Um das unten angegebene Beispiel implementieren zu können, müssen folgende Variablen im aktuellen Modul definiert werden:

FMousePosX, FMousePosY,
FMousePressX, FMousePressY,
FRightMousePressed, FLeftMousePressed,
FxDelta, FyDelta, FxStart, FyStart,
FxRot und FyRot (sind alle als var im aktuellen Modul definiert)

FRightMousePressed und FLeftMousePressed müssen in der Prozedur MouseDown/MouseUp gesetzt werden.

FxRot und FyRot müssen mit 0 initialisiert werden.

<pascal>
unit Example;

interface

uses
Windows, ...

type
TFExample = class(TForm)
.
.
.
private
.
.
.
public
.
.
.
published
.
.
.

var
FExample: TFExample;

FxStart, // berechnung der mausbewegungen.
FxDelta, // delta = aktuelle position minus start
FyStart, // start wird erfasst sobald eine maustaste
FyDelta:integer; // gedrückt wird.

FxRot, // umrechnung von delta in rotation wenn
FyRot:double; // drehung gewünscht ist (je nach taste)

FMousePressX, // aktuelle mausposition, wenn maustaste gedrückt wird
FMousePressY: integer;
FMousePosX, // aktuelle mausposition
FMousePosY: integer;

//mausaktivität überprüfen
FRightMousePressed:boolean; // ist die rechte maustaste gedrückt?
FLeftMousePressed:boolean; // ist die linke maustaste gedrückt?

const
crCursorMove = 1;
crCursorRotate = 2;
crCursorSelect = 3;

implementation

uses ...

{$R *.dfm}
{$R cursors.res}
</pascal>
<pascal>
procedure TFExample.FormMouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer);
begin
// mausposition merken
FMousePosX := X;
FMousePosY := Y;

//das Ziehen der Szene kann nur bei gedrückter Maustaste passieren
if not (FRightMousePressed or FLeftMousePressed) then exit;

//ausrechenen um wieviel der Mauszeiger bewegt wurde
FxDelta := FxStart-X;
FyDelta := FyStart-Y;

//Rotation anpassen, damit es nicht zu schnell wird
FxRot := FxRot - FyDelta/20;
Fyrot := FyRot - FxDelta/20;

//das naechste mal ist das hier unser startpunkt:
FxStart := X;
FyStart := Y;

if FRightMousePressed then
begin
if FxRot <> 0 then FCamera.RotateCamera (FxRot, 0, 0);
if FyRot <> 0 then FCamera.RotateCamera (0, FyRot, 0);
end;
if FLeftMousePressed then
begin
if FxRot <> 0 then FCamera.TranslateCamera (FxRot, 0, 0);
if FyRot <> 0 then FCamera.TranslateCamera (0, FyRot, 0);
end;
Paint;

FxRot := 0;
FyRot := 0;
end;
</pascal>
<pascal>
procedure TFExample.FormMouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
begin
if Button = mbRight then
begin
//rechte maustaste gedrückt
FRightMousePressed:=true;
//Startposition merken
FxStart:=X;
FyStart:=Y;
Screen.Cursor := crCursorRotate;
end
else if Button = mbLeft then
begin
//rechte maustaste gedrückt
FLeftMousePressed:=true;
//Startposition merken
FxStart:=X;
FyStart:=Y;
Screen.Cursor := crCursorMove;
end;
// aktuelle Mouseposition festhalten. so kann z.B. überprüft werden
// welches Objekt an der aktuellen Mausposition liegt
FMousePressX := X;
FMousePressY := Y;
end;
</pascal>
<pascal>
procedure TFExample.FormMouseUp(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
begin
if Button = mbRight then
begin
FRightMousePressed:=false;
end;
if Button = mbLeft then
begin
FLeftMousePressed:=false;
end;
Screen.Cursor := crCursorSelect;
end;
</pascal>
<pascal>
procedure TFExample.FormCreate(Sender: TObject);
begin
inherited;

FxRot:=0;
FyRot:=0;

FRightMousePressed := false;
FLeftMousePressed := false;

Screen.Cursors[crCursorMove] := LoadCursor(HInstance,'MOVE');
Screen.Cursors[crCursorRotate] := LoadCursor(HInstance,'ROTATE');
Screen.Cursors[crCursorSelect] := LoadCursor(HInstance,'SELECT');
Screen.Cursor := crCursorSelect;
end;
</pascal>

Das mit den unterschiedlichen Cursordarstellungen habe ich nur als Hinweis gelassen. Diese Anweisungen müsst Ihr rausnehemen es sei denn, dass Ihr eine Resourcendatei mit drei unterschiedlichen Cursorarten erstellt und sie unter "Cursors.res" abspeichert.

Dieses Beispiel ist vereinfacht dargestellt und es kann sein, dass man daran noch etwas herumspielen muss. Ich habe noch das Mausrad eingesetzt um in den Bildschirm hinein- oder aus ihm herauszuzoomen (TranslateCamera(0,0,?)).
Durch modifizieren der Geschwindigkeit (+/-) für die einzelnen Achsen, die an die Prozeduren TranslateCamera und RotateCamera übergeben werden kann man entweder die Szene oder die Kamera bewegen.

3. Szene zeichnen:

Lichteigenschaften setzen

Materialeigenschaften setzen

... (die üblichen Vorbereitungen treffen)

FCamera.Apply

Szene zeichnen

wenn Terrain gewünscht:
FCamera.ApplyForTerrain
Terrain zeichnen
ende wenn

Swapbuffers...

usw.

Den Kameracode findet ihr unter [[Kamera (2)]]. 
Die verwendete Toolsammlung findet ihr unter [[Kamera (3)]].

[[Kategorie:Anleitung]]

Kamera (1)

2006-05-21T05:52:23Z

Andyh:

Kamera (1)

2006-05-21T05:47:55Z

Andyh:

Kamera (1)

2006-05-21T05:41:04Z

Andyh:

Kamera (1)

2006-05-21T05:36:08Z

Andyh:

Kamera (1)

2006-05-21T05:35:22Z

Andyh:

Diskussion:Detail Mapping

2006-02-08T07:49:39Z

Andyh:

Hallo,

ich versuche schon seit ein paar Tagen, meine Texturen mit Detailmapping zu verfeinern. Vom Prinzip her ist mir auch schon klar wie es geht, aber es hapert noch an ein paar Kleinigkeiten. Der hier verfügbare Artikel hat mir auch schon weitergeholfen aber einiges ist mir am dargestellten Beispiel nicht ganz klar:

<pascal>
// Alle Schnittpunkte des Objektes renderm
for v := 0 to High(VertexData) do // wo kommt VertexData her? ist das OpenGL?
begin // ----------------------------------------
// ...

// Texturkoordinate für die Detailtextur
glMultiTexCoord2f(GL_TEXTURE1, Vertex[v].s*16, Vertex[v].t*16); // das gleiche mit Vertex.
// Texturkoordinate für die Basistextur // woher kommt diese Array?
glMultiTexCoord2f(GL_TEXTURE0, Vertex[v].s, Vertex[v].t); // ------------------------

// ...
end;
</pascal>

Für eine Auflösung meines Knotens wäre ich sehr dankbar,

Andy

----

Fragen ins Forum

Ansonsten soviel:

*VertexData = zu rendernde Daten (soweit ich das sehe)
*Vertex = Texturkoordinaten (wenn ich das richtig interpretiere)

Ansonsten schau doch einfach mal in die Doku der verwendeten Befehle ...

MfG,
--[[Benutzer:BenBE|BenBE]] 13:54, 5. Feb 2006 (CET)

-------------------------------------
Sorry, werde ich das nächste mal tun (Fragen in´s Forum).

Vielen Dank für die Antwort,

Andy

Diskussion:Detail Mapping

2006-02-03T07:49:16Z

Andyh:

Diskussion:Detail Mapping

2006-02-03T07:48:16Z

Andyh:

Diskussion:Detail Mapping

2006-02-03T07:46:53Z

Andyh:

Kamera (1)

2006-01-19T08:09:27Z

Andyh:

Kamera

2006-01-19T08:05:47Z

Andyh:

Kamera (3)

2006-01-08T07:05:44Z

Andyh:

Eine Beschreibung findet ihr unter [[Kamera (1)]]. 
Den Kameracode findet ihr unter [[Kamera (2)]].

Ich habe einfach alle Funktionen meiner Toolsammlung hierhin kopiert. Ich wollte jetzt nicht offline etwas weglöschen was vielleicht benötigt wird. Ihr findet also hier einen ganzen Wust von Funktionen, der zum Betrieb der Kamera nicht benötigt wird. Vielleicht könnt Ihr das eine oder andere aber brauchen...

<pascal>
unit OpenGLUtil;

interface

uses DglOpenGL, Math, Windows, Graphics, SysUtils, Dialogs, glBmp;

type
TProjection=(Frustum, Orthographic, Perspective);

TGLPlace=packed record
X,Y,Z: glFloat;
end;

TScale=packed record
X,Y,Z: glFloat;
end;

TGLPosition=packed record
X,Y,Z,W: glFloat;
end;

TPosition = packed record
X,Y,Z,W: GLdouble;
end;

TGLVector = packed record
X,Y,Z: GLfloat;
end;
TGLVectorArray = array of TGLvector;
TGLfloatArray = array of TGLfloat;

TGKVector = packed record
X,Y,Z: GLfloat;
end;

TAngle = packed record
X,Y,Z: GLdouble;
end;

TGLColor=record
red,green,blue,alpha: GLclampf;
end;

TRotation = packed record
angle, x, y, z: GLfloat;
end;

TTextureInfo = packed record
BitmapName: string;
TextureNum: GLUint;
theBmp: TGLbmp;
end;
TTextureList = array of TTextureInfo;

TMatrix = array [0..3,0..3] of TGLFloat;
TArrMatrix = array [0..15] of TGLFloat;
TFrustum = array [0..5,0..3] of TGLFloat;
TArrVector = array [0..3] of TGLFloat;

function GetMatrixX (matrix: TArrMatrix): TGLvector;
function GetMatrixY (matrix: TArrMatrix): TGLvector;
function GetMatrixZ (matrix: TArrMatrix): TGLvector;
function GetMatrixPos (matrix: TArrMatrix): TGLvector;
procedure SetMatrixX (var matrix: TArrMatrix; v: TGLvector);
procedure SetMatrixY (var matrix: TArrMatrix; v: TGLvector);
procedure SetMatrixZ (var matrix: TArrMatrix; v: TGLvector);
procedure SetMatrixPos (var matrix: TArrMatrix; v: TGLvector);
function Multiply (Color: TGLcolor; m: TGLdouble): TGLcolor;overload;
function Multiply (V1, V2: TGLVector): TGLVector;overload;
function Multiply (M1, M2: TArrMatrix): TArrMatrix;overload;
function Divide (V1, V2: TGLVector): TGLVector;overload;
function Divide (V1: TGLVector; d: TGLdouble): TGLVector;overload;
function MakeVector(X,Y,Z:TGLFloat):TArrVector;overload;
function MakeVector(X,Y,Z,W:TGLFloat):TArrVector;overload;
procedure Normalize(aVector:TArrVector;var RVec:TArrVector);overload;
procedure Normalize(aVector:TGLVector;var RVec:TGLVector);overload;
function GetIdentity(Matrix:TMatrix):TMatrix;overload;
function GetIdentity(Matrix:TArrMatrix):TArrMatrix;overload;
function MatrixTranspose(const M:TMatrix):TMatrix;register;
function VectorRotateX(v:TArrVector;a:TGLFloat):TArrVector;overload;
function VectorRotateY(v:TArrVector;a:TGLFloat):TArrVector;overload;
function VectorRotateZ(v:TArrVector;a:TGLFloat):TArrVector;overload;
function VectorRotateX(v:TGLVector;a:TGLFloat):TGLVector;overload;
function VectorRotateY(v:TGLVector;a:TGLFloat):TGLVector;overload;
function VectorRotateZ(v:TGLVector;a:TGLFloat):TGLVector;overload;

function GL2GKVector (V: TGLVector): TGKVector;
function GK2GLVector (V: TGKVector): TGLVector;
function GL2WinColor (GLcol: TGLcolor): TColor;
function Win2GLColor (WinCol: Tcolor): TGLcolor;
function CalcNormale (V1, V2, V3: TGLVector): TGLVector;
function CrossProduct(V1, V2: TGLVector): TGLVector;
function DotProduct (V1, V2: TGLVector): GLdouble;
function LoadTexture(Filename: String; var Texture: GLuint): Boolean;
function Magnitude(V1 : TGLVector) : GLdouble;
function ScalarProduct (V1, V2: TGLVector): GLdouble;
function SubtractVector (Vec1, Vec2: TGLVector): TGLVector;overload;
function SubtractVector (Vec: TGLVector; X, Y, Z: TGLdouble): TGLVector;overload;
function AddVector (Vec1, Vec2: TGLVector): TGLVector;overload;
function AddVector (Vec: TGLVector; X, Y, Z: TGLdouble): TGLVector;overload;
function ForceForegroundWindow(hwnd: THandle): Boolean;
procedure InitGLEnv (dc: HDC; rc: HGLRC; hndl: THandle);// pixelformat setzen
procedure CopyVector (FromVektor: TGLVector; var ToVektor: TGLVector);
procedure InitVector (var V1: TGLVector; x, y, z: TGLdouble);overload;
procedure InitVector (var V1: TGKVector; x, y, z: TGLdouble);overload;
procedure InitVector (var V1: TArrVector; x, y, z: TGLdouble);overload;
procedure InitScale (var S1: TScale; x, y, z: TGLdouble);
procedure LoadBitmap(Filename: String;
out Width: Cardinal;
out Height: Cardinal;
out pData: Pointer);
procedure GetRotation (V1, V2: TGLVector;
var Rotation: TRotation);
function MakeTextureFromBitmap (Bitmap: string; var BitmapList: TTextureList): GLenum;
procedure EnableTexture (Texture: GLenum; TextureTiled: boolean);
procedure DisableTexture;
function TextToGLVector (VTxt: string): TGLVector;
function TextToGKVector (VTxt: string): TGKVector;
function GKVectorToText (V1: TGKVector): string;overload;
function GKVectorToText (V1: TGKVector; digits: byte): string;overload;
function GLVectorToText (V1: TGLVector): string;overload;
function GLVectorToText (V1: TGLVector; digits: byte): string;overload;
function MyCone (Start, Ende: TGLVector;
RadiusStart, RadiusEnde: TGLfloat;
Slices: Integer): boolean;
function InvertMatrix (src: TArrMatrix; var inverse: TArrMatrix): boolean;

const
C_X = 0;
C_Y = 1;
C_Z = 2;
C_W = 3;
C_EPS:TGLFloat=0.01;
C_DEGTORAD:TGLFloat=3.1412/180;
C_RADTODEG:TGLFloat=180/3.1412;
C_LAMBDA_INCREMENT:TGLFloat=0.01;

implementation

uses Forms, KanalUtil, OGLinclude, Controls;

function MyPower (Base: extended; Exp: integer): extended;
begin
result := Base * Base;
end;

procedure CopyVector (FromVektor: TGLVector; var ToVektor: TGLVector);
begin
ToVektor.X := FromVektor.X;
ToVektor.Y := FromVektor.Y;
ToVektor.Z := FromVektor.Z;
end;

function GetMatrixX (matrix: TArrMatrix): TGLvector;
// holt den X-vektor aus matrix und gibt ihn zurück
begin
result.X := matrix[00];
result.Y := matrix[01];
result.Z := matrix[02];
end;

function GetMatrixY (matrix: TArrMatrix): TGLvector;
// holt den Y-vektor aus matrix und gibt ihn zurück
begin
result.X := matrix[04];
result.Y := matrix[05];
result.Z := matrix[06];
end;

function GetMatrixZ (matrix: TArrMatrix): TGLvector;
// holt den Z-vektor aus matrix und gibt ihn zurück
begin
result.X := matrix[08];
result.Y := matrix[09];
result.Z := matrix[10];
end;

function GetMatrixPos (matrix: TArrMatrix): TGLvector;
// holt den Position-vektor aus matrix und gibt ihn zurück
begin
result.X := matrix[12];
result.Y := matrix[13];
result.Z := matrix[14];
end;

procedure SetMatrixX (var matrix: TArrMatrix; v: TGLvector);
// setzt den durch v bestimmten X-vektor in matrix
begin
matrix[00] := v.X;
matrix[01] := v.Y;
matrix[02] := v.Z;
end;

procedure SetMatrixY (var matrix: TArrMatrix; v: TGLvector);
// setzt den durch v bestimmten Y-vektor in matrix
begin
matrix[04] := v.X;
matrix[05] := v.Y;
matrix[06] := v.Z;
end;

procedure SetMatrixZ (var matrix: TArrMatrix; v: TGLvector);
// setzt den durch v bestimmten Z-vektor in matrix
begin
matrix[08] := v.X;
matrix[09] := v.Y;
matrix[10] := v.Z;
end;

procedure SetMatrixPos (var matrix: TArrMatrix; v: TGLvector);
// setzt den durch v bestimmten Position-vektor in matrix
begin
matrix[12] := v.X;
matrix[13] := v.Y;
matrix[14] := v.Z;
end;

function SubtractVector (Vec1, Vec2: TGLVector): TGLVector;
// subtrahiert Vec2 von vec1 und gibt das ergebnis in vec3 zurück
var
Vec3: TGLVector;
begin
Vec3 .X := Vec1.X - Vec2.X;
Vec3 .Y := Vec1.Y - Vec2.Y;
Vec3 .Z := Vec1.Z - Vec2.Z;
result := Vec3;
end;

function SubtractVector (Vec: TGLVector; X, Y, Z: TGLdouble): TGLVector;
// subtrahiert X, Y, Z von vec.x, vec.y, vec.z und gibt das
// ergebnis zurück
begin
Vec .X := Vec.X - X;
Vec .Y := Vec.Y - Y;
Vec .Z := Vec.Z - Z;
result := Vec;
end;

function AddVector (Vec1, Vec2: TGLVector): TGLVector;
// addiert Vec2 auf vec1 und gibt das ergebnis in vec3 zurück
var
Vec3: TGLVector;
begin
Vec3 .X := Vec1.X + Vec2.X;
Vec3 .Y := Vec1.Y + Vec2.Y;
Vec3 .Z := Vec1.Z + Vec2.Z;
result := Vec3;
end;

function AddVector (Vec: TGLVector; X, Y, Z: TGLdouble): TGLVector;
// addiert X, Y, Z auf vec.x, vec.y, vec.z und gibt das
// ergebnis zurück
begin
Vec .X := Vec.X + X;
Vec .Y := Vec.Y + Y;
Vec .Z := Vec.Z + Z;
result := Vec;
end;

function Magnitude(V1 : TGLVector) : GLdouble;
var
Ergebnis: GLdouble;
begin
// gibt die länge des vektors zurück
Ergebnis := MyPower(V1.X,2)+MyPower(V1.Y,2)+MyPower(V1.Z,2);
try
result := sqrt(Ergebnis);
except
result := 0;
end;
end;

function DotProduct (V1, V2: TGLVector): GLdouble;
var
len1, len2: GLdouble;
Ergebnis: GLdouble;
begin
//len1 := MyPower(V1.X,2)+MyPower(V1.Y,2)+MyPower(V1.Z,2);
//len2 := MyPower(V2.X,2)+MyPower(V2.Y,2)+MyPower(V2.Z,2);
len1 := Magnitude (V1);
len2 := Magnitude (V2);
Ergebnis := ScalarProduct (V1, V2);
Ergebnis := arccos (Ergebnis / (len1 * len2));
result := radtodeg (Ergebnis) * 2.0;
end;

function CrossProduct(V1, V2: TGLVector): TGLVector;
var
CrossVec: TGLVector;
begin
//CrossVec.X := +((V1.Y*V2.Z) - (V1.Z*V2.Y));
//CrossVec.Y := -((V1.X*V2.Z) - (V1.Z*V2.X));
//CrossVec.Z := +((V1.X*V2.Y) - (V1.Y*V2.X));
CrossVec.X := ((V1.Y*V2.Z) - (V1.Z*V2.Y));
CrossVec.Y := ((V1.Z*V2.X) - (V1.X*V2.Z));
CrossVec.Z := ((V1.X*V2.Y) - (V1.Y*V2.X));
result := CrossVec;
end;

function CalcNormale (V1, V2, V3: TGLVector): TGLVector;
var
Kreuz: TGLvector;
V1V2, V1V3: TGLvector;
begin
// gibt die normale von 3 vektoren zurück (die senkrechte auf die
// durch die drei vektoren gebildete ebene)
V1V2 := SubtractVector (V2, V1);
V1V3 := SubtractVector (V3, V1);

Kreuz := CrossProduct (V1V2, V1V3);

Normalize (Kreuz, result);
end;

procedure InitVector (var V1: TGLVector; x, y, z: TGLdouble);
begin
V1.x := x;
V1.y := y;
V1.z := z;
end;

procedure InitVector (var V1: TGKVector; x, y, z: TGLdouble);
begin
V1.x := x;
V1.y := y;
V1.z := z;
end;

procedure InitVector (var V1: TArrVector; x, y, z: TGLdouble);
begin
V1[C_X] := x;
V1[C_Y] := y;
V1[C_Z] := z;
end;

procedure InitScale (var S1: TScale; x, y, z: TGLdouble);
begin
S1.x := x;
S1.y := y;
S1.z := z;
end;

function Multiply (V1, V2: TGLVector): TGLVector;
var
ret: TGLVector;
begin
// zwei vektoren miteinander multiplizieren
ret.X := V1.X * V2.X;
ret.Y := V1.Y * V2.Y;
ret.Z := V1.Z * V2.Z;
result := ret;
end;

function Divide (V1, V2: TGLVector): TGLVector;
var
ret: TGLVector;
begin
// zwei vektoren miteinander multiplizieren
ret.X := V1.X / V2.X;
ret.Y := V1.Y / V2.Y;
ret.Z := V1.Z / V2.Z;
result := ret;
end;

function ScalarProduct (V1, V2: TGLVector): GLdouble;
begin
// die summe der potenzen der einzelnen achsen von zwei vektoren errechnen
result := (V1.X*V2.X +
V1.Y*V2.Y +
V1.Z*V2.Z);
end;

function LoadTexture(Filename: String; var Texture: GLuint): Boolean;
resourcestring
Res_LoadUnable = 'Unable to load ';
Res_LoadingTex = 'Loading Textures';
var
pData: Pointer;
Width: Cardinal;
Height: Cardinal;
newTexture: GLint;
begin
pData :=nil;
LoadBitmap(Filename, Width, Height, pData);

if (Assigned(pData)) then
Result := True
else
begin
Result := False;
MessageBox(0, PChar(Res_LoadUnable + filename),
pchar (Res_LoadingTex), MB_OK);
exit;
end;

glGenTextures(1, @NewTexture);
glBindTexture(GL_TEXTURE_2D, NewTexture);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); {Texture blends with object background}

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); { only first two can be used }
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); { all of the above can be used }

gluBuild2DMipmaps(GL_TEXTURE_2D, 3, Width, Height, GL_RGB, GL_UNSIGNED_BYTE, pData);

Texture := newTexture;
end;

procedure LoadBitmap(Filename: String;
out Width: Cardinal;
out Height: Cardinal;
out pData: Pointer);
resourcestring
Res_ReadErr = 'Error reading palette';
Res_OpenErr = 'Error opening: ';
Res_BitmapDataErr = 'Error reading bitmap data';
Res_BmpUnit = 'BMP Unit';
var
FileHeader: BITMAPFILEHEADER;
InfoHeader: BITMAPINFOHEADER;
Palette: array of RGBQUAD;
BitmapFile: THandle;
BitmapLength: Cardinal;
PaletteLength: Cardinal;
ReadBytes: Cardinal;
Front: ^Byte;
Back: ^Byte;
Temp: Byte;
I : Cardinal;
begin
BitmapFile := CreateFile(PChar(Filename), GENERIC_READ, FILE_SHARE_READ, nil, OPEN_EXISTING, 0, 0);
if (BitmapFile = INVALID_HANDLE_VALUE) then begin
MessageBox(0, PChar(Res_OpenErr+Filename), PChar(Res_BmpUnit), MB_OK);
Exit;
end;

// Get header information
ReadFile(BitmapFile, FileHeader, SizeOf(FileHeader), ReadBytes, nil);
ReadFile(BitmapFile, InfoHeader, SizeOf(InfoHeader), ReadBytes, nil);

// Get palette
PaletteLength := InfoHeader.biClrUsed;
SetLength(Palette, PaletteLength);
ReadFile(BitmapFile, Palette, PaletteLength, ReadBytes, nil);
if (ReadBytes <> PaletteLength) then begin
MessageBox(0, PChar(Res_ReadErr), PChar(Res_BmpUnit), MB_OK);
CloseHandle(BitmapFile);
Exit;
end;

Width := InfoHeader.biWidth;
Height := InfoHeader.biHeight;
BitmapLength := InfoHeader.biSizeImage;
if BitmapLength = 0 then
BitmapLength := Width * Height * InfoHeader.biBitCount Div 8;

// Get the actual pixel data
GetMem(pData, BitmapLength);
ReadFile(BitmapFile, pData^, BitmapLength, ReadBytes, nil);
if (ReadBytes <> BitmapLength) then begin
MessageBox(0, PChar(Res_BitmapDataErr), PChar(Res_BmpUnit), MB_OK);
CloseHandle(BitmapFile);
Exit;
end;
CloseHandle(BitmapFile);

// Bitmaps are stored BGR and not RGB, so swap the R and B bytes.
for I :=0 to Width * Height - 1 do
begin
Front := Pointer(Cardinal(pData) + I*3);
Back := Pointer(Cardinal(pData) + I*3 + 2);
Temp := Front^;
Front^ := Back^;
Back^ := Temp;
end;
end;

function GK2GLVector (V: TGKVector): TGLVector;
// ändert Gauss-Krüger Koordinaten in OpenGL Koordinaten um
begin
result.X := V.X;
result.Y := V.Z;
result.Z := V.Y;
end;

function GL2GKVector (V: TGLVector): TGKVector;
// ändert OpenGL Koordinaten in Gauss-Krüger Koordinaten um
begin
result.X := V.X;
result.Y := V.Z;
result.Z := V.Y;
end;

function Win2GLColor (WinCol: TColor): TGLcolor;
begin
result.Red := GetRValue (WinCol) / 255;
result.Green := GetGValue (WinCol) / 255;
result.Blue := GetBValue (WinCol) / 255;
result.Alpha := 0.0;
end;

function GL2WinColor (GLcol: TGLcolor): TColor;
begin
result := Rgb (StrToInt (FloatToStr (int (GLcol.Red * 255))),
StrToInt (FloatToStr (int (GLcol.Green * 255))),
StrToInt (FloatToStr (int (GLcol.Blue * 255))));
end;

procedure GetRotation (V1, V2: TGLVector;
var Rotation: TRotation);
var
tmpCyl, tmpZiel, nullVec: TGLVector;
normale, ResultLen: TGLVector;
VectorLength: GLfloat;
begin
// temporäre vektoren initialisieren
InitVector (nullVec, 0,0,0);
InitVector (tmpCyl, 0,0,0);

// länge des zu drehenden objekts ermitteln
ResultLen := SubtractVector (V2, V1);
VectorLength := Magnitude (ResultLen);

// vektoren zur bildung der dreiecksfläche bilden.
// die schenkel schneiden sich im nullpunkt
// der Cylinder läuft immer entlang der Z-Achse
tmpCyl.Z := VectorLength;
tmpZiel := SubtractVector (V2, V1);
tmpZiel.Z := tmpZiel.Z + VectorLength;

// senkrechte zu den beiden vektoren bilden
// (um diese achse soll nachher gedreht werden)
// drehachse für späteren gebrauch speichern
normale := CalcNormale (tmpCyl, tmpZiel, nullVec);

// um "Angle" Grad soll nachher gedreht werden
Rotation.Angle := DotProduct(tmpCyl, tmpZiel);
Rotation.X := normale.X;
Rotation.Y := normale.Y;
Rotation.Z := normale.Z;
end;

function MakeTextureFromBitmap (Bitmap: string; var BitmapList: TTextureList): GLenum;
// die funktion lädt die in Bitmap übergebene Grafik und gibt die Textturnummer
// zurück. ist das bitmap schon im array BitmapList enthalten, wird die bereits
// vergeben nummer zurückgegeben.
resourcestring
Res_TextureNotFound = 'Texturdatei nicht gefunden: ';
Res_Error = 'Error';
var
i, Laenge: integer;
begin
result := 0;
if length (trim (Bitmap)) = 0 then
exit;
Bitmap := uppercase (ExePath + trim (Bitmap));
// suchen, ob die textur schon geladen wurde
Laenge := length (BitmapList);
if Laenge > 0 then
for i := 0 to Laenge-1 do
begin
if (BitmapList[i].BitmapName = Bitmap) and
(glIsTexture (BitmapList[i].TextureNum)) then
result := BitmapList[i].TextureNum;
end;

if result = 0 then
begin
if not fileexists (Bitmap) then
begin
MessageBox (0, PChar (Res_TextureNotFound+Bitmap),
pchar (Res_Error), MB_OK or MB_ICONERROR);
exit;
end;
end;

if (result = 0) then
begin
setlength (BitmapList, Laenge+1);
BitmapList[Laenge].BitmapName := Bitmap;
BitmapList[Laenge].TextureNum := 0;
BitMapList[Laenge].theBmp := TglBmp.Create;
if BitMapList[Laenge].theBmp.LoadImage (BitMap) then
begin
BitMapList[Laenge].theBmp.SetTextureWrap(GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE);
BitMapList[Laenge].theBmp.GenTexture (false, false);
result := BitmapList[Laenge].theBmp.TextureID;
BitmapList[Laenge].TextureNum := BitmapList[Laenge].theBmp.TextureID;
end;
end;
end;

procedure EnableTexture (Texture: GLenum; TextureTiled: boolean);
begin
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, Texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
if TextureTiled then
begin
glTexparameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexparameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
end
else
begin
glTexparameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexparameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
end;
end;

procedure DisableTexture;
begin
glDisable(GL_TEXTURE_2D);
end;

function TextToGLVector (VTxt: string): TGLVector;
const
subdelim: char = '/';
var
posi: integer;
V1: TGLVector;
begin
InitVector (V1,0,0,0);
posi := pos (subdelim, VTxt);
if posi > 0 then
begin
V1.X := StrToFloat (copy (VTxt, 1, posi-1));
VTxt := copy (VTxt, posi+1, length (VTxt));
posi := pos (subdelim, VTxt);
end;
if posi > 0 then
begin
V1.Y := StrToFloat (copy (VTxt, 1, posi-1));
VTxt := copy (VTxt, posi+1, length (VTxt));
end;
if length (VTxt) > 0 then V1.Z := StrToFloat (VTxt);

result := V1;
end;

function TextToGKVector (VTxt: string): TGKVector;
const
subdelim: char = '/';
var
posi: integer;
V1: TGKVector;
begin
InitVector (V1,0,0,0);
posi := pos (subdelim, VTxt);
if posi > 0 then
begin
V1.X := StrToFloat (copy (VTxt, 1, posi-1));
VTxt := copy (VTxt, posi+1, length (VTxt));
posi := pos (subdelim, VTxt);
end;
if posi > 0 then
begin
V1.Y := StrToFloat (copy (VTxt, 1, posi-1));
VTxt := copy (VTxt, posi+1, length (VTxt));
end;
if length (VTxt) > 0 then V1.Z := StrToFloat (VTxt);

result := V1;
end;

function GKVectorToText (V1: TGKVector): string;
const
subdelim: char = '/';
var
VTxt: string;
begin
VTxt := FloatToStr (V1.X) + subdelim;
VTxt := VTxt + FloatToStr (V1.Y) + subdelim;
VTxt := VTxt + FloatToStr (V1.Z);
result := VTxt;
end;

function GKVectorToText (V1: TGKVector; digits: byte): string;
const
subdelim: char = '/';
var
VTxt: string;
begin
VTxt := Format('%*.*f', [digits+3, digits, V1.X]) + subdelim;
VTxt := VTxt + Format('%*.*f', [digits+3, digits, V1.Y]) + subdelim;
VTxt := VTxt + Format('%*.*f', [digits+3, digits, V1.Z]);
result := VTxt;
end;

function GLVectorToText (V1: TGLVector): string;
const
subdelim: char = '/';
var
VTxt: string;
begin
VTxt := FloatToStr (V1.X) + subdelim;
VTxt := VTxt + FloatToStr (V1.Y) + subdelim;
VTxt := VTxt + FloatToStr (V1.Z);
result := VTxt;
end;

function GLVectorToText (V1: TGLVector; digits: byte): string;
const
subdelim: char = '/';
var
VTxt: string;
begin
VTxt := Format('%*.*f', [digits+3, digits, V1.X]) + subdelim;
VTxt := VTxt + Format('%*.*f', [digits+3, digits, V1.Y]) + subdelim;
VTxt := VTxt + Format('%*.*f', [digits+3, digits, V1.Z]);
result := VTxt;
end;

function MyCone (Start, Ende: TGLVector;
RadiusStart, RadiusEnde: TGLfloat;
Slices: Integer): boolean;
var
Slice: Integer;
Laenge, xdelta, zdelta: TGLfloat;
V1, V2, V3, V4: TGLvector;
A, B: Single;
tmpVec: TGLvector;
begin
result := true;
// laenge des kegels berechnen
// hierbei wird davon ausgegangen, dass der kegel senkrecht steht
// Laenge := Ende.y - Start.y;
tmpVec := SubtractVector (Start, Ende);
Laenge := Magnitude (tmpVec);
// radiusdifferenz berechnen
xdelta := Start.x - Ende.x;
zdelta := Start.z - Ende.z;
xdelta := -xdelta;
//zdelta := zdelta;
glBegin (GL_TRIANGLE_STRIP);
// der kegel wird entlang der z-achse gezeichnet
V1.z := 0;
V2.z := 0;
V3.z := Laenge;
V4.z := Laenge;
for Slice := 1 to Slices do begin
A := 2 * PI * Slice / Slices;
B := 2 * PI * (Slice+1) / Slices;
V1.x := sin(A)*RadiusStart;
V1.y := cos(A)*RadiusStart;
V2.x := sin(B)*RadiusStart;
V2.y := cos(B)*RadiusStart;
// umsetzung von y nach z-achse
V3.x := (sin(B)*RadiusEnde)+xdelta;
V3.y := (cos(B)*RadiusEnde)+zdelta;
V4.x := (sin(A)*RadiusEnde)+xdelta;
V4.y := (cos(A)*RadiusEnde)+zdelta;
//Normale := CalcNormale (V1, V3, V2);
//glNormal3fv(@Normale);
if Slice = 1 then
begin
glTexCoord2f(1,0); glVertex3fv(@V1);
glTexCoord2f(1,1); glVertex3fv(@V4);
glTexCoord2f(1-Slice/Slices,0); glVertex3fv(@V2);
glTexCoord2f(1-Slice/Slices,1); glVertex3fv(@V3);
end
else
begin
glTexCoord2f(1-Slice/Slices,0); glVertex3fv(@V2);
glTexCoord2f(1-Slice/Slices,1); glVertex3fv(@V3);
end;
// aktuellen und nächsten punkt des kreises (oben und unten)
// nehmen und ein rechteck zeichnen. alle rechtecke zusammen sollten
// einen geschlossenen kegel ergeben.
//glBegin(GL_QUADS);
// glNormal3fv(@Normale);
// glTexCoord2f(0,0); glVertex3fv(@V2);
// glTexCoord2f(1,0); glVertex3fv(@V1);
// glTexCoord2f(1,1); glVertex3fv(@V4);
// glTexCoord2f(0,1); glVertex3fv(@V3);
//glEnd;
end;
glEnd; // (GL_TRIANGLE_STRIP)
end;

{-----------------------------------------------------------------------------}
{----------------------------- für TRUVCamera --------------------------------}
{-----------------------------------------------------------------------------}

function Multiply(M1, M2: TArrMatrix): TArrMatrix;
// multiplies two 4x4 matrices
var
ret: TArrMatrix;
begin
glPushMatrix();
glLoadMatrixf(@M1);
glMultMatrixf(@M2);
glGetFloatv(GL_MODELVIEW_MATRIX,@ret);
glPopMatrix();
result := ret;
end;

function MakeVector(X,Y,Z:TGLFloat):TArrVector;
begin
result[0]:=x;
result[1]:=y;
result[2]:=z;
end;

function MakeVector(X,Y,Z,W:TGLFloat):TArrVector;
begin
result[0]:=x;
result[1]:=y;
result[2]:=z;
result[3]:=w;
end;

procedure Normalize(aVector:TArrVector;var RVec:TArrVector);
var
d:double;
begin
InitVector (RVec,1,1,1);
d:=Sqrt(Sqr(aVector[C_X])+Sqr(aVector[C_Y])+Sqr(aVector[C_Z]));
if d=0 then
begin
//raise exception.Create('Zero length vector(Normalize 1)');
exit;
end;
RVec[C_X]:=aVector[C_X]/d;
RVec[C_Y]:=aVector[C_Y]/d;
RVec[C_Z]:=aVector[C_Z]/d;
end;

procedure Normalize(aVector:TGLVector; var RVec:TGLVector);
var
d:double;
begin
InitVector (RVec,1,1,1);
d:=Sqrt(Sqr(aVector.X)+Sqr(aVector.Y)+Sqr(aVector.Z));
if d=0 then
begin
//raise exception.Create('Zero length vector(Normalize 2)');
exit;
end;
RVec.X:=aVector.X/d;
RVec.Y:=aVector.Y/d;
RVec.Z:=aVector.Z/d;
end;

function GetIdentity(Matrix:TMatrix):TMatrix;
begin
result[0,0]:=1.0;result[0,1]:=0.0;result[0,2]:=0.0;result[0,3]:=0.0;
result[1,0]:=0.0;result[1,1]:=1.0;result[1,2]:=0.0;result[1,3]:=0.0;
result[2,0]:=0.0;result[2,1]:=0.0;result[2,2]:=1.0;result[2,3]:=0.0;
result[3,0]:=0.0;result[3,1]:=0.0;result[3,2]:=0.0;result[3,3]:=1.0;
end;

function GetIdentity(Matrix:TArrMatrix):TArrMatrix;
begin
result[0]:=1.0;result[1]:=0.0;result[2]:=0.0;result[3]:=0.0;
result[4]:=0.0;result[5]:=1.0;result[6]:=0.0;result[7]:=0.0;
result[8]:=0.0;result[9]:=0.0;result[10]:=1.0;result[11]:=0.0;
result[12]:=0.0;result[13]:=0.0;result[14]:=0.0;result[15]:=1.0;
end;

function MatrixTranspose(const M:TMatrix):TMatrix;register;
var
i,j:integer;
begin
for i:=0 to 3 do
for j:=0 to 3 do
result[i,j]:=M[j,i];
end;

function VectorRotateX(v:TArrVector;a:TGLFloat):TArrVector;
var
temp: TArrVector;
sine,cosine:TGLFloat;
begin
a:=a*C_DEGTORAD;
sine:=Sin(a);
cosine:=Cos(a);

temp[C_X] := v[C_x];
temp[C_Y] := (v[C_Y] * cosine) + (v[C_Z] * -sine);
temp[C_Z] := (v[C_Y] * sine) + (v[C_Z] * cosine);
result := temp;
end;

function VectorRotateY(v: TArrVector;a:TGLFloat):TArrVector;
var
temp: TArrVector;
sine,cosine:TGLFloat;
begin
a:=a*C_DEGTORAD;
sine:=Sin(a);
cosine:=Cos(a);

temp[C_x] := (v[C_x] * cosine) + (v[C_z] * sine);
temp[C_y] := v[C_y];
temp[C_z] := (v[C_x] * -sine) + (v[C_z] * cosine);
result := temp;
end;

function VectorRotateZ(v: TArrVector; a: TGLFloat):TArrVector;
var
temp: TArrVector;
sine,cosine:TGLFloat;
begin
a:=a*C_DEGTORAD;
sine:=Sin(a);
cosine:=Cos(a);
temp[C_x] := (v[C_x] * cosine) + (v[C_y] * -sine);
temp[C_y] := (v[C_x] * sin(a)) + (v[C_y] * cosine);
temp[C_z] := v[C_z];
result := temp;
end;

function VectorRotateX(v:TGLVector;a:TGLFloat):TGLVector;
var
temp: TGLVector;
sine,cosine:TGLFloat;
begin
a:=a*C_DEGTORAD;
sine:=Sin(a);
cosine:=Cos(a);

temp.X := v.x;
temp.Y := (v.Y * cosine) + (v.Z * -sine);
temp.Z := (v.Y * sine) + (v.Z * cosine);
result := temp;
end;

function VectorRotateY(v: TGLVector;a:TGLFloat):TGLVector;
var
temp: TGLVector;
sine,cosine:TGLFloat;
begin
a:=a*C_DEGTORAD;
sine:=Sin(a);
cosine:=Cos(a);

temp.x := (v.x * cosine) + (v.z * sine);
temp.y := v.y;
temp.z := (v.X * -sine) + (v.z * cosine);
result := temp;
end;

function VectorRotateZ(v: TGLVector; a: TGLFloat):TGLVector;
var
temp: TGLVector;
sine,cosine:TGLFloat;
begin
a:=a*C_DEGTORAD;
sine:=Sin(a);
cosine:=Cos(a);
temp.x := (v.x * cosine) + (v.y * -sine);
temp.y := (v.x * sin(a)) + (v.y * cosine);
temp.z := v.z;
result := temp;
end;

{-----------------------------------------------------------------------------}
{-------------------------------- allgemein ----------------------------------}
{-----------------------------------------------------------------------------}

function InvertMatrix (src: TArrMatrix; var inverse: TArrMatrix): boolean;
var
t: TGLdouble;
i, j, k, swap: integer;
tmp: TMatrix;
begin
result := false;
inverse := GetIdentity(inverse);

for i := 0 to 3 do
begin
for j := 0 to 3 do
begin
tmp[i][j] := src[i*4+j];
end;
end;

for i := 0 to 3 do
begin
// look for largest element in column.
swap := i;
for j := i+1 to 3 do
begin
if abs(tmp[j][i]) > abs(tmp[i][i]) then
begin
swap := j;
end;
end;

if not (swap = i) then
begin
// swap rows.
for k := 0 to 3 do
begin
t := tmp[i][k];
tmp[i][k] := tmp[swap][k];
tmp[swap][k] := t;

t := inverse[i*4+k];
inverse[i*4+k] := inverse[swap*4+k];
inverse[swap*4+k] := t;
end;
end;

if tmp[i][i] = 0 then
begin
{ no non-zero pivot. the matrix is singular, which
shouldn't happen. This means the user gave us a bad
matrix. }
exit;
end;

t := tmp[i][i];
for k := 0 to 3 do
begin
tmp[i][k] := tmp[i][k]/t;
inverse[i*4+k] := inverse[i*4+k]/t;
end;

for j := 0 to 3 do
begin
if not (j = i) then
begin
t := tmp[j][i];
for k := 0 to 3 do
begin
tmp[j][k] := tmp[j][k]-tmp[i][k]*t;
inverse[j*4+k] := inverse[j*4+k]-inverse[i*4+k]*t;
end;
end;
end;
end;
result := true;
end;

function Multiply (Color: TGLcolor; m: TGLdouble): TGLcolor;
var
ret: TGLcolor;
begin
ret.red := Color.red * m;
ret.green := Color.green * m;
ret.blue := Color.blue * m;
result := ret;
end;

function Divide (V1: TGLvector; d: TGLdouble): TGLvector;
var
ret: TGLvector;
begin
ret.x := V1.x / d;
ret.y := V1.y / d;
ret.z := V1.z / d;
result := ret;
end;

function ForceForegroundWindow(hwnd: THandle): Boolean;
{
Manchmal funktioniert die SetForeGroundWindow Funktion
nicht so, wie sie sollte; besonders unter Windows 98/2000,
wenn ein anderes Fenster den Fokus hat.
ForceForegroundWindow ist eine "verbesserte" Version von
der SetForeGroundWindow API-Funktion, um ein Fenster in
den Vordergrund zu bringen.
}
const
SPI_GETFOREGROUNDLOCKTIMEOUT = $2000;
SPI_SETFOREGROUNDLOCKTIMEOUT = $2001;
var
ForegroundThreadID: DWORD;
ThisThreadID: DWORD;
timeout: DWORD;
begin
if IsIconic(hwnd) then ShowWindow(hwnd, SW_RESTORE);

if GetForegroundWindow = hwnd then Result := True
else
begin
// Windows 98/2000 doesn't want to foreground a window when some other
// window has keyboard focus

if ((Win32Platform = VER_PLATFORM_WIN32_NT) and (Win32MajorVersion > 4)) or
((Win32Platform = VER_PLATFORM_WIN32_WINDOWS) and
((Win32MajorVersion > 4) or ((Win32MajorVersion = 4) and
(Win32MinorVersion > 0)))) then
begin
// Code from Karl E. Peterson, www.mvps.org/vb/sample.htm
// Converted to Delphi by Ray Lischner
// Published in The Delphi Magazine 55, page 16

Result := False;
ForegroundThreadID := GetWindowThreadProcessID(GetForegroundWindow, nil);
ThisThreadID := GetWindowThreadPRocessId(hwnd, nil);
if AttachThreadInput(ThisThreadID, ForegroundThreadID, True) then
begin
BringWindowToTop(hwnd); // IE 5.5 related hack
SetForegroundWindow(hwnd);
AttachThreadInput(ThisThreadID, ForegroundThreadID, False);
Result := (GetForegroundWindow = hwnd);
end;
if not Result then
begin
// Code by Daniel P. Stasinski
SystemParametersInfo(SPI_GETFOREGROUNDLOCKTIMEOUT, 0, @timeout, 0);
SystemParametersInfo(SPI_SETFOREGROUNDLOCKTIMEOUT, 0, TObject(0),
SPIF_SENDCHANGE);
BringWindowToTop(hwnd); // IE 5.5 related hack
SetForegroundWindow(hWnd);
SystemParametersInfo(SPI_SETFOREGROUNDLOCKTIMEOUT, 0, TObject(timeout), SPIF_SENDCHANGE);
end;
end
else
begin
BringWindowToTop(hwnd); // IE 5.5 related hack
SetForegroundWindow(hwnd);
end;

Result := (GetForegroundWindow = hwnd);
end;
end; { ForceForegroundWindow }

procedure InitGLEnv (dc: HDC; rc: HGLRC; hndl: THandle);
resourcestring
Res_ChooseFailed = 'ChoosePixelFormat failed with ';
var
pfd: TPixelFormatDescriptor;
PixelFormat: TGLUint;
pFlags: TPFDFlags;
flags: word absolute pFlags;
StencilBits,
ColorBits,
DepthBits: integer;
begin
pflags := [];
include (pflags, DoubleBuffer);
include (pflags, Stereo);
include (pflags, Draw_To_Window);
include (pflags, Draw_To_Bitmap);
include (pflags, Support_GDI);
include (pflags, Support_OpenGL);
include (pflags, Generic_Format);
include (pflags, Need_Palette);
include (pflags, Need_System_Palette);
include (pflags, Swap_Exchange);
include (pflags, Swap_Copy);
include (pflags, Swap_Layer_Buffers);
include (pflags, Generic_Accelerated);

ColorBits := 24;
DepthBits := 32;
StencilBits := 0;

with TWinControl(hndl) do
begin
fillchar(pfd,SizeOf(pfd),0);
with pfd do
begin
nSize := SizeOf(pfd);
nVersion := 1;
dwFlags := flags or
PFD_DRAW_TO_WINDOW
or PFD_SUPPORT_OPENGL
or PFD_DOUBLEBUFFER;
iPixelType := PFD_TYPE_RGBA;
cColorBits := ColorBits;
cDepthBits := DepthBits;
cStencilBits := StencilBits;
iLayerType := PFD_MAIN_PLANE;
cRedBits := 0;
cRedShift := 0;
cGreenBits := 0;
cBlueBits := 0;
cBlueShift := 0;
cAlphaBits := 0;
cAlphaShift := 0;
cAccumBits := 0;
cAccumRedBits := 0;
cAccumGreenBits := 0;
cAccumBlueBits := 0;
cAccumAlphaBits := 0;
cAuxBuffers := 0;
bReserved := 0;
dwLayerMask := 0;
dwVisibleMask := 0;
dwDamageMask := 0;
end; {with}

PixelFormat := ChoosePixelFormat(dc, @pfd);
if PixelFormat=0 then
raise Exception.Create(Res_ChooseFailed+IntToStr(GetLastError));

//if not SetPixelFormat(FglDC, PixelFormat, @pfd) then
// raise Exception.Create('SetPixelFormat failed with '+
// IntToStr(GetLastError));
end;
end;

end.
</pascal>
[[Kategorie:Anleitung]]

Techniken und Algorithmen

2006-01-08T07:04:35Z

Andyh:

== Was hier hinein gehört ==
Hier kommen, wie der Name vermuten lässt '''Erklärungen''' zu in der 3D-Echtzeitprogrammierung verwendeten '''Techniken''' hin. Z.B. verschiedene Schattentechniken, Bump-Mapping, etc.

[[Hintergrundwissen]] gehört hier nicht rein, also solche Sachen wie ''"was ist ein Tiefenpuffer und wofür ist er gut"'' haben hier nichts zu suchen. 
Sollte es für eine Technik/Thematik (siehe unten für Beispiel) mehrere "Lösungswege" geben, sollte eine kleine Überschrift eingefügt werden.

Wenn ihr einen Technik oder Alorithmus Artikel erstellt, so solltet ihr unter den Artikel ein
<nowiki>[[Kategorie:Technik_oder_Algorithmus]]</nowiki>
stellen. Damit wird der Artikel der [[:Kategorie:Technik_oder_Algorithmus]] zugeordnet.
Falls dieser Artikel nicht nur erklärt was der Begriff bedeutet, sondern auch noch eine Anleitung ist, wie man die entsprechende Technik realisiert, so könnt ihr den Artikel auch noch der Kategorie [[:Kategorie:Anleitung|Anleitung]] zuweisen.

== Übersicht ==
=== Nützliche Helfer ===
In dieser Rubrik findet sich all das, was ein OpenGL/Graphikprogrammierer immer brauch oder schnell mal zur Hand haben muss:
* [[Framecounter]] (Wie schnell läuft mein Programm?)
* [[Texture Loader]] (Laden und verwalten von Texturen)
* [[Model Loader]] (Laden von Modellen die mit Programmen wie 3D Studio Max, Lightwave, Milkshape usw. erstellt wurden.)
* Eine Möglichkeit zum [[Text ausgeben]]
* [[Kamera]]
** [[Kamera (1)]] (Szene in drei Ebenen verschieben und drehen)
** [[Kamera (2)]] (Kamera Source, letztes Update 8.1.2006)
** [[Kamera (3)]] (Für die Kamera benötigte Utilities)
* [[Extensionausgabe]] (Ausgabe der unterstützten Extensions und sonstiger Eigenschaften)

=== Licht und Schatten ===
Das Beleuchtungsmodell von OpenGL besitzt von Haus aus keine Möglichkeit zur Darstellung von Schatten (nicht zuletzt weil es dafür immernoch keine einheitliche Methode gibt), allerdings haben sich über die Jahre hinweg einige Techniken mehr oder weniger durchgesetzt : <ul>
<li>[[Lightmaps]]</li>
<li>[[Projezierte Shadowmaps]] / [[Projezierte Textur]]en</li>
<li>[[Volumetrische Stencilschatten]]</li>
<li>[[Silhouette]] {{icpIcon}}</li></ul>

=== Statische Umgebungen ===
Besonders in Aussenszenen ist es oft nötig dem Betrachter den Eindruck zu vermitteln, er befinde sich in einer unendlich großen Umgebung. Da man dies jedoch schlecht über speziell dafür erstellte Geometrie lösen kann (weil das schlichtweg zu viel Aufwand und zu leistungsintensiv wäre), haben sich einige Techniken eingebürgert, mit denen man dem Betrachter eine solche unendliche Landschaft mit wenig Geometrie und einigen Tricks vorgaugeln kann : <ul>
<li>[[Skyboxen]]</li>
<li>[[Skydome]]</li>
<li>[[Skysphere]]</li>
</ul>

=== Dynamische Effekte ===
Das Auge ißt bekanntlich mit. Auch bei 3D Anwendungen, vor allem in der Unterhaltungsindustrie, spielen gigantische Effekte, die dem User ein "Ohhh" und "Ahhh" und vor allem "Wow!" entlocken eine immer größere Rolle. Wie man solche Effekte am besten implementiert finden Sie in den Artikeln dieses Abschnitts. 
(Befassen Sie sich zuerst mit den Grundlagen von [[Partikelsysteme|Partikelsystemen]].)
<ul>
<li>[[Explosionen]] (Allseits gern gesehen. Außer in direkter Nachbarschaft)</li>
<li>[[Lichtsäulen]] (Bekannt für die magischen Momente in diversen Rollenspielen.) </li>
<li>[[Partikelsysteme]] (Grundlage für viele Effekte) </li>
</ul>

=== Natürliche Phänomene ===
Ziel vieler Echtzeit 3D-Anwendung (auch wenn genau der gegenteilige Trend manchmal interessant sein dürfte) ist eine zumindest optische Annäherung an die Realität, also Szenen möglichst "naturgetreu" (auch urbane Szenen können "naturgetreu" sein, auch wenn diese wenig natürlich sind) darzustellen. Dazu gehören auch natürliche Phänomene, wie z.B. realistisch spiegelndes Wasser, Wetterbedingungen (Regen, Schnee, Nebel), Feuer, etc. Oft gibt es für ein natürliches Phänomen recht fortgeschrittene Umsetzungsmöglichkeiten, manchmal liegt die Lösung aber auch recht nahe : <ul>
<li>[[Prozeduale Bäume|Bäume]]</li>
<li>[[Blitz]]</li>
<li>[[Feuer]]</li>
<li>[[Himmel]]</li>
<li>[[Nebel]]</li>
<li>[[Staub]]</li>
<li>[[Wasser]]</li>
<li>[[Wettereffekt]]e (Regen, Schnee)</li>
<li>[[Wolken]] (als Ergänzung zu den statischen Umgebungen)</li>
</ul>

=== Raumunterteilungstechniken ===
Moderne 3D-Anwendungen müssen immer größere und komplexere 3D-Umgebungen darstellen, wobei oft jedoch große Teile eben dieser nicht sichtbar sind, aber ohne entsprechende Optimierungen trotzdem über den Datenbus geschoben (und von der Grafikkarte geclippt) werden müssen. Deshalb finden diverse Raumunterteilungstechniken (die u.a. aus anderen Bereichen stammen) in modernen 3D-Programmen Anwendung : 
<ul>
<li>[[BSP-Bäume]] (Binary Space Partitioning = Binäre Raumunterteilung)</li>
<li>[[Octree]]s (Dreidimensionale Erweiterung eines Quadtrees)</li>
<li>[[Portal]]e (Logische Sichtbegrenzung an Durchgängen)</li>
<li>[[PVS]] (Potentially Visible Sets = Mögliche sichtbare Sets)</li>
</ul>

=== Terrain Darstellung ===
In vielen 3D Anwendungen, vom Flugsimulator über Egoshooter bis zum Strategiespiel, muss die Umgebung visualisiert werden. Welche Techniken bei der Speicherung (siehe auch '''Raumunterteilungstechniken'''), Bildaufbau und Texturierung zum Einsatz kommen, findet ihr hier: 
:'''[[LOD|Level of Detail]] Algorithmen für Landschaften'''

*[[VDPM]] ('''V'''iew-'''D'''ependent '''P'''rogressive '''M'''eshes)
*[[ROAM]] ('''R'''eal-time '''O'''ptimally '''A'''dapting '''M'''eshes)
*[[Geometrical Mipmapping]]
*[[VIPMs]] ('''V'''iew '''I'''ndependent '''P'''rogressive '''M'''eshe'''s''')

:'''Texturierung'''

*[[Texture Splatting]] (Kombination von Texturen mittels [[Blenden|Blending]] und [[Multitexturing]])
*[[Texture Backing]] (Dynamisches erstellen von Texturen)

=== Prozeduale Grafiken ===
Prozeduale Grafiken werden häufig verwendet um
*eine vielfältige Umgebung zu gewährleisten
*Speicherplatz auf der Festplatte zu sparen
*den Grafikern die Arbeit zu erleichtern (und teilweise sogar erst zu ermöglichen)
Die Algorithmen und Möglichkeiten die sich dabei bieten sind hier aufgelistet: <ul>
<li>[[Perlin Noise]] (Algorithmus für Texturen, Landschaft und vieles mehr)</li>
<li>[[L-Systems]] (aus wenig mach viel, Landschaftsgenerierung, Baumgenerierung, ...)</li>
<li>[[Midpoint Displacement]] (primär zur Landschaftsgenerierung)</li>
<li>[[Fault Formation]] (primär zur Landschaftsgenerierung)</li>
<li>[[Prozeduale Landschaft]] (Spezielle Hinweise und Techniken zur Landschaftsgenerierung</li>
<li>[[Prozeduale Bäume]] (Techniken und Algorithmen speziell zur Baumgenerierung)</li>
<li>[[Prozeduale Texturen]] (Spezielle Hinweise zu Wasser, Lava und ähnliches)</li>
</ul>

=== Pathfinding ===
Pathfinding ist einer der grundlegenden Bereiche der Künstlichen Intelligenz, und aus diesem Grund für Spiele mit Computergegnern meistens unumgänglich.
<ul>
<li>[[Tiefensuche]]</li>
<li>[[Breitensuche]]</li>
<li>[[A-Stern]]</li>
<li>[[Dijkstra]]</li>
<li>[[Floyd Warshall]]</li>
<li>[[Navigation Meshes]]</li>
<li>[[Pathfinding-Level of Detail]]</li>
</ul>

=== Sonstiges ===
<ul>
<li>[[Screenshot]]s von OpenGL Ausgaben</li>
<li>[[Interpolation]]</li>
<li>[[Bilder als Ressourcen]] speichern und laden</li>
</ul>

== Externe Links ==
Weitere Links zum Thema "Effekte unter OpenGL" findet ihr in der [[Link]]-Sammlung unter [[Link#Effekte_und_Techniken_mit_OpenGL|Effekte und Techniken mit OpenGL]].

Techniken und Algorithmen

2006-01-08T07:04:04Z

Andyh:

== Was hier hinein gehört ==
Hier kommen, wie der Name vermuten lässt '''Erklärungen''' zu in der 3D-Echtzeitprogrammierung verwendeten '''Techniken''' hin. Z.B. verschiedene Schattentechniken, Bump-Mapping, etc.

[[Hintergrundwissen]] gehört hier nicht rein, also solche Sachen wie ''"was ist ein Tiefenpuffer und wofür ist er gut"'' haben hier nichts zu suchen. 
Sollte es für eine Technik/Thematik (siehe unten für Beispiel) mehrere "Lösungswege" geben, sollte eine kleine Überschrift eingefügt werden.

Wenn ihr einen Technik oder Alorithmus Artikel erstellt, so solltet ihr unter den Artikel ein
<nowiki>[[Kategorie:Technik_oder_Algorithmus]]</nowiki>
stellen. Damit wird der Artikel der [[:Kategorie:Technik_oder_Algorithmus]] zugeordnet.
Falls dieser Artikel nicht nur erklärt was der Begriff bedeutet, sondern auch noch eine Anleitung ist, wie man die entsprechende Technik realisiert, so könnt ihr den Artikel auch noch der Kategorie [[:Kategorie:Anleitung|Anleitung]] zuweisen.

== Übersicht ==
=== Nützliche Helfer ===
In dieser Rubrik findet sich all das, was ein OpenGL/Graphikprogrammierer immer brauch oder schnell mal zur Hand haben muss:
* [[Framecounter]] (Wie schnell läuft mein Programm?)
* [[Texture Loader]] (Laden und verwalten von Texturen)
* [[Model Loader]] (Laden von Modellen die mit Programmen wie 3D Studio Max, Lightwave, Milkshape usw. erstellt wurden.)
* Eine Möglichkeit zum [[Text ausgeben]]
* [[Kamera]]
** [[Kamera (1)]] (Szene in drei Ebenen verschieben und drehen)
** [[Kamera (2)]] (Kamera Source, letztes Update 8.1.2005)
** [[Kamera (3)]] (Für die Kamera benötigte Utilities)
* [[Extensionausgabe]] (Ausgabe der unterstützten Extensions und sonstiger Eigenschaften)

=== Licht und Schatten ===
Das Beleuchtungsmodell von OpenGL besitzt von Haus aus keine Möglichkeit zur Darstellung von Schatten (nicht zuletzt weil es dafür immernoch keine einheitliche Methode gibt), allerdings haben sich über die Jahre hinweg einige Techniken mehr oder weniger durchgesetzt : <ul>
<li>[[Lightmaps]]</li>
<li>[[Projezierte Shadowmaps]] / [[Projezierte Textur]]en</li>
<li>[[Volumetrische Stencilschatten]]</li>
<li>[[Silhouette]] {{icpIcon}}</li></ul>

=== Statische Umgebungen ===
Besonders in Aussenszenen ist es oft nötig dem Betrachter den Eindruck zu vermitteln, er befinde sich in einer unendlich großen Umgebung. Da man dies jedoch schlecht über speziell dafür erstellte Geometrie lösen kann (weil das schlichtweg zu viel Aufwand und zu leistungsintensiv wäre), haben sich einige Techniken eingebürgert, mit denen man dem Betrachter eine solche unendliche Landschaft mit wenig Geometrie und einigen Tricks vorgaugeln kann : <ul>
<li>[[Skyboxen]]</li>
<li>[[Skydome]]</li>
<li>[[Skysphere]]</li>
</ul>

=== Dynamische Effekte ===
Das Auge ißt bekanntlich mit. Auch bei 3D Anwendungen, vor allem in der Unterhaltungsindustrie, spielen gigantische Effekte, die dem User ein "Ohhh" und "Ahhh" und vor allem "Wow!" entlocken eine immer größere Rolle. Wie man solche Effekte am besten implementiert finden Sie in den Artikeln dieses Abschnitts. 
(Befassen Sie sich zuerst mit den Grundlagen von [[Partikelsysteme|Partikelsystemen]].)
<ul>
<li>[[Explosionen]] (Allseits gern gesehen. Außer in direkter Nachbarschaft)</li>
<li>[[Lichtsäulen]] (Bekannt für die magischen Momente in diversen Rollenspielen.) </li>
<li>[[Partikelsysteme]] (Grundlage für viele Effekte) </li>
</ul>

=== Natürliche Phänomene ===
Ziel vieler Echtzeit 3D-Anwendung (auch wenn genau der gegenteilige Trend manchmal interessant sein dürfte) ist eine zumindest optische Annäherung an die Realität, also Szenen möglichst "naturgetreu" (auch urbane Szenen können "naturgetreu" sein, auch wenn diese wenig natürlich sind) darzustellen. Dazu gehören auch natürliche Phänomene, wie z.B. realistisch spiegelndes Wasser, Wetterbedingungen (Regen, Schnee, Nebel), Feuer, etc. Oft gibt es für ein natürliches Phänomen recht fortgeschrittene Umsetzungsmöglichkeiten, manchmal liegt die Lösung aber auch recht nahe : <ul>
<li>[[Prozeduale Bäume|Bäume]]</li>
<li>[[Blitz]]</li>
<li>[[Feuer]]</li>
<li>[[Himmel]]</li>
<li>[[Nebel]]</li>
<li>[[Staub]]</li>
<li>[[Wasser]]</li>
<li>[[Wettereffekt]]e (Regen, Schnee)</li>
<li>[[Wolken]] (als Ergänzung zu den statischen Umgebungen)</li>
</ul>

=== Raumunterteilungstechniken ===
Moderne 3D-Anwendungen müssen immer größere und komplexere 3D-Umgebungen darstellen, wobei oft jedoch große Teile eben dieser nicht sichtbar sind, aber ohne entsprechende Optimierungen trotzdem über den Datenbus geschoben (und von der Grafikkarte geclippt) werden müssen. Deshalb finden diverse Raumunterteilungstechniken (die u.a. aus anderen Bereichen stammen) in modernen 3D-Programmen Anwendung : 
<ul>
<li>[[BSP-Bäume]] (Binary Space Partitioning = Binäre Raumunterteilung)</li>
<li>[[Octree]]s (Dreidimensionale Erweiterung eines Quadtrees)</li>
<li>[[Portal]]e (Logische Sichtbegrenzung an Durchgängen)</li>
<li>[[PVS]] (Potentially Visible Sets = Mögliche sichtbare Sets)</li>
</ul>

=== Terrain Darstellung ===
In vielen 3D Anwendungen, vom Flugsimulator über Egoshooter bis zum Strategiespiel, muss die Umgebung visualisiert werden. Welche Techniken bei der Speicherung (siehe auch '''Raumunterteilungstechniken'''), Bildaufbau und Texturierung zum Einsatz kommen, findet ihr hier: 
:'''[[LOD|Level of Detail]] Algorithmen für Landschaften'''

*[[VDPM]] ('''V'''iew-'''D'''ependent '''P'''rogressive '''M'''eshes)
*[[ROAM]] ('''R'''eal-time '''O'''ptimally '''A'''dapting '''M'''eshes)
*[[Geometrical Mipmapping]]
*[[VIPMs]] ('''V'''iew '''I'''ndependent '''P'''rogressive '''M'''eshe'''s''')

:'''Texturierung'''

*[[Texture Splatting]] (Kombination von Texturen mittels [[Blenden|Blending]] und [[Multitexturing]])
*[[Texture Backing]] (Dynamisches erstellen von Texturen)

=== Prozeduale Grafiken ===
Prozeduale Grafiken werden häufig verwendet um
*eine vielfältige Umgebung zu gewährleisten
*Speicherplatz auf der Festplatte zu sparen
*den Grafikern die Arbeit zu erleichtern (und teilweise sogar erst zu ermöglichen)
Die Algorithmen und Möglichkeiten die sich dabei bieten sind hier aufgelistet: <ul>
<li>[[Perlin Noise]] (Algorithmus für Texturen, Landschaft und vieles mehr)</li>
<li>[[L-Systems]] (aus wenig mach viel, Landschaftsgenerierung, Baumgenerierung, ...)</li>
<li>[[Midpoint Displacement]] (primär zur Landschaftsgenerierung)</li>
<li>[[Fault Formation]] (primär zur Landschaftsgenerierung)</li>
<li>[[Prozeduale Landschaft]] (Spezielle Hinweise und Techniken zur Landschaftsgenerierung</li>
<li>[[Prozeduale Bäume]] (Techniken und Algorithmen speziell zur Baumgenerierung)</li>
<li>[[Prozeduale Texturen]] (Spezielle Hinweise zu Wasser, Lava und ähnliches)</li>
</ul>

=== Pathfinding ===
Pathfinding ist einer der grundlegenden Bereiche der Künstlichen Intelligenz, und aus diesem Grund für Spiele mit Computergegnern meistens unumgänglich.
<ul>
<li>[[Tiefensuche]]</li>
<li>[[Breitensuche]]</li>
<li>[[A-Stern]]</li>
<li>[[Dijkstra]]</li>
<li>[[Floyd Warshall]]</li>
<li>[[Navigation Meshes]]</li>
<li>[[Pathfinding-Level of Detail]]</li>
</ul>

=== Sonstiges ===
<ul>
<li>[[Screenshot]]s von OpenGL Ausgaben</li>
<li>[[Interpolation]]</li>
<li>[[Bilder als Ressourcen]] speichern und laden</li>
</ul>

== Externe Links ==
Weitere Links zum Thema "Effekte unter OpenGL" findet ihr in der [[Link]]-Sammlung unter [[Link#Effekte_und_Techniken_mit_OpenGL|Effekte und Techniken mit OpenGL]].

Kamera (2)

2006-01-08T07:01:19Z

Andyh:

Eine Beschreibung findet ihr unter [[Kamera (1)]]. 
Die verwendete Toolsammlung findet ihr unter [[Kamera (3)]].

<pascal>
// Wie ich selber immer wieder merken muss, ist eine Software anscheinend
// nie fertig. Immer moechte man etwas verbessern oder neue Features
// einbauen.
// Sollte also jemand Änderungs- oder Verbesserungsvorschläge haben oder
// neue Ideen einbringen wollen, oder sollten Verstaendnisfragen bestehen,
// so mailt bitte an
//
// Andree.Heyroth@t-online.de
//
// Danke.
//
// Updates:
//
// 06.11.2005
// Die Deklaration der DESTROY Methode war falsch. Das fuehrte dazu,
// dass in der Methode CREATE erzeugte Objekte nicht richtig frei-
// gegeben wurden und es zu EAccessViolations kam. Die Methode wird
// jetzt in der PUBLIC Section mit der Direktive OVERRIDE aufgerufen.
//
// 11.11.2005
// Die Positionierung funktioniert jetzt.
// Wegen eines Verstaendnisproblems wurden die Positionen immer auf den
// Kamerapunkt aufaddiert. Das bedeutete, dass die Positionierung aus
// dem Ruder lief wenn sie nicht im Nullpunkt stattfand. Je groesser die
// gewuenschte Position war um so groesser war die Abweichung von der
// Darstellung.
// Ich habe nicht bedacht, dass bei einer "Kamera"-bewegung und -drehung
// ja eigentlich die Szene bewegt und gedreht wird. Deswegen wurden nach
// einer Positionierung die folgenden Projektionen immer basierend auf der
// danach gueltigen Kameraposition gemacht.
// Jetzt wird die Position so gesetzt, dass die gewuenschte Kameraposition
// immer vor dem Betrachter steht.
//
// 23.11.2005
// Neues Flag (FFixedAxis) zur Entscheidung zwischen angepasster und realer
// Drehung. Dadurch wird das Bewegungsmodell angepasst. Siehe Methode Offset,
// bzw. UpdateMatrixOffset.
//
// 10.12.2005
// Property PointOfRotation ist jetzt nicht mehr ReadOnly.
// Der Blickpunkt bzw. Rotationspunkt kann jetzt direkt verändert werden.
// So kann eine neue Blickrichtung angenommen werden ohne vorher die Kamera-
// eigenschaften zu sichern und nach einem PositionCamera wieder zu setzen.
//
// 19.12.2005
// Neue Methode PositionCross.
// Die Methode PositionCross schiebt das Fadenkreuz in den angegebenen Punkt
// ohne die Lage der Szene zu verändern. Diese Funktionalitaet ist anders als
// ein neues Setzen der Property FPointOfRotation weil dabei die Szene in das
// Koordinatenkreuz geschoben wird.
//
unit Camera;

interface

Uses DglOpenGL, OpenGLUtil, Windows, Classes;

type
TCameraMatrix=Class
StackMatrix: array [0..9] of TArrMatrix;
StackCtr: integer;
Matrix: TArrMatrix;
InverseMatrix: TArrMatrix;
constructor Create;
//destructor destroy;
procedure Identity;
procedure Push;
procedure Pop;
procedure Load(M: TArrMatrix);
end;

TCamera=Class
Enabled: boolean;
function UpVector: TGLvector;
procedure RestorePosition(pos: integer);
procedure SavePosition(pos: integer);
function GiveStoredPosition(pos: integer): TGLvector;
procedure RotateCamera(ix, iy, iz: TGLdouble);
procedure TranslateCamera(ix, iy, iz: TGLdouble);
procedure CameraHome;
procedure PositionCamera(PositionVec: TGLvector; ViewVec: TGLvector; upVec: TGLvector);
procedure Adjust;
procedure Apply;
procedure ApplyForTerrain;
private
FPosition: TGLvector;
FViewDirection: TGLvector;
FPointOfRotation: TGLvector;
HomeMatrix: TCameraMatrix;
CameraMatrix: TCameraMatrix;
Initiated: boolean;
PosArray: array [0..9] of TCameraMatrix;
RotArray: array [0..9] of TGLvector;
FFixedAxis: boolean;
procedure Debug (Text: string);
function UpdateMatrixOffset(newMatrix: TArrMatrix): TArrMatrix;
function GetViewDirection: TGLvector;
procedure SetViewDirection (View: TGLvector);
procedure Initiate;
function GetPosition: TGLvector;
procedure SetPosition (Pos: TGLvector);
procedure Identity;
procedure Offset(x, y, z: TGLfloat);
procedure RotateRoundAxis(rx, ry, rz: TGLfloat);
procedure SetPointOfRotation (NewPoint: TGLvector);
public
constructor Create;
destructor Destroy;override;
function InverseMatrix: TArrMatrix;
procedure PositionCross(CrossVec: TGLvector);
published
property PointOfRotation: TGLvector read FPointOfRotation write SetPointOfRotation;
property Position: TGLvector read GetPosition write SetPosition;
property ViewDirection: TGLvector read GetViewDirection write SetViewDirection;
property FixedAxis: boolean read FFixedAxis write FFixedAxis;
end;
TPCamera=^TCamera;

var
FDebugFile: Textfile;
FDebugFileName: string;
FDebugOn: boolean;

implementation

uses SysUtils, KanalUtil;

constructor TCameraMatrix.Create;
begin
inherited create;
StackCtr := 0;
end;
{
destructor TCameraMatrix.Destroy;
begin
inherited destroy;
end;
}

procedure TCameraMatrix.Push;
begin
if (StackCtr > -1) and (StackCtr < 10) then
begin
StackMatrix[StackCtr] := Matrix;
inc (StackCtr);
end;
end;

procedure TCameraMatrix.Pop;
begin
if (StackCtr > 0) and (StackCtr < 11) then
begin
dec (StackCtr);
Load (StackMatrix[StackCtr]);
end;
end;

procedure TCameraMatrix.Identity;
// GetIdentity: aus OpenGL.pas
// initialisiert die CameraMatrix mit der Identitaetsmatrix
begin
Matrix := GetIdentity(Matrix);
InverseMatrix := GetIdentity(InverseMatrix);
end;

procedure TCameraMatrix.Load(M: TArrMatrix);
// die Matrix mit den Werten einer beliebigen anderen matrix fuellen
var
i: integer;
begin
for i:=0 to 15 do
Matrix[i]:=M[i];
// die invertierte Matrix kann benutzt werden um Objkekte z.B.
// immer zum Benutzer auszurichten
InvertMatrix (M, InverseMatrix);
end;

constructor TCamera.Create;
var
i: integer;
begin
inherited create;

// Initiated wird gebraucht um einmal alle Positionsspeicher
// mit der Anfangsposition zu belegen
Initiated := false;

// Kameramatrix anlegen
CameraMatrix := TCameraMatrix.Create;

// Matrix der letzten Position von PositionCamera anlegen
HomeMatrix := TCameraMatrix.Create;

// Positionsspeicher anlegen
for i := 0 to 9 do
PosArray[i] := TCameraMatrix.Create;

// standardmaessig immer entlang der bildschirmachsen verschieben
FFixedAxis := true;
end;

destructor TCamera.Destroy;
// alle in create belegten Resourcen wieder freigeben
var
i: integer;
begin
FreeAndNil (CameraMatrix);
FreeAndNil (HomeMatrix);
for i := 0 to 9 do
FreeAndNil (PosArray[i]);

inherited destroy;
end;

procedure TCamera.RotateRoundAxis(rx, ry, rz: TGLfloat);
// hier drehen wir jetzt um die einzelnen Achsen.
// die Parameter geben die "Drehgeschwindigkeit" vor.
var
newMatrix: TArrMatrix;
tempX, tempY, tempZ: TGLvector;
begin
glMatrixMode (GL_MODELVIEW);
glPushMatrix();

// aktuelle Position und Lage der Kamera herstellen
glLoadMatrixf(@CameraMatrix.Matrix);

if FFixedAxis then
begin
// über die bildschirmachsen drehen
tempX := GetMatrixX (CameraMatrix.InverseMatrix);
tempY := GetMatrixY (CameraMatrix.InverseMatrix);
tempZ := GetMatrixZ (CameraMatrix.InverseMatrix);
// wenn gewuenscht um die X-Achse drehen
if(rx <> 0) then
glRotatef(rx,tempX.X,tempX.Y,tempX.Z);

// wenn gewuenscht um die Y-Achse drehen
if(ry <> 0) then
glRotatef(ry,tempY.X,tempY.Y,tempY.Z);

// wenn gewuenscht um die Z-Achse drehen
if(rz <> 0) then
glRotatef(rz,tempZ.X,tempZ.Y,tempZ.Z);
end
else
begin
// über die achsen des koordinatenkreuzes drehen
// wenn gewuenscht um die X-Achse drehen
if(rx <> 0) then
glRotatef(rx,1,0,0);

// wenn gewuenscht um die Y-Achse drehen
if(ry <> 0) then
glRotatef(ry,0,1,0);

// wenn gewuenscht um die Z-Achse drehen
if(rz <> 0) then
glRotatef(rz,0,0,1);
end;

// die neu erzeugte Matrix auslesen
glGetFloatv(GL_MODELVIEW_MATRIX, @newMatrix);

glPopMatrix();

// und in die Kameramatrix sichern
CameraMatrix.Load(newMatrix);
end;

procedure TCamera.Identity;
begin
CameraMatrix.Identity;
HomeMatrix.Identity;

Enabled := true;
end;

procedure TCamera.Offset(x, y, z: TGLfloat);
// verschieben der Kamera auf einer beliebigen Achse
var
newMatrix: TArrMatrix;
//OldView: TGLvector;
begin
Debug ('- Offset - Start --------------------------------------------------');
glMatrixMode (GL_MODELVIEW);

glPushMatrix();
glLoadIdentity;
glTranslatef(x,y,z);
glGetFloatv(GL_MODELVIEW_MATRIX, @newMatrix);
glPopMatrix();

Debug ('Position: '+GLvectorToText (GetMatrixPos (newMatrix)));
newMatrix := UpdateMatrixOffset (newMatrix);
CameraMatrix.Load(newMatrix);
Debug ('- Offset - Ende- --------------------------------------------------');
end;

procedure TCamera.PositionCamera(PositionVec: TGLvector;
ViewVec: TGLvector;
upVec: TGLvector);
var
newMatrix: TArrMatrix;
i: integer;
P, V, U: TGLvector;
Laenge: TGLdouble;
begin
Debug ('- PositionCamera - Start ------------------------------------------');
// die gewuenschte konstruktion immer auf die Z-ebene projizieren.
// zuerst die position in den nullpunkt holen
InitVector (P, 0, 0, 0);
// jetzt den viewpoint um den gleichen betrag reduzieren, damit
// die gerade parallel verschoben wird.
V := SubtractVector (ViewVec, PositionVec);
// U ist halt schneller geschrieben als upVec...
U := upVec;

// den betrag ermitteln, um den die kamera nachher auf der Z-Achse
// verschoben werden muss
Laenge := Magnitude (SubtractVector (P, V));

Identity;

glMatrixMode (GL_MODELVIEW);
glPushMatrix;
glLoadIdentity;

// glulookat wird die matrix parallel zur Z-achse ausrichten
gluLookAt (P.X, P.Y, P.Z, V.X, V.Y, V.Z, U.X, U.Y, U.Z);
glGetFloatv(GL_MODELVIEW_MATRIX, @newMatrix);
glPopMatrix;

CameraMatrix.Load(newMatrix);
HomeMatrix.Load(newMatrix);

// da wir uns jetzt am zielpunkt befinden, müssen wir auf der Z-achse
// wieder zurueck zur kameraposition
Offset (0, 0, -Laenge);

// alle positionsspeicher mit der Kameraposition, Blickrichtung
// und dem upVector belegen. Nur beim ersten Aufruf von
// PositionCamera
if not Initiated then
Initiate;

FPointOfRotation := ViewVec;
Debug ('PointOfRotation: '+GLvectorToText (FPointOfRotation));
Debug ('- PositionCamera - Ende -------------------------------------------');
end;

procedure TCamera.PositionCross (CrossVec: TGLvector);
// diese prozedur verschiebt, im gegensatz zu einem verändern von
// PointOfRotation, das Koordinatenkreuz und nicht die Szene.
var
newMatrix: TArrMatrix;
PosDiff: TGLvector;
begin
Debug ('- PositionCross - Start -------------------------------------------');

PosDiff := SubtractVector (FPointOfRotation, CrossVec);

// Szene in das koordinatenkreuz verschieben
FPointOfRotation := CrossVec;

// jetzt die Szene wieder um den gleichen betrag zurückverschieben
// das sieht dann so aus, als ob das koordinatenkreuz verschoben
// worden wäre
// zuerst die aktuelle neue Situation herstellen
// (mit neuem FPointOfRotation)
Apply;

// jetzt um den Differenzbetrag des alten und neuen
// Rotationspunkts zurück verschieben
glTranslatef (-PosDiff.X, 0, 0);
glTranslatef (0, -PosDiff.Y, 0);
glTranslatef (0, 0, -PosDiff.Z);

// jetzt vom neuen Rotationspunktes zurück ins Zentrum, damit beim
// nächsten Apply das glTranslatef (-FPointOfRotation, ...) klappt
glTranslatef (CrossVec.X, 0, 0);
glTranslatef (0, CrossVec.Y, 0);
glTranslatef (0, 0, CrossVec.Z);

// aktuelle Matrix holen...
glGetFloatv(GL_MODELVIEW_MATRIX, @newMatrix);

// und als Kameramatrix abspeichern
CameraMatrix.Load(newmatrix);
Debug ('- PositionCross - Ende --------------------------------------------');
end;

procedure TCamera.CameraHome;
// Kamera in die beim letzten Aufruf von PositionCamera uebergebene
// Position/Lage bringen
begin
CameraMatrix.Load(HomeMatrix.Matrix);
end;

procedure TCamera.SavePosition (pos: integer);
// wie der Prozedurname schon sagt...
begin
if (pos < 0) or (pos > 9) then
exit;

PosArray[pos].Load(CameraMatrix.Matrix);
RotArray[pos] := FPointOfRotation;
end;

procedure TCamera.RestorePosition (pos: integer);
// wie der Prozedurname schon sagt...
begin
if (pos < 0) or (pos > 9) then
exit;

CameraMatrix.Load(PosArray[pos].Matrix);
FPointOfRotation := RotArray[pos];
end;

function TCamera.GiveStoredPosition (pos: integer): TGLvector;
// gibt den Inhalt des durch pos bestimmten
// Positionsspecihers zurueck
begin
if (pos < 0) or (pos > 9) then
exit;

result := GetMatrixPos (PosArray[pos].Matrix);
end;

procedure TCamera.TranslateCamera(ix, iy, iz: TGLdouble);
// vom Benutzer aufzurufende Methode um eine Verschiebung
// durchzufuehren
begin
Offset (ix, iy, iz);
end;

procedure TCamera.RotateCamera(ix, iy, iz: TGLdouble);
// vom Benutzer aufzurufende Methode um eine Drehung
// durchzufuehren
begin
RotateRoundAxis (-iy, -ix, -iz);
end;

procedure TCamera.Apply;
// hier wird die Kamera eingeschaltet. Nach dem Aufruf dieser Prozedur
// sollte die Szene mit allen benoetigten Drehungen, Verschiebungen
// gezeichnet werden.
begin
if not Enabled then
exit;

glMatrixMode (GL_MODELVIEW);
glLoadMatrixf(@CameraMatrix.Matrix);
glTranslatef (-FPointOfRotation.X,
-FPointOfRotation.y,
-FPointOfRotation.Z);
end;

procedure TCamera.ApplyForTerrain;
// hier wird wie in Apply die Kamera eingeschaltet. da man um ein terrain
// (skycube, ...) anzuzeigen aber immer die gleiche entfernung zur welt
// einhalten muss, wird hier nur gedreht und nicht verschoben.
var
pos: TGLvector;
begin
if not Enabled then
exit;

glMatrixMode (GL_MODELVIEW);
// für das Terrain nur die Drehung ausführen
glLoadMatrixf(@CameraMatrix.Matrix);
// deswegen jetzt die verschiebung zurücknehmen
Pos := GetMatrixPos (CameraMatrix.InverseMatrix);
glTranslatef (Pos.X, Pos.Y, Pos.Z);
end;

function TCamera.GetPosition: TGLvector;
// diese Property-Funktion fragt die aktuelle Position der Kamera ab
begin
// position: letzte Spalte der Matrix
result := AddVector (GetMatrixPos (CameraMatrix.InverseMatrix), FPointOfRotation);
end;

procedure TCamera.SetPosition (Pos: TGLvector);
// diese Property-Funktion setzt eine neue Position der Kamera
var
m: TArrMatrix;
begin
// position: letzte Spalte der Matrix
m := CameraMatrix.Matrix;
SetMatrixPos (m, SubtractVector (Pos, FPointOfRotation));
CameraMatrix.Load (m);
end;

function TCamera.GetViewDirection: TGLvector;
// mit dieser Funktion kann die aktuelle Blickrichtung der Kamera
// abgefragt werden
var
return: TGLvector;
begin
// view direction: dritte Spalte der Matrix (Z-Achse)
result := GetMatrixZ (CameraMatrix.InverseMatrix);
end;

procedure TCamera.SetViewDirection (View: TGLvector);
// mit dieser Funktion kann die aktuelle Blickrichtung der Kamera
// gesetzt werden
begin
// view direction: dritte Spalte der Matrix (Z-Achse)
SetMatrixZ (CameraMatrix.InverseMatrix, View);
end;

function TCamera.UpVector: TGLvector;
// mit dieser Funktion kann die aktuelle Ausrichtung der Kamera
// abgefragt werden
var
return: TGLvector;
begin
// upVector: zweite Spalte der Matrix (Y-Achse)
result := GetMatrixY (CameraMatrix.InverseMatrix);
end;

procedure TCamera.Adjust;
// mit dieser Prozedur kann die Kamera zu jeder Zeit, unabhaengig
// von Drehung und Position, zur Y-Achse ausgerichtet werden.
// Die aktuelle Position wird dabei beibehalten.
var
m: TArrMatrix;
v: TGLvector;
begin
// position aus der aktuellen cameramatrix holen
v := GetMatrixPos (CameraMatrix.Matrix);
// m mit identitätsmatrix initialisieren
m := GetIdentity(m);
// die position aus der aktuellen cameramatrix in m speichern
SetMatrixPos (m, v);
// m als aktuelle cameramatrix speichern
CameraMatrix.Load(m);
end;

function TCamera.InverseMatrix: TArrMatrix;
begin
result := CameraMatrix.InverseMatrix;
end;

procedure TCamera.Initiate;
var
i: integer;
begin
for i := 0 to 9 do
SavePosition (i);
Initiated := true;
end;

function TCamera.UpdateMatrixOffset (newMatrix: TArrMatrix): TArrMatrix;
begin
// wenn ich mit Multiply (FixedAxis) arbeite, wird die zeichnung immer
// entlang der bildschirmachsen verschoben. wenn ich Multiply, version 2
// nehme, wird sie auf den errechneten achsen verschoben.
if FFixedAxis then
begin
result := Multiply (newMatrix, CameraMatrix.Matrix);
end
else
begin
result := Multiply (CameraMatrix.Matrix, newMatrix);
end;
end;

procedure TCamera.SetPointOfRotation (NewPoint: TGLvector);
// setzt den viewpoint oder rotationpoint ohne die anderen parameter zu
// veraendern. so kann man z.B. eine Kamerafahrt in immer der gleichen
// position simulieren.
begin
FPointOfRotation := NewPoint;
end;

procedure TCamera.Debug (Text: string);
begin
if not FDebugOn then
exit;
writeln (FDebugFile, DateToStr (date) + ' | ' +
TimeToStr (time) + ' | ' +
Text);
end;

Initialization
FDebugOn := false;
FDebugFileName := ExePath + 'APPLICATION.DBG';
if FDebugOn then
begin
AssignFile (FDebugFile, FDebugFileName);
Rewrite (FDebugFile);
end;

finalization
if FDebugOn then
CloseFile (FDebugFile);

end.
</pascal>
[[Kategorie:Anleitung]]

Kamera (2)

2005-11-19T12:08:49Z

Andyh:

Kamera (2)

2005-11-19T12:08:22Z

Andyh: