home *** CD-ROM | disk | FTP | other *** search
/ ARM Club 1 / ARM_CLUB_CD.iso / contents / sillies / silly1 / !Rippler / c / ripmod < prev    next >
Text File  |  1990-04-14  |  3KB  |  188 lines
  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <string.h>
  4.  
  5. #include "kernel.h"
  6. #include "swis.h"
  7.  
  8.  
  9. #define TRUE (1==1)
  10. #define FALSE (1==0)
  11.  
  12. int rippling = FALSE;
  13. int *driver_start, *display_start;
  14. int driver_bank;
  15. int *waves = NULL;
  16. int SIZE;
  17. int r12;
  18. int oldstate;
  19. int ticks = 0;
  20. int ripples = 0;
  21. int waiting = FALSE;
  22. int rip = -255;
  23.  
  24. extern void EventEntry(void);
  25. extern void cb_entry(void);
  26. extern void asm_ripple(int *, int *, int *, int);
  27.  
  28. int do_ripple(void)
  29. {
  30.     ripples++;
  31.     asm_ripple(driver_start, display_start, waves, SIZE | (rip << 16));
  32. /*
  33.     for (i = 0; i < 256; i++)
  34.     {
  35.         int *src;
  36.         int j, off;
  37.         off = i + rip;
  38.         if (off < 0 || off > SIZE - 1)
  39.             src = driver_start + 80 * i;
  40.         else
  41.         {
  42.             off = waves[off] + i;
  43.             if (off < 0 || off > 255)
  44.             {
  45.                 for (j = 0; j < 80; j++)
  46.                     *dst++ = 0x44444444;
  47.                 continue;
  48.             }
  49.             src = driver_start + 80 * off;
  50.         }
  51.         for (j = 0; j < 80; j++)
  52.             *dst++ = *src++;
  53.     }
  54. */
  55.     if (++rip >= SIZE)
  56.         rip = -255;
  57.     waiting = FALSE;
  58.     return(1);
  59. }
  60.  
  61. static void stop_rippling(void)
  62. {
  63.     _kernel_swi_regs r;
  64.     rippling = FALSE;
  65.     r.r[0] = 113;
  66.     r.r[1] = driver_bank;
  67.     _kernel_swi(OS_Byte, &r, &r);
  68. }
  69.  
  70. static void start_rippling(void)
  71. {
  72.     static int vars[] = { 148, 149, -1 };
  73.     int *result[2];
  74.     _kernel_swi_regs r;
  75.     r.r[0] = 250;
  76.     r.r[1] = 0;
  77.     r.r[2] = 255;
  78.     _kernel_swi(OS_Byte, &r, &r);
  79.     driver_bank = r.r[1];
  80.     r.r[0] = 113;
  81.     r.r[1] = driver_bank == 2 ? 1 : 2;
  82.     _kernel_swi(OS_Byte, &r, &r);
  83.     r.r[0] = (int)vars;
  84.     r.r[1] = (int)result;
  85.     _kernel_swi(OS_ReadVduVariables, &r, &r);
  86.     driver_start = result[0];
  87.     display_start = result[1];
  88.     rippling = (driver_start != display_start);
  89. }
  90.  
  91. int Event_Handler(_kernel_swi_regs *r, void *pw)
  92. {
  93.     ticks++;
  94.     if (r->r[0] == 4 && waves != NULL && rippling && !waiting)
  95.     {
  96.         _kernel_swi_regs x;
  97.         waiting = TRUE;
  98.         x.r[0] = (int)cb_entry;
  99.         x.r[1] = (int)pw;
  100.         _kernel_swi(OS_AddCallBack, &x, &x);
  101.     }
  102.     return(1);
  103. }
  104.  
  105. void closedown(void)
  106. {
  107.     _kernel_swi_regs r;
  108.     r.r[0] = 13;
  109.     r.r[1] = 4;
  110.     _kernel_swi(OS_Byte, &r, &r);
  111.     rippling = FALSE;
  112.     r.r[0] = 0x10;
  113.     r.r[1] = (int)EventEntry;
  114.     r.r[2] = r12;
  115.     _kernel_swi(OS_Release, &r, &r);
  116.     if (waves != NULL)
  117.     {
  118.         r.r[0] = 7;
  119.         r.r[2] = (int)waves;
  120.         _kernel_swi(OS_Module, &r, &r);
  121.     }
  122. }
  123.  
  124. _kernel_oserror *initialise(char *tail, int pbase, void *pw)
  125. {
  126.     _kernel_swi_regs r;
  127.     rippling = FALSE;
  128.     waiting = FALSE;
  129.     r12 = (int)pw;
  130.     r.r[0] = 0x10;
  131.     r.r[1] = (int)EventEntry;
  132.     r.r[2] = (int)pw;
  133.     _kernel_swi(OS_Claim, &r, &r);
  134.     r.r[0] = 14;
  135.     r.r[1] = 4;
  136.     _kernel_swi(OS_Byte, &r, &r);
  137.     atexit(closedown);
  138.     return(NULL);
  139. }
  140.  
  141. void service(int n, _kernel_swi_regs *r, void *pw)
  142. {
  143.     switch(n)
  144.     {
  145.         case 0x4d:
  146.             oldstate = rippling;
  147.             if (rippling)
  148.                 stop_rippling();
  149.             break;
  150.         case 0x46:
  151.             if (oldstate)
  152.                 start_rippling();
  153.             break;
  154.         case 0xbb:
  155.             waves = (int*)r->r[0];
  156.             SIZE = r->r[2];
  157.             break;
  158.     }
  159. }
  160.  
  161. _kernel_oserror *command(char *argv, int argc, int n, void *pw)
  162. {
  163.     switch(argv[0])
  164.     {
  165.         case '0':
  166.             stop_rippling();
  167.             break;
  168.         case '1':
  169.             start_rippling();
  170.             break;
  171.         case '2':
  172.             if (waves != NULL)
  173.                 do_ripple();
  174.             break;
  175.         case '3':
  176.         {
  177.             int i;
  178.             printf("Wave table at %p\n", waves);
  179.             printf("Rippling = %d\n", rippling);
  180.             printf("Ticks = %d\n", ticks);
  181.             printf("Ripples = %d\n", ripples);
  182.             printf("Waiting = %d\n", waiting);
  183.             break;
  184.         }
  185.     }
  186.     return(NULL);
  187. }
  188.