GEOS-Programme selber schreiben ?


  • spacer
  • 2828 Views 100 replies

This site uses cookies. By continuing to browse this site, you are agreeing to our Cookie Policy.

All users must confirm the minimum age (16) in their profile!<br /> <br /> From tomorrow the use of Forum64 will only possible after updating the profile data.<br /> The profile update is still possible after then.<br /> <br /> Thank you for your understanding.<br /> <br /> Team forum64.de

  • ajunra wrote:

    Du kannst ja mal 64Copy probieren.
    64Copy kann nicht wirklich mit Geos-Dateien umgehen. Das sagt der Autor selber in der Anleitung und empfiehlt dafür selbst StarCommander. Man kann sich die Info anzeigen lassen (Datei - Info) in Geos. Das wars.

    Mit Geos-Dateien umgehen kann StarCommander (sta.c64.org/sc.html) . Er kann auch Dateien zwischen D64, D71 und D81-Images kopieren. Das funktioniert perfekt. Image öffnen, Geos-Datei auf PC ablegen (ein korrektes .CVT wird erstellt). Dann ein anderes Image öffnen und die .CVT da rein kopieren. Die Geos-Datei wird automatisch nach Geos zurück konvertiert.
    StarCommander kann auch direkt auf Disketten schreiben. Allerdings wohl nur unter MS-DOS bzw. bis maximal WindowsXP 32 bit

    Nachteil beider Programme: Sie sind MS-DOS- basierent. Deshalb funktionieren sie nicht auf 64bit Windows-Systemen.

    Zum Kopieren von Geos-Dateien zwischen verschiedenen Dxx-Images nutze ich heute noch StarCommander auf Windows 10 Home 32bit.

    DirMaster ist leider keine Alternative. Macht zuviele schwerwiegende Fehler.....

    Gruß
    Werner
  • spacer wrote:

    Welche Adresse hat bitte das erste Byte im Grundscreen von GEOS64 oben links?
    Falls Du sowas meinst wie Poke "A", Adresse (oben links), das gibt es in Geos nicht.
    Geos bedeutet: Graphic Environment Operation System

    Da wird in Punkten (Pixel) gerechnet. Das erste (sichtbare) Pixel liegt an Adresse $a000. Das geht bis Adresse $bfff.

    Wenn Du z.B. obiges Basic-Beispiel in Geos realisieren willst, dann enthält das Geos-Kernal Routinen, die das realisieren, hier PutChar. Du mußt eine x-Koordinate und eine y-Koordinate und den Code des Zeichens angeben, welches ausgegeben werden soll. Beachte: Geos arbeitet mit ASCII-Code und nicht Pet-Ascii.

    Es gibt in Geos noch einen weiteren Bereich: Hintergrund-Bildschirm. Der wird dafür benutzte, wenn z.B eine Dialogbox aufgebaut werden soll. Geos speichert den Bildschirmbereich den die Dialogbox benutzt in den Hintergrundbildschirm und zeichnet dann die Dialogbox. Wird die Dialogbox verlassen, wird der Bereich aus dem Hintergrundbildschirm einfach in den Vordergrund-Bildschirm zurückgeschrieben. Der Hintergrund-Bildschirm liegt von $6000-$7f3f. Einzelheiten im MegaAssembler-Handbuch

    spacer wrote:

    Bleibt das immer gleich?
    Ja. Der sichbare Bildschirm liegt immer von $a000-$bfff.

    Gruß
    Werner
  • Hallo, danke.
    Klappt schon wunderbar.
    Ist schon ein großer Meilenstein um etwas zu schaffen in Grafik mit einem cc65 Programm.

    Es klappt schon, ob es Sicherheitskonform ist sehe ich nicht.
    1000x die 129 geschrieben mit POKE in cc65
    und 1000x die 255 geschrieben mit einem zeiger in cc65.

    Die Geschwindigkeit ist super.

    Das compilierte Programm hat 894 Byte und das umgewandelte Compilierte als cvt hat 891 Byte.

    pokee.c

    C Source Code

    1. #include <geos.h>
    2. #include <conio.h>
    3. #include <stdlib.h>
    4. #include <stdio.h>
    5. #include <ctype.h>
    6. #include <peekpoke.h>
    7. struct window wholeScreen = {0, SC_PIX_HEIGHT-1, 0, SC_PIX_WIDTH-1};
    8. int main(void)
    9. {
    10. unsigned int x;
    11. unsigned int xx;
    12. unsigned char *zeiger;
    13. SetPattern(0);
    14. InitDrawWindow(&wholeScreen);
    15. Rectangle();
    16. xx=0xA000+1000;
    17. for (x=0xA000; x<xx; x++) {
    18. POKE(x,129);
    19. }
    20. Sleep(10*50);
    21. return 0;
    22. }
    Display All


    pokeezei.c

    C Source Code

    1. #include <geos.h>
    2. #include <conio.h>
    3. #include <stdlib.h>
    4. #include <stdio.h>
    5. #include <ctype.h>
    6. #include <peekpoke.h>
    7. struct window wholeScreen = {0, SC_PIX_HEIGHT-1, 0, SC_PIX_WIDTH-1};
    8. int main(void)
    9. {
    10. unsigned int x;
    11. unsigned int xx;
    12. unsigned char *zeiger;
    13. SetPattern(0);
    14. InitDrawWindow(&wholeScreen);
    15. Rectangle();
    16. xx=0xA000+1000;
    17. for (x=0xA000; x<xx; x++) {
    18. zeiger=x;
    19. *zeiger=255;
    20. }
    21. Sleep(10*50);
    22. return 0;
    23. }
    Display All
    Images
    • Bild2.jpg

      2.9 kB, 400×268, viewed 4 times
    • Bild3.jpg

      6.7 kB, 500×347, viewed 4 times

    The post was edited 3 times, last by spacer ().

  • spacer wrote:

    Einzelheiten im MegaAssembler-Handbuch, was du mir empfohlen hast ?
    Ja.

    Im Teil A des Buches werden einige Programme erstellt. Die Quell-Texte dazu sind auch auf der Diskette, die das Programm MegaAssembler enthält. Hinweis: Im Buch gibt es auch ein paar Druckfehler in den abgedruckten Quelltexten. Die Quelltexte auf der Programm-Disk sind aber i.O.
    Im Teil B werden alle wichtigen Speicherstellen und alle Geos-Routinen erläutert.

    Gruß
    Werner
  • Habe ich jetzt gelesen mit dem Grafikbereich.

    Alle Befehle sind vergleichbar mit den Befehlen in cc65:
    -----------------------
    xx=BACK_SCR_BASE+7000;
    for (x=BACK_SCR_BASE; x<xx; x++) {
    POKE(x,129);
    }
    POKE(SCREEN_BASE+10,PEEK(BACK_SCR_BASE+100));
    -----------------------

    Das Buch kann man gut Benutzen.

    Danke.
    Gruss
  • Habe jetzt mal eine ASM aus deinem Buch (Kapitel 4.5)umgesetzt um zu sehen...wie funktioniert das mit dem cc65.
    Es wurde 1zu1 umgesetzt
    Habe aber zur Übersicht die einfache ASM-Variante vom cc65 geommen. Später kommt das ohne asm(...).

    Gruss

    C Source Code

    1. #include <geos.h>
    2. #include <conio.h>
    3. #include <stdlib.h>
    4. #include <stdio.h>
    5. #include <ctype.h>
    6. #include <peekpoke.h>
    7. struct window wholeScreen = {0, SC_PIX_HEIGHT-1, 0, SC_PIX_WIDTH-1};
    8. void linieadr(){
    9. asm("lda #<50");
    10. asm("sta $08");
    11. asm("lda #>50");
    12. asm("sta $09");
    13. asm("lda #100");
    14. asm("sta $18");
    15. asm("lda #<300");
    16. asm("sta $0a");
    17. asm("lda #>300");
    18. asm("sta $0b");
    19. asm("lda #255");
    20. asm("jsr $c118");
    21. asm("rts");
    22. }
    23. int main(void)
    24. {
    25. SetPattern(0);
    26. InitDrawWindow(&wholeScreen);
    27. Rectangle();
    28. linieadr();
    29. cgetc ();
    30. return 0;
    31. }
    Display All
    Images
    • Bild2.jpg

      3.74 kB, 500×344, viewed 4 times
  • spacer wrote:

    Es wurde 1zu1 umgesetzt
    Glückwunsch.

    Anmerkung:
    Das Beispiel aus Kapitel 4.5 enthält noch keine MegaAssembler-Syntax. Das würde so auch mit jedem anderen Assembler funktionieren.

    Wenn man MegaAssembler-Syntax mit dem MegaAssembler benutzt, dann würden die Zeilen 11-23 Deines Quelltextes folgendermaßen aussehen:

    LoadW r3,50 ; linke x-Koordinate
    LoadB r11l,100 ; y-Koordinate
    LoadW r4,300 ; rechte x-Koordinate
    lda #255 ; Linienmuster
    jsr HorizontalLine ; Linie zeichnen
    rts

    (Erklärung der Rountine im MegaAssembler-Handbuch Seite 226 oben)

    Auf jeden Fall ist die MegaAssembler-Syntax leichter les- und verstehbar, als das Listing aus dem MegaAssembler-Handbuch. In den späteren Beispiel-Listings des MegaAssembler-Buches (ab Kapitel 5) wird auch konsequent die MegaAssembler-Syntax benutzt.

    Der MegaAssembler macht dann daraus den Code, wie er in Deinem Beispiel Zeilen 11-23 zu finden ist und wie er vom C64 unter Geos verstanden wird.

    Wie man das mit cc65 macht, kann ich nicht sagen. Habe mich über die Jahre an die Schreibweise (Syntax) von MegaAssembler gewöhnt und keine Lust und Zeit noch eine neue Schreibweise (Syntax) zu lernen ;) .

    Was Du am Ende benutzt (MegaAssembler, cc64 oder was auch immer), bleibt natürlich Dir überlassen.

    Gruß
    Werner
  • wweicht wrote:

    Habe mich über die Jahre an die Schreibweise (Syntax) von MegaAssembler gewöhnt und keine Lust und Zeit noch eine neue Schreibweise (Syntax) zu lernen .
    Gute Entscheidung.

    Ich finde es zwar toll das man in C(?) Code für GEOS schreiben kann, und ich hab das eben auch mal mit dem Code aus Post#48 mit dem cl65 getestet, aber ich bin mir da nicht so sicher wie effizient der generierte Code ist. Ich hab das CVT mal in VICE geladen und disassembliert.

    Source Code

    1. .C:0400 A9 02 LDA #$02
    2. .C:0402 20 39 C1 JSR SetPattern
    3. .C:0405 A9 C0 LDA #$C0
    4. .C:0407 85 2F STA dispBufferOn
    5. .C:0409 20 2D 05 JSR $052D
    6. .C:040c A9 00 LDA #$00
    7. .C:040e A2 60 LDX #$60
    8. .C:0410 85 58 STA $58
    9. .C:0412 86 59 STX $59
    10. .C:0414 20 21 04 JSR $0421
    11. .C:0417 58 CLI
    12. .C:0418 20 90 04 JSR $0490
    13. .C:041b 20 A7 04 JSR $04A7
    14. .C:041e 4C 2C C2 JMP EnterDeskTop
    15. .C:0421 A0 00 LDY #$00
    16. .C:0423 F0 07 BEQ $042C
    17. .C:0425 A9 2D LDA #$2D
    18. .C:0427 A2 04 LDX #$04
    19. .C:0429 4C 4A 05 JMP $054A
    20. .C:042c 60 RTS
    21. .C:042d 20 B3 04 JSR $04B3
    22. .C:0430 A9 00 LDA #$00 ;Füllmuster setzen.
    23. .C:0432 20 39 C1 JSR SetPattern
    24. .C:0435 A9 40 LDA #$40 ;Fensterkoordinaten setzen.
    25. .C:0437 A2 05 LDX #$05
    26. .C:0439 20 CC 04 JSR $04CC
    27. .C:043c 20 24 C1 JSR Rectangle
    28. .C:043f A2 A3 LDX #$A3
    29. .C:0441 A9 E8 LDA #$E8
    30. .C:0443 A0 02 LDY #$02
    31. .C:0445 20 24 05 JSR $0524
    32. .C:0448 A2 A0 LDX #$A0
    33. .C:044a A9 00 LDA #$00
    34. .C:044c A0 04 LDY #$04
    35. .C:044e 20 24 05 JSR $0524
    36. .C:0451 A0 02 LDY #$02
    37. .C:0453 D1 58 CMP ($58),Y
    38. .C:0455 8A TXA
    39. .C:0456 C8 INY
    40. .C:0457 F1 58 SBC ($58),Y
    41. .C:0459 B0 1A BCS $0475
    42. .C:045b A0 05 LDY #$05
    43. .C:045d 20 DF 04 JSR $04DF
    44. .C:0460 85 60 STA $60
    45. .C:0462 86 61 STX $61
    46. .C:0464 A9 81 LDA #$81
    47. .C:0466 A0 00 LDY #$00
    48. .C:0468 91 60 STA ($60),Y
    49. .C:046a A0 05 LDY #$05
    50. .C:046c 20 DF 04 JSR $04DF
    51. .C:046f 20 C0 04 JSR $04C0
    52. .C:0472 4C 4C 04 JMP $044C
    53. .C:0475 A2 01 LDX #$01
    54. .C:0477 A9 F4 LDA #$F4
    55. .C:0479 20 EF 04 JSR $04EF
    56. .C:047c A2 00 LDX #$00
    57. .C:047e 8A TXA
    58. .C:047f 4C C7 04 JMP $04C7
    59. .C:0482 C8 INY
    60. .C:0483 48 PHA
    61. .C:0484 18 CLC
    62. .C:0485 98 TYA
    63. .C:0486 65 58 ADC $58
    64. .C:0488 85 58 STA $58
    65. .C:048a 90 02 BCC $048E
    66. .C:048c E6 59 INC $59
    67. .C:048e 68 PLA
    68. .C:048f 60 RTS
    69. .C:0490 AD 46 05 LDA $0546
    70. .C:0493 AE 47 05 LDX $0547
    71. .C:0496 20 0C 05 JSR $050C
    72. .C:0499 AD 48 05 LDA $0548
    73. .C:049c AE 49 05 LDX $0549
    74. .C:049f 20 0C 05 JSR $050C
    75. .C:04a2 A0 04 LDY #$04
    76. .C:04a4 4C 2D 04 JMP $042D
    77. .C:04a7 A0 00 LDY #$00
    78. .C:04a9 F0 07 BEQ $04B2
    79. .C:04ab A9 40 LDA #$40
    80. .C:04ad A2 05 LDX #$05
    81. .C:04af 4C 4A 05 JMP $054A
    82. .C:04b2 60 RTS
    83. .C:04b3 A5 58 LDA $58
    84. .C:04b5 38 SEC
    85. .C:04b6 E9 06 SBC #$06
    86. .C:04b8 85 58 STA $58
    87. .C:04ba 90 01 BCC $04BD
    88. .C:04bc 60 RTS
    89. .C:04bd C6 59 DEC $59
    90. .C:04bf 60 RTS
    91. .C:04c0 18 CLC
    92. .C:04c1 69 01 ADC #$01
    93. .C:04c3 90 01 BCC $04C6
    94. .C:04c5 E8 INX
    95. .C:04c6 60 RTS
    96. .C:04c7 A0 06 LDY #$06
    97. .C:04c9 4C 83 04 JMP $0483
    98. .C:04cc 85 66 STA $66
    99. .C:04ce 86 67 STX $67
    100. .C:04d0 A0 00 LDY #$00
    101. .C:04d2 B1 66 LDA ($66),Y
    102. .C:04d4 99 06 00 STA $0006,Y
    103. .C:04d7 C8 INY
    104. .C:04d8 C0 06 CPY #$06
    105. .C:04da D0 F6 BNE $04D2
    106. .C:04dc 60 RTS
    107. .C:04dd A0 01 LDY #$01
    108. .C:04df B1 58 LDA ($58),Y
    109. .C:04e1 AA TAX
    110. .C:04e2 88 DEY
    111. .C:04e3 B1 58 LDA ($58),Y
    112. .C:04e5 60 RTS
    113. .C:04e6 20 99 C1 JSR Sleep
    114. .C:04e9 A6 68 LDX $68
    115. .C:04eb 9A TXS
    116. .C:04ec 6C 60 00 JMP ($0060)
    117. .C:04ef 85 02 STA $02
    118. .C:04f1 86 03 STX $03
    119. .C:04f3 68 PLA
    120. .C:04f4 85 60 STA $60
    121. .C:04f6 68 PLA
    122. .C:04f7 85 61 STA $61
    123. .C:04f9 E6 60 INC $60
    124. .C:04fb D0 02 BNE $04FF
    125. .C:04fd E6 61 INC $61
    126. .C:04ff BA TSX
    127. .C:0500 86 68 STX $68
    128. .C:0502 20 E6 04 JSR $04E6
    129. .C:0505 4C C3 C1 JMP MainLoop
    130. .C:0508 A9 00 LDA #$00
    131. .C:050a A2 00 LDX #$00
    132. .C:050c 48 PHA
    133. .C:050d A5 58 LDA $58
    134. .C:050f 38 SEC
    135. .C:0510 E9 02 SBC #$02
    136. .C:0512 85 58 STA $58
    137. .C:0514 B0 02 BCS $0518
    138. .C:0516 C6 59 DEC $59
    139. .C:0518 A0 01 LDY #$01
    140. .C:051a 8A TXA
    141. .C:051b 91 58 STA ($58),Y
    142. .C:051d 68 PLA
    143. .C:051e 88 DEY
    144. .C:051f 91 58 STA ($58),Y
    145. .C:0521 60 RTS
    146. .C:0522 A0 00 LDY #$00
    147. .C:0524 91 58 STA ($58),Y
    148. .C:0526 C8 INY
    149. .C:0527 48 PHA
    150. .C:0528 8A TXA
    151. .C:0529 91 58 STA ($58),Y
    152. .C:052b 68 PLA
    153. .C:052c 60 RTS
    154. .C:052d A9 00 LDA #$00
    155. .C:052f A2 00 LDX #$00
    156. .C:0531 85 02 STA $02
    157. .C:0533 86 03 STX $03
    158. .C:0535 A9 6F LDA #$6F
    159. .C:0537 A2 05 LDX #$05
    160. .C:0539 85 04 STA $04
    161. .C:053b 86 05 STX $05
    162. .C:053d 4C 78 C1 JMP ClearRam
    163. .C:0540 00 b $00
    164. .C:0541 C7 b $c7
    165. .C:0542 00 00 w $0000
    166. .C:0544 3F 01 w $013f
    167. .C:0546 00 b $00
    168. .C:0547 00 b $00
    169. .C:0548 00 b $00
    170. .C:0549 00 b $00
    171. .C:054a 8D 58 05 STA $0558
    172. .C:054d 8E 59 05 STX $0559
    173. .C:0550 8D 5F 05 STA $055F
    174. .C:0553 8E 60 05 STX $0560
    175. .C:0556 88 DEY
    176. .C:0557 B9 FF FF LDA $FFFF,Y
    177. .C:055a 8D 69 05 STA $0569
    178. .C:055d 88 DEY
    179. .C:055e B9 FF FF LDA $FFFF,Y
    180. .C:0561 8D 68 05 STA $0568
    181. .C:0564 8C 6B 05 STY $056B
    182. .C:0567 20 FF FF JSR $FFFF
    183. .C:056a A0 FF LDY #$FF
    184. .C:056c D0 E8 BNE $0556
    185. .C:056e 60 RTS
    186. .C:056f 00 b $00
    187. .C:0570 00 b $00
    Display All
    Wenn ich das richtig vestanden hab sollte das Programm den Bildschirm löschen und dann 1000 Bytes im Grafikspeicher schreiben. Ich hoffe mal der C-Code ist nicht optimal, denn der generierte Code scheint mir mehr als nur überdimensioniert.

    Ich hoffe mal das ich den cl65 nicht richtig verwendet habe und der Code noch optimierbar ist. Für mich wäre ansonsten der generierte Code nur für kleinere Programme sinnvoll nutzbar wenn man C kann aber kein Assembler.

    Ich halte es da wie wweicht und bleibe beim MegaAss. Aber cool das man unter Linux ein GEOS-Programm compilieren kann. Auch wenn da vermutlich nur GEOS 1.x/2.x und nicht MP3 unterstützt wird.
  • Ich habe als Neuling mit meinem 70 jahren ausgelotet mit was man es besser machen kann. Seit mehren Tagen suche ich und bin dann auf cc65 umgestiegen. Beim Optimieren kommt noch etwas raus aber nicht viel , der wird dann von 800 Byte auf ca 600 Byte runtergehen.

    Da ich nicht meinen ASM-Code auf dem GEOS2.5 schreiben möchte unter einem GEOS-Editor habe ich mich zu diesen Ziel mit Cross entschlossen.
    Es gibt leider keinen ASM der unter Cross genutzt werden kann für GEOS-Code.

    Ich brauche Math-Befehle für meine Grafik mit Bewegung und FLOAT (geht auch mit dem cc65 unter GEOS2.5).
    Da kann der Mega leider nur die internen langsamen von GEOS anbieten.

    Ich würde mich freuen wenn ich mal schöne Grafikbeispiele usw von den Usern mit MegaAss hier sehen könnte , habe mir schon im Internet einen
    Wolf gelaufen. Es fehlen so wie bei mir mit cc65 mal schöne kleine Teste vom MegaAss....
    Es wird hier nur etwas geschrieben wenn hier etwas gemacht wurde...schade.

    Ich habe festgestellt das der cc65 für große Programme optimal ist.

    Gruss

    The post was edited 1 time, last by spacer ().

  • spacer wrote:

    cc65 ist für größere Programme optimal , beim MegaAss würde bald der Texteditor vom GEOS platzen und die Langsamkeit beim Compilieren habe ich festgestellt.
    Das sehe ich anders. Für größere Programme wird bei dem ineffizienten Code ganz schnell der Speicher knapp.

    Und was größere Programme mit dem MegaAss angeht, ich glaube ich darf sagen das GeoDOS und MegaPatch zu den größten GEOS-Projekten gehören und auch nach 20Jahren arbeite ich noch mit GeoWrite/MegaAss. Man kann da nänmlich den Code auf viele kleine Textdateien aufteilen und die dann assemblieren, genau wie unter C/cc65. MegaPatch besteht aus über 400 einzelnen Quelltext-Dateien.

    Das assemblieren unter GEOS langsamer ist, das stimmt. Bitte aber nicht vergessen das dies unter VICE kein Thema ist (WARP-Modus) und am C64 mit SCPU oder TC64 auch Möglichkeiten existieren das zu beschleunigen. Mal davon abgesehen das die mit dem MegaAss erstellten Programme direkt getestet werden können, nix mit CVT und kopieren auf D64 usw...

    spacer wrote:

    Jeder so wie er kann.
    Hab ich ja geschrieben... wenn jemand C kann ist das doch OK... aber optimaler Code sieht eben anders aus. Schau Dir mal die Routine bei $052d in meinem Post an: Die soll genau 0(!) Bytes ab $056f löschen. kein Assembler-Programmierer käme auf die Idee so etwas zu schreiben.
  • -------------------
    GeoDOS und MegaPatch zu den größten GEOS-Projekten gehören
    -------------------
    Leider sehe ich keine Resultate in irgendein Forum wo ich mal viele funktionelle Tätigkeiten sehen kann zum lernen in Deutsch.

    ---------------
    Bytes ab $056f löschen
    ---------------
    Das ist für mich Kinderkram....das noch zu beurteilen.

    Ich nehme den cc65 , weil ich zur Zeit gute Erfolge habe.
    Es macht Spaß, das das GEOS2.5 jetzt FLOAT-Zahlen ausgeben kann mit dem cc65 , sogar aus den Basic-ROM raus.
    Das ist mein Hobby, wer macht so etwas verrücktes schon und tüftelt so.

    Gruss

    The post was edited 2 times, last by spacer ().

  • spacer wrote:

    Leider sehe ich keine Resultate in irgendein Forum wo ich mal auf viele funktionelle Tätigkeiten sehen kann.
    Was meinst Du damit?
    Den Code von GeoDOS kannst Du hier einsehen, den von MegaPatch findest Du hier. Mehr GEOS Code in Assembler geht fast nicht (gibt ja noch mehr Programme dort zu finden... geoDirSelect, geoCham64RTC). Der Code ist weitestgehend auch gut dokumentiert.

    Aber ich will Dich ja nicht von C abbringen. Wie gesagt finde ich es cool das es überhaupt funktioniert. Hab den cc65 extra aus dem github heruntergeladen und compilliert weil es mich schon immer interresiert hat wie C-Code gegen Assembler abschneidet. Das ist jetzt das erste mal das ich das beurteilen kann. Am PC fehlt mir da der Background.


    spacer wrote:

    Das ist für mich Kinderkram....das noch zu beurteilen.
    Ich kann kein C... kann nur den Code zumindest halbwegs lesen. Schreib doch einen C-Code zu dem Beispiel von oben der optimiert ist. Mich würde das wirklich interessieren wie das aussieht im Vergleich zu einer reinen ASM-Routine. Ein paar Bytes Verlust sind kein Thema. Aber es sollte kein Code enthalten sein der absolut nichts macht.


    P.S. Hab gerade noch etwas Feedback bekommen, der Code lässt sich wohl noch etwas optimieren, aber nie so effizient wie Assembler. Macht nix. Jeder wie er kann ;)

    The post was edited 3 times, last by darkvision ().


  • Schreib doch einen C-Code zu dem Beispiel von oben der optimiert ist.

    Ich nehme an das dieser Code:

    SetPattern(0);
    InitDrawWindow(&wholeScreen);
    Rectangle();

    Einiges verbraucht. Und anders durch eigene Routinen ersetzt werden kann.

    Ich hatte ja oben einmal nachgefragt ob alle Macros aus MegaAss mal lesbar umgesetzt werden im normalen Textformat, das wäre eine große Hilfe.

    Danke.
    Gruss