Aus Oxoscript wird NanoPy - mehr Infos

3D-Grafik-Funktionen

drawOrigin

  drawOrigin()

Diese Funktion zeichnet einen Koordinatenrahmen, bei dem jede Achse eine Länge von 1 Meter/Einheit hat.

Konventionell ist x rot, y grün und z blau.

Verwende zum Beispiel translate3D() oder rotate3D(), um die Position des Ursprungs zu ändern.

drawCube

  drawCube(size:float)

Zeichnet eine 3D-Form: Würfel

fill(255,255,255)
rotate3D(0,PI/4,0)
drawCube(2)
update()

drawSphere

  drawSphere(size:float)

Zeichnet eine 3D-Form: Kugel

fill(255,255,255)
drawSphere(2)
update()

drawCuboid

  drawCuboid(w:float, l:float, h:float)

Zeichnet eine 3D-Form: Quader

fill(255,255,255)
rotate3D(0, PI/4, 0)
drawCuboid(3, 2, 1)
update()

drawCylinder

  drawCylinder(r:float, h:float)

Zeichnet eine 3D-Form: Zylinder

fill(255,255,255)
rotate3D(-PI/4, -PI/4, 0)
drawCylinder(2, 3)
update()

drawTriangularPrism

  drawTriangularPrism(r:float, h:float)

Zeichnet eine 3D-Form: Dreieckiges Prisma

fill(255,255,255)
rotate3D(-PI/4, -PI/4, 0)
drawTriangularPrism(2, 3)
update()

translate3D

  translate3D(x:float, y:float, z:float)

Verwende diese Funktion, um den aktuellen Rahmen (Welt) zu verschieben.

Die Funktion ist additiv. Jeder zusätzliche Aufruf verschiebt den Nullpunkt relativ zur vorangehenden Position. Wenn man das nicht möchte, kann man push()/pop() verwenden, die den Ursprungszustand wieder herstellen.

Im Gegensatz zu 2D-Objekten sind die translate- und rotate-Funktionen die einzige Möglichkeit, die Position von 3D-Formen zu bestimmen.

translateX

  translateX(x:float)

Gleich wie translate3D(x, y, z), aber nur die X-Achse wird verschoben.

fill(255,255,255)
translateX(-5)
def onDraw():
    for i in 100:
        clear()
        translateX(0.1)
        drawCube(2)
        update()
    translateX(-10)

translateY

  translateY(y:float)

Gleich wie translate3D(x, y, z), aber nur die Y-Achse wird verschoben.

fill(255,255,255)
translateY(-5)
def onDraw():
    for i in 100:
        clear()
        translateY(0.1)
        drawCube(2)
        update()
    translateY(-10)

translateZ

  translateZ(z:float)

Gleich wie translate3D(x, y, z), aber nur die Z-Achse wird verschoben.

fill(255,255,255)
translateZ(-5)
def onDraw():
    for i in 100:
        clear()
        translateZ(0.1)
        drawCube(2)
        update()
    translateZ(-10)

rotate3D

  rotate3D(x:float, y:float, z:float)

Verwende diese Funktion, um den aktuellen Rahmen (Welt) um den Ursprungspunkt zu drehen.

Die Funktion ist additiv. Jeder zusätzliche Aufruf verschiebt den Nullpunkt relativ zur vorangehenden Position. Wenn man das nicht möchte, kann man push()/pop() verwenden, die den Ursprungszustand wieder herstellen.

Im Gegensatz zu 2D-Objekten sind die translate- und rotate-Funktionen die einzige Möglichkeit, die Position von 3D-Formen zu bestimmen.

rotateX

  rotateX(x:float)

Gleich wie rotate3D(x, y, z), aber es wird nur um die X-Achse gedreht.

fill(255,255,255)
def onDraw():
    clear()
    rotateX(0.1)
    drawCube(2)
    update()

rotateY

  rotateY(y:float)

Gleich wie rotate3D(x, y, z), aber es wird nur um die Y-Achse gedreht.

fill(255,255,255)
def onDraw():
    clear()
    rotateY(0.1)
    drawCube(2)
    update()

rotateZ

  rotateZ(z:float)

Gleich wie rotate3D(x, y, z), aber es wird nur um die Z-Achse gedreht.

fill(255,255,255)
def onDraw():
    clear()
    rotateZ(0.1)
    drawCube(2)
    update()

scale3D

  scale3D(x:float, y:float, z:float)

Skaliert alle nachfolgenden Zeichenbefehle um den angegebenen Wert. Zum Beispiel verdoppelt sich die Größe mit dem Wert 2 oder halbiert sich mit 0,5.

Hinweis: scale3D() ist multiplikativ. Das bedeutet, dass z. B. scale3D(2) und scale3D(1.5) zusammen denselben Effekt erzielen wie ein einzelnes scale3D(3).

Beispiel:

fill(255,255,255)
drawSphere(1)
update()
delay(1000)

scale3D(2,2,2)
drawSphere(1)
update()
delay(1000)

