; Septic's Demoskola - Lektion 12 : Fylld vektor
; Skriven av Vicious / Septic - 8 Februari 1994

DisableCache=1	; En nolla betyder att funktionen är avstängd...
DisableMotor=1

ScreenWidth=320
ScreenHeight=256
ScreenSize=Screenwidth/8*ScreenHeight
NrOfBpl=2

Distance=360

XSpeed=3
YSpeed=1
Zspeed=2

	section	Lektion10,code_c

j:	movem.l	d0-a6,-(sp)

	bsr.w	INIT
	tst.l	gfxbase		; Kolla om vi hittade gfx.library
	beq.s	error		; Nepp...Då hoppar vi ut...

	move.w	#%1000001111000000,$dff096	; Sätt DMA
	;	  S    NDBCBSD
	;	  E    aMPOLPS
	;	  T    sALPTRK
	;	       t
	;              y

	move.l	#copper,$dff080	; Nu sätter vi vår egen copperlista
	move.w	d0,$dff088	; Och tvingar den att börja direkt...

main:
	bsr.s	sync
	bsr.w	SwapPages
	bsr.w	ClrDrawPage
	bsr.w	Rotate
	bsr.w	DrawCube
	bsr.w	FillPage
	bsr.s	NewAngle

	cmp.l	#360,depth	; Kolla om vi zoomat färdigt...
	beq.s	.noadd
	add.l	#5,depth	; Zooma in mera!
.noadd:
	btst	#6,$bfe001	; Testa vänster musknapp!
	bne.s	main

xit:	bsr.w	UnINIT
error:	movem.l	(sp)+,d0-a6
	rts

; Syncroniserings rutin
sync:	move.l	$dff004,d0
	and.l	#$1ff00,d0
	lsr.l	#8,d0
	cmp.w	#$f0,d0		; Kolla om rasterrad=$f0
	bne.s	sync
	rts

; Den här rutinen adderar speed-värdena till de tre vinklarna och kollar
; om en vinkel är >359 vilket betyder att den skall "wrappas" runt!
NewAngle:
	movem.l	d0-a6,-(sp)
	lea.l	AngleX(pc),a0
	add.l	#XSpeed,(a0)
	bsr.s	ChkAngle
	addq.l	#4,a0
	add.l	#YSpeed,(a0)
	bsr.s	ChkAngle
	addq.l	#4,a0
	add.l	#ZSpeed,(a0)
	bsr.s	ChkAngle
	movem.l	(sp)+,d0-a6
	rts

ChkAngle:
	cmp.l	#360,(a0)
	blo.s	.angOk
	sub.l	#360,(a0)
.angOk:	rts

; Den här rutinen roterar ett obegränsat antal punkter i X, Y och Z
Rotate:
	movem.l	d0-a6,-(sp)
	lea.l	coords(pc),a0
	lea.l	coords2d(pc),a1
	lea.l	sintable(pc),a2
	lea.l	costable(pc),a3
	moveq	#14,d5
