;
;   PROJECT: ppt
;   MODULE : render2.a
;
;   $Id: render2.a,v 1.7 1997-10-06 21:49:50 jj Exp $
;
;   Support functions for renderer. Mainly to fasten things up a bit ;)
;
;

        XDEF    @RGBDistance
        XDEF    @BestMatchPen4
        XDEF    @BestMatchPen8
        XDEF    @Plane2Chunk
        XDEF    @QuickMapRow
        XDEF    _BestMatchPen8
        XDEF    _Plane2Chunk
        XDEF    _QuickMapRow
        XDEF    @QuickMapARGBDeepRow
        XDEF    _QuickMapARGBDeepRow

;
; INPUTS: d0.h = r1, d0.l = g1,
;         d1.h = b1, d1.l = g2,
;         d2.h = r2, d2.l = b2.
;
; OUTPUTS: D0  = distance^2
; TRASHED: D1,D2
;
; This function returns the square of the distance of two rgb vectors
; (r1,g1,b1) and (r2,g2,b2)
;
; This code is rather time-critical, so that is why it is written in assembler.

        section code,code

@RGBDistance:
        move.l  D7,-(A7)        ; our scratch register

;   First calculate green.

        sub.w   D1,D0
        move.w  D0,D7
        muls.w  D7,D7           ; D7 = (g1-g2)^2

;   Then blue

        swap    D1
        sub.w   D2,D1
        muls.w  D1,D1           ; D1 = (b1-b2)^2
        add.l   D1,D7

;   And finally red.

        swap    D0
        swap    D2
        sub.w   D0,D2
        muls.w  D2,D2           ; D2 = (r1-r2)^2
        add.l   D2,D7


        move.l  D7,D0
        move.l (A7)+,D7
        rts


;
; BestMatchPen8() calculates the closest pen for 8bit color values.
;
; Input : A0    = pointer to colortable (ARGBPixel_T *)
;         D4.w  = ncolors
;         D0.b  = r
;         D1.b  = g
;         D2.b  = b
;
; Output:
;         D0    = pen number
;
; used: D6 holds offset
;       D7 holds minimum
;       D3 is trash (holds mask value);
;       D5 is counter

_BestMatchPen8:
@BestMatchPen8:

        movem.l  D2-D7,-(A7)
        move.w  #$00FF,D3       ; mask

; adjust registers for RGBDistance

        and.w   D3,D0           ; D0 = ????00RR
        swap    D0              ; D0 = 00RR????
        move.w  D1,D0           ; D0 = ??RR??GG
        and.w   D3,D0           ; D0 = 00RR00GG
        move.w  D2,D1           ; D1 = ??????BB
        and.w   D3,D1           ; D1 = ????00BB
        swap    D1              ; D1 = 00BB????

        moveq.l #-1,D7          ; D7 holds minimum value, D7 = 0xFFFFFFFF
        moveq.l #0,D5           ; D5 is counter

; Fetch the color values from the colortable
; We'll have to set D2.h to R, D1.l to G and D2.l to B

__bmp8_loop:
        add.l  #1,A0            ; Skip alpha

; Get red
        move.b  (A0)+,D2        ; D2 = ??????rr
        and.w  D3,D2            ; D2 = ????00rr
        swap    D2              ; D2 = 00rr????

; Get green
        move.b  (A0)+,D1        ; D1 = 00BB??gg
        and.w  D3,D1            ; D1 = 00BB00gg

; Get blue
        move.b  (A0)+,D2        ; D2 = 00rr??bb
        and.w  D3,D2            ; D2 = 00rr00bb


; Color registers are done, so calculate the distance!

        movem.l D0-D1,-(A7)
        bsr.w   @RGBDistance    ; D0 = distance
        tst.l   D0              ; if D0 = 0, a perfect match was found
        beq.w   __bmp8_quickend ; thus, skip to end
        cmp.l   D7,D0           ; res = D0-D7. if res < 0 ts D0-D7 < 0 <=> D0<D7
        bcc.w   __bmp8_skip
            move.l D0,D7
            move.w D5,D6
__bmp8_skip
        movem.l (A7)+,D0-D1
        addq.w  #1,D5
        cmp.w   D4,D5
        bne.w   __bmp8_loop

        move.w  D6,D0

        movem.l (A7)+,D2-D7

        rts

__bmp8_quickend
        movem.l (A7)+,D0-D1
        move.w  D5,D0
        movem.l (A7)+,D2-D7
        rts


;
; BestMatchPen4() calculates the closest pen for 4bit color tables (LoadRGB4())
;
; Input : A0    = pointer to colortable (UWORD *)
;         D4.w  = ncolors
;         D0.b  = r
;         D1.b  = g
;         D2.b  = b
;
; Output:
;         D0    = pen number
;
; used: D6 holds offset
;       D7 holds minimum
;       D3 is trash
;       D5 is counter

@BestMatchPen4:

        movem.l  D3-D7,-(A7)

