BrawlLib.Imaging.RGBAPixel Struct Reference

Inheritance diagram for BrawlLib.Imaging.RGBAPixel:

Public Member Functions
	RGBAPixel (byte r, byte g, byte b, byte a)
	RGBAPixel (uint u)
override string	ToString ()
override int	GetHashCode ()
override bool	Equals (object obj)
int	CompareTo (object obj)

Static Public Member Functions
static implicit	operator RGBAPixel (ARGBPixel p)
static implicit	operator ARGBPixel (RGBAPixel p)
static	operator Color (RGBAPixel p)
static implicit	operator RGBAPixel (Vector4 p)
static implicit	operator Vector4 (RGBAPixel p)
static implicit	operator Vector3 (RGBAPixel p)
static implicit	operator RGBAPixel (uint u)
static implicit	operator uint (RGBAPixel p)
static RGBAPixel	operator& (RGBAPixel p1, RGBAPixel p2)
static RGBAPixel	operator| (RGBAPixel p1, RGBAPixel p2)
static bool	operator== (RGBAPixel p1, RGBAPixel p2)
static bool	operator!= (RGBAPixel p1, RGBAPixel p2)
static int	Compare (RGBAPixel p1, RGBAPixel p2)
static RGBAPixel	Parse (string s)

Public Attributes
byte	R
byte	G
byte	B
byte	A

Static Public Attributes
const float	ColorFactor = 1.0f / 255.0f

Properties
byte	Red [get, set]
byte	Green [get, set]
byte	Blue [get, set]
byte	Alpha [get, set]
VoidPtr	Address [get]

Constructor & Destructor Documentation

RGBAPixel() [1/2]

BrawlLib.Imaging.RGBAPixel.RGBAPixel ( byte  r, byte  g, byte  b, byte  a  )

inline

        {
            R = r;
            G = g;
            B = b;
            A = a;
        }

RGBAPixel() [2/2]

BrawlLib.Imaging.RGBAPixel.RGBAPixel ( uint  u )

inline

        {
            string temp = u.ToString("X8");
            R = Convert.ToByte(temp.Substring(0, 2), 16);
            G = Convert.ToByte(temp.Substring(2, 2), 16);
            B = Convert.ToByte(temp.Substring(4, 2), 16);
            A = Convert.ToByte(temp.Substring(6, 2), 16);
        }

Member Function Documentation

Compare()

static int BrawlLib.Imaging.RGBAPixel.Compare ( RGBAPixel  p1, RGBAPixel  p2  )

inlinestatic

        {
            int v1 = *(int*) &p1;
            int v2 = *(int*) &p2;
 
            if (v1 > v2)
            {
                return 1;
            }
 
            if (v1 < v2)
            {
                return -1;
            }
 
            return 1;
        }

CompareTo()

int BrawlLib.Imaging.RGBAPixel.CompareTo ( object  obj )

inline

        {
            if (obj is RGBAPixel)
            {
                RGBAPixel o = (RGBAPixel) obj;
                if (A > o.A)
                {
                    return 1;
                }
 
                if (A < o.A)
                {
                    return -1;
                }
 
                if (R > o.R)
                {
                    return 1;
                }
 
                if (R < o.R)
                {
                    return -1;
                }
 
                if (G > o.G)
                {
                    return 1;
                }
 
                if (G < o.G)
                {
                    return -1;
                }
 
                if (B > o.B)
                {
                    return 1;
                }
 
                if (B < o.B)
                {
                    return -1;
                }
 
                return 0;
            }
 
            return 1;
        }

Equals()

override bool BrawlLib.Imaging.RGBAPixel.Equals ( object  obj )

inline

        {
            if (obj is RGBAPixel)
            {
                return this == (RGBAPixel) obj;
            }
 
            return false;
        }

GetHashCode()

override int BrawlLib.Imaging.RGBAPixel.GetHashCode ( )

inline

        {
            fixed (RGBAPixel* p = &this)
            {
                return *(int*) p;
            }
        }

operator ARGBPixel()

static implicit BrawlLib.Imaging.RGBAPixel.operator ARGBPixel ( RGBAPixel  p )

inlinestatic

        {
            return new ARGBPixel {A = p.A, B = p.B, G = p.G, R = p.R};
        }

operator Color()

static BrawlLib.Imaging.RGBAPixel.operator Color ( RGBAPixel  p )

inlineexplicitstatic

        {
            ARGBPixel a = p;
            return Color.FromArgb((int) a);
        }

operator RGBAPixel() [1/3]

static implicit BrawlLib.Imaging.RGBAPixel.operator RGBAPixel ( ARGBPixel  p )

inlinestatic

        {
            return new RGBAPixel {A = p.A, B = p.B, G = p.G, R = p.R};
        }

