hilfe bei emu8086



  • hallo an alle!
    ich bin total neu im gebiet assembler, deswegen wollte ich fragen ob ihr mir helfen könnt. das problem ist folgendes: ich will ein programm schreiben, welches auf der konsole einen kreis zeichnet, ich weis jedoch nicht wie ich anfangen soll. könnt emir bitte jemand helfen? würde sehr dankbar sein! 🙂



  • newguy schrieb:

    hallo an alle!
    ich bin total neu im gebiet assembler, deswegen wollte ich fragen ob ihr mir helfen könnt. das problem ist folgendes: ich will ein programm schreiben, welches auf der konsole einen kreis zeichnet, ich weis jedoch nicht wie ich anfangen soll. könnt emir bitte jemand helfen? würde sehr dankbar sein! 🙂

    Anfangen:
    Für einen kleinen Kreis würde vermutlich eine Wurzel-Berechnung ausreichen?
    Sonst wäre die Berechnung mit Sin/Cos möglicherweise etwas genauer, damit keine Lücken entstehen.

    Dirk



  • Und dann dieser circle hack d=0.242; x+=d*y; y-=d*x; (früher erschien unter "circle hack" die mathematik dazu, jetzt nicht mehr.( )

    Und Bresenham bzw http://en.wikipedia.org/wiki/Midpoint_circle_algorithm



  • Ach, Ihr seid ja gemein. EMU8086 emuliert ganz knallhart einen 8086-Prozessor. Da gibts keine Wurzel und Gleitkommazahlen (FPU).

    @newguy: Hier bitte:

    #MAKE_COM#    ; emu8086 soll ein COM-Programm herstellen
    ORG 100h           ; Beginn des geladenen COM-Programms
    
            ; DS & ES = CS (eigentlich überflüssig)
            mov ax, cs
            mov ds, ax
            mov es, ax
    
            ; Achtelkreis: Methode von Horn
            ; http://de.wikipedia.org/wiki/Rasterung_von_Kreisen#Midpoint-Algorithmus
            mov di, OFFSET xy
            mov cx, 0
    
            loop1:
            mov al, [y]
            mov ah, [x]
            cmp ah, al                      ; x < y ?
            jl endloop1                     ; ja -> Schleifenende
            stosw                           ; x & y in die xy-Tabelle eintragen
    
            xor ah, ah                       ; // d = 2*y + d + 1
            shl ax, 1
            add ax, [d]
            inc ax
            mov d, ax
            inc [y]
    
            cmp ax, 0                       ; d > 0 ?
            jle loop1                       ; nein -> continue
    
            xor dx, dx                       ; // d = d - 2*x + 2
            mov dl, [x]
            shl dx, 1
            sub ax, dx
            add ax, 2
            mov d, ax
            dec [x]
    
            jmp loop1
            endloop1:
    
            ; Viertelkreis: zusätzlich gespiegelte Werte vom Achtelkreis
            mov si, di
            loop2:
            sub si, 2
            mov ax, [si]
            xchg al, ah
            stosw
            cmp si, OFFSET xy
            jne loop2
            shl cx, 1
    
            ; Halbkreis: zusätzlich negierte x-Werte vom Viertelkreis
            mov si, di
            loop3:
            sub si, 2
            mov ax, [si]
            neg ah
            stosw
            cmp si, OFFSET xy
            jne loop3
            shl cx, 1
    
            ; Vollkreis: zusätzlich negierte y-Werte vom Halbkreis
            mov si, di
            loop4:
            sub si, 2
            mov ax, [si]
            neg al
            stosw
            cmp si, OFFSET xy
            jne loop4
            shl cx, 1
    
            xor ax, ax
            mov [di], ax
    
            ; Ausgabe
            mov ax, 0B800h                  ; ES = Video-RAM
            mov es, ax
            mov bl, '*'                     ; BX: Weißer Stern
            mov bh, 0x0F                    ; Vordergrund weiß, Hintergrund schwarz
    
            ; Mittelpunkt zeichnen
            mov ah, 40                      ; x
            mov al, 12                      ; y
            mov cx, ax                      ; Mittelpunkt merken
            call vec2ofs                    ; Vektor in Offsetadresse umrechnen
            mov es:[di], bx                 ; zeichnen
    
            ; Kreis zeichnen
            mov si, OFFSET xy               ; Tabellenanfang
            loop5:
            lodsw
            test ax, ax                     ; Tabellenende?
            je endloop5                     ; ja -> Ende
            add al, cl                      ; relativen Vektor zum Mittelpunkt addieren
            add ah, ch
            call vec2ofs                    ; Vektor in Offsetadresse umrechnen
            mov es:[di], bx                 ; zeichnen
            jmp loop5
            endloop5:
    
            ret                             ; Programmende
    
            ; Funktion vec2ofs: Umrechnung von Punkten zu Offset im Videoram
            vec2ofs:                        ; Übergabe: al,ah = x,y
            xor dx, dx
            mov dl, ah
            xor ah, ah
            mov ah, 80
            mul ah
            add ax, dx
            mov di, ax
            shl di, 1
            ret
    
            ; Variablen
            r dw 10
            d dw -10
            x db 10
            y db 0
            xy: dw 00                       ; expandiert nach hinten!
    

    Und nun überleg Dir, ob Du Assembler nicht mit etwas kleineren Brötchen anfangen willst. 😉

    viele grüße
    ralph



  • danke für die schnelle antwort! und danke auch für den tipp 😉 ich dachte assembler wäre leichter, doch anscheinend habe ich mich gewaltig getäuscht 🙂 ich werde wohl von ganz ganz unten starten müssen! nochmals danke! 🙂


Anmelden zum Antworten