home *** CD-ROM | disk | FTP | other *** search
/ Fujiology Archive / fujiology_archive_v1_0.iso / !FALCON / LINEOUT / DELTA.ZIP / DELTASRC.ZIP / DELTA.SRC / DSPSNIL2.SO < prev    next >
Text File  |  2003-01-01  |  13KB  |  693 lines
  1. ; Textured pretzel. A delta screen. Made with u-fly.
  2.  
  3. ; You can change these, to your liking.
  4. Pretzel.IN:        =    600        ; inner pretzel radius
  5. Pretzel.OUT:        =    1500        ; outer pretzel radius
  6. Pretzel.NORMAL_DIV:    =    $100        ; inverse normal scalar (8:8)
  7. Pretzel.RINGS:        =    10
  8. Pretzel.SLICES:        =    40
  9.  
  10. ; Do not change these!
  11. Pretzel.VERTICES:    =    Pretzel.RINGS*Pretzel.SLICES
  12. Pretzel.POLYS:        =    Pretzel.RINGS*Pretzel.SLICES
  13.  
  14.             RSRESET
  15. Pretzel.object:        RS.W    8192
  16. Pretzel.BLOCK_SIZE:    RS.B    0
  17.  
  18. ******** OBJECT TABLE ********
  19.  
  20. * Must be first in object!!
  21. Pretzel.table:
  22.     DC.L    Pretzel.mainLoop
  23.     DC.L    Pretzel.init
  24.     DC.L    rts
  25.     DC.L    Pretzel.invRot
  26.     DC.L    Pretzel.incXRot
  27.     DC.L    Pretzel.decXRot
  28.     DC.L    Pretzel.incYRot
  29.     DC.L    Pretzel.decYRot
  30.     DC.L    Pretzel.setZoomOut
  31.     DC.L    0
  32.  
  33.     IFND    DEMO_SYSTEM
  34.     INCLUDE    HFLY_DSP.S                * Include the CPU-DSP engine.
  35.     TEXT
  36.     ENDC
  37.  
  38. ******** INIT SUBROUTINE ********
  39.  
  40. * OUTPUT: d0.l: 0   = All clear.
  41. *               neg = Error! Not initialized!
  42. Pretzel.init:
  43.     move.l    #Pretzel.BLOCK_SIZE,d0
  44.     bsr.l    Mem.register
  45.  
  46.     lea    sine_tbl,a1
  47.     bsr.l    Matrix.init
  48.  
  49. .success:
  50.     moveq    #0,d0
  51.     rts
  52. .error:    moveq    #-1,d0
  53.     rts
  54.  
  55. ******** SCREENINIT SUBROUTINE ********
  56.  
  57. Pretzel.initRealtime:
  58.     bsr.l    Mem.getBlock
  59.     move.l    d0,Pretzel.baseAdr
  60.  
  61. ; Init u fly..
  62.     bsr.l    HumanFly.init
  63.  
  64.     lea    Viewport.settingsTable,a0
  65.     move.w    #320,Viewport.XSCREEN(a0)
  66.     move.w    #200,Viewport.YSCREEN(a0)
  67.     move.w    #0,Viewport.XSTART(a0)
  68.     move.w    #0,Viewport.YSTART(a0)
  69.     move.w    #320,Viewport.XEND(a0)
  70.     move.w    #200,Viewport.YEND(a0)
  71.     move.w    #160,Viewport.XCENTER(a0)
  72.     move.w    #100,Viewport.YCENTER(a0)
  73.     move.w    #256+32,Viewport.ASPECT(a0)
  74.     move.w    #$100,Viewport.FOCAL(a0)
  75.     bsr.l    Viewport.update
  76.  
  77.     lea    textureTable,a0
  78.     bsr.l    Polygon.init
  79.  
  80.     bsr.l    ObjectRegistry.clear
  81.  
  82.     movea.l    Pretzel.baseAdr,a0
  83.     adda.l    #Pretzel.object,a0
  84.     bsr.w    Pretzel.generate
  85. ; d0.l=size
  86.     movea.l    Pretzel.baseAdr,a0
  87.     adda.l    #Pretzel.object,a0
  88.     bsr.l    ObjectRegistry.set
  89.     tst.w    d0
  90.     bmi.s    .error
  91.  
  92.     move.w    #+1,Pretzel.rotDir
  93.     clr.w    Pretzel.oldRot
  94.     clr.w    Pretzel.zoomActive
  95.     clr.w    Pretzel.xDir
  96.     clr.w    Pretzel.yDir
  97.  
  98.     clr.l    d0
  99.     move.w    monitormode,d1
  100.     cmpi.w    #vga60,d1
  101.     beq.s    .vga60
  102.     cmpi.w    #vga100,d1
  103.     beq.s    .vga100
  104.     cmpi.w    #rgb50,d1
  105.     beq.s    .rgb50
  106. * Unknown monitormode..
  107.     rts
  108. .vga60:    move.l    #vga60_16bit_320_200,Pretzel.resRout
  109.     rts
  110. .vga100:move.l    #vga100_16bit_320_200,Pretzel.resRout
  111.     rts
  112. .rgb50:    move.l    #rgb50_16bit_320_200,Pretzel.resRout
  113.     rts
  114.  
  115. .error:    moveq    #-1,d0
  116.     rts
  117.  
  118. Pretzel.initScreen:
  119.     lea    Viewport.settingsTable,a0
  120.     movem.w    Viewport.XSTART(a0),d0/d6
  121.     movem.w    Viewport.YSTART(a0),d1/d7
  122.     moveq    #$00000000,d4
  123.     bsr.l    Viewport.paintRectangle
  124.     rts
  125.  
  126. ******** MAINLOOP SUBROUTINE ********
  127.  
  128. Pretzel.mainLoop:
  129.     movea.l    scr,a0
  130.     bsr.l    Primitive.setScreenbuffer
  131.  
  132.     move.l    frmcnt,d0
  133.     sub.l    lastframecount,d0
  134.     bne.s    .end_realtime_init
  135.     move.l    d0,-(sp)
  136.     bsr.w    Pretzel.initRealtime
  137.     move.l    (sp)+,d0
  138. .end_realtime_init:
  139.     cmpi.l    #3,d0
  140.     bhs.s    .end_screeninit
  141.     bsr.l    Pretzel.initScreen
  142. .end_screeninit:
  143.  
  144.     bsr.w    Pretzel.zoom
  145.  
  146.     move.w    Pretzel.xDir,d2
  147.     beq.s    .x_done
  148.     move.w    $04BC.w,d0
  149.     move.w    Pretzel.xRotTime,d1
  150.     sub.w    d1,d0
  151.     add.w    d0,d0
  152.     cmpi.w    #sintbllen/8,d0
  153.     blt.s    .x_ok
  154.     move.w    #sintbllen/8,d0
  155.     clr.w    Pretzel.xDir
  156. .x_ok:    muls.w    d2,d0
  157.     add.w    Pretzel.oldXRot,d0
  158.     move.w    d0,Pretzel.xRot
  159. .x_done:
  160.     move.w    Pretzel.yDir,d2
  161.     beq.s    .y_done
  162.     move.w    $04BC.w,d0
  163.     move.w    Pretzel.yRotTime,d1
  164.     sub.w    d1,d0
  165.     add.w    d0,d0
  166.     cmpi.w    #sintbllen/8,d0
  167.     blt.s    .y_ok
  168.     move.w    #sintbllen/8,d0
  169.     clr.w    Pretzel.yDir
  170. .y_ok:    muls.w    d2,d0
  171.     add.w    Pretzel.oldYRot,d0
  172.     move.w    d0,Pretzel.yRot
  173. .y_done:
  174. ;    move.w    $04BC.w,Pretzel.xRot
  175.  
  176.     bsr.w    Pretzel.paint
  177.     
  178.     lea    scr,a0
  179.      move.l    (a0)+,d0
  180.     move.l    (a0)+,d1
  181.     move.l    (a0),-(a0)
  182.     move.l    d0,4(a0)
  183.     move.l    d1,-(a0)
  184.  
  185.     movea.l    Pretzel.resRout,a0
  186.     suba.l    a1,a1
  187.     movea.l    d0,a2
  188. .again:    bsr.l    Screen.requestUpdate
  189.     tst.l    d0
  190.     bmi.s    .again
  191.     clr.l    Pretzel.resRout
  192.     rts
  193.  
  194. ;======= subroutines
  195.  
  196. Pretzel.invRot:
  197.     neg.w    Pretzel.rotDir
  198.     move.w    $04BC.w,Pretzel.rotSwapTime
  199.     move.w    Pretzel.rot,Pretzel.oldRot
  200.     rts
  201.  
  202. Pretzel.incXRot:
  203.     move.w    #+1,Pretzel.xDir
  204.     move.w    Pretzel.xRot,Pretzel.oldXRot
  205.     move.w    $04BC.w,Pretzel.xRotTime
  206.     rts
  207.  
  208. Pretzel.decXRot:
  209.     move.w    #-1,Pretzel.xDir
  210.     move.w    Pretzel.xRot,Pretzel.oldXRot
  211.     move.w    $04BC.w,Pretzel.xRotTime
  212.     rts
  213.  
  214. Pretzel.incYRot:
  215.     move.w    #+1,Pretzel.yDir
  216.     move.w    Pretzel.yRot,Pretzel.oldYRot
  217.     move.w    $04BC.w,Pretzel.yRotTime
  218.     rts
  219.  
  220. Pretzel.decYRot:
  221.     move.w    #-1,Pretzel.yDir
  222.     move.w    Pretzel.yRot,Pretzel.oldYRot
  223.     move.w    $04BC.w,Pretzel.yRotTime
  224.     rts
  225.  
  226. Pretzel.setZoomOut:
  227.     not.w    Pretzel.zoomActive
  228.     move.l    $04BA.w,Pretzel.zoomStart
  229.     rts
  230.  
  231. Pretzel.zoom:
  232.     tst.w    Pretzel.zoomActive
  233.     beq.s    .no_zoom
  234.     move.l    $04BA.w,d0
  235.     sub.l    Pretzel.zoomStart,d0
  236.     move.w    d0,d1
  237.     lsl.l    #4,d0
  238.     addi.w    #11000,d0
  239.     move.w    d0,Pretzel.z
  240.     mulu.w    d1,d1
  241.     lsr.l    #8,d1
  242.     move.l    d1,d2
  243.     move.l    d1,d3
  244.     mulu.w    #5,d2
  245.     lsr.l    d2
  246.     mulu.w    #7,d3
  247.     lsr.l    d3
  248.     movem.w    d1-d3,Pretzel.rotTable
  249.     rts
  250.  
  251. .no_zoom:
  252.     move.w    #11000,Pretzel.z
  253.     rts
  254.  
  255. ; 0<=phi<2pi, 0<=theta<2pi
  256. ;
  257. ; a.x=r(phi, theta)*cos(2*theta)
  258. ; a.y=r(phi, theta)*sin(2*theta)
  259. ; a.z=IN*sin(phi)+OUT*sin(theta)
  260. ;
  261. ; r(phi, theta)=OUT+IN*cos(phi)+OUT*cos(theta/2)^2
  262. ;
  263. ; INPUT:
  264. ; d0.w=r
  265. ; a0: objectbuffer
  266. ; OUTPUT:
  267. ; d0.l=size
  268. Pretzel.generate:
  269.     movea.l    a0,a6
  270.  
  271. ; Output vertices..
  272.     lea    sine_tbl,a1
  273.     move.w    d0,.radius
  274.     move.w    #2*Pretzel.VERTICES,(a0)+        ; #vertices+#normals
  275.     move.w    #Pretzel.VERTICES,(a0)+            ; #normals
  276.     movea.l    a0,a4                    ; a4: vertices
  277.     lea    Pretzel.VERTICES*Vertex.SIZE(a0),a0
  278.     moveq    #Pretzel.RINGS-1,d7
  279.  
  280. .ring_loop:
  281.     moveq    #Pretzel.SLICES-1,d6
  282.     move.w    d7,d0
  283.     mulu.w    #sintbllen/Pretzel.RINGS,d0
  284. ; d0.w=phi
  285.     Get_Cos    a1,d0,d2
  286.     muls.w    #Pretzel.IN*2,d2
  287.     swap    d2
  288.     addi.w    #Pretzel.OUT,d2
  289. ; d2.w=OUT+IN*cos(phi)
  290.  
  291. .point_loop:
  292.     move.w    d6,d0
  293.     mulu.w    #sintbllen/(Pretzel.SLICES*2),d0
  294. ; d0.w=theta/2
  295.     Get_Cos    a1,d0,d0
  296.     move.w    d0,d1
  297. ; d1.w=cos(theta/2)
  298.     muls.w    #Pretzel.OUT*2,d1
  299.     swap    d1
  300. ; d1.w=OUT*cos(theta/2)
  301.     muls.w    d0,d1
  302.     add.l    d1,d1
  303.     swap    d1
  304. ; d1.w=OUT*cos(theta/2)^2
  305.     move.w    d2,d3
  306.     add.w    d1,d3
  307. ; d2.w=r(phi, theta)
  308.  
  309. ; z....
  310.     move.w    d7,d0
  311.     mulu.w    #sintbllen/Pretzel.RINGS,d0
  312. ; d0.w=phi
  313.     Get_Sin    a1,d0,d0
  314.     muls.w    #Pretzel.IN*2,d0
  315. ; d0.l=IN*sin(phi)
  316.     move.w    d6,d1
  317.     mulu.w    #sintbllen/Pretzel.SLICES,d1
  318. ; d1.w=theta
  319.     Get_Sin    a1,d1,d1
  320.     muls.w    #Pretzel.OUT*2,d1
  321. ; d1.l=OUT*sin(theta)
  322.     add.l    d0,d1
  323.     swap    d1
  324.     move.w    d1,-(a0)
  325.  
  326.     move.w    d6,d0
  327.     mulu.w    #2*sintbllen/Pretzel.SLICES,d0
  328.     Do_SinModulo    d0
  329. ; d0.w=theta*2
  330.     Get_SinCos    a1,d0,d0,d1
  331.     muls.w    d3,d0
  332.     muls.w    d3,d1
  333.     add.l    d0,d0
  334.     add.l    d1,d1
  335.     swap    d0
  336.     swap    d1
  337. ; y
  338.     move.w    d1,-(a0)
  339. ; x
  340.     move.w    d0,-(a0)
  341.  
  342.     dbf    d6,.point_loop
  343.  
  344.     dbf    d7,.ring_loop
  345.  
  346.     lea    Pretzel.VERTICES*Vertex.SIZE*2(a0),a0
  347.  
  348. ; Calculate normals! Uses the output vertices for this.
  349. ;
  350. ; n = o/|o|, normal is outward vector normalized to unit-length.
  351. ; -   -  -
  352. ;
  353. ; o = (u[i-1, j] + u[i, j]) X (v[i, j-1] + v[i, j])
  354. ; -    -           -           -           -
  355. ;
  356. ; u[i, j] = a[i+1, j]-a[i, j], v[i, j] = a[i, j+1]-a[i, j]
  357. ; -         -         -                  -         -
  358. ;
  359. ; o = (a[i+1, j]-a[i-1, j]) X (a[i, j+1]-a[i, j-1])
  360. ; -    -         -             -         -
  361. ;
  362. ;             [l.z*r.y-l.y*r.z]
  363. ; o = l X r = [l.x*r.z-l.z*r.x]
  364. ; -   -   -   [l.y*r.x-l.x*r.y]
  365. ;
  366. ; i, j are discrete versions of phi, theta.
  367. ;
  368. ; u[I+i, j]=u[i, j], v[i, J+j]=v[i, j], where I, J are #steps of i, j.
  369. ; -         -        -         -
  370. ;
  371. ; I.e. u and v wrap around.
  372. ;      -     -
  373. ;
  374.     moveq    #Pretzel.RINGS-1,d7
  375.  
  376. .normal_rloop:
  377.     moveq    #Pretzel.SLICES-1,d6
  378.  
  379. .normal_ploop:
  380. ; First, we calc l..
  381. ;                -
  382.     move.w    d7,d3
  383.     mulu.w    #Pretzel.SLICES,d3
  384.     clr.l    d4
  385.     move.w    d6,d4
  386.     addq.w    #1,d4
  387.     divu.w    #Pretzel.SLICES,d4
  388.     swap    d4                    ; d4.w=wrapped i+1
  389.     add.w    d4,d3                    ; d3.l=offset [i+1, j]
  390.     mulu.w    #Vertex.SIZE,d3
  391.     movem.w    (a4,d3.l),d0-d2
  392. ; d0-d2=a[i+1,j]
  393. ;       -
  394.     move.w    d7,d3
  395.     mulu.w    #Pretzel.SLICES,d3
  396.     clr.l    d4
  397.     move.w    d6,d4
  398.     subq.w    #1,d4
  399.     bpl.s    .i_pos
  400.     moveq    #Pretzel.SLICES-1,d4
  401. .i_pos:    add.w    d4,d3                    ; d3.l=offset [i-1, j]
  402.     mulu.w    #Vertex.SIZE,d3
  403.     sub.w    Vertex.X(a4,d3.l),d0
  404.     sub.w    Vertex.Y(a4,d3.l),d1
  405.     sub.w    Vertex.Z(a4,d3.l),d2
  406. ; d0-d2=a[i+1,j]-a[i-1,j]=l
  407. ;       -        -        -
  408.  
  409. ; Store l on stack.
  410. ;       -
  411.     movem.w    d0-d2,-(sp)
  412.  
  413. ; Now, we calc r..
  414. ;              -
  415.     clr.l    d3
  416.     move.w    d7,d3
  417.     addq.w    #1,d3
  418.     divu.w    #Pretzel.RINGS,d3
  419.     swap    d3
  420.     mulu.w    #Pretzel.SLICES,d3
  421.     add.w    d6,d3                    ; d3.l=offset [i, j+1]
  422.     mulu.w    #Vertex.SIZE,d3
  423.     movem.w    (a4,d3.l),d0-d2
  424. ; d0-d2=a[i,j+1]
  425. ;       -
  426.     move.w    d7,d3
  427.     subq.w    #1,d3
  428.     bpl.s    .j_pos
  429.     moveq    #Pretzel.RINGS-1,d3
  430. .j_pos:    mulu.w    #Pretzel.SLICES,d3
  431.     add.w    d6,d3                    ; d3.l=offset [i, j-1]
  432.     mulu.w    #Vertex.SIZE,d3
  433.     sub.w    Vertex.X(a4,d3.l),d0
  434.     sub.w    Vertex.Y(a4,d3.l),d1
  435.     sub.w    Vertex.Z(a4,d3.l),d2
  436.     
  437. ; d0-d2=a[i,j+1]-a[i,j-1]=r
  438. ;       -        -        -
  439.  
  440. ; Now we calculate the outward vector o.
  441. ;                                     -
  442. ;             [l.z*r.y-l.y*r.z]
  443. ; o = l X r = [l.x*r.z-l.z*r.x]
  444. ; -   -   -   [l.y*r.x-l.x*r.y]
  445. ;
  446.     movem.w    (sp),d3-d5
  447.  
  448. ; d3-d5=l
  449. ;       -
  450.     muls.w    d1,d5                ; d5.l=l.z*r.y
  451.     muls.w    d2,d4                ; d4.l=l.y*r.z
  452.     sub.l    d4,d5
  453.     movea.l    d5,a2                ; a2=l.z*r.y-l.y*r.z
  454.     movem.w    (sp),d3-d5
  455. ; d3-d5=l
  456. ;       -
  457.     muls.w    d2,d3                ; d3.l=l.x*r.z    
  458.     muls.w    d0,d5                ; d5.l=l.z*r.x
  459.     sub.l    d5,d3                ; d3.l=l.x*r.z-l.z*r.x
  460.     movea.l    d3,a3                ; a3=l.x*r.z-l.z*r.x
  461.     movem.w    (sp)+,d3-d5
  462. ; d3-d5=l
  463. ;       -
  464.     muls.w    d0,d4                ; d4.l=l.y*r.x
  465.     muls.w    d1,d3                ; d3.l=l.x*r.y
  466.     sub.l    d3,d4                ; d4.l=l.y*r.x-l.x*r.y
  467. ; a2/a3/d4=o
  468. ;          -
  469.  
  470.     move.l    a2,d0
  471.     move.l    a3,d1
  472.     move.l    d4,d2
  473.     asr.l    #7,d0
  474.     asr.l    #7,d1
  475.     asr.l    #7,d2
  476.     muls.w    d0,d0
  477.     muls.w    d1,d1
  478.     muls.w    d2,d2
  479.     add.l    d0,d1
  480.     add.l    d2,d1
  481.     bsr.l    Math.sqrt
  482. ; d0.l=|o|/128 (16:16)
  483. ;       -
  484.     move.l    a2,d1
  485.     move.l    a3,d2
  486.     move.l    d4,d3
  487.     swap    d0
  488.     mulu.w    #Pretzel.NORMAL_DIV,d0
  489.     lsr.l    #8,d0
  490.     divs.w    d0,d1
  491.     divs.w    d0,d2
  492.     divs.w    d0,d3
  493. ; d1-d3=n, store it..
  494. ;       -
  495.     move.w    d3,-(a0)
  496.     move.w    d2,-(a0)
  497.     move.w    d1,-(a0)
  498.     dbf    d6,.normal_ploop
  499.  
  500.     dbf    d7,.normal_rloop
  501.  
  502.     lea    Pretzel.VERTICES*Vertex.SIZE(a0),a0
  503.  
  504.     clr.w    (a0)+                ; #texels
  505.  
  506.     move.w    #Pretzel.POLYS,(a0)+        ; #primitives
  507.     moveq    #Pretzel.RINGS-1,d7
  508.  
  509. .prim_ring_loop:
  510.     move.w    d7,d2
  511.     mulu.w    #Pretzel.SLICES,d2
  512.     clr.l    d3
  513.     move.w    d7,d3
  514.     addq.w    #1,d3
  515.     divu.w    #Pretzel.RINGS,d3
  516.     swap    d3
  517.     mulu.w    #Pretzel.SLICES,d3
  518.     moveq    #Pretzel.SLICES-1,d6
  519.     
  520. .primloop:
  521.     move.w    #Polygon.QUAD|Polygon.ENVMAPPED|0,(a0)+
  522.  
  523.     move.w    d6,d0
  524.     add.w    d3,d0
  525.     move.w    d0,(a0)+
  526.  
  527.     clr.l    d0
  528.     move.w    d6,d0
  529.     addq.w    #1,d0
  530.     divu.w    #Pretzel.SLICES,d0
  531.     swap    d0
  532.     move.w    d0,d1
  533.     add.w    d3,d0
  534.     move.w    d0,(a0)+
  535.  
  536.     add.w    d2,d1
  537.     move.w    d1,(a0)+
  538.  
  539.     move.w    d6,d0
  540.     add.w    d2,d0
  541.     move.w    d0,(a0)+
  542.  
  543.     REPT    4
  544.     move.w    -8(a0),d0
  545.     addi.w    #Pretzel.VERTICES,d0
  546.     move.w    d0,(a0)+
  547.     ENDR
  548.  
  549.     dbra    d6,.primloop
  550.  
  551.     dbra    d7,.prim_ring_loop
  552.  
  553. .end:    suba.l    a6,a0
  554.     move.l    a0,d0
  555.     rts
  556.  
  557. .radius:DC.W    0
  558.  
  559. Pretzel.paint:
  560.     bsr.l    PrimitiveMesh.new
  561.  
  562.     clr.w    d0
  563.     clr.w    d1
  564.     move.w    Pretzel.oldRot,d2
  565.     move.w    $04BC.w,d3
  566.     sub.w    Pretzel.rotSwapTime,d3
  567.     muls.w    Pretzel.rotDir,d3
  568.     add.w    d3,d2
  569.     move.w    d2,Pretzel.rot
  570.     mulu.w    #7,d2
  571.     lsr.l    #1,d2
  572.     bsr.l    Matrix.generate
  573.     move.w    #0,d0
  574.     move.w    #0,d1
  575.     move.w    Pretzel.z,d2
  576.     bsr.l    Matrix.translate
  577.     bsr.l    Matrix.push
  578.  
  579.     move.w    Pretzel.xRot,d0
  580.     move.w    Pretzel.yRot,d1
  581.     move.w    Pretzel.zRot,d2
  582.     bsr.l    Matrix.generate
  583.     bsr.l    Matrix.push
  584.  
  585.     moveq    #TransformObject.BACKFACE_CULLING|TransformObject.PERSPECTIVATE,d0
  586.     moveq    #0,d1
  587.     bsr.l    TransformObject.transform
  588.  
  589.     bsr.l    Matrix.pop
  590.     bsr.l    Matrix.pop
  591.  
  592.     bsr.l    PrimitiveMesh.sortZ
  593.     bsr.l    PrimitiveMesh.complete
  594.  
  595.     IFNE    0
  596.     lea    Viewport.settingsTable,a0
  597.     movem.w    Viewport.XSTART(a0),d0/d6
  598.     movem.w    Viewport.YSTART(a0),d1/d7
  599.     moveq    #$00000000,d4
  600.     bsr.l    Viewport.paintRectangle
  601.     ELSE
  602.     movea.l    Pretzel.rectTableAdr,a0
  603.     move.w    (a0)+,d7
  604.     beq.s    .end_restore
  605.     subq.w    #1,d7
  606. .restore_loop:
  607.     move.w    d7,-(sp)
  608.     movem.w    (a0)+,d1/d7
  609.     movem.w    (a0)+,d0/d6
  610.     move.l    a0,-(sp)
  611.     moveq    #$00000000,d4
  612.     bsr.l    Viewport.paintRectangle
  613.     movea.l    (sp)+,a0
  614.     move.w    (sp)+,d7
  615.     dbra    d7,.restore_loop
  616. .end_restore:
  617.     ENDC
  618.  
  619.     movea.l    Pretzel.rectTableAdr,a0
  620.     bsr.l    PrimitiveMesh.paint
  621.  
  622.     lea    Pretzel.rectTableAdr,a0
  623.      move.l    (a0)+,d0
  624.     move.l    (a0)+,d1
  625.     move.l    (a0),-(a0)
  626.     move.l    d0,4(a0)
  627.     move.l    d1,-(a0)
  628.     rts
  629.  
  630. ******** OBJECT DATA ********
  631.  
  632.     DATA
  633.  
  634. textureTable:
  635.     DC.L    FlareGen.chromeFogBuffer
  636.     DC.L    0
  637.  
  638. Pretzel.rectTableAdr:
  639.     DC.L    Pretzel.rectangleTable
  640.     DC.L    Pretzel.rectangleTable2
  641.     DC.L    Pretzel.rectangleTable3
  642.  
  643. ******** OBJECT RESERVES ********
  644.  
  645.     BSS
  646.  
  647. Pretzel.resRout:
  648.     DS.L    1
  649.  
  650. Pretzel.rectangleTable:
  651.     DS.W    1+4*32
  652. Pretzel.rectangleTable2:
  653.     DS.W    1+4*32
  654. Pretzel.rectangleTable3:
  655.     DS.W    1+4*32
  656.  
  657. Pretzel.rotTable:
  658. Pretzel.xRot:
  659.     DS.W    1
  660. Pretzel.yRot:
  661.     DS.W    1
  662. Pretzel.zRot:
  663.     DS.W    1
  664. Pretzel.xRotTime:
  665.     DS.W    1
  666. Pretzel.yRotTime:
  667.     DS.W    1
  668. Pretzel.xDir:
  669.     DS.W    1
  670. Pretzel.yDir:
  671.     DS.W    1
  672. Pretzel.oldXRot:
  673.     DS.W    1
  674. Pretzel.oldYRot:
  675.     DS.W    1
  676. Pretzel.rotSwapTime:
  677.     DS.W    1
  678. Pretzel.oldRot:
  679.     DS.W    1
  680. Pretzel.rot:
  681.     DS.W    1
  682. Pretzel.rotDir:
  683.     DS.W    1
  684.  
  685. Pretzel.zoomActive:
  686.     DS.W    1
  687. Pretzel.zoomStart:
  688.     DS.L    1
  689. Pretzel.z:
  690.     DS.W    1
  691.  
  692. Pretzel.baseAdr:
  693.     DS.L    1