; adjust registers for RGBDistance

        swap    D0              ; D0 = ??RR????
        move.w  D1,D0           ; D0 = ??RR??GG
        andi.l  #$00FF00FF,D0   ; D0 = 00RR00GG OK
        move.w  D2,D1           ; D1 = ??????BB
        andi.w  #$00FF,D1       ; D1 = ????00BB
        swap    D1              ; D1 = 00BB????

        moveq.l #-1,D7          ; D7 holds minimum value, D7 = 0xFFFFFFFF
        moveq.l #0,D5           ; D5 is counter

__bmp4_loop:
        move.w  (A0)+,D2        ; D2 = ????0rgb First color
        move.w  D2,D3           ; D3 = ????0rgb
        andi.w  #$00F0,D3       ; D3 = ????00g0
        move.w  D3,D1           ; D1 = 00BB00g0
        lsr.b   #4,D3           ; D3 = ????000g
        or.b    D3,D1           ; D1 = 00BB00gg OK

        move.w  D2,D3           ; D3 = ????0rgb
        andi.w  #$0F00,D3       ; D3 = ????0r00
        lsr.w   #4,D3           ; D3 = ????00r0
        swap    D2              ; D2 = 0rgb????
        move.w  D3,D2           ; D2 = 0rgb00r0
        lsr.w   #4,D3           ; D3 = ????000r
        or.b    D3,D2           ; D2 = 0rgb00rr

; and finally blue

        swap    D2              ; D2 = 00rr0rgb
        andi.w  #$000F,D2       ; D2 = 00rr000b
        move.b  D2,D3           ; D3 = ????000b
        lsl.b   #4,D2           ; D2 = 00rr00b0
        or.b    D3,D2           ; D2 = 00rr00bb

; Color registers are done, so calculate the distance!

        movem.l D0-D1,-(A7)
        bsr.w   @RGBDistance    ; D0 = distance
        cmp.l   D7,D0           ; res = D0-D7. if res < 0 ts D0-D7 < 0 <=> D0<D7
        bcc.w   __bmp4_skip
            move.l D0,D7
            move.w D5,D6
__bmp4_skip
        movem.l (A7)+,D0-D1
        addq.w  #1,D5
        cmp.w   D4,D5
        bne.w   __bmp4_loop

        move.w  D6,D0

        movem.l (A7)+,D3-D7

        rts

;
; This routine makes the mapping fast
;
; Enter:
;    D0 = windowwidth
;    D1 = srcwidth
;    D2 = components (IGNORED!)
;    A0 = map to RGB data
;    A1 = map to quickrender row

; Used:
;    D7 = column counter, increased by D1 each step
;    D6 = calculations
;    D4 = scratch
;    D5 = scratch
;    D3 = scratch

;   There's an interesting speedup possibility here:
;   If I use the QuickColorRemapTable and ditch the divu #$3, D5,
;   I get test rendering times of about 3.41 seconds. If I don't,
;   I get somewhere around 3.62 seconds. So the divu call is not
;   really important. This might change on a 68040, since it's data
;   caches are larger.

        XDEF @QuickMapRow
        XREF _QuickRemapTable
;;        XREF _QuickColorRemapTable

_QuickMapRow:
@QuickMapRow:
        movem.l D2-D7/A2-A6,-(A7)

        moveq   #0,D7       ; D7 = column counter
        moveq   #0,D4
        lea     _QuickRemapTable,A2
;;        lea _QuickColorRemapTable,A2
        ext.l   D1          ; make sure we are 32 bit
        move.l  D1,D2
        mulu.w  D0,D2        ; D2 = windowwidth * srcwidth
maploop:

; Calculate pixel location

        move.l  D7,D6       ; D7 holds col*srcwidth
        divu.w  D0,D6       ; D6 = col * srcwidth / winwidth
        ext.l   D6          ; trash remainder
        move.l  D6,D3
        add.l   D6,D6
        add.l   D3,D6       ; D6 = 3*D6

; Calculate pixel value

        moveq   #0,D5       ; D5 is intensity
        move.b  0(A0,D6),D4
        add.w   D4,D5
        move.b  1(A0,D6),D4
        add.w   D4,D5
        move.b  2(A0,D6),D4
        add.w   D4,D5       ; D5 = r+g+b

        divu.w  #$3,D5      ; D5 = intensity

; Write to memory.

        move.b  0(A2,D5.W),(A1)+

; Check if we've done all columns in this row

        add.l   D1,D7       ; Add sourcewidth
        cmp.l   D7,D2
        bne     maploop

; exit
        movem.l (A7)+,D2-D7/A2-A6
        rts

;-------------------------------------------------------------------------
;
;  Same as above, but for CGX
;
;    D0.w = windowwidth
;    D1.w = srcwidth
;    D2.b = high alpha intensity
;    D3.b = low alpha intensity
;    D4.w = row
;    A0 = map to RGB data
;    A1 = map to quickrender row (pixelrow)
;
;  Could really use some more optimization.
;    D2 is still free.

