Dreidimensionales Array darstellen.

[Muellermilchtrinker]

Hallo DP,

habe ein Array

Delphi-Quellcode:

var cuar: array[1..5][1..5][1..5] of integer

und möchte dieses gerne in 3D darstellen. Habe gedacht, dass ich für jedes Element einen kleinen Würfel mache.
Habe gelesen, dass das mit OpenGL funktioniert. Hat jmd. dafür einen Code, oder ein kleines Tutorial indem das erklärt wird???
Danke euch schonmal.

[Jens01]

http://www.delphigl.com/
Hier gibt es alle Tutorials. Den Würfel mit OpenGL zu machen ist recht einfach. Bis Du OpenGL am Laufen hast, dauert es aber....
Gruss Jens

[Uwe Raabe]

Zitat:

Zitat von Jens01 (Beitrag 1041339)

http://www.delphigl.com/
Hier gibt es alle Tutorials. Den Würfel mit OpenGL zu machen ist recht einfach. Bis Du OpenGL am Laufen hast, dauert es aber....

In dem Fall werfe ich mal GLScene in den Ring. Damit bekommt man das in wenigen Minuten hin. Ich bin auch gerne bereit, die Würfel als Lehrbeispiel zu liefern - allerdings nur wenn eines meiner installierten Delphi's passt...

[Muellermilchtrinker]

Also, ich hab jetzt das Tutorial durch. Mein Formular steht, hat ein blauen Hintergrund und da drin ist ein farbiges Quadrat.
Meine Frage jetzt, wie kann ich das ganze auf einem Panel zeichnen, d.h. das Panel als Darstellung nutzen. Und wie bilde ich jetzt die Würfel???

[blackfin]

Zitat:

GLScene

Ich finde, GLScene ist mit Vorsicht zu geniessen.
Zum "mal schnell was zusammenklicken" mag das ganz nett sein und es hat wirklich mächtige Funktionen, allerdings lässt die Performance ganz schön zu wünschen übrig, sobald man Shader benutzt (für jedes Material und jedes Objekt wird der einzeln Shader initialisiert->gerendert->finalisiert anstatt Objekte mit dem gleichen Shader in einem Aufwasch zu rendern), was das K.O. für jede moderne Applikation ist. Und um das gerade zu biegen, muss man tief in den Source :D
Ausserdem verstecken sich in GLScene massig Bugs, die extrem nerven können. Und hat man dann keine Ahnung von OpenGL, so ist man fast hoffnungslos verloren.
Ich finde die Idee dahinter wirklich gut und verwende es teilweise auch, aber man muss meiner Meinung nach vorher schon in OpenGL halbwegs firm sein, um die Bugs und Fallstricke suchen und eliminieren zu können.

@Müllermilchtrinker: Willst du dir ne Anzeige für einen LED-Cube bauen? :D
Sollte ich die Tage mal Zeit haben, wurschtel ich mal ne Routine zusammen.

Generell sollte dir dabei aber auch folgendes NeHe-Tutorial helfen:
http://nehe.gamedev.net/data/lessons....asp?lesson=05

Ganz unten gibts dafür auch einen Delphi-Quellcode.

Zitat:

Meine Frage jetzt, wie kann ich das ganze auf einem Panel zeichnen

Du verwendest das Handle des Panels für das Erstellen des OpenGL-Context.

[turboPASCAL]

Ich habe da mal etwas vorbe...

So etwas ?
http://www.delphipraxis.net/838301-post10.html
http://www.delphipraxis.net/attachme...enshot_206.jpg

[Muellermilchtrinker]

Ihr habt's erraten. Soll eine Mustererstellung für meinen LED Cube werden. Aber der ist nur 5³. Es steht bis jetzt alles, außer die 3D Ansicht. :D
Das mit dem Panel hat sich erledigt.

[Jens01]

Du solltest Dich hiermit beschäftigen, wenn Du genanntes Tut durch hast :
http://wiki.delphigl.com/index.php/glBegin
Ich würd sagen GL_QUADS und GL_QUAD_STRIP sind wichtig für Dich.

ein Würfel könnte so aussehen :

Delphi-Quellcode:

glBegin(GL_QUADS);
//vorderseite
glVertex3f(0, 0, 0);
glVertex3f(1, 0, 0);
glVertex3f(1, 1, 0);
glVertex3f(0, 1, 0);
//Seite rechts
glVertex3f(0, 1, 0);
glVertex3f(1, 1, 0);
glVertex3f(1, 1, 1);
glVertex3f(0, 1, 1);
//Seite links .. usw
glEnd;

[Muellermilchtrinker]

