1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use densevec::Key;
use rinecs::{Component};
use serde_derive::{Serialize, Deserialize};
// {KeyedDenseVec, Key};
// use rin::graphics;
// use hashbrown::HashMap;
// use std::path::PathBuf;
// use rin::util::ValueCache;

#[derive(Clone,Copy,Debug,Component,Eq,PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub struct TextureRef{id: usize}

impl Key for TextureRef{
    fn to_usize(self) -> usize{
        self.id
    }

    fn from_usize(id: usize) -> TextureRef{
        TextureRef{id}
    }
}

#[derive(Clone,Copy,Debug,Component,Eq,PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub struct CubemapRef{id: usize}


impl Key for CubemapRef{
    fn to_usize(self) -> usize{
        self.id
    }

    fn from_usize(id: usize) -> CubemapRef{
        CubemapRef{id}
    }
}

#[derive(Clone,Copy,Debug,Component,Eq,PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub struct SamplerRef{id: usize}


impl Key for SamplerRef{
    fn to_usize(self) -> usize{
        self.id
    }

    fn from_usize(id: usize) -> SamplerRef{
        SamplerRef{id}
    }
}

#[derive(Clone,Debug,Copy)]
#[repr(i32)]
pub enum Wrap{
    Repeat = 0,
    Extend = 1,
    Clip = 2,
}

#[derive(Clone,Debug,Copy)]
#[repr(i32)]
pub enum Filter{
    Nearest = 0,
    Linear = 1,
    NearestMipNearest = 2,
    NearestMipLinear = 3,
    LinearMipNearest = 4,
    LinearMipLinear = 5,
}

pub struct Sampler{
    pub wrap: Wrap,
    pub minfilter: Filter,
    pub magfilter: Filter,
}


#[derive(Debug,Clone,Copy,Component,Eq,PartialEq, Ord, Hash, PartialOrd, Serialize, Deserialize)]
pub struct TextureSampler{
    pub texture: TextureRef,
    pub sampler: Option<SamplerRef>,
}

impl From<TextureRef> for TextureSampler{
    fn from(texture: TextureRef) -> TextureSampler{
        TextureSampler{
            texture,
            sampler: None,
        }
    }
}


impl From<TextureRef> for Option<TextureSampler>{
    fn from(texture: TextureRef) -> Option<TextureSampler>{
        Some(TextureSampler{
            texture,
            sampler: None,
        })
    }
}


#[derive(Debug,Clone,Copy,Component,Eq,PartialEq, Ord, Hash, PartialOrd, Serialize, Deserialize)]
pub struct CubemapSampler{
    pub cubemap: CubemapRef,
    pub sampler: Option<SamplerRef>,
}

impl From<CubemapRef> for CubemapSampler{
    fn from(cubemap: CubemapRef) -> CubemapSampler{
        CubemapSampler{
            cubemap,
            sampler: None,
        }
    }
}


impl From<CubemapRef> for Option<CubemapSampler>{
    fn from(cubemap: CubemapRef) -> Option<CubemapSampler>{
        Some(CubemapSampler{
            cubemap,
            sampler: None,
        })
    }
}

bitflags::bitflags!{
    pub struct TextureCreationFlags: u32{
        // TODO: COMPRESS should be a flag but only 8bit images are allowed,
        // #[cfg(feature="squish")]
        // const COMPRESS = 1 << 0;
        const MIPMAPS  = 1 << 1;
        const PREMULTIPLY_ALPHA  = 1 << 2;
    }
}