scale3D(1.5,1.5,1.5)
drawSphere(1)
update()

scaleX

  scaleX(x:float)

Gleich wie scale3D(x, y, z), aber nur Skalierung auf der X-Achse.

fill(255,255,255)
def onDraw():
    push()
    for i in 100:
        clear()
        scaleX(0.99)
        drawSphere(4)
        update()
    pop()

scaleY

  scaleY(y:float)

Gleich wie scale3D(x, y, z), aber nur Skalierung auf der Y-Achse.

fill(255,255,255)
def onDraw():
    push()
    for i in 100:
        clear()
        scaleY(0.99)
        drawSphere(4)
        update()
    pop()

scaleZ

  scaleZ(z:float)

Gleich wie scale3D(x, y, z), aber nur Skalierung auf der Z-Achse.

fill(255,255,255)
rotateY(PI/2)
def onDraw():
    push()
    for i in 100:
        clear()
        scaleZ(0.99)
        drawSphere(4)
        update()
    pop()

translateCamera3D

  translateCamera3D(x:float, y:float, z:float)

Neben der Verwendung von translate3D(), um das gesamte Bild (die Welt) zu bewegen, kann diese Funktion auch verwendet werden, um die Position der Kamera zu bewegen.

Die Funktion ist additiv. Jeder zusätzliche Aufruf verschiebt den Nullpunkt relativ zur vorangehenden Position. Wenn man das nicht möchte, kann man push()/pop() verwenden, die den Ursprungszustand wieder herstellen.

Im Gegensatz zu 2D-Objekten sind die translate- und rotate-Funktion die einzige Möglichkeit, die Position von 3D-Formen zu bestimmen.

translateCameraX

  translateCameraX(x:float)

Gleich wie translateCamera3D(x, y, z), aber nur die X-Achse der Kamera wird verschoben.

fill(255,255,255)
translateCameraX(-5)
def onDraw():
    for i in 100:
        clear()
        translateCameraX(0.1)
        drawCube(2)
        update()
    translateCameraX(-10)

translateCameraY

  translateCameraY(y:float)

Gleich wie translateCamera3D(x, y, z), aber nur die Y-Achse der Kamera wird verschoben.

fill(255,255,255)
translateCameraY(-5)
def onDraw():
    for i in 100:
        clear()
        translateCameraY(0.1)
        drawCube(2)
        update()
    translateCameraY(-10)

translateCameraZ

  translateCameraZ(z:float)

Gleich wie translateCamera3D(x, y, z), aber nur die Z-Achse der Kamera wird verschoben.

fill(255,255,255)
translateCameraZ(-5)
def onDraw():
    for i in 100:
        clear()
        translateCameraZ(0.1)
        drawCube(2)
        update()
    translateCameraZ(-10)

rotateCamera3D

  rotateCamera3D(x:float, y:float, z:float))

Neben der Verwendung von rotate3D() zum Drehen des gesamten Rahmens (Welt) kann diese Funktion auch zum Drehen der Kamera verwendet werden.

Die Funktion ist additiv. Jeder zusätzliche Aufruf verschiebt den Nullpunkt relativ zur vorangehenden Position. Wenn man das nicht möchte, kann man push()/pop() verwenden, die den Ursprungszustand wieder herstellen.

Im Gegensatz zu 2D-Objekten sind die translate- und rotate-Funktion die einzige Möglichkeit, die Position von 3D-Formen zu bestimmen.

rotateCameraX

  rotateCameraX(x:float)

Gleich wie rotateCamera3D(x, y, z), aber nur Drehung der Kamera um die X-Achse.

fill(255,255,255)
def onDraw():
    clear()
    rotateCameraX(0.1)
    drawCube(2)
    update()

rotateCameraY

  rotateCameraY(y:float)

Gleich wie rotateCamera3D(x, y, z), aber nur Drehung der Kamera um die Y-Achse.

fill(255,255,255)
def onDraw():
    clear()
    rotateCameraY(0.1)
    drawCube(2)
    update()

rotateCameraZ

  rotateCameraZ(z:float)

Gleich wie rotateCamera3D(x, y, z), aber nur Drehung der Kamera um die Z-Achse.

fill(255,255,255)
def onDraw():
    clear()
    rotateCameraZ(0.1)
    drawCube(2)
    update()

drawShape3D

  drawShape3D(vertices:float[], triangles:int[])

Mit der Funktion drawShape3D() können benutzerdefinierte 3D-Formen erstellt und gerendert werden.

Jede Form besteht aus einer Liste von Scheitelpunkten (Positionen im 3D-Raum) und einer Liste von Dreiecken/Flächen zwischen diesen Scheitelpunkten.

image

Beispiel:

verts:float[30] = [
    -1,-1,-1,
    1,-1,-1,
    1,1,-1,
    -1,1,-1,
    -1,-1,1,
    1,-1,1,
    1,1,1,
    -1,1,1,
    0,-1,2,
    0,1,2
]
tris:int[48] = [
    0,1,4,
    1,5,4,
    1,2,5,
    2,6,5,
    2,3,6,
    3,7,6,
    3,0,7,
    0,4,7,
    0,3,2,
    0,2,1,
    4,5,8,
    6,7,9,
    5,6,8,
    7,4,9,
    4,8,9,
    6,9,8
]

