use vrm_spec::vrmc_vrm_1_0::{
AvatarPermissionType, CommercialUsageType, CreditNotationType, Meta, ModificationType,
};
#[derive(Debug, Clone, Default)]
pub struct AvatarMeta {
pub(crate) name: String,
pub(crate) version: Option<String>,
pub(crate) authors: Vec<String>,
pub(crate) copyright_information: Option<String>,
pub(crate) contact_information: Option<String>,
pub(crate) references: Option<Vec<String>>,
pub(crate) third_party_licenses: Option<String>,
pub(crate) thumbnail_image: Option<u32>,
pub(crate) license_url: Option<String>,
pub(crate) other_license_url: Option<String>,
pub(crate) permissions: AvatarPermissions,
}
#[derive(Debug, Clone, Default)]
pub struct AvatarPermissions {
pub avatar_permission: AvatarPermission,
pub commercial_usage: CommercialUsage,
pub credit_notation: CreditNotation,
pub modification: ModificationPermission,
pub allow_redistribution: bool,
pub allow_excessively_violent_usage: bool,
pub allow_excessively_sexual_usage: bool,
pub allow_political_or_religious_usage: bool,
pub allow_antisocial_or_hate_usage: bool,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum AvatarPermission {
#[default]
OnlyAuthor,
OnlySeparatelyLicensedPerson,
Everyone,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum CommercialUsage {
#[default]
PersonalNonProfit,
PersonalProfit,
Corporation,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum CreditNotation {
#[default]
Required,
Unnecessary,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum ModificationPermission {
#[default]
Prohibited,
AllowModification,
AllowModificationRedistribution,
}
impl From<AvatarPermissionType> for AvatarPermission {
fn from(val: AvatarPermissionType) -> Self {
match val {
AvatarPermissionType::OnlyAuthor => Self::OnlyAuthor,
AvatarPermissionType::OnlySeparatelyLicensedPerson => {
Self::OnlySeparatelyLicensedPerson
}
AvatarPermissionType::Everyone => Self::Everyone,
}
}
}
impl From<CommercialUsageType> for CommercialUsage {
fn from(val: CommercialUsageType) -> Self {
match val {
CommercialUsageType::PersonalNonProfit => Self::PersonalNonProfit,
CommercialUsageType::PersonalProfit => Self::PersonalProfit,
CommercialUsageType::Corporation => Self::Corporation,
}
}
}
impl From<CreditNotationType> for CreditNotation {
fn from(val: CreditNotationType) -> Self {
match val {
CreditNotationType::Required => Self::Required,
CreditNotationType::Unnecessary => Self::Unnecessary,
}
}
}
impl From<ModificationType> for ModificationPermission {
fn from(val: ModificationType) -> Self {
match val {
ModificationType::Prohibited => Self::Prohibited,
ModificationType::AllowModification => Self::AllowModification,
ModificationType::AllowModificationRedistribution => {
Self::AllowModificationRedistribution
}
}
}
}
impl AvatarPermissions {
pub(crate) fn load_meta(meta: &vrm_spec::vrmc_vrm_1_0::Meta) -> Self {
Self {
avatar_permission: meta.avatar_permission.map(Into::into).unwrap_or_default(),
commercial_usage: meta.commercial_usage.map(Into::into).unwrap_or_default(),
credit_notation: meta.credit_notation.map(Into::into).unwrap_or_default(),
modification: meta.modification.map(Into::into).unwrap_or_default(),
allow_redistribution: meta.allow_redistribution.unwrap_or(false),
allow_excessively_violent_usage: meta.allow_excessively_violent_usage.unwrap_or(false),
allow_excessively_sexual_usage: meta.allow_excessively_sexual_usage.unwrap_or(false),
allow_political_or_religious_usage: meta
.allow_political_or_religious_usage
.unwrap_or(false),
allow_antisocial_or_hate_usage: meta.allow_antisocial_or_hate_usage.unwrap_or(false),
}
}
}
impl AvatarMeta {
pub fn new(
name: impl Into<String>,
authors: impl IntoIterator<Item = impl Into<String>>,
license_url: impl Into<String>,
) -> Self {
Self {
name: name.into(),
authors: authors.into_iter().map(Into::into).collect(),
license_url: Some(license_url.into()),
..Self::default()
}
}
pub(crate) fn load_meta(meta: &Meta) -> Self {
Self {
name: meta.name.clone(),
version: meta.version.clone(),
authors: meta.authors.clone(),
copyright_information: meta.copyright_information.clone(),
contact_information: meta.contact_information.clone(),
references: meta.references.clone(),
third_party_licenses: meta.third_party_licenses.clone(),
thumbnail_image: meta.thumbnail_image.as_ref().map(|i| i.value() as u32),
license_url: Some(meta.license_url.clone()),
other_license_url: meta.other_license_url.clone(),
permissions: AvatarPermissions::load_meta(meta),
}
}
pub fn name(&self) -> &str {
&self.name
}
pub fn version(&self) -> Option<&str> {
self.version.as_deref()
}
pub fn authors(&self) -> &[String] {
&self.authors
}
pub fn copyright_information(&self) -> Option<&str> {
self.copyright_information.as_deref()
}
pub fn contact_information(&self) -> Option<&str> {
self.contact_information.as_deref()
}
pub fn references(&self) -> Option<&[String]> {
self.references.as_deref()
}
pub fn third_party_licenses(&self) -> Option<&str> {
self.third_party_licenses.as_deref()
}
pub fn thumbnail_image(&self) -> Option<u32> {
self.thumbnail_image
}
pub fn license_url(&self) -> Option<&str> {
self.license_url.as_deref()
}
pub fn other_license_url(&self) -> Option<&str> {
self.other_license_url.as_deref()
}
pub fn permissions(&self) -> &AvatarPermissions {
&self.permissions
}
}