pub unsafe trait Pixel {
type Encoding: Copy;
type RawEncoding: Copy;
type SamplerType: SamplerType;
fn pixel_format() -> PixelFormat;
}
pub unsafe trait ColorPixel: Pixel {}
pub unsafe trait DepthPixel: Pixel {}
pub unsafe trait RenderablePixel: Pixel {}
pub unsafe trait SamplerType {
fn sample_type() -> Type;
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct PixelFormat {
pub encoding: Type,
pub format: Format,
}
impl PixelFormat {
pub fn is_color_pixel(self) -> bool {
match self.format {
Format::Depth(_) => false,
_ => true,
}
}
pub fn is_depth_pixel(self) -> bool {
!self.is_color_pixel()
}
pub fn canals_len(self) -> usize {
match self.format {
Format::R(_) => 1,
Format::RG(_, _) => 2,
Format::RGB(_, _, _) => 3,
Format::RGBA(_, _, _, _) => 4,
Format::SRGB(_, _, _) => 3,
Format::SRGBA(_, _, _, _) => 4,
Format::Depth(_) => 1,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Type {
NormIntegral,
NormUnsigned,
Integral,
Unsigned,
Floating,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Format {
R(Size),
RG(Size, Size),
RGB(Size, Size, Size),
RGBA(Size, Size, Size, Size),
SRGB(Size, Size, Size),
SRGBA(Size, Size, Size, Size),
Depth(Size),
}
impl Format {
pub fn size(self) -> usize {
let bits = match self {
Format::R(r) => r.bits(),
Format::RG(r, g) => r.bits() + g.bits(),
Format::RGB(r, g, b) => r.bits() + g.bits() + b.bits(),
Format::RGBA(r, g, b, a) => r.bits() + g.bits() + b.bits() + a.bits(),
Format::SRGB(r, g, b) => r.bits() + g.bits() + b.bits(),
Format::SRGBA(r, g, b, a) => r.bits() + g.bits() + b.bits() + a.bits(),
Format::Depth(d) => d.bits(),
};
bits / 8
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Size {
Eight,
Ten,
Eleven,
Sixteen,
ThirtyTwo,
}
impl Size {
pub fn bits(self) -> usize {
match self {
Size::Eight => 8,
Size::Ten => 10,
Size::Eleven => 11,
Size::Sixteen => 16,
Size::ThirtyTwo => 32,
}
}
}
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct NormIntegral;
unsafe impl SamplerType for NormIntegral {
fn sample_type() -> Type {
Type::NormIntegral
}
}
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct NormUnsigned;
unsafe impl SamplerType for NormUnsigned {
fn sample_type() -> Type {
Type::NormUnsigned
}
}
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct Integral;
unsafe impl SamplerType for Integral {
fn sample_type() -> Type {
Type::Integral
}
}
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct Unsigned;
unsafe impl SamplerType for Unsigned {
fn sample_type() -> Type {
Type::Unsigned
}
}
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct Floating;
unsafe impl SamplerType for Floating {
fn sample_type() -> Type {
Type::Floating
}
}
macro_rules! impl_Pixel {
($t:ty, $encoding:ty, $raw_encoding:ty, $encoding_ty:ident, $format:expr) => {
unsafe impl Pixel for $t {
type Encoding = $encoding;
type RawEncoding = $raw_encoding;
type SamplerType = $encoding_ty;
fn pixel_format() -> PixelFormat {
PixelFormat {
encoding: Type::$encoding_ty,
format: $format,
}
}
}
};
}
macro_rules! impl_ColorPixel {
($t:ty) => {
unsafe impl ColorPixel for $t {}
};
}
macro_rules! impl_DepthPixel {
($t:ty) => {
unsafe impl DepthPixel for $t {}
};
}
macro_rules! impl_RenderablePixel {
($t:ty) => {
unsafe impl RenderablePixel for $t {}
};
}
#[derive(Clone, Copy, Debug)]
pub struct R8I;
impl_Pixel!(R8I, i8, i8, Integral, Format::R(Size::Eight));
impl_ColorPixel!(R8I);
impl_RenderablePixel!(R8I);
#[derive(Clone, Copy, Debug)]
pub struct NormR8I;
impl_Pixel!(NormR8I, i8, i8, NormIntegral, Format::R(Size::Eight));
impl_ColorPixel!(NormR8I);
impl_RenderablePixel!(NormR8I);
#[derive(Clone, Copy, Debug)]
pub struct R8UI;
impl_Pixel!(R8UI, u8, u8, Unsigned, Format::R(Size::Eight));
impl_ColorPixel!(R8UI);
impl_RenderablePixel!(R8UI);
#[derive(Clone, Copy, Debug)]
pub struct NormR8UI;
impl_Pixel!(NormR8UI, u8, u8, NormUnsigned, Format::R(Size::Eight));
impl_ColorPixel!(NormR8UI);
impl_RenderablePixel!(NormR8UI);
#[derive(Clone, Copy, Debug)]
pub struct R16I;
impl_Pixel!(R16I, i16, i16, Integral, Format::R(Size::Sixteen));
impl_ColorPixel!(R16I);
impl_RenderablePixel!(R16I);
#[derive(Clone, Copy, Debug)]
pub struct NormR16I;
impl_Pixel!(NormR16I, i16, i16, NormIntegral, Format::R(Size::Sixteen));
impl_ColorPixel!(NormR16I);
impl_RenderablePixel!(NormR16I);
#[derive(Clone, Copy, Debug)]
pub struct R16UI;
impl_Pixel!(R16UI, u16, u16, Unsigned, Format::R(Size::Sixteen));
impl_ColorPixel!(R16UI);
impl_RenderablePixel!(R16UI);
#[derive(Clone, Copy, Debug)]
pub struct NormR16UI;
impl_Pixel!(NormR16UI, u16, u16, NormUnsigned, Format::R(Size::Sixteen));
impl_ColorPixel!(NormR16UI);
impl_RenderablePixel!(NormR16UI);
#[derive(Clone, Copy, Debug)]
pub struct R32I;
impl_Pixel!(R32I, i32, i32, Integral, Format::R(Size::ThirtyTwo));
impl_ColorPixel!(R32I);
impl_RenderablePixel!(R32I);
#[derive(Clone, Copy, Debug)]
pub struct NormR32I;
impl_Pixel!(NormR32I, i32, i32, NormIntegral, Format::R(Size::ThirtyTwo));
impl_ColorPixel!(NormR32I);
impl_RenderablePixel!(NormR32I);
#[derive(Clone, Copy, Debug)]
pub struct R32UI;
impl_Pixel!(R32UI, u32, u32, Unsigned, Format::R(Size::ThirtyTwo));
impl_ColorPixel!(R32UI);
impl_RenderablePixel!(R32UI);
#[derive(Clone, Copy, Debug)]
pub struct NormR32UI;
impl_Pixel!(
NormR32UI,
u32,
u32,
NormUnsigned,
Format::R(Size::ThirtyTwo)
);
impl_ColorPixel!(NormR32UI);
impl_RenderablePixel!(NormR32UI);
#[derive(Clone, Copy, Debug)]
pub struct R32F;
impl_Pixel!(R32F, f32, f32, Floating, Format::R(Size::ThirtyTwo));
impl_ColorPixel!(R32F);
impl_RenderablePixel!(R32F);
#[derive(Clone, Copy, Debug)]
pub struct RG8I;
impl_Pixel!(
RG8I,
(i8, i8),
i8,
Integral,
Format::RG(Size::Eight, Size::Eight)
);
impl_ColorPixel!(RG8I);
impl_RenderablePixel!(RG8I);
#[derive(Clone, Copy, Debug)]
pub struct NormRG8I;
impl_Pixel!(
NormRG8I,
(i8, i8),
i8,
NormIntegral,
Format::RG(Size::Eight, Size::Eight)
);
impl_ColorPixel!(NormRG8I);
impl_RenderablePixel!(NormRG8I);
#[derive(Clone, Copy, Debug)]
pub struct RG8UI;
impl_Pixel!(
RG8UI,
(u8, u8),
u8,
Unsigned,
Format::RG(Size::Eight, Size::Eight)
);
impl_ColorPixel!(RG8UI);
impl_RenderablePixel!(RG8UI);
#[derive(Clone, Copy, Debug)]
pub struct NormRG8UI;
impl_Pixel!(
NormRG8UI,
(u8, u8),
u8,
NormUnsigned,
Format::RG(Size::Eight, Size::Eight)
);
impl_ColorPixel!(NormRG8UI);
impl_RenderablePixel!(NormRG8UI);
#[derive(Clone, Copy, Debug)]
pub struct RG16I;
impl_Pixel!(
RG16I,
(i16, i16),
i16,
Integral,
Format::RG(Size::Sixteen, Size::Sixteen)
);
impl_ColorPixel!(RG16I);
impl_RenderablePixel!(RG16I);
#[derive(Clone, Copy, Debug)]
pub struct NormRG16I;
impl_Pixel!(
NormRG16I,
(i16, i16),
i16,
NormIntegral,
Format::RG(Size::Sixteen, Size::Sixteen)
);
impl_ColorPixel!(NormRG16I);
impl_RenderablePixel!(NormRG16I);
#[derive(Clone, Copy, Debug)]
pub struct RG16UI;
impl_Pixel!(
RG16UI,
(u16, u16),
u16,
Unsigned,
Format::RG(Size::Sixteen, Size::Sixteen)
);
impl_ColorPixel!(RG16UI);
impl_RenderablePixel!(RG16UI);
#[derive(Clone, Copy, Debug)]
pub struct NormRG16UI;
impl_Pixel!(
NormRG16UI,
(u16, u16),
u16,
NormUnsigned,
Format::RG(Size::Sixteen, Size::Sixteen)
);
impl_ColorPixel!(NormRG16UI);
impl_RenderablePixel!(NormRG16UI);
#[derive(Clone, Copy, Debug)]
pub struct RG32I;
impl_Pixel!(
RG32I,
(i32, i32),
i32,
Integral,
Format::RG(Size::ThirtyTwo, Size::ThirtyTwo)
);
impl_ColorPixel!(RG32I);
impl_RenderablePixel!(RG32I);
#[derive(Clone, Copy, Debug)]
pub struct NormRG32I;
impl_Pixel!(
NormRG32I,
(i32, i32),
i32,
NormIntegral,
Format::RG(Size::ThirtyTwo, Size::ThirtyTwo)
);
impl_ColorPixel!(NormRG32I);
impl_RenderablePixel!(NormRG32I);
#[derive(Clone, Copy, Debug)]
pub struct RG32UI;
impl_Pixel!(
RG32UI,
(u32, u32),
u32,
Unsigned,
Format::RG(Size::ThirtyTwo, Size::ThirtyTwo)
);
impl_ColorPixel!(RG32UI);
impl_RenderablePixel!(RG32UI);
#[derive(Clone, Copy, Debug)]
pub struct NormRG32UI;
impl_Pixel!(
NormRG32UI,
(u32, u32),
u32,
NormUnsigned,
Format::RG(Size::ThirtyTwo, Size::ThirtyTwo)
);
impl_ColorPixel!(NormRG32UI);
impl_RenderablePixel!(NormRG32UI);
#[derive(Clone, Copy, Debug)]
pub struct RG32F;
impl_Pixel!(
RG32F,
(f32, f32),
f32,
Floating,
Format::RG(Size::ThirtyTwo, Size::ThirtyTwo)
);
impl_ColorPixel!(RG32F);
impl_RenderablePixel!(RG32F);
#[derive(Clone, Copy, Debug)]
pub struct RGB8I;
impl_Pixel!(
RGB8I,
(i8, i8, i8),
i8,
Integral,
Format::RGB(Size::Eight, Size::Eight, Size::Eight)
);
impl_ColorPixel!(RGB8I);
impl_RenderablePixel!(RGB8I);
#[derive(Clone, Copy, Debug)]
pub struct NormRGB8I;
impl_Pixel!(
NormRGB8I,
(i8, i8, i8),
i8,
NormIntegral,
Format::RGB(Size::Eight, Size::Eight, Size::Eight)
);
impl_ColorPixel!(NormRGB8I);
impl_RenderablePixel!(NormRGB8I);
#[derive(Clone, Copy, Debug)]
pub struct RGB8UI;
impl_Pixel!(
RGB8UI,
(u8, u8, u8),
u8,
Unsigned,
Format::RGB(Size::Eight, Size::Eight, Size::Eight)
);
impl_ColorPixel!(RGB8UI);
impl_RenderablePixel!(RGB8UI);
#[derive(Clone, Copy, Debug)]
pub struct NormRGB8UI;
impl_Pixel!(
NormRGB8UI,
(u8, u8, u8),
u8,
NormUnsigned,
Format::RGB(Size::Eight, Size::Eight, Size::Eight)
);
impl_ColorPixel!(NormRGB8UI);
impl_RenderablePixel!(NormRGB8UI);
#[derive(Clone, Copy, Debug)]
pub struct RGB16I;
impl_Pixel!(
RGB16I,
(i16, i16, i16),
i16,
Integral,
Format::RGB(Size::Sixteen, Size::Sixteen, Size::Sixteen)
);
impl_ColorPixel!(RGB16I);
impl_RenderablePixel!(RGB16I);
#[derive(Clone, Copy, Debug)]
pub struct NormRGB16I;
impl_Pixel!(
NormRGB16I,
(i16, i16, i16),
i16,
NormIntegral,
Format::RGB(Size::Sixteen, Size::Sixteen, Size::Sixteen)
);
impl_ColorPixel!(NormRGB16I);
impl_RenderablePixel!(NormRGB16I);
#[derive(Clone, Copy, Debug)]
pub struct RGB16UI;
impl_Pixel!(
RGB16UI,
(u16, u16, u16),
u16,
Unsigned,
Format::RGB(Size::Sixteen, Size::Sixteen, Size::Sixteen)
);
impl_ColorPixel!(RGB16UI);
impl_RenderablePixel!(RGB16UI);
#[derive(Clone, Copy, Debug)]
pub struct NormRGB16UI;
impl_Pixel!(
NormRGB16UI,
(u16, u16, u16),
u16,
NormUnsigned,
Format::RGB(Size::Sixteen, Size::Sixteen, Size::Sixteen)
);
impl_ColorPixel!(NormRGB16UI);
impl_RenderablePixel!(NormRGB16UI);
#[derive(Clone, Copy, Debug)]
pub struct RGB32I;
impl_Pixel!(
RGB32I,
(i32, i32, i32),
i32,
Integral,
Format::RGB(Size::ThirtyTwo, Size::ThirtyTwo, Size::ThirtyTwo)
);
impl_ColorPixel!(RGB32I);
impl_RenderablePixel!(RGB32I);
#[derive(Clone, Copy, Debug)]
pub struct NormRGB32I;
impl_Pixel!(
NormRGB32I,
(i32, i32, i32),
i32,
NormIntegral,
Format::RGB(Size::ThirtyTwo, Size::ThirtyTwo, Size::ThirtyTwo)
);
impl_ColorPixel!(NormRGB32I);
impl_RenderablePixel!(NormRGB32I);
#[derive(Clone, Copy, Debug)]
pub struct RGB32UI;
impl_Pixel!(
RGB32UI,
(u32, u32, u32),
u32,
Unsigned,
Format::RGB(Size::ThirtyTwo, Size::ThirtyTwo, Size::ThirtyTwo)
);
impl_ColorPixel!(RGB32UI);
impl_RenderablePixel!(RGB32UI);
#[derive(Clone, Copy, Debug)]
pub struct NormRGB32UI;
impl_Pixel!(
NormRGB32UI,
(u32, u32, u32),
u32,
NormUnsigned,
Format::RGB(Size::ThirtyTwo, Size::ThirtyTwo, Size::ThirtyTwo)
);
impl_ColorPixel!(NormRGB32UI);
impl_RenderablePixel!(NormRGB32UI);
#[derive(Clone, Copy, Debug)]
pub struct RGB32F;
impl_Pixel!(
RGB32F,
(f32, f32, f32),
f32,
Floating,
Format::RGB(Size::ThirtyTwo, Size::ThirtyTwo, Size::ThirtyTwo)
);
impl_ColorPixel!(RGB32F);
impl_RenderablePixel!(RGB32F);
#[derive(Clone, Copy, Debug)]
pub struct RGBA8I;
impl_Pixel!(
RGBA8I,
(i8, i8, i8, i8),
i8,
Integral,
Format::RGBA(Size::Eight, Size::Eight, Size::Eight, Size::Eight)
);
impl_ColorPixel!(RGBA8I);
impl_RenderablePixel!(RGBA8I);
#[derive(Clone, Copy, Debug)]
pub struct NormRGBA8I;
impl_Pixel!(
NormRGBA8I,
(i8, i8, i8, i8),
i8,
NormIntegral,
Format::RGBA(Size::Eight, Size::Eight, Size::Eight, Size::Eight)
);
impl_ColorPixel!(NormRGBA8I);
impl_RenderablePixel!(NormRGBA8I);
#[derive(Clone, Copy, Debug)]
pub struct RGBA8UI;
impl_Pixel!(
RGBA8UI,
(u8, u8, u8, u8),
u8,
Unsigned,
Format::RGBA(Size::Eight, Size::Eight, Size::Eight, Size::Eight)
);
impl_ColorPixel!(RGBA8UI);
impl_RenderablePixel!(RGBA8UI);
#[derive(Clone, Copy, Debug)]
pub struct NormRGBA8UI;
impl_Pixel!(
NormRGBA8UI,
(u8, u8, u8, u8),
u8,
NormUnsigned,
Format::RGBA(Size::Eight, Size::Eight, Size::Eight, Size::Eight)
);
impl_ColorPixel!(NormRGBA8UI);
impl_RenderablePixel!(NormRGBA8UI);
#[derive(Clone, Copy, Debug)]
pub struct RGBA16I;
impl_Pixel!(
RGBA16I,
(i16, i16, i16, i16),
i16,
Integral,
Format::RGBA(Size::Sixteen, Size::Sixteen, Size::Sixteen, Size::Sixteen)
);
impl_ColorPixel!(RGBA16I);
impl_RenderablePixel!(RGBA16I);
#[derive(Clone, Copy, Debug)]
pub struct NormRGBA16I;
impl_Pixel!(
NormRGBA16I,
(i16, i16, i16, i16),
i16,
NormIntegral,
Format::RGBA(Size::Sixteen, Size::Sixteen, Size::Sixteen, Size::Sixteen)
);
impl_ColorPixel!(NormRGBA16I);
impl_RenderablePixel!(NormRGBA16I);
#[derive(Clone, Copy, Debug)]
pub struct RGBA16UI;
impl_Pixel!(
RGBA16UI,
(u16, u16, u16, u16),
u16,
Unsigned,
Format::RGBA(Size::Sixteen, Size::Sixteen, Size::Sixteen, Size::Sixteen)
);
impl_ColorPixel!(RGBA16UI);
impl_RenderablePixel!(RGBA16UI);
#[derive(Clone, Copy, Debug)]
pub struct NormRGBA16UI;
impl_Pixel!(
NormRGBA16UI,
(u16, u16, u16, u16),
u16,
NormUnsigned,
Format::RGBA(Size::Sixteen, Size::Sixteen, Size::Sixteen, Size::Sixteen)
);
impl_ColorPixel!(NormRGBA16UI);
impl_RenderablePixel!(NormRGBA16UI);
#[derive(Clone, Copy, Debug)]
pub struct RGBA32I;
impl_Pixel!(
RGBA32I,
(i32, i32, i32, i32),
i32,
Integral,
Format::RGBA(
Size::ThirtyTwo,
Size::ThirtyTwo,
Size::ThirtyTwo,
Size::ThirtyTwo
)
);
impl_ColorPixel!(RGBA32I);
impl_RenderablePixel!(RGBA32I);
#[derive(Clone, Copy, Debug)]
pub struct NormRGBA32I;
impl_Pixel!(
NormRGBA32I,
(i32, i32, i32, i32),
i32,
NormIntegral,
Format::RGBA(
Size::ThirtyTwo,
Size::ThirtyTwo,
Size::ThirtyTwo,
Size::ThirtyTwo
)
);
impl_ColorPixel!(NormRGBA32I);
impl_RenderablePixel!(NormRGBA32I);
#[derive(Clone, Copy, Debug)]
pub struct RGBA32UI;
impl_Pixel!(
RGBA32UI,
(u32, u32, u32, u32),
u32,
Unsigned,
Format::RGBA(
Size::ThirtyTwo,
Size::ThirtyTwo,
Size::ThirtyTwo,
Size::ThirtyTwo
)
);
impl_ColorPixel!(RGBA32UI);
impl_RenderablePixel!(RGBA32UI);
#[derive(Clone, Copy, Debug)]
pub struct NormRGBA32UI;
impl_Pixel!(
NormRGBA32UI,
(u32, u32, u32, u32),
u32,
NormUnsigned,
Format::RGBA(
Size::ThirtyTwo,
Size::ThirtyTwo,
Size::ThirtyTwo,
Size::ThirtyTwo
)
);
impl_ColorPixel!(NormRGBA32UI);
impl_RenderablePixel!(NormRGBA32UI);
#[derive(Clone, Copy, Debug)]
pub struct RGBA32F;
impl_Pixel!(
RGBA32F,
(f32, f32, f32, f32),
f32,
Floating,
Format::RGBA(
Size::ThirtyTwo,
Size::ThirtyTwo,
Size::ThirtyTwo,
Size::ThirtyTwo
)
);
impl_ColorPixel!(RGBA32F);
impl_RenderablePixel!(RGBA32F);
#[derive(Clone, Copy, Debug)]
pub struct R11G11B10F;
impl_Pixel!(
R11G11B10F,
(f32, f32, f32, f32),
f32,
Floating,
Format::RGB(Size::Eleven, Size::Eleven, Size::Ten)
);
impl_ColorPixel!(R11G11B10F);
impl_RenderablePixel!(R11G11B10F);
#[derive(Clone, Copy, Debug)]
pub struct SRGB8UI;
impl_Pixel!(
SRGB8UI,
(u8, u8, u8),
u8,
NormUnsigned,
Format::SRGB(Size::Eight, Size::Eight, Size::Eight)
);
impl_ColorPixel!(SRGB8UI);
impl_RenderablePixel!(SRGB8UI);
#[derive(Clone, Copy, Debug)]
pub struct SRGBA8UI;
impl_Pixel!(
SRGBA8UI,
(u8, u8, u8, u8),
u8,
NormUnsigned,
Format::SRGBA(Size::Eight, Size::Eight, Size::Eight, Size::Eight)
);
impl_ColorPixel!(SRGBA8UI);
impl_RenderablePixel!(SRGBA8UI);
#[derive(Clone, Copy, Debug)]
pub struct Depth32F;
impl_Pixel!(Depth32F, f32, f32, Floating, Format::Depth(Size::ThirtyTwo));
impl_DepthPixel!(Depth32F);