The Donut

Hier mal was lustiges aus dem Paralleluniversum - und vielleicht ja auch für Altgerät interessant. Etwa als Benchmark (?) - statt Apfelmännchen. Evtl. mit Sinustabellen ausreichend performant auch auf Z80 und Co.

Hier ist gewissermaßen die Vorgeschichte https://www.youtube.com/shorts/FIZI3k7mTvA

und da die eigentliche Webseite dazu (die Buttons bei den Bildern anklicken) :

https://www.a1k0n.net/2011/07/20/donut-math.html

in C kann das dann auch so aussehen

Donut-shaped C code that generates a 3D spinning donut

und so sieht der Programmcode dann in voller Schönheit aus

https://bit.ly/2BITbQm

donut_deobfuscated.c

Shared with Dropbox

www.dropbox.com

int main() {
    float A = 0, B = 0;
    float i, j;
    int k;
    float z[1760];
    char b[1760];
    printf("\x1b[2J");
    for(;;) {
        memset(b,32,1760);
        memset(z,0,7040);
        for(j=0; j < 6.28; j += 0.07) {
            for(i=0; i < 6.28; i += 0.02) {
                float c = sin(i);
                float d = cos(j);
                float e = sin(A);
                float f = sin(j);
                float g = cos(A);
                float h = d + 2;
                float D = 1 / (c * h * e + f * g + 5);
                float l = cos(i);
                float m = cos(B);
                float n = sin(B);
                float t = c * h * g - f * e;
                int x = 40 + 30 * D * (l * h * m - t * n);
                int y= 12 + 15 * D * (l * h * n + t * m);
                int o = x + 80 * y;
                int N = 8 * ((f * e - c * d * g) * m - c * d * e - f * g - l * d * n);
                if(22 > y && y > 0 && x > 0 && 80 > x && D > z[o]) {
                    z[o] = D;
                    b[o] = ".,-~:;=!*#$@"[N > 0 ? N : 0];
                }
            }
        }
        printf("\x1b[H");
        for(k = 0; k < 1761; k++) {
            putchar(k % 80 ? b[k] : 10);
            A += 0.00004;
            B += 0.00002;
        }
        usleep(30000);
    }
    return 0;
}

und wenn es jemand eintippt, kann man auch zuschauen

https://www.youtube.com/watch?v=ux0jQNvCExQ

Spinning Donut with C ( C Programming )

na ja - und mittlerweile ist es wohl ein Internet Meme geworden

einfach mal nach "donut" oder "donut.c" oder "donut.py" suchen gehen.

Gern auch mal in Rainbow-Colors

Donut C-Code that produces spinning Rainbow Donut

.

Modifikation : x2 in Size und Lissajous dazu, ASCII bißchen agbeändert

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>

int main() {
    float A = 0, B = 0;
    float i, j;
    int k;
    float z[1760*4];
    char b[1760*4];
    printf("\x1b[2J");
    for(;;) {
        memset(b,32,1760*4);
        memset(z,0,7040*4);
    int dx = ceil( sin(A/6)*32 );
    int dy = ceil( cos(B/9)*8 );
        for(j=0; j < 6.28; j += 0.035) {
            for(i=0; i < 6.28; i += 0.01) {
                float c = sin(i);
                float d = cos(j);
                float e = sin(A);
                float f = sin(j);
                float g = cos(A);
                float h = d + 2;
                float D = 1 / (c * h * e + f * g + 5);
                float l = cos(i);
                float m = cos(B);
                float n = sin(B);
                float t = c * h * g - f * e;
                int x = 80 + dx + 60 * D * (l * h * m - t * n);
                int y = 24 + dy + 30 * D * (l * h * n + t * m);
                int o = x + 160 * y;
                int N = 12 * ((f * e - c * d * g) * m - c * d * e - f * g - l * d * n);
                if(44 > y && y > 0 && x > 0 && 160 > x && D > z[o]) {
                    z[o] = D;
//                     b[o] = ".,-~:;=!*#$@"[N > 0 ? N : 0];
                    b[o] = ".,-~:;=()!uoO*#$&W@"[N > 0 ? N : 0];
                }
            }
        }
        printf("\x1b[H");
        for(k = 0; k < 1761*4; k++) {
            putchar(k % 160 ? b[k] : 10);
//             A += 0.000027;
//             B += 0.00002;
        }
            A += 0.24;
            B += 0.21;
        usleep(30000);
    }
    return 0;
}

