src/vmd.cpp

   1 #include "vmd.h"
   2 #include "text.h"
   3 #include <algorithm>
   4 #include <string>
   5
   6 namespace meshio {
   7 namespace vmd {
   8
   9 template<typename T>
  10 struct SortKeyFrameList
  11 {
  12         typedef T MAP;
  13         void operator()(typename MAP::value_type &channel)
  14         {
  15                 channel.second->sort();
  16         }
  17 };
  18
  19 template<class READER>
  20         void
  21         readBoneMap(READER &reader, IO &io)
  22         {
  23                 std::wstring name=
  24                         text::trim(text::to_WideChar(CP_OEMCP, reader.getString(15, true)));
  25                 unsigned int frame=reader.getUint();
  26                 IO::BoneMap::iterator found=io.boneMap.find(name);
  27                 if(found==io.boneMap.end()){
  28                         // not found
  29                         found=io.boneMap.insert(
  30                                                 std::make_pair(name,
  31                             new KeyFrameList<KeyFrame<BoneKey> >())).first;
  32                         io.boneKeys.push_back(name);
  33                 }
  34                 BoneKey &key=found->second->push(frame).key;
  35
  36                 reader.get(key.pos);
  37                 reader.get(key.q);
  38                 reader.get(key.interpolationX);
  39                 reader.get(key.interpolationY);
  40                 reader.get(key.interpolationZ);
  41                 reader.get(key.interpolationRot);
  42         }
  43
  44 template<class READER>
  45         void
  46         readMorphMap(READER &reader, IO &io)
  47         {
  48                 std::wstring name=
  49                         text::trim(text::to_WideChar(CP_OEMCP, reader.getString(15, true)));
  50                 unsigned int frame=reader.getUint();
  51                 IO::MorphMap::iterator found=io.morphMap.find(name);
  52                 if(found==io.morphMap.end()){
  53                         // not found
  54                         found=io.morphMap.insert(
  55                                         std::make_pair(name,
  56                         new KeyFrameList<KeyFrame<MorphKey> >())).first;
  57                         io.morphKeys.push_back(name);
  58                 }
  59                 MorphKey &key=found->second->push(frame).key;
  60
  61                 reader.get(key.weight);
  62         }
  63
  64 class Implementation
  65 {
  66         IO &io_;
  67         binary::IReader &reader_;
  68
  69 public:
  70         Implementation(IO &io, binary::IReader &reader)
  71                 : io_(io), reader_(reader)
  72                 {}
  73
  74         bool parse()
  75         {
  76                 // check header
  77                 std::string line=reader_.getString(30, true);
  78                 if(line=="Vocaloid Motion Data file"){
  79                         io_.version="1";
  80                         text::copyStringAndFillZero(io_.name, reader_.getString(10));
  81                         return parseBody();
  82                 }
  83                 else if(line=="Vocaloid Motion Data 0002"){
  84                         io_.version="2";
  85                         text::copyStringAndFillZero(io_.name, reader_.getString(20));
  86                         return parseBody();
  87                 }
  88                 else{
  89                         //std::cout << "unknown header:" << line << std::endl;
  90                         return false;
  91                 }
  92         }
  93
  94
  95 private:
  96         bool parseBody()
  97         {
  98                 if(!parseFrame()){
  99                         return false;
 100                 }
 101                 if(!parseMorph()){
 102                         return false;
 103                 }
 104                 if(!parseCamera()){
 105                         return false;
 106                 }
 107                 if(!parseLight()){
 108                         return false;
 109                 }
 110                 // sort
 111                 std::for_each(io_.boneMap.begin(), io_.boneMap.end(),
 112                                 SortKeyFrameList<IO::BoneMap>());
 113                 std::for_each(io_.morphMap.begin(), io_.morphMap.end(),
 114                                 SortKeyFrameList<IO::MorphMap>());
 115                 return true;
 116         }
 117
 118         bool parseMorph()
 119         {
 120                 unsigned int count=reader_.getUint();
 121                 for(unsigned int i=0; i<count; ++i){
 122                         readMorphMap(reader_, io_);
 123                 }
 124                 return true;
 125         }
 126
 127         bool parseFrame()
 128         {
 129                 unsigned int count=reader_.getUint();
 130                 for(unsigned int i=0; i<count; ++i){
 131                         readBoneMap(reader_, io_);
 132                 }
 133                 return true;
 134         }
 135
 136         bool parseCamera()
 137         {
 138                 return true;
 139         }
 140
 141         bool parseLight()
 142         {
 143                 return true;
 144         }
 145 };
 146
 147
 148 ///////////////////////////////////////////////////////////////////////////////
 149 //! IO
 150 ///////////////////////////////////////////////////////////////////////////////
 151 IO::IO()
 152 {
 153 }
 154
 155 IO::~IO()
 156 {
 157         for(BoneMap::iterator it=boneMap.begin(); it!=boneMap.end(); ++it){
 158                 delete it->second;
 159         }
 160         boneMap.clear();
 161
 162         for(MorphMap::iterator it=morphMap.begin(); it!=morphMap.end(); ++it){
 163                 delete it->second;
 164         }
 165         morphMap.clear();
 166
 167 }
 168
 169 bool IO::read(binary::IReader &reader)
 170 {
 171         return Implementation(*this, reader).parse();
 172 }
 173
 174 bool IO::read(const wchar_t *path)
 175 {
 176         std::vector<char> all;
 177         binary::readAll(path, all);
 178         if(all.empty()){
 179                 return false;
 180         }
 181         binary::MemoryReader reader(&all[0], all.size());
 182         return read(reader);
 183 }
 184
 185 bool IO::read(const char *path)
 186 {
 187         std::vector<char> all;
 188         binary::readAll(path, all);
 189         if(all.empty()){
 190                 return false;
 191         }
 192         binary::MemoryReader reader(&all[0], all.size());
 193         return read(reader);
 194 }
 195
 196 bool IO::write(std::ostream &os)
 197 {
 198         return false;
 199 }
 200
 201 BoneKeyFrameList* IO::getBoneKeyFrameList(const std::wstring &name)
 202 {
 203         return boneMap[name];
 204 }
 205
 206 MorphKeyFrameList* IO::getMorphKeyFrameList(const std::wstring &name)
 207 {
 208         return morphMap[name];
 209 }
 210
 211 } // namespace vmd
 212 } // namespace meshio