cgmath/src/color/channel.rs

// Copyright 2013 The Lmath Developers. For a full listing of the authors,
// refer to the AUTHORS file at the top-level directory of this distribution.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

/// A color channel
pub trait Channel: Num {
    /// Convert a channel to the enclosing type
    ///
    /// # Example
    ///
    /// ~~~
    /// let chan: f32 = Channel::from(0xFFFFu16);
    /// assert chan == 1.0f32;
    /// ~~~
    pub fn from<T:Channel>(val: T) -> Self;

    pub fn to_channel_u8(&self)    -> u8;
    pub fn to_channel_u16(&self)   -> u16;
    pub fn to_channel_u32(&self)   -> u32;
    pub fn to_channel_u64(&self)   -> u64;
    pub fn to_channel_f32(&self)   -> f32;
    pub fn to_channel_f64(&self)   -> f64;
    pub fn to_channel_float(&self) -> float;
}

impl Channel for u8 {
    #[inline] pub fn from<T:Channel>(val: T) -> u8 { val.to_channel_u8() }

    #[inline] pub fn to_channel_u8(&self)    -> u8    { (*self) }
    #[inline] pub fn to_channel_u16(&self)   -> u16   { (*self as u16 << 8) | (*self) as u16 }
    #[inline] pub fn to_channel_u32(&self)   -> u32   { (self.to_channel_u16() as u32 << 16) | self.to_channel_u16() as u32 }
    #[inline] pub fn to_channel_u64(&self)   -> u64   { (self.to_channel_u32() as u64 << 32) | self.to_channel_u32() as u64 }
    #[inline] pub fn to_channel_f32(&self)   -> f32   { (*self as f32)   / (0xFF as f32)   }
    #[inline] pub fn to_channel_f64(&self)   -> f64   { (*self as f64)   / (0xFF as f64)   }
    #[inline] pub fn to_channel_float(&self) -> float { (*self as float) / (0xFF as float) }
}

impl Channel for u16 {
    #[inline] pub fn from<T:Channel>(val: T) -> u16 { val.to_channel_u16() }

    #[inline] pub fn to_channel_u8(&self)    -> u8    { (*self >> 8) as u8 }    // this is the equivalent of `self/256`. Some folks prefer to do `self/257`
    #[inline] pub fn to_channel_u16(&self)   -> u16   { (*self) }
    #[inline] pub fn to_channel_u32(&self)   -> u32   { (*self as u32 << 16) | (*self) as u32 }
    #[inline] pub fn to_channel_u64(&self)   -> u64   { (self.to_channel_u32() as u64 << 32) | self.to_channel_u32() as u64 }
    #[inline] pub fn to_channel_f32(&self)   -> f32   { (*self) / 0xFFFF as f32   }
    #[inline] pub fn to_channel_f64(&self)   -> f64   { (*self) / 0xFFFF as f64   }
    #[inline] pub fn to_channel_float(&self) -> float { (*self) / 0xFFFF as float }
}

impl Channel for u32 {
    #[inline] pub fn from<T:Channel>(val: T) -> u32 { val.to_channel_u32() }

    #[inline] pub fn to_channel_u8(&self)    -> u8    { (*self >> 24) as u8 }
    #[inline] pub fn to_channel_u16(&self)   -> u16   { (*self >> 16) as u16 }
    #[inline] pub fn to_channel_u32(&self)   -> u32   { (*self) }
    #[inline] pub fn to_channel_u64(&self)   -> u64   { (*self as u64 << 32) | (*self) as u64 }
    #[inline] pub fn to_channel_f32(&self)   -> f32   { (*self) / 0xFFFF_FFFF as f32   }
    #[inline] pub fn to_channel_f64(&self)   -> f64   { (*self) / 0xFFFF_FFFF as f64   }
    #[inline] pub fn to_channel_float(&self) -> float { (*self) / 0xFFFF_FFFF as float }
}

impl Channel for u64 {
    #[inline] pub fn from<T:Channel>(val: T) -> u64 { val.to_channel_u64() }

    #[inline] pub fn to_channel_u8(&self)    -> u8    { (*self >> 56) as u8 }
    #[inline] pub fn to_channel_u16(&self)   -> u16   { (*self >> 48) as u16 }
    #[inline] pub fn to_channel_u32(&self)   -> u32   { (*self >> 32) as u32 }
    #[inline] pub fn to_channel_u64(&self)   -> u64   { (*self) }
    #[inline] pub fn to_channel_f32(&self)   -> f32   { (*self) / 0xFFFF_FFFF_FFFF_FFFF_u64 as f32   }
    #[inline] pub fn to_channel_f64(&self)   -> f64   { (*self) / 0xFFFF_FFFF_FFFF_FFFF_u64 as f64   }
    #[inline] pub fn to_channel_float(&self) -> float { (*self) / 0xFFFF_FFFF_FFFF_FFFF_u64 as float }
}

impl Channel for f32 {
    #[inline] pub fn from<T:Channel>(val: T) -> f32 { val.to_channel_f32() }


    #[inline] pub fn to_channel_u8(&self)    -> u8    { (*self) * (0xFF_u8    as f32) as u8  }
    #[inline] pub fn to_channel_u16(&self)   -> u16   { (*self) * (0xFFFF_u16 as f32) as u16 }
    #[inline] pub fn to_channel_u32(&self)   -> u32   { fail!(~"to_channel_u32 not yet implemented for f32") }
    #[inline] pub fn to_channel_u64(&self)   -> u64   { fail!(~"to_channel_u64 not yet implemented for f32") }
    #[inline] pub fn to_channel_f32(&self)   -> f32   { (*self) }
    #[inline] pub fn to_channel_f64(&self)   -> f64   { (*self) as f64 }
    #[inline] pub fn to_channel_float(&self) -> float { (*self) as float }
}

impl Channel for f64 {
    #[inline] pub fn from<T:Channel>(val: T) -> f64 { val.to_channel_f64() }

    #[inline] pub fn to_channel_u8(&self)    -> u8    { (*self) * (0xFF_u8    as f64) as u8  }
    #[inline] pub fn to_channel_u16(&self)   -> u16   { (*self) * (0xFFFF_u16 as f64) as u16 }
    #[inline] pub fn to_channel_u32(&self)   -> u32   { fail!(~"to_channel_u32 not yet implemented for f64") }
    #[inline] pub fn to_channel_u64(&self)   -> u64   { fail!(~"to_channel_u64 not yet implemented for f64") }
    #[inline] pub fn to_channel_f32(&self)   -> f32   { (*self) as f32 }
    #[inline] pub fn to_channel_f64(&self)   -> f64   { (*self) }
    #[inline] pub fn to_channel_float(&self) -> float { (*self) as float }
}

impl Channel for float {
    #[inline] pub fn from<T:Channel>(val: T) -> float { val.to_channel_float() }

    #[inline] pub fn to_channel_u8(&self)    -> u8    { (*self) * (0xFF_u8    as float) as u8  }
    #[inline] pub fn to_channel_u16(&self)   -> u16   { (*self) * (0xFFFF_u16 as float) as u16 }
    #[inline] pub fn to_channel_u32(&self)   -> u32   { fail!(~"to_channel_u32 not yet implemented for float") }
    #[inline] pub fn to_channel_u64(&self)   -> u64   { fail!(~"to_channel_u64 not yet implemented for float") }
    #[inline] pub fn to_channel_f32(&self)   -> f32   { (*self) as f32 }
    #[inline] pub fn to_channel_f64(&self)   -> f64   { (*self) as f64 }
    #[inline] pub fn to_channel_float(&self) -> float { (*self) }
}