.calculate:
	movem.l	(a0)+,d0-d2

	; X rotation
	move.l	d2,d3		; Spara X
	move.l	AngleX(pc),d4	; Hämta X-vinkeln
	add.l	d4,d4		; *2 (för att sinusvärdena är i wordsize)
	move.w	(a3,d4.w),d7	; Hämta cosinus för vinkeln a
	muls.w	d7,d2		; Cos a * Z
	move.w	(a2,d4.w),d6	; Hämta sinus för vinkeln a
	muls.w	d1,d6		; Y * Sin a
	sub.l	d6,d2		; Z - Y
	asr.l	d5,d2		; Dividera med 16384 för att få ny Z

	move.w	(a2,d4.w),d6
	muls.w	d6,d3		; Sin a * old Z
	move.w	(a3,d4.w),d7
	muls.w	d7,d1		; Cos a * Y
	add.l	d3,d1		; Z + Y
	asr.l	d5,d1		; Ny Y

	; Y rotation
	move.l	d0,d3
	move.l	AngleY(pc),d4
	add.l	d4,d4
	move.w	(a3,d4.w),d7
	muls.w	d7,d0		; Cos a * X
	move.w	(a2,d4.w),d6
	muls.w	d2,d6		; Z * Sin a
	sub.l	d6,d0		; Z - X
	asr.l	d5,d0		; Ny X

	move.w	(a2,d4.w),d6
	muls.w	d6,d3		; Sin a * gammal X
	move.w	(a3,d4.w),d7
	muls.w	d7,d2		; Cos a * Z
	add.l	d3,d2		; X + Z
	asr.l	d5,d2		; Ny Z

	; Z rotation
	move.l	d0,d3
	move.l	AngleZ(pc),d4
	add.l	d4,d4
	move.w	(a3,d4.w),d7
	muls.w	d7,d0		; Cos a * X
	move.w	(a2,d4.w),d6
	muls.w	d1,d6		; Y * sin a
	sub.l	d6,d0		; Y - X
	asr.l	d5,d0		; Ny X

	move.w	(a2,d4.w),d6
	muls.w	d6,d3		; Sin a * X
	move.w	(a3,d4.w),d7
	muls.w	d7,d1		; Cos a * Y
	add.l	d3,d1		; X + Y
	asr.l	d5,d1		; Ny Y

	; Konvertera 3d till 2d...
	add.l	#distance,d2	; Addera distansen till Z
	move.l	depth(pc),d4	; Hämta djup-värdet
	muls.w	d4,d0		; Djupet*X
	divs.w	d2,d0		; och dividera med Z+Distansen
	ext.l	d0		; Utvidga wordet till longword
	muls.w	d4,d1		; Djupet*Y
	divs.w	d2,d1		; och dividera med Z+Distansen
	ext.l	d1

	move.l	d0,(a1)+	; Lagra X
	move.l	d1,(a1)+	; Lagra Y

	cmp.l	#-6666,(a0)	; Kolla slutet på tabellen
	bne.w	.calculate

	movem.l	(sp)+,d0-a6
	rts


DrawCube:
	movem.l	d0-a6,-(sp)
	move.l	drawpage(pc),a0		; Skärmpekare
	move.l	#screenwidth/8,a1	; Skärmbredden i bytes
	move.l	#-1,a2			; Mask

	lea.l	coords2d(pc),a3
	lea.l	lines(pc),a4

.nxtpoly:
	move.l	(a4)+,d4	; Hämta polygonens färgnummer
	move.l	(a4)+,d7	; Antal linjer i polygonen
	move.l	(a4),d5		; Lagra koordinat 1
	bsr.w	HiddenFace
	bpl.w	.visible	; Om normalen är positiv är polygonen synlig
	lsl.l	#2,d7		; Koordinaterna ligger på jämna longwords
	add.l	d7,a4		; Peka på nästa polygon
	bra.w	.nopoly

.visible:
	subq.l	#2,d7
	bmi.w	.nopoly
.drawpoly:
	move.l	(a4)+,d6	; Koordinat nummer
	lsl.l	#3,d6		; *8
	move.l	(a3,d6.w),d0
	move.l	4(a3,d6.w),d1

	add.l	#screenwidth/2,d0
	add.l	#screenheight/2,d1

	move.l	(a4),d6
	lsl.l	#3,d6		; *8
	move.l	(a3,d6.w),d2
	move.l	4(a3,d6.w),d3

	add.l	#screenwidth/2,d2
	add.l	#screenheight/2,d3

	ror.b	#1,d4		; Shifta ut färgnumret
	bpl.s	.notbpl1	; Kolla om vi ska sätta något i bitplanet
	bsr.w	DrawLine	; I så fall ritar vi en linje
.notbpl1:
	ror.b	#1,d4		; Kolla andra bitplanet också...
	bpl.s	.notbpl2
	lea.l	screensize(a0),a0	; Addera till skärmpekaren
	bsr.w	DrawLine		; och rita ut i bitplan 2!
	lea.l	-screensize(a0),a0
