home *** CD-ROM | disk | FTP | other *** search
/ The CDPD Public Domain Collection for CDTV 3 / CDPDIII.bin / pd / commodities / superdark / blankers / plasma_cycle.dark.c < prev    next >
C/C++ Source or Header  |  1993-03-10  |  7KB  |  325 lines
  1.  /* Fichier plasma_cycle.dark.c                */
  2. /* Module appele par le programme principal    */
  3. /* pour effectuer un effet defini..appele par    */
  4. /* loadseg                    */
  5.  
  6. #include    <exec/types.h>
  7. #include    <exec/memory.h>
  8. #include    <dos/dos.h>
  9. #include    <intuition/intuition.h>
  10. #include    <intuition/gadgetclass.h>
  11. #include    <graphics/gfx.h>
  12. #include    <graphics/gfxmacros.h>
  13. #include    <graphics/gfxbase.h>
  14. #include    <graphics/rastport.h>
  15. #include    <clib/exec_protos.h>
  16. #include    <clib/intuition_protos.h>
  17. #include    "/includes/struct.h"
  18. #include    "/includes/tom_gadget.h"
  19.  
  20. #define    MAX_LEVEL    8
  21. #define MAX_ALT    256
  22.  
  23. #define        DEPTH    5
  24. #define    WIDTH    320
  25. #define    HEIGHT    256
  26.  
  27. extern    char    *pr_buff;
  28.  
  29. /*UBYTE    far    t[(1<<MAX_LEVEL)+1][(1<<MAX_LEVEL)+1];*/
  30. char    **t;
  31.  
  32. char    p_ver[]="$VER: Plasma_Cycle v1.0 (06/02/93)";
  33.  
  34. struct NewScreen    Screen = {
  35.     0, 0, WIDTH,  HEIGHT, DEPTH, 0,0, 0, CUSTOMSCREEN, NULL, NULL ,NULL, NULL};
  36.  
  37. USHORT  depth=2;
  38. int    decalage;
  39. int    offx,offy;
  40. USHORT    width,height;
  41.  
  42. struct    RastPort    *rp;
  43. struct    Screen    *s;
  44. extern    struct    appel_proc    *p_data_proc;
  45. extern    struct    GfxBase    *GfxBase;
  46.  
  47. char    *p_text_info="      'Plasma_Cycle'\n\n\nThis effect have been inspired by\n  an old programm that I have,in\noberon I think...Some code have been\ntaken from this!\n";
  48.  
  49. #define reg register
  50. extern    void __asm MultiPlot(reg __a0 struct Screen *,reg __d0 WORD, reg __d1 WORD,reg __d2 WORD);
  51.  
  52. #define    SIZE  8
  53. #define        COUNT         (1 << SIZE)
  54.  
  55. UWORD Range[] = {32, 32, 32, 22, 14, 8, 4, 2};
  56.  
  57. UWORD  *ScreenColors;
  58. #define    NB_COL    10
  59. int    max_color=10;
  60. UWORD    CMap[NB_COL+1]={
  61.     0x00f, 0x8f8, 0xff0, 0xe50, 0xf00,
  62.     0x0ff, 0x356, 0xf06, 0x00f, 0x0ff,
  63.     0xfff
  64. };
  65.  
  66. UWORD *Cell;
  67.  
  68. int    pas_min;
  69.  
  70. struct tom_gadget my_gadg[]={
  71.     {"_Resolution",    SCREEN,    125,14,139,14,0, 0,0,0,0},
  72. /*    {"_Altitude",SLIDER,    125,14,139,9,1, 1,MAX_ALT,0,0},*/
  73.     {0,        END_LISTE,  0,  0,   0, 0, 0,0,0,0,0}
  74. };
  75. WORD    cx,cy;
  76.  
  77. unsigned    int    seed;
  78. void    rotate();
  79.  
  80.  
  81. /***************************************************************************/
  82.  
  83. unsigned        int     my_rand()
  84. {
  85.         
  86.         seed=25173*seed+138490;
  87.         return(seed);
  88. }
  89.  
  90. /***************************************************************************/
  91.  
  92. UWORD    random(int    ampl)
  93. {
  94.     return(my_rand()%ampl);
  95. }
  96.  
  97.  
  98. /***************************************************************************/
  99.  
  100. void    SetCell(UWORD l,UWORD c,UWORD val)
  101. {
  102.     if((l<height)&&(c<width)){
  103.         *(Cell+(l*width+c))=val;
  104.     }
  105. }
  106.  
  107. /***************************************************************************/
  108.  
  109. UWORD ValCell(UWORD l,UWORD c)
  110. {
  111.     return (*(Cell+(l*width+c)));
  112. }
  113.  
  114. /***************************************************************************/
  115.  
  116. void    set(UWORD l,UWORD c,UWORD size,int height)
  117. {
  118.     UWORD rang;
  119.  
  120.     rang = Range[size];
  121.     height = height + random(rang) - (rang + 1) / 2;
  122.     if(height<1)height=1;
  123.     SetCell(l,c,height);
  124.     MultiPlot(s,(WORD)(offx+c),(WORD)(offy+l),height);
  125. }
  126.  
  127. /***************************************************************************/
  128.  
  129. /*
  130.  * grow - grow the basic scenery heights.
  131.  */
  132.  
  133. void    grow()
  134. {
  135.     UWORD l,c,i,step,nextStep,l1;
  136.     UWORD l2,c1,c2;
  137.  
  138.     SetCell(0,0,0);
  139.     step = COUNT;
  140.     for(i=0;i<SIZE;i++){
  141.     nextStep = step / 2;
  142.     for(l=0;(l<height)&&(tst_end()==FALSE);l+=step){
  143.         l1 = l + nextStep;
  144.         l2 = l + step;
  145.         if( l2 == height){
  146.         l2 = 0;
  147.         }
  148.         for(c=0;c<width;c+=step){
  149.         c1 = c + nextStep;
  150.         c2 = c + step;
  151.         if(c2 == width){
  152.             c2 = 0;
  153.         }
  154.         set(l, c1, i, (ValCell(l,c) + ValCell(l,c2) + 1) / 2);
  155.         set(l1, c, i, (ValCell(l,c) + ValCell(l2,c) + 1) / 2);
  156.         set(l1, c1, i, (ValCell(l,c) + ValCell(l,c2) +
  157.                 ValCell(l2,c) + ValCell(l2,c2) + 2) / 4);
  158.         }
  159.     }
  160.     step = nextStep;
  161.     }
  162. }
  163.  
  164.  
  165. /***************************************************************************/
  166.  
  167. UWORD    fade_one_digit(USHORT    n,USHORT    j,UWORD mask)
  168. {
  169.     register    UWORD    s,d;
  170.     s=CMap[n]&mask;
  171.     d=CMap[n+1]&mask;
  172.     return(((s+(d-s)*j*NB_COL/max_color))&mask);
  173. }
  174.  
  175. /***************************************************************************/
  176.  
  177. void    rotate()
  178. {
  179.     static    unsigned    int    compt=0;
  180.     unsigned    int    n,i;
  181.  
  182.     n=compt;
  183.     for(i=1;i<depth;i++){
  184.         n=n%max_color;
  185.         SetRGB4(    &s->ViewPort,i,
  186.                 (ScreenColors[n+1]&0xf00)>>8,
  187.                 (ScreenColors[n+1]&0x0f0)>>4,
  188.                 (ScreenColors[n+1]&0x00f));
  189.         n++;
  190.     }
  191.     compt++;
  192. }
  193.  
  194.  
  195. /********************************************************** dark ***/
  196.  
  197. void    dark()
  198. {
  199.   int    i;
  200.   USHORT    n,j;
  201.   ULONG    did;
  202.   struct    tom_gadget    *pg;
  203.  
  204.   pg=&my_gadg[0];
  205.   /* With WB2.0 or higher, we use facilities of the intuition lib. */
  206.   /* to open screen (overscan...)                       */
  207.   if((GfxBase->LibNode.lib_Version>=37)&&(pg->d3!=0)){
  208.      s=OpenScreenTags(NULL,
  209.                SA_Width,(ULONG)pg->d1,
  210.                SA_Height,(ULONG)pg->d2,
  211.                            SA_Depth,(ULONG)pg->d3,
  212.                SA_Overscan,(ULONG)pg->value,
  213.                            SA_DisplayID,(ULONG)pg->p_data,
  214.                            SA_Quiet,TRUE,TAG_DONE);
  215.      width=pg->d1;
  216.      height=pg->d2;
  217.    }else{
  218.  
  219.  
  220.       /******************************************************/
  221.       /* We find the resolution with the maximum of colors! */
  222.       /******************************************************/
  223.  
  224.       width=0;
  225.       find_res((USHORT)TRUE,&depth,&width,&height,&did);
  226.  
  227.       if(COUNT>width)width=COUNT;
  228.       if(COUNT>height)height=COUNT;
  229.       Screen.Width=width;
  230.       Screen.Height=height;
  231.       Screen.ViewModes=did;
  232.       if(depth<2)return;
  233.  
  234.       s = OpenScreen(&Screen);
  235.  }
  236.  if(!s)return;
  237.  FreeSprite (0);
  238.  GfxBase->SpriteReserved|=1;
  239.  rp = &(s->RastPort);
  240.  depth=1<<rp->BitMap->Depth;
  241.  
  242.  /****************************************************************/
  243.  /* We create a color map, with transitions, in the range of all */
  244.  /* the availables colors                     */
  245.  /****************************************************************/
  246.  
  247.  if(depth>NB_COL*4){
  248.     max_color=depth;
  249.  }else{
  250.     max_color=depth*4;
  251.  }
  252.  ScreenColors=(UWORD *)AllocMem(sizeof(UWORD)*(max_color),MEMF_CLEAR);
  253.  if(ScreenColors){
  254.   /* We create a fading ColorMap, with transition....*/
  255.   n=0;
  256.   j=0;
  257.   for(i=1;i<max_color;i++){
  258.  
  259.     ScreenColors[i]= fade_one_digit(n,j,0xF00)
  260.             |fade_one_digit(n,j,0X0f0)
  261.             |fade_one_digit(n,j,0X00F);
  262.  
  263.     j++;
  264.     if(j>=(max_color/NB_COL)){
  265.         j=0;
  266.         n++;
  267.     }
  268.   }
  269.   ScreenColors[0]=0;
  270.  
  271. /*
  272.   offx=(width-COUNT)/2;
  273.   offy=(height-COUNT)/2;
  274. */
  275.   offx=0;
  276.   offy=0;
  277.  
  278.   Cell=(UWORD *)AllocMem(width*height*sizeof(WORD),MEMF_CLEAR);
  279.   if(Cell!=0){
  280.     LoadRGB4(&s->ViewPort,ScreenColors,depth);
  281.  
  282.     while(tst_end()==FALSE){
  283.         SetRast(rp,0);
  284. /*
  285.         for(i=0;i<MAX_LEVEL;i++){
  286.             for(j=0;j<MAX_LEVEL;j++){
  287.                 t[i][j]=0;
  288.             }
  289.         }
  290.         pas_min=1;
  291.         cx=0;
  292.         cy=0;
  293.         calcul(0,0,1<<MAX_LEVEL);
  294.         cx+=1<<MAX_LEVEL;
  295.         calcul(0,0,1<<MAX_LEVEL);
  296. */
  297.         grow();
  298.  
  299.         for(i=0;(i<200)&&(tst_end()==FALSE);i++){
  300.             WaitTOF();
  301.             WaitTOF();
  302.             rotate();
  303.         }
  304.     }
  305.     FreeMem(Cell,width*height*sizeof(WORD));
  306.    }
  307.   }
  308.   if(ScreenColors)FreeMem(ScreenColors,sizeof(UWORD)*(max_color));
  309.   CloseScreen(s);
  310.    
  311. }
  312.  
  313. void    proc_init()
  314. {
  315.         seed=VBeamPos();
  316. }
  317. void    proc_save()
  318. {
  319. }
  320.  
  321. void    proc_end()
  322. {
  323. }
  324.  
  325.