home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / alib / d8xx / d835 / mandelsquare.lha / MandelSquare / MandelSquare-1.06.lha / Palette.c < prev    next >
C/C++ Source or Header  |  1992-10-24  |  8KB  |  399 lines
  1. /*
  2. **    MandelSquare - AmigaDOS 2.0/3.0 Mandelbrot set explorer
  3. **
  4. **    Palette.c, Colour palette management routines
  5. **
  6. **    Copyright © 1991-1992 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10.     /* A palette template, to be filled in later. */
  11.  
  12. struct Palette
  13. {
  14.     APTR            Colours;
  15.     LONG            NumColours;
  16.     struct ColourRecord *    Record;
  17. };
  18.  
  19.     /* A 32 bit colour triplet. */
  20.  
  21. struct ColourTriplet
  22. {
  23.     ULONG            Red,
  24.                 Green,
  25.                 Blue;
  26. };
  27.  
  28.     /* A set of colour palette entries, suitable for submitting
  29.      * to LoadRGB32().
  30.      */
  31.  
  32. struct ColourRecord
  33. {
  34.         /* Number of colour registers to set. */
  35.  
  36.     WORD            NumColours;
  37.  
  38.         /* Offset of the first colour to set. */
  39.  
  40.     WORD            FirstColour;
  41.  
  42.         /* Space for at least one colour triplet. Note:
  43.          * this entry is bound to grow.
  44.          */
  45.  
  46.     struct ColourTriplet    Triplets[1];
  47.  
  48.         /* The trick: the last word will serve as an array
  49.          * terminator as the record is bound to grow in
  50.          * triplets only.
  51.          */
  52.  
  53.     WORD            Terminator;
  54. };
  55.  
  56.     /* Global flag. */
  57.  
  58. extern BYTE        Is39;
  59.  
  60.     /* Exported routines. */
  61.  
  62. VOID            FreePalette(struct Palette *Palette);
  63. struct Palette *    AllocPalette(LONG NumColours,BYTE TrueColour);
  64. struct Palette *    GetPalette(struct Screen *Screen,struct Palette *Palette);
  65. VOID            LoadPalette(struct Screen *Screen,struct Palette *Palette,LONG NumColours);
  66. LONG            GetPaletteSize(struct Palette *Palette);
  67. BYTE            GetPaletteTriplet(struct Palette *Palette,UBYTE *Triplet,LONG Index);
  68. BYTE            SetPaletteTriplet(struct Palette *Palette,UBYTE R,UBYTE G,UBYTE B,LONG Index);
  69. ULONG            GetPaletteEntry(struct Palette *Palette,LONG Index);
  70. BYTE            SetPaletteEntry(struct Palette *Palette,ULONG Entry,LONG Index);
  71.  
  72.     /* FreePalette(struct Palette *Palette):
  73.      *
  74.      *    Free palette memory.
  75.      */
  76.  
  77. VOID
  78. FreePalette(struct Palette *Palette)
  79. {
  80.     if(Palette)
  81.     {
  82.         if(Palette -> Colours)
  83.             FreeVec(Palette -> Colours);
  84.  
  85.         if(Palette -> Record)
  86.             FreeVec(Palette -> Record);
  87.  
  88.         FreeVec(Palette);
  89.     }
  90. }
  91.  
  92.     /* AllocPalette(LONG NumColours,BYTE TrueColour):
  93.      *
  94.      *    Allocate palette memory.
  95.      */
  96.  
  97. struct Palette *
  98. AllocPalette(LONG NumColours,BYTE TrueColour)
  99. {
  100.     if(NumColours)
  101.     {
  102.         struct Palette *Palette;
  103.  
  104.             /* Allocate the template. */
  105.  
  106.         if(Palette = (struct Palette *)AllocVec(sizeof(struct Palette),MEMF_ANY | MEMF_CLEAR))
  107.         {
  108.                 /* Pick up the number of colours. */
  109.  
  110.             Palette -> NumColours = NumColours;
  111.  
  112.                 /* Are we to use a true colour palette (24 bits)? */
  113.  
  114.             if(Is39 && TrueColour)
  115.             {
  116.                     /* Allocate 24 colour palette. */
  117.  
  118.                 if(Palette -> Colours = AllocVec(sizeof(ULONG) * Palette -> NumColours,MEMF_ANY | MEMF_CLEAR))
  119.                 {
  120.                         /* Allocate colour records. */
  121.  
  122.                     if(Palette -> Record = (struct ColourRecord *)AllocVec(sizeof(struct ColourRecord) + ((NumColours - 1) * sizeof(struct ColourTriplet)),MEMF_ANY | MEMF_CLEAR))
  123.                         return(Palette);
  124.                     else
  125.                         FreeVec(Palette -> Colours);
  126.                 }
  127.                 else
  128.                     return(Palette);
  129.             }
  130.             else
  131.             {
  132.                     /* Allocate standard palette. */
  133.  
  134.                 if(Palette -> Colours = AllocVec(sizeof(UWORD) * Palette -> NumColours,MEMF_ANY | MEMF_CLEAR))
  135.                     return(Palette);
  136.             }
  137.  
  138.             FreeVec(Palette);
  139.         }
  140.     }
  141.  
  142.     return(NULL);
  143. }
  144.  
  145.     /* GetPalette(struct Screen *Screen,struct Palette *Palette):
  146.      *
  147.      *    Get the screen colours palette.
  148.      */
  149.  
  150. struct Palette *
  151. GetPalette(struct Screen *Screen,struct Palette *Palette)
  152. {
  153.     if(Screen)
  154.     {
  155.         LONG i;
  156.  
  157.             /* No palette given? Allocate a new one... */
  158.  
  159.         if(!Palette)
  160.         {
  161.             if(!(Palette = AllocPalette(Screen -> ViewPort . ColorMap -> Count,Screen -> ViewPort . ColorMap -> Count == 256)))
  162.                 return(NULL);
  163.         }
  164.  
  165.             /* v39 true colour palette? */
  166.  
  167.         if(Palette -> Record)
  168.         {
  169.             ULONG    *Colours = Palette -> Colours,
  170.                  Triplet[3];
  171.  
  172.                 /* Run down the table... */
  173.  
  174.             for(i = 0 ; i < Palette -> NumColours ; i++)
  175.             {
  176.                     /* Query the colour table entry. */
  177.  
  178.                 GetRGB32(Screen -> ViewPort . ColorMap,i,1,Triplet);
  179.  
  180.                     /* Only eight colours so far. */
  181.  
  182.                 Triplet[0] >>= 24;
  183.                 Triplet[1] >>= 24;
  184.                 Triplet[2] >>= 24;
  185.  
  186.                     /* Build new entry. */
  187.  
  188.                 Colours[i] = (Triplet[0] << 16) | (Triplet[1] << 8) | Triplet[2];
  189.             }
  190.         }
  191.         else
  192.         {
  193.             UWORD *Colours = Palette -> Colours;
  194.  
  195.                 /* Fill the table. */
  196.  
  197.             for(i = 0 ; i < Palette -> NumColours ; i++)
  198.                 Colours[i] = GetRGB4(Screen -> ViewPort . ColorMap,i);
  199.         }
  200.  
  201.         return(Palette);
  202.     }
  203.  
  204.     return(NULL);
  205. }
  206.  
  207.     /* LoadPalette(struct Screen *Screen,struct Palette *Palette,LONG NumColours):
  208.      *
  209.      *    Load the screen palette.
  210.      */
  211.  
  212. VOID
  213. LoadPalette(struct Screen *Screen,struct Palette *Palette,LONG NumColours)
  214. {
  215.     if(Screen && Palette)
  216.     {
  217.             /* Set up number of colours if invalid. */
  218.  
  219.         if(NumColours > Palette -> NumColours || !NumColours)
  220.             NumColours = Palette -> NumColours;
  221.  
  222.             /* Not too much, please. */
  223.  
  224.         if(NumColours > Screen -> ViewPort . ColorMap -> Count)
  225.             NumColours = Screen -> ViewPort . ColorMap -> Count;
  226.  
  227.             /* v39 true colour palette? */
  228.  
  229.         if(Palette -> Record)
  230.         {
  231.             ULONG    *Colours = Palette -> Colours;
  232.             LONG     i;
  233.  
  234.                 /* Set up the colour records. */
  235.  
  236.             for(i = 0 ; i < NumColours ; i++)
  237.             {
  238.                 Palette -> Record -> Triplets[i] . Red        = (0xFFFFFFFF / 255) * ((Colours[i] >> 16) & 0xFF);
  239.                 Palette -> Record -> Triplets[i] . Green    = (0xFFFFFFFF / 255) * ((Colours[i] >>  8) & 0xFF);
  240.                 Palette -> Record -> Triplets[i] . Blue        = (0xFFFFFFFF / 255) * ((Colours[i]      ) & 0xFF);
  241.             }
  242.  
  243.                 /* Fill in the number of colours to display. */
  244.  
  245.             Palette -> Record -> NumColours = NumColours;
  246.  
  247.                 /* Load the palette. */
  248.  
  249.             LoadRGB32(&Screen -> ViewPort,(ULONG *)Palette -> Record);
  250.         }
  251.         else
  252.             LoadRGB4(&Screen -> ViewPort,Palette -> Colours,NumColours);
  253.     }
  254. }
  255.  
  256.     /* GetPaletteSize(struct Palette *Palette):
  257.      *
  258.      *    Query the size of the palette.
  259.      */
  260.  
  261. LONG
  262. GetPaletteSize(struct Palette *Palette)
  263. {
  264.     if(Palette)
  265.         return(Palette -> NumColours);
  266.     else
  267.         return(0);
  268. }
  269.  
  270.     /* GetPaletteTriplet(struct Palette *Palette,UBYTE *Triplet,LONG Index):
  271.      *
  272.      *    Fill in a single colour triplet.
  273.      */
  274.  
  275. BYTE
  276. GetPaletteTriplet(struct Palette *Palette,UBYTE *Triplet,LONG Index)
  277. {
  278.     if(Palette)
  279.     {
  280.         if(Index <= Palette -> NumColours)
  281.         {
  282.             if(Palette -> Record)
  283.             {
  284.                 ULONG *Colours = Palette -> Colours;
  285.  
  286.                 Triplet[0] = (Colours[Index] >> 16) & 0xFF;
  287.                 Triplet[1] = (Colours[Index] >>  8) & 0xFF;
  288.                 Triplet[2] = (Colours[Index]      ) & 0xFF;
  289.             }
  290.             else
  291.             {
  292.                 UWORD *Colours = Palette -> Colours;
  293.  
  294.                 Triplet[0] = (Colours[Index] >> 8) & 0xF;
  295.                 Triplet[1] = (Colours[Index] >> 4) & 0xF;
  296.                 Triplet[2] = (Colours[Index]     ) & 0xF;
  297.             }
  298.  
  299.             return(TRUE);
  300.         }
  301.     }
  302.  
  303.     return(FALSE);
  304. }
  305.  
  306.     /* SetPaletteTriplet(struct Palette *Palette,UBYTE R,UBYTE G,UBYTE B,LONG Index):
  307.      *
  308.      *    Set a single colour triplet.
  309.      */
  310.  
  311. BYTE
  312. SetPaletteTriplet(struct Palette *Palette,UBYTE R,UBYTE G,UBYTE B,LONG Index)
  313. {
  314.     if(Palette)
  315.     {
  316.         if(Index <= Palette -> NumColours)
  317.         {
  318.             if(Palette -> Record)
  319.             {
  320.                 ULONG *Colours = Palette -> Colours;
  321.  
  322.                 Colours[Index] = (R << 16) | (G << 8) | B;
  323.             }
  324.             else
  325.             {
  326.                 UWORD *Colours = Palette -> Colours;
  327.  
  328.                 Colours[Index] = (R << 8) | (G << 4) | B;
  329.             }
  330.  
  331.             return(TRUE);
  332.         }
  333.     }
  334.  
  335.     return(FALSE);
  336. }
  337.  
  338.     /* GetPaletteEntry(struct Palette *Palette,LONG Index):
  339.      *
  340.      *    Query a packed colour table entry.
  341.      */
  342.  
  343. ULONG
  344. GetPaletteEntry(struct Palette *Palette,LONG Index)
  345. {
  346.     if(Palette)
  347.     {
  348.         if(Index <= Palette -> NumColours)
  349.         {
  350.             if(Palette -> Record)
  351.             {
  352.                 ULONG *Colours = Palette -> Colours;
  353.  
  354.                 return(Colours[Index]);
  355.             }
  356.             else
  357.             {
  358.                 UWORD *Colours = Palette -> Colours;
  359.  
  360.                 return((ULONG)Colours[Index]);
  361.             }
  362.         }
  363.     }
  364.  
  365.     return(0);
  366. }
  367.  
  368.     /* SetPaletteEntry(struct Palette *Palette,ULONG Entry,LONG Index):
  369.      *
  370.      *    Set a packed colour table entry.
  371.      */
  372.  
  373. BYTE
  374. SetPaletteEntry(struct Palette *Palette,ULONG Entry,LONG Index)
  375. {
  376.     if(Palette)
  377.     {
  378.         if(Index <= Palette -> NumColours)
  379.         {
  380.             if(Palette -> Record)
  381.             {
  382.                 ULONG *Colours = Palette -> Colours;
  383.  
  384.                 Colours[Index] = Entry;
  385.             }
  386.             else
  387.             {
  388.                 UWORD *Colours = Palette -> Colours;
  389.  
  390.                 Colours[Index] = Entry;
  391.             }
  392.  
  393.             return(TRUE);
  394.         }
  395.     }
  396.  
  397.     return(FALSE);
  398. }
  399.