.notbpl2:
	rol.b	#2,d4		; Fixa tillbaka färgen...

	dbf	d7,.drawpoly

	; Rita sista linjen i polygonen...
	move.l	(a4)+,d6	; Koordinat nummer
	lsl.l	#3,d6		; *8
	move.l	(a3,d6.w),d0
	move.l	4(a3,d6.w),d1

	add.l	#screenwidth/2,d0
	add.l	#screenheight/2,d1

	lsl.l	#3,d5		; *8
	move.l	(a3,d5.w),d2
	move.l	4(a3,d5.w),d3

	add.l	#screenwidth/2,d2
	add.l	#screenheight/2,d3

	roxr.b	#1,d4
	bcc.s	.notbpl1b
	bsr.s	DrawLine
.notbpl1b:
	roxr.b	#1,d4
	bcc.s	.notbpl2b
	lea.l	screensize(a0),a0
	bsr.s	DrawLine
	lea.l	-screensize(a0),a0
.notbpl2b:

.nopoly:
	cmp.l	#-6666,(a4)
	bne.w	.nxtpoly

	movem.l	(sp)+,d0-a6
	rts


; Den här rutinen räknar ut en polygons normal...
HiddenFace:
	movem.l	d1-d6,-(sp)

	move.l	(a4),d6		; Koordinat nummer 1
	lsl.l	#3,d6		; *8
	move.l	(a3,d6.w),d0	; X1
	move.l	4(a3,d6.w),d1	; Y1

	move.l	4(a4),d6	; Koordinat nummer 2
	lsl.l	#3,d6		; *8
	move.l	(a3,d6.w),d2	; X2
	move.l	4(a3,d6.w),d3	; Y2

	move.l	8(a4),d6	; Koordinat nummer 3
	lsl.l	#3,d6		; *8
	move.l	(a3,d6.w),d4	; X3
	move.l	4(a3,d6.w),d5	; Y3

	sub.l	d4,d0		; (X1-X3)=Vx1
	sub.l	d5,d1		; (Y1-Y3)=Vy1
	sub.l	d4,d2		; (X2-X3)=Vx2
	sub.l	d5,d3		; (Y2-Y3)=Vy2

	muls.w	d3,d0		; Vx1*Vy2
	muls.w	d2,d1		; Vy1*Vx2

	sub.l	d1,d0		; (Vx1*Vx2)-(Vy1*Vy2)

	movem.l	(sp)+,d1-d6
	rts

*** Linjeritnings Rutin  ***
; Den här rutinen ritar en linje med blittern
; D0 - X1   D1 - Y1   D2 - X2   D3 - Y2
; A0 - Skärmpekare
; A1 - Skärmbredden i bytes
; A2 - Linjens mask ($ffff för helt fylld linje)

DrawLine:
	movem.l	d0-a6,-(sp)

	cmp.w	d1,d3
	beq.w	.DontDraw
	bcc.s	.D1D3ok
	exg	d0,d2
	exg	d1,d3
.D1D3ok:
	move.l	a1,d4		; Lägg skärmbredden i D4
	mulu.w	d1,d4		; Multiplicera med Y1
	moveq	#-$10,d5	; D5=$fffffff0
	and.w	d0,d5		; Plocka bort de 4 lägsta bitarna
	lsr.w	#3,d5		; Multiplicera med 8 (2^3=8)
	add.w	d5,d4		; Addera detta till Y1
	add.l	a0,d4		; Addera skärmpekaren till detta

	moveq	#0,d5
	sub.w	d1,d3		; Ta reda på delta Y
	roxl.b	#1,d5		; Shifta ut X-flaggan i D5. Att X-flaggan
				; sätts här anger att D1 är högre än D3 och
				; därför kan vi senare med hjälp av D5 ta
				; fram rätt oktant utan större problem...
	tst.w	d3		; Kolla om D3 är negativt
	bge.s	.y2gy1
	neg.w	d3		; I så fall gör vi det positivt!
.y2gy1:
	sub.w	d0,d2		; Ta reda på delta X och gör samma sak som
				; med Y...
	roxl.b	#1,d5
	tst.w	d2
	bge.s	.x2gx1
	neg.w	d2
.x2gx1:
	move.w	d3,d1		; Flytta delta Y till D1

	; Fix corners (Fast method by Tec/Cryptoburners)
	add.w	d1,d1
	cmp.w	d2,d1
	dbhi	d3,.notfix
