Wir haben keine einzige Herausforderung beim Zeichnen eines echten dreidimensionalen Würfels.

Herausforderung

Ihre Aufgabe ist es, einen gedrehten Würfel mit Perspektive zu zeichnen. Es kann in einem separaten Fenster oder als Bild sein.

Eingang

Ihre Eingabe besteht aus 3 separaten Zahlen zwischen 0 und 359,99 ... Diese repräsentieren die Drehung um die x-, y- und z-Achse in Grad.

0 0 0
30 0 40
95 320 12

Ausgabe

Sie können es entweder in einem separaten Fenster anzeigen oder ein Bild speichern. Sie können jede Art von Anzeige verwenden (vektorbasiert, gerastert usw.).

Bearbeiten: ASCII ist ebenfalls zulässig, um Golfsprachen nur mit Textausgabe zuzulassen.

Die Ausgabe für gerasterte oder ASCII-Grafiken muss mindestens 50 * 50 betragen (Pixel für die Rasterung, Zeichen für ASCII).

Zusätzliche Information

Die positive z-Achse zeigt aus dem Fenster, die x-Achse ist horizontal und die y-Achse ist vertikal. Grundsätzlich der OpenGL-Standard.

Drehungen erfolgen gegen den Uhrzeigersinn, wenn Sie den Würfel in der negativen Richtung einer bestimmten Achse betrachten, z. B. nach unten auf die y-Achse.

Die Kamera sollte sich in negativer z-Richtung auf der z-Achse in einem angemessenen Abstand vom Würfel befinden, der Würfel sollte sich auf (0; 0; 0) befinden. Das. Der Würfel muss außerdem vollständig sichtbar sein und mindestens 50% des Zeichenrahmens einnehmen. Die Kamera sollte in positiver z-Richtung auf den Würfel schauen.

Die Rotationen des Würfels werden in der Reihenfolge x-> y-> z angewendet.

Der Würfel wird um seine Mitte gedreht, er bewegt sich nicht.

Um einen Würfel im 2D-Raum zu projizieren, müssen Sie die x- und y-Koordinaten des Würfels durch den Abstand parallel zur z-Achse zwischen dem Punkt und der Kamera teilen.

Regeln

Rendering-Bibliotheken sind zulässig, die Eckpunkte müssen jedoch im Code definiert werden. Keine 3D-Würfel-Modellklasse.

Testfälle

Schuhe (Rubin) 235 231

Alles von Grund auf neu berechnet.

Shoes.app{p,a,b,c=ARGV.map{|j|j.to_f/90}
k=1+i="i".to_c
p=(0..3).map{|j|y,z=(k*i**(j+a)).rect
x,z=(((-1)**j+z*i)*i**b).rect
q=(x+y*i)*i**c
[90*(k+q/(z-4)),90*(k+q/(4+z))]}
4.upto(15){|j|line *(p[j%4][0].rect+p[(j+j/4)%4][1].rect)}}

Anruf von der Kommandozeile zB shoes cube3d.rb 0 30 0

Die Idee ist, gleichzeitig die vier Eckpunkte eines Tetraeders in 3d zu erzeugen / zu drehen. Wenn diese dann auf 2d reduziert werden, erzeugen wir die vier Eckpunkte des inversen Tetraeders (die insgesamt 8 Eckpunkte sind die des Würfels). Dies ergibt 4 Eckpunktpaare, die den 4 Körperdiagonalen entsprechen. Schließlich werden die 2d-Eckpunkte durch Linien verbunden: Jeder Scheitelpunkt des ursprünglichen Tetraeders muss mit jedem Scheitelpunkt des inversen Tetraeders verbunden werden, der die 12 Kanten und 4 Körperdiagonalen des Würfels bildet. Die Bestellung stellt sicher, dass die Körperdiagonalen nicht aufgezeichnet werden.

Ausgabe von Testfällen

Beachten Sie, dass die Drehung um die z-Achse vom POV des Betrachters aus im Uhrzeigersinn erfolgt, um mit den letzten beiden Testfällen übereinzustimmen. Dies scheint jedoch im Widerspruch zur Spezifikation zu stehen. Die Drehrichtung kann durch Ändern von *i**c-> umgekehrt werden/i**c

ungolfed