Hat keiner ein Beispiel für mich???

[Jens01]

Wo hängst Du?
Wenn Du mein Beispiel vervollständigst, hast Du einen ganzen Würfel!
Das ist dasselbe, wie aus dem NeHe Tut, welches blackfin verlinkt hat.
Für viele kleine Würfel mußt Du entweder jeden Würfel einzeln eingeben oder mit einer Schleife die Würfel erzeugen.
Mach mal den ganzen Würfel und guck obs läuft!

[Muellermilchtrinker]

Ich hab jetzt einen großen Cube, aber der ist nicht so schön quadratisch, es ist eher ein Quader.
Dann drehe ich noch so:
Das im Render:

Delphi-Quellcode:

glRotatef(RotateX, 1, 0, 0);
glRotatef(RotateY, 0, 1, 0);
glRotatef(RotateZ, 0, 0, 1);

Und dann ein zweiten Timer mit einem Interval von 1s:

Delphi-Quellcode:

procedure TForm1.Timer2Timer(Sender: TObject);
begin
  RotateY := RotateY - 0.15;
  if RotateY <= 0 then RotateY := RotateY + 360;
  RotateX := RotateX - 0.15;
  if RotateX <= 0 then RotateX := RotateX + 360;
end;

Doch leider ist die Drehung sehr ruckelig. Wie bekomme ich das flüssiger??? Und wie bekomme ich den Cube sauber quadratisch.

[Jens01]

Zitat:

Ich hab jetzt einen großen Cube, aber der ist nicht so schön quadratisch, es ist eher ein Quader.

Das wird am Perspektiv-Modus liegen!
Irgendwo wird bei Dir das stehen:

Delphi-Quellcode:

gluPerspective(45.0, ClientWidth/ClientHeight, NearClipping, FarClipping);

Entweder gewöhnst Du Dich an den Anblick oder Du nimmst den Ortho-Modus
http://wiki.delphigl.com/index.php/glOrtho
http://wiki.delphigl.com/index.php/Tutorial_2D
Guck Dir bitte gluOrtho2D an.

Zitat:

Doch leider ist die Drehung sehr ruckelig. Wie bekomme ich das flüssiger???

Ich verstehe Deinen Code dazu irgendwie nicht, warum addierst Du die Winkel in der Render-Prod nicht einfach auf?

Delphi-Quellcode:

RotateY := RotateY + 1

[Muellermilchtrinker]

Zitat:

Zitat von Jens01 (Beitrag 1042636)

Zitat:

Doch leider ist die Drehung sehr ruckelig. Wie bekomme ich das flüssiger???

Ich verstehe Deinen Code dazu irgendwie nicht, warum addierst Du die Winkel in der Render-Prod nicht einfach auf?

Delphi-Quellcode:

RotateY := RotateY + 1

Den Code hab ich aus irgendeinem Tutorial. Wenn ich da jetzt +1 machen, dann sind die Abstände so groß, das ist dann garnicht mehr flüssig.

Zum Orthomodus:
Das versteh ich nicht. Kann mir nicht jemand die Zeile geben und sagen, wo ich das ändern soll???

PS:
Mich kotzt das ganze OpenGL an. Wieso geht das nicht einfacher??? Ich will jetzt endlich mein Programm fertig haben und mich nicht über dieses blöde OpenGL rumärgern.
Ich bräuchte eigentlich nur einen Code, der mir viele kleine Würfel darstellt. Und dann noch mein Array überprüft, ob eine eins, dann soll die Farbe des Würfels anders sein, als wenn dort eine null steht.

[Jens01]

Zitat:

Wenn ich da jetzt +1 machen, dann sind die Abstände so groß, das ist dann garnicht mehr flüssig.

Probier doch einen kleineren Summanden aus, zB 0.15.

Delphi-Quellcode:

if RotateY <= 0 then RotateY := RotateY + 360;

Ich glaube, diese Zeile hat in Deinem Code den Ärger gemacht.

Zitat:

Zum Orthomodus:
Das versteh ich nicht. Kann mir nicht jemand die Zeile geben und sagen, wo ich das ändern soll???

Wenn Du den Code aus dem Tut abgetippt hast, dann mußt Du die diese Zeile :

Delphi-Quellcode:

gluPerspective(45.0, ClientWidth/ClientHeight, NearClipping, FarClipping);

mit gluOrhto2D ersetzen.

Zitat:

Mich kotzt das ganze OpenGL an.

Ich hatte doch gesagt, dass OpenGL etwas länger dauert bis es läuft! Das ist 3D Grafik und dafür braucht man eben etwas. Wenn es kannst, dann gibt es Ruhm, Ehre und Anerkennung!:wink:

