Würfel

Aus DGL Wiki
Wechseln zu: Navigation, Suche

Allgemein

Ein Würfel besteht aus 8 Punkten, 12 Kanten und 6 Flächen. Hier wird der Würfel mit der OpenGl Zeichenroutine GL_QUADS (siehe glBegin) gerendert. Es wird die aktiv gebundene Textur für alle Flächen benutzt. Will man jede Flache mit einer einzelnen Textur versehen, muss man die Texturen vor der entsprechenden Fläche binden. Außerdem muss man jede Fläche in ein eigenes glBegin/glEnd-Paar klammern.


Verwendete Typen

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


Parameter

Die Kantenlängen des Würfels werden mit den Parametern dx, dy, dz in der jeweiligen Dimension (x, y und z) festgelegt.

Inverted gibt an, ob die Würfelflächen-normalen nach außen (false) oder nach innen (true) zeigen. (siehe glFrontFace)

Der Parameter voffset dient dazu den Würfel zu verschieben. Achtung: Der Würfel-Ursprung bleibt dabei erhalten. D.h. ein vorangestelltes glRotatef rotiert den Würfel nicht um sich selbst, sondern um dessen Ursprung.

Die Parameter toffset und tscale beziehen sich auf die Textur-Koordinaten. toffset verschiebt die Textur in u- und v-Richtung, wohingegen tscale die Textur in u- und v-Richtung skaliert.


Procedure

Procedure DrawBoxObject(dx, dy, dz: Single; inverted: boolean; 
                        voffset: TVector3f; toffset, tscale: TVector2f);
Var i : shortint;
Begin
  If (inverted)
    Then i := -1
    Else i := +1;

  dx := 0.5 * dx;
  dy := 0.5 * dy;
  dz := 0.5 * dz;

  glBegin(GL_QUADS);
    // left (inverted: right)
    glNormal3f(-1, 0, 0);
    glTexCoord2f(            toffset[0],             toffset[1]);
    glVertex3f(-dx*i + voffset[0], -dy + voffset[1], -dz + voffset[2]);
    glTexCoord2f(tscale[0] + toffset[0],             toffset[1]);
    glVertex3f(-dx*i + voffset[0], -dy + voffset[1], +dz + voffset[2]);
    glTexCoord2f(tscale[0] + toffset[0], tscale[1] + toffset[1]);
    glVertex3f(-dx*i + voffset[0], +dy + voffset[1], +dz + voffset[2]);
    glTexCoord2f(            toffset[0], tscale[1] + toffset[1]);
    glVertex3f(-dx*i + voffset[0], +dy + voffset[1], -dz + voffset[2]);

    // right (inverted: left)
    glNormal3f(1, 0, 0);
    glTexCoord2f(            toffset[0],             toffset[1]);
    glVertex3f(+dx*i + voffset[0], -dy + voffset[1], +dz + voffset[2]);
    glTexCoord2f(tscale[0] + toffset[0],             toffset[1]);
    glVertex3f(+dx*i + voffset[0], -dy + voffset[1], -dz + voffset[2]);
    glTexCoord2f(tscale[0] + toffset[0], tscale[1] + toffset[1]);
    glVertex3f(+dx*i + voffset[0], +dy + voffset[1], -dz + voffset[2]);
    glTexCoord2f(            toffset[0], tscale[1] + toffset[1]);
    glVertex3f(+dx*i + voffset[0], +dy + voffset[1], +dz + voffset[2]);

    // top (inverted: bottom)
    glNormal3f(0, 1, 0);
    glTexCoord2f(            toffset[0],             toffset[1]);
    glVertex3f(-dx + voffset[0], +dy*i + voffset[1], +dz + voffset[2]);
    glTexCoord2f(tscale[0] + toffset[0],             toffset[1]);
    glVertex3f(+dx + voffset[0], +dy*i + voffset[1], +dz + voffset[2]);
    glTexCoord2f(tscale[0] + toffset[0], tscale[1] + toffset[1]);
    glVertex3f(+dx + voffset[0], +dy*i + voffset[1], -dz + voffset[2]);
    glTexCoord2f(            toffset[0], tscale[1] + toffset[1]);
    glVertex3f(-dx + voffset[0], +dy*i + voffset[1], -dz + voffset[2]);

    // bottom (inverted: top)
    glNormal3f(0, -1, 0);
    glTexCoord2f(            toffset[0],             toffset[1]);
    glVertex3f(-dx + voffset[0], -dy*i + voffset[1], -dz + voffset[2]);
    glTexCoord2f(tscale[0] + toffset[0],             toffset[1]);
    glVertex3f(+dx + voffset[0], -dy*i + voffset[1], -dz + voffset[2]);
    glTexCoord2f(tscale[0] + toffset[0], tscale[1] + toffset[1]);
    glVertex3f(+dx + voffset[0], -dy*i + voffset[1], +dz + voffset[2]);
    glTexCoord2f(            toffset[0], tscale[1] + toffset[1]);
    glVertex3f(-dx + voffset[0], -dy*i + voffset[1], +dz + voffset[2]);

    // front (inverted: back)
    glNormal3f(0, 0, 1);
    glTexCoord2f(            toffset[0],             toffset[1]);
    glVertex3f(-dx + voffset[0], -dy + voffset[1], +dz*i + voffset[2]);
    glTexCoord2f(tscale[0] + toffset[0],             toffset[1]);
    glVertex3f(+dx + voffset[0], -dy + voffset[1], +dz*i + voffset[2]);
    glTexCoord2f(tscale[0] + toffset[0], tscale[1] + toffset[1]);
    glVertex3f(+dx + voffset[0], +dy + voffset[1], +dz*i + voffset[2]);
    glTexCoord2f(            toffset[0], tscale[1] + toffset[1]);
    glVertex3f(-dx + voffset[0], +dy + voffset[1], +dz*i + voffset[2]);

    // back (inverted: front)
    glNormal3f(0, 0, -1);
    glTexCoord2f(            toffset[0],             toffset[1]);
    glVertex3f(+dx + voffset[0], -dy + voffset[1], -dz*i + voffset[2]);
    glTexCoord2f(tscale[0] + toffset[0],             toffset[1]);
    glVertex3f(-dx + voffset[0], -dy + voffset[1], -dz*i + voffset[2]);
    glTexCoord2f(tscale[0] + toffset[0], tscale[1] + toffset[1]);
    glVertex3f(-dx + voffset[0], +dy + voffset[1], -dz*i + voffset[2]);
    glTexCoord2f(            toffset[0], tscale[1] + toffset[1]);
    glVertex3f(+dx + voffset[0], +dy + voffset[1], -dz*i + voffset[2]);
  glEnd;
