From e334fd9afea769206f6aba087ae08c4e851d4f5c Mon Sep 17 00:00:00 2001
From: the_fiddler <the_fiddler@ebc5dd9b-fb1d-0410-b6f8-d24c324e9604>
Date: Thu, 28 Feb 2008 13:38:19 +0000
Subject: [PATCH] Initial commit.
---
Source/OpenTK/Graphics/ColorDepth.cs | 174 +++++++++++++++++++++++++++
1 file changed, 174 insertions(+)
create mode 100644 Source/OpenTK/Graphics/ColorDepth.cs
diff --git a/Source/OpenTK/Graphics/ColorDepth.cs b/Source/OpenTK/Graphics/ColorDepth.cs
new file mode 100644
index 00000000..f71f00d8
--- /dev/null
+++ b/Source/OpenTK/Graphics/ColorDepth.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
+{
+ /// <summary>Defines the ColorDepth component of a GraphicsFormat.</summary>
+ /// <remarks>
+ /// <para>A ColorDepth contains Red, Green, Blue and Alpha components that descibe
+ /// the allocated bits per pixel for the corresponding color.</para>
+ /// </remarks>
+ public struct ColorDepth
+ {
+ byte red, green, blue, alpha;
+ bool isIndexed;
+ int bitsPerPixel;
+
+ #region --- Constructors ---
+
+ /// <summary>
+ /// Constructs a new ColorDepth with the specified aggregate bits per pixel.
+ /// </summary>
+ /// <param name="bpp">The bits per pixel sum for the Red, Green, Blue and Alpha color channels.</param>
+ public ColorDepth(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;
+ }
+ }
+
+ /// <summary>
+ /// Constructs a new ColorDepth with the specified bits per pixel for
+ /// the Red, Green, Blue and Alpha color channels.
+ /// </summary>
+ /// <param name="red">Bits per pixel for the Red color channel.</param>
+ /// <param name="green">Bits per pixel for the Green color channel.</param>
+ /// <param name="blue">Bits per pixel for the Blue color channel.</param>
+ /// <param name="alpha">Bits per pixel for the Alpha color channel.</param>
+ public ColorDepth(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 ---
+
+ /// <summary>Gets the bits per pixel for the Red channel.</summary>
+ public int Red { get { return red; } private set { red = (byte)value; } }
+ /// <summary>Gets the bits per pixel for the Green channel.</summary>
+ public int Green { get { return green; } private set { green = (byte)value; } }
+ /// <summary>Gets the bits per pixel for the Blue channel.</summary>
+ public int Blue { get { return blue; } private set { blue = (byte)value; } }
+ /// <summary>Gets the bits per pixel for the Alpha channel.</summary>
+ public int Alpha { get { return alpha; } private set { alpha = (byte)value; } }
+ /// <summary>Gets a System.Boolean indicating whether this ColorDepth is indexed.</summary>
+ public bool IsIndexed { get { return isIndexed; } private set { isIndexed = value; } }
+ /// <summary>Gets the sum of Red, Green, Blue and Alpha bits per pixel.</summary>
+ public int BitsPerPixel { get { return bitsPerPixel; } private set { bitsPerPixel = value; } }
+
+ #endregion
+
+ #region --- Operator Overloads ---
+
+ /// <summary>
+ /// Converts the specified bpp into a new ColorDepth.
+ /// </summary>
+ /// <param name="bpp">The bits per pixel to convert.</param>
+ /// <returns>A ColorDepth with the specified bits per pixel.</returns>
+ public static implicit operator ColorDepth(int bpp)
+ {
+ return new ColorDepth(bpp);
+ }
+
+ //public static implicit operator int(ColorDepth mode)
+ //{
+ // return mode.BitsPerPixel;
+ //}
+
+ #endregion
+
+ #region --- Overrides ---
+
+ public override bool Equals(object obj)
+ {
+ return (obj is ColorDepth) ? (this == (ColorDepth)obj) : false;
+ }
+
+ public static bool operator ==(ColorDepth left, ColorDepth 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 !=(ColorDepth left, ColorDepth 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
+ }
+}