[Muellermilchtrinker]

Zitat:

Zitat von Jens01 (Beitrag 1042884)

Zitat:

Wenn ich da jetzt +1 machen, dann sind die Abstände so groß, das ist dann garnicht mehr flüssig.

Probier doch einen kleineren Summanden aus, zB 0.15.

Der kleine Summand, hab ich ja und es ist immer noch nicht flüssig. Hab die zwei Zeilen mal auskommentiert.
EDIT: Das mit dem flüssig hat sich erledigt, ich nutze ja die Timer Methode und musste da einfach die Framezahl bzw. Das Interval ändern.

Zitat:

Zitat von Jens01 (Beitrag 1042884)

Zitat:

Zum Orthomodus:
Das versteh ich nicht. Kann mir nicht jemand die Zeile geben und sagen, wo ich das ändern soll???

Wenn Du den Code aus dem Tut abgetippt hast, dann mußt Du die diese Zeile :

Delphi-Quellcode:

gluPerspective(45.0, ClientWidth/ClientHeight, NearClipping, FarClipping);

mit gluOrhto2D ersetzen.

Ich würd es ja ersetzen, aber ich weiß nicht, welche Parameter ich übergeben muss.

Zitat:

Zitat von Jens01 (Beitrag 1042884)

Zitat:

Mich kotzt das ganze OpenGL an.

Ich hatte doch gesagt, dass OpenGL etwas länger dauert bis es läuft! Das ist 3D Grafik und dafür braucht man eben etwas. Wenn es kannst, dann gibt es Ruhm, Ehre und Anerkennung!:wink:

Eigentlich sollte das nur für ein bzw. zwei Projekte sein. Und bei dem zweiten ist das das gleiche wie im ersten. Ich mein den Code, nicht das man denkt, dass das Projekt das selbe ist.

[Muellermilchtrinker]

Keiner ne Ahnung???

[Jens01]

Okay, Du gibst nicht auf. Also ..

Zitat:

Eigentlich sollte das nur für ein bzw. zwei Projekte sein. Und bei dem zweiten ist das das gleiche wie im ersten. Ich mein den Code, nicht das man denkt, dass das Projekt das selbe ist.

Ich sagte ja schon, das ist 3D Grafik und nicht so trivial. Hier gibt es eigentlich nur ganz oder gar nicht. Ansonsten mußt Du einen suchen, der es Dir macht. Hier gibt es wohl auch einige Freiberufler, die es für Geld machen.
GLScene ist ganz sicher auch eine gute Komponente, die es für D2009 bei sourceforge gibt.

Zitat:

Ich würd es ja ersetzen, aber ich weiß nicht, welche Parameter ich übergeben muss.

Ich selbst müßte -ehrlich gesagt- auch nachgucken, welche Parameter man genau einsetzen muß. Ich habe das für mich in der Hauptsache durch Probieren (try and error) herausgefunden. Bei meinem Programmteil läuft es.:wink:
Hier sind aber gute Beispiele und einige Übungen -auch für diese Ortho-Sache. Das Buch mußt Du DIr ja nicht unbedingt kaufen.
http://www.inf.tu-dresden.de/content...amme/index.htm

[Medium]

Ohne nen büschen Arbeit und Einsatz geht's halt nicht. Du willst ne 3D-Darstellung, also musst du eine bauen. Die nötigen Infos hast du, und die OpenGL Docs sind nicht wirklich schlecht. Was fix und fertiges gibt's so wohl nicht. Eigentlich ist das sogar ein 1A Einstiegsprojekt für OpenGL, da es ein wunderbares und simples Beispiel ist.

[Muellermilchtrinker]

Zitat:

Zitat von Jens01 (Beitrag 1043517)

Okay, Du gibst nicht auf. Also ..

Wer hat gesagt, dass ich aufgeb??? :D

Zitat:

Zitat von Jens01 (Beitrag 1043517)

Ich sagte ja schon, das ist 3D Grafik und nicht so trivial. Hier gibt es eigentlich nur ganz oder gar nicht. Ansonsten mußt Du einen suchen, der es Dir macht. Hier gibt es wohl auch einige Freiberufler, die es für Geld machen.
GLScene ist ganz sicher auch eine gute Komponente, die es für D2009 bei sourceforge gibt.

Ich will des jetzt schon mit OpenGL machen. Hab ja auch damit angefangen und zahlen will ich nicht. :D

Aber ich werd mir deine Seite demnächst mal anschauen. Jetzt steht erstmal Urlaub auf dem Plan. :D