Shoes.app{
  p,a,b,c=ARGV.map{|j|j.to_f/90}   #Throw away first argument (script name) and translate next three to fractions of a right angle.
  k=1+i="i".to_c                   #set up constants i=sqrt(-1) and k=1+i

  p=(0..3).map{|j|                 #build an array p of 4 elements (each element wil be a 2-element array containing the ends of a body diagonal in complex number format)
    y,z=(k*i**(j+a)).rect          #generate 4 sides of square: 1+i,i-1,-1-i,-i+1, rotate about x axis by a, and store in y and z as reals 
    x,z=(((-1)**j+z*i)*i**b).rect  #generate x axis displacements 1,-1,1,-1, rotate x and z about y axis by b, store in x and z as reals
    q=(x+y*i)*i**c                 #rotate x and y about z axis, store result in q as complex number
  [90*(k+q/(z-4)),90*(k+q/(4+z))]} #generate "far" vertex q/(4+z) and "near" vertex q/-(4-z) opposite ends of body diagonal in 2d format.

  4.upto(15){|j|                   #iterate through 12 edges, use rect and + to convert the two complex numbers into a 4 element array for line method
    line *(p[j%4][0].rect+         #cycle through 4 vertices of the "normal" tetrahedron
     p[(j+j/4)%4][1].rect)         #draw to three vertices of the "inverted" tetrahedron. j/4=1,2,3, never 0
  }                                #so the three edges are drawn but the body diagonal is not.
}

Beachten Sie, dass aus historischen Gründen in Zeile 9 ein Skalierungsfaktor von 90 angewendet wird (der für das Golfen mit 90 Grad in Zeile 2 identisch ist), aber am Ende gab es keinen Golfvorteil bei der Verwendung dieses bestimmten Werts, so dass er zu einem geworden ist willkürliche Wahl.

HTML / CSS / JS, 739 Byte, wahrscheinlich nicht konkurrierend

Aber ich wollte nur CSS 3D-Transformationen zeigen.

w=_=>o.style.transform=`rotateZ(${z.value}deg) rotateY(${y.value}deg) rotateX(${-x.value}deg)`

input {
  width: 5em;
}

#c{width:90px;height:90px;margin:90px;position:relative;perspective:180px}#o{position:absolute;width:90px;height:90px;transform-style:preserve-3d;transform-origin:45px 45px 0px;}#o *{position:absolute;width:90px;height:90px;border:2px solid black}#f{transform:translateZ(45px)}#b{transform:rotateX(180deg)translateZ(45px)}#r{transform:rotateY(90deg)translateZ(45px)}#l{transform:rotateY(-90deg)translateZ(45px)}#u{transform:rotateX(90deg)translateZ(45px)}#d{transform:rotateX(-90deg)translateZ(45px)}

<div oninput=w()>
  X:<input id="x" type="number" value="0" min="0" max="360">
  Y:<input id="y" type="number" value="0" min="0" max="360">
  Z:<input id="z" type="number" value="0" min="0" max="360">
</div>
<!-- Above code for ease of use of snippet. Golfed version: <div oninput=w()><input id=x><input id=y><input id=z></div> -->

<div id=c><div id=o><div id=f></div><div id=b></div><div id=r></div><div id=l></div><div id=u></div><div id=d>

Ahorn, 130 + 14 (in Bearbeitung)

with(plots):f:=(X,Y,Z)->plot3d(0,x=0..1,y=0..1,style=contour,tickmarks=[0,0,0],labels=["","",""],axes=boxed,orientation=[Z,-X,Y]);

Dies zeichnet eine konstante Funktion in einem Feld und verwendet dann Plotoptionen, um Häkchen, Beschriftungen und die Funktion selbst auszublenden. Durch Hinzufügen projection=.5zu den Optionen wird die Kamera näher gebracht und die perspektivische Ansicht ermöglicht.
Ich habe dies geschrieben, bevor die Spezifikationen fertiggestellt wurden und die Rotationsreihenfolge x, y', z''statt ist x, y, z. Bis ich die Winkel fixiere, ist hier eine andere Lösung

POV-Ray, 182

#include"a.txt"
#include"shapes.inc"
camera{location 9*z look_at 0}
light_source{9*z color 1}
object{Wire_Box(<-2,-2,-2>,<2,2,2>,.01,0)texture{pigment{color rgb 1}}rotate<R.x,-R.y,-R.z>}

liest Eingabe über die a.txtDatei , die enthalten sollte ,
#declare R=<xx,yy,zz>;
mit xx,yy,zzwobei der Drehwinkel