Moved Stars45 to StarsEx

1 files changed, 0 insertions, 294 deletions

diff --git a/Stars45/Color.h b/Stars45/Color.h
deleted file mode 100644
index cecdb4b..0000000
--- a/Stars45/Color.h
+++ /dev/null
@@ -1,294 +0,0 @@
-/*  Starshatter: The Open Source Project
-    Copyright (c) 2021-2022, Starshatter: The Open Source Project Contributors
-    Copyright (c) 2011-2012, Starshatter OpenSource Distribution Contributors
-    Copyright (c) 1997-2006, Destroyer Studios LLC.
-
-    AUTHOR:       John DiCamillo
-
-
-    OVERVIEW
-    ========
-    Universal Color Format class
-*/
-
-#ifndef Color_h
-#define Color_h
-
-#include "Types.h"
-
-// +--------------------------------------------------------------------+
-
-class Video;
-
-// +--------------------------------------------------------------------+
-
-struct ColorFormat
-{
-    ColorFormat(int palsize)
-    : pal(palsize), bpp(8),
-    rdown(0), rshift(0), rmask(0),
-    gdown(0), gshift(0), gmask(0),
-    bdown(0), bshift(0), bmask(0),
-    adown(0), ashift(0), amask(0) { }
-
-    ColorFormat(int size, BYTE r, BYTE rs, BYTE g, BYTE gs, BYTE b, BYTE bs, BYTE a=0, BYTE as=0)
-    : pal(0), bpp(size),
-    rdown(8-r), rshift(rs), rmask(((1<<r)-1)<<rs),
-    gdown(8-g), gshift(gs), gmask(((1<<g)-1)<<gs),
-    bdown(8-b), bshift(bs), bmask(((1<<b)-1)<<bs),
-    adown(8-a), ashift(as), amask(((1<<a)-1)<<as) { }
-
-    int   pal;
-    int   bpp;
-    BYTE  rdown, rshift;
-    BYTE  gdown, gshift;
-    BYTE  bdown, bshift;
-    BYTE  adown, ashift;
-
-    DWORD rmask;
-    DWORD gmask;
-    DWORD bmask;
-    DWORD amask;
-};
-
-// +--------------------------------------------------------------------+
-
-class Color
-{
-    friend class ColorIndex;
-    friend class ColorValue;
-
-public:
-    static const char* TYPENAME() { return "Color"; }
-
-    enum Misc  { SHADE_LEVELS = 64 }; // max 128!
-    enum Mask  { RMask   = 0x00ff0000,
-        GMask   = 0x0000ff00,
-        BMask   = 0x000000ff,
-        AMask   = 0xff000000,
-        RGBMask = 0x00ffffff };
-    enum Shift { RShift  = 16,
-        GShift  =  8,
-        BShift  =  0,
-        AShift  = 24 };
-
-    Color()               : rgba(0)      { }
-    Color(const Color& c) : rgba(c.rgba) { }
-    Color(BYTE r, BYTE g, BYTE b, BYTE a=255) {
-        rgba = (r<<RShift)|(g<<GShift)|(b<<BShift)|(a<<AShift); }
-
-    Color(BYTE index);
-
-    Color&   operator= (const Color& c)       { rgba = c.rgba; return *this; }
-    int      operator==(const Color& c) const { return rgba == c.rgba; }
-    int      operator!=(const Color& c) const { return rgba != c.rgba; }
-    Color&   operator+=(const Color& c);       // simple summation
-
-    Color    operator+(DWORD d) const;
-
-    Color    operator+(const Color& c) const;  // color alpha blending
-    Color    operator*(const Color& c) const;  // color modulation
-    Color    operator*(double scale)   const;
-    Color    dim(double scale)         const;
-
-    void     Set(DWORD value) { rgba = value; }
-    void     Set(BYTE r, BYTE g, BYTE b, BYTE a=255) {
-        rgba = (r<<RShift)|(g<<GShift)|(b<<BShift)|(a<<AShift); }
-
-    DWORD    Value()  const { return rgba;  }
-
-    void     SetRed(BYTE r)    { rgba = (rgba & ~RMask) | (r << RShift); }
-    void     SetGreen(BYTE g)  { rgba = (rgba & ~GMask) | (g << GShift); }
-    void     SetBlue(BYTE b)   { rgba = (rgba & ~BMask) | (b << BShift); }
-    void     SetAlpha(BYTE a)  { rgba = (rgba & ~AMask) | (a << AShift); }
-
-    DWORD    Red()    const { return (rgba & RMask) >> RShift; }
-    DWORD    Green()  const { return (rgba & GMask) >> GShift; }
-    DWORD    Blue()   const { return (rgba & BMask) >> BShift; }
-    DWORD    Alpha()  const { return (rgba & AMask) >> AShift; }
-
-    float    fRed()   const { return (float)(Red()  /255.0); }
-    float    fGreen() const { return (float)(Green()/255.0); }
-    float    fBlue()  const { return (float)(Blue() /255.0); }
-    float    fAlpha() const { return (float)(Alpha()/255.0); }
-
-    BYTE     Index()  const { return table[((rgba&RMask)>>(RShift+3)<<10)|
-        ((rgba&GMask)>>(GShift+3)<< 5)|
-        ((rgba&BMask)>>(BShift+3))]; }
-
-    inline BYTE  IndexedBlend(BYTE dst) const;
-    static DWORD FormattedBlend(DWORD c1, DWORD c2);
-
-    DWORD    TextureFormat(int keep_alpha=0)  const;
-    DWORD    Formatted()                      const;
-    DWORD    Unfaded()                        const;
-    Color    ShadeColor(int shade)            const;
-    DWORD    Shaded(int shade)                const;
-    Color    Faded()                          const;
-
-    // some useful colors
-    static   Color          White;
-    static   Color          Black;
-    static   Color          Gray;
-    static   Color          LightGray;
-    static   Color          DarkGray;
-    static   Color          BrightRed;
-    static   Color          BrightBlue;
-    static   Color          BrightGreen;
-    static   Color          DarkRed;
-    static   Color          DarkBlue;
-    static   Color          DarkGreen;
-    static   Color          Yellow;
-    static   Color          Cyan;
-    static   Color          Magenta;
-    static   Color          Tan;
-    static   Color          Brown;
-    static   Color          Violet;
-    static   Color          Orange;
-
-    static void UseVideo(Video* v);
-    static void UseFormat(const ColorFormat& cf);
-    static void UseTextureFormat(const ColorFormat& cf, int alpha_level=0);
-    static void WithTextureFormat(int alpha_level=0);
-    static void SetPalette(PALETTEENTRY* pal, int palsize, BYTE* invpal=0);
-    static void SavePalette(const char* basename);
-    static void SetFade(double f, Color c=Black, int build_shade=false);
-
-    static const ColorFormat& GetTextureFormat(int alpha_level=0) { return texture_format[alpha_level]; }
-    static const ColorFormat& GetScreenFormat()                   { return format; }
-
-    // indexed color initialization:
-    static void BuildShadeTable();
-    static void SaveShadeTable(const char* basename);
-    static void BuildBlendTable();
-
-    static double GetFade()       { return fade;       }
-    static Color  GetFadeColor()  { return fade_color; }
-
-    static Color Scale(const Color& c1, const Color& c2, double scale);
-    static Color Unformat(DWORD formatted_color);
-
-private:
-    DWORD    rgba;
-
-    static   bool           standard_format;
-    static   PALETTEENTRY   palette[256];
-    static   BYTE           table[32768];
-    static   ColorFormat    format;
-    static   int            texture_alpha_level;
-    static   ColorFormat    texture_format[4];
-    static   double         fade;
-    static   Color          fade_color;
-    static   Video*         video;
-};
-
-// +--------------------------------------------------------------------+
-
-class ColorValue
-{
-    friend class Color;
-
-public:
-    static const char* TYPENAME() { return "ColorValue"; }
-
-    ColorValue()                     : r(0),   g(0),   b(0),   a(0)      { }
-    ColorValue(const ColorValue& c)  : r(c.r), g(c.g), b(c.b), a(c.a)    { }
-    ColorValue(const Color& c)       : r( c.fRed()   ),
-    g( c.fGreen() ),
-    b( c.fBlue()  ),
-    a( c.fAlpha() )                   { }
-    ColorValue(float ar,
-    float ag,
-    float ab,
-    float aa=1.0f)        : r(ar),  g(ag),  b(ab),  a(aa)     { }
-
-    int         operator==(const ColorValue& c) const { return r==c.r && g==c.g && b==c.b && a==c.a; }
-    int         operator!=(const ColorValue& c) const { return r!=c.r || g!=c.g || b!=c.b || a!=c.a; }
-    ColorValue& operator+=(const ColorValue& c);       // simple summation
-
-    ColorValue  operator+(const ColorValue& c)   const;  // color alpha blending
-    ColorValue  operator*(const ColorValue& c)   const;  // color modulation
-    ColorValue  operator*(double scale)          const;
-    ColorValue  dim(double scale)                const;
-
-    void     Set(float ar, float ag, float ab, float aa=1.0f) { r=ar; g=ag; b=ab; a=aa; }
-
-    void     SetRed(float ar)    { r=ar; }
-    void     SetGreen(float ag)  { g=ag; }
-    void     SetBlue(float ab)   { b=ab; }
-    void     SetAlpha(float aa)  { a=aa; }
-
-    float    Red()    const { return r; }
-    float    Green()  const { return g; }
-    float    Blue()   const { return b; }
-    float    Alpha()  const { return a; }
-
-    Color    ToColor()                        const;
-    DWORD    TextureFormat(int keep_alpha=0)  const { return ToColor().TextureFormat(keep_alpha);  }
-    DWORD    Formatted()                      const { return ToColor().Formatted();                }
-    DWORD    Unfaded()                        const { return ToColor().Unfaded();                  }
-    Color    ShadeColor(int shade)            const { return ToColor().ShadeColor(shade);          }
-    DWORD    Shaded(int shade)                const { return ToColor().Shaded(shade);              }
-    Color    Faded()                          const { return ToColor().Faded();                    }
-
-private:
-    float    r, g, b, a;
-};
-
-// +--------------------------------------------------------------------+
-
-class ColorIndex
-{
-    friend class Color;
-
-public:
-    static const char* TYPENAME() { return "ColorIndex"; }
-
-    ColorIndex()                        : index(0)        { }
-    ColorIndex(const ColorIndex& c)     : index(c.index)  { }
-    ColorIndex(BYTE r, BYTE g, BYTE b)                    { index = Color(r,g,b).Index(); }
-    ColorIndex(BYTE i)                  : index(i)        { }
-
-    ColorIndex& operator= (const ColorIndex& c)       { index = c.index; return *this; }
-    int         operator==(const ColorIndex& c) const { return index == c.index; }
-    int         operator!=(const ColorIndex& c) const { return index != c.index; }
-
-    BYTE     Index()  const { return index; }
-
-    DWORD    Red()    const { return Color::palette[index].peRed;   }
-    DWORD    Green()  const { return Color::palette[index].peGreen; }
-    DWORD    Blue()   const { return Color::palette[index].peBlue;  }
-
-    float    fRed()   const { return (float)(Red()  /255.0); }
-    float    fGreen() const { return (float)(Green()/255.0); }
-    float    fBlue()  const { return (float)(Blue() /255.0); }
-
-    DWORD    TextureFormat()   const { return texture_palette[index];    }
-    DWORD    Unfaded()         const { return unfaded_palette[index];    }
-    DWORD    Formatted()       const { return formatted_palette[index];  }
-    DWORD    Shaded(int shade) const { return shade_table[shade*256+index]; }
-    ColorIndex Faded()         const { return ColorIndex(index);         }
-
-    // note: this will only work in 8-bit color mode...
-    ColorIndex ShadeColor(int s) const { return ColorIndex((BYTE)(shade_table[s*256+index])); }
-
-    // for poly shading optimization
-    static DWORD*  ShadeTable()      { return shade_table; }
-
-    BYTE     IndexedBlend(BYTE dst) const { return blend_table[dst*256+index]; }
-
-private:
-    BYTE     index;
-
-    static   DWORD*   texture_palette;
-    static   DWORD    texture_palettes[4][256];
-    static   DWORD    unfaded_palette[256];
-    static   DWORD    formatted_palette[256];
-    static   DWORD    shade_table[256*256];
-    static   BYTE     blend_table[256*256];
-};
-
-inline BYTE Color::IndexedBlend(BYTE dst) const { return ColorIndex::blend_table[dst*256+Index()]; }
-
-#endif  // Color_h
-