Einen CubeEditor sollte ja auch 3D-Ansicht enthalten und der dazugehörige Simulator dafür, brauch ja auch was als Ausgabe. Werd mich wieder melden, wenn ich ein Problem hab (wird noch öfters vorkommen :stupid:).

[PhilmacFLy]

Nur so als Gedanke, wie wärs wenn dus anstatt als Würfel also Tabellen darstelltst und die z Achse die anzahl der Tabellen sind und die quasi so durchblättern lässt?

[Muellermilchtrinker]

Zum ändern/erstellen der Muster hab ich ja die Ebenen, die ich dann durchschalten kann.
Ich möchte aber noch eine 3D Ansicht machen, damit man das Muster auch "real" sieht.

[Jens01]

Okay, bis dahin.
Meld Dich auch bei DGL an, die Leute sind richtig fit bei OpenGL.

Und sag, was ist Urlaub!?:shock:

[Muellermilchtrinker]

Zitat:

Zitat von Jens01 (Beitrag 1043679)

Und sag, was ist Urlaub!?:shock:

Weißt du das nicht??? Man geht da in ein anderes Land/Gebiet/Stadt und entspannt sich dort. :-D

Aber back to topic:

PROBLEM GELÖST
Ich hab das Problem gelöst (ohne gluOrtho2D :shock:). Mir wurde auf DGL geraten diese Zeile:

Delphi-Quellcode:

gluPerspective(45.0, ClientWidth/ClientHeight, NearClipping, FarClipping);

durch diese Zeile zu ersetzen:

Delphi-Quellcode:

gluPerspective(45.0, panel1.ClientWidth/panel1.ClientHeight, NearClipping, FarClipping);

Und es hat geklappt. Begründung: mit meinem vorherigen Code hab ich alles auf die Formulargröße gesetzt. MIt diesem Code mach ich das auf mein Panel und das ist ja so schön quadratisch. :-D Und jetzt ist mein Würfel ein Würfel. :stupid:

Weiter gehts:

Ich hab mir jetzt diese Prozedur geschrieben:

Delphi-Quellcode:

procedure TForm1.Cube(Color:Integer);
begin
    if Color <> 0 then glColor4f(0.5, 0.5, 1.0, 0.8)  // Set The Color
    else glColor4f(0.3, 0.3, 0.3, 0.4);
      glVertex3f( 1.0, 1.0,-1.0);         // Top Right Of The Quad (Top)
      glVertex3f(-1.0, 1.0,-1.0);         // Top Left Of The Quad (Top)
      glVertex3f(-1.0, 1.0, 1.0);         // Bottom Left Of The Quad (Top)
      glVertex3f( 1.0, 1.0, 1.0);         // Bottom Right Of The Quad (Top)

    if Color <> 0 then glColor4f(0.5, 0.5, 1.0, 0.8)  // Set The Color
    else glColor4f(0.3, 0.3, 0.3, 0.4);
      glVertex3f( 1.0,-1.0, 1.0);         // Top Right Of The Quad (Bottom)
      glVertex3f(-1.0,-1.0, 1.0);         // Top Left Of The Quad (Bottom)
      glVertex3f(-1.0,-1.0,-1.0);         // Bottom Left Of The Quad (Bottom)
      glVertex3f( 1.0,-1.0,-1.0);         // Bottom Right Of The Quad (Bottom)

    if Color <> 0 then glColor4f(0.5, 0.5, 1.0, 0.8)  // Set The Color
    else glColor4f(0.3, 0.3, 0.3, 0.4);
      glVertex3f( 1.0, 1.0, 1.0);         // Top Right Of The Quad (Front)
      glVertex3f(-1.0, 1.0, 1.0);         // Top Left Of The Quad (Front)
      glVertex3f(-1.0,-1.0, 1.0);         // Bottom Left Of The Quad (Front)
      glVertex3f( 1.0,-1.0, 1.0);         // Bottom Right Of The Quad (Front)

    if Color <> 0 then glColor4f(0.5, 0.5, 1.0, 0.8)  // Set The Color
    else glColor4f(0.3, 0.3, 0.3, 0.4);
      glVertex3f( 1.0,-1.0,-1.0);         // Bottom Left Of The Quad (Back)
      glVertex3f(-1.0,-1.0,-1.0);         // Bottom Right Of The Quad (Back)
      glVertex3f(-1.0, 1.0,-1.0);         // Top Right Of The Quad (Back)
      glVertex3f( 1.0, 1.0,-1.0);         // Top Left Of The Quad (Back)

    if Color <> 0 then glColor4f(0.5, 0.5, 1.0, 0.8)  // Set The Color
    else glColor4f(0.3, 0.3, 0.3, 0.4);
      glVertex3f(-1.0, 1.0, 1.0);         // Top Right Of The Quad (Left)
      glVertex3f(-1.0, 1.0,-1.0);         // Top Left Of The Quad (Left)
      glVertex3f(-1.0,-1.0,-1.0);         // Bottom Left Of The Quad (Left)
      glVertex3f(-1.0,-1.0, 1.0);         // Bottom Right Of The Quad (Left)

    if Color <> 0 then glColor4f(0.5, 0.5, 1.0, 0.8)  // Set The Color
    else glColor4f(0.3, 0.3, 0.3, 0.4);
      glVertex3f( 1.0, 1.0,-1.0);         // Top Right Of The Quad (Right)
      glVertex3f( 1.0, 1.0, 1.0);         // Top Left Of The Quad (Right)
      glVertex3f( 1.0,-1.0, 1.0);         // Bottom Left Of The Quad (Right)
      glVertex3f( 1.0,-1.0,-1.0);         // Bottom Right Of The Quad (Right)
