use gltf_derive::Validate;
use serde_derive::{Serialize, Deserialize};
use serde::{de, ser};
use std::fmt;
use crate::validation::Checked;
use crate::{extensions, image, Extras, Index};
pub const NEAREST: u32 = 9728;
pub const LINEAR: u32 = 9729;
pub const NEAREST_MIPMAP_NEAREST: u32 = 9984;
pub const LINEAR_MIPMAP_NEAREST: u32 = 9985;
pub const NEAREST_MIPMAP_LINEAR: u32 = 9986;
pub const LINEAR_MIPMAP_LINEAR: u32 = 9987;
pub const CLAMP_TO_EDGE: u32 = 33_071;
pub const MIRRORED_REPEAT: u32 = 33_648;
pub const REPEAT: u32 = 10_497;
pub const VALID_MAG_FILTERS: &'static [u32] = &[
NEAREST,
LINEAR,
];
pub const VALID_MIN_FILTERS: &'static [u32] = &[
NEAREST,
LINEAR,
NEAREST_MIPMAP_NEAREST,
LINEAR_MIPMAP_NEAREST,
NEAREST_MIPMAP_LINEAR,
LINEAR_MIPMAP_LINEAR,
];
pub const VALID_WRAPPING_MODES: &'static [u32] = &[
CLAMP_TO_EDGE,
MIRRORED_REPEAT,
REPEAT,
];
#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq)]
pub enum MagFilter {
Nearest = 1,
Linear,
}
impl MagFilter {
pub fn as_gl_enum(&self) -> u32 {
match *self {
MagFilter::Nearest => NEAREST,
MagFilter::Linear => LINEAR,
}
}
}
#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq)]
pub enum MinFilter {
Nearest = 1,
Linear,
NearestMipmapNearest,
LinearMipmapNearest,
NearestMipmapLinear,
LinearMipmapLinear,
}
impl MinFilter {
pub fn as_gl_enum(&self) -> u32 {
match *self {
MinFilter::Nearest => NEAREST,
MinFilter::Linear => LINEAR,
MinFilter::NearestMipmapNearest => NEAREST_MIPMAP_NEAREST,
MinFilter::LinearMipmapNearest => LINEAR_MIPMAP_NEAREST,
MinFilter::NearestMipmapLinear => NEAREST_MIPMAP_LINEAR,
MinFilter::LinearMipmapLinear => LINEAR_MIPMAP_LINEAR,
}
}
}
#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq)]
pub enum WrappingMode {
ClampToEdge = 1,
MirroredRepeat,
Repeat,
}
impl WrappingMode {
pub fn as_gl_enum(&self) -> u32 {
match *self {
WrappingMode::ClampToEdge => CLAMP_TO_EDGE,
WrappingMode::MirroredRepeat => MIRRORED_REPEAT,
WrappingMode::Repeat => REPEAT,
}
}
}
#[derive(Clone, Debug, Default, Deserialize, Serialize, Validate)]
#[serde(default)]
pub struct Sampler {
#[serde(rename = "magFilter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mag_filter: Option<Checked<MagFilter>>,
#[serde(rename = "minFilter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub min_filter: Option<Checked<MinFilter>>,
#[cfg(feature = "names")]
#[cfg_attr(feature = "names", serde(skip_serializing_if = "Option::is_none"))]
pub name: Option<String>,
#[serde(default, rename = "wrapS")]
pub wrap_s: Checked<WrappingMode>,
#[serde(default, rename = "wrapT")]
pub wrap_t: Checked<WrappingMode>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub extensions: Option<extensions::texture::Sampler>,
#[serde(default)]
#[cfg_attr(feature = "extras", serde(skip_serializing_if = "Option::is_none"))]
pub extras: Extras,
}
#[derive(Clone, Debug, Deserialize, Serialize, Validate)]
pub struct Texture {
#[cfg(feature = "names")]
#[cfg_attr(feature = "names", serde(skip_serializing_if = "Option::is_none"))]
pub name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub sampler: Option<Index<Sampler>>,
pub source: Index<image::Image>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub extensions: Option<extensions::texture::Texture>,
#[serde(default)]
#[cfg_attr(feature = "extras", serde(skip_serializing_if = "Option::is_none"))]
pub extras: Extras,
}
#[derive(Clone, Debug, Deserialize, Serialize, Validate)]
pub struct Info {
pub index: Index<Texture>,
#[serde(default, rename = "texCoord")]
pub tex_coord: u32,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub extensions: Option<extensions::texture::Info>,
#[serde(default)]
#[cfg_attr(feature = "extras", serde(skip_serializing_if = "Option::is_none"))]
pub extras: Extras,
}
impl<'de> de::Deserialize<'de> for Checked<MagFilter> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: de::Deserializer<'de>
{
struct Visitor;
impl<'de> de::Visitor<'de> for Visitor {
type Value = Checked<MagFilter>;
fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "any of: {:?}", VALID_MAG_FILTERS)
}
fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
where E: de::Error
{
use self::MagFilter::*;
use crate::validation::Checked::*;
Ok(match value as u32 {
NEAREST => Valid(Nearest),
LINEAR => Valid(Linear),
_ => Invalid,
})
}
}
deserializer.deserialize_u64(Visitor)
}
}
impl<'de> de::Deserialize<'de> for Checked<MinFilter> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: de::Deserializer<'de>
{
struct Visitor;
impl<'de> de::Visitor<'de> for Visitor {
type Value = Checked<MinFilter>;
fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "any of: {:?}", VALID_MIN_FILTERS)
}
fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
where E: de::Error
{
use self::MinFilter::*;
use crate::validation::Checked::*;
Ok(match value as u32 {
NEAREST => Valid(Nearest),
LINEAR => Valid(Linear),
NEAREST_MIPMAP_NEAREST => Valid(NearestMipmapNearest),
LINEAR_MIPMAP_NEAREST => Valid(LinearMipmapNearest),
NEAREST_MIPMAP_LINEAR => Valid(NearestMipmapLinear),
LINEAR_MIPMAP_LINEAR => Valid(LinearMipmapLinear),
_ => Invalid,
})
}
}
deserializer.deserialize_u64(Visitor)
}
}
impl ser::Serialize for MinFilter {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: ser::Serializer,
{
serializer.serialize_u32(self.as_gl_enum())
}
}
impl<'de> de::Deserialize<'de> for Checked<WrappingMode> {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: de::Deserializer<'de>
{
struct Visitor;
impl<'de> de::Visitor<'de> for Visitor {
type Value = Checked<WrappingMode>;
fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "any of: {:?}", VALID_WRAPPING_MODES)
}
fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
where E: de::Error
{
use self::WrappingMode::*;
use crate::validation::Checked::*;
Ok(match value as u32 {
CLAMP_TO_EDGE => Valid(ClampToEdge),
MIRRORED_REPEAT => Valid(MirroredRepeat),
REPEAT => Valid(Repeat),
_ => Invalid,
})
}
}
deserializer.deserialize_u64(Visitor)
}
}
impl ser::Serialize for MagFilter {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: ser::Serializer,
{
serializer.serialize_u32(self.as_gl_enum())
}
}
impl Default for WrappingMode {
fn default() -> Self {
WrappingMode::Repeat
}
}
impl ser::Serialize for WrappingMode {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: ser::Serializer,
{
serializer.serialize_u32(self.as_gl_enum())
}
}