home *** CD-ROM | disk | FTP | other *** search
/ 8bitfiles.net/archives / archives.tar / archives / genie-commodore-file-library / Information / HACKING1.SFX / hacking1.2-3 < prev    next >
Encoding:
Text File  |  1990-02-12  |  25.1 KB  |  501 lines
  1. ┴ ┬┴╙╔├ DEMONSTRATION PROGRAM IS ALSO INCLUDED IN THE ╒╒ SECTION FOR THIS
  2. PACKAGE.  ╔T STARTS BY PUTTING THE PIXEL CURSOR AT THE CENTER OF THE SCREEN
  3. AND THEN PICKS A RANDOM POINT TO DRAW TO, AND REPEATS UNTIL YOU PRESS A KEY
  4. TO STOP IT.  ╞OR AN INTERESTING EFFECT, PUT A CALL TO $1303 IMMEDIATELY BEFORE
  5. THE CALL TO DRAW THE LINE.
  6.  
  7. ╘HE POINT PLOTTING SPEED IS ABOUT 4,100 PIXELS PER SECOND AND THE LINE DRAWING
  8. SPEED IS A BIT SLOWER THAN THIS BECAUSE OF ALL OF THE CALCULATIONS THAT HAVE
  9. TO BE DONE TO DRAW A LINE.  ╘HERE ARE FASTER PIXEL PLOTTING AND LINE DRAWING
  10. ALGORITHMS THAN THE ONES IMPLEMENTED HERE, BUT THAT IS MATERIAL FOR A FUTURE
  11. ARTICLE.
  12.  
  13. 2. ╔╬╘╥╧─╒├╘╔╧╬ ╘╧ ╘╚┼ ╓─├
  14.  
  15. ╨ROGRAMMING THE 8563 ╓IDEO ─ISPLAY ├ONTROLLER IS QUITE STRAIGHT FORWARD.  ┘OU
  16. ACCESS IT A BIT INDIRECTLY, BUT IT CAN STILL BE DONE AT RELATIVELY HIGH SPEEDS
  17. USING MACHINE LANGUAGE.  ╘HE ╓─├ CONTAINS 37 CONTROL REGISTERS AND FROM 16╦ TO
  18. 64╦ OF DEDICATED DISPLAY MEMORY THAT IS SEPARATE FROM THE MAIN PROCESSOR.  ╘HE
  19. MEMORY MUST BE ACCESSED THROUGH THE ╓─├ REGISTERS.
  20.  
  21. ╘HE IMPORTANT ╓─├ REGISTERS FOR THIS EXERCISE ARE:
  22.  
  23. ╥┼╟   ┬╔╘╙   ─┼╙├
  24. ---   ----   ----
  25. $12   7-0    ╓─├ ╥┴═ ADDRESS HIGH BYTE
  26. $13   7-0    ╓─├ ╥┴═ ADDRESS LOW BYTE
  27. $18   7      ┬LOCK COPY / BLOCK FILL MODE SELECT
  28. $19   7      ┬ITMAP / ├HARACTER MODE SELECT
  29. $19   6      ├OLOR / ═ONOCHROME MODE SELECT
  30. $1A   7-4    ╞OREGROUND COLOR
  31. $1A   3-0    ┬ACKGROUND COLOR
  32. $1E   7-0    ├OPY / FILL REPETITION COUNT
  33. $1F   7-0    ╓─├ ╥┴═ DATA READ / WRITE
  34.  
  35. ┘OU ACCESS THE ╓─├ CHIP REGISTERS THOUGH ADDRESSES $─╞00 AND $─╞01 ON BANK 15.
  36. ╠OCATION $─╞00 SELECTS THE ╓─├ REGISTER TO USE ON WRITE AND RETURNS THE ╓─├
  37. STATUS ON READ.  ╘HE ONLY IMPORTANT STATUS INFORMATION IS BIT 7 (VALUE $80)
  38. WHICH IS THE "READY" FLAG.  ╘HE FOLLOWING TWO SUBROUTINES READ OR WRITE THE
  39. VALUE IN .┴ TO ╓─├ REGISTER NUMBER .╪:
  40.  
  41. ╓DC╥EAD:  STX $DF00                  ╓DC╫RITE: STX $DF00
  42. ╫AIT╠OOP: BIT $DF00                  ╫AIT╠OOP: BIT $DF00
  43.           BPL ╫AIT╠OOP                         BPL ╫AIT╠OOP
  44.           LDA $DF01                            STA $DF01
  45.           RTS                                  RTS
  46.  
  47. ╧NCE THE CURRENT ╓─├ REGISTER IS SELECTED AT $DF00, IT REMAINS SELECTED.  ┘OU
  48. MAY READ OR WRITE IT THOUGH $DF01 AS MANY TIMES AS YOU LIKE AS LONG AS YOU
  49. WAIT FOR THE ╓─├ TO BE "READY" BETWEEN ACCESSES.
  50.  
  51. ╔N ORDER TO ACCESS THE ╓─├ ╥┴═, YOU MUST FIRST PUT THE HIGH AND LOW BYTES OF
  52. THE ╓─├ ╥┴═ ADDRESS INTO REGISTERS $12 AND $13 (HIGH BYTE FIRST) AND THEN
  53. READ OR WRITE THROUGH REGISTER $1F TO READ OR WRITE THE DATA IN THE ╓─├ ╥┴═.
  54. ┴FTER EACH ACCESS TO REGISTER $1F, THE ╓─├ ╥┴═ ADDRESS IS INCREMENTED BY ONE.
  55. ╙O, IF YOU REPEATEDLY READ OR WRITE TO REGISTER $1F YOU CAN READ OR WRITE A
  56. CHUNK OF ╓─├ MEMORY VERY QUICKLY.
  57.  
  58. 3. ┼╬╘┼╥╔╬╟ ╟╥┴╨╚╔├╙ ═╧─┼
  59.  
  60. ┴CTIVATING THE GRAPHICS MODE OF THE ╓─├ IS VERY SIMPLE - YOU JUST HAVE TO SET
  61. BIT 7 OR ╓─├ REGISTER $19 AND POOF!  ┘OU SHOULD ALSO CLEAR BIT 6 OF THAT
  62. REGISTER TO DISABLE THE CHARACTER COLOR MODE.  ╘HIS GRAPHICS PACKAGE SUPPORTS
  63. ONLY MONOCHROME GRAPHICS SINCE THE STANDARD 16╦ ╓─├ DOES NOT HAVE ENOUGH SPACE
  64. TO HOLD BOTH THE BITMAP AND THE 8*8 PIXEL CELL ATTRIBUTES.  ╘HE 640*200 PIXEL
  65. DISPLAY TAKES 128,000 BITS OR 16,000 BYTES.  ╘HIS LEAVES 384 BYTES OF ╓─├ ╥┴═
  66. THAT IS NOT NEEDED BY THE BITMAP BUT IT IS NOT LARGE ENOUGH TO DO ANYTHING
  67. WITH, SO IT IS WASTED.
  68.  
  69. ╫HEN YOU DISABLE THE CHARACTER COLOR MODE, THE ╓─├ TAKES ITS FOREGROUND AND
  70. BACKGROUND COLOR VALUES FROM REGISTER $1A.  ╘HE FOREGROUND COLOR IS WHAT COLOR
  71. THE "1" BITS IN THE BITMAP WILL BE DISPLAYED IN AND THE BACKGROUND COLOR, THE
  72. "0" BITS.
  73.  
  74. ╬OW THAT THE BITMAP MODE IS SET UP, WE MUST CLEAR THE ╓─├ MEMORY LOCATIONS 0
  75. TO 15999 (DECIMAL) TO CLEAR THE BITMAP SCREEN.  ╘HIS CAN BE DONE VERY QUICKLY
  76. USING THE ╓─├ FILL MODE.  ╔F YOU POKE A VALUE INTO ╓─├ REGISTER NUMBER $1E,
  77. THE ╓─├ WILL FILL ITS MEMORY FROM THE LOCATION CURRENTLY IN THE ╓─├ ╥┴═
  78. ADDRESS REGISTERS FOR THE NUMBER OF BYTES YOU JUST POKED INTO REGISTER $1E
  79. WITH THE VALUE THAT YOU LAST POKED INTO THE ╓─├ ╥┴═ DATA REGISTER.  (╘HIS IS
  80. ASSUMING THAT "FILL" MODE IS SELECTED IN REGISTER $18).  ╔F YOU POKE A 0 INTO
  81. THE REPEAT REGISTER IT MEANS TO FILL 256 BYTES.
  82.  
  83. ╙O, TO CLEAR THE BITMAP, POKE A ZERO INTO BOTH OF THE ╓─├ ╥┴═ ADDRESS
  84. REGISTERS SINCE THE BITMAP STARTS AT LOCATION 0.  ╘HEN POKE A VALUE OF 0 INTO
  85. ╓─├ ╥┴═ DATA REGISTER.  ╘HIS SETS THE FILL VALUE TO 0 AND POKES THE FIRST ╓─├
  86. ╥┴═ LOCATION.  ╘HEN, GO INTO A LOOP AND PUT A ZERO INTO THE ╓─├ REPEAT
  87. REGISTER 63 TIMES.  ╘HIS WILL FILL 63 CONTIGUOUS CHUNKS OF 256 BYTES EACH.
  88. ╫E END UP FILLING 16,129 BYTES, BUT THAT IS NOT A PROBLEM SINCE WE HAVE 384
  89. "SAFETY" BYTES AT THE END OF THE BITMAP.  ╔NTERNALLY, THE ╓─├ WILL FILL ITS
  90. MEMORY AT A RATE OF ABOUT 1 ═EGABYTE PER SECOND (IF ╔ REMEMBER MY TEST RESULTS
  91. CORRECTLY), SO CLEARING THE SCREEN IS A ╨─╤ OPERATION.
  92.  
  93. 4. ┼╪╔╘╔╬╟ ╟╥┴╨╚╔├╙ ═╧─┼
  94.  
  95. ╘O EXIT FROM GRAPHICS MODE WE HAVE TO RELOAD THE CHARACTER SET FROM THE ╥╧═
  96. ON BANK 14 AND WE HAVE TO GO BACK INTO CHARACTER MODE AND CLEAR THE TEXT
  97. SCREEN.  ╘HE KERNEL PROVIDES ITS OWN CHARACTER RELOAD ROUTINE SO ╔ USED THAT.
  98. ╘HE ONLY PROBLEM WITH IT IS THAT IT IS A LOT SLOWER THAN IT HAS TO BE.  ╔T
  99. TAKES ABOUT 0.45 SECONDS WHEREAS THE SAME JOB CAN BE DONE IN ABOUT 0.09
  100. SECONDS.  ╘HE KERNEL IS SO SLOW BECAUSE IT USES THE KERNEL ╔╬─╞┼╘├╚ NONSENSE.
  101.  
  102. ╘HEN YOU JUST SET THE BITMAP MODE BIT TO ZERO AND THE CHARACTER COLOR MODE TO
  103. ONE.  ╘HIS GETS YOU BACK TO NORMAL CHARACTER MODE.  ┘OU ALSO HAVE TO CLEAR THE
  104. TEXT SCREEN SINCE IT WILL BE FILLED WITH GARBAGE FROM THE GRAPHING.
  105.  
  106. 5. ╨╧╔╬╘ ╨╠╧╘╘╔╬╟
  107.  
  108. ╘HE PIXELS ON THE SCREEN ACCESSED BY THEIR ╪ AND ┘ COORDINATES, 0 <= ╪ <= 639,
  109. 0 <= ┘ <= 199.  ╘HE FORMULA TO CALCULATE THE BYTE ADDRESS IN THE ╓─├ ╥┴═ GIVEN
  110. THE ╪ AND ┘ COORDINATES IS MADE SIMPLE BY THE MAPPING OF BYTES TO THE PIXELS
  111. ON THE SCREEN.  ╘HE BYTES OF ╓─├ MEMORY GO ACROSS THE SCREEN RATHER THAN IN
  112. 8*8 CELLS LIKE THE ╓╔├ SCREEN.  ┼ACH PIXEL ROW IS DEFINED BY 80 CONSECUTIVE
  113. BYTES OF ╓─├ ╥┴═.
  114.  
  115. ╘HE FORMULA FOR THE BYTE ADDRESS OF A PIXEL IS: ┴─=┘*80+╔╬╘(╪/8), AND THE
  116. FORMULA FOR THE BIT NUMBER IS SIMPLY ┬╔=╪ ┴╬─ 7.  ╘HE BIT NUMBER CAN BE USED
  117. AS AN INDEX INTO A TABLE OF BIT VALUES: [$80,$40,$20,$10,$08,$04,$02,$01],
  118. SUCH THAT INDEX 0 CONTAINS $80, SINCE THE HIGHEST BIT IS THE LEFTMOST BIT.
  119.  
  120. ├ALCULATING THE BIT NUMBER AND LOOKING UP THE BIT VALUE IS VERY EASY TO DO IN
  121. MACHINE LANGUAGE, BUT THE BYTE ADDRESS CALCULATION REQUIRES A LITTLE MORE
  122. WORK.  ╞IRST WE HAVE TO MULTIPLY THE ┘ VALUE BY 80, USING A 16-BIT WORD FOR
  123. STORAGE.  ╘HIS IS DONE BY SHIFTING THE ┘ VALUE LEFT TWICE, ADDING THE ORIGINAL
  124. ┘ VALUE, AND SHIFTING LEFT FOUR MORE TIMES.  ╘HEN WE HAVE TO SHIFT THE ╪ VALUE
  125. RIGHT BY THREE USING A 16-BIT WORD FOR STORAGE TO GET ╔╬╘(╪/8), AND WE ADD THE
  126. TWO RESULTS TOGETHER AND WE HAVE THE BYTE ADDRESS.
  127.  
  128. ╘O PLOT THE POINT, WE HAVE TO PEEK INTO THE ╓─├ ╥┴═ AT THE BYTE ADDRESS TO SEE
  129. WHAT IS "BEHIND" THE PIXEL WE WANT TO PLOT.  ╘HEN ╧╥ THE NEW BIT VALUE ON TO
  130. THE "BACKGROUND" VALUE AND POKE THE RESULT BACK INTO ╓─├ ╥┴═ AT THE BYTE
  131. ADDRESS.  ╒NFORTUNATELY, SINCE THE ╓─├ ╥┴═ ADDRESS REGISTER AUTO-INCREMENTS
  132. AFTER EACH REFERENCE, WE WILL HAVE TO SET IT TWICE - ONCE FOR THE READ AND
  133. ONCE FOR THE WRITE.  ╘HAT MEANS THAT THE ╓─├ REGISTERS HAVE TO BE ACCESSED SIX
  134. TIMES FOR EACH PIXEL.  ╞ORTUNATELY, THE ╓─├ OPERATES AT ITS HIGHEST SPEED IN
  135. MONOCHROME BITMAP MODE (IT HAS LESS WORK TO DO THAN IN COLOR CHARACTER MODE,
  136. SO IT IS ABLE TO PAY MORE ATTENTION TO THE ├╨╒).
  137.  
  138. ┼FFECTS OTHER THAN JUST PLOTTING THE POINT CAN BE ACHIEVED BY USING FUNCTIONS
  139. OTHER THAN ╧╥ TO PUT THE POINT ON THE BACKGROUND.  ┼╧╥ WOULD "FLIP" THE PIXEL,
  140. AND ┴╬─-╬╧╘ (ACHIEVED BY ╠─┴ BITVAL : ┼╧╥ #$FF : ┴╬─ BACKGROUND) WOULD ERASE
  141. THE PIXEL.
  142.  
  143. 6. ╠╔╬┼ ─╥┴╫╔╬╟
  144.  
  145. ╘HE LINE DRAWING ROUTINE THAT IS IMPLEMENTED IN THE PACKAGE IS GIVEN BY THE
  146. FOLLOWING ┬┴╙╔├ CODE (IN FACT, ╔ PROGRAMMED IT IN ┬┴╙╔├ FIRST TO GET IT
  147. WORKING; OF COURSE, THE ┬┴╙╔├ VERSION IS AS SLOW AS HELL):
  148.  
  149. 10 DX=X-LX:DY=Y-LY
  150. 20 IF ABS(DX)>ABS(DY) THEN BEGIN R=DX:GY=DY/ABS(DX):GX=SGN(DX)
  151. 30 BEND:ELSE R=DY:GX=DX/ABS(DY):GY=SGN(DY)
  152. 40 PX=LX+0.5:PY=LY+0.5
  153. 50 FORI=1TO ABS(R): <╨╠╧╘ ╨╪,╨┘> :PX=PX+GX:PY=PY+GY:NEXT
  154. 60 LX=X:LY=Y
  155.  
  156. ╘HIS IMPLEMENTS THE ┬ASIC ╔NCREMENTAL ┴LGORITHM FOR RASTER LINE DRAWING.  ╘HE
  157. "LX" AND "LY" ARE THE POSITION OF THE PIXEL CURSOR AND "X" AND "Y" ARE THE
  158. COORDINATES TO DRAW THE LINE TO.  ╘HE "DX" AND "DY" ARE THE DIFFERENCES IN THE
  159. ╪ AND ┘ DIRECTIONS.  ╘HE IDEA IS THAT WE WILL INCREMENT THE PIXEL CURSOR BY
  160. A CONSTANT OF 1 IN ONE DIRECTION AND BY A FRACTION 0.0 <= G <= 1.0 IN THE
  161. OTHER DIRECTION.  ╘HIS FRACTION IS ACTUALLY THE SLOPE OF THE LINE.
  162.  
  163. ╠INES 20 AND 30 FIGURE OUT THE INCREMENTS FOR THE ╪ AND ┘ DIRECTIONS ("GX" AND
  164. "GY").  ╘HESE ARE SIGNED FRACTIONAL NUMBERS ON THE RANGE -1.0 <= G <= 1.0.
  165. ╫E CHECK THE "DX" AND "DY" TO SEE WHICH HAS THE GREATEST ABSOLUTE VALUE AND
  166. THAT WILL BE THE DIRECTION THAT IS INCREMENTED BY 1, 0, OR -1 AND THE OTHER
  167. DIRECTION WILL INCREMENT BY THE (FRACTIONAL) SLOPE OF THE LINE WITH RESPECT TO
  168. THE OTHER DIRECTION.
  169.  
  170. ╠INE 40 STARTS THE PLOTTING AT THE CURRENT PIXEL CURSOR LOCATION ╨╠╒╙ 0.5.  ╫E
  171. ADD 1/2 TO THE ╪ AND ┘ POSITIONS TO "CENTER" ONTO THE PIXEL CELL.  ╔F WE
  172. DIDN'T DO THIS, WE WOULD NOTICE DIS-SYMMETRY IN PLOTTING TO THE LEFT AND TO
  173. THE RIGHT.  ╞OR EXAMPLE, 50.0 - 0.3 = 49.7 AND 50.0 + 0.3 = 50.3.  ╔F WE
  174. TRUNCATE THESE VALUES, GOING LEFT BY 0.3 MOVES US TO POSITION 49 WHEREAS GOING
  175. RIGHT BY 0.3 MAKES US STAY IN THE SAME POSITION.  ╘HIS IS DIS-SYMMETRY AND
  176. MAKES PLOTS LOOK A BIT OFF.  ┴DDING 0.5 CORRECTS THE PROBLEM.
  177.  
  178. ╠INE 50 GOES INTO A LOOP FOR THE LONGEST DIMENSION OF THE LINE (THE ONE
  179. INCREMENTED BY 1).  ╘HE <╨╠╧╘ ╨╪,╨┘> IS NOT EXACTLY ┬┴╙╔├; YOU SUBSTITUTE
  180. THE CALL TO THE POINT PLOT ROUTINE DESCRIBED IN THE PREVIOUS SECTION.  ╔T
  181. REPEATEDLY ADDS THE ╪ AND ┘ INCREMENT VALUES UNTIL THE LINE IS FINISHED.
  182. ╘HIS ALGORITHM DRAWS THE LINE IN THE DIRECTION THAT YOUR END POINTS IMPLY.
  183.  
  184. 6.1. ╞╥┴├╘╔╧╬┴╠ ╬╒═┬┼╥ ╥┼╨╥┼╙┼╬╘┴╘╔╧╬
  185.  
  186. ╘HERE ARE ONLY TWO REAL COMPLICATIONS TO THE MACHINE LANGUAGE IMPLEMENTATION
  187. ARE THE REPRESENTATION OF THE SIGNED FRACTIONAL NUMBERS AND THE DIVISION OF
  188. THE FRACTIONAL NUMBERS.  ╘O REPRESENT THE NUMBERS ╔ USE A 32-BIT FORMAT WITH
  189. A 16-BIT SIGNED INTEGER PORTION (-32768 TO +32767) AND A 16-BIT FRACTIONAL
  190. PORTION (0.0 TO 0.99998474 IN 0.00001526 INCREMENTS).  ╘HE WEIGHT VALUES OF
  191. THE BIT POSITIONS ARE AS FOLLOWS:
  192.  
  193. ╨╧╙    31 ... 22 21 20 19 18 17 16  15  14  13  12    11   10     9 ...      0
  194. ╓┴╠ 32768 ... 64 32 16  8  4  2  1 1/2 1/4 1/8 1/16 1/32 1/64 1/128 ...1/65536
  195.  
  196. ╞OR EXAMPLE, 0...00001011101.10011010000...0 (NOTICE THE ┬╔╬┴╥┘ POINT) IS
  197. 64 + 16 + 8 + 4 + 1 + 1/2 + 1/16 + 1/32 + 1/128 = 93.6015625 IN DECIMAL.  ╧R,
  198. AS A SHORT CUT, YOU CAN CONSIDER THE INTEGER 16 BITS AND THE FRACTIONAL 16
  199. BITS AS INDEPENDENT WORDS AND ADD 1/65536TH OF THE SECOND TO THE FIRST.  ╘HUS,
  200. FOR THE EXAMPLE ABOVE, THE QUANTITY IS 93 + (32768+4096+2048+512)/65536 =
  201. 93.6015625.  (╟OOD, THEY BOTH MATCH).  ╘HE FIRST CALCULATION USES TRUE BASE 2
  202. WHEREAS THE SECOND CALCULATION USES BASE 65536.
  203.  
  204. ╘WO'S COMPLEMENT REPRESENTATION IS USED TO ACHIEVE SIGNEDNESS (,╨ARK!).  ╫E
  205. SHOULD ALL KNOW ABOUT TWO'S COMP.  ╫ELL, IT WORKS JUST FINE FOR FRACTIONAL
  206. BINARY NUMBERS AS WELL.  ╔N FACT, IT MAKES NO DIFFERENCE AT ALL.  ┘OU CAN JUST
  207. THINK OF THE QUANTITY AS AN INTEGER NUMBER OF 65536'S OF A PIXEL AND YOU GET
  208. THE INTEGER OPERATIONS OF COMPLEMENT, ADD, AND SUBTRACT FOR FREE.  ╘HE EASY
  209. WAY TO GET THE TWO'S COMP. REPRESENTATION OF A NUMBER IS TO TAKE THE POSITIVE
  210. BINARY IMAGE OF THE NUMBER AND SUBTRACT IT FROM 0 (THIS MAKES PERFECT SENSE
  211. SINCE 0 - X = -X).
  212.  
  213. ╞RACTIONAL BINARY DIVISION IS A LITTLE MORE COMPLICATED.  ╘HERE IS NO PROBLEM
  214. WITH THE BINARY POINT, SINCE THE LAWS OF MATHEMATICS SAY WE CAN MULTIPLY THE
  215. TOP AND BOTTOM BY THE SAME QUANTITY (LIKE 65536) WITHOUT CHANGING THE RESULT,
  216. BUT HANDLING THE TWO'S COMPLEMENT IS A PROBLEM.  ╫HAT ╔ DID WAS FIGURE OUT
  217. WHAT THE SIGN OF THE RESULT OF THE DIVISION WAS GOING TO BE (BY ┼╧╥ING THE
  218. SIGN BITS TOGETHER) AND THEN CONVERTED THE TWO OPERANDS TO THEIR POSITIVE
  219. VALUE IF THEY WERE ORIGINALLY NEGATIVE.  ╘HIS LETS ME PERFORM A 32-BIT
  220. UNSIGNED DIVISION OPERATION AND THEN ╔ CONVERT THE RESULT TO A NEGATIVE IF THE
  221. RESULT IS SUPPOSED TO BE NEGATIVE.  ╘HE 32-BIT DIVIDE IS NOT ALL THAT
  222. COMPLICATED; IT IS DONE THE SAME WAY THAT YOU WOULD DO IT ON PAPER (REMEMBER
  223. THOSE DAYS) EXCEPT YOU USE BINARY DIGITS.  ╘HE DIVIDE SUBROUTINE DOES NOT
  224. EXACTLY RIVAL SUPERCOMPUTER SPEEDS, BUT IT DOES GET THE JOB DONE.
  225.  
  226. 6.2. ═┴├╚╔╬┼ ╠┴╬╟╒┴╟┼ ╧╨┼╥┴╘╔╧╬
  227.  
  228. ╫HILE DRAWING THE LINE, THE ╪ AND ┘ COORDINATES ARE 32-BIT SIGNED FRACTIONAL
  229. NUMBERS AS WELL AS THE "GX" AND "GY" VECTOR COMPONENTS ("GO" VALUES).  ╠INES
  230. 20 AND 30 REQUIRE QUITE A BIT OF WORK IN 6502 MACHINE LANGUAGE AND USE THE
  231. 32-BIT ADD, SUBTRACT, 2'S COMPLEMENT, AND DIVIDE OPERATIONS DESCRIBED IN THE
  232. PREVIOUS SECTION.  ╘O FIND THE ┴┬╙OLUTE VALUE OF A NUMBER, CHECK TO SEE
  233. WHETHER IT IS POSITIVE OR NEGATIVE.  ╔F IT IS POSITIVE, YOU ARE DONE.  ╔F IT
  234. IS NEGATIVE, JUST DO A 2'S COMPLEMENT ON IT (MAKES SENSE: 0 - (-X) = X).
  235.  
  236. ╠INE 40 IS DONE BY SIMPLY TAKING THE PIXEL CURSOR ╪ AND ┘ COORDINATES (WHICH
  237. ARE STORED AS UNSIGNED INTEGERS AND ARE REMEMBERED BETWEEN LINE DRAW CALLS)
  238. AND PUT THEM INTO THE HIGH WORD OF A 32-BIT FIELD AND THEN PUT $8000 (32768)
  239. INTO THE LOW WORD (WHICH GIVES ╓ + 1/2).
  240.  
  241. ╠INE 50 IS EASILY IMPLEMENTED AS A LOOP THAT DECREMENTS THE "R" WORD UNTIL IT
  242. REACHES ZERO, WHILE CALLING THE POINT PLOT ROUTINE AND DOING THE 32-BIT ADD TO
  243. ADD THE "G" VALUES TO THE ╪ AND ┘ COORDINATES.  ╫HEN THE LINE IS FINISHED, THE
  244. FINAL ╪ AND ┘ COORDINATES ARE PUT BACK INTO THE PIXEL CURSOR POSITION STORAGE
  245. AND THE PACKAGE IS READY FOR THE NEXT CALL.
  246.  
  247. 7. ├╧╬├╠╒╙╔╧╬
  248.  
  249. ╚A!  ╘HIS AIN'T NO FORMAL PAPER SO ╔ DON'T HAVE TO WRITE A CONCLUSION.
  250. ╙O THERE! [┼D.╬OTE - ╚E IS CURRENTLY WORKING ON HIS ═ASTERS THESIS, SO YOU'LL
  251. HAVE TO PARDON 'EM HERE.. (GRIN) ]
  252.  
  253. ================================================================================
  254. BEGIN 640 HIRES80.BIN
  255. ═`!-,`15,$1-,2!-,$!-,$!.╙8*─`├0#_╩>"┬&┬#,╙:╞'╚┴─@╙,╓╔`*(2(,╙-
  256. ═┌"#,╙:─`(,╦-╩2"┬&"#,╙:─`╚┴┌@/╥#,╙8├0^╞`@#,┌╔─╥#2_┌(9╩4=,╙,╓$
  257. ═^╚7\╞*``┴/╠*)╧╠*)╧╠89?╩0`╬;["┬;["┬;["┬;["┬;[┴?╩┼_(;]1╧╒╩1╧╒╩
  258. ═1╧╒╩&&7┌┴?╩┼_67[┴?╬┼_"─'╩╦╓>$╪7\8(!`(!`(!`(!```@5╤.┼^┌(2(,╙-
  259. ═╔?╦╚(,╙-(-├-!?╥╚╔?╬┬$┬#,╙:7┌┌"#,╙9┴,╥╠╓╔`(5─┴66%9╚5╟┴5*%4╪54
  260. ═╚┬`&8"9┴)╞(╞8╥92)┼,╞5*54╘`╩┼4╠50╔5/┼49`1.*52┘5"%4╩53┘5&%4[`"
  261. ═╤┼0╞9"9┼)╞8╞9\╦0╥&"$4*90$!`╪┴5"╔`.502(10╩0#┼4*┴╚8$┬╔`(5@┴6$@
  262. ═╙╤-╚$!─╪╩0#┼9(5─╩0#┼985┼╩0#┼9╚5╞╩0#┼9╪5╟8*4,╔`╘@&┴2%^╚3[╔1"─
  263. ═$2`:%(7\┴/╓┼_,7┌╔?╫┼^[!$╔?╩%$╚50╔?╬%$╪51╔?╥%8╩7]┴6.┼$2`╤%*(#
  264. ══625#╠╚0^:4-,`╩╔`(4-╩0&%#-`&╩?^%#84,.*─`┘1*%$╩─`┘1.%$╓"┼_(42
  265. ═┴5"┼_843┴5&┼^╚5┬╔?╬%8┌4-(#$4╚@.╒9)4*╥┴#┘3.╚4+/__+/__+/__╔1$╨
  266. ═"╩─`┴1&╔`840╘`:╔_╪41┴1!,╦┴2╨!╪6+┴╚╥$├6"%!(8%┴`┬┬!┌─`┼0╦*$/╠╪
  267. ═╔03┼┬╪4,╔07┼├(4-.*4(┘8╓%$*─`╠`*╔_╪41(%@4╔8╬%!*6,┴06╔@(4#┴0>╔
  268. ═`(4"┴0:┼├84(╩0"%":4$╔@6─"""╚$┌42!1/╨.╤┬┼`╞4*┴0*┼`╓4+┴0.┼!&4,
  269. ═┴02┼!64-┴048╔09┼#╚4&╔0=┼#╪4'╔0┴┼$(4(╔0┼┼$84)┘┴+0╬^833%05╔02╞
  270. &!:0(3`,5
  271. `
  272. END
  273. ================================================================================
  274. BEGIN 640 HIRES.DEMO
  275. ═`1╨╤'&0`┬╥#"*-$╚(├$╙,$8┬*2─@╠[$@╘2@┬0├,┬*2"╟(/╪1(─┴)4─53.#`╬
  276. ═0─┼.(@!!'&╪`╟┬#1*"(╤,╙`╙(┬─`4┴╤╪`$12╠═$╚(├$╙,#`┬*0!╙'((`╟┬!$
  277. ═4┬╨╙,├`@╦╥`╥-34╠,╙(╨╦3(╒-┬╨╤,#`╠,`"%'(╨`6+*╒*+╠╚,2╞╠-├0╨*0"7
  278. ═')8`6;*╒*+╠╚,2╞╠,├`╨*0"╥'*``╟┬!$4┬╤8(*\@,├4╒+%┬═,├4╓+%─╠,0"[
  279. ╠'*╚`╚2!!)`#-'+0`┬╥!!)+(┬(┬"╟(#$╘,`#='+╪`╟┬#1*"(╤,╙`╓(┬─```"[
  280. `
  281. END
  282. ==============================================================================
  283. ;*****************************************************************************
  284. ;*  "╚╔╥┼╙80.┬╔╬" HIRES LINE PLOTTING PACKAGE FOR THE ├OMMODORE 128 80-COL   *
  285. ;*  SCREEN.                                                                  *
  286. ;*                                                                           *
  287. ;*  ╘HIS PACKAGE CONTAINS A COUPLE OF IRREGULARITIES THAT ╔ DISCOVERED       *
  288. ;*  WHILE ╔ WAS COMMENTING IT.  ╔ LEFT THEM IN RATHER THAN START ALL OVER,   *
  289. ;*  SINCE THIS PACKAGE WAS WRITTEN WITH A MONITOR RATHER THAN AN ASSEMBLER.  *
  290. ;*****************************************************************************
  291.  
  292. ;*****************************************************************************
  293. ;*  PACKAGE ENTRY POINTS                                                     *
  294. ;*****************************************************************************
  295.  
  296. .$1300  [4C 01 15]  JMP $1501     ;JMP TO DRAW LINE/POSITION PIXEL CURSOR
  297. .$1303  [4C 11 13]  JMP $1311     ;JMP TO ENTER HIRES MODE
  298. .$1306  [4C 48 13]  JMP $1348     ;JMP TO EXIT HIRES MODE
  299. .$1309  [4C 10 13]  JMP $1310     ;RESERVED
  300. .$130C  [4C 10 13]  JMP $1310     ;RESERVED
  301. .$130F: $B3                       ;LIBRARY LOADED IDENTIFIER
  302. .$1310  [60      ]  RTS
  303.  
  304. ;*****************************************************************************
  305. ;*  ENTER HIRES MODE                                                         *
  306. ;*****************************************************************************
  307.  
  308. .$1311  [A9 00   ]  LDA #$00      ;SWITCH TO BANK 15 (KERNAL BANK)
  309. .$1313  [8D 00 FF]  STA $FF00
  310. .$1316  [A9 E0   ]  LDA #$E0      ;SET COLOR TO LIGHT GREY ON BLACK
  311. .$1318  [A2 1A   ]  LDX #$1A
  312. .$131A  [20 CC CD]  JSR $CDCC
  313. .$131D  [A9 87   ]  LDA #$87      ;ENTER BITMAP MODE (NOTE - FOR VERSION 2 ╓─├)
  314. .$131F  [A2 19   ]  LDX #$19
  315. .$1321  [20 CC CD]  JSR $CDCC
  316. .$1324  [A9 00   ]  LDA #$00      ;SET ╓─├ ╥┴═ ADDRESS HIGH
  317. .$1326  [A2 12   ]  LDX #$12
  318. .$1328  [20 CC CD]  JSR $CDCC
  319. .$132B  [E8      ]  INX           ;SET ╓─├ ╥┴═ ADDRESS LOW
  320. .$132C  [20 CC CD]  JSR $CDCC
  321. .$132F  [A9 00   ]  LDA #$00      ;SET ╓─├ ╥┴═ DATA REGISTER TO $00
  322. .$1331  [20 CA CD]  JSR $CDCA
  323. .$1334  [A9 20   ]  LDA #$20      ;SELECT BLOCK FILL MODE
  324. .$1336  [A2 18   ]  LDX #$18
  325. .$1338  [20 CC CD]  JSR $CDCC
  326. .$133B  [A9 00   ]  LDA #$00      ;FILL 256*63 ╓─├ BYTES WITH 0
  327. .$133D  [A2 1E   ]  LDX #$1E      ;  TO CLEAR THE HIRES SCREEN
  328. .$133F  [A0 3F   ]  LDY #$3F
  329. .$1341  [20 CC CD]  JSR $CDCC
  330. .$1344  [88      ]  DEY
  331. .$1345  [D0 FA   ]  BNE $1341
  332. .$1347  [60      ]  RTS
  333.  
  334. ;*****************************************************************************
  335. ;*  EXIT HIRES MODE                                                          *
  336. ;*****************************************************************************
  337.  
  338. .$1348  [20 0C CE]  JSR $CE0C     ;RELOAD THE CHARACTER SETS
  339. .$134B  [A9 93   ]  LDA #$93      ;CLEAR THE TEXT SCREEN
  340. .$134D  [20 D2 FF]  JSR $FFD2
  341. .$1350  [A2 19   ]  LDX #$19      ;RESTORE COLOR TEXT MODE
  342. .$1352  [A9 47   ]  LDA #$47
  343. .$1354  [4C CC CD]  JMP $CDCC
  344.  
  345. ;*****************************************************************************
  346. ;*CALCULATE THE BITMAP BYTE ADDRESS AND BIT VALUE FOR PIXEL GIVEN X=.┴╪,Y=.┘ *
  347. ;*****************************************************************************
  348.  
  349. .$1357  [84 FA   ]  STY $FA       ;SAVE .┴ AND .┘
  350. .$1359  [85 FC   ]  STA $FC
  351. .$135B  [98      ]  TYA           ;PUT PIXEL CURSOR Y POSITION INTO .┴
  352. .$135C  [A0 00   ]  LDY #$00      ;CLEAR PIXEL CURSOR Y POSITION HIGH BYTE
  353. .$135E  [84 FB   ]  STY $FB
  354. .$1360  [0A      ]  ASL A         ;MULTIPLY PIXEL CURSOR Y BY 2 GIVING Y*2
  355. .$1361  [26 FB   ]  ROL $FB       ;  AND WE MUST SHIFT THE HIGH BYTE TO
  356. .$1363  [0A      ]  ASL A         ;AGAIN, GIVING Y*4
  357. .$1364  [26 FB   ]  ROL $FB
  358. .$1366  [18      ]  CLC           ;ADD THE ORIGINAL Y, GIVING Y*5
  359. .$1367  [65 FA   ]  ADC $FA
  360. .$1369  [90 02   ]  BCC $136D
  361. .$136B  [E6 FB   ]  INC $FB
  362. .$136D  [0A      ]  ASL A         ;MULTIPLY BY 2 AGAIN, GIVING Y*10
  363. .$136E  [26 FB   ]  ROL $FB
  364. .$1370  [0A      ]  ASL A         ;AGAIN, GIVING Y*20
  365. .$1371  [26 FB   ]  ROL $FB
  366. .$1373  [0A      ]  ASL A         ;AGAIN, GIVING Y*40
  367. .$1374  [26 FB   ]  ROL $FB
  368. .$1376  [0A      ]  ASL A         ;AGAIN, GIVING Y*80: HA!  WE ARE DONE
  369. .$1377  [26 FB   ]  ROL $FB
  370. .$1379  [85 FA   ]  STA $FA       ;SAVE LOW BYTE OF Y*80
  371. .$137B  [A5 FC   ]  LDA $FC       ;RESTORE X COORDINATE LOW BYTE
  372. .$137D  [86 FD   ]  STX $FD       ;SET UP X COORDINATE HIGH BYTE
  373. .$137F  [46 FD   ]  LSR $FD       ;DIVIDE THE X COORDINATE BY 2 GIVING X/2
  374. .$1381  [6A      ]  ROR A         ;  WE MUST ROR THE HIGH BYTE, THEN THE LOW
  375. .$1382  [46 FD   ]  LSR $FD       ;AGAIN, GIVING X/4
  376. .$1384  [6A      ]  ROR A
  377. .$1385  [46 FD   ]  LSR $FD       ;AGAIN, GIVING X/8: DONE
  378. .$1387  [6A      ]  ROR A
  379. .$1388  [18      ]  CLC           ;NOW ADD Y*80 AND X/8
  380. .$1389  [65 FA   ]  ADC $FA
  381. .$138B  [85 FA   ]  STA $FA
  382. .$138D  [A5 FD   ]  LDA $FD
  383. .$138F  [65 FB   ]  ADC $FB
  384. .$1391  [85 FB   ]  STA $FB       ;GIVING US THE PIXEL BYTE ADDRESS IN ($FA)
  385. .$1393  [A5 FC   ]  LDA $FC       ;GET X MOD 8
  386. .$1395  [29 07   ]  AND #$07      ;  HA! WE CAN JUST EXTRACT THE LOW THREE BITS
  387. .$1397  [AA      ]  TAX
  388. .$1398  [BD 9E 13]  LDA $139E,X   ;LOOK UP THE BIT VALUE IN THE TABLE
  389. .$139B  [85 FC   ]  STA $FC       ;  AND SAVE IT AT $FC
  390. .$139D  [60      ]  RTS           ;EXIT WITH ADDRESS IN ($FA) AND VALUE IN $FC
  391.  
  392. ;*****************************************************************************
  393. ;*  BIT VALUE TABLE                                                          *
  394. ;*****************************************************************************
  395.  
  396. .$139E: $80  $40  $20  $10        ;BIT VALUES STORED LEFT TO RIGHT
  397. .$13A2: $08  $04  $02  $01
  398.  
  399. .$13A6  [00      ]  BRK                  ;FILLER - ╔ FORGET WHY ╔ PUT IT HERE
  400. .$13A7  [00      ]  BRK
  401.  
  402. ;*****************************************************************************
  403. ;*  PLOT PIXEL AT X=.┴╪, Y=.┘ ON BITMAP SCREEN                               *
  404. ;*****************************************************************************
  405.  
  406. .$13A8  [20 57 13]  JSR $1357     ;CALCULATE THE PIXEL ADDRESS AND VALUE
  407. .$13AB  [A5 FB   ]  LDA $FB       ;SET ╓─├ ╥┴╬ ADDRESS HIGH TO PIXEL ADDRESS
  408. .$13AD  [A2 12   ]  LDX #$12
  409. .$13AF  [20 CC CD]  JSR $CDCC
  410. .$13B2  [A5 FA   ]  LDA $FA       ;SET ╓─├ ╥┴═ ADDRESS LOW TO PIXEL ADDRESS
  411. .$13B4  [E8      ]  INX
  412. .$13B5  [20 CC CD]  JSR $CDCC
  413. .$13B8  [20 D8 CD]  JSR $CDD8     ;PEEK THE ╓─├ ╥┴═ ADDRESS
  414. .$13BB  [05 FC   ]  ORA $FC       ;╧╥ ON THE NEW PIXEL VALUE
  415. .$13BD  [A8      ]  TAY           ;  AND SAVE THE RESULT (BYTE TO POKE BACK)
  416. .$13BE  [A5 FB   ]  LDA $FB       ;RESET THE ╓─├ ╥┴═ ADDRESS TO THE PIXEL
  417. .$13C0  [A2 12   ]  LDX #$12      ;  ADDRESS; THIS IS NECESSARY SINCE THE
  418. .$13C2  [20 CC CD]  JSR $CDCC     ;  ╓─├ WILL INCREMENT ITS ╥┴═ ADDRESS ON
  419. .$13C5  [A5 FA   ]  LDA $FA       ;  EVERY ACCESS
  420. .$13C7  [E8      ]  INX
  421. .$13C8  [20 CC CD]  JSR $CDCC
  422. .$13CB  [98      ]  TYA
  423. .$13CC  [4C CA CD]  JMP $CDCA     ;AND POKE THE NEW PIXEL BYTE VALUE
  424.  
  425. ;*****************************************************************************
  426. ;*  PERFORM THE UNSIGNED 32-BIT DIVIDE WITH 16-BIT DENOMINATOR (BOTTOM)      *
  427. ;*    [$63 $62 $61 $60] IS THE NUMERATOR (TOP)                               *
  428. ;*            [$51 $50] IS THE DENOMINATOR (BOTTOM)                          *
  429. ;*    [$67 $66 $65 $64] IS THE QUOTIENT (RESULT)                             *
  430. ;*        [$54 $53 $52] IS THE REMAINDER                                     *
  431. ;*****************************************************************************
  432.  
  433. .$13CF  [A9 00   ]  LDA #$00      ;SET THE RESULT TO 0
  434. .$13D1  [85 64   ]  STA $64
  435. .$13D3  [85 65   ]  STA $65
  436. .$13D5  [85 66   ]  STA $66
  437. .$13D7  [85 67   ]  STA $67
  438.  
  439. .$13D9  [85 52   ]  STA $52       ;CLEAR THE REMAINDER
  440. .$13DB  [85 53   ]  STA $53
  441. .$13DD  [85 54   ]  STA $54
  442.  
  443. .$13DF  [A2 20   ]  LDX #$20      ;SET THE LOOP COUNT TO 32 BITS
  444. .$13E1  [06 60   ]  ASL $60       ;SHIFT OUT THE HIGH BIT OF THE NUMERATOR
  445. .$13E3  [26 61   ]  ROL $61
  446. .$13E5  [26 62   ]  ROL $62
  447. .$13E7  [26 63   ]  ROL $63
  448. .$13E9  [26 52   ]  ROL $52       ;SHIFT IT INTO THE REMAINDER
  449. .$13EB  [26 53   ]  ROL $53
  450. .$13ED  [26 54   ]  ROL $54
  451. .$13EF  [A5 54   ]  LDA $54       ;CHECK IF THE REMAINDER IS >= THE DENOMINATOR
  452. .$13F1  [D0 0A   ]  BNE $13FD
  453. .$13F3  [A5 52   ]  LDA $52
  454. .$13F5  [C5 50   ]  CMP $50
  455. .$13F7  [A5 53   ]  LDA $53
  456. .$13F9  [E5 51   ]  SBC $51
  457. .$13FB  [90 11   ]  BCC $140E     ;IF NOT, GO TO NEXT BIT
  458. .$13FD  [38      ]  SEC           ;SUBRACT THE DENOMINATOR FROM THE REMAINDER
  459. .$13FE  [A5 52   ]  LDA $52
  460. .$1400  [E5 50   ]  SBC $50
  461. .$1402  [85 52   ]  STA $52
  462. .$1404  [A5 53   ]  LDA $53
  463. .$1406  [E5 51   ]  SBC $51
  464. .$1408  [85 53   ]  STA $53
  465. .$140A  [B0 02   ]  BCS $140E
  466. .$140C  [C6 54   ]  DEC $54
  467. .$140E  [26 64   ]  ROL $64       ;SHIFT A "1" BIT INTO THE DENOMINATOR.  ╬OTE
  468. .$1410  [26 65   ]  ROL $65       ;  THE FIRST "ROL" SHOULD HAVE BEEN PRECEEDED
  469. .$1412  [26 66   ]  ROL $66       ;  BY A "SEC"; THIS IS A ┬╒╟!  ╚OWEVER, IT
  470. .$1414  [26 67   ]  ROL $67       ;  WILL FAIL ONLY IF DENOM >=32768 WHICH
  471.                                   ;  CANNOT HAPPEN IN THIS APPLICATION.
  472. .$1416  [CA      ]  DEX           ;GO ON TO THE NEXT BIT
  473. .$1417  [D0 C8   ]  BNE $13E1
  474. .$1419  [60      ]  RTS
  475.  
  476. ;*****************************************************************************
  477. ;*  GET THE ABSOLUTE VALUE OF THE 2'S COMP NUMBER IN .┴┘ -> .┴┘              *
  478. ;*****************************************************************************
  479.  
  480. .$141A  [84 50   ]  STY $50
  481. .$141C  [A6 50   ]  LDX $50
  482. .$141E  [10 10   ]  BPL $1430     ;IF THE NUMBER IS POSITIVE, EXIT
  483. .$1420  [38      ]  SEC           ;ELSE TAKE THE 2'S COMPLEMENT OF THE NEGATIVE
  484. .$1421  [85 50   ]  STA $50       ;  VALUE TO GET THE POSITIVE VALUE
  485. .$1423  [A9 00   ]  LDA #$00
  486. .$1425  [E5 50   ]  SBC $50
  487. .$1427  [48      ]  PHA
  488. .$1428  [84 50   ]  STY $50
  489. .$142A  [A9 00   ]  LDA #$00
  490. .$142C  [E5 50   ]  SBC $50
  491. .$142E  [A8      ]  TAY
  492. .$142F  [68      ]  PLA
  493. .$1430  [60      ]  RTS
  494.  
  495. ;*****************************************************************************
  496. ;*  PERFORM THE FRACTIONAL SIGNED 32-BIT DIVIDE                              *
  497. ;*****************************************************************************
  498.  
  499. .$1431  [48      ]  PHA           ;REMEMBER THE SIGN OF THE RESULT
  500.  
  501.