end;

Damit mache ich mein Cube und kann die Farbe beeinflussen. aber das ist ja nur ein Cube. Ich brauch aber mehrere (genau: 125). Wie schaffe ich die Verschiebung (je nach Koordinate)??? Zwischen den Cubes sollte auch ein bisschen Platz sein.

[blackfin]

glTranslate()

und

Tutorial Matrix 2

[Muellermilchtrinker]

Delphi-Quellcode:

    for x := 1 to 5 do
    begin
      for y := 1 to 5 do
      begin
        for z := 1 to 5 do
        begin
          glTranslatef(x/10,y/10,z/10);
          glBegin(GL_QUADS);
            Cube(0);
          glEnd;
        end;
      end;
    end;

Gibt leider nicht das Ergebnis. Ich glaub ich hab irgendwo in der Routine ein Problem.

[blackfin]

Kurz nur draufgesehen, mögliches Problem:

Du verschiebst in deiner Routine ja immer weiter, ohne dass du den Zeichenstift zurücksetzt :)
OpenGL ist eine State-Machine, das heisst, wenn du verschiebst, verschiebt er immer relativ!

Also: Ursprung vor jedem Cube setzen:

Delphi-Quellcode:

 for x := 1 to 5 do
    begin
      for y := 1 to 5 do
      begin
        for z := 1 to 5 do
        begin
          glMatrixMode(GL_MODELVIEW) ; // optional, falls ModelView-Matrix nicht aktiv
          glLoadIdentity() ; // <---- möööp :D
          glTranslatef(x/10,y/10,z/10);
          glBegin(GL_QUADS);
            Cube(0);
          glEnd;
        end;
      end;
    end;

[Jens01]

Ich persönlich würde hier eine bzw mehrere Schleifen bevorzugen.
ganz grob z.B.:

Delphi-Quellcode:

procedure WholeCube;
var
  i: Integer;
  i2: Integer;
  i3: Integer;
  x, y,z : Double;
begin
  Ebene := 5;
  Reihe := 5;
  Spalte := 5;

  z := 0;
  for i := 0 to Ebene - 1 do
  begin
    y := 0;
    for i2 := 0 to Reihe - 1 do
    begin
      x := 0;
      for i3 := 0 to Spalte - 1 do
      begin
        Cube(x, y, z);
        x := x + Abstand
      end;
      y := Y + Abstand;
    end;
    z := z + Abstand;
  end;
end;

Delphi-Quellcode:

procedure Cube(x,y,z: Double);
begin
  glVertex3f( 1.0 + x, 1.0 + Y,-1.0 + z);         // Top Right Of The Quad (Top)
  glVertex3f(-1.0 + x, 1.0 + Y,-1.0 + z);         // Top Left Of The Quad (Top)
  glVertex3f(-1.0 + x, 1.0 + Y, 1.0 + z);         // Bottom Left Of The Quad (Top)
  glVertex3f( 1.0 + x, 1.0 + Y, 1.0 + z);         // Bottom Right Of The Quad (Top)
  ...
end;

Also das ist jetzt eine ganz grobe Skizze (das funktioniert so 1:1 noch nicht). Für den Würfel selbst sollte man vielleicht auch eine Schleife nutzen.

Jetzt hast Du 2 Möglichkeiten!

[blackfin]

Wenn schon optimieren: Ich würde das Zeichnen eines einzelnen Cubes in eine Display-Liste speichern, die man nur noch aufrufen muss. (Stichwörter: GlNewList und GLEndList).
Das ist wesentlich schneller als dauernd glbegin / glvertex / glend.