End;


Beispiel Aufruf

Einen nach außen ausgerichteten Würfel mit der Kantenlänge 1 und normalen Texturkoordinaten zeichnet man wie folgt: 

Const voffset : TVector3f = (0.0, 0.0, 0.0);
      toffset : TVector2f = (0.0, 0.0);
      tscale  : TVector2f = (1.0, 1.0);

DrawBoxObject(1.0, 1.0, 1.0, false, voffset, toffset, tscale);

Koordinaten für einen Würfel

Koordinaten für einen Würfel, welche man direkt in einen Puffer von OpenGL schreiben kann, inklusive Koordinaten für eine Textur. 

type
  TFace3x3 = array[0..2] of TVector3f;
  TFace3x2 = array[0..2] of TVector2f;

const
  QuadVector: array[0..11] of TFace3x3 = (
    // Umfang
    ((-0.5, +0.5, +0.5), (-0.5, -0.5, +0.5), (+0.5, -0.5, +0.5)), ((-0.5, +0.5, +0.5), (+0.5, -0.5, +0.5), (+0.5, +0.5, +0.5)),
    ((+0.5, +0.5, +0.5), (+0.5, -0.5, +0.5), (+0.5, -0.5, -0.5)), ((+0.5, +0.5, +0.5), (+0.5, -0.5, -0.5), (+0.5, +0.5, -0.5)),
    ((+0.5, +0.5, -0.5), (+0.5, -0.5, -0.5), (-0.5, -0.5, -0.5)), ((+0.5, +0.5, -0.5), (-0.5, -0.5, -0.5), (-0.5, +0.5, -0.5)),
    ((-0.5, +0.5, -0.5), (-0.5, -0.5, -0.5), (-0.5, -0.5, +0.5)), ((-0.5, +0.5, -0.5), (-0.5, -0.5, +0.5), (-0.5, +0.5, +0.5)),
    // oben
    ((+0.5, +0.5, +0.5), (+0.5, +0.5, -0.5), (-0.5, +0.5, -0.5)), ((+0.5, +0.5, +0.5), (-0.5, +0.5, -0.5), (-0.5, +0.5, +0.5)),
    // unten
    ((-0.5, -0.5, +0.5), (-0.5, -0.5, -0.5), (+0.5, -0.5, -0.5)), ((-0.5, -0.5, +0.5), (+0.5, -0.5, -0.5), (+0.5, -0.5, +0.5)));

  QuadTextureVertex: array[0..11] of TFace3x2 = (
    ((0.0, 0.0), (0.0, 1.0), (1.0, 1.0)), ((0.0, 0.0), (1.0, 1.0), (1.0, 0.0)),
    ((0.0, 0.0), (0.0, 1.0), (1.0, 1.0)), ((0.0, 0.0), (1.0, 1.0), (1.0, 0.0)),
    ((0.0, 0.0), (0.0, 1.0), (1.0, 1.0)), ((0.0, 0.0), (1.0, 1.0), (1.0, 0.0)),
    ((0.0, 0.0), (0.0, 1.0), (1.0, 1.0)), ((0.0, 0.0), (1.0, 1.0), (1.0, 0.0)),
    ((0.0, 0.0), (0.0, 1.0), (1.0, 1.0)), ((0.0, 0.0), (1.0, 1.0), (1.0, 0.0)),
    ((0.0, 0.0), (0.0, 1.0), (1.0, 1.0)), ((0.0, 0.0), (1.0, 1.0), (1.0, 0.0)));

Beispiele, schreiben in einen Puffer

  glBufferData(GL_ARRAY_BUFFER, sizeof(QuadVector, @QuadVector, GL_STATIC_DRAW);
Abgerufen von „https://wiki.delphigl.com/index.php?title=Würfel&oldid=26799“