.notfix:
	move.w	d3,d1		; Flytta delta Y till D1
	sub.w	d2,d1		; Delta Y-Delta X anger vilket som är
				; störst!
	bge.s	.dygdx
	exg	d2,d3		; Vi vill ha det största värdet i D3.
				; Detta är nu dx.

.dygdx:	roxl.b	#1,d5		; Shifta in X-flaggan här också...

	move.b	Octant_table(pc,d5.l),d5	; Nu kan vi enkelt hämta
						; korrekt oktant från en
						; speciell tabell...

	add.w	d2,d2		; dy multiplicerat med 2

.WBlit:	btst #6,$dff002	; Vänta tills blittern är klar
	bne.s	.WBlit

	move.w	d2,$dff062	; Skriv dy till BLTBMOD
	sub.w	d3,d2		; Kolla om vi behöver sätta SIGN-biten
	bge.s	.signnl
	or.b	#$40,d5		; Sätt SIGN-flaggan i D5
.signnl: move.w	d2,$dff052	; Skriv (4*dy)-(2*dx) till BLTAPT
	sub.w	d3,d2
	move.w	d2,$dff064	; Och skriv 4*(dy-dx) till BLTAMOD

	move.w	#$8000,$dff074	; Sätt BLTADAT till $8000
	move.w	a2,$dff072	; Sätt linjemask i BLTBDAT
	move.w	#$ffff,$dff044	; Sätt rätt BLTAFWM
	and.w	#$000f,d0	; Maska bort allt utom de lägsta 4 bitarna
	ror.w	#4,d0		; Flytta upp 4 låga bitarna till de 4 höga

	or.w	#(srca+srcc+dest)!(a&b&nc+na&c),d0	; Minterm ABc+aC

	move.w	d0,$dff040	; Sätt korrekt värde i BLTCON0
	move.w	d5,$dff042	; och i BLTCON1
	move.l	d4,$dff048	; Första pixeln på linjen
	move.l	d4,$dff054	; Och första pixeln på linjen här också
	move.w	a1,$dff060	; Bredden på skärmen i BLTCMOD
	move.w	a1,$dff066	; och i BLTDMOD också

	lsl.w	#6,d3		; dx i bit 6-15
	addq.w	#2,d3		; och bit 0-5 = 2
	move.w	d3,$dff058	; Sätt detta sen i BLTSIZE för att starta
				; linjen...

.dontdraw:
	movem.l	(sp)+,d0-a6
	rts

Octant_table:
	dc.b 0*4+3	; y1<y2, x1<x2, dx<dy = Okt6 
	dc.b 4*4+3	; y1<y2, x1<x2, dx>dy = Okt7
	dc.b 2*4+3	; y1<y2, x1>x2, dx<dy = Okt5
	dc.b 5*4+3	; y1<y2, x1>x2, dx>dy = Okt4
	dc.b 1*4+3	; y1>y2, x1<x2, dx<dy = Okt1
	dc.b 6*4+3	; y1>y2, x1<x2, dx>dy = Okt0
	dc.b 3*4+3	; y1>y2, x1>x2, dx<dy = Okt2
	dc.b 7*4+3	; y1>y2, x1>x2, dx>dy = Okt3


; Detta är initialiserings-rutinen....
AttnFlags=296
INIT:
	movem.l	d0-a6,-(sp)
	bsr.w	FetchVBR

	move.l	$4.w,a6
	jsr	-132(a6)	; Forbid - Stäng av multitasking

 IFNE DisableCache		; Kolla om den här rutinen ska vara med...
	cmp.w	#36,20(a6)	; Disable Cache funkar bara på KS2.0++
	bcs.s	.not20		; Om lägre än 2.0 så hoppar vi vidare...
	move.l	#$00003818,d0	; Har inte kunnat testa de här siffrorna
	move.l	#$80003b1b,d1	; men det ska förmodligen funka :-)
	jsr	-648(a6)	; CacheControl()
	lea.l	OldCache(pc),a0
	move.l	d0,(a0)
