From d2ede50705e94ab6608dbaee7b51dd59549f0213 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Mon, 3 Mar 2008 12:46:58 +0000 Subject: [PATCH] Renamed. --- Source/OpenTK/Graphics/ColorFormat.cs | 174 ++++++++++++++++++++++++++ 1 file changed, 174 insertions(+) create mode 100644 Source/OpenTK/Graphics/ColorFormat.cs diff --git a/Source/OpenTK/Graphics/ColorFormat.cs b/Source/OpenTK/Graphics/ColorFormat.cs new file mode 100644 index 00000000..81f79396 --- /dev/null +++ b/Source/OpenTK/Graphics/ColorFormat.cs @@ -0,0 +1,174 @@ +#region --- License --- +/* Licensed under the MIT/X11 license. + * Copyright (c) 2006-2008 the OpenTK Team. + * This notice may not be removed from any source distribution. + * See license.txt for licensing detailed licensing details. + */ +#endregion + +using System; +using System.Collections.Generic; +using System.Text; + +namespace OpenTK.Graphics +{ + /// Defines the ColorFormat component of a GraphicsMode. + /// + /// A ColorFormat contains Red, Green, Blue and Alpha components that descibe + /// the allocated bits per pixel for the corresponding color. + /// + public struct ColorFormat + { + byte red, green, blue, alpha; + bool isIndexed; + int bitsPerPixel; + + #region --- Constructors --- + + /// + /// Constructs a new ColorFormat with the specified aggregate bits per pixel. + /// + /// The bits per pixel sum for the Red, Green, Blue and Alpha color channels. + public ColorFormat(int bpp) + { + if (bpp < 0) + throw new ArgumentOutOfRangeException("bpp", "Must be greater or equal to zero."); + red = green = blue = alpha = 0; + bitsPerPixel = bpp; + isIndexed = false; + + switch (bpp) + { + case 32: + Red = Green = Blue = Alpha = 8; + break; + case 24: + Red = Green = Blue = 8; + break; + case 16: + Red = Blue = 5; + Green = 6; + break; + case 15: + Red = Green = Blue = 5; + break; + case 8: + Red = Green = 3; + Blue = 2; + IsIndexed = true; + break; + case 4: + Red = Green = 2; + Blue = 1; + IsIndexed = true; + break; + case 1: + IsIndexed = true; + break; + default: + Red = Blue = Alpha = (byte)(bpp / 4); + Green = (byte)((bpp / 4) + (bpp % 4)); + break; + } + } + + /// + /// Constructs a new ColorFormat with the specified bits per pixel for + /// the Red, Green, Blue and Alpha color channels. + /// + /// Bits per pixel for the Red color channel. + /// Bits per pixel for the Green color channel. + /// Bits per pixel for the Blue color channel. + /// Bits per pixel for the Alpha color channel. + public ColorFormat(int red, int green, int blue, int alpha) + { + if (red < 0 || green < 0 || blue < 0 || alpha < 0) + throw new ArgumentOutOfRangeException("Arguments must be greater or equal to zero."); + this.red = (byte)red; + this.green = (byte)green; + this.blue = (byte)blue; + this.alpha = (byte)alpha; + this.bitsPerPixel = red + green + blue + alpha; + this.isIndexed = false; + if (this.bitsPerPixel < 15) + this.isIndexed = true; + } + + #endregion + + #region --- Public Methods --- + + /// Gets the bits per pixel for the Red channel. + public int Red { get { return red; } private set { red = (byte)value; } } + /// Gets the bits per pixel for the Green channel. + public int Green { get { return green; } private set { green = (byte)value; } } + /// Gets the bits per pixel for the Blue channel. + public int Blue { get { return blue; } private set { blue = (byte)value; } } + /// Gets the bits per pixel for the Alpha channel. + public int Alpha { get { return alpha; } private set { alpha = (byte)value; } } + /// Gets a System.Boolean indicating whether this ColorFormat is indexed. + public bool IsIndexed { get { return isIndexed; } private set { isIndexed = value; } } + /// Gets the sum of Red, Green, Blue and Alpha bits per pixel. + public int BitsPerPixel { get { return bitsPerPixel; } private set { bitsPerPixel = value; } } + + #endregion + + #region --- Operator Overloads --- + + /// + /// Converts the specified bpp into a new ColorFormat. + /// + /// The bits per pixel to convert. + /// A ColorFormat with the specified bits per pixel. + public static implicit operator ColorFormat(int bpp) + { + return new ColorFormat(bpp); + } + + //public static implicit operator int(ColorFormat mode) + //{ + // return mode.BitsPerPixel; + //} + + #endregion + + #region --- Overrides --- + + public override bool Equals(object obj) + { + return (obj is ColorFormat) ? (this == (ColorFormat)obj) : false; + } + + public static bool operator ==(ColorFormat left, ColorFormat right) + { + if ((object)left == (object)null && (object)right != (object)null || + (object)left != (object)null && (object)right == (object)null) + return false; + + if ((object)left == (object)null && (object)right == (object)null) + return true; + + return left.Red == right.Red && + left.Green == right.Green && + left.Blue == right.Blue && + left.Alpha == right.Alpha; + } + + public static bool operator !=(ColorFormat left, ColorFormat right) + { + return !(left == right); + } + + public override int GetHashCode() + { + return Red ^ Green ^ Blue ^ Alpha; + } + + public override string ToString() + { + return string.Format("{0} ({1})", BitsPerPixel, (IsIndexed ? " indexed" : Red.ToString() + Green.ToString() + Blue.ToString() + Alpha.ToString())); + } + + #endregion + } +}