_QuickMapARGBDeepRow:
@QuickMapARGBDeepRow:
        movem.l D2-D7/A2-A6,-(A7)

        move.l  D2,A2       ; White
        move.l  D3,A3       ; Black

        moveq   #0,D7       ; D7 = column counter

; Black or white?
        lsr.w   #3,D4
        move.l  D4,A6       ; A6 = row/8

deepmaploop:
; Black or white, again:
        move.l  D7,D6
        lsr.w   #3,D6
        move.l  A6,D3
        eor.w   D6,D3       ; even, if black; odd, if white
        btst    #0,D3
        bne     deep_white

        move.l  A2,A4
        bra     deep_pixel
deep_white:
        move.l  A3,A4       ; A4 = background pixel value.

; Calculate pixel location

deep_pixel:
        move.l  D7,D6
        mulu.w  D1,D6       ; col*srcwidth
        divu.w  D0,D6       ; D6 = col * scrwidth/winwidth
        ext.l   D6          ; no remainder
        lsl.l   #2,D6       ; x4

; Calculate pixel RGB value

        move.l  0(A0,D6),D4 ; ARGB pixel
        move.l  D4,D5
        move.l  D4,A5       ; A5 = original pixel data
        moveq   #24,D3
        lsr.l   D3,D5       ; D5 = alpha
        move.l  D5,D4
        move.w  #255,D6
        sub.w   D4,D6       ; D6 = 255-alpha

; Pre-calculate the background value to be mixed (a * t)
        move.l  A4,D3
        mulu.w  D3,D5       ; D5 = t * alpha

; Red
        move.l  A5,D4
        moveq   #16,D3
        lsr.l   D3,D4
        and.l   #$FF,D4
        mulu.w  D6,D4
        add.w   D5,D4
        lsr.w   #8,D4       ; /256
        move.b  D4,(A1)+
; Green
        move.l  A5,D4
        lsr.l   #8,D4
        and.l   #$FF,D4
        mulu.w  D6,D4
        add.w   D5,D4
        lsr.w   #8,D4       ; /256
        move.b  D4,(A1)+
; Blue
        move.l  A5,D4
        and.l   #$FF,D4
        mulu.w  D6,D4
        add.w   D5,D4
        lsr.w   #8,D4       ; /256
        move.b  D4,(A1)+

; End loop
        addq    #1,D7
        cmp.l   D7,D0       ; < winwidth?
        bne     deepmaploop

; exit
        movem.l (A7)+,D2-D7/A2-A6
        rts


;-------------------------------------------------------------------------
;
;  Functions to convert from bitplane format to chunky format
;
;  Stolen from IFX devkit


;-------------------------------------------------------------------------
;
;  Plane2Chunk(UBYTE **planes, UBYTE *output, int width, WORD depth )
;              a0              a1             d0         d1
;
;  Generic bitplane-to-chunky converter.  There must be 8 elements
;  in the planes array, and they will be modified by this function.
;  Output is where to store chunky data, width is the number of
;  pixels to convert, and depth is the number of bitplanes.
;
;  Assumes starting at leftmost edge of plane pointers.

_Plane2Chunk:
@Plane2Chunk:
                movem.l d2/d3-d6/a2-a4,-(sp)

                moveq   #0,d3
                move.w  d1,d3
                subq    #1,d3
                lsr.l   #3,d3                   ;
                addq    #1,d3                   ; d3 = ((depth-1)/8) +1

                cmp.w   #8,d1                   ; Limit depth to a max of 8
                bls.s   L8
                moveq   #8,d1

L8              moveq   #7,d6                   ; Init Bit offset.
                bra.s   L7

                ; Column loop.
L1              moveq   #0,d2                   ; Init color to zero.
                moveq   #1,d4                   ; Init color mask.

                move.l  a0,a3                   ; Point to planes.
                move.w  d1,d5                   ; Init plane counter.
                bra.s   L4

                ; Plane loop.
L2              move.l  (a3)+,a4                ; Get plane pointer.
                btst.b  d6,(a4)                 ; Color plane set?
                beq.s   L3                      ; Nope - skip it.
                add.w   d4,d2                   ; Yes - add in color mask.
L3              add.w   d4,d4                   ; Increment color mask.
L4              dbf     d5,L2

                ; Bump to next column.
                subq.w  #1,d6                   ; Next bit over.
                bpl.s   L5
                moveq   #7,d6                   ; Byte change...
                move.l  a0,a3
                move.w  d1,d5
                bra.s   L42
L41             addq.l  #1,(a3)+
L42             dbf     d5,L41

L5              move.b  d2,(a1)                 ; into chunky buffer we go
                add.l   d3,a1                   ; Add the skip amount

L7              dbf     d0,L1

                movem.l (sp)+,d2/d3-d6/a2-a4
                rts


        END