.not20:
 ENDC

	lea.l	gfxname(pc),a1
	jsr	-408(a6)	; OldOpenLibrary() - Funkar lika bra som
	tst.l	d0		; valiga openlibrary() om man inte behöver
	beq.w	noGfx		; öppna en speciell version...
	move.l	d0,GfxBase
	move.l	d0,a6
	jsr	-456(a6)	; Ownblitter - Ska vi använda blittern måste
				; vi se till att vi får ta den...
	jsr	-228(a6)	; Och det är lika bra att vänta på den oxå!
				; Det gör vi med WaitBlit()
	sub.l	a1,a1
	jsr	-222(a6)	; Loadview - Nu kysser vi copperlistan adjö!
	jsr	-270(a6)	; WaitTOF - Vänta tills vi med säkerhet kan
	jsr	-270(a6)	; installera våra egna saker...WaitTOF ska
				; enligt Commodore helst köras två gånger!
	lea.l	oldintena(pc),a1
	move.w	$dff01c,(a1)+	; Spara gamla interrupt statusen
	move.w	$dff002,(a1)	; Spara gammal DMA
	move.w	#$7fff,d0
	move.w	d0,$dff09a	; INTENA
	move.w	d0,$dff096	; DMACON - Vi rensar gammal skit...

 IFNE DisableMotor		; Kolla om vi ska kötta av drivemotorn...
	move.b	#-1,$bfd100	; Den här lilla kodsnutten är inte direkt
	nop			; snäll men bör fungera ändå. Det värsta
	nop			; som kan hända är att driven fortsätter
	move.b	#$81,$bfd100	; att vara på.
	nop			; Mer om denna lilla snutt kommer när jag
	nop			; tar upp HW-trackloading! Tills dess får
	move.b	#-1,$bfd100	; ni svälja den utan förklaring...
 ENDC
	movem.l	(sp)+,d0-a6
	rts

NoGFX:	move.l	$4.w,a6
	jsr	-138(a6)	; Permit multitasking...
	movem.l	(sp)+,d0-a6
	rts

; Denna rutin sätter upp systemet igen...
UNINIT:
	movem.l	d0-a6,-(sp)
	move.w	oldintena(pc),d0
	or.w	#$8000,d0		; Så bitarna sätts och inte rensas
	move.w	d0,$dff09a
	move.w	olddmacon(pc),d0
	or.w	#$8000,d0
	move.w	d0,$dff096

	move.l	gfxbase(pc),a6
	jsr	-228(a6)	; Waitblit()
	jsr	-462(a6)	; DisOwnBlit()

	lea.l	intname(pc),a1	; Nu måste vi öppna Intuition
	move.l	$4.w,a6
	jsr	-408(a6)	; OldOpenlibrary
	move.l	d0,a2
	tst.l	d0		; Kolla om intuition gick att öppna....
	beq.s	.closegfx	; Hoppa om det inte gick...

	lea.l	34(a2),a1	; Fetcha Viewporten!
	move.l	gfxbase(pc),a6
	jsr	-222(a6)	; Loadviewa in den riktiga viewporten!
	move.l	$26(a6),$dff080	; Och restora gamla copperlistorna...
	move.l	$30(a6),$dff084

	move.l	a2,a1
	move.l	$4.w,a6
	jsr	-414(a6)	; Stäng intuition

.closegfx:
	move.l	$4.w,a6
	move.l	gfxbase(pc),a1
	jsr	-414(a6)	; och stäng också graphics.library...

 IFNE DisableCache
; Nu sätter vi på cache-minnet igen...
	cmp.w	#36,20(a6)	; Kolla version igen...Verkligen dumt
	bcs.s	.not20		; om det skulle ändra sig under programmets
				; gång! :-)))
	move.l	oldcache(pc),d0
	moveq	#-1,d1
	jsr	-648(a6)	; CacheControl()
.not20:
 ENDC
	jsr	-138(a6)	; Permit multitasking

	bsr.s	FetchTime
	movem.l	(sp)+,d0-a6
	rts