Aber das ist erst dann angesagt, wenn die "normale" routine funzt :D

[Muellermilchtrinker]

Also mein aktueller Code sieht so aus:

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, ExtCtrls, dglOpenGL;

Type
  TVector2f = Array [0..1] of Single;
  TVector3f = Array [0..2] of Single;

type
  TForm1 = class(TForm)
    Panel1: TPanel;
    Timer1: TTimer;
    Timer2: TTimer;
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
    procedure Timer1Timer(Sender: TObject);
    procedure Timer2Timer(Sender: TObject);
  private
    { Private-Deklarationen }
    FrameCount  : Cardinal; //FrameCounter
    procedure SetupGL;
    procedure Render;
    procedure ErrorHandler;
    procedure Cube(x,y,z:Double;Color:Integer);
  public
    { Public-Deklarationen }
    DC                                : HDC;  //Handle auf Zeichenfläche
    RC                                : HGLRC;//Rendering Context
  end;

var
  Form1: TForm1;

const
  NearClipping = 1;
  FarClipping  = 1000;

var
  RotateX  : single;                 // Rotation um die X-Achse
  RotateY  : single;                 // Rotation um die Y-Achse
  RotateZ  : single;                 // Rotation um die Z-Achse
  PosVect  : TVector3f;         // Vector mit der Position des Objektes.

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
  DC:= GetDC(Panel1.Handle);
  if not InitOpenGL then Application.Terminate;
  RC:= CreateRenderingContext( DC,
                               [opDoubleBuffered],
                               32,
                               24,
                               0,0,0,
                               0);
  ActivateRenderingContext(DC, RC);
  SetupGL;
end;

procedure TForm1.SetupGL;
begin
  glClearColor(0.0, 0.0, 0.0, 0.0); //Hintergrundfarbe:
  glEnable(GL_DEPTH_TEST);          //Tiefentest aktivieren
  glEnable(GL_CULL_FACE);           //Backface Culling aktivieren

  RotateX := 0;
  RotateY := 0;
  RotateZ := 0;
  PosVect[0] := 0;
  PosVect[1] := 0;
  PosVect[2] := -5;
end;

procedure TForm1.Cube(x,y,z:Double;Color:Integer);
begin
    if Color <> 0 then glColor4f(0.5, 0.5, 1.0, 0.8)  // Set The Color
    else glColor4f(0.3, 0.3, 0.3, 0.4);
      glVertex3f( 1.0+x, 1.0+y,-1.0+z);         // Top Right Of The Quad (Top)
      glVertex3f(-1.0+x, 1.0+y,-1.0+z);         // Top Left Of The Quad (Top)
      glVertex3f(-1.0+x, 1.0+y, 1.0+z);         // Bottom Left Of The Quad (Top)
      glVertex3f( 1.0+x, 1.0+y, 1.0+z);         // Bottom Right Of The Quad (Top)

    if Color <> 0 then glColor4f(0.5, 0.5, 1.0, 0.8)  // Set The Color
    else glColor4f(0.3, 0.3, 0.3, 0.4);
      glVertex3f( 1.0+x,-1.0+y, 1.0+z);         // Top Right Of The Quad (Bottom)
      glVertex3f(-1.0+x,-1.0+y, 1.0+z);         // Top Left Of The Quad (Bottom)
      glVertex3f(-1.0+x,-1.0+y,-1.0+z);         // Bottom Left Of The Quad (Bottom)
      glVertex3f( 1.0+x,-1.0+y,-1.0+z);         // Bottom Right Of The Quad (Bottom)

    if Color <> 0 then glColor4f(0.5, 0.5, 1.0, 0.8)  // Set The Color
    else glColor4f(0.3, 0.3, 0.3, 0.4);
      glVertex3f( 1.0+x, 1.0+y, 1.0+z);         // Top Right Of The Quad (Front)
      glVertex3f(-1.0+x, 1.0+y, 1.0+z);         // Top Left Of The Quad (Front)
      glVertex3f(-1.0+x,-1.0+y, 1.0+z);         // Bottom Left Of The Quad (Front)
      glVertex3f( 1.0+x,-1.0+y, 1.0+z);         // Bottom Right Of The Quad (Front)

    if Color <> 0 then glColor4f(0.5, 0.5, 1.0, 0.8)  // Set The Color
    else glColor4f(0.3, 0.3, 0.3, 0.4);
      glVertex3f( 1.0+x,-1.0+y,-1.0+z);         // Bottom Left Of The Quad (Back)
      glVertex3f(-1.0+x,-1.0+y,-1.0+z);         // Bottom Right Of The Quad (Back)
      glVertex3f(-1.0+x, 1.0+y,-1.0+z);         // Top Right Of The Quad (Back)
      glVertex3f( 1.0+x, 1.0+y,-1.0+z);         // Top Left Of The Quad (Back)

    if Color <> 0 then glColor4f(0.5, 0.5, 1.0, 0.8)  // Set The Color
    else glColor4f(0.3, 0.3, 0.3, 0.4);
      glVertex3f(-1.0+x, 1.0+y, 1.0+z);         // Top Right Of The Quad (Left)
      glVertex3f(-1.0+x, 1.0+y,-1.0+z);         // Top Left Of The Quad (Left)
      glVertex3f(-1.0+x,-1.0+y,-1.0+z);         // Bottom Left Of The Quad (Left)
      glVertex3f(-1.0+x,-1.0+y, 1.0+z);         // Bottom Right Of The Quad (Left)

    if Color <> 0 then glColor4f(0.5, 0.5, 1.0, 0.8)  // Set The Color
    else glColor4f(0.3, 0.3, 0.3, 0.4);
      glVertex3f( 1.0+x, 1.0+y,-1.0+z);         // Top Right Of The Quad (Right)
      glVertex3f( 1.0+x, 1.0+y, 1.0+z);         // Top Left Of The Quad (Right)
      glVertex3f( 1.0+x,-1.0+y, 1.0+z);         // Bottom Left Of The Quad (Right)
      glVertex3f( 1.0+x,-1.0+y,-1.0+z);         // Bottom Right Of The Quad (Right)
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  DeactivateRenderingContext;
  DestroyRenderingContext(RC);
  ReleaseDC(Handle, DC);
