; RUTINA 3D DEL LOGO DE A-CIRCLE MENEANDOSE(LA) :-)
;
; *ENTERELY* CODED BY WASI/A-CIRCLE 21-1-94  2:00 am 
; THANKS TO FRANKIE OF PROAMIGA FOR THE BITMAP ESTRUCTURE DATA. :-)
; THANKS TO CJ/SAE FOR THE VECTOR FORMULA IN THE "HOWTOCODE"
;
; (c) A-CIRCLE 1994
;
;        Escrito en AsmOne.
;
; AVISO: para cambiar el numero de puntos para hacer otro objeto hay que
;        cambiar el buffer donde se almacenan los puntos
;	 Los includes tienen que ir con el programa porque si no no funciona.
;	 (logicamente. :-) )
;	 El codigo completo esta compuesto por:
;		-AC3dDB.s
;		-Data01.i
;		-Func00.i
;		-Hard00.i		
;	 Por desgracia el display no funciona correctamente en un A1200 pero 
;	puede que en breve lo hAGA si aprendo como hacerlo y si Mijac me deja
;	experimentar con su A1200.
;
; opt 	c-	; esto es para el Devpac. Sirve para que el Devpac no haga
		; distinciones entre mayusculas y minusculas. 
******************************************************************************
*                            M  A  C  R  O  S				     *
******************************************************************************
Line 	MACRO				;Comienzo del macro
	move.l	\1,a1			;Direccion Rastport en uso
	jsr	Move(a6)		;Movemos el cursor a X,Y
	move.l	\1,a1			;Direccion Rastport en uso	
	move.w	d2,d0			;Posicion X1
	move.w	d3,d1			;Posicion Y1
	jsr	Draw(a6)		;Dibujamos la linea desde X,Y a X1,Y1
	ENDM				;Fin del macro