; Den här rutinen hämtar VBR, vilket är en offset till vektorområdet
; på högre processorer än 68000. På en vanlig 68000 är VBR alltid 0.
FetchVBR:
	move.l	a6,-(sp)
	move.l	$4.w,a6			; Hämta exec
	sub.l	a0,a0			; Nollställ a0
	btst	#0,Attnflags+1(a6)	; Kolla om 68010++
	beq.s	.Lower
	move.l	a5,-(sp)
	lea.l	.getVBR(pc),a5
	jsr	-30(a6)		; Vi måste hämta VBR i supervisor mode
	move.l	(sp)+,a5
.lower:	move.l	(sp)+,a6
	rts

.GetVBR:movem.l	a0/a1,-(sp)
	lea.l	MyVBR(pc),a1	; Här ska vi skriva in VBRen.
	dc.l	$4e7a8801	; Detta är egentligen instruktionen
				; MOVEC VBR,A0 men eftersom äldre versioner
				; av AsmOne inte stödjer den instruktionen
				; gjorde jag ett litet specialtrick här...
	move.l	a0,(a1)
	movem.l	(sp)+,a0/a1
	rte			; Återvänd från supervisor...

; Fetch Time Variables
IOTV_SIZE		=$28
IO_COMMAND		=$1C
TR_SETSYSTIME		=$B
tr_time			=$20
_LVOCloseDevice		=-$1C2
_LVODoIO		=-$1C8
_LVOReadBattClock	=-$C
_LVOOpenDevice		=-$1BC
_LVOOpenResource	=-$1F2
FetchTime:
	movem.l	d0-a6,-(sp)
	move.l	4.w,a6
	lea	battclockname(pc),a1
	jsr	_LVOOpenResource(a6)
	move.l	d0,d6
	beq.b	.noclock

	moveq	#0,d0
	moveq	#0,d1
	lea	timername(pc),a0
	lea	timerio(pc),a2
	move.l	a2,a1
	jsr	_LVOOpenDevice(a6)
	move.l	d0,d7
	bne.b	.notimerdev

	exg.l	d6,a6
	jsr	_LVOReadBattClock(a6)
	exg.l	d6,a6
	move.l	a2,a1
	move.l	d0,tr_time(a1)
	move.w	#TR_SETSYSTIME,IO_COMMAND(a1)
	jsr	_LVODoIO(a6)
	move.l	a2,a1
	jsr	_LVOCloseDevice(a6)
.notimerdev
.noclock
	movem.l	(sp)+,d0-a6
	rts

timerio	dcb.b	IOTV_SIZE
battclockname	dc.b	'battclock.resource',0
timername	dc.b	'timer.device',0
		even
MyVBR:	dc.l	0		; Här lägger vi VBR!

*** End of INIT routine ***


; Rensa skärmen med blittern!
ClrDrawPage:
	btst	#6,$dff002
	bne.s	clrdrawpage
	move.l	#$01000000,$dff040	; BLTCON
	move.w	#0,$dff066		; BLTDMOD
	move.l	drawpage(pc),$dff054	; BLTDPT
	move.w	#(((screenheight*nrofbpl)-1)*64)+(screenwidth/16),$dff058
	rts


; Fyll vektorer med blittern!
FillPage:
	btst	#6,$dff002
	bne.s	Fillpage
	move.l	drawpage(pc),a0
	add.l	#(screensize*nrofbpl)-2,a0
	move.w	#(srca!dest)!a,$dff040	; BLTCON0
	move.w	#$0012,$dff042		; BLTCON1 (EFE!DESC)
	move.l	#$ffffffff,$dff044	; BLTAFWM
	move.l	a0,$dff050		; BLTAPT
	move.l	a0,$dff054		; BLTDPT
	move.l	#0,$dff064		; BLTAMOD&BLTDMOD
	move.w	#(((screenheight*nrofbpl)-1)*64)+(screenwidth/16),$dff058
	rts

; Flippa fram den färdigritade sidan!
SwapPages:
	movem.l	d0/a0,-(sp)
	lea.l	drawpage(pc),a0
	move.l	(a0),d0
	move.l	4(a0),(a0)
	move.l	d0,4(a0)

	lea.l	bplptr+2(pc),a0
	move.w	d0,4(a0)
	swap	d0
	move.w	d0,(a0)
	swap	d0
	add.l	#screensize,d0
	lea.l	8(a0),a0
	move.w	d0,4(a0)
	swap	d0
	move.w	d0,(a0)
	movem.l	(sp)+,d0/a0
	rts