end;

procedure TForm1.Render;
Const voffset : TVector3f = (0.0, 0.0, 0.0);
      toffset : TVector2f = (0.0, 0.0);
      tscale  : TVector2f = (1.0, 1.0);
var x,y,z:Integer;
begin
  glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);

  glMatrixMode(GL_PROJECTION);
  glLoadIdentity;
  gluPerspective(150.0, Panel1.ClientWidth/Panel1.ClientHeight, NearClipping, FarClipping);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity;

  glTranslatef(0, 0, 0);

  // Das Objekt auf seine aktuelle Position setzen.
  glTranslatef( PosVect[0],  PosVect[1],  PosVect[2]);

  { Das Objekt noch drehen, damit denn wir haben bis jetzt ja nur den }
  { Vector gedreht.                                                   }
  glRotatef(RotateX, 1, 0, 0);
  glRotatef(RotateY, 0, 1, 0);
  glRotatef(RotateZ, 0, 0, 1);

  glBegin(GL_QUADS);
    for x := 0 to 4 do
      for y := 0 to 4 do
        for z := 0 to 4 do
          Cube(x*3,y*3,z*3,0);
  glEnd;

  SwapBuffers(DC);
end;

procedure TForm1.Timer1Timer(Sender: TObject);
begin
  inc(FrameCount);
  Render;
  If FrameCount = 20 then
  begin
    ErrorHandler;
    FrameCount := 0;
  end;
end;

procedure TForm1.Timer2Timer(Sender: TObject);
begin
  RotateY := RotateY + 0.5;
//  if RotateY <= 0 then RotateY := RotateY + 360;
//  RotateX := RotateX + 0.5;
//  if RotateX <= 0 then RotateX := RotateX + 360;
//  RotateZ := RotateY + 0.5;
end;

procedure TForm1.ErrorHandler;
begin
  Form1.Caption := string(gluErrorString(glGetError));
end;

end.

Rauskommt nun das: siehe Video in der Zip Datei: Anhang 31950 PS: Das ruckeln kommt von der Aufnahme. In Wirklichkeit ist es schön flüssig. Leider sieht es noch nicht so aus, wie in diesem Beispiel: http://www.delphipraxis.net/1041654-post6.html

Farben sind die gleichen. Hab von turboPASCAL schon den Code bekommen. Blick aber nicht ganz so durch und ich will es ja selber machen. Farben sind die gleichen wie in dem Programm von turboPASCAL

[Jens01]

von der Bewegung her, solltest Du Dich mit dem Kamera-Thema auseinandersetzen.
http://wiki.delphigl.com/index.php/Kamera

Der Autor hat ein Programmteil veröffentlicht, welches (bis auf Kleinigkeiten) gut läuft. Es läßt sich auch in Dein Programm einfacher einbinden, als man am Anfang vermuten würde. Ggf kannst Du den Autor auch einfach ansprechen.

Bei Deinem Problem mit den Farben mußt Du konkreter werden.