fill(255,255,255)
rotateX(-PI_DIV2)
scaleZ(0.8)

def onDraw():
    clear()
    rotateZ(0.02)
    drawOrigin()
    drawShape3D(verts, tris)
    update()

beginShape3D

  beginShape3D()

Beginnt eine Polygondefinition. Diese besteht aus einem beginShape3D(), mehreren Aufrufen von addVertex3D() und einem Abschluss mit endShape3D().

Beispiel:

const l = 1.06 # 0.1 .. 2.0

fill(255,255,255)

def onDraw():
    clear()
    rotateY(0.02)
    beginShape3D() # Fläche 1
    addVertex3D(l, l, l)
    addVertex3D(-l, l, -l)
    addVertex3D(-l, -l, l) # Fläche 2
    addVertex3D(l, l, l)
    addVertex3D(-l, -l, l)
    addVertex3D(l, -l, -l) # Fläche 3
    addVertex3D(-l, -l, l)
    addVertex3D(-l, l, -l)
    addVertex3D(l, -l, -l) # Fläche 4
    addVertex3D(-l, l, -l)
    addVertex3D(l, l, l)
    addVertex3D(l,-l, -l)
    endShape3D()
    update()

Dieses Beispiel zeichnet ein einfaches Tetraeder mit vier im Raum rotierenden Flächen.

endShape3D

  endShape3D()

Diese Funktion schließt eine Polygondefinition ab.

Wenn endShape3D() aufgerufen wird, wird das Polygon in den Bildschirmpuffer gezeichnet.

Beispiel: Siehe beginShape3D()

addVertex3D

  addVertex3D(x:float, y:float, z:float)

Diese Funktion fügt einen Punkt an der Position x/y/z in eine Polygondefinition ein.

Beispiel: Siehe beingShape3D()

render

  render()

Alle 3D-Formen werden oberhalb von 2D-Elementen gezeichnet. Der Grund dafür ist der automatische Aufruf von render() innerhalb der Funktion update().

Wenn man 2D-Elemente oberhalb von 3D-Formen zeichnen möchte, kann render() manuell nach dem Zeichnen der 3D-Formen aufgerufen werden.

fill(230, 204, 57)
background(162, 9, 176)
textFont(FONT_ROBOTO_BOLD_64)
drawSphere(3)
stroke(0, 0, 0)
drawText(26, 90, "Sphere") # dieser schwarze Text wird hinter der Kugel stehen
render()
stroke(255, 255, 255)
drawText(20, 80, "Sphere") # dieser weiße Text wird vor der Kugel stehen
update()

translationMode

  translationMode(mode:byte)

Manchmal ist es einfacher, im Weltmaßstab zu denken (vor allem, wenn es um aufeinanderfolgende Rotationen geht).

Daher kann man mit diser Funktion den Bezugsrahmen der Translation auf LOCAL (Standard) oder GLOBAL setzen.

translationMode(LOCAL)
translationMode(GLOBAL)

rotationMode

  rotationMode(mode:byte)

Manchmal ist es einfacher, im Weltmaßstab zu denken (vor allem, wenn es um aufeinanderfolgende Rotationen geht).

Daher kann man mit dieser Funktion den Bezugsrahmen der Drehung auf LOCAL (Standard) oder GLOBAL setzen.

rotationMode(LOCAL)
rotationMode(GLOBAL)

getWorldRotation3D

  getWorldRotation3D()->rotation3D

Für aufwändigere 3D-Anwendungen ist es hilfreich, die aktuelle Weltdrehung schreiben und lesen zu können.

Diese Funktion gibt ein rotation3D-Objekt/Klasse zurück (per Referenz).

rotation:rotation3D
rotation = getWorldRotation3D()

setWorldRotation3D

  setWorldRotation3D(rotation:rotation3D)

Für aufwändigere 3D-Anwendungen ist es hilfreich, die aktuelle Weltdrehung schreiben und lesen zu können.

Diese Funktion schreibt eine zuvor gelesene Weltrotation.

rotation:rotation3D
rotation = getWorldRotation3D()
setWorldRotation3D(rotation)

rotateAroundAxis

  rotateAroundAxis(angle:float, axis:vector3D)

In komplexeren Anwendungen ist es fast unmöglich, nur mit rotate3D() um eine bestimmte Drehachse zu rotieren. Aus diesem Grund wurde die Funktion rotateAroundAxis() implementiert.

Dieser Befehl dreht den aktuellen Frame entlang einer vom Benutzer angegebenen Achse (3D-Vektor) um einen bestimmten Winkel (in Rad).

Sie arbeitet entweder im LOCAL- oder GLOBAL-Modus, abhängig vom aktuell eingestellten rotationMode().

axis = vector3D(x=1,y=2,z=0.5)
rotateAroundAxis(PI/4, axis)