************* COPPER ************

copper:
	dc.w	$008e,$2c81	; DIWSTRT
	dc.w	$0090,$2cc1	; DIWSTOP
	dc.w	$0092,$0038	; DDFSTRT
	dc.w	$0094,$00d0	; DDFSTOP
	dc.w	$0100,$2200	; BPLCON0
	dc.w	$0102,$0000	; BPLCON1
	dc.w	$0104,$0000	; BPLCON2
	dc.w	$0106,$0000	; BLPCON3
	dc.w	$0108,$0000	; BPLMOD0
	dc.w	$010a,$0000	; BPLMOD1

	; Bitplanspekare
bplptr:	dc.w	$00e0,$0000,$00e2,$0000
	dc.w	$00e4,$0000,$00e6,$0000

	dc.w	$0180,$000,$0182,$f04,$0184,$e03,$0186,$d02

	dc.w	$ffff,$fffe

gfxname:dc.b	'graphics.library',0
intname:dc.b	'intuition.library',0
	even
gfxbase:dc.l	0
oldintena:
	dc.w	0
olddmacon:
	dc.w	0
OldCache:
	dc.l	0

DrawPage:
	dc.l	scr1
ShowPage:
	dc.l	scr2

Depth:	dc.l	0
AngleX:	dc.l	0
AngleY:	dc.l	0
AngleZ:	dc.l	0

; Koordinater för kuben
Coords:
	dc.l	-50,-50,-50
	dc.l	50,-50,-50
	dc.l	50,50,-50
	dc.l	-50,50,-50

	dc.l	-50,-50,50
	dc.l	50,-50,50
	dc.l	50,50,50
	dc.l	-50,50,50
	dc.l	-6666

; Linjedata som anger hur polygonerna är uppbyggda.
; Formatet: Färg,Antal linjer,punkt1, punkt2, punkt3 osv...
Lines:
	dc.l	1,4,0,1,2,3	; Totalt sex polygonsidor i en kub
	dc.l	1,4,7,6,5,4
	dc.l	2,4,0,3,7,4
	dc.l	2,4,5,6,2,1
	dc.l	3,4,4,5,1,0
	dc.l	3,4,6,7,3,2
	dc.l	-6666

coords2d:ds.l	8*2

; Sinus och cosinustabell, uppskiftad 14 ggr, vilket är samma sak som
; multiplikation med 16384.
SinTable:
	dc.w	 0,286,572,857,1143,1428
	dc.w	 1713,1997,2280,2563,2845,3126
	dc.w	 3406,3686,3964,4240,4516,4790
	dc.w	 5063,5334,5604,5872,6138,6402
	dc.w	 6664,6924,7182,7438,7692,7943
	dc.w	 8192,8438,8682,8923,9162,9397
	dc.w	 9630,9860,10087,10311,10531,10749
	dc.w	 10963,11174,11381,11585,11786,11982
	dc.w	 12176,12365,12551,12733,12911,13085
	dc.w	 13255,13421,13583,13741,13894,14044
	dc.w	 14189,14330,14466,14598,14726,14849
	dc.w	 14968,15082,15191,15296,15396,15491
	dc.w	 15582,15668,15749,15826,15897,15964
	dc.w	 16026,16083,16135,16182,16225,16262
	dc.w	 16294,16322,16344,16362,16374,16382