*\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/*
******************************************************************************
*                            I   N  I  C  I  O				     *
******************************************************************************

	bra.w	go			;los includes no se ejecutan(pin floi!)
	incdir	"df0:"
	include	"Data01.i"		;Archivo de datos. En este archivo 
	                                ;estan todos los cosenos y los senos 
	                                ;desde 0 hasta 360 y multiplicados por
	                                ;1000
	include "Hard00.i"		;Archivo direcciones hardware regs.
	include	"Func00.i"		;Archivo de offsets

******************************************************************************

go:	
	bsr.B	libs			;setup
	bsr.w	mi_bitmap		;inicializar primer bitmap
	bsr.w	mi_bitmap2		;inicializar segundo bitmap
	bsr.w	makecop			;setup copper
	bsr.w	loadcolors		;setup registros de color

screenswap:
	* Mostrar la uno y dibujar en la 2
	move.l	cop1adr,cop1lch(a5)	;mostrar pantalla 1
	bsr.w	checkblt		;chequear blitter
	bsr.w	checkblt		;otra vez
	bsr.w	vposrcheck		;esperar al vertical blank
	move.l	#rastport2,rastportactual;dibujar en el segundo bitmap
	bsr.w	clsblt2			;borrar la pantalla 2
	bsr.w	transfer		;calcular coordenadas
	bsr.w	drawlines		;dibujar
	
	* Mostrar la 2 y dibujar en la 1
	move.l	cop2adr,cop1lch(a5)	;mostrar pantalla 2
	bsr.w	checkblt		;chequear el blitter
	bsr.w	checkblt		;otra vez
	bsr.w	vposrcheck		;esperar al vertical blank
	move.l	#rastport,rastportactual;dibujar en el primer bitmap
	bsr.w	clsblt1			;borrar pantalla 1
	bsr.w	transfer		;calcular coordenadas
	bsr.w	drawlines		;dibujar


	btst	#6,$bfe001		;boton izquierdo pulsado?
	bne.B	screenswap		;No--> MAS MADERA!!!
        
	bsr.w	cerrar_libs		;Si--> ADIOS
	rts

; Abrimos librerias salvamos copper antiguo y reservamos memoria para los
; dos copper lists que vamos a usar.

libs:    
	lea	$dff000,a5		;Cargamos dir. base hardware regs
	move.l  execbase,a6        	;Direccion base exec.library
	jsr	forbid(a6)
        lea     gfxname,a1         	;nombre graphics.library
        jsr     OpenLibrary(a6)		;Abrir
        move.l  d0,gfxbase         	;Salvamos direccion base Gfx.lib
	move.l	d0,a0			;La cargamos en A0
	move.l	$26(a0),oldcop		;y salvamos el copper actual
	move.l	execbase,a6		;direccion base exec.library
	moveq.l	#40,d0			;cantidad de memoria a reservar
	moveq.l	#2,d1			;en chip
	jsr	AllocMem(a6)		;Ejecuten
	move.l	d0,cop1adr		;salvamos la direccion 

	moveq.l	#40,d0			;desde aqui, idem de lo de arriba
	moveq.l	#2,d1
	jsr	AllocMem(a6)
	move.l	d0,cop2adr		
	rts
	
; Bien esta puta mierda que viene ahora sirve para cargar una view. En este 
; caso la operacion "sub.l a1,a1", osea restar a1 en a1, que es igual a 0,
; indica a LoadView() que carge una view vacia que, en teoria, podria servir
; para que no saliese por pantalla la basura esa que sale a veces pero que a mi
; me sale siempre %$%.^$%&.^$#..@.!@#%$$.#@#.$#. 

lview:
	move.l	gfxbase,a6		;direccion base Graphics.library
	sub.l	a1,a1			;0 -> nada
	jsr	loadview(a6)		;ruuuuuuuuuuun 
	jsr	waitof(a6)		;wait VBL
	jsr	waitof(a6)		;wast VBL otra vez
	rts

; "Fabricamos" nuestro propio copper list al igual que hice en el programa
; de crear un pantalla y sacar el grafico por pantalla
;	d0-direccion primer bitplane
;	a0-direccion de la memoria reservada para el copper list
;	d3-comienzo de las direcciones hardware de los bitplanes
;	d2-Numero de planos

MakeCop:
	move.l	#bitplane1,d0
	move.l	cop1adr,a0
	move.w	#bpl0pth,d3
	moveq.l	#1,d2	
cloop:
	move.w	d3,(a0)+
	swap	d0
	move.w	d0,(a0)+
	add.l	#2,d3
	move.w	d3,(a0)+
	swap	d0
	move.w	d0,(a0)+
	add.l	#2,d3
	add.l	#10240,d0
	dbf	d2,cloop
	move.w	#bplcon0,(a0)+
	move.w	#%0001000000000000,(a0)+
	move.w	#diwstrt,(a0)+
	move.w	#$2c81,(a0)+
	move.w	#diwstop,(a0)+
	move.w	#$2c91,(a0)+
	move.w	#ddfstrt,(a0)+
	move.w	#$0038,(a0)+
	move.w	#ddfstop,(a0)+
	move.w	#$00d0,(a0)+
	move.l	#$fffffffe,(a0)+

	move.l	#bitplane12,d0
	move.l	cop2adr,a0
	move.w	#bpl0pth,d3
	moveq.l	#1,d2	
cloop2:
	move.w	d3,(a0)+
	swap	d0
	move.w	d0,(a0)+
	add.l	#2,d3
	move.w	d3,(a0)+
	swap	d0
	move.w	d0,(a0)+
	add.l	#2,d3
	add.l	#10240,d0
	dbf	d2,cloop2
	move.w	#bplcon0,(a0)+
	move.w	#%0001000000000000,(a0)+
	move.w	#diwstrt,(a0)+
	move.w	#$2c81,(a0)+
	move.w	#diwstop,(a0)+
	move.w	#$2c91,(a0)+
	move.w	#ddfstrt,(a0)+
	move.w	#$0038,(a0)+
	move.w	#ddfstop,(a0)+
	move.w	#$00d0,(a0)+
	move.l	#$fffffffe,(a0)+
	rts

; Inicializamos los BitMaps que vamos a usar: son dos BitMaps de 2 planos (d0),
; de 320 (d1) x 256 (d2).
; Despues inicializamos los Rastports a los Bitmaps que inicializamos antes
; El rastport les dice a muchas de las funciones de la libreria grafica donde
; cojones tienen que efectuar sus operaciones. Por ejemplo la funcion Draw() 
; para dibujar lineas o Polydraw(), para dibujar muchas de golpe.

mi_bitmap:
        move.l 	gfxbase,a6          	; direccion base Gfx.lib
        lea 	bitmap,a0           	; estructura del bitmap
        move.l 	#2,d0               	; 2 planos
        move.l 	#320,d1             	; x=320
        move.l 	#256,d2             	; y=256
        jsr 	InitBitMap(a6)      	; Inicializamos bitmap

        lea 	rastport,a1		; Puntero al rastport
        jsr 	InitRastPort(a6)    	; inicializamos rastport
        move.l 	#bitmap,R_Bitmap    	; guardo valor para luego
	rts

mi_bitmap2:
        move.l 	gfxbase,a6          	; direccion base Gfx.lib
        lea 	bitmap2,a0           	; estructura del bitmap
        move.l 	#2,d0               	; 2 planos
        move.l 	#320,d1             	; x=320
        move.l 	#256,d2             	; y=256
        jsr 	InitBitMap(a6)      	; Inicializamos bitmap
	
	lea	rastport2,a1		; lo mismo que para el primer rastport
	jsr	InitRastport(a6)
	move.l	#bitmap2,R_Bitmap2
	rts

; Aqui lo que hacemos es cargar una tabla de colores en los registros de color
; con la funcion LoadRGB4(), podia haberlo hecho a mano pero no tenia ganas.
;   A0: direccion del Viewport (en este caso es 0 porque no definimos ninguno
;   colortable: array con los colores que vamos a cargar
;   d0: numero de colores a cargar (0-1)

loadcolors:
	move.l	gfxbase,a6
	move.l	#0,a0
	lea	colortable,a1
	move.l	#1,d0
	jsr	LoadRGB4(a6)
	rts 	

; Lo que viene ahora son 4 rutinas que las pongo juntas porque me da la gana
; las dos primeras (clsblt1 y clsblt2) borran las pantallas en las que 
; dibujamos las lineas.
;	-bltdpt: aqui metemos la direccion del primer bitplane (o sea, a partir
; 		 de donde vamos a borrar la memoria             
;	-bltsize: aqui metemos la cantidad de memoria a borrar (o sea, hasta 
;		  donde vamos a borrar. Al inicializar este registro es cuando
;		  el blitter se activa.
; las otras dos esperan que el blitter haya acabado y el vertical blank. La del
; vertical blank tenia que haberlo hecho con la funcion de la libreria grafica
; WaitOF() pero me dio por leer el HowToCode y alli CJ decia que si usas el 
; Forbid(),que sirve para eliminar el multitasking, con el WaitOF(), el Forbid
; no funcionaria (y tenia razon, no funciona) asi que lo tuve que hacer a pelo
; leyendo directamente del registro de hardware VPOSR que te dice en que 
; posicion vertical de la pantalla se encuentra el haz de electrones.

clsblt1:
	move.l	#bitplane1,bltdpt(a5)
	clr.w	bltdmod(a5)
	clr.w	bltcon1(a5)
	move.w	#$100,bltcon0(a5)
	move.w	#10240*2,bltsize(a5)
	rts

clsblt2:
	move.l	#bitplane12,bltdpt(a5)
	clr.w	bltdmod(a5)
	clr.w	bltcon1(a5)
	move.w	#$100,bltcon0(a5)
	move.w	#10240*2,bltsize(a5)
	rts

checkblt:
	move.l	gfxbase,a6
	jsr	WaitBlit(a6)
	rts

vposrcheck:
	move.l	vposr(a5),d6
	and.l	#$0001ff00,d6
	cmp.l	#$00001000,d6
	bne.B	vposrcheck
	rts

; En esta parte del programa, que logicamente se llama al finalizar el mismo o
; sea cuando le des al boton izquierdo del raton, lo que hacemos es restablecer
; el copper anterior, cerrar la libreria grafica, liberar la memoria usada por
; los copper lists y permitir el multitasking. Y se acabo.

cerrar_libs:
	move.l	oldcop,Cop1lch(a5)
	move.l	gfxbase,a6
	
        move.l  gfxbase,a1
        move.l  execbase,a6
        jsr     CloseLibrary(a6)

	move.l	cop1adr,a1
	moveq.l	#40,d0
	jsr	FreeMem(a6)
	
	move.l	cop2adr,a1
	moveq.l	#40,d0
	jsr	FreeMem(a6)
	jsr	permit(a6)
	rts

*******************************************************************************
*       A PARTIR DE AQUI COMIENZA LA RUITNA DE CALCULO DE PUNTOS, LINEAS      *
*                                Y ANIMACION				      *
*	Bien, estas son las formulas para calcular las coordenas de los       *
*	puntos que forman el objeto.					      *
*		X1=(CX*cos(c1)+CY*sin(c1))/1000				      *
*		Y1=(CX*sin(c1)-CY*cos(c1))/1000	                              *
*									      *
*		X2=(X1*cos(c2)+CZ*sin(c2))/1000				      *
*		Z1=(X1*sin(c2)-CZ*cos(c2))/1000				      *
*									      *
*		Y2=(Y1*cos(c3)+Z1*sin(c3))/1000				      *
*		Z2=(Y1*sin(c3)-Z1*cos(c3))/1000				      *
*	donde:								      *
*		C1,C2 y C3 son los valores de las rotaciones de los puntos    *
*		respecto a los tres ejes                                      *
*		CX,CY y CZ son las coordenadas de los puntos respecto a los   *
*		tres ejes                                                     *
*		X1,Y1 y Z1 son variables temporales                           *
*		y los resultados de las formulas de arriba se guardan en      *
*		X2,Y2 y Z2 para utilizarlos en la siguiente formula:          *
*		                                                              *
*		DISP_X=(X2*256)/(Z2+512)+160	                              *
*		DISP_Y=(Y2*256)/(Z2+512)+128                                  *
*		                                                              *
*	donde:                                                                *
*		DISP_X y DISP_Y son el resultado final de todas las formulas  *
*		y son las coordenas CX, XY y CZ convertidas a 2D	      *
*		512 es una valor variable que equivale a la distancia al punto*
*		de vista: cuanto mas grande sea este valor mas lejos estara   *
*		del punto de vista y cuanto mas pequenyo mas cerca.           *
*		160 y 128 son otros dos valores variables que situan el objeto*
*		en la pantalla.                                               *
*						                              *
*									      *
*	                                                                      *
*******************************************************************************

transfer:
	moveq.l	#0,d0			;despejamos todos los registros
	moveq.l	#0,d1			;de datos
	moveq.l	#0,d2
	moveq.l	#0,d3
	moveq.l	#0,d4
	moveq.l	#0,d5
	moveq.l	#0,d6
	moveq.l	#0,d7
	
	
Calc:
	move.w	NAng1,d5		;Num. de angulo 1 en d5
	move.w	NAng3,d6		;       "       2 en d6
	move.w	NAng2,d7		;       "	3 en d7
	move.l	#cos,a0			;cargamos lista de cosenos
	move.l	#sin,a1			;cargamos lista de senos
	move.l	#cx,a2			;cargamos listas de puntos (x)
	move.l	#cy,a3			;	      "		   (y)	
	move.l	#cz,a4			;             "		   (z)


* X1,Y1
	moveq.l	#0,d0			;calulamos X1 e Y1
	moveq.l	#0,d1
        move.l	(a2,d4),d0		
        move.l	(a3,d4),d1	
	muls	(a0,d5),d0	
	muls	(a1,d5),d1
	add.l	d0,d1
	asr.l	#8,d1
	asr.l	#2,d1
	move.l	d1,X1			;ya tenemos X1
	
	moveq.l	#0,d0
	moveq.l	#0,d1
	move.l	(a2,d4),d0
	move.l	(a3,d4),d1
	muls	(a1,d5),d0	
	muls	(a0,d5),d1
	sub.l	d1,d0
	asr.l	#8,d0
	asr.l	#2,d0
   	move.l	d0,Y1			;ya tenemos Y1	
	
* X2,Z1
	moveq.l	#0,d0			;calculamos X2,Z1
	moveq.l	#0,d1
        move.l	X1,d0		
        move.l	(a4,d4),d1	
	muls	(a0,d6),d0	
	muls	(a1,d6),d1
	add.l	d0,d1
	asr.l	#8,d1
	asr.l	#2,d1
	move.l	d1,X2			;ya tenemos X2
	
	moveq.l	#0,d0
	moveq.l	#0,d1
	move.l	X1,d0
	move.l	(a4,d4),d1
	muls	(a1,d6),d0	
	muls	(a0,d6),d1
	sub.l	d1,d0
	asr.l	#8,d0
	asr.l	#2,d0
	move.l	d0,Z1			;ya tenemos Z1	

* Y2,Z2
	moveq.l	#0,d0
	moveq.l	#0,d1
        move.l	Y1,d0		 	;calculamos Y2,Z2
        move.l	Z1,d1	
	muls	(a0,d7),d0	
	muls	(a1,d7),d1
	add.l	d0,d1
	asr.l	#8,d1
	asr.l	#2,d1
	move.l	d1,Y2			;ya tenemos Y2
	
	moveq.l	#0,d0
	moveq.l	#0,d1
	move.l	Y1,d0
	move.l	Z1,d1
	muls	(a1,d7),d0	
	muls	(a0,d7),d1
	sub.l	d1,d0
	asr.l	#8,d0
	asr.l	#2,d0
	move.l	d0,Z2			;ya tenemos Z2	


* CALCULAMOS EL EJE Z
	moveq.l	#0,d0
	moveq.l	#0,d1
	move.l	#disp_x,a2		;bloques de memoria reservados para
	move.l	#disp_y,a3		;guardar las coord. de pantalla
	
	move.l	X2,d2			;Calculamos la coordenada X en 2d
	muls	#256,d2			
	move.l	z2,d3
	add.l	#512,d3
	divs	d3,d2
	add.l	#160,d2
	move.w	d2,d0	
	
	
	move.l	Y2,d2			;Calculamos la coordenada Y en 2d
	muls	#256,d2
	move.l	z2,d3
	add.l	#512,d3
	divs	d3,d2
	add.l	#128,d2
	move.w	d2,d1	

	adda.l	d4,a2			;Salvamos las coordenadas 
	adda.l	d4,a3
	move.l	d0,(a2)
	move.l	d1,(a3)
	add.l	#4,d4
	cmp.w	num_pts,d4		;se acabaron los puntos? 
	bne.w	calc			;no.pues calcula otro
	rts

; Ahora empieza la rutina para trazar las lineas del objeto en la pantalla.
; La funcion "line rastportactual" llama a un macro definido al principio del
; programa y le pasa la variable rastportactual que contiene el rastport en
; el que tiene que dibujar (o sea en que pantalla tiene que dibujar el objeto)

drawlines:
	move.l	gfxbase,a6		;direccion base graphics.library
	moveq.l	#0,d5			;Incializamos contador
loop:	move.l	#disp_x,a0		;cargamos lista de coords X
	move.l	#disp_y,a2		;cargamos lista de coords Y
	move.l	#ejes1,a3		;cargamos lista de ejes
	move.l	#ejes2,a4		;
	move.w	(a3,d5),d0		;primer eje (desde)
	muls	#4,d0			;coordenada a coger
	move.l	d0,d1
	move.l	(a0,d0),d0		;primer punto		
	move.l	(a2,d1),d1
	
	move.w	(a4,d5),d2		;primer eje (hasta)
	muls	#4,d2			;coordenada a coger
	move.l	d2,d3	
	move.l	(a0,d2),d2		;segundo punto
	move.l	(a2,d3),d3
	line	rastportactual		;trazamos la linea
	addq.l	#2,d5			;siguiente eje
	cmp.w	num_lns,d5		;se acabaron las lineas?
	bne.B	loop			;no.siguiente linea

	;rotacion eje Z
	add.w	#4,Nang1		;si.siguiente angulo
	cmp.w	#360*2,NAng1		;ultimo angulo?
	bge.B	Restore1		;Si.->pues despeja la variable

sigue1: ;rotacion eje X						      	
	add.w	#8,Nang2		;idem de lo de arriba 
	cmp.w	#358*2,NAng2
	bge.B	Restore2	

sigue2: ;rotacion eje Y
	add.w	#4,Nang3		;idem de idem
	cmp.w	#360*2,NAng3
	bge.B	Restore3
sigue3:	
	rts

restore1:
	move.w	#0,Nang1		;despeja la variable 
	bra.B	sigue1			;y continua con el programa
restore2:
	move.w	#0,Nang2		;idem de lo de arriba
	bra.B	sigue2
restore3:
	move.w	#0,Nang3		;idem de idem (joder!)
	bra.B	sigue3

******************************************************************************
*                 H   A   S   T   A      A   Q   U   I 			     *
******************************************************************************

;----------------------------------------------------------------------
;              D E F I C I O N E S  D E L  B I T M A P
;-----------------------------------------------------------------------
bitmap:
bytesperrow:    
        blk.w 	1
bytes:  blk.w 	1
flags:  blk.b 	1
depth:  blk.b 	1
pad:    blk.w 	1
plane1: dc.l 	bitplane1
plane2: dc.l 	bitplane2
plane3: dc.l 	bitplane3
plane4: dc.l 	bitplane4
plane5: dc.l 	bitplane5
planes: blk.l 	1
bitplane1: 	blk.b 	10240 ;dimension de un plano en bytes
bitplane2: 	blk.b 	10240
bitplane3: 	blk.b 	10240
bitplane4: 	blk.b 	10240
bitplane5: 	blk.b 	10240
rastport:
        blk.l 	1,0
R_Bitmap:
        blk.l 	1
        blk.b 	102
        

bitmap2:
bytesperrow2:    
         blk.w 	1
bytes2:  blk.w 	1
flags2:  blk.b 	1
depth2:  blk.b 	1
pad2:    blk.w 	1
plane12: dc.l 	bitplane12
plane22: dc.l 	bitplane22
plane32: dc.l 	bitplane32
plane42: dc.l 	bitplane42
plane52: dc.l 	bitplane52
planes2: blk.l 	1
rastport2:
        blk.l 	1
R_Bitmap2:
        blk.l 	1
        blk.b 	102
bitplane12: 	blk.b 	10240 ;dimension de un plano en bytes
bitplane22: 	blk.b 	10240
bitplane32: 	blk.b 	10240
bitplane42: 	blk.b 	10240
bitplane52: 	blk.b 	10240

rastportactual:
	dc.l	0
view:	dc.l	0
;------------------------------------------------------------------------
;                     C  O  N  S  T  A  N  T  E  S
;------------------------------------------------------------------------
dosname:	
	dc.b	"dos.library",0
gfxname: 
	dc.b 	"graphics.library",0
	even
;------------------------------------------------------------------------
;                       V  A  R  I  A  B  L  E  S
;------------------------------------------------------------------------
oldcop:		
	dc.l	0
gfxbase:	
	dc.l	0
APen:	dc.w	0
LineY:	dc.w	0
Posx:	dc.w	0
planeaddress:
	dc.l	0
cop1adr:
	dc.l	0
cop2adr:
	dc.l	0
;------------------------------------------------------------------------
;  			      PALETA DE COLORES 
;------------------------------------------------------------------------
colortable:
	dc.w	$000f
	dc.w	$0fff
	dc.w	$0999
	dc.w	$0EEE
	dc.w	$0A30
	dc.w	$0F61
	dc.w	$0DA0
	dc.w	$0C80
	dc.w	$024D
	dc.w	$057F
	dc.w	$0293
	dc.w	$0260
	dc.w	$0C00
	dc.w	$0F21
	dc.w	$00c0
	dc.w	$0f00
	dc.w	$0000
	dc.w	$00C0
	dc.w	$0999
	dc.w	$0EEE
	dc.w	$0A30
	dc.w	$0F61
	dc.w	$0DA0
	dc.w	$0C80
	dc.w	$024D
	dc.w	$057F
	dc.w	$0293
	dc.w	$0260
	dc.w	$0C00
	dc.w	$0F21
	dc.w	$00c0
	dc.w	$0f00

;----------------------------------------------------------------------------
;              DATOS PARA LA CREACION Y ROTACION DEL OBJETO
;----------------------------------------------------------------------------
NAng1:	dc.w	0
NAng2:	dc.w	0
NAng3:	dc.w	0
CX:	dc.l	0,-50,-100,-150,-200,-125,-75,50,50,150,150,75,75,150
	dc.l	150,-100,75,20
CY:	dc.l	-50,-50,50,-50,-50,100,100,-50,100,100,65,65,0,0,-50,75,70,-55
CZ:	dc.l	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0

X1:	dc.l	0
X2:	dc.l	0
Y1:	dc.l	0
Y2:	dc.l	0
Z1:	dc.l	0
Z2:	dc.l	0

ejes1:	dc.w	0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,0
ejes2:	dc.w	1,2,3,4,5,6,0,8,9,10,11,12,13,14,7

num_pts:dc.w	18*4		
num_lns:dc.w	15*2
disp_x:	blk.l	18		;----> estos dos son los buffers que hay que
disp_y:	blk.l	18		;      cambiar. Se reserva tanta memoria de
				;      tipo "long word" como numero de 
				;      puntos haya.