[Muellermilchtrinker]

wie bekomme, ich das so schön wie in dem beispiel von turboPASCAL??? bei ihm sind ja die würfel halb durchsichtig.
Die Farbe hab ich aus seinem Code

[Jens01]

Das mit den transparenten Farben stell erst einmal nach ganz hinten. Das kann richtig kompliziert werden! Im schlimmsten Fall mußt Du tiefensortieren.
(Ich weiß nicht wie es turboPascal gemacht hat.)

[Muellermilchtrinker]

Oh man. Ich dachte da müsste man nicht soviel beachten.

[blackfin]

Zitat:

Das mit den transparenten Farben stell erst einmal nach ganz hinten. Das kann richtig kompliziert werden! Im schlimmsten Fall mußt Du tiefensortieren.

Nö :D naja...doch..aber zum ersten Testen:
Mach mal einfach folgendes nach
glEnable(GL_CULL_FACE);

Delphi-Quellcode:

glEnable(GL_BLEND) ;
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);

Edit: und schalte dazu mal glEnable(GL_DEPTH_TEST); aus! also auskommentieren! Der Tiefentest beisst sich nämlich in diesem konkreten Fall mit dem Alphablending.

achja und setz beim Aufruf von Cube den letzten Parameter auf 1 statt 0!
In deiner Cube-Routine setzt du auch dauernd die color neu, das brauchst du gar nicht, da OpenGL eine Statemachine ist, einmal genügt, bis du ne andere Farbe brauchst.

Und warums sch**** aussieht in deinem Fall, liegt an der Kamera.
Eine Nearclippingplane von 1 und eine Farclippingplane von 1000 ist Mist hoch 8! :D
Durch diese riesen Grenzen wird nur die Genauigkeit extrem verschlechtert.
Nimm mal probeweise lieber:

Delphi-Quellcode:

NearClipping = 0.1;
FarClipping = 100;

Zitat:

Oh man. Ich dachte da müsste man nicht soviel beachten.

:lol::lol::lol::lol::lol::lol::lol::lol::lol:
Willkommen in der Matrix!

[Muellermilchtrinker]

Also, das mit dem transparent ist jetzt so, wie ich es mir vorgestellt hab.
Ich denke jetzt fehlt nur noch die Kamera, um eine ordentliche Anzeige zu haben. Oder???

[blackfin]

Zitat:

Ich denke jetzt fehlt nur noch die Kamera, um eine ordentliche Anzeige zu haben. Oder???

Joa :) Und dass sich der Würfel auch um die Mittelachse dreht :) Da hab ich dir aber ein Tutorial verlinkt auf der ersten dritten Seite, damit müsstest du das auch hinbekommen.
Stichwort: Translate vor Rotate / Rotate vor translate usw. :D

[blackfin]

Ich hab heute nen lieben Tag....:lol:

Also, folgendes ändern:

Delphi-Quellcode:

PosVect[2] := -20;

dann...
Bei allen Schleifen anstatt von 0 bis 4:

Delphi-Quellcode:

for xyz := -2 to 2 do

und eben die Nearclipping und Farclipping wie im obigen Beitrag

und:

Delphi-Quellcode:

gluPerspective(90.0, Panel1.ClientWidth/Panel1.ClientHeight, NearClipping, FarClipping);

[Muellermilchtrinker]

Danke, Danke.
Ich glaub jetzt ist alles fertig und ich kann es in mein Programm einbauen. Hatte bis jetzt nur ein extra Programm um alles zu testen und meinen originalen Code vom richtigen Programm zu schonen. :stupid:

EDIT: Ich frag lieber euch: Fehlt noch was??? :stupid:

[blackfin]

Fragst du nach Optimierungs-Möglichkeiten? Frag lieber nicht :stupid:
Ansonsten...Licht fehlt bzw. generell kann ein Cube ja nur zwei farben haben (an/aus). Ist das kein RGB-Teil?

[Muellermilchtrinker]

Ich sch**ß auf Optimierungen. :D
Nein der Cube ist ein stinklangweiligernormaler 5³ LED Cube mit blauen LEDs. :lol:
Obwohl schon die Software (Bascom) steht und alles funktioniert und ich mir nur meine Muster von Hand (Bytes zusammenklicken) müsste, bin ich so verrückt und nutze meine letzten zwei Pins vom AtMega32 für eine RS232-Anbindung. Damit ich dann auch meine Musik anzeigen kann und mit dem Editor dann sofort das Muster auf dem Cube hab. :lol:
Glücklicherweise waren die letzten zwei Portpins RxD und TxD. Hab ich ein Glück. :stupid: