home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 109 / EnigmaAmiga109CD.iso / software / testi / corsoasm / sorgenti5 / lezione9i5.s < prev    next >
Text File  |  1995-10-23  |  18KB  |  492 lines
  1.  
  2. ; Lezione9i5.s    Clipping di Bob a destra. (By Erra Ugo)
  3. ;        Tasto sinistro per uscire.
  4.  
  5.     section    CLippaD,code
  6.  
  7. ;    Include    "DaWorkBench.s"    ; togliere il ; prima di salvare con "WO"
  8.  
  9. *****************************************************************************
  10.     include    "Startup1.s" ; Salva Copperlist Etc.
  11. *****************************************************************************
  12.  
  13.         ;5432109876543210
  14. DMASET    EQU    %1000001111000000    ; copper,bitplane,blitter DMA
  15.  
  16.  
  17. ; Definiamo in queste equ le costanti relative al nostro bob...
  18.  
  19. XBob    equ    16*8    ; Dimenzione X del bob
  20. YBob    equ    29    ; Dimenzione Y del bob
  21. XWord    equ    8    ; Numero di word del bob
  22.  
  23. ; Definiamo il limiti delo schermo
  24.  
  25. XMax    =    320-64        ; Limite orizontale destro dello schermo
  26. XMin    =    0        ; Limite orizontale sinistro dello schermo
  27. YMax    =    200-YBob    ; Limite verticale inferiore dello schermo
  28. YMin    =    0        ; Limite verticale superiore dello schermo
  29.  
  30.  
  31. Start:
  32.     Lea    Screen,a0        ; prepariamo il puntatore
  33.     Move.l    a0,d0            ; al bitplane.
  34.     Move.w    d0,BPLPointer1+6
  35.     Swap    d0
  36.     Move.w    d0,BPLPointer1+2
  37.  
  38.     Lea    $dff000,a6        ; CUSTOM REGISTER in a5
  39.     Move.w    #DMASET,$96(a6)        ; DMACON - abilita bitplane, copper
  40.     Move.l    #CopperList,$80(a6)    ; Puntiamo la nostra COP
  41.     Move.w    d0,$88(a6)        ; Facciamo partire la COP
  42.     Move.w    #0,$1fc(a6)        ; Disattiva l'AGA
  43.     Move.w    #$c00,$106(a6)        ; Disattiva l'AGA
  44.     Move.w    #$11,$10c(a6)        ; Disattiva l'AGA
  45.  
  46.     Moveq    #100,d0        ; d0 e' la coordinata x
  47.     Move.w    #100,d1        ; d1 e' la coordinata y
  48.     Moveq    #0,d2        ; azzeriamo il resto dei registri dati
  49.     Moveq    #0,d3        ; bla bla bla
  50.     Moveq    #0,d4        ; bla bla
  51.     Moveq    #0,d5        ; bla
  52.     Moveq    #0,d6        
  53.     Moveq    #0,d7
  54.  
  55. Loop:
  56.     Cmpi.b    #$ff,$6(a6)
  57.     Bne.s    Loop
  58.  
  59.     Bsr.w    LeggiJoyst    ; La routine legge lo stato del joystick
  60.                 ; ed aggiorna x ed y direttamente nei registri
  61.                 ; d0 e d1.
  62.     Bsr.w    CheckLimit    ; Controlla se la routine e' nei limiti
  63.     Bsr.w    CancellaSchermo    ; pulisci lo schermo
  64.     Bsr.s    ClipBobRight    ; clippa il bob lo piazza a video
  65.     Btst    #6,$bfe001    ; Attende la pressione del tasto sinistro
  66.     Bne.s    Loop        ; ...
  67.     Rts
  68.  
  69. ; ****************************************************************************
  70. ; La tecnica decritta viene implementata nel seguente modo:
  71. ; 1)Se la coordinata in alto a destra e uscita dal limite massimo allora
  72. ;   non blitta nulla.
  73. ; 2)Calcola di quanti pixel il bob e' uscito fuori, nel seguente modo
  74. ;   Xout=(x+xdim)-XMax
  75. ; 3)Si calcola quindi esattamente di quante word il bob è uscito fuori e 
  76. ;   di quanti pixel, nel seguente modo XOut/16 e XOut mod 16.
  77. ; 4)A questo punto dalla tabella maskright preleviamo il valore
  78. ;   del registro BLTLWM tramite il valore XOut mod 16
  79. ; 5)Prepariamo il modulo A del blitter tramite l'operazione (XBob-XOut)/16
  80. ; ****************************************************************************
  81.  
  82. ;           . . . .
  83. ;          :¦:¦:¦:¦:¦       
  84. ;          ¦    ____l___    
  85. ;          |__  '______/    
  86. ;         _!\____,---.|     
  87. ;    .---/___ (¯°) °_||----.
  88. ;    |   \ \/\ ¯¯¯¯T  l_   |
  89. ;    |  _ \ \/\___,_)__ \  |
  90. ;    |  |  \ \/ /| | l/ /  |
  91. ;    |  |   \ \/¯T¯T¯/ /T  |
  92. ;    |  |    \_¯¯¯¯¯¯_/ |  |
  93. ;    |  |     `------'  |  |
  94. ;    |  l_______/¯¯)¯¯\_|  |
  95. ;    l_______l__  _(_  (___|
  96. ;    .. .  .   \___)___/ xCz
  97.  
  98. ClipBobRight:
  99.     Movem.l    d0-d7/a0,-(a7)
  100.     Cmpi.w    #XMax,d0    ; Confronta la coordinata in alto a sinistra
  101.                 ; con il XMax
  102.     Bge.w    ExitClipRight    ; se e' maggiore allora il bob e' completamente
  103.                 ; fuori, e quindi non facciamo nulla
  104.  
  105.     Move.w    #XBob,d7    ; d7=Dimensione del bob
  106.     Add.w    d0,d7        ; Sommo a d7 la coordinata x, quindi d7 e'
  107.                 ; uguale alla coordinata in alto a destra. 
  108.     Subi.w    #XMax,d7    ; Calcolo di quanti pixel il bob e'uscito fuori
  109.     Ble.w    IsInLeft    ; Se il risultato e' mimore di zero allora
  110.                 ; il bob e' uscito completamente fuori.
  111.  
  112.     Move.w    d7,d6        ; d7=d6=numero di pixel out
  113.     Lsr.w    #4,d6        ; d6=d6/16 numero di word out
  114.     Move.w    #XWord,d2    ; d2=numero di word del bob originariamente
  115.     Andi.w    #15,d7        ; d7=numero di pixel out
  116.  
  117.                 ; Adesso calcolo il nuovo valore di bltsize
  118.     Move.w    d2,d5        ; d5=numero di word del bob originariamente
  119.     Sub.w    d6,d2        ; d2 numero di word in
  120.     Move.w    #YBob,d3    ; Dimensione verticale in d3
  121.     Lsl.w    #6,d3        ; Moltiplico d3 per 64
  122.     Add.w    d2,d3        ; d3=bltsize ridotto
  123.  
  124.                 ; Calcoliamo il nuovo modulo della destinazione
  125.     Moveq    #40,d4        ; Per calcolare il nuovo modulo della
  126.                 ; destinazione. Non facciamo che sottrarre
  127.                 ; le dimensioni restanti del bob a 40.
  128.     Add.w    d5,d5        ; d5=d5*2 numero di byte del bob originariam.
  129.     Add.w    d6,d6        ; d6=d6*2 modulo di A in byte
  130.     Sub.w    d6,d5        ; d5=numero di byte out
  131.     Sub.w    d5,d4        ; d4=modulo di D
  132.  
  133.     Moveq    #-1,d5
  134.     Add.w    d7,d7        ; con d7 preleviamo il valore della maschera
  135.     Lea    MaskRight,a0    ; in a0 l'ind. della tabella
  136.     Move.w    (a0,d7.w),d5    ; d5=maskera    
  137.  
  138.     Mulu    #40,d1        ; Da qui blitting normale...
  139.     Move.w    d0,d2
  140.     Lsr.w    #3,d0    
  141.     Add.w    d0,d1    
  142.     Lea    Screen,a0
  143.     Adda.l    d1,a0
  144.     Andi.w    #$000f,d2
  145.     Ror.w    #4,d2        ; piu` efficente che fare LSL #4,d2 e
  146.                 ; poi LSL #8,D2
  147.     Ori.w    #$09f0,d2        
  148.  
  149.     Btst    #6,2(a6)
  150. WaitBlit1b:
  151.     Btst    #6,2(a6)    ; dmaconr - aspetta che il blitter sia libero
  152.     bne.s    WaitBlit1b
  153.  
  154.     Move.w    d2,$40(a6)    ; bltcon0
  155.     Move.l    d5,$44(a6)    ; bltafwm
  156.     Move.l    #Bob,$50(a6)    ; bltapt
  157.     Move.l    a0,$54(a6)    ; bltdpt
  158.     Move.w    d6,$64(a6)    ; bltamod
  159.     Move.w    d4,$66(a6)    ; bltdmod
  160.     Move.w    d3,$58(a6)    ; bltsize
  161.     Movem.l    (a7)+,d0-d7/a0
  162.     Rts
  163.  
  164. IsInLeft:
  165.     Mulu.w    #40,d1        ; In questo caso usufruiamo del blitter
  166.     Move.w    d0,d2        ; normalmente poiche' il bob si trova entro
  167.     Lsr.w    #3,d0        ; il limiti prefissati.
  168.     Add.w    d0,d1    
  169.     Lea    Screen,a0
  170.     Add.l    d1,a0
  171.     Andi.w    #$000f,d2
  172.     Ror.w    #4,d2
  173.     Ori.w    #$09f0,d2        
  174.  
  175.     Moveq    #-1,d7
  176.     Clr.w    d7
  177.  
  178.     Btst    #6,2(a6)
  179. WaitBlit1a:
  180.     Btst    #6,2(a6)    ; dmaconr - aspetta che il blitter sia libero
  181.     bne.s    WaitBlit1a
  182.  
  183.     Move.w    d2,$40(a6)    ; bltcon0
  184.     Move.w    #0,$42(a6)    ; bltcon1
  185.     Move.l    d7,$44(a6)    ; bltafwm
  186.     Move.l    #Bob,$50(a6)    ; bltapt
  187.     Move.l    a0,$54(a6)    ; bltdpt
  188.     Move.w    #-2,$64(a6)    ; bltamod
  189.     Move.w    #40-18,$66(a6)    ; bltdmod
  190.     Move.w    #(29*64)+(144/16),$58(a6)    ; bltsize
  191. ExitClipRight:
  192.     Movem.l    (a7)+,d0-d7/a0
  193.     Rts
  194.  
  195. ; ****************************************************************************
  196. ; Questa routine controlla che il bob non esca dai limti fisici dello
  197. ; schermo. Infatti abbiamo realizzato una routine che taglia le parti che
  198. ; escono al di fuori della nostra destra, ma non abbiamo fatto nulla per
  199. ; gli altri limiti dello schermo. Quindi questa routine controlla se le 
  200. ; coordinate sono sempre nel range giusto.
  201. ; ****************************************************************************
  202.  
  203. CheckLimit:
  204.     Cmpi.w    #XMin,d0    ; E' uscito dalla sinistra ?
  205.     Bge.s    Limit2        ; no, allora vedi sopra e sotto
  206.     Move.w    #XMin,d0    ; si, allora rimettilo nei nostri limiti
  207. Limit2:
  208.     Cmpi.w    #YMin,d1    ;E' uscito da sopra ?
  209.     Bge.s    Limit3        ;no,allora vedi sotto
  210.     Move.w    #YMin,d1    ;si, allora rimettilo nei limiti
  211.     Bra.s    End_Limit    ;e' euindi esci fuori poiche' il nostro bob non
  212.                 ;puo' stare contemporaneamente sopra e sotto.
  213. Limit3:
  214.     Cmpi.w    #YMax,d1    ; Come sopra ma controlliamo il limite
  215.     Blt.s    End_Limit    ; verticale in basso.
  216.     Move.w    #YMax,d1
  217. End_Limit
  218.     Rts
  219.  
  220.  
  221.  
  222. ; ****************************************************************************
  223. ; Questa routine legge il joystick e aggiorna i valori contenuti nelle
  224. ; variabili sprite_x e sprite_y
  225. ; ****************************************************************************
  226.  
  227. LeggiJoyst:
  228.     Move.w    $dff00c,D3    ; JOY1DAT
  229.     Btst.l    #1,D3        ; il bit 1 ci dice se si va a destra
  230.     Beq.s    NODESTRA    ; se vale zero non si va a destra
  231.     Addq.w    #1,d0        ; se vale 1 sposta a di un pixel lo sprite
  232.     Bra.s    CHECK_Y        ; vai al controllo della Y
  233. NODESTRA:
  234.     Btst    #9,D3        ; il bit 9 ci dice se si va a sinistra
  235.     Beq.s    CHECK_Y        ; se vale zero non si va a sinistra
  236.     Subq.w    #1,d0        ; se vale 1 sposta lo sprite
  237. CHECK_Y:
  238.     Move.w    D3,D2        ; copia il valore del registro
  239.     Lsr.w    #1,D2        ; fa scorrere i bit di un posto verso destra 
  240.     Eor.w    D2,D3        ; esegue l'or esclusivo. Ora possiamo testare
  241.     Btst    #8,D3        ; testiamo se va in alto
  242.     Beq.s    NOALTO        ; se no controlla se va in basso
  243.     Subq.w    #1,d1        ; se si sposta lo sprite
  244.     Bra.s    ENDJOYST
  245. NOALTO:
  246.     Btst    #0,D3        ; testiamo se va in basso
  247.     Beq.s    ENDJOYST    ; se no finisci
  248.     Addq.w    #1,d1        ; se si sposta lo sprite
  249. ENDJOYST:
  250.     Rts
  251.  
  252. ;****************************************************************************
  253. ; Questa routine cancella lo schermo mediante il blitter.
  254. ;****************************************************************************
  255.  
  256. CancellaSchermo:
  257.     btst    #6,2(a6)
  258. WBlit3:
  259.     btst    #6,2(a6)         ; attendi che il blitter abbia finito
  260.     bne.s    wblit3
  261.  
  262.     move.l    #$01000000,$40(a6)    ; BLTCON0 e BLTCON1: Cancella
  263.     move.w    #$0000,$66(a6)        ; BLTDMOD=0
  264.     move.l    #Screen,$54(a6)        ; BLTDPT - indirizzo schermo
  265.     move.w    #(64*256)+20,$58(a6)    ; BLTSIZE (via al blitter !)
  266.                     ; cancella tutto lo schermo
  267.  
  268.     rts
  269.  
  270. ; ****************************************************************************
  271.  
  272.         section    cop,data_C
  273.  
  274. copperlist
  275.     dc.w    $8E,$2c81    ; DiwStrt
  276.     dc.w    $90,$2cc1    ; DiwStop
  277.     dc.w    $92,$38        ; DdfStart
  278.     dc.w    $94,$d0        ; DdfStop
  279.     dc.w    $102,0        ; BplCon1
  280.     dc.w    $104,0        ; BplCon2
  281.     dc.w    $108,0        ; Bpl1Mod
  282.     dc.w    $10a,0        ; Bpl2Mod
  283.  
  284.     dc.w $100,$1200        ; BPLCON0 - 2 bitplanes lowres
  285.  
  286.     dc.w $180,$000    ; Color0
  287.     dc.w $182,$aaa    ; Color1
  288.  
  289. BPLPOINTER1:
  290.     dc.w $e0,0,$e2,0    ;primo     bitplane
  291.  
  292.     dc.l    $ffff,$fffe    ; fine della copperlist
  293.  
  294. ******************************************************************************
  295.  
  296. ; il bob e' ad 1 bitplane, largo 128 pixel e alto 29 linee
  297.  
  298. Bob:
  299.     Incbin    "Amiga.bmp"
  300.  
  301. ; ****************************************************************************
  302.  
  303. ; Questa e' la tabella che ci serve per "mozzare" i pixel indesiderati.
  304.  
  305. MaskRight:
  306.     dc.w    %1111111111111111
  307.     dc.w    %1111111111111110
  308.     dc.w    %1111111111111100
  309.     dc.w    %1111111111111000
  310.     dc.w    %1111111111110000
  311.     dc.w    %1111111111100000
  312.     dc.w    %1111111111000000
  313.     dc.w    %1111111110000000
  314.     dc.w    %1111111100000000
  315.     dc.w    %1111111000000000
  316.     dc.w    %1111110000000000
  317.     dc.w    %1111100000000000
  318.     dc.w    %1111000000000000
  319.     dc.w    %1110000000000000
  320.     dc.w    %1100000000000000
  321.     dc.w    %1000000000000000
  322.  
  323. ; ****************************************************************************
  324.  
  325.     Section Miobuffero,BSS_C
  326.  
  327. Screen:
  328.         ds.b    (320*256)/8
  329.  
  330.     end
  331.  
  332.  Questo breve programma mostra come sia possibile attraverso il blitter 
  333.  effettuare il clipping di bob, utile in molti videogiochi. Innanzitutto
  334.  vediamo cos'è il clipping in generale. Le routine di clipping sono famose
  335.  sopratutto nella grafica 2d e anche 3d, infatti capita spesso di dover
  336.  tracciare line che escono al di fuori della memoria video disponibile, ad
  337.  esempio, si pensi ad un linea che abbia una coordinata (300,450) e che si 
  338.  debba disegnare in un aria video di 320x256, si nota immediatamente che
  339.  la linea se disegnata con un qualunque algoritmo, quest' ultimo potrebbe
  340.  scrivere in una zona di memoria riserveta ad esempio per il codice e 
  341.  quindi mandare in crash la macchina. Lo stesso discorso vale per i bob.
  342.  Infatti supponiamo di avere un' area video di dimensioni 320x256, e un bob
  343.  di 64x20 pixel, ebbene il nostro verra piazzato a video basandoce sulla
  344.  coordinate in alto a sinistra(puo' anche essere un' altra coordinata) siano
  345.  esse x e y. Attraverso il blitter potremo piazzare questo bob in un qualunque
  346.  punto dell'area disponibile, ma cosa accade se piazziamo il nostro bob
  347.  nel punto di coordinata ad esempio (300,120). Osserviamo il disegno
  348.  
  349.  
  350.   (0x0) _______________________
  351.     |            |
  352.     |            |
  353.     |       (300x120) ___|___
  354.     |            |    |   |
  355.     |            | A    | B |
  356.     |            |___|___|
  357.     |            |
  358.     |            |
  359.     |            |
  360.     |            |
  361.     |_______________________|(320x256)
  362.  
  363.  
  364.  
  365.  Come si vede la porsione del bob "B" non entra nell'area video ed esce
  366.  al di fuori. La domanda e' "Ma dove và esattamente?", la risposta e' 
  367.  "dipende dai casi". Infatti supponiamo sempre di avere un' area video
  368.  di 320x256 ad 1 bitplane, ebbene finchè ci manteniamo in un range di 
  369.  coordinate non c'e' nessun rischio che il blitter rovini zone di memorie
  370.  particolari, infatti la porzione di bob uscita fuori rientrera' della
  371.  sinistra, ma di un pixel piu' in basso cioe' avverà una cosa del genere.
  372.  
  373.  
  374.  
  375.   (0x0) _______________________
  376.     |            |
  377.     |            |
  378.     |       (300x120) ___|
  379.     |___            |    |
  380.     |   |            | A    |
  381.     | B |            |___|
  382.     |___|            |
  383.     |            |
  384.     |            |
  385.     |            |
  386.     |_______________________|(320x256)
  387.  
  388.  
  389.  Basti pensare al fatto che la memoria e' sequenziale, quindi arrivati
  390.  all' ultima word di una riga la succesiva word sara' la prima della riga
  391.  successiva. Quindi in questo caso si vede che c'è un rischio per i
  392.  nostri dati o il nostro codice, ma supponiamo che la cordinata sia
  393.  tremendamente vicina alla (320,256), in questo caso rischiamo davvero
  394.  grosso! In ogni modo resta un fatto, quella porzione di bob e' antiestetica.
  395.  Avete mai visto un gioco in cui i bob che escono dalla destra entrano dalla
  396.  sinitra alla Silvan ? Ci sono varie soluzion per eliminare quella porzione
  397.  di bob diventata inutile e pericolosa. Una potrebbe essere quella di fare
  398.  un area video piu' grande, cioe' aggiungere dei delle zone di sicurezza a
  399.  destra e a sinistra della memoria video. Cioe' una cosa di questo genere:
  400.  
  401.  
  402.  
  403.  
  404.        _______________________________________
  405.     |\\\\\\\|            |\\\\\\\|    
  406.     |\\\\\\\|            |\\\\\\\|
  407.     |\\\\\\\|               |\\\\\\\|
  408.     |\\\\\\\|                |\\\\\\\|
  409.     |\\\\\\\|                |\\\\\\\|
  410.     |\\\\\\\|                |\\\\\\\|  
  411.     |\\\\\\\|            |\\\\\\\|
  412.     |\\\\\\\|            |\\\\\\\|
  413.     |\\\\\\\|            |\\\\\\\|
  414.     |\\\\\\\|            |\\\\\\\|
  415.     |\\\\\\\|_______________________|\\\\\\\|
  416.        
  417.  
  418.        |\\\|
  419.        |\\\| <- Area di memoria di sicurezza
  420.        |\\\|
  421.  
  422.  
  423.  Come si vede dal disegno, questa soluzione ci garantisce due cose: la prima
  424.  e' che le porzioni di bob superflue non intaccheranno i nostri dati e la 
  425.  seconda che quelle porzioni non rientreranno dalla sinistra. Ma facciamo un
  426.  po' i conti... le dimensioni di quelle aree dovranno essere al piu' uguali
  427.  alla dimesione orizontale massima dei bob, quindi se abbiamo un bob che ha
  428.  dimensione massima orizontale 128 pixel ed inoltre lo adoperiamo in un
  429.  contesto di 5 bitplane avremo bisogno di 2 aree di ((256x128)/8)*5=20480
  430.  cioè in totale 40960, inoltre dobbiamo considerare anche le aree di
  431.  sicurezza che si dovrebbero porre in alto ed in basso della nostra area
  432.  video, quindi l'occupazione di memoria sarebbe troppa.
  433.  La soluzione quindi va cercata in un algoritmo che sia in grado di prelevare
  434.  le porzioni di bob che a noi interessano in quel momento e di scriverle
  435.  nelle zone di memoria corrette. Il tutto puo' essere fatto col blitter.
  436.  Quindi il programma mostra come sia possibile realizzarlo partendo da
  437.  alcune considerazioni. Innanzitutto se il nostro bob deve essere piazzato ad
  438.  una coordinata tale che tutto il bob rientra nella memoria video allora
  439.  questo lo si puo' fare con una classica routine per spostare un bob col
  440.  blitter. Le varianti avvengono quando la coordinata xb in basso a destra 
  441.  coincide con il limite massimo della memoria video e la supera totalmente.
  442.  Prepariamoci per un ragionamento abbastanza intreccioso. 
  443.  Sia XM la coordinata limite della nostra area video d'ora in poi finestra,
  444.  ed inoltre supponiamo che XM sia un multiplo di 16 pixel(per comodita')
  445.  quindi facciamo delle osservazioni. Il nostro bob quando coincidera' con XM,
  446.  la coordinata xa in alto a sinistra sara' anch'essa un multiplo di 16 pixel,
  447.  poiche' il bob ha dimensione orizzontale multipla di 16 pixel. Infatti
  448.  se abbiamo un bob di 64 pixel ed XM=320 allora quando xb coincidera' con XM
  449.  si avra'  che xa=320-64=256 che e' ancora un multiplo di 16, questo significa
  450.  che se il nostro bob si sposta solamente di un'altro pixel xb sara' uguale 
  451.  a XM+1 ma la cosa importante e' che andremo a scrivere nel primo bit della 
  452.  word successiva a (XM/16) nel nostro esempio essendo XM=320 la word che 
  453.  invaderemo sara' la 41-nesima. Se avete capito questo allora avete superato
  454.  il peggio e se qualcuno di voi ha sperimentato moltissimo col blitter forse
  455.  già vede la soluzione del problema. Infatti quello che dobbiamo fare ora e'
  456.  impedire che il blitter scriva nella word invasa questo l'ho realizziamo 
  457.  molto semplicemente col registro del blitter BLTLWM settendolo a 
  458.  "1111111111111110", in questo modo gli ultimi bit dell'ultima word del nostro
  459.  bob non verrano copiati. Se il nostro bob si sposterà di un'altro pixel
  460.  allora la word sarà settata a "1111111111111100". Ma cosa accade se il nostro
  461.  bob esce di 16 pixel in piu' dalla finestra video ? E' evidente che non
  462.  possiamo piu' utilizzare il registro BLTLWM ma dobbiamo usufruire anche del
  463.  modulo. Se noi abbiamo un bob non in formato RAW le informazioni sono 
  464.  memorizzate una di seguito all'altra, quindi settiamo il modulo della 
  465.  sorgente a zero se ora il nostro bob e' uscito di 16 pixel fuori, allora 
  466.  dobbiamo dire al nostro blitter una cosa di questo genere: il mio bob
  467.  ha oramai dimensione x-16 e altezza y quindi leggi x-16 bit e subito dopo
  468.  saltane 16(quelli fuori dalla finestra video), invece quando scrivi, scrivine
  469.  x-16 e poi salta di 320-(x-16) pixel. E' evidenete che non parliamo al 
  470.  blitter in questo modo, e ne in termini di pixel ma spero di avervi fatto
  471.  capire. Quindi unendo le due tecniche della mascherazione dei bit indesiderati
  472.  e del salto delle informazioni inutili tramite il modulo riusciamo a fare
  473.  un clipping di bob velocemente, logicamente impieghiamo meno tempo a non
  474.  farlo ma pensiamo anche al fatto che in questo modo piu' porzione di bob
  475.  esce fuori e' piu' il blitter termina il lavoro di copia.
  476.  
  477.  Tramite joystick potete spostare un bob di 128x29 pixel, provate a cambiare
  478.  la coordinata XMax(deve essere multiplo di 16).
  479.  
  480.  In questo esempio ci limitiamo ad illustrare la tecnica del "taglio" del bob
  481.  senza preoccuparci dello sfondo. Infatti disegnamo il nostro bob mediante una
  482.  semplice copia. Inoltre per non complicare il listato, eseguiamo ogni volta
  483.  una cancellazione dell'intero schermo invece che del solo rettangolo che
  484.  racchiude il bob.
  485.  Potete provare voi ad estendere questa tecnica all'esempio del bob completo
  486.  (cioe` con ripristino dello sfondo). In questo caso dovete tenere presente
  487.  che quando il bob viene "tagliato" a destra bisogna variare il modulo e la
  488.  dimensione della blittata non solo nella routine di disegno del bob (come
  489.  avviene in questo esempio) ma anche nelle routine di salvataggio e ripristino
  490.  dello sfondo.
  491.  
  492.