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
137
138
139
140
141
142
143
144
145
146
147
148
149
150

use derivative::Derivative;
use serde::{Deserialize, Serialize};

use amethyst_assets::{PrefabData, ProgressCounter};
use amethyst_core::{
    ecs::{
        hibitset::BitSet,
        prelude::{Component, DenseVecStorage, Entity, WriteStorage},
    },
    math::Matrix4,
};
use amethyst_derive::PrefabData;
use amethyst_error::Error;
use amethyst_rendy::skinning::JointTransformsPrefab;

/// Joint, attach to an entity with a `Transform`
#[derive(Debug, Clone)]
pub struct Joint {
    /// The skins attached to this joint.
    pub skins: Vec<Entity>,
}

impl Component for Joint {
    type Storage = DenseVecStorage<Self>;
}

/// Skin, attach to the root entity in the mesh hierarchy
#[derive(Debug)]
pub struct Skin {
    /// Joint entities for the skin
    pub joints: Vec<Entity>,
    /// Mesh entities that use the skin
    pub meshes: BitSet,
    /// Bind shape matrix
    pub bind_shape_matrix: Matrix4<f32>,
    /// Bring the mesh into the joints local coordinate system
    pub inverse_bind_matrices: Vec<Matrix4<f32>>,
    /// Scratch area holding the current joint matrices
    pub joint_matrices: Vec<Matrix4<f32>>,
}

impl Skin {
    /// Creates a new `Skin`
    pub fn new(
        joints: Vec<Entity>,
        meshes: BitSet,
        inverse_bind_matrices: Vec<Matrix4<f32>>,
    ) -> Self {
        let len = joints.len();
        Skin {
            joints,
            meshes,
            inverse_bind_matrices,
            bind_shape_matrix: Matrix4::identity(),
            joint_matrices: Vec::with_capacity(len),
        }
    }
}

impl Component for Skin {
    type Storage = DenseVecStorage<Self>;
}

/// `PrefabData` for loading `Joint`s
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct JointPrefab {
    /// Index of the `Prefab` `Entity` where the `Skin` is placed.
    pub skins: Vec<usize>,
}

impl<'a> PrefabData<'a> for JointPrefab {
    type SystemData = WriteStorage<'a, Joint>;
    type Result = ();

    fn add_to_entity(
        &self,
        entity: Entity,
        storage: &mut Self::SystemData,
        entities: &[Entity],
        _: &[Entity],
    ) -> Result<(), Error> {
        storage
            .insert(
                entity,
                Joint {
                    skins: self.skins.iter().map(|i| entities[*i]).collect(),
                },
            )
            .map(|_| ())?;

        Ok(())
    }
}

/// `PrefabData` for loading `Skin`s
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SkinPrefab {
    /// Indices of `Entity`s in the `Prefab` which have `Joint`s belonging to this `Skin`
    pub joints: Vec<usize>,
    /// The bind shape matrix of the `Skin`
    pub bind_shape_matrix: Matrix4<f32>,
    /// Indices of the `Entity`s in the `Prefab` which have `Mesh`s using this `Skin`
    pub meshes: Vec<usize>,
    /// Inverse bind matrices of the `Joint`s
    pub inverse_bind_matrices: Vec<Matrix4<f32>>,
}

impl<'a> PrefabData<'a> for SkinPrefab {
    type SystemData = WriteStorage<'a, Skin>;
    type Result = ();

    fn add_to_entity(
        &self,
        entity: Entity,
        storage: &mut Self::SystemData,
        entities: &[Entity],
        _: &[Entity],
    ) -> Result<(), Error> {
        storage
            .insert(
                entity,
                Skin {
                    joints: self.joints.iter().map(|index| entities[*index]).collect(),
                    meshes: self
                        .meshes
                        .iter()
                        .map(|index| entities[*index].id())
                        .collect(),
                    bind_shape_matrix: self.bind_shape_matrix,
                    inverse_bind_matrices: self.inverse_bind_matrices.clone(),
                    joint_matrices: Vec::with_capacity(self.joints.len()),
                },
            )
            .map(|_| ())?;

        Ok(())
    }
}

/// `PrefabData` for full skinning support
#[derive(Clone, Debug, Default, Derivative, Serialize, Deserialize, PrefabData)]
#[serde(default)]
pub struct SkinnablePrefab {
    /// Place `Skin` on the `Entity`
    pub skin: Option<SkinPrefab>,
    /// Place `Joint` on the `Entity`
    pub joint: Option<JointPrefab>,
    /// Place `JointTransforms` on the `Entity`
    pub joint_transforms: Option<JointTransformsPrefab>,
}