und als "Filmdokument" (vereinfacht evtl das Ansehen)

Müßte man eigentlich mal schauen, wie man in so einem Terminal Fettdruck anzeigen kann oder das "N" direkt an die aalib übergebn und den passenden Wert (für 0-63 oder sogar 0-255 ) dann da übernimmt.

Außerdem gibt es ja wahrscheinlich sogar passende "gute" Textstrings mit "aufsteigender Helligkeit" und paar mehr Zeichen als 12.

Ist schon interesssant, auch weil das ja nicht viel anders ist, was die Leut' da so rumspielen, als das am 128er/Spectrum gemacht worden ist. Nur eben jetzt mit großen Maschinen die künstlich (ASCII) häßlich gehalten werden. Sehr schön sind auch bei YT die Sachen zu dem Python Turtle Modul. Einfach mal googeln/yt-uben - das ist doch alles sehr bekannt. Verfolgerkurven und solche rotationssymmetrischen Bildchen und auch Rekursionsgrafikbildchen ^[YT].

stimmt - das "Mikrosekundenwarten" will da eigentlich angesagt werden, aber hier lief es auch ohne Warnung durch

Ich habe mal noch eine "flexible" Variante gebastelt.

Damit kann man das Ganze auch sehr einfach an ein großes Terminalfenster anpassen. Da sieht der Donut gleich nochmal viel leckerer aus. Mit bißchen Abstand zum Bildschirm (>=3m) wird es dann schon fast eine Grafikdemo.

Compilen wie eben beschrieben. Aber: man kann jetzt in den Zeilen ganz am Anfang ( Zeile 7 und 8 ) die Wunsch-Auflösung einstellen. Einfach für 80 x 24 z.B. mal 160 x 44 oder was entsprechend größeres vorgeben und neu übersetzen.

DonutFlex.c :

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <math.h>
#include <string.h>

#define XMAX  80    // default 80
#define YMAX  24    // default 24

#define XMID (int)(XMAX / 2)
#define YMID (int)(YMAX / 2)

#define XZOOM (int)(0.750*XMID)
#define YZOOM (int)(1.250*YMID)

int main() {

    float A = 0, B = 0;
    float i, j;
    int k;
    float z[XMAX*YMAX];
    char b[XMAX*YMAX];

    printf("\x1b[2J");

    for(;;) {
        memset(b,32,XMAX*YMAX);
        memset(z,0,XMAX*YMAX*4);
        for(j=0; j < 6.28; j += 0.035) {
            for(i=0; i < 6.28; i += 0.01) {
                float c = sin(i);
                float d = cos(j);
                float e = sin(A);
                float f = sin(j);
                float g = cos(A);
                float h = d + 2;
                float D = 1 / (c * h * e + f * g + 5);
                float l = cos(i);
                float m = cos(B);
                float n = sin(B);
                float t = c * h * g - f * e;
                int x = XMID + XZOOM * D * (l * h * m - t * n);
                int y = YMID + YZOOM * D * (l * h * n + t * m);
                int o = x + XMAX * y;
                int N = 8 * ((f * e - c * d * g) * m - c * d * e - f * g - l * d * n);
                if(YMAX > y && y > 0 && x > 0 && XMAX > x && D > z[o]) {
                    z[o] = D;
                    b[o] = ".,-~:;=!*#$@"[N > 0 ? N : 0];
                }
            }
        }

        printf("\x1b[H");
        for(k = 0; k < XMAX*YMAX+1; k++) {
            putchar(k % XMAX ? b[k] : 10);
        }

        A += 0.070;
        B += 0.035;
        usleep(30000);
    }

    return 0;
}

