home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 1 / GoldFishApril1994_CD1.img / d1xx / d170 / fasttext / fasttext.asm < prev    next >
Encoding:
Assembly Source File  |  1988-11-22  |  17.6 KB  |  525 lines
  1. *
  2. * Fast font Assembly sub-routines
  3. * 
  4. * Copyright 1988 by Darren M. Greenwald
  5. *
  6. * Rev. 3.0 9/27/88
  7. *
  8. * New blitter based routine to handle any size font
  9. *
  10. * This new routine relies on the brute force approach, and the blitter!
  11. * The font data is unpacked, and the masking, shifting, and target
  12. * addresses are pre-calculate for speed.
  13. *
  14. * This version of the fast text routines can render fonts of any height,
  15. * and of any size from 4-16 pixels wide.  Wider fonts, proportional fonts,
  16. * and styles are currently not supported.
  17. *
  18. * This routine is copyrighted, and freely distributable.  It may not be
  19. * used in any commercial product, shareware product, or commercial
  20. * publication  without permission.  It is permissible to release this file
  21. * as part of a public domain collection, or on a telecommunication service
  22. * as long as no "special charge" is made for this program;
  23. * "special charge" does not include standard charges for replication
  24. * of the media, or use of the system.
  25. *
  26. * The intent of the above should be clear - I did the work, and am giving
  27. * the code away for free.  While you may use it, you may not
  28. * profit from it.
  29. *
  30. * The previous fast text routines I released in 1987 were public domain
  31. * in every sense of the word.  In order to use these routines in a
  32. * commercial, or shareware venture, you must ask permission - at the most
  33. * I may ask in return that you include credit for the use of these
  34. * routines within your program's documentation, and/or free registration, or
  35. * a copy of the software you are developing.  In addition, I will provide
  36. * answers if you have any questions, and just maybe provide assistance
  37. * with modifying the routines to suit your needs.  All I ask is that you
  38. * ask!
  39. *
  40.  
  41.             XDEF     _InitFastText   ;Declare these labels visible to linker
  42.             XDEF     _FreeFastText
  43.             XDEF     _FastText
  44.  
  45.             XREF     _GfxBase
  46.             XREF     _LVOAllocMem
  47.             XREF     _LVOFreeMem
  48.             XREF     _LVOBltTemplate
  49.             XREF     _LVOText
  50.             XREF     _OwnBlitter
  51.             XREF     _DisownBlitter
  52.             XREF     _WaitBlit
  53.  
  54.             include  "SYS2:asm/exec/types.i"
  55.             include  "SYS2:asm/graphics/text.i"
  56.             include  "SYS2:asm/hardware/blit.i"
  57.             include  "SYS2:asm/hardware/custom.i"
  58.             include  "SYS2:asm/graphics/rastport.i"
  59.             CSEG
  60.  
  61. * ---------------------------------------------------------------------
  62. * Call this routine to free any memory allocated by InitFastText() 
  63. * below.
  64. * 
  65. * This is a safe routine - it can be called safely even if InitFastText()
  66. * fails.
  67. * ---------------------------------------------------------------------
  68. _FreeFastText:
  69.  
  70.             MOVE.L   FontData,D0       ;safety check for NULL ptr
  71.             BEQ      nodata
  72.             MOVEA.L  D0,A1             ;address of buffer to free
  73.             MOVE.L   FontSize,D0       ;size of buffer to free
  74.             MOVEA.L  $4,A6             ;ExecBase
  75.             JSR      _LVOFreeMem(A6)
  76.             CLR.L    FontData          ;set to NULL
  77.  
  78. nodata:
  79.  
  80.             MOVE.L   Imagebuf,D0
  81.             BEQ      nobuf             ;safety valve
  82.             MOVEA.L  D0,A1             ;address of buffer
  83.             MOVE.L   Imagesize,D0      ;size of working buffer
  84.             MOVEA.L  $4,A6
  85.             JSR      _LVOFreeMem(A6)
  86.             CLR.L    Imagebuf          ;set to NULL
  87.  
  88. nobuf:      RTS
  89.  
  90. * ---------------------------------------------------------------------
  91. * This routine does a few things for you.
  92. *
  93. * It checks to make sure the font size is within 4 bits wide, and 16
  94. * bits wide.  It also checks for PROP fonts.  Wider/thinner fonts, and
  95. * PROP fonts will cause this routine to fall through, and set up to
  96. * use Text() instead of the fast text routines.  This is transparent, so
  97. * you do not have to write additional code to handle anything if
  98. * the FastText() routine cannot be used.
  99. *
  100. * It allocates 2 chip ram buffers - one for the unpacked font data,
  101. * and the other for an image buffer to draw in.  The amount of space
  102. * required is calculated for you based on the font size per the pointer
  103. * to a TextFont structure which is passed via the stack.
  104. *
  105. * The font data is unpacked into words using an edge-to-edge model.
  106. * Extraneous bits are masked out, and the image data is left justified.
  107. *
  108. * The blitter masks, shifts, and destination addresses are pre-calcuated
  109. * for speed during rendering.
  110. *
  111. * An indirect function pointer is set-up based on the font width.  8 bit
  112. * wide fonts can be rendered faster then other fonts, so a special
  113. * blitter routine is devoted to handling 8 bit wide fonts.  Often this is
  114. * the most common font, so it makes sense to use this capability.
  115. *
  116. * ---------------------------------------------------------------------
  117.  
  118. font        EQU      04       ;stack offset
  119.  
  120. _InitFastText:
  121.  
  122.             MOVEA.L  font(SP),A2       ;address of a text font struct
  123.  
  124.             TST.L    tf_CharSpace(A2)  ;is this a prop font?
  125.             BNE      Initfailed
  126.  
  127.             CLR.L    D0
  128.  
  129.             MOVE.W   tf_XSize(A2),D0
  130.             MOVE.L   D0,XSize          ;save
  131.             CMP.W    #16,D0            ;check bounds of this
  132.             BHI      Initfailed
  133.  
  134.             MOVE.W   tf_YSize(A2),D0
  135.             MOVE.L   D0,YSize          ;save
  136.             CMP.W    #4,D0             ;check bounds of this
  137.             BLT      Initfailed
  138.  
  139.             MOVE.W   tf_Baseline(A2),Baseline
  140.  
  141. * allocate space for font imagery in unpacked word format - egads, this
  142. * uses a lot of memory, buts its the price to be paid I guess?
  143. *
  144.  
  145.             CLR.L    FontData          ;NULL by default
  146.             CLR.L    Imagebuf
  147.  
  148.             MULU     #512,D0           ;1 WORD per line * 256 chars
  149.             MOVE.L   D0,FontSize       ;save size of buffer
  150.             MOVE.L   #$10003,D1        ;MEMF_PUBLIC|MEMF_CHIP|MEMF_CLEAR
  151.             MOVEA.L  $4,A6
  152.             JSR      _LVOAllocMem(A6)  ;allocate space
  153.             TST.L    D0
  154.             BEQ      Initfailed        ;no memory for font data
  155.             MOVE.L   D0,FontData       ;save pointer
  156.  
  157. * allocate an image buffer for me to draw text in
  158.  
  159.             MOVE.L   YSize,D0
  160.             MULU     #128,D0           ;size of buffer calculated
  161.             MOVE.L   D0,Imagesize      ;save size
  162.             MOVEQ    #03,D1            ;MEMF_PUBLIC|MEMF_CHIP
  163.             MOVEA.L  $4,A6
  164.             JSR      _LVOAllocMem(A6)  ;allocate space
  165.             TST.L    D0
  166.             BEQ      NoImagebuf        ;no memory for font data
  167.             MOVE.L   D0,Imagebuf       ;save pointer
  168.  
  169. * unpack font data
  170.  
  171.             MOVEA.L  tf_CharLoc(A2),A0 ;location of offsets|width
  172.             MOVEA.L  tf_CharData(A2),A1
  173.             MOVEA.L  FontData,A3       ;where to put unpacked imagery
  174.  
  175.             CLR.L    D0
  176.             MOVE.B   tf_LoChar(A2),D0
  177.  
  178.             CLR.L    D1
  179.             MOVE.B   tf_HiChar(A2),D1
  180.  
  181.             SUB.B    D0,D1             ;total # of chars to unpack
  182.  
  183.             LSL.L    #1,D0             ;BYTE to WORD offset
  184.             ADDA.L   D0,A3             ;adjust pntr into image array now
  185.  
  186. dounpack:   MOVE.L   (A0)+,D0          ;fetch offset|width of each char
  187.  
  188.             CLR.L    D2
  189.             MOVE.W   D0,D2             ;width in D2
  190.  
  191.             SWAP     D0                ;pix offset in D0
  192.             CLR.L    D3
  193.             MOVE.W   D0,D3             ;word offset in D3
  194.  
  195.             AND.L    #$000F,D0
  196.             LSR.W    #4,D3             ;calc word offset
  197.             LSL.W    #1,D3
  198.  
  199.             CLR.L    D4                ;create mask
  200.             NOT.L    D4                ;all ones!
  201.             LSR.L    D2,D4             ;mask for this character
  202.             NOT.L    D4                ;invert mask
  203.  
  204.             MOVE.L   YSize,D5
  205.             SUBQ.W   #1,D5             ;-1 for DBF loop
  206.             CLR.L    D6
  207.  
  208. unpkfont:   MOVE.L   0(A1,D3.W),D7     ;create in D7
  209.  
  210.             LSL.L    D0,D7             ;left justify?
  211.             AND.L    D4,D7             ;mask lower bits
  212.             SWAP     D7                ;move to lower word
  213.             
  214.             MOVE.W   D7,0(A3,D6.L)     ;store
  215.  
  216.             ADD.W    tf_Modulo(A2),D3  ;adjust word offset
  217.             ADD.L    #512,D6
  218.  
  219.             DBF      D5,unpkfont
  220.  
  221.             ADDQ.L   #2,A3
  222.  
  223.             DBF      D1,dounpack
  224.  
  225. * set up arrays of pre-inited masks, shift values, and target addresses
  226.  
  227.             MOVE.W   #DEST+SRCB+SRCA+$FC,D7
  228.  
  229.             MOVE.L   XSize,D0
  230.             CMP.W    #08,D0            ;if equal to 8, use FASTEST mode!
  231.             BNE      docon0
  232.             MOVEQ    #00,D7            ;bltcon mask for bltcon1, or 0
  233.  
  234. docon0:
  235.  
  236.             MOVE.W   #255,D1           ;loop 256 times
  237.             MOVEQ    #00,D0            ;initial pixel offset
  238.  
  239.             MOVEA.L  #masks,A0
  240.             MOVEA.L  #shift,A1
  241.             MOVEA.L  #local,A2
  242.  
  243.             MOVEQ    #12,D5            ;shift value used later
  244.             MOVE.L   XSize,D6          ;used later
  245.  
  246. setup:      MOVE.L   D0,D2
  247.             MOVE.L   D2,D3
  248.  
  249.             LSR.W    #4,D2             ;calculate word offset
  250.             LSL.W    #1,D2             ; div by 16 * 2 for WORD offset
  251.  
  252.             AND.W    #$000F,D3         ;mask out all but pix offset
  253.  
  254.             MOVE.L   D2,D4
  255.             ADD.L    Imagebuf,D4       ;address to write this too
  256.             MOVE.L   D4,(A2)+          ;save address
  257.  
  258.             CLR.W    D4                ;create mask
  259.             NOT.W    D4                ;all ones!
  260.             LSR.W    D3,D4             ;mask for this character
  261.             NOT.W    D4                ;invert mask
  262.  
  263.             MOVE.W   D4,(A0)+          ;save mask
  264.  
  265.             LSL.W    D5,D3             ;shift for bltcon format
  266.             OR.W     D7,D3             ;depends of con0, or con1
  267.             MOVE.W   D3,(A1)+          ;save shift
  268.  
  269.             ADD.L    D6,D0
  270.             DBF      D1,setup
  271.  
  272. * determine maximum # of characters which can be drawn
  273.  
  274.             MOVE.L   XSize,D0
  275.             MOVE.L   #1008,D1
  276.             DIVU     D0,D1
  277.             MOVE.W   D1,Maxchars
  278.  
  279. * set-up blitter control functions based on font width
  280. * optimize for 8 bit wide fonts!
  281.  
  282.             CMP.W    #08,D0            ;if equal to 8, use FASTER mode!
  283.             BEQ      faster
  284.  
  285. slower:     MOVE.L   #Bltslow,OutPut
  286.             MOVEQ    #2,D0             ;width
  287.             BRA      setsize
  288.  
  289. faster:     MOVE.L   #Bltfast,OutPut
  290.             MOVEQ    #1,D0             ;width
  291.  
  292. setsize:    MOVE.L   YSize,D1          ;height
  293.             LSL.W    #6,D1             ;per blitter's delight
  294.             OR.W     D1,D0
  295.             MOVE.L   D0,blitsize
  296.  
  297.             RTS                        ;return TRUE
  298.  
  299.  
  300. * some error, return false
  301.  
  302. NoImagebuf: JSR      _FreeFastText     ;release alloced memory
  303.  
  304. * indicates regular system Text() may be used via these calls
  305.  
  306. Initfailed: CLR.L    OutPut            ;default to calling Text()
  307.             MOVEQ    #00,D0            ;return FALSE
  308.             RTS
  309.  
  310.  
  311. * ---------------------------------------------------------------------
  312. * Routines to render the line via the blitter!
  313. *
  314. * The blitter routines vary somewhat to optimize for speed!  8 bit wide
  315. * fonts are drawn much faster then other width fonts, but all fonts
  316. * are drawn much faster then Text()!  This makes sense to do this since
  317. * 8 bit wide fonts are the most common, and because I can make use of
  318. * some special blitter capabilities to speed the process along!
  319. * ---------------------------------------------------------------------
  320.  
  321.  
  322. rp          EQU      0004        ;stack offsets
  323. txbptr      EQU      rp+4
  324. count       EQU      txbptr+4
  325.  
  326. _FastText:  TST.L    OutPut
  327.             BEQ      CallText    ;if InitFastText() failed!
  328.  
  329.             MOVE.L   count(SP),D3
  330.             BEQ      Noway       ;why would you put a 0 for # of chars?
  331.             CMP.W    Maxchars,D3
  332.             BLS      getblitter
  333.             MOVE.W   Maxchars,D3 ;prevent overflow
  334.  
  335. * ok, I need that blitter for me only!
  336.  
  337. getblitter: SUBQ.W   #1,D3
  338.             JSR      _OwnBlitter
  339.             JSR      _WaitBlit
  340.  
  341. * set-up globals first
  342.  
  343.             MOVEA.L  txbptr(SP),A0
  344.             MOVEM.L  group,D4-D7/A1-A3
  345.  
  346. * call appropriate routine
  347.  
  348.             MOVEA.L  OutPut,A6
  349.             JSR      (A6)
  350.  
  351. * free blitter for someone else
  352.  
  353.             JSR      _DisownBlitter
  354.  
  355. * now blast this into the rastport!
  356.  
  357.             MOVEA.L  Imagebuf,A0       ;address of bitplane
  358.             MOVEQ    #00,D0            ;no offset
  359.             MOVE.L   #128,D1           ;src modulo
  360.             MOVEA.L  rp(SP),A1         ;rastport
  361.             CLR.L    D2
  362.             MOVE.W   rp_cp_x(A1),D2    ;x dest
  363.             ADD.W    D4,rp_cp_x(A1)    ;modify Move() position
  364.             CLR.L    D3
  365.             MOVE.W   rp_cp_y(A1),D3    ;dest y
  366.             SUB.W    Baseline,D3       ;- baseline of font
  367.             MOVE.L   YSize,D5          ;y size
  368.             MOVEA.L  _GfxBase,A6
  369.             JSR      _LVOBltTemplate(A6)
  370. Noway:      RTS
  371.  
  372.  
  373. * If InitFastText() failed, Text() may still be called via the
  374. * FastText() function.
  375. *
  376. * This makes use in a system which must use any size font easier to program.
  377. *
  378. CallText:   MOVEA.L  rp(SP),A1
  379.             MOVEA.L  txbptr(SP),A0
  380.             MOVE.L   count(SP),D0
  381.             MOVEA.L  _GfxBase,A6
  382.             JSR      _LVOText(A6)
  383.             RTS
  384.  
  385. * --------------------------------------------------
  386. * This is the faster logic for an 8 bit wide fonts!
  387. * --------------------------------------------------
  388. Bltfast:    MOVEA.L  #$dff000,A6       ;address of custom chips
  389.  
  390. * once set, these blitter registers dont change
  391.  
  392.             MOVE.W   #DEST+SRCB+SRCA+$FC,bltcon0(A6)
  393.             MOVE.W   #$FFFF,bltalwm(A6)   ;no last word mask
  394.             MOVE.W   #126,bltdmod(A6)
  395.             MOVE.W   #126,bltamod(A6)
  396.             MOVE.W   #510,bltbmod(A6)
  397.  
  398. * do as much set-up as possible while last blit is busy
  399.  
  400. blit8:      CLR.L    D0
  401.             MOVE.B   (A0)+,D0
  402.             BEQ      blt8done          ;terminate if NULL found
  403.  
  404.             LSL.W    #1,D0             ;cast to WORD offset
  405.             ADD.L    D5,D0             ;ready with pointer!
  406.  
  407.             ADD.L    D6,D4             ;add to width
  408.  
  409. Wait8:      BTST     #6,dmaconr(A6)    ;wait for last blit to complete
  410.             BNE      Wait8
  411.  
  412. * these blitter register change for each blit
  413.  
  414.             MOVE.L   D0,bltbpt(A6)     ;b src
  415.             MOVE.L   (A3),bltdpt(A6)   ;d src pntr
  416.             MOVE.L   (A3)+,bltapt(A6)  ;a src pntr
  417.             MOVE.W   (A1)+,bltafwm(A6) ;first word mask           
  418.             MOVE.W   (A2)+,bltcon1(A6) ;shift value for b
  419.  
  420.             MOVE.W   D7,bltsize(A6)    ;trigger blit
  421.             DBF      D3,blit8          ;char counter
  422.  
  423. blt8done:   RTS
  424.  
  425. * --------------------------------------------------
  426. * This is the slower mode for odd width fonts!
  427. * --------------------------------------------------
  428. Bltslow:    MOVEA.L  #$dff000,A6       ;address of custom chips
  429.             MOVEQ    #00,D1            ;address of destination here
  430.  
  431. * these registers dont change once set
  432.  
  433.             CLR.W    bltalwm(A6)       ;last word mask
  434.             CLR.W    bltcon1(A6)       ;no special modes
  435.             MOVE.W   #124,bltbmod(A6)  ;modulos
  436.             MOVE.W   #124,bltdmod(A6)
  437.  
  438. * this bit clears the image buffer as needed - speed optimized
  439. * thinner fonts will be drawn faster due to less hits
  440. * a hit is TRUE whenever the font imagery rolls over into the next word
  441.  
  442. doblits:    MOVE.W   (A1)+,D0
  443.             MOVE.L   (A3)+,D2
  444.             CMP.L    D2,D1
  445.             BEQ      dochars           ;working on same word
  446.  
  447. Waitlast:   BTST     #6,dmaconr(A6)    ;wait if needed
  448.             BNE      Waitlast
  449.  
  450.             MOVE.L   D2,D1             ;save for next time around
  451.  
  452.             MOVE.W   #124,bltamod(A6)
  453.             MOVE.W   D0,bltafwm(A6)
  454.             MOVE.L   D2,bltdpt(A6)     ;d src pntr
  455.             MOVE.L   D2,bltapt(A6)     ;a src pntr
  456.             MOVE.W   #DEST+SRCA+$F0,bltcon0(A6) ;d=a
  457.             MOVE.W   D7,bltsize(A6)    ;trigger blitter clear
  458.  
  459. * setup while last blit is busy
  460.  
  461. dochars:    CLR.L    D0
  462.             MOVE.B   (A0)+,D0
  463.             BEQ      bltodddone        ;terminate if NULL found
  464.  
  465.             LSL.W    #1,D0             ;cast to WORD offset
  466.             ADD.L    D5,D0             ;ready with pointer!
  467.  
  468.             ADD.L    D6,D4             ;add to width
  469.  
  470. Waitpack:   BTST     #6,dmaconr(A6)    ;wait for image packing
  471.             BNE      Waitpack
  472.  
  473. * set up blitter for character image move
  474.  
  475.             MOVE.W   #508,bltamod(A6)
  476.             MOVE.W   #$FFFF,bltafwm(A6)
  477.             MOVE.L   D0,bltapt(A6)     ;a src
  478.             MOVE.L   D2,bltbpt(A6)     ;b src pntr
  479.             MOVE.L   D2,bltdpt(A6)     ;d src pntr
  480.             MOVE.W   (A2)+,bltcon0(A6) ;shift value for a
  481.             MOVE.W   D7,bltsize(A6)    ;trigger blit
  482.  
  483.             DBF      D3,doblits        ;checks count
  484.  
  485. bltodddone: RTS
  486.  
  487.             RTS
  488.  
  489.  
  490.             DSEG
  491. * global variables I use - private!
  492.  
  493. Imagebuf:   dc.l     0     ;address of image buffer - part of above struct
  494. Imagesize:  ds.l     1     ;size of working buffer
  495.  
  496. FontSize:   ds.l     1     ;size of font data buffer
  497.  
  498. YSize:      ds.l     1     ;size of font height
  499.  
  500. Maxchars:   ds.w     1     ;Max chars which can be drawn at one time
  501.  
  502. Baseline:   ds.w     1     ;baseline of font
  503.  
  504. OutPut:     dc.l     0     ;address of function to call or NULL for Text()
  505.  
  506. masks:      ds.w     256   ;256 words for masks
  507. shift:      ds.w     256   ;256 shift values
  508. local:      ds.l     256   ;256 pointers to target location
  509.  
  510. * these are grouped for a good reason - the MOVEM instruction is used
  511. * by the rendering routines for efficiency - DONT play with the order
  512. * of these unless you know what you are doing.
  513.  
  514. group:      dc.l     0     ;0 to init width of line register
  515. FontData:   dc.l     0     ;address of font data
  516. XSize:      dc.l     0     ;size of font width
  517. blitsize:   dc.l     0     ;blit size value
  518.             dc.l     masks ;address of arrays
  519.             dc.l     shift
  520.             dc.l     local
  521.  
  522.  
  523.             END
  524.  
  525.