Apple-2-SW/antoine-source
1
0
Fork 0
mirror of https://github.com/antoinevignau/source.git synced 2025-01-04 04:31:04 +00:00
Code Issues Projects Releases Wiki Activity
14d02c2ab0
antoine-source/appleworksgs/Pict/Src/picture.aii
Antoine Vignau 5fef614692 First release
2023-03-04 03:45:20 +01:00

1 line
29 KiB
Plaintext
Executable File
Raw Blame History

LOAD 'Macros.dump'
INCLUDE 'Pict.equ'
INCLUDE 'Driver.equ'
IMPORT D_MemoryError
IMPORT D_BeachBall
IMPORT Q_BgColor
IMPORT Q_ChExtra
IMPORT Q_DhDvText
IMPORT Q_DhText
IMPORT Q_DvText
IMPORT Q_FgColor
IMPORT D_GrowHandle
IMPORT Q_LongText
IMPORT D_NeedHandle
IMPORT Q_PixRect
IMPORT Q_PixRgn
IMPORT Q_Region
IMPORT Q_SpExtra
IMPORT Q_Text
IMPORT Q_TxFace
IMPORT Q_TxFont
IMPORT Q_TxMode
IMPORT Q_TxSize
IMPORT Q_addbytes
IMPORT Q_center
IMPORT Q_gotPScomm
IMPORT Q_op
IMPORT Q_pictSCB
IMPORT Q_picterr
IMPORT Q_theBGcolor
IMPORT Q_theChExtra
IMPORT Q_theFGcolor
IMPORT Q_theMask
IMPORT Q_thePnLoc
IMPORT Q_thePnSize
IMPORT Q_theSpExtra
IMPORT Q_theTxFont
IMPORT Q_theTxLoc
IMPORT Q_theTxMode
ENTRY Q_Angles
ENTRY Q_Arc
ENTRY Q_Arcs
ENTRY Q_ChangePictSize
ENTRY Q_Comments
ENTRY Q_Copy2
ENTRY Q_Copy4
ENTRY Q_CopyPt
ENTRY Q_DhDv
ENTRY Q_FakeDhDv
ENTRY Q_JustRect
ENTRY Q_linetext
ENTRY Q_manglePt
ENTRY Q_Mask
ENTRY Q_Nop
ENTRY Q_NudgePt
ENTRY Q_OvalSize
ENTRY Pict_pattern
ENTRY Q_PenSize
ENTRY Q_Pixels
ENTRY Q_Point
ENTRY Q_Poly
ENTRY Q_Polys
ENTRY Q_Rect
ENTRY Q_Rects
ENTRY Q_Regions
ENTRY Q_ShiftPen
ENTRY Q_Undef
ENTRY Q_Lfrom
ENTRY Q_Line
ENTRY Q_Slfrom
ENTRY Q_Sline
****************************************************************
* ;
* Picture mangling routines ;
*______________________________________________________________*
* ;
* Some things should be brought to the attention of ;
* whoever tries to D_Read this piece of spaghetti code. ;
* ;
* First of all, all pictures are flipped and rotated ;
* ;as if* the picture were defined in 320-mode. The actual ;
* SCB for the D_New picture is no different from that of the ;
* old picture, but rectangles which look approximately ;
* Q_square will still look approximately Q_square when rotated. ;
* Such a rectangle will in fact be twice as wide as tall if ;
* it's defined in 640 mode, so before rotation, horizontal ;
* values are doubled and vertical values are halved. This ;
* can introduce a bit of round-off error, but it's ;
* unavoidable. ;
* ;
* A result of this mode-faking is that occasionally, ;
* a 'ShortLine' opcode will have to be translated into a ;
* 'Q_Line' opcode, or a 'SLineFrom' into 'LineFrom'. For ;
* this reason (and to place mangled Q_Text), the location of ;
* the pen is maintained throughout the source picture. ;
* ;
* Secondly, naively rotated and flipped lines will not ;
* appear to be mangled correctly, due to the somewhat ;
* inconsistent way QuickDraw handles pensizes. Thus, the ;
* pen size is also maintained, and used in Q_NudgePt. ;
* ;
* Third, there is some number-hacking in Q_Point rotation ;
* to prevent rotated pictures from creeping up and to the ;
* left. There's a comment in Q_CopyPt describing the hack. ;
* ;
* Other notes concerning the mangling of pixel maps, ;
* Q_Text, and Q_Regions can be found in their respective files. ;
* ;
* -- jge, 2/4/88 ;
* ;
****************************************************************
****************************************************************
*
* Q_ManglePict(oldpict:l,what:w) -> newpict:l -- the guts of the
* picture routines. Interprets the opcodes, distributing
* the work to other routines.
*
****************************************************************
Q_ManglePict PROC EXPORT
;Using Q_PictData
EXPORT Q_linetext
EXPORT Q_Rects
EXPORT Q_Arcs
EXPORT Q_Polys
EXPORT Q_Regions
EXPORT Q_Pixels
EXPORT Q_Comments
EXPORT Q_Nop
EXPORT Q_Copy2
EXPORT Q_Copy4
EXPORT Q_Copy6
EXPORT Q_Point
EXPORT Q_OvalSize
EXPORT Q_PenSize
EXPORT Q_Line
EXPORT Q_Lfrom
EXPORT Q_Sline
EXPORT Q_Slfrom
EXPORT Q_Rect
EXPORT Q_JustRect
EXPORT Q_FixRect
EXPORT Q_Arc
EXPORT Q_Poly
EXPORT Q_DhDv
EXPORT Q_ShiftPen
EXPORT Q_FakeDhDv
EXPORT Q_CopyPt
EXPORT Q_manglePt
EXPORT Q_NudgePt
EXPORT Q_Angles
EXPORT Pict_pattern
EXPORT Q_Mask
EXPORT Q_Undef
EXPORT Q_ChangePictSize
export oldpict
export what
export newpict
export Q_newsize
export oldptr
export newptr
export count
export thepoint
export temp
input ~~oldpict:l,~~what:w
output ~~newpict:l
local oldsize:l,~~newsize:l
local ~~oldptr:l,~~newptr:l
local oldend:l
local ~~count:w,~~thepoint:l,~~temp:l
begin +b
stz Q_picterr
*--------------------------------------------------------------*
* Lock down the old pict, allocate the D_New one, copy the ;
* header, and compute some useful information. ;
*--------------------------------------------------------------*
movelong #0,Q_theTxFont
movelong #0,Q_theSpExtra
movelong #0,Q_theChExtra
moveword #1,Q_thePnSize
moveword #1,Q_thePnSize+2
moveword #0,Q_theFGcolor
moveword #15,Q_theBGcolor
moveword #0,Q_theTxMode
movelong #$ffffffff,Q_theMask
movelong #$ffffffff,Q_theMask+4
movelong #0,Q_thePnLoc
movelong #0,Q_theTxLoc
stz Q_gotPScomm
pushlong <oldpict
_Hlock
movelong [<oldpict],<oldptr
addword [<oldptr]:#6,[<oldptr]:#2,Q_center ; get the Q_center
addword [<oldptr]:#8,[<oldptr]:#4,Q_center+2 ; of the pict.
spacelong ; get the size
pushlong <oldpict
_GetHandleSize
pulllong oldsize
addlong <oldptr,oldsize,oldend ; compute end of pict
movelong oldsize,<Q_newsize
spacelong ; allocate the D_New pict handle
pushlong <Q_newsize
pushword #$8000 ; X_Locked, while I use the pointer...
jsl D_NeedHandle
sta Q_picterr ; store the error code
pulllong <newpict
jcs accept ; (uh oh.)
movelong [<newpict],<newptr ; ...which I get here!
lda [<oldptr] ; D_Save the SCB
and #$80
sta Q_pictSCB
beq centerok ; adjust for 640 mode?
cmpw <what,#Q_rotr ; only if rotating!
blt centerok
lsr Q_center+2
centerok jsl Q_Copy2 ; copy SCB
jsl Q_JustRect ; copy frame
jsl Q_Nop ; copy version
*--------------------------------------------------------------*
* D_Read and interpret the opcodes ;
*--------------------------------------------------------------*
loop
jsl D_BeachBall
cmpl <oldptr,oldend
jeq accept
jgt myabort
moveword [<oldptr],Q_op ; get the opcode
cmpw Q_op,#$15 ; classify it.
bgt it_draws ; is it a drawing opcode?
jtl H_table1,Q_op ; if not, use the table and loop back.
jcs abort
brl loop
it_draws cmpw Q_op,#$A1 ; is it too big?
jgt myabort
lda Q_op ; get the high nybble...
lsr a
lsr a
lsr a
lsr a
dec a ; ...and skip over $0X and $1X.
dec a
jtl H_table2
jcs abort
brl loop
myabort moveword #$a501,Q_picterr ; (JE error 1)
abort pushlong <newpict
_DisposeHandle
accept lda Q_Picterr
return a
*--------------------------------------------------------------*
* The long routine table ;
*--------------------------------------------------------------*
H_table1 DC.L Q_Nop ; 00 = Q_Nop
DC.L Q_Region ; 01 = clip Q_Region
DC.L Pict_pattern ; 02 = background D_Pattern
DC.L Q_TxFont ; 03 = Q_Text font
DC.L Q_TxFace ; 04 = Q_Text face
DC.L Q_TxMode ; 05 = Q_Text mode
DC.L Q_SpExtra ; 06 = space extra
DC.L Q_PenSize ; 07 = pen size
DC.L Q_Copy4 ; 08 = pen mode
DC.L Pict_pattern ; 09 = pen D_Pattern
DC.L Pict_pattern ; 0A = fill D_Pattern
DC.L Q_OvalSize ; 0B = oval size
DC.L Q_Point ; 0C = origin
DC.L Q_TxSize ; 0D = Q_Text size
DC.L Q_FgColor ; 0E = foreground color
DC.L Q_BgColor ; 0F = background color
DC.L Q_Undef ; 10 = <undefined>
DC.L Q_Undef ; 11 = <version>
DC.L Q_ChExtra ; 12 = char extra
DC.L Q_Mask ; 13 = pen Q_Mask
DC.L Q_Copy4 ; 14 = Q_Arc rot??
DC.L Q_Copy4 ; 15 = font flags
*--------------------------------------------------------------*
* The short routine table ;
*--------------------------------------------------------------*
h_table2 DC.L Q_linetext ; 2x = lines or Q_Text
DC.L Q_Rects ; 3x = rectangle
DC.L Q_Rects ; 4x = round Q_Rect
DC.L Q_Rects ; 5x = oval
DC.L Q_Arcs ; 6x = Q_Arc
DC.L Q_Polys ; 7x = polygon
DC.L Q_Regions ; 8x = Q_Region
DC.L Q_Pixels ; 9x = Q_Pixels
DC.L Q_Comments ; Ax = Q_Comments
****************************************************************
* ;
* DRAWING OPCODE-GROUP ROUTINES ;
* ;
****************************************************************
*--------------------------------------------------------------*
* Copy lines or Q_Text, depending on low nybble of Q_op ;
*--------------------------------------------------------------*
Q_linetext ;
lda Q_op ; get the low nybble
and #$f
jtl lt_table
rtl
lt_table DC.L Q_Line ; 20 = Q_Line
DC.L Q_Lfrom ; 21 = Q_Line from
DC.L Q_Sline ; 22 = short Q_Line
DC.L Q_Slfrom ; 23 = short Q_Line from
DC.L Q_Undef ; 24 = <undefined>
DC.L Q_Undef ; 25 = <undefined>
DC.L Q_Undef ; 26 = <undefined>
DC.L Q_Undef ; 27 = <undefined>
DC.L Q_Text ; 28 = Q_Text
DC.L Q_DhText ; 29 = dh Q_Text
DC.L Q_DvText ; 2A = dv Q_Text
DC.L Q_DhDvText ; 2B = offset Q_Text
DC.L Q_LongText ; 2C = long Q_Text
DC.L Q_Undef ; 2D = <undefined>
DC.L Q_Undef ; 2E = <undefined>
DC.L Q_Undef ; 2F = <undefined>
*--------------------------------------------------------------*
* Copy Q_Rect opcode and parameters (if any) ;
*--------------------------------------------------------------*
Q_Rects ;
lda Q_op ; get the low three bits
and #7
cmp #5 ; is this legal?
jgt Q_Undef
lda Q_op
and #8 ; same Q_Rect?
jeq Q_Rect ; if not, copy the D_New one
jmp Q_Nop ; otherwise, just the opcode will do
*--------------------------------------------------------------*
* Copy Q_Arc opcode and parameters (if any) ;
*--------------------------------------------------------------*
Q_Arcs ;
lda Q_op ; get the low nybble
and #$7
cmp #$5 ; is this legal?
jgt Q_Undef
lda Q_op
and #$8 ; same?
jeq Q_Arc ; if not, copy the D_New one
jsl Q_Nop ; if so, just copy the opcode
jmp Q_Angles ; and the Q_Angles
*--------------------------------------------------------------*
* Copy Q_Poly opcode and parameters (if any) ;
*--------------------------------------------------------------*
Q_Polys ;
lda Q_op ; get the low nybble
and #$7
cmp #$5 ; is this legal?
jgt Q_Undef
lda Q_op
and #$8 ; same?
jeq Q_Poly ; if not, copy it
jmp Q_Nop ; else, just copy the opcode
*--------------------------------------------------------------*
* Copy Q_Region opcode and parameters (if any) ;
*--------------------------------------------------------------*
Q_Regions ;
lda Q_op ; get the low nybble
and #$7
cmp #$5 ; is this legal?
jgt Q_Undef
lda Q_op
and #$8 ; same?
jeq Q_Region ; if not, copy the D_New one
jmp Q_Nop ; else just copy the opcode
*--------------------------------------------------------------*
* Copy pixelmap opcode and parameters ;
*--------------------------------------------------------------*
Q_Pixels ;
cmpw Q_op,#$91
jgt Q_Undef
jeq Q_PixRgn
jmp Q_PixRect
*--------------------------------------------------------------*
* Copy comment opcode and data ;
* Now mangles the first PSHandle comment appropriately ;
*--------------------------------------------------------------*
Q_Comments ;
cmpw Q_op,#$A1
jne Q_Undef
jsl Q_Copy2 ; copy the opcode
moveword [<oldptr],<temp ; get the type
jsl Q_Copy2 ; copy it
moveword [<oldptr],<count ; get the data size
jsl Q_Copy2 ; copy it
pushlong <oldptr ; copy the data
pushlong <newptr
pushword #0 ; high word
pushword <count ; low word
_BlockMove
cmpw <temp,#192 ; PSHandle?
bne notps
lda Q_gotPScomm ; First one?
bne notps
jtl manglePS,<what
notPS addwl <count,<oldptr
addwl <count,<newptr
clc
rtl
ManglePS DC.L FlipHPS
DC.L FlipVPS
DC.L RotRPS
DC.L RotLPS
*--------------------------------------------------------------*
FlipHPS rtl
*--------------------------------------------------------------*
FlipVPS rtl
*--------------------------------------------------------------*
RotRPS rtl
*--------------------------------------------------------------*
RotLPS rtl
****************************************************************
* ;
* SIMPLE OPCODE INTERPRETING ROUTINES ;
* ;
****************************************************************
*--------------------------------------------------------------*
* Copy the Q_Nop opcode ;
*--------------------------------------------------------------*
Q_Nop ;
Q_Copy2 ;
moveword [<oldptr],[<newptr] ; store the opcode
addwl #2,<oldptr ; move the pointers
addwl #2,<newptr
clc
rtl
*--------------------------------------------------------------*
* Copy an opcode and its two byte parameter ;
*--------------------------------------------------------------*
Q_Copy4 ;
movelong [<oldptr],[<newptr] ; store the opcode
addwl #4,<oldptr ; move the pointers
addwl #4,<newptr
clc
rtl
*--------------------------------------------------------------*
* Copy an opcode and its four byte parameter ;
*--------------------------------------------------------------*
Q_Copy6 ;
movelong [<oldptr],[<newptr] ; store the opcode
ldy #4
moveword [<oldptr]:y,[<newptr]:y
addwl #6,<oldptr ; move the pointers
addwl #6,<newptr
clc
rtl
*--------------------------------------------------------------*
* Copy a Q_Point opcode and mangle its parameters ;
*--------------------------------------------------------------*
Q_Point ;
jsl Q_Nop ; copy the opcode
jmp Q_CopyPt ; mangle and copy the Q_Point
*--------------------------------------------------------------*
* Copy an Q_OvalSize opcode and mangle its data ;
*--------------------------------------------------------------*
Q_OvalSize ;
jsl Q_Nop
movelong [<oldptr],<thepoint ; get the value
cmpw <what,#Q_rotr
jlt keepit
ldx <thepoint ; if I'm rotating,
lda <thepoint+2 ; swap the components
stx <thepoint+2
sta <thepoint
lda Q_pictSCB ; 640 mode?
beq keepit
asl <thepoint+2 ; if so, double the D_New xcoord
lsr <thepoint ; and halve the D_New ycoord
keepit movelong <thepoint,[<newptr] ; store it!
addwl #4,<oldptr ; adjust the pointers
addwl #4,<newptr
rtl
*--------------------------------------------------------------*
* Copy a Q_PenSize opcode, mangle the data, and remember it ;
*--------------------------------------------------------------*
Q_PenSize ;
jsl Q_OvalSize
movelong <thepoint,Q_thePnSize ; it's left here by Q_OvalSize
rtl
*--------------------------------------------------------------*
* Copy a Q_Line opcode and mangle its data ;
*--------------------------------------------------------------*
Q_Line ;
jsl Q_Point ; opcode, pnloc
jsl Q_NudgePt ; adjust for the Q_PenSize
jsl Q_CopyPt
movelong [<oldptr],Q_thePnLoc ; remember the pen location
jmp Q_NudgePt
*--------------------------------------------------------------*
* Copy a Q_Line from opcode and mangle its data ;
*--------------------------------------------------------------*
Q_Lfrom ;
jsl Q_Nop ; opcode
movelong [<oldptr],Q_thePnLoc ; remember the pen location
jsl Q_CopyPt ; pnloc
jmp Q_NudgePt ; adjust for the Q_PenSize
*--------------------------------------------------------------*
* Copy a short Q_Line opcode and mangle its data ;
*--------------------------------------------------------------*
Q_Sline ;
cmpw <what,#Q_rotr ; am I rotating?
blt dosline
lda Q_pictSCB ; in 640 mode?
beq dosline
; moveword [<oldptr]:#6,a ; I need to turn this into a Q_Line
; and #$ff ; opcode if I'm in 640 mode
; cmp #64
; blt dosline ; > P U N T <
; cmp #256-64
; bgt dosline
;
movelong #2,Q_addbytes ; What luck. Change the pict size
jsl Q_ChangePictSize ; to accomodate the different opcode
moveword #$20,[<newptr] ; (Q_Line)
addwl #2,<oldptr ; adjust the pointers
addwl #2,<newptr
movelong [<oldptr],Q_thePnLoc ; remember the pen location
jsl Q_CopyPt ; copy pen loc
jsl Q_NudgePt ; adjust for Q_PenSize
jsl Q_FakeDhDv ; account for dh, dv (see below)
jmp Q_NudgePt ; adjust for Q_PenSize
dosline jsl Q_Nop ; opcode
movelong [<oldptr],Q_thePnLoc ; remember the pen location
jsl Q_CopyPt ; pnloc
jsl Q_NudgePt ; adjust for the Q_PenSize
jmp Q_DhDv ; dh, dv
*--------------------------------------------------------------*
* Copy a short Q_Line from opcode and mangle its data ;
*--------------------------------------------------------------*
Q_Slfrom ;
cmpw <what,#Q_rotr ; am I rotating?
blt doslfrom
lda Q_pictSCB ; in 640 mode?
beq doslfrom
; moveword [<oldptr]:#2,a ; I need to turn this into a Q_Line
; and #$ff ; opcode if I'm in 640 mode!!
; cmp #64
; blt doslfrom ; > P U N T <
; cmp #265-64
; bgt doslfrom
movelong #2,Q_addbytes ; What luck. Change the pict size
jsl Q_ChangePictSize ; to accomodate the different opcode
moveword #$21,[<newptr] ; (LineFrom)
addwl #2,<oldptr ; adjust the pointers
addwl #2,<newptr
jsl Q_FakeDhDv ; account for dh, dv (see below)
jmp Q_NudgePt ; adjust for Q_PenSize
doslfrom jsl Q_Nop ; opcode
jmp Q_DhDv ; dh, dv
*--------------------------------------------------------------*
* Copy a Q_Rect opcode and mangle its parameters ;
*--------------------------------------------------------------*
Q_Rect ;
jsl Q_Nop ; copy the opcode
Q_JustRect ; ; ---- Copy ONLY the Q_Rect ----
jsl Q_CopyPt ; copy the upper left Q_Point
jsl Q_CopyPt ; copy the lower right Q_Point
subwl #8,<newptr ; back up a minute
Q_FixRect ; ; ---- Legalize Q_Rect at newptr ----
ldy #4
cmpw [<newptr],[<newptr]:y ; top and bottom ok?
bmi tb_ok
pushword [<newptr] ; if not, swap 'em.
moveword [<newptr]:y,[<newptr]
pullword [<newptr]:y
tb_ok addwl #2,<newptr
cmpw [<newptr],[<newptr]:y ; left and right ok?
bmi lr_ok
pushword [<newptr] ; if not, swap 'em.
moveword [<newptr]:y,[<newptr]
pullword [<newptr]:y
lr_ok addwl #6,<newptr
clc
rtl
*--------------------------------------------------------------*
* Copy an Q_Arc opcode and mangle its data ;
*--------------------------------------------------------------*
Q_Arc ;
jsl Q_Rect ; copy the opcode and mangle the Q_Rect
jmp Q_Angles ; mangle the Q_Angles
*--------------------------------------------------------------*
* Copy a polygon opcode and mangle its data ;
*--------------------------------------------------------------*
Q_Poly ;
jsl Q_Nop ; copy the opcode
moveword [<oldptr],<count ; get the size of the polygon
jsl Q_Rect ; copy it and the bounds
subword <count,#10,<count ; subtract size and bounds
lsr <count ; and divide by 4
lsr <count ; to get number of points
ptloop jsl Q_CopyPt ; mangle a Q_Point
jsl Q_NudgePt ; adjust for the Q_PenSize
dec <count ; one less left
bne ptloop ; repeat until no more
clc
rtl
****************************************************************
* ;
* BOTTOM-LEVEL GRUNGE WORK ROUTINES ;
* ;
****************************************************************
*--------------------------------------------------------------*
* Mangle and copy a distance parameter from oldptr to newptr ;
*--------------------------------------------------------------*
* NOTE: At this Q_Point we know ;dh|<63 or Q_pictSCB=0 ;
*--------------------------------------------------------------*
Q_DhDv ;
moveword [<oldptr],<thepoint
jsl Q_ShiftPen ; adjust the pen location
jtl mangleDist,<what
moveword <thepoint,[<newptr]
addwl #2,<oldptr
addwl #2,<newptr
clc
rtl
mangleDist DC.L h_dist
DC.L v_dist
DC.L r_dist
DC.L l_dist
h_dist lda <thepoint
eor #$ff00 ; flip the high byte (dx)
clc
adc #$100
sta <thepoint
rtl
v_dist lda <thepoint
xba ; reverse the bytes (switch dx and dy)
eor #$ff00 ; flip the low byte (dy)
clc
adc #$100
xba ; reverse the bytes (switch dx and dy)
sta <thepoint
rtl
r_dist lda <thepoint ; dx = dy; dy = -dx
xba ; reverse the bytes (switch dx and dy)
eor #$ff00 ; flip the high byte (dy)
clc
adc #$100
sta <thepoint
bra fix_dist ; adjust for mode if necessary
l_dist lda <thepoint ; dx = -dy ; dy = dx
eor #$ff00 ; flip the high byte (dy)
clc
adc #$100
xba ; reverse the bytes (switch dx and dy)
sta <thepoint
fix_dist lda Q_pictSCB ; am I in 640 mode?
jeq nofix
short
asl <thepoint+1 ; double dh
lda <thepoint ; halve dv
asl a
ror <thepoint
long
nofix rtl
*--------------------------------------------------------------*
* Shift Q_thePnLoc by the value store in thePoint (dh, dv) ;
*--------------------------------------------------------------*
Q_ShiftPen ;
lda <thepoint ; ---- Adjust Q_thePnLoc ----
and #$ff ; get just dv
bit #$80 ; get dv's sign
beq gotdv
ora #$ff00
gotdv clc
adc Q_thePnLoc
sta Q_thePnLoc
lda <thepoint+1
and #$ff ; get just dh
bit #$80 ; get dh's sign
beq gotdh
ora #$ff00
gotdh clc
adc Q_thePnLoc+2
sta Q_thePnLoc+2
rtl
*--------------------------------------------------------------*
* Convert a dh, dv parameter into a Q_Point parameter ;
*--------------------------------------------------------------*
Q_FakeDhDv ;
moveword [<oldptr],<thepoint ; get the distance
jsl Q_ShiftPen ; adjust the pen location
movelong Q_thePnLoc,<thepoint ; that's the D_New Q_Point!
jtl Q_manglePt,<what ; mangle it
movelong <thepoint,[<newptr] ; store it
addwl #2,<oldptr ; adjust the pointers
addwl #4,<newptr
rtl
*--------------------------------------------------------------*
* Mangle and copy a Q_Point from oldptr to newptr ;
*--------------------------------------------------------------*
Q_CopyPt ;
movelong [<oldptr],<thepoint
jtl Q_manglePt,<what
movelong <thepoint,[<newptr]
addwl #4,<oldptr
addwl #4,<newptr
clc
rtl
Q_manglePt ;
DC.L h_point
DC.L v_point
DC.L r_point
DC.L l_point
*--------------------------------------------------------------*
h_point lda Q_center+2 ; H-flip the Q_Point around Q_center.x
sec
sbc <thepoint+2
sta <thepoint+2
rtl
*--------------------------------------------------------------*
v_point lda Q_center ; V-flip the Q_Point around Q_center.y
sec
sbc <thepoint
sta <thepoint
rtl
*--------------------------------------------------------------*
;
; NOTE: The reason behind adding the last bit of either Q_center or
; Q_center+2 in the calculations below is to prevent the picture
; from creeping up and/or to the left when (Q_center)+(Q_center+2)
; is odd. Trust me. It works.
; -- jge, 1/20/88
;
r_point lda Q_pictSCB ; adjust for 640 mode?
beq dor_point
lda <thepoint+2 ; if so, halve the x-coord (sigh)
asl a ; (preserve the sign)
ror <thepoint+2
dor_point lda Q_center+2 ; R-rotate the Q_Point around Q_center
and #1 ; <adjust for creep>
clc
adc Q_center+2 ; pt.x <= -(pt.y - Q_center.y) + Q_center.x
adc Q_center
sta <temp ; (divide by 2, preserving
asl <temp ; the sign)
ror a ;
sec
sbc <thepoint
tax ; D_Save it here...
lda Q_center ; pt.y <= pt.x - Q_center.x + Q_center.y
and #1 ; <adjust for creep>
clc
adc Q_center
sec
sbc Q_center+2
sta <temp ; (divide by 2, preserving
asl <temp ; the sign)
ror a ;
clc
adc <thepoint+2
sta <thepoint
stx <thepoint+2 ; ...and store it here.
lda Q_pictSCB ; adjust for 640 mode?
beq didr_point
asl <thepoint+2 ; if so, double the D_New x-coord
didr_point rtl
*--------------------------------------------------------------*
l_point lda Q_pictSCB ; adjust for 640-mode?
beq dol_point
lda <thepoint+2 ; if so, halve the x-coord (sigh)
asl a ; (preserve the sign)
ror <thepoint+2
dol_point lda Q_center ; L-rotate the Q_Point around Q_center
and #1 ; <adjust for creep>
clc
adc Q_center ; pt.y <= -(pt.x - Q_center.x) + Q_center.y
adc Q_center+2
sta <temp ; (divide by 2, preserving
asl <temp ; the sign)
ror a ;
sec
sbc <thepoint+2
tay ; D_Save it here...
lda Q_center+2 ; pt.x <= pt.y - Q_center.y + Q_center.x
and #1 ; <adjust for creep>
clc
adc Q_center+2
sec
sbc Q_center
sta <temp ; (divide by 2, preserving
asl <temp ; the sign)
ror a ;
clc
adc <thepoint
sta <thepoint+2
sty <thepoint ; ...and store it here.
lda Q_pictSCB ; adjust for 640-mode?
beq didl_point
asl <thepoint+2 ; if so, double the D_New x-coord
didl_point rtl
*--------------------------------------------------------------*
* Adjust the last mangled Q_Point with respect to the Q_PenSize ;
*--------------------------------------------------------------*
Q_NudgePt ;
subwl #4,<newptr ; back up a minute
lda <what ; which coordinate do I need to nudge?
and #1
beq HorR
subword [<newptr],Q_thePnSize,[<newptr] ; if V or L, nudge y up
bra nudged
HorR ldy #2 ; if H or R, nudge x left
subword [<newptr]:y,Q_thePnSize+2,[<newptr]:y
nudged addwl #4,<newptr ; ok, I'm done now
rtl
*--------------------------------------------------------------*
* Mangle and copy Q_Angles from oldptr to newptr ;
*--------------------------------------------------------------*
Q_Angles ;
movelong [<oldptr],<thepoint
jtl mangleAngle,<what
movelong <thepoint,[<newptr]
addwl #4,<oldptr
addwl #4,<newptr
clc
rtl
mangleAngle DC.L h_angle
DC.L v_angle
DC.L r_angle
DC.L l_angle
h_angle lda #360 ; start = (360-start-Q_Arc) mod 360
sec
sbc <thepoint
sbc <thepoint+2
bge h_ok ; is it still positive?
clc
adc #360 ; if not, adjust it.
h_ok sta <thepoint
rtl
v_angle lda #180 ; start = (180-start-Q_Arc) mod 360
sec
sbc <thepoint
sbc <thepoint+2
bge v_ok ; still positive?
clc
adc #360 ; if not, adjust.
v_ok sta <thepoint
rtl
r_angle lda <thepoint ; start = (start + 90) mod 360
clc
adc #90
cmp #360 ; less than 360?
blt r_ok
sec ; if not, adjust.
sbc #360
r_ok sta <thepoint
rtl
l_angle lda <thepoint ; start = (start - 90) mod 360
sec
sbc #90
bge l_ok ; still positive?
clc ; if not, adjust.
adc #360
l_ok sta <thepoint
rtl
*--------------------------------------------------------------*
* Copy a D_Pattern opcode and mangle its data ;
*--------------------------------------------------------------*
* NOTE: This doesn't flip or rotate patterns, since that ;
* would be seriously screwed up in 640 mode. ;
*--------------------------------------------------------------*
Pict_pattern ;
jsl Q_Nop ; move the opcode
pushlong <oldptr ; move the D_Pattern
pushlong <newptr
pushlong #32
_BlockMove
addwl #32,<oldptr
addwl #32,<newptr
rtl
*--------------------------------------------------------------*
* Copy a Q_Mask opcode and mangle its data ;
*--------------------------------------------------------------*
* NOTE: DOESN'T REALLY MANGLE, AND PROBABLY NEVER WILL! ;
*--------------------------------------------------------------*
Q_Mask ;
jsl Q_Nop ; move the opcode
movelong [<oldptr],[<newptr] ; move the Q_Mask
ldy #4
movelong [<oldptr]:y,[<newptr]:y
addwl #8,<oldptr
addwl #8,<newptr
rtl ; No surgery (for now) <or for ever?>
****************************************************************
* ;
* MISCELLANY ;
* ;
****************************************************************
*--------------------------------------------------------------*
* Abort! An undefined opcode was found! ;
*--------------------------------------------------------------*
Q_Undef ;
moveword #$A501,Q_picterr
sec
rtl
*--------------------------------------------------------------*
* Add Q_addbytes to newpict and D_Update the pointer ;
*--------------------------------------------------------------*
Q_ChangePictSize ;
sublong <newptr,[<newpict],<temp ; get offset into pict
pushlong <newpict
_HUnLock
addlong Q_addbytes,<Q_newsize,<Q_newsize
pushlong <Q_newsize
pushlong <newpict
jsl D_GrowHandle
sta Q_picterr
bcs nochange
pushlong <newpict
_HLock
addlong [<newpict],<temp,<newptr
lda #0
clc
nochange rtl
oldpict equ ~~oldpict
what equ ~~what
newpict equ ~~newpict
Q_newsize equ ~~newsize
oldptr equ ~~oldptr
newptr equ ~~newptr
count equ ~~count
thepoint equ ~~thepoint
temp equ ~~temp
ENDP
END
Reference in New Issue View Git Blame Copy Permalink