und hier ist gleich noch die Anschlußbastelei, wo das Lissajous (s.o.) und das leicht andere ASCII wieder mit drin ist und zusätzlich eine Änderung in der Tiefe. Video gibt es auch, s.u. Damit das schön aussieht, sollte das Fenster schon etwas größer sein als die Standardeinstellung. Bei ganz hohen Auflösungen und wenn der Kringel weit nach vorn kommt, entstehen Artefakte, die man durch engeres Zeichnen der Ringe beheben kann - das bedeutet, daß man in Zeile 35 die Schrittweite für j kleiner macht, z.B. von 0.035 auf 0.015. Es wird dadurch dann aber insgesamt auch deutlich langsamer.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <math.h>
#include <string.h>

#define XMAX  120    // default 80
#define YMAX   36    // default 24

#define XMID (int)(XMAX / 2)
#define YMID (int)(YMAX / 2)

#define XZOOM (int)(0.750*XMID)
#define YZOOM (int)(1.250*YMID)

#define XLISS (0.4*XMID)
#define YLISS (0.4*YMID)

int main() {

    float A = 0, B = 0;
    float i, j;
    int k;
    float z[XMAX*YMAX];
    char b[XMAX*YMAX];

    printf("\x1b[2J");

    for(;;) {
        memset(b,32,XMAX*YMAX);
        memset(z,0,XMAX*YMAX*4);
        int dx = ceil( sin(A/6)*XLISS );
        int dy = ceil( cos(B/9)*YLISS );
        float dz = cos(A/7) *3 + 2;
        for(j=0; j < 6.28; j += 0.035) {
            for(i=0; i < 6.28; i += 0.01) {
                float c = sin(i);
                float d = cos(j);
                float e = sin(A);
                float f = sin(j);
                float g = cos(A);
                float h = d + 2;
                float D = 1 / (c * h * e + f * g + 5 + dz);
                float l = cos(i);
                float m = cos(B);
                float n = sin(B);
                float t = c * h * g - f * e;
                int x = XMID + dx + XZOOM * D * (l * h * m - t * n);
                int y = YMID + dy + YZOOM * D * (l * h * n + t * m);
                int o = x + XMAX * y;
                int N = 12 * ((f * e - c * d * g) * m - c * d * e - f * g - l * d * n);
                if(YMAX > y && y > 0 && x > 0 && XMAX > x && D > z[o]) {
                    z[o] = D;
//                     b[o] = ".,-~:;=!*#$@"[N > 0 ? N : 0];
                    b[o] = ".,-~:;=()!*uoO&$#W@"[N > 0 ? N : 0];
                }
            }
        }

        printf("\x1b[H");
        for(k = 0; k < XMAX*YMAX+1; k++) {
            putchar(k % XMAX ? b[k] : 10);
        }

        A += 0.170;
        B += 0.135;
        usleep(12000);
    }

    return 0;
}

.

Sehr hübsch ist auch, wenn man die Bewegung im FlexLissajousDeep noch ein bißchen "erratischer" macht. Das geht einfach, und komplett ohne Zufallszahlen, durch dezentes Ändern der Counter A, B. Etwa indem man die Zeilen 65 und 66 ersetzt/erweitert durch

entweder

        A += 0.170+(sin(B)/7);
        B += 0.135+(sin(A)/4);

oder z.B.

        A += 0.270+(sin(B)/3);
        B += 0.235+(sin(A)/4);

und evtl. die Wartechleife bißchen anpaßt, z.B. usleep(7500); .

Tiefen-Colouring (dunkel ist hinten) ist auch einfach

dazu wird die Tiefe dz in einen Integer Wert gewandelt und dann mit auf das N in Zeile 55, welches das ASCII Zeichen auswählt/bestimmt, aufaddiert. Damit das schön funktioniert sollte der Wert von dz (in Zeile 34 berechnet) evtl. noch angepaßt werden, d.h. wenn wie im Bsp oben dort Werte für dz von -1 bis +5 herausfallen, sollte man evtl. nach "oben" hin ausgleichen, damit auch die Stufe "-1" in die ASCII Bestimmung eingeht. In diesem Fall würde man dann halt noch für Z ein "+1" machen. (Muß man aber nicht, Werte < 0 werden sonst einfach nicht berücksichtigt und erhalten einfach das kleinste/erste ASCII Symbol.) Große dz Werte ( z.B. bei -12 <= dz <= 12 ), kann man auch noch geschickt durch Teilen mit z.B. 3 oder 4 zurechtstutzen.

