moflib-1.0/moflib/moflib/mof/script/seq_parser.hpp

   1 #pragma once
   2 #include <mof/Color.hpp>
   3 #include <lua.hpp>
   4 #include <vector>
   5 #include <stdexcept>
   6 #include <mof/streams.hpp>
   7
   8
   9 // seq_factory
  10 namespace mof
  11 {
  12 namespace script
  13 {
  14         template <typename T>
  15         class seq_parser
  16         {
  17         public:
  18                 typedef typename KeyFrameAnimation<T>::KeyFrame key_frame;
  19 //{{{ parse
  20                 typename Manipulator<T>::ptr parse(lua_State* l, size_t offset) const
  21                 {
  22                         std::vector<typename KeyFrameAnimation<T>::KeyFrame> v;
  23
  24                         lua_pushnil(l);
  25                         while (lua_next(l, offset) != 0) {
  26                                 if (lua_isnumber(l, -2)) {
  27                                         v.push_back(pop_key_frame(l));
  28                                 }
  29                                 else if (lua_isstring(l, -2)) {
  30                                         // loopなど TODO
  31                                 }
  32                                 lua_pop(l, 1);// pop the value
  33                         }
  34                         return make_manip(v);
  35                 }
  36 //}}}
  37         private:
  38 //{{{ pop_key_frame
  39                 key_frame pop_key_frame(lua_State* l) const
  40                 {
  41                 }
  42 //}}}
  43 //{{{ make_manip
  44                 typename Manipulator<T>::ptr make_manip(const std::vector<key_frame>& v) const
  45                 {
  46                 }
  47 //}}}
  48         };
  49 //{{{ <Color4f>
  50                 seq_parser<Color4f>::key_frame seq_parser<Color4f>::pop_key_frame(lua_State* l) const
  51                 {
  52                         FrameNumber frame = lua_tointeger(l, -2);
  53                         double values[4];
  54                         int index = 0;
  55                         lua_pushnil(l);
  56                         for (; lua_next(l, -2) && index < 4; ++index) {
  57                                 values[index] = lua_tonumber(l, -1);
  58                                 lua_pop(l, 1);
  59                         }
  60                         if (index == 4) {
  61                                 return key_frame(frame, Color4f(values[0], values[1], values[2], values[3]));// ARGB
  62                         }
  63                         else if (index == 3) {
  64                                 return key_frame(frame, Color4f(values[0], values[1], values[2]));// RGB
  65                         }
  66                         else throw std::runtime_error("too few color parameters");
  67                 }
  68
  69                 Manipulator<Color4f>::ptr seq_parser<Color4f>::make_manip(const std::vector<seq_parser<Color4f>::key_frame>& v) const
  70                 {
  71                         return makeKeyFrameAnimationHandler<Color4f>(v.front(), v.back());
  72                 }
  73         //};
  74 //}}}
  75 //{{{ <Vector2D>
  76                 seq_parser<Vector2D>::key_frame seq_parser<Vector2D>::pop_key_frame(lua_State* l) const
  77                 {
  78                         FrameNumber frame = lua_tointeger(l, -2);
  79                         double values[2];
  80                         int index = 0;
  81                         lua_pushnil(l);
  82                         for (; lua_next(l, -2) && index < 2; ++index) {
  83                                 values[index] = lua_tonumber(l, -1);
  84                                 lua_pop(l, 1);
  85                         }
  86                         if (index == 2) {
  87                                 return key_frame(frame, Vector2D(static_cast<float>(values[0]), static_cast<float>(values[1])));
  88                         }
  89                         else throw std::runtime_error("too few position2D parameters");
  90                 }
  91
  92                 Manipulator<Vector2D>::ptr seq_parser<Vector2D>::make_manip(const std::vector<seq_parser<Vector2D>::key_frame>& v) const
  93                 {
  94                         return makeKeyFrameAnimationHandler<Vector2D>(v.front(), v.back());
  95                 }
  96         //};
  97 //}}}
  98 //{{{ <Vector3D>
  99                 seq_parser<Vector3D>::key_frame seq_parser<Vector3D>::pop_key_frame(lua_State* l) const
 100                 {
 101                         FrameNumber frame = lua_tointeger(l, -2);
 102                         float values[3];
 103                         int index = 0;
 104                         lua_pushnil(l);
 105                         for (; lua_next(l, -2) && index < 3; ++index) {
 106                                 values[index] = static_cast<float>(lua_tonumber(l, -1));
 107                                 lua_pop(l, 1);
 108                         }
 109                         if (index == 3) {
 110                                 return key_frame(frame, Vector3D(values[0], values[1], values[2]));
 111                         }
 112                         else throw std::runtime_error("too few position3D parameters");
 113                 }
 114
 115                 Manipulator<Vector3D>::ptr seq_parser<Vector3D>::make_manip(const std::vector<seq_parser<Vector3D>::key_frame>& v) const
 116                 {
 117                         return makeKeyFrameAnimationHandler<Vector3D>(v.front(), v.back());
 118                 }
 119         //};
 120 //}}}
 121 }// namespace script
 122 }// namespace mof
 123