CosTable:
	dc.w	 16384,16382,16374,16362,16344
	dc.w	 16322,16294,16262,16225,16182,16135
	dc.w	 16083,16026,15964,15897,15826,15749
	dc.w	 15668,15582,15491,15396,15296,15191
	dc.w	 15082,14968,14849,14726,14598,14466
	dc.w	 14330,14189,14044,13894,13741,13583
	dc.w	 13421,13255,13085,12911,12733,12551
	dc.w	 12365,12176,11983,11786,11585,11381
	dc.w	 11174,10963,10749,10531,10311,10087
	dc.w	 9860,9630,9397,9162,8923,8682
	dc.w	 8438,8192,7943,7692,7438,7182
	dc.w	 6924,6664,6402,6138,5872,5604
	dc.w	 5334,5063,4790,4516,4240,3964
	dc.w	 3686,3406,3126,2845,2563,2280
	dc.w	 1997,1713,1428,1143,857,572
	dc.w	 286,0,-286,-572,-857,-1143
	dc.w	-1428,-1713,-1997,-2280,-2563,-2845
	dc.w	-3126,-3406,-3686,-3964,-4240,-4516
	dc.w	-4790,-5063,-5334,-5604,-5871,-6138
	dc.w	-6402,-6664,-6924,-7182,-7438,-7692
	dc.w	-7943,-8192,-8438,-8682,-8923,-9162
	dc.w	-9397,-9630,-9860,-10087,-10311,-10531
	dc.w	-10749,-10963,-11174,-11381,-11585,-11786
	dc.w	-11982,-12176,-12365,-12551,-12733,-12911
	dc.w	-13085,-13255,-13421,-13583,-13741,-13894
	dc.w	-14044,-14189,-14330,-14466,-14598,-14726
	dc.w	-14849,-14968,-15082,-15191,-15296,-15396
	dc.w	-15491,-15582,-15668,-15749,-15826,-15897
	dc.w	-15964,-16026,-16083,-16135,-16182,-16225
	dc.w	-16262,-16294,-16322,-16344,-16362,-16374
	dc.w	-16382,-16384,-16382,-16374,-16362,-16344
	dc.w	-16322,-16294,-16262,-16225,-16182,-16135
	dc.w	-16083,-16026,-15964,-15897,-15826,-15749
	dc.w	-15668,-15582,-15491,-15396,-15296,-15191
	dc.w	-15082,-14968,-14849,-14726,-14598,-14466
	dc.w	-14330,-14189,-14044,-13894,-13741,-13583
	dc.w	-13421,-13255,-13085,-12911,-12733,-12551
	dc.w	-12365,-12176,-11983,-11786,-11585,-11381
	dc.w	-11174,-10963,-10749,-10531,-10311,-10087
	dc.w	-9860,-9630,-9397,-9162,-8923,-8682
	dc.w	-8438,-8192,-7943,-7692,-7438,-7182
	dc.w	-6924,-6664,-6402,-6138,-5872,-5604
	dc.w	-5334,-5063,-4790,-4516,-4241,-3964
	dc.w	-3686,-3406,-3126,-2845,-2563,-2280
	dc.w	-1997,-1713,-1428,-1143,-857,-572
	dc.w	-286,0,286,572,857,1143
	dc.w	 1428,1713,1997,2280,2563,2845
	dc.w	 3126,3406,3686,3964,4240,4516
	dc.w	 4790,5063,5334,5604,5871,6138
	dc.w	 6402,6664,6924,7182,7438,7692
	dc.w	 7943,8192,8438,8682,8923,9162
	dc.w	 9397,9630,9860,10087,10311,10531
	dc.w	 10749,10963,11174,11381,11585,11786
	dc.w	 11982,12176,12365,12551,12733,12911
	dc.w	 13085,13255,13421,13583,13741,13894
	dc.w	 14044,14189,14330,14466,14598,14726
	dc.w	 14849,14968,15082,15191,15296,15396
	dc.w	 15491,15582,15668,15749,15826,15897
	dc.w	 15964,16026,16083,16135,16182,16225
	dc.w	 16262,16294,16322,16344,16362,16374
	dc.w	 16382,16384

	section	scr,BSS_c
scr1:	ds.b	screensize*nrofbpl
scr2:	ds.b	screensize*nrofbpl

; Blitter MINTERM data
DEST =	$100
SRCC =	$200
SRCB =	$400
SRCA =	$800

ABC =	$80
ABNC =	$40
ANBC =	$20
ANBNC =	$10
NABC =	$8
NABNC =	$4
NANBC =	$2
NANBNC =	$1

A = ABC!ABNC!ANBC!ANBNC
B = ABC!ABNC!NABC!NABNC
C = ABC!ANBC!NABC!NANBC

NA = (~A)&$FF
NB = (~B)&$FF
NC = (~C)&$FF