operator RGBAPixel() [2/3]

static implicit BrawlLib.Imaging.RGBAPixel.operator RGBAPixel ( uint  u )

inlinestatic

        {
            return new RGBAPixel(u);
        }

operator RGBAPixel() [3/3]

static implicit BrawlLib.Imaging.RGBAPixel.operator RGBAPixel ( Vector4  p )

inlinestatic

        {
            return new RGBAPixel((byte) (p._x * 255.0f), (byte) (p._y * 255.0f), (byte) (p._z * 255.0f),
                (byte) (p._w * 255.0f));
        }

operator uint()

static implicit BrawlLib.Imaging.RGBAPixel.operator uint ( RGBAPixel  p )

inlinestatic

        {
            return BitConverter.ToUInt32(new byte[] {p.R, p.G, p.B, p.A}, 0);
        }

operator Vector3()

static implicit BrawlLib.Imaging.RGBAPixel.operator Vector3 ( RGBAPixel  p )

inlinestatic

        {
            return new Vector3(p.R / 255.0f, p.G / 255.0f, p.B / 255.0f);
        }

operator Vector4()

static implicit BrawlLib.Imaging.RGBAPixel.operator Vector4 ( RGBAPixel  p )

inlinestatic

        {
            return new Vector4(p.R / 255.0f, p.G / 255.0f, p.B / 255.0f, p.A / 255.0f);
        }

operator!=()

static bool BrawlLib.Imaging.RGBAPixel.operator!= ( RGBAPixel  p1, RGBAPixel  p2  )

inlinestatic

        {
            return *(int*) &p1 != *(int*) &p2;
        }

operator&()

static RGBAPixel BrawlLib.Imaging.RGBAPixel.operator& ( RGBAPixel  p1, RGBAPixel  p2  )

inlinestatic

        {
            return new RGBAPixel((byte) (p1.R & p2.R), (byte) (p1.G & p2.G), (byte) (p1.B & p2.B),
                (byte) (p1.A & p2.A));
        }

operator==()

static bool BrawlLib.Imaging.RGBAPixel.operator== ( RGBAPixel  p1, RGBAPixel  p2  )

inlinestatic

        {
            return *(int*) &p1 == *(int*) &p2;
        }

operator|()

static RGBAPixel BrawlLib.Imaging.RGBAPixel.operator| ( RGBAPixel  p1, RGBAPixel  p2  )

inlinestatic

        {
            return new RGBAPixel((byte) (p1.R | p2.R), (byte) (p1.G | p2.G), (byte) (p1.B | p2.B),
                (byte) (p1.A | p2.A));
        }

Parse()

static RGBAPixel BrawlLib.Imaging.RGBAPixel.Parse ( string  s )

inlinestatic

        {
            RGBAPixel p;
            byte* ptr = (byte*) &p;
            for (int i = 0; i < 8; i += 2)
            {
                *ptr++ = s.Length >= i + 2
                    ? byte.Parse(s.Substring(i, 2), System.Globalization.NumberStyles.HexNumber)
                    : (byte) (i == 6 ? 0xFF : 0);
            }
 
            return p;
        }

ToString()

override string BrawlLib.Imaging.RGBAPixel.ToString ( )

inline

        {
            //return String.Format("R:{0:X2} G:{1:X2} B:{2:X2} A:{3:X2}", R, G, B, A);
            return $"R:{R} G:{G} B:{B} A:{A}";
        }

Member Data Documentation

A

byte BrawlLib.Imaging.RGBAPixel.A

B

byte BrawlLib.Imaging.RGBAPixel.B

ColorFactor

const float BrawlLib.Imaging.RGBAPixel.ColorFactor = 1.0f / 255.0f

static

G

byte BrawlLib.Imaging.RGBAPixel.G

R

byte BrawlLib.Imaging.RGBAPixel.R

Property Documentation

Address

VoidPtr BrawlLib.Imaging.RGBAPixel.Address

get

        {
            get
            {
                fixed (void* p = &this)
                {
                    return p;
                }
            }
        }

Alpha

byte BrawlLib.Imaging.RGBAPixel.Alpha

getset

        {
            get => A;
            set => A = value;
        }

Blue

byte BrawlLib.Imaging.RGBAPixel.Blue

getset

        {
            get => B;
            set => B = value;
        }

Green

byte BrawlLib.Imaging.RGBAPixel.Green

getset

        {
            get => G;
            set => G = value;
        }

Red

byte BrawlLib.Imaging.RGBAPixel.Red

getset

        {
            get => R;
            set => R = value;
        }

---

The documentation for this struct was generated from the following file:

• BrawlLib/Imaging/PixelTypes.cs