Wichtig ist, daß man "Z" noch umkehrt - nämlich aus hohen Z-Werte sollen "kleine" Farben/ASCIIs werden und niedrige Z-Werte sollen "helle" Farben/hohe ASCIIs erhalten. Deswegen wird  Z = Maximalwert(dz) - dz  genommen.

... d.h. ,

in die "Farbauswahl" - zwischen Zeile 52 und 53 - kommt dazu

int Z = 6 - (dz + 1);

oder für eine Variante mit vielen Tiefenwerten von dz ( wie etwa bei einer (Zeile34) float dz = cos(A/7) * 12 + 11 ; )

int Z = 12 - (int) floor ( dz / 2 );

und, die eigentliche "Farbauswahl" ändert sich zu

Zeile 55 b[o] = ".,-~:;=()!*uoO&$#W@"[N+Z > 0 ? N+Z : 0];

wobei man evtl. für "viel Tiefe" (großes Z) die Auswahl an ASCII Zeichen noch anpassen muß, im einfachsten Fall durch Verdopplung von ASCII Werten, etwas so

Zeile 55 b[o] = "..,,--~~::;;==(())!!*uoO&$#W@"[N+Z > 0 ? N+Z : 0];

.

...

Na, so ganz schlimm ist es dann auch wieder nicht, aber es ist ja unglaublich ineinander "gestaucht". Wenn man das ganz klassisch aufschreiben würde, sähe das schonmal anders aus - und ist dann auch wesentlich verständlicher.

Aber der Autor von dem Teil, Andy Sloane, hatte es ja eigentlich mal (2006) als eine Art Demo gebaut - um zu zeigen, wie man in C komischen Code schreiben kann.

Hier mal noch die beiden "Erstveröffentlichungen"

https://www.a1k0n.net/2006/09/15/obfuscated-c-donut.html

https://www.a1k0n.net/2006/09/20/obfuscated-c-donut-2.html

Du kannst ja mal probieren einen 2D "Donut" auf dem Pet hinzubekommen. Mit der Grafikkarte sollte das sogar schön aussehen und außerdem ist das ein Grafikklassiker, auch unbewegt und mit leidglich (x,y) ohne Beleuchtung usf. Man malt dazu einen (unsichtbaren) Kreis und darauf aller paar Grad mit dem jeweilig aktuellen (x,y) Wert als Mittelpunkt einen kleineren Kreis - bis man einmal um den großen Kreis herum ist.

Wenn man das fertig hat, kann man anfangen statt kleinen Kreisen mal kleine Ellipsen zu malen - und schon ist man optisch nah dran.

Kleiner Tip: im Einheitskreis gilt 1 = x² + y² und für Kreise mit Radius wird daraus Radius² = x² + y² . Du kannst also bei bekanntem Radius zu jedem beliebigen x das passende y ausrechnen (und natürlich auch für jedes beliebige y das dazugehörige x). Außerdem ist der Sinus/Cosinus vom Drehwinkel ein wichtiges HIlfsmittel - weil sin(winkel) = y / Radius gilt, und cos(winkel) = x / Radius . Probier einfach mal ...

ist nicht schwer. Am Besten nicht das Circle Kommando benutzen, sondern schön Einzelpixel malen - das fördert das Nachvollziehen erheblich.

Das Drehen im Raum und auch das Beleuchten ist dann soviel anders auch nicht mehr - wenn man es in Einzelschritten macht.

Nur - das in der gezeigten Form da so eng zusammenzupacken, das ist schon wirklich witzig - und naturgemäß dann auch nicht mehr wirklich "übersichtlich" oder gar "selbsterklärend".