home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format 105 / af105sub.adf / Beyondthedark.LZX / BeyondTheDark / Developer / Source / Interference / Interference.c next >
C/C++ Source or Header  |  2013-06-15  |  9KB  |  367 lines
  1. /* Interference Library */
  2.  
  3. #include <exec/memory.h>
  4. #include <exec/execbase.h>
  5. #include <graphics/gfxbase.h>
  6. #include <intuition/intuitionbase.h>
  7. #include <libraries/iffparse.h>
  8. #include <utility/tagitem.h>
  9.  
  10. #include <clib/macros.h>
  11.  
  12. #define __USE_SYSBASE 42
  13.  
  14. #include <proto/exec.h>
  15. #include <proto/graphics.h>
  16. #include <proto/intuition.h>
  17. #include <proto/mathieeedoubbas.h>
  18. #include <proto/mathieeedoubtrans.h>
  19. #include <proto/utility.h>
  20.  
  21. #include <math.h>
  22.  
  23. #include <BTD.h>
  24.  
  25. struct IntuitionBase *IntuitionBase;
  26. struct Library *UtilityBase;
  27. struct GfxBase *GfxBase;
  28. struct Library *MathIeeeDoubBasBase;
  29. struct Library *MathIeeeDoubTransBase;
  30.  
  31. #define KTAG(o) (BTD_Client+(o))
  32.  
  33. #define IS_Colors  KTAG(0)
  34. #define IS_Cycle   KTAG(1)
  35. #define IS_Cycling KTAG(2)
  36. #define IS_Formula KTAG(3)
  37. #define IS_Clear   KTAG(4)
  38.  
  39. #define MAX_CYCLING 1000L
  40. #define DEF_CYCLING 60L
  41.  
  42. #define MAX_COLORS 255
  43. #define DEF_COLORS 31
  44.  
  45. #define MAX_FORMULA 1
  46. #define DEF_FORMULA 0
  47.  
  48. #define FindTagData(l,t,d) GetTagData((t),(d),(l))
  49.  
  50. char *Formulas[] = {"Quadratic","Cubic",NULL};
  51.  
  52. struct BTDCycle InterferenceCycleParams[] =
  53.  {
  54.   IS_Formula,"Formula",BTDPT_CYCLE,DEF_FORMULA,Formulas
  55.  };
  56.  
  57.  
  58. struct BTDInteger InterferenceIntParams[] =
  59.  {
  60.   IS_Cycling,"Cycling Counter",BTDPT_INTEGER,DEF_CYCLING,1L,MAX_CYCLING,TRUE,
  61.   IS_Colors,"Colors",BTDPT_INTEGER,DEF_COLORS,2L,MAX_COLORS,TRUE
  62.  };
  63.  
  64. struct BTDBoolean InterferenceBoolParams[] =
  65.  {
  66.   IS_Cycle,"Cycle",BTDPT_BOOLEAN,TRUE,
  67.   IS_Clear,"Clear before redraw",BTDPT_BOOLEAN,FALSE
  68.  };
  69.  
  70. struct BTDNode *InterferenceParams[] = 
  71.   {
  72.    &InterferenceCycleParams[0].BC_Node,
  73.    &InterferenceIntParams[1].BI_Node,
  74.    &InterferenceBoolParams[0].BB_Node,
  75.    &InterferenceIntParams[0].BI_Node,
  76.    &InterferenceBoolParams[1].BB_Node,
  77.    NULL
  78.   };
  79.  
  80. struct BTDInfo InterferenceInfo =
  81.  {
  82.   BTDI_Revision,MAKE_ID('I','F','R','C'),
  83.   "Interference Blanker","selfmade blanker\nbased on some fractal exposées","Markus Illenseer '92,'93,'94",
  84.   InterferenceParams};
  85.  
  86. struct InterferenceStruct
  87.  {
  88.   struct BTDDrawInfo *BTDDrawInfo;
  89.   UWORD  Seconds;
  90.   UWORD  Time;
  91.   UWORD  Left;    /* Left Offset of our Rect */
  92.   UWORD  Top;     /* Top Offset of our Rect */
  93.   UWORD  Width;   /* Width of our Rect */
  94.   UWORD  Height;  /* Height of our Rect */
  95.   DOUBLE str,sti;
  96.   UWORD  ypos;
  97.   UWORD  xpos;
  98.   BOOL   DoCycle;
  99.   UWORD  Formula;
  100.   LONG   hs_RandN,hs_RandF,hs_RandI;
  101.   SHORT  Cycle;
  102.   SHORT  Colors;
  103.   SHORT  Cycling;
  104.   BOOL   Clear;
  105.  };
  106.  
  107. /* library stuff */
  108.  
  109. char MyBlankerName[] = "interference.btd";
  110. char MyBlankerID[]   = "Interference Blanker V" VERSION "." REVISION " for BTD";
  111. LONG MyBlankerLibInit(void)
  112.  
  113. {
  114.  if (GfxBase=(struct GfxBase *)OpenLibrary("graphics.library",37L))
  115.   {
  116.    if (IntuitionBase=(struct IntuitionBase *)OpenLibrary("intuition.library",37L))
  117.     {
  118.      if (UtilityBase=OpenLibrary("utility.library",37L))
  119.       {
  120.        if (MathIeeeDoubBasBase=OpenLibrary("mathieeedoubbas.library",37L))
  121.         {
  122.          if (MathIeeeDoubTransBase=OpenLibrary("mathieeedoubtrans.library",37L)) return TRUE;
  123.  
  124.          CloseLibrary (MathIeeeDoubBasBase);
  125.         }
  126.        CloseLibrary (UtilityBase);
  127.       }
  128.      CloseLibrary (&IntuitionBase->LibNode);
  129.     }
  130.    CloseLibrary (&GfxBase->LibNode);
  131.   }
  132.  return FALSE;
  133. }
  134.  
  135. void MyBlankerLibFree(void)
  136.  
  137. {
  138.  CloseLibrary (MathIeeeDoubTransBase);
  139.  CloseLibrary (MathIeeeDoubBasBase);
  140.  CloseLibrary (UtilityBase);
  141.  CloseLibrary (&IntuitionBase->LibNode);
  142.  CloseLibrary (&GfxBase->LibNode);
  143. }
  144.  
  145. struct BTDInfo *QueryMyBlanker(void)
  146.  
  147. {
  148.  return &InterferenceInfo;
  149. }
  150.  
  151. void __regargs InitRandom(struct InterferenceStruct *IS,ULONG Instance)
  152.  
  153. {
  154.  ULONG Time[2];
  155.  
  156.  CurrentTime (&Time[0],&Time[1]);
  157.  IS->hs_RandN=(LONG)Time[0];
  158.  if (Time[1]<1024L) Time[1]|=1;
  159.  else Time[1]>>=10;
  160.  Time[1]^=Instance;
  161.  
  162.  IS->hs_RandF=4*Time[1]+1;
  163.  IS->hs_RandI=2*Time[1]+1;
  164. }
  165.  
  166. WORD __regargs Random(struct InterferenceStruct *IS,WORD Max)
  167.  
  168. {
  169.  IS->hs_RandN=IS->hs_RandF*IS->hs_RandN+IS->hs_RandI;
  170.  if (IS->hs_RandN<0L) IS->hs_RandN=-IS->hs_RandN;
  171.  
  172.  return (WORD)(IS->hs_RandN%Max);
  173. }
  174.  
  175. struct InterferenceStruct *InitMyBlanker(struct TagItem *TagList)
  176.  
  177. {
  178.  struct BTDDrawInfo *BTDDrawInfo;
  179.  struct InterferenceStruct *IS;
  180.  ULONG *Error,Dummy;
  181.  UWORD Index,Instance,Formula;
  182.  LONG Colors,Step,Cycling;
  183.  BOOL DoCycle,Clear;
  184.  
  185.  if ((BTDDrawInfo=(struct BTDDrawInfo *)
  186.                    FindTagData(TagList,BTD_DrawInfo,NULL))==NULL) return NULL;
  187.  Error=(LONG *)FindTagData(TagList,BTD_Error,(ULONG)&Dummy);
  188.  if ((IS=AllocVec(sizeof(struct InterferenceStruct),MEMF_PUBLIC|MEMF_CLEAR))==NULL)
  189.   {
  190.    *Error=BTDERR_Memory;
  191.    return NULL;
  192.   }
  193.  
  194.  Instance=FindTagData(TagList,BTD_Instance,0L);
  195.  Colors=FindTagData(TagList,IS_Colors,DEF_COLORS);
  196.  Cycling=FindTagData(TagList,IS_Cycling,DEF_CYCLING);
  197.  DoCycle=FindTagData(TagList,IS_Cycle,TRUE);
  198.  Clear=FindTagData(TagList,IS_Clear,FALSE);
  199.  Formula=FindTagData(TagList,IS_Formula,DEF_FORMULA);
  200.  
  201.  InitRandom(IS,Instance);
  202.  
  203.  IS->BTDDrawInfo=BTDDrawInfo;
  204.  IS->Left=IS->BTDDrawInfo->BDI_Left;
  205.  IS->Top=IS->BTDDrawInfo->BDI_Top;
  206.  IS->Width=IS->BTDDrawInfo->BDI_Width;
  207.  IS->Height=IS->BTDDrawInfo->BDI_Height;
  208.  
  209.  IS->ypos=IS->Top;
  210.  IS->xpos=IS->Left;
  211.  IS->str=IEEEDPDiv(IEEEDPFlt(Random(IS,80)+20),IEEEDPFlt(IS->Width));
  212.  IS->sti=IEEEDPDiv(IEEEDPFlt(Random(IS,80)+20),IEEEDPFlt(IS->Height));
  213.  IS->Formula = Formula;
  214.  IS->Cycle=0;
  215.  IS->DoCycle=DoCycle;
  216.  IS->Cycling=Cycling;
  217.  IS->Clear=Clear;
  218.  IS->Colors=Colors-1;
  219.  
  220.  Step=(256/(IS->Colors));
  221.  
  222.  for(Index=0; Index<IS->Colors+1; Index++)
  223.   {
  224.    BTDDrawInfo->BDI_Red[BTDDrawInfo->BDI_Pens[Index]]=Step*(Index);
  225.    BTDDrawInfo->BDI_Green[BTDDrawInfo->BDI_Pens[Index]]=0;
  226.    BTDDrawInfo->BDI_Blue[BTDDrawInfo->BDI_Pens[Index]]=255-Step*(Index);
  227.    BTDDrawInfo->BDI_Changed[BTDDrawInfo->BDI_Pens[Index]]=TRUE;
  228.   }
  229.  return IS;
  230. }
  231.  
  232. void EndMyBlanker(struct InterferenceStruct *IS)
  233.  
  234. {
  235.  FreeVec (IS);
  236. }
  237.  
  238. void AnimMyBlanker(struct InterferenceStruct *IS)
  239.  
  240. {
  241.  DOUBLE I,R;
  242.  static UWORD X,Y,Z,H,T,L,W;
  243.  struct BTDDrawInfo *BTDDrawInfo;
  244.  
  245.  BTDDrawInfo=IS->BTDDrawInfo;
  246.  
  247.  IS->xpos++;
  248.  X=IS->xpos;
  249.  L=IS->Left;
  250.  W=IS->Width;
  251.  
  252.  if(X>L+W) 
  253.   {
  254.    IS->xpos=X=L;
  255.    IS->ypos++;
  256.   }
  257.  
  258.  Y=IS->ypos;
  259.  H=IS->Height;
  260.  T=IS->Top;
  261.  
  262.  if (Y>=(H+T))
  263.   {
  264.    UBYTE Red,Green,Blue;
  265.    ULONG Index;
  266.  
  267.    if(IS->DoCycle)
  268.     {
  269.      if(IS->Cycle<=0) IS->Cycle=IS->Cycling;
  270.  
  271.      if(IS->Cycle>=2) 
  272.       {
  273.  
  274.        IS->Cycle--;
  275.  
  276.        for (Index=0L; Index<7L; Index++)
  277.         WaitTOF();
  278.  
  279.        Red=BTDDrawInfo->BDI_Red[BTDDrawInfo->BDI_Pens[0]];
  280.        Green=BTDDrawInfo->BDI_Green[BTDDrawInfo->BDI_Pens[0]];
  281.        Blue=BTDDrawInfo->BDI_Blue[BTDDrawInfo->BDI_Pens[0]];
  282.  
  283.        for (Index=0L; Index<IS->Colors; Index++)
  284.         {
  285.          BTDDrawInfo->BDI_Red[BTDDrawInfo->BDI_Pens[Index]]=
  286.           BTDDrawInfo->BDI_Red[BTDDrawInfo->BDI_Pens[Index+1]];
  287.          BTDDrawInfo->BDI_Green[BTDDrawInfo->BDI_Pens[Index]]=
  288.           BTDDrawInfo->BDI_Green[BTDDrawInfo->BDI_Pens[Index+1]];
  289.          BTDDrawInfo->BDI_Blue[BTDDrawInfo->BDI_Pens[Index]]=
  290.           BTDDrawInfo->BDI_Blue[BTDDrawInfo->BDI_Pens[Index+1]];
  291.         }
  292.  
  293.        for (Index=0L; Index<IS->Colors; Index++)
  294.          BTDDrawInfo->BDI_Changed[BTDDrawInfo->BDI_Pens[Index]]=TRUE;
  295.  
  296.        BTDDrawInfo->BDI_Red[BTDDrawInfo->BDI_Pens[Index]]=Red;
  297.        BTDDrawInfo->BDI_Green[BTDDrawInfo->BDI_Pens[Index]]=Green;
  298.        BTDDrawInfo->BDI_Blue[BTDDrawInfo->BDI_Pens[Index]]=Blue;
  299.        BTDDrawInfo->BDI_Changed[BTDDrawInfo->BDI_Pens[Index]]=TRUE;
  300.       }
  301.  
  302.     }
  303.    else
  304.     {
  305.  
  306. /* Dammit, muss das doppelt gemacht werden.. grummel */
  307.  
  308.      IS->str=IEEEDPDiv(IEEEDPFlt(Random(IS,80)+20),IEEEDPFlt(W));
  309.      IS->sti=IEEEDPDiv(IEEEDPFlt(Random(IS,80)+20),IEEEDPFlt(H));
  310.  
  311.      if(IS->Clear)
  312.       {
  313.        SetAPen (BTDDrawInfo->BDI_RPort,BTD_BgPen);
  314.        RectFill (BTDDrawInfo->BDI_RPort,L,T,
  315.                  W-1,T+H-1);
  316.       }
  317.      IS->ypos=T;
  318.      IS->xpos=L;
  319.     }
  320.    
  321.    if(IS->Cycle==1) 
  322.     {
  323.  
  324.      IS->str=IEEEDPDiv(IEEEDPFlt(Random(IS,80)+20),IEEEDPFlt(W));
  325.      IS->sti=IEEEDPDiv(IEEEDPFlt(Random(IS,80)+20),IEEEDPFlt(H));
  326.  
  327.      if(IS->Clear)
  328.       {
  329.        SetAPen (BTDDrawInfo->BDI_RPort,BTD_BgPen);
  330.        RectFill (BTDDrawInfo->BDI_RPort,L,T,
  331.                  L+W-1,T+H-1);
  332.       }
  333.  
  334.      IS->ypos=T;
  335.      IS->xpos=L;
  336.      IS->Cycle=0;
  337.  
  338.     }
  339.   }
  340.  else
  341.   {
  342.  
  343.  
  344.    I=IEEEDPMul(IEEEDPFlt(Y),IS->sti);
  345.  
  346.     {
  347.      R=IEEEDPMul(IEEEDPFlt(X),IS->str);
  348.      if(IS->Formula==0)
  349.       Z=IEEEDPFix(IEEEDPAdd(IEEEDPMul(R,R),IEEEDPMul(I,I)));
  350.       /* i^2,r^2 */
  351.      else
  352.       Z=IEEEDPFix(IEEEDPAdd(IEEEDPMul(R,IEEEDPMul(R,R)),IEEEDPMul(I,IEEEDPMul(I,I))));
  353.       /* i^3,r^3 */
  354.  
  355.      SetAPen (BTDDrawInfo->BDI_RPort,BTDDrawInfo->BDI_Pens[(Z%(IS->Colors))]);
  356.      WritePixel (BTDDrawInfo->BDI_RPort,X,Y);
  357.     }
  358.  
  359.   }
  360. }
  361.  
  362. ULONG PenCountMyBlanker(struct TagItem *TagList)
  363.  
  364. {
  365.  return FindTagData(TagList,IS_Colors,DEF_COLORS);
  366. }
  367.