lua/lmeshio_bind.cpp

   1 /*
   2 ** Lua binding: lmeshio
   3 ** Generated automatically by tolua++-1.0.93(lua) on Sun May 01 00:10:15 2011
   4 */
   5
   6 #ifndef __cplusplus
   7 #include "stdlib.h"
   8 #endif
   9 #include "string.h"
  10
  11 #include "tolua++.h"
  12
  13 /* Exported function */
  14 TOLUA_API int  tolua_lmeshio_open (lua_State* tolua_S);
  15
  16 #include "pmd.h"
  17 #include "vmd.h"
  18 #include "mqo.h"
  19 #include "la.h"
  20 #include "color.h"
  21 using namespace meshio;
  22
  23 /* function to release collected object via destructor */
  24 #ifdef __cplusplus
  25
  26 static int tolua_collect_meshio__pmd__Bone (lua_State* tolua_S)
  27 {
  28  meshio::pmd::Bone* self = (meshio::pmd::Bone*) tolua_tousertype(tolua_S,1,0);
  29         Mtolua_delete(self);
  30         return 0;
  31 }
  32
  33 static int tolua_collect_meshio__pmd__IO (lua_State* tolua_S)
  34 {
  35  meshio::pmd::IO* self = (meshio::pmd::IO*) tolua_tousertype(tolua_S,1,0);
  36         Mtolua_delete(self);
  37         return 0;
  38 }
  39
  40 static int tolua_collect_meshio__Vector2 (lua_State* tolua_S)
  41 {
  42  meshio::Vector2* self = (meshio::Vector2*) tolua_tousertype(tolua_S,1,0);
  43         Mtolua_delete(self);
  44         return 0;
  45 }
  46
  47 static int tolua_collect_meshio__fRGBA (lua_State* tolua_S)
  48 {
  49  meshio::fRGBA* self = (meshio::fRGBA*) tolua_tousertype(tolua_S,1,0);
  50         Mtolua_delete(self);
  51         return 0;
  52 }
  53
  54 static int tolua_collect_meshio__mqo__IO (lua_State* tolua_S)
  55 {
  56  meshio::mqo::IO* self = (meshio::mqo::IO*) tolua_tousertype(tolua_S,1,0);
  57         Mtolua_delete(self);
  58         return 0;
  59 }
  60
  61 static int tolua_collect_meshio__Vector3 (lua_State* tolua_S)
  62 {
  63  meshio::Vector3* self = (meshio::Vector3*) tolua_tousertype(tolua_S,1,0);
  64         Mtolua_delete(self);
  65         return 0;
  66 }
  67
  68 static int tolua_collect_meshio__Vector4 (lua_State* tolua_S)
  69 {
  70  meshio::Vector4* self = (meshio::Vector4*) tolua_tousertype(tolua_S,1,0);
  71         Mtolua_delete(self);
  72         return 0;
  73 }
  74
  75 static int tolua_collect_meshio__Quaternion (lua_State* tolua_S)
  76 {
  77  meshio::Quaternion* self = (meshio::Quaternion*) tolua_tousertype(tolua_S,1,0);
  78         Mtolua_delete(self);
  79         return 0;
  80 }
  81
  82 static int tolua_collect_std__vector_meshio__pmd__Bone__ (lua_State* tolua_S)
  83 {
  84  std::vector<meshio::pmd::Bone*>* self = (std::vector<meshio::pmd::Bone*>*) tolua_tousertype(tolua_S,1,0);
  85         Mtolua_delete(self);
  86         return 0;
  87 }
  88
  89 static int tolua_collect_std__vector_unsigned_short_ (lua_State* tolua_S)
  90 {
  91  std::vector<unsigned short>* self = (std::vector<unsigned short>*) tolua_tousertype(tolua_S,1,0);
  92         Mtolua_delete(self);
  93         return 0;
  94 }
  95
  96 static int tolua_collect_std__vector_unsigned_int_ (lua_State* tolua_S)
  97 {
  98  std::vector<unsigned int>* self = (std::vector<unsigned int>*) tolua_tousertype(tolua_S,1,0);
  99         Mtolua_delete(self);
 100         return 0;
 101 }
 102
 103 static int tolua_collect_std__vector_meshio__Vector3_ (lua_State* tolua_S)
 104 {
 105  std::vector<meshio::Vector3>* self = (std::vector<meshio::Vector3>*) tolua_tousertype(tolua_S,1,0);
 106         Mtolua_delete(self);
 107         return 0;
 108 }
 109
 110 static int tolua_collect_std__vector_meshio__pmd__Vertex_ (lua_State* tolua_S)
 111 {
 112  std::vector<meshio::pmd::Vertex>* self = (std::vector<meshio::pmd::Vertex>*) tolua_tousertype(tolua_S,1,0);
 113         Mtolua_delete(self);
 114         return 0;
 115 }
 116
 117 static int tolua_collect_meshio__pmd__Vertex (lua_State* tolua_S)
 118 {
 119  meshio::pmd::Vertex* self = (meshio::pmd::Vertex*) tolua_tousertype(tolua_S,1,0);
 120         Mtolua_delete(self);
 121         return 0;
 122 }
 123
 124 static int tolua_collect_std__vector_meshio__pmd__Material_ (lua_State* tolua_S)
 125 {
 126  std::vector<meshio::pmd::Material>* self = (std::vector<meshio::pmd::Material>*) tolua_tousertype(tolua_S,1,0);
 127         Mtolua_delete(self);
 128         return 0;
 129 }
 130
 131 static int tolua_collect_meshio__pmd__Material (lua_State* tolua_S)
 132 {
 133  meshio::pmd::Material* self = (meshio::pmd::Material*) tolua_tousertype(tolua_S,1,0);
 134         Mtolua_delete(self);
 135         return 0;
 136 }
 137
 138 static int tolua_collect_std__vector_meshio__pmd__Bone_ (lua_State* tolua_S)
 139 {
 140  std::vector<meshio::pmd::Bone>* self = (std::vector<meshio::pmd::Bone>*) tolua_tousertype(tolua_S,1,0);
 141         Mtolua_delete(self);
 142         return 0;
 143 }
 144
 145 static int tolua_collect_std__vector_meshio__pmd__IK_ (lua_State* tolua_S)
 146 {
 147  std::vector<meshio::pmd::IK>* self = (std::vector<meshio::pmd::IK>*) tolua_tousertype(tolua_S,1,0);
 148         Mtolua_delete(self);
 149         return 0;
 150 }
 151
 152 static int tolua_collect_meshio__pmd__IK (lua_State* tolua_S)
 153 {
 154  meshio::pmd::IK* self = (meshio::pmd::IK*) tolua_tousertype(tolua_S,1,0);
 155         Mtolua_delete(self);
 156         return 0;
 157 }
 158
 159 static int tolua_collect_std__vector_meshio__pmd__Morph_ (lua_State* tolua_S)
 160 {
 161  std::vector<meshio::pmd::Morph>* self = (std::vector<meshio::pmd::Morph>*) tolua_tousertype(tolua_S,1,0);
 162         Mtolua_delete(self);
 163         return 0;
 164 }
 165
 166 static int tolua_collect_meshio__pmd__Morph (lua_State* tolua_S)
 167 {
 168  meshio::pmd::Morph* self = (meshio::pmd::Morph*) tolua_tousertype(tolua_S,1,0);
 169         Mtolua_delete(self);
 170         return 0;
 171 }
 172
 173 static int tolua_collect_std__vector_meshio__pmd__BoneGroup_ (lua_State* tolua_S)
 174 {
 175  std::vector<meshio::pmd::BoneGroup>* self = (std::vector<meshio::pmd::BoneGroup>*) tolua_tousertype(tolua_S,1,0);
 176         Mtolua_delete(self);
 177         return 0;
 178 }
 179
 180 static int tolua_collect_meshio__pmd__BoneGroup (lua_State* tolua_S)
 181 {
 182  meshio::pmd::BoneGroup* self = (meshio::pmd::BoneGroup*) tolua_tousertype(tolua_S,1,0);
 183         Mtolua_delete(self);
 184         return 0;
 185 }
 186
 187 static int tolua_collect_std__vector_std__pair_unsigned_short_unsigned_char___ (lua_State* tolua_S)
 188 {
 189  std::vector<std::pair<unsigned short,unsigned char> >* self = (std::vector<std::pair<unsigned short,unsigned char> >*) tolua_tousertype(tolua_S,1,0);
 190         Mtolua_delete(self);
 191         return 0;
 192 }
 193
 194 static int tolua_collect_std__pair_unsigned_short_unsigned_char_ (lua_State* tolua_S)
 195 {
 196  std::pair<unsigned short,unsigned char>* self = (std::pair<unsigned short,unsigned char>*) tolua_tousertype(tolua_S,1,0);
 197         Mtolua_delete(self);
 198         return 0;
 199 }
 200
 201 static int tolua_collect_std__vector_meshio__pmd__RigidBody_ (lua_State* tolua_S)
 202 {
 203  std::vector<meshio::pmd::RigidBody>* self = (std::vector<meshio::pmd::RigidBody>*) tolua_tousertype(tolua_S,1,0);
 204         Mtolua_delete(self);
 205         return 0;
 206 }
 207
 208 static int tolua_collect_meshio__pmd__RigidBody (lua_State* tolua_S)
 209 {
 210  meshio::pmd::RigidBody* self = (meshio::pmd::RigidBody*) tolua_tousertype(tolua_S,1,0);
 211         Mtolua_delete(self);
 212         return 0;
 213 }
 214
 215 static int tolua_collect_std__vector_meshio__pmd__Constraint_ (lua_State* tolua_S)
 216 {
 217  std::vector<meshio::pmd::Constraint>* self = (std::vector<meshio::pmd::Constraint>*) tolua_tousertype(tolua_S,1,0);
 218         Mtolua_delete(self);
 219         return 0;
 220 }
 221
 222 static int tolua_collect_meshio__pmd__Constraint (lua_State* tolua_S)
 223 {
 224  meshio::pmd::Constraint* self = (meshio::pmd::Constraint*) tolua_tousertype(tolua_S,1,0);
 225         Mtolua_delete(self);
 226         return 0;
 227 }
 228
 229 static int tolua_collect_std__vector_meshio__mqo__Face_ (lua_State* tolua_S)
 230 {
 231  std::vector<meshio::mqo::Face>* self = (std::vector<meshio::mqo::Face>*) tolua_tousertype(tolua_S,1,0);
 232         Mtolua_delete(self);
 233         return 0;
 234 }
 235
 236 static int tolua_collect_meshio__mqo__Face (lua_State* tolua_S)
 237 {
 238  meshio::mqo::Face* self = (meshio::mqo::Face*) tolua_tousertype(tolua_S,1,0);
 239         Mtolua_delete(self);
 240         return 0;
 241 }
 242
 243 static int tolua_collect_std__vector_meshio__mqo__Material_ (lua_State* tolua_S)
 244 {
 245  std::vector<meshio::mqo::Material>* self = (std::vector<meshio::mqo::Material>*) tolua_tousertype(tolua_S,1,0);
 246         Mtolua_delete(self);
 247         return 0;
 248 }
 249
 250 static int tolua_collect_meshio__mqo__Material (lua_State* tolua_S)
 251 {
 252  meshio::mqo::Material* self = (meshio::mqo::Material*) tolua_tousertype(tolua_S,1,0);
 253         Mtolua_delete(self);
 254         return 0;
 255 }
 256
 257 static int tolua_collect_std__vector_meshio__mqo__Object_ (lua_State* tolua_S)
 258 {
 259  std::vector<meshio::mqo::Object>* self = (std::vector<meshio::mqo::Object>*) tolua_tousertype(tolua_S,1,0);
 260         Mtolua_delete(self);
 261         return 0;
 262 }
 263
 264 static int tolua_collect_meshio__mqo__Object (lua_State* tolua_S)
 265 {
 266  meshio::mqo::Object* self = (meshio::mqo::Object*) tolua_tousertype(tolua_S,1,0);
 267         Mtolua_delete(self);
 268         return 0;
 269 }
 270 #endif
 271
 272
 273 /* function to register type */
 274 static void tolua_reg_types (lua_State* tolua_S)
 275 {
 276  tolua_usertype(tolua_S,"meshio::pmd::Vertex");
 277  tolua_usertype(tolua_S,"meshio::pmd::Material");
 278  tolua_usertype(tolua_S,"meshio::pmd::Bone");
 279  tolua_usertype(tolua_S,"meshio::pmd::IK");
 280  tolua_usertype(tolua_S,"meshio::pmd::Morph");
 281  tolua_usertype(tolua_S,"meshio::pmd::BoneGroup");
 282  tolua_usertype(tolua_S,"meshio::pmd::RigidBody");
 283  tolua_usertype(tolua_S,"meshio::pmd::Constraint");
 284  tolua_usertype(tolua_S,"meshio::pmd::IO");
 285  tolua_usertype(tolua_S,"meshio::mqo::Scene");
 286  tolua_usertype(tolua_S,"meshio::mqo::Material");
 287  tolua_usertype(tolua_S,"meshio::mqo::Face");
 288  tolua_usertype(tolua_S,"meshio::mqo::Object");
 289  tolua_usertype(tolua_S,"meshio::mqo::IO");
 290  tolua_usertype(tolua_S,"meshio::Vector2");
 291  tolua_usertype(tolua_S,"meshio::Vector3");
 292  tolua_usertype(tolua_S,"meshio::Vector4");
 293  tolua_usertype(tolua_S,"meshio::Quaternion");
 294  tolua_usertype(tolua_S,"meshio::fRGBA");
 295  tolua_usertype(tolua_S,"meshio::fixed_string<20>");
 296  tolua_usertype(tolua_S,"meshio::fixed_string<50>");
 297  tolua_usertype(tolua_S,"meshio::fixed_string<100>");
 298  tolua_usertype(tolua_S,"meshio::fixed_string<256>");
 299  tolua_usertype(tolua_S,"fRGB");
 300  tolua_usertype(tolua_S,"std::vector<meshio::pmd::Bone*>");
 301  tolua_usertype(tolua_S,"std::vector<unsigned short>");
 302  tolua_usertype(tolua_S,"std::vector<unsigned int>");
 303  tolua_usertype(tolua_S,"std::vector<meshio::Vector3>");
 304  tolua_usertype(tolua_S,"std::vector<meshio::pmd::Vertex>");
 305  tolua_usertype(tolua_S,"std::vector<meshio::pmd::Material>");
 306  tolua_usertype(tolua_S,"std::vector<meshio::pmd::Bone>");
 307  tolua_usertype(tolua_S,"std::vector<meshio::pmd::IK>");
 308  tolua_usertype(tolua_S,"std::vector<meshio::pmd::Morph>");
 309  tolua_usertype(tolua_S,"std::vector<meshio::pmd::BoneGroup>");
 310  tolua_usertype(tolua_S,"std::vector<std::pair<unsigned short,unsigned char> >");
 311  tolua_usertype(tolua_S,"std::array<meshio::fixed_string<100>,10>");
 312  tolua_usertype(tolua_S,"std::vector<meshio::pmd::RigidBody>");
 313  tolua_usertype(tolua_S,"std::vector<meshio::pmd::Constraint>");
 314  tolua_usertype(tolua_S,"std::vector<meshio::mqo::Face>");
 315  tolua_usertype(tolua_S,"std::vector<meshio::mqo::Material>");
 316  tolua_usertype(tolua_S,"std::vector<meshio::mqo::Object>");
 317  tolua_usertype(tolua_S,"std::pair<std::vector<meshio::pmd::Bone*>::iterator, std::vector<meshio::pmd::Bone*>::iterator>");
 318  tolua_usertype(tolua_S,"std::pair<std::vector<unsigned short>::iterator, std::vector<unsigned short>::iterator>");
 319  tolua_usertype(tolua_S,"std::pair<std::vector<unsigned int>::iterator, std::vector<unsigned int>::iterator>");
 320  tolua_usertype(tolua_S,"std::pair<std::vector<meshio::Vector3>::iterator, std::vector<meshio::Vector3>::iterator>");
 321  tolua_usertype(tolua_S,"std::pair<std::vector<meshio::pmd::Vertex>::iterator, std::vector<meshio::pmd::Vertex>::iterator>");
 322  tolua_usertype(tolua_S,"std::pair<std::vector<meshio::pmd::Material>::iterator, std::vector<meshio::pmd::Material>::iterator>");
 323  tolua_usertype(tolua_S,"std::pair<std::vector<meshio::pmd::Bone>::iterator, std::vector<meshio::pmd::Bone>::iterator>");
 324  tolua_usertype(tolua_S,"std::pair<std::vector<meshio::pmd::IK>::iterator, std::vector<meshio::pmd::IK>::iterator>");
 325  tolua_usertype(tolua_S,"std::pair<std::vector<meshio::pmd::Morph>::iterator, std::vector<meshio::pmd::Morph>::iterator>");
 326  tolua_usertype(tolua_S,"std::pair<std::vector<meshio::pmd::BoneGroup>::iterator, std::vector<meshio::pmd::BoneGroup>::iterator>");
 327  tolua_usertype(tolua_S,"std::pair<std::vector<std::pair<unsigned short,unsigned char> >::iterator, std::vector<std::pair<unsigned short,unsigned char> >::iterator>");
 328  tolua_usertype(tolua_S,"std::pair<unsigned short,unsigned char>");
 329  tolua_usertype(tolua_S,"std::pair<std::vector<meshio::pmd::RigidBody>::iterator, std::vector<meshio::pmd::RigidBody>::iterator>");
 330  tolua_usertype(tolua_S,"std::pair<std::vector<meshio::pmd::Constraint>::iterator, std::vector<meshio::pmd::Constraint>::iterator>");
 331  tolua_usertype(tolua_S,"std::pair<std::vector<meshio::mqo::Face>::iterator, std::vector<meshio::mqo::Face>::iterator>");
 332  tolua_usertype(tolua_S,"std::pair<std::vector<meshio::mqo::Material>::iterator, std::vector<meshio::mqo::Material>::iterator>");
 333  tolua_usertype(tolua_S,"std::pair<std::vector<meshio::mqo::Object>::iterator, std::vector<meshio::mqo::Object>::iterator>");
 334 }
 335
 336 /* get function: pos of class  meshio::pmd::Vertex */
 337 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Vertex_pos
 338 static int tolua_get_meshio__pmd__Vertex_pos(lua_State* tolua_S)
 339 {
 340   meshio::pmd::Vertex* self = (meshio::pmd::Vertex*)  tolua_tousertype(tolua_S,1,0);
 341 #ifndef TOLUA_RELEASE
 342   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'pos'",NULL);
 343 #endif
 344    tolua_pushusertype(tolua_S,(void*)&self->pos,"meshio::Vector3");
 345  return 1;
 346 }
 347 #endif //#ifndef TOLUA_DISABLE
 348
 349 /* set function: pos of class  meshio::pmd::Vertex */
 350 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Vertex_pos
 351 static int tolua_set_meshio__pmd__Vertex_pos(lua_State* tolua_S)
 352 {
 353   meshio::pmd::Vertex* self = (meshio::pmd::Vertex*)  tolua_tousertype(tolua_S,1,0);
 354 #ifndef TOLUA_RELEASE
 355   tolua_Error tolua_err;
 356   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'pos'",NULL);
 357   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::Vector3",0,&tolua_err)))
 358    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 359 #endif
 360   self->pos = *((meshio::Vector3*)  tolua_tousertype(tolua_S,2,0))
 361 ;
 362  return 0;
 363 }
 364 #endif //#ifndef TOLUA_DISABLE
 365
 366 /* get function: normal of class  meshio::pmd::Vertex */
 367 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Vertex_normal
 368 static int tolua_get_meshio__pmd__Vertex_normal(lua_State* tolua_S)
 369 {
 370   meshio::pmd::Vertex* self = (meshio::pmd::Vertex*)  tolua_tousertype(tolua_S,1,0);
 371 #ifndef TOLUA_RELEASE
 372   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'normal'",NULL);
 373 #endif
 374    tolua_pushusertype(tolua_S,(void*)&self->normal,"meshio::Vector3");
 375  return 1;
 376 }
 377 #endif //#ifndef TOLUA_DISABLE
 378
 379 /* set function: normal of class  meshio::pmd::Vertex */
 380 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Vertex_normal
 381 static int tolua_set_meshio__pmd__Vertex_normal(lua_State* tolua_S)
 382 {
 383   meshio::pmd::Vertex* self = (meshio::pmd::Vertex*)  tolua_tousertype(tolua_S,1,0);
 384 #ifndef TOLUA_RELEASE
 385   tolua_Error tolua_err;
 386   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'normal'",NULL);
 387   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::Vector3",0,&tolua_err)))
 388    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 389 #endif
 390   self->normal = *((meshio::Vector3*)  tolua_tousertype(tolua_S,2,0))
 391 ;
 392  return 0;
 393 }
 394 #endif //#ifndef TOLUA_DISABLE
 395
 396 /* get function: uv of class  meshio::pmd::Vertex */
 397 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Vertex_uv
 398 static int tolua_get_meshio__pmd__Vertex_uv(lua_State* tolua_S)
 399 {
 400   meshio::pmd::Vertex* self = (meshio::pmd::Vertex*)  tolua_tousertype(tolua_S,1,0);
 401 #ifndef TOLUA_RELEASE
 402   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'uv'",NULL);
 403 #endif
 404    tolua_pushusertype(tolua_S,(void*)&self->uv,"meshio::Vector2");
 405  return 1;
 406 }
 407 #endif //#ifndef TOLUA_DISABLE
 408
 409 /* set function: uv of class  meshio::pmd::Vertex */
 410 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Vertex_uv
 411 static int tolua_set_meshio__pmd__Vertex_uv(lua_State* tolua_S)
 412 {
 413   meshio::pmd::Vertex* self = (meshio::pmd::Vertex*)  tolua_tousertype(tolua_S,1,0);
 414 #ifndef TOLUA_RELEASE
 415   tolua_Error tolua_err;
 416   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'uv'",NULL);
 417   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::Vector2",0,&tolua_err)))
 418    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 419 #endif
 420   self->uv = *((meshio::Vector2*)  tolua_tousertype(tolua_S,2,0))
 421 ;
 422  return 0;
 423 }
 424 #endif //#ifndef TOLUA_DISABLE
 425
 426 /* get function: bone0 of class  meshio::pmd::Vertex */
 427 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Vertex_unsigned_bone0
 428 static int tolua_get_meshio__pmd__Vertex_unsigned_bone0(lua_State* tolua_S)
 429 {
 430   meshio::pmd::Vertex* self = (meshio::pmd::Vertex*)  tolua_tousertype(tolua_S,1,0);
 431 #ifndef TOLUA_RELEASE
 432   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'bone0'",NULL);
 433 #endif
 434   tolua_pushnumber(tolua_S,(lua_Number)self->bone0);
 435  return 1;
 436 }
 437 #endif //#ifndef TOLUA_DISABLE
 438
 439 /* set function: bone0 of class  meshio::pmd::Vertex */
 440 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Vertex_unsigned_bone0
 441 static int tolua_set_meshio__pmd__Vertex_unsigned_bone0(lua_State* tolua_S)
 442 {
 443   meshio::pmd::Vertex* self = (meshio::pmd::Vertex*)  tolua_tousertype(tolua_S,1,0);
 444 #ifndef TOLUA_RELEASE
 445   tolua_Error tolua_err;
 446   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'bone0'",NULL);
 447   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 448    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 449 #endif
 450   self->bone0 = ((unsigned short)  tolua_tonumber(tolua_S,2,0))
 451 ;
 452  return 0;
 453 }
 454 #endif //#ifndef TOLUA_DISABLE
 455
 456 /* get function: bone1 of class  meshio::pmd::Vertex */
 457 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Vertex_unsigned_bone1
 458 static int tolua_get_meshio__pmd__Vertex_unsigned_bone1(lua_State* tolua_S)
 459 {
 460   meshio::pmd::Vertex* self = (meshio::pmd::Vertex*)  tolua_tousertype(tolua_S,1,0);
 461 #ifndef TOLUA_RELEASE
 462   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'bone1'",NULL);
 463 #endif
 464   tolua_pushnumber(tolua_S,(lua_Number)self->bone1);
 465  return 1;
 466 }
 467 #endif //#ifndef TOLUA_DISABLE
 468
 469 /* set function: bone1 of class  meshio::pmd::Vertex */
 470 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Vertex_unsigned_bone1
 471 static int tolua_set_meshio__pmd__Vertex_unsigned_bone1(lua_State* tolua_S)
 472 {
 473   meshio::pmd::Vertex* self = (meshio::pmd::Vertex*)  tolua_tousertype(tolua_S,1,0);
 474 #ifndef TOLUA_RELEASE
 475   tolua_Error tolua_err;
 476   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'bone1'",NULL);
 477   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 478    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 479 #endif
 480   self->bone1 = ((unsigned short)  tolua_tonumber(tolua_S,2,0))
 481 ;
 482  return 0;
 483 }
 484 #endif //#ifndef TOLUA_DISABLE
 485
 486 /* get function: weight0 of class  meshio::pmd::Vertex */
 487 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Vertex_unsigned_weight0
 488 static int tolua_get_meshio__pmd__Vertex_unsigned_weight0(lua_State* tolua_S)
 489 {
 490   meshio::pmd::Vertex* self = (meshio::pmd::Vertex*)  tolua_tousertype(tolua_S,1,0);
 491 #ifndef TOLUA_RELEASE
 492   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'weight0'",NULL);
 493 #endif
 494   tolua_pushnumber(tolua_S,(lua_Number)self->weight0);
 495  return 1;
 496 }
 497 #endif //#ifndef TOLUA_DISABLE
 498
 499 /* set function: weight0 of class  meshio::pmd::Vertex */
 500 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Vertex_unsigned_weight0
 501 static int tolua_set_meshio__pmd__Vertex_unsigned_weight0(lua_State* tolua_S)
 502 {
 503   meshio::pmd::Vertex* self = (meshio::pmd::Vertex*)  tolua_tousertype(tolua_S,1,0);
 504 #ifndef TOLUA_RELEASE
 505   tolua_Error tolua_err;
 506   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'weight0'",NULL);
 507   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 508    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 509 #endif
 510   self->weight0 = ((unsigned char)  tolua_tonumber(tolua_S,2,0))
 511 ;
 512  return 0;
 513 }
 514 #endif //#ifndef TOLUA_DISABLE
 515
 516 /* get function: edge_flag of class  meshio::pmd::Vertex */
 517 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Vertex_unsigned_edge_flag
 518 static int tolua_get_meshio__pmd__Vertex_unsigned_edge_flag(lua_State* tolua_S)
 519 {
 520   meshio::pmd::Vertex* self = (meshio::pmd::Vertex*)  tolua_tousertype(tolua_S,1,0);
 521 #ifndef TOLUA_RELEASE
 522   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'edge_flag'",NULL);
 523 #endif
 524   tolua_pushnumber(tolua_S,(lua_Number)self->edge_flag);
 525  return 1;
 526 }
 527 #endif //#ifndef TOLUA_DISABLE
 528
 529 /* set function: edge_flag of class  meshio::pmd::Vertex */
 530 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Vertex_unsigned_edge_flag
 531 static int tolua_set_meshio__pmd__Vertex_unsigned_edge_flag(lua_State* tolua_S)
 532 {
 533   meshio::pmd::Vertex* self = (meshio::pmd::Vertex*)  tolua_tousertype(tolua_S,1,0);
 534 #ifndef TOLUA_RELEASE
 535   tolua_Error tolua_err;
 536   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'edge_flag'",NULL);
 537   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 538    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 539 #endif
 540   self->edge_flag = ((unsigned char)  tolua_tonumber(tolua_S,2,0))
 541 ;
 542  return 0;
 543 }
 544 #endif //#ifndef TOLUA_DISABLE
 545
 546 /* get function: diffuse of class  meshio::pmd::Material */
 547 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Material_diffuse
 548 static int tolua_get_meshio__pmd__Material_diffuse(lua_State* tolua_S)
 549 {
 550   meshio::pmd::Material* self = (meshio::pmd::Material*)  tolua_tousertype(tolua_S,1,0);
 551 #ifndef TOLUA_RELEASE
 552   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'diffuse'",NULL);
 553 #endif
 554    tolua_pushusertype(tolua_S,(void*)&self->diffuse,"meshio::fRGBA");
 555  return 1;
 556 }
 557 #endif //#ifndef TOLUA_DISABLE
 558
 559 /* set function: diffuse of class  meshio::pmd::Material */
 560 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Material_diffuse
 561 static int tolua_set_meshio__pmd__Material_diffuse(lua_State* tolua_S)
 562 {
 563   meshio::pmd::Material* self = (meshio::pmd::Material*)  tolua_tousertype(tolua_S,1,0);
 564 #ifndef TOLUA_RELEASE
 565   tolua_Error tolua_err;
 566   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'diffuse'",NULL);
 567   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::fRGBA",0,&tolua_err)))
 568    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 569 #endif
 570   self->diffuse = *((meshio::fRGBA*)  tolua_tousertype(tolua_S,2,0))
 571 ;
 572  return 0;
 573 }
 574 #endif //#ifndef TOLUA_DISABLE
 575
 576 /* get function: shinness of class  meshio::pmd::Material */
 577 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Material_shinness
 578 static int tolua_get_meshio__pmd__Material_shinness(lua_State* tolua_S)
 579 {
 580   meshio::pmd::Material* self = (meshio::pmd::Material*)  tolua_tousertype(tolua_S,1,0);
 581 #ifndef TOLUA_RELEASE
 582   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'shinness'",NULL);
 583 #endif
 584   tolua_pushnumber(tolua_S,(lua_Number)self->shinness);
 585  return 1;
 586 }
 587 #endif //#ifndef TOLUA_DISABLE
 588
 589 /* set function: shinness of class  meshio::pmd::Material */
 590 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Material_shinness
 591 static int tolua_set_meshio__pmd__Material_shinness(lua_State* tolua_S)
 592 {
 593   meshio::pmd::Material* self = (meshio::pmd::Material*)  tolua_tousertype(tolua_S,1,0);
 594 #ifndef TOLUA_RELEASE
 595   tolua_Error tolua_err;
 596   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'shinness'",NULL);
 597   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 598    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 599 #endif
 600   self->shinness = ((float)  tolua_tonumber(tolua_S,2,0))
 601 ;
 602  return 0;
 603 }
 604 #endif //#ifndef TOLUA_DISABLE
 605
 606 /* get function: specular of class  meshio::pmd::Material */
 607 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Material_specular
 608 static int tolua_get_meshio__pmd__Material_specular(lua_State* tolua_S)
 609 {
 610   meshio::pmd::Material* self = (meshio::pmd::Material*)  tolua_tousertype(tolua_S,1,0);
 611 #ifndef TOLUA_RELEASE
 612   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'specular'",NULL);
 613 #endif
 614    tolua_pushusertype(tolua_S,(void*)&self->specular,"fRGB");
 615  return 1;
 616 }
 617 #endif //#ifndef TOLUA_DISABLE
 618
 619 /* set function: specular of class  meshio::pmd::Material */
 620 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Material_specular
 621 static int tolua_set_meshio__pmd__Material_specular(lua_State* tolua_S)
 622 {
 623   meshio::pmd::Material* self = (meshio::pmd::Material*)  tolua_tousertype(tolua_S,1,0);
 624 #ifndef TOLUA_RELEASE
 625   tolua_Error tolua_err;
 626   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'specular'",NULL);
 627   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fRGB",0,&tolua_err)))
 628    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 629 #endif
 630   self->specular = *((fRGB*)  tolua_tousertype(tolua_S,2,0))
 631 ;
 632  return 0;
 633 }
 634 #endif //#ifndef TOLUA_DISABLE
 635
 636 /* get function: ambient of class  meshio::pmd::Material */
 637 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Material_ambient
 638 static int tolua_get_meshio__pmd__Material_ambient(lua_State* tolua_S)
 639 {
 640   meshio::pmd::Material* self = (meshio::pmd::Material*)  tolua_tousertype(tolua_S,1,0);
 641 #ifndef TOLUA_RELEASE
 642   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ambient'",NULL);
 643 #endif
 644    tolua_pushusertype(tolua_S,(void*)&self->ambient,"fRGB");
 645  return 1;
 646 }
 647 #endif //#ifndef TOLUA_DISABLE
 648
 649 /* set function: ambient of class  meshio::pmd::Material */
 650 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Material_ambient
 651 static int tolua_set_meshio__pmd__Material_ambient(lua_State* tolua_S)
 652 {
 653   meshio::pmd::Material* self = (meshio::pmd::Material*)  tolua_tousertype(tolua_S,1,0);
 654 #ifndef TOLUA_RELEASE
 655   tolua_Error tolua_err;
 656   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ambient'",NULL);
 657   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"fRGB",0,&tolua_err)))
 658    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 659 #endif
 660   self->ambient = *((fRGB*)  tolua_tousertype(tolua_S,2,0))
 661 ;
 662  return 0;
 663 }
 664 #endif //#ifndef TOLUA_DISABLE
 665
 666 /* get function: toon_index of class  meshio::pmd::Material */
 667 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Material_unsigned_toon_index
 668 static int tolua_get_meshio__pmd__Material_unsigned_toon_index(lua_State* tolua_S)
 669 {
 670   meshio::pmd::Material* self = (meshio::pmd::Material*)  tolua_tousertype(tolua_S,1,0);
 671 #ifndef TOLUA_RELEASE
 672   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'toon_index'",NULL);
 673 #endif
 674   tolua_pushnumber(tolua_S,(lua_Number)self->toon_index);
 675  return 1;
 676 }
 677 #endif //#ifndef TOLUA_DISABLE
 678
 679 /* set function: toon_index of class  meshio::pmd::Material */
 680 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Material_unsigned_toon_index
 681 static int tolua_set_meshio__pmd__Material_unsigned_toon_index(lua_State* tolua_S)
 682 {
 683   meshio::pmd::Material* self = (meshio::pmd::Material*)  tolua_tousertype(tolua_S,1,0);
 684 #ifndef TOLUA_RELEASE
 685   tolua_Error tolua_err;
 686   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'toon_index'",NULL);
 687   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 688    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 689 #endif
 690   self->toon_index = ((unsigned char)  tolua_tonumber(tolua_S,2,0))
 691 ;
 692  return 0;
 693 }
 694 #endif //#ifndef TOLUA_DISABLE
 695
 696 /* get function: flag of class  meshio::pmd::Material */
 697 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Material_unsigned_flag
 698 static int tolua_get_meshio__pmd__Material_unsigned_flag(lua_State* tolua_S)
 699 {
 700   meshio::pmd::Material* self = (meshio::pmd::Material*)  tolua_tousertype(tolua_S,1,0);
 701 #ifndef TOLUA_RELEASE
 702   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'flag'",NULL);
 703 #endif
 704   tolua_pushnumber(tolua_S,(lua_Number)self->flag);
 705  return 1;
 706 }
 707 #endif //#ifndef TOLUA_DISABLE
 708
 709 /* set function: flag of class  meshio::pmd::Material */
 710 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Material_unsigned_flag
 711 static int tolua_set_meshio__pmd__Material_unsigned_flag(lua_State* tolua_S)
 712 {
 713   meshio::pmd::Material* self = (meshio::pmd::Material*)  tolua_tousertype(tolua_S,1,0);
 714 #ifndef TOLUA_RELEASE
 715   tolua_Error tolua_err;
 716   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'flag'",NULL);
 717   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 718    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 719 #endif
 720   self->flag = ((unsigned char)  tolua_tonumber(tolua_S,2,0))
 721 ;
 722  return 0;
 723 }
 724 #endif //#ifndef TOLUA_DISABLE
 725
 726 /* get function: vertex_count of class  meshio::pmd::Material */
 727 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Material_unsigned_vertex_count
 728 static int tolua_get_meshio__pmd__Material_unsigned_vertex_count(lua_State* tolua_S)
 729 {
 730   meshio::pmd::Material* self = (meshio::pmd::Material*)  tolua_tousertype(tolua_S,1,0);
 731 #ifndef TOLUA_RELEASE
 732   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'vertex_count'",NULL);
 733 #endif
 734   tolua_pushnumber(tolua_S,(lua_Number)self->vertex_count);
 735  return 1;
 736 }
 737 #endif //#ifndef TOLUA_DISABLE
 738
 739 /* set function: vertex_count of class  meshio::pmd::Material */
 740 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Material_unsigned_vertex_count
 741 static int tolua_set_meshio__pmd__Material_unsigned_vertex_count(lua_State* tolua_S)
 742 {
 743   meshio::pmd::Material* self = (meshio::pmd::Material*)  tolua_tousertype(tolua_S,1,0);
 744 #ifndef TOLUA_RELEASE
 745   tolua_Error tolua_err;
 746   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'vertex_count'",NULL);
 747   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 748    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 749 #endif
 750   self->vertex_count = ((unsigned int)  tolua_tonumber(tolua_S,2,0))
 751 ;
 752  return 0;
 753 }
 754 #endif //#ifndef TOLUA_DISABLE
 755
 756 /* get function: texture of class  meshio::pmd::Material */
 757 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Material_texture
 758 static int tolua_get_meshio__pmd__Material_texture(lua_State* tolua_S)
 759 {
 760   meshio::pmd::Material* self = (meshio::pmd::Material*)  tolua_tousertype(tolua_S,1,0);
 761 #ifndef TOLUA_RELEASE
 762   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'texture'",NULL);
 763 #endif
 764    tolua_pushusertype(tolua_S,(void*)&self->texture,"meshio::fixed_string<20>");
 765  return 1;
 766 }
 767 #endif //#ifndef TOLUA_DISABLE
 768
 769 /* set function: texture of class  meshio::pmd::Material */
 770 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Material_texture
 771 static int tolua_set_meshio__pmd__Material_texture(lua_State* tolua_S)
 772 {
 773   meshio::pmd::Material* self = (meshio::pmd::Material*)  tolua_tousertype(tolua_S,1,0);
 774 #ifndef TOLUA_RELEASE
 775   tolua_Error tolua_err;
 776   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'texture'",NULL);
 777   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::fixed_string<20>",0,&tolua_err)))
 778    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 779 #endif
 780   self->texture = *((meshio::fixed_string<20>*)  tolua_tousertype(tolua_S,2,0))
 781 ;
 782  return 0;
 783 }
 784 #endif //#ifndef TOLUA_DISABLE
 785
 786 /* get function: name of class  meshio::pmd::Bone */
 787 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Bone_name
 788 static int tolua_get_meshio__pmd__Bone_name(lua_State* tolua_S)
 789 {
 790   meshio::pmd::Bone* self = (meshio::pmd::Bone*)  tolua_tousertype(tolua_S,1,0);
 791 #ifndef TOLUA_RELEASE
 792   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'name'",NULL);
 793 #endif
 794    tolua_pushusertype(tolua_S,(void*)&self->name,"meshio::fixed_string<20>");
 795  return 1;
 796 }
 797 #endif //#ifndef TOLUA_DISABLE
 798
 799 /* set function: name of class  meshio::pmd::Bone */
 800 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Bone_name
 801 static int tolua_set_meshio__pmd__Bone_name(lua_State* tolua_S)
 802 {
 803   meshio::pmd::Bone* self = (meshio::pmd::Bone*)  tolua_tousertype(tolua_S,1,0);
 804 #ifndef TOLUA_RELEASE
 805   tolua_Error tolua_err;
 806   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'name'",NULL);
 807   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::fixed_string<20>",0,&tolua_err)))
 808    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 809 #endif
 810   self->name = *((meshio::fixed_string<20>*)  tolua_tousertype(tolua_S,2,0))
 811 ;
 812  return 0;
 813 }
 814 #endif //#ifndef TOLUA_DISABLE
 815
 816 /* get function: parent_index of class  meshio::pmd::Bone */
 817 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Bone_unsigned_parent_index
 818 static int tolua_get_meshio__pmd__Bone_unsigned_parent_index(lua_State* tolua_S)
 819 {
 820   meshio::pmd::Bone* self = (meshio::pmd::Bone*)  tolua_tousertype(tolua_S,1,0);
 821 #ifndef TOLUA_RELEASE
 822   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'parent_index'",NULL);
 823 #endif
 824   tolua_pushnumber(tolua_S,(lua_Number)self->parent_index);
 825  return 1;
 826 }
 827 #endif //#ifndef TOLUA_DISABLE
 828
 829 /* set function: parent_index of class  meshio::pmd::Bone */
 830 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Bone_unsigned_parent_index
 831 static int tolua_set_meshio__pmd__Bone_unsigned_parent_index(lua_State* tolua_S)
 832 {
 833   meshio::pmd::Bone* self = (meshio::pmd::Bone*)  tolua_tousertype(tolua_S,1,0);
 834 #ifndef TOLUA_RELEASE
 835   tolua_Error tolua_err;
 836   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'parent_index'",NULL);
 837   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 838    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 839 #endif
 840   self->parent_index = ((unsigned short)  tolua_tonumber(tolua_S,2,0))
 841 ;
 842  return 0;
 843 }
 844 #endif //#ifndef TOLUA_DISABLE
 845
 846 /* get function: tail_index of class  meshio::pmd::Bone */
 847 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Bone_unsigned_tail_index
 848 static int tolua_get_meshio__pmd__Bone_unsigned_tail_index(lua_State* tolua_S)
 849 {
 850   meshio::pmd::Bone* self = (meshio::pmd::Bone*)  tolua_tousertype(tolua_S,1,0);
 851 #ifndef TOLUA_RELEASE
 852   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'tail_index'",NULL);
 853 #endif
 854   tolua_pushnumber(tolua_S,(lua_Number)self->tail_index);
 855  return 1;
 856 }
 857 #endif //#ifndef TOLUA_DISABLE
 858
 859 /* set function: tail_index of class  meshio::pmd::Bone */
 860 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Bone_unsigned_tail_index
 861 static int tolua_set_meshio__pmd__Bone_unsigned_tail_index(lua_State* tolua_S)
 862 {
 863   meshio::pmd::Bone* self = (meshio::pmd::Bone*)  tolua_tousertype(tolua_S,1,0);
 864 #ifndef TOLUA_RELEASE
 865   tolua_Error tolua_err;
 866   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'tail_index'",NULL);
 867   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 868    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 869 #endif
 870   self->tail_index = ((unsigned short)  tolua_tonumber(tolua_S,2,0))
 871 ;
 872  return 0;
 873 }
 874 #endif //#ifndef TOLUA_DISABLE
 875
 876 /* get function: type of class  meshio::pmd::Bone */
 877 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Bone_type
 878 static int tolua_get_meshio__pmd__Bone_type(lua_State* tolua_S)
 879 {
 880   meshio::pmd::Bone* self = (meshio::pmd::Bone*)  tolua_tousertype(tolua_S,1,0);
 881 #ifndef TOLUA_RELEASE
 882   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'type'",NULL);
 883 #endif
 884   tolua_pushnumber(tolua_S,(lua_Number)self->type);
 885  return 1;
 886 }
 887 #endif //#ifndef TOLUA_DISABLE
 888
 889 /* set function: type of class  meshio::pmd::Bone */
 890 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Bone_type
 891 static int tolua_set_meshio__pmd__Bone_type(lua_State* tolua_S)
 892 {
 893   meshio::pmd::Bone* self = (meshio::pmd::Bone*)  tolua_tousertype(tolua_S,1,0);
 894 #ifndef TOLUA_RELEASE
 895   tolua_Error tolua_err;
 896   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'type'",NULL);
 897   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 898    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 899 #endif
 900   self->type = ((meshio::pmd::BONE_TYPE) (int)  tolua_tonumber(tolua_S,2,0))
 901 ;
 902  return 0;
 903 }
 904 #endif //#ifndef TOLUA_DISABLE
 905
 906 /* get function: ik_index of class  meshio::pmd::Bone */
 907 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Bone_unsigned_ik_index
 908 static int tolua_get_meshio__pmd__Bone_unsigned_ik_index(lua_State* tolua_S)
 909 {
 910   meshio::pmd::Bone* self = (meshio::pmd::Bone*)  tolua_tousertype(tolua_S,1,0);
 911 #ifndef TOLUA_RELEASE
 912   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ik_index'",NULL);
 913 #endif
 914   tolua_pushnumber(tolua_S,(lua_Number)self->ik_index);
 915  return 1;
 916 }
 917 #endif //#ifndef TOLUA_DISABLE
 918
 919 /* set function: ik_index of class  meshio::pmd::Bone */
 920 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Bone_unsigned_ik_index
 921 static int tolua_set_meshio__pmd__Bone_unsigned_ik_index(lua_State* tolua_S)
 922 {
 923   meshio::pmd::Bone* self = (meshio::pmd::Bone*)  tolua_tousertype(tolua_S,1,0);
 924 #ifndef TOLUA_RELEASE
 925   tolua_Error tolua_err;
 926   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ik_index'",NULL);
 927   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 928    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 929 #endif
 930   self->ik_index = ((unsigned short)  tolua_tonumber(tolua_S,2,0))
 931 ;
 932  return 0;
 933 }
 934 #endif //#ifndef TOLUA_DISABLE
 935
 936 /* get function: pos of class  meshio::pmd::Bone */
 937 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Bone_pos
 938 static int tolua_get_meshio__pmd__Bone_pos(lua_State* tolua_S)
 939 {
 940   meshio::pmd::Bone* self = (meshio::pmd::Bone*)  tolua_tousertype(tolua_S,1,0);
 941 #ifndef TOLUA_RELEASE
 942   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'pos'",NULL);
 943 #endif
 944    tolua_pushusertype(tolua_S,(void*)&self->pos,"meshio::Vector3");
 945  return 1;
 946 }
 947 #endif //#ifndef TOLUA_DISABLE
 948
 949 /* set function: pos of class  meshio::pmd::Bone */
 950 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Bone_pos
 951 static int tolua_set_meshio__pmd__Bone_pos(lua_State* tolua_S)
 952 {
 953   meshio::pmd::Bone* self = (meshio::pmd::Bone*)  tolua_tousertype(tolua_S,1,0);
 954 #ifndef TOLUA_RELEASE
 955   tolua_Error tolua_err;
 956   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'pos'",NULL);
 957   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::Vector3",0,&tolua_err)))
 958    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 959 #endif
 960   self->pos = *((meshio::Vector3*)  tolua_tousertype(tolua_S,2,0))
 961 ;
 962  return 0;
 963 }
 964 #endif //#ifndef TOLUA_DISABLE
 965
 966 /* get function: english_name of class  meshio::pmd::Bone */
 967 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Bone_english_name
 968 static int tolua_get_meshio__pmd__Bone_english_name(lua_State* tolua_S)
 969 {
 970   meshio::pmd::Bone* self = (meshio::pmd::Bone*)  tolua_tousertype(tolua_S,1,0);
 971 #ifndef TOLUA_RELEASE
 972   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'english_name'",NULL);
 973 #endif
 974    tolua_pushusertype(tolua_S,(void*)&self->english_name,"meshio::fixed_string<20>");
 975  return 1;
 976 }
 977 #endif //#ifndef TOLUA_DISABLE
 978
 979 /* set function: english_name of class  meshio::pmd::Bone */
 980 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Bone_english_name
 981 static int tolua_set_meshio__pmd__Bone_english_name(lua_State* tolua_S)
 982 {
 983   meshio::pmd::Bone* self = (meshio::pmd::Bone*)  tolua_tousertype(tolua_S,1,0);
 984 #ifndef TOLUA_RELEASE
 985   tolua_Error tolua_err;
 986   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'english_name'",NULL);
 987   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::fixed_string<20>",0,&tolua_err)))
 988    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
 989 #endif
 990   self->english_name = *((meshio::fixed_string<20>*)  tolua_tousertype(tolua_S,2,0))
 991 ;
 992  return 0;
 993 }
 994 #endif //#ifndef TOLUA_DISABLE
 995
 996 /* get function: parent of class  meshio::pmd::Bone */
 997 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Bone_parent_ptr
 998 static int tolua_get_meshio__pmd__Bone_parent_ptr(lua_State* tolua_S)
 999 {
1000   meshio::pmd::Bone* self = (meshio::pmd::Bone*)  tolua_tousertype(tolua_S,1,0);
1001 #ifndef TOLUA_RELEASE
1002   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'parent'",NULL);
1003 #endif
1004    tolua_pushusertype(tolua_S,(void*)self->parent,"meshio::pmd::Bone");
1005  return 1;
1006 }
1007 #endif //#ifndef TOLUA_DISABLE
1008
1009 /* set function: parent of class  meshio::pmd::Bone */
1010 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Bone_parent_ptr
1011 static int tolua_set_meshio__pmd__Bone_parent_ptr(lua_State* tolua_S)
1012 {
1013   meshio::pmd::Bone* self = (meshio::pmd::Bone*)  tolua_tousertype(tolua_S,1,0);
1014 #ifndef TOLUA_RELEASE
1015   tolua_Error tolua_err;
1016   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'parent'",NULL);
1017   if (!tolua_isusertype(tolua_S,2,"meshio::pmd::Bone",0,&tolua_err))
1018    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1019 #endif
1020   self->parent = ((meshio::pmd::Bone*)  tolua_tousertype(tolua_S,2,0))
1021 ;
1022  return 0;
1023 }
1024 #endif //#ifndef TOLUA_DISABLE
1025
1026 /* get function: tail of class  meshio::pmd::Bone */
1027 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Bone_tail
1028 static int tolua_get_meshio__pmd__Bone_tail(lua_State* tolua_S)
1029 {
1030   meshio::pmd::Bone* self = (meshio::pmd::Bone*)  tolua_tousertype(tolua_S,1,0);
1031 #ifndef TOLUA_RELEASE
1032   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'tail'",NULL);
1033 #endif
1034    tolua_pushusertype(tolua_S,(void*)&self->tail,"meshio::Vector3");
1035  return 1;
1036 }
1037 #endif //#ifndef TOLUA_DISABLE
1038
1039 /* set function: tail of class  meshio::pmd::Bone */
1040 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Bone_tail
1041 static int tolua_set_meshio__pmd__Bone_tail(lua_State* tolua_S)
1042 {
1043   meshio::pmd::Bone* self = (meshio::pmd::Bone*)  tolua_tousertype(tolua_S,1,0);
1044 #ifndef TOLUA_RELEASE
1045   tolua_Error tolua_err;
1046   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'tail'",NULL);
1047   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::Vector3",0,&tolua_err)))
1048    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1049 #endif
1050   self->tail = *((meshio::Vector3*)  tolua_tousertype(tolua_S,2,0))
1051 ;
1052  return 0;
1053 }
1054 #endif //#ifndef TOLUA_DISABLE
1055
1056 /* get function: children of class  meshio::pmd::Bone */
1057 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Bone_children
1058 static int tolua_get_meshio__pmd__Bone_children(lua_State* tolua_S)
1059 {
1060   meshio::pmd::Bone* self = (meshio::pmd::Bone*)  tolua_tousertype(tolua_S,1,0);
1061 #ifndef TOLUA_RELEASE
1062   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'children'",NULL);
1063 #endif
1064    tolua_pushusertype(tolua_S,(void*)&self->children,"std::vector<meshio::pmd::Bone*>");
1065  return 1;
1066 }
1067 #endif //#ifndef TOLUA_DISABLE
1068
1069 /* set function: children of class  meshio::pmd::Bone */
1070 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Bone_children
1071 static int tolua_set_meshio__pmd__Bone_children(lua_State* tolua_S)
1072 {
1073   meshio::pmd::Bone* self = (meshio::pmd::Bone*)  tolua_tousertype(tolua_S,1,0);
1074 #ifndef TOLUA_RELEASE
1075   tolua_Error tolua_err;
1076   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'children'",NULL);
1077   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"std::vector<meshio::pmd::Bone*>",0,&tolua_err)))
1078    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1079 #endif
1080   self->children = *((std::vector<meshio::pmd::Bone*>*)  tolua_tousertype(tolua_S,2,0))
1081 ;
1082  return 0;
1083 }
1084 #endif //#ifndef TOLUA_DISABLE
1085
1086 /* get function: index of class  meshio::pmd::Bone */
1087 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Bone_unsigned_index
1088 static int tolua_get_meshio__pmd__Bone_unsigned_index(lua_State* tolua_S)
1089 {
1090   meshio::pmd::Bone* self = (meshio::pmd::Bone*)  tolua_tousertype(tolua_S,1,0);
1091 #ifndef TOLUA_RELEASE
1092   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'index'",NULL);
1093 #endif
1094   tolua_pushnumber(tolua_S,(lua_Number)self->index);
1095  return 1;
1096 }
1097 #endif //#ifndef TOLUA_DISABLE
1098
1099 /* set function: index of class  meshio::pmd::Bone */
1100 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Bone_unsigned_index
1101 static int tolua_set_meshio__pmd__Bone_unsigned_index(lua_State* tolua_S)
1102 {
1103   meshio::pmd::Bone* self = (meshio::pmd::Bone*)  tolua_tousertype(tolua_S,1,0);
1104 #ifndef TOLUA_RELEASE
1105   tolua_Error tolua_err;
1106   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'index'",NULL);
1107   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
1108    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1109 #endif
1110   self->index = ((unsigned short)  tolua_tonumber(tolua_S,2,0))
1111 ;
1112  return 0;
1113 }
1114 #endif //#ifndef TOLUA_DISABLE
1115
1116 /* method: new of class  meshio::pmd::Bone */
1117 #ifndef TOLUA_DISABLE_tolua_lmeshio_meshio_pmd_Bone_new00
1118 static int tolua_lmeshio_meshio_pmd_Bone_new00(lua_State* tolua_S)
1119 {
1120 #ifndef TOLUA_RELEASE
1121  tolua_Error tolua_err;
1122  if (
1123      !tolua_isusertable(tolua_S,1,"meshio::pmd::Bone",0,&tolua_err) ||
1124      !tolua_isnoobj(tolua_S,2,&tolua_err)
1125  )
1126   goto tolua_lerror;
1127  else
1128 #endif
1129  {
1130
1131
1132   {
1133    meshio::pmd::Bone* tolua_ret = (meshio::pmd::Bone*)  Mtolua_new((meshio::pmd::Bone)());
1134     tolua_pushusertype(tolua_S,(void*)tolua_ret,"meshio::pmd::Bone");
1135   }
1136
1137  }
1138  return 1;
1139 #ifndef TOLUA_RELEASE
1140  tolua_lerror:
1141  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
1142  return 0;
1143 #endif
1144 }
1145 #endif //#ifndef TOLUA_DISABLE
1146
1147 /* method: new_local of class  meshio::pmd::Bone */
1148 #ifndef TOLUA_DISABLE_tolua_lmeshio_meshio_pmd_Bone_new00_local
1149 static int tolua_lmeshio_meshio_pmd_Bone_new00_local(lua_State* tolua_S)
1150 {
1151 #ifndef TOLUA_RELEASE
1152  tolua_Error tolua_err;
1153  if (
1154      !tolua_isusertable(tolua_S,1,"meshio::pmd::Bone",0,&tolua_err) ||
1155      !tolua_isnoobj(tolua_S,2,&tolua_err)
1156  )
1157   goto tolua_lerror;
1158  else
1159 #endif
1160  {
1161
1162
1163   {
1164    meshio::pmd::Bone* tolua_ret = (meshio::pmd::Bone*)  Mtolua_new((meshio::pmd::Bone)());
1165     tolua_pushusertype(tolua_S,(void*)tolua_ret,"meshio::pmd::Bone");
1166     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
1167   }
1168
1169  }
1170  return 1;
1171 #ifndef TOLUA_RELEASE
1172  tolua_lerror:
1173  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
1174  return 0;
1175 #endif
1176 }
1177 #endif //#ifndef TOLUA_DISABLE
1178
1179 /* get function: index of class  meshio::pmd::IK */
1180 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__IK_unsigned_index
1181 static int tolua_get_meshio__pmd__IK_unsigned_index(lua_State* tolua_S)
1182 {
1183   meshio::pmd::IK* self = (meshio::pmd::IK*)  tolua_tousertype(tolua_S,1,0);
1184 #ifndef TOLUA_RELEASE
1185   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'index'",NULL);
1186 #endif
1187   tolua_pushnumber(tolua_S,(lua_Number)self->index);
1188  return 1;
1189 }
1190 #endif //#ifndef TOLUA_DISABLE
1191
1192 /* set function: index of class  meshio::pmd::IK */
1193 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__IK_unsigned_index
1194 static int tolua_set_meshio__pmd__IK_unsigned_index(lua_State* tolua_S)
1195 {
1196   meshio::pmd::IK* self = (meshio::pmd::IK*)  tolua_tousertype(tolua_S,1,0);
1197 #ifndef TOLUA_RELEASE
1198   tolua_Error tolua_err;
1199   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'index'",NULL);
1200   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
1201    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1202 #endif
1203   self->index = ((unsigned short)  tolua_tonumber(tolua_S,2,0))
1204 ;
1205  return 0;
1206 }
1207 #endif //#ifndef TOLUA_DISABLE
1208
1209 /* get function: target of class  meshio::pmd::IK */
1210 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__IK_unsigned_target
1211 static int tolua_get_meshio__pmd__IK_unsigned_target(lua_State* tolua_S)
1212 {
1213   meshio::pmd::IK* self = (meshio::pmd::IK*)  tolua_tousertype(tolua_S,1,0);
1214 #ifndef TOLUA_RELEASE
1215   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'target'",NULL);
1216 #endif
1217   tolua_pushnumber(tolua_S,(lua_Number)self->target);
1218  return 1;
1219 }
1220 #endif //#ifndef TOLUA_DISABLE
1221
1222 /* set function: target of class  meshio::pmd::IK */
1223 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__IK_unsigned_target
1224 static int tolua_set_meshio__pmd__IK_unsigned_target(lua_State* tolua_S)
1225 {
1226   meshio::pmd::IK* self = (meshio::pmd::IK*)  tolua_tousertype(tolua_S,1,0);
1227 #ifndef TOLUA_RELEASE
1228   tolua_Error tolua_err;
1229   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'target'",NULL);
1230   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
1231    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1232 #endif
1233   self->target = ((unsigned short)  tolua_tonumber(tolua_S,2,0))
1234 ;
1235  return 0;
1236 }
1237 #endif //#ifndef TOLUA_DISABLE
1238
1239 /* get function: length of class  meshio::pmd::IK */
1240 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__IK_unsigned_length
1241 static int tolua_get_meshio__pmd__IK_unsigned_length(lua_State* tolua_S)
1242 {
1243   meshio::pmd::IK* self = (meshio::pmd::IK*)  tolua_tousertype(tolua_S,1,0);
1244 #ifndef TOLUA_RELEASE
1245   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'length'",NULL);
1246 #endif
1247   tolua_pushnumber(tolua_S,(lua_Number)self->length);
1248  return 1;
1249 }
1250 #endif //#ifndef TOLUA_DISABLE
1251
1252 /* set function: length of class  meshio::pmd::IK */
1253 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__IK_unsigned_length
1254 static int tolua_set_meshio__pmd__IK_unsigned_length(lua_State* tolua_S)
1255 {
1256   meshio::pmd::IK* self = (meshio::pmd::IK*)  tolua_tousertype(tolua_S,1,0);
1257 #ifndef TOLUA_RELEASE
1258   tolua_Error tolua_err;
1259   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'length'",NULL);
1260   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
1261    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1262 #endif
1263   self->length = ((unsigned char)  tolua_tonumber(tolua_S,2,0))
1264 ;
1265  return 0;
1266 }
1267 #endif //#ifndef TOLUA_DISABLE
1268
1269 /* get function: iterations of class  meshio::pmd::IK */
1270 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__IK_unsigned_iterations
1271 static int tolua_get_meshio__pmd__IK_unsigned_iterations(lua_State* tolua_S)
1272 {
1273   meshio::pmd::IK* self = (meshio::pmd::IK*)  tolua_tousertype(tolua_S,1,0);
1274 #ifndef TOLUA_RELEASE
1275   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'iterations'",NULL);
1276 #endif
1277   tolua_pushnumber(tolua_S,(lua_Number)self->iterations);
1278  return 1;
1279 }
1280 #endif //#ifndef TOLUA_DISABLE
1281
1282 /* set function: iterations of class  meshio::pmd::IK */
1283 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__IK_unsigned_iterations
1284 static int tolua_set_meshio__pmd__IK_unsigned_iterations(lua_State* tolua_S)
1285 {
1286   meshio::pmd::IK* self = (meshio::pmd::IK*)  tolua_tousertype(tolua_S,1,0);
1287 #ifndef TOLUA_RELEASE
1288   tolua_Error tolua_err;
1289   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'iterations'",NULL);
1290   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
1291    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1292 #endif
1293   self->iterations = ((unsigned short)  tolua_tonumber(tolua_S,2,0))
1294 ;
1295  return 0;
1296 }
1297 #endif //#ifndef TOLUA_DISABLE
1298
1299 /* get function: weight of class  meshio::pmd::IK */
1300 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__IK_weight
1301 static int tolua_get_meshio__pmd__IK_weight(lua_State* tolua_S)
1302 {
1303   meshio::pmd::IK* self = (meshio::pmd::IK*)  tolua_tousertype(tolua_S,1,0);
1304 #ifndef TOLUA_RELEASE
1305   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'weight'",NULL);
1306 #endif
1307   tolua_pushnumber(tolua_S,(lua_Number)self->weight);
1308  return 1;
1309 }
1310 #endif //#ifndef TOLUA_DISABLE
1311
1312 /* set function: weight of class  meshio::pmd::IK */
1313 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__IK_weight
1314 static int tolua_set_meshio__pmd__IK_weight(lua_State* tolua_S)
1315 {
1316   meshio::pmd::IK* self = (meshio::pmd::IK*)  tolua_tousertype(tolua_S,1,0);
1317 #ifndef TOLUA_RELEASE
1318   tolua_Error tolua_err;
1319   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'weight'",NULL);
1320   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
1321    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1322 #endif
1323   self->weight = ((float)  tolua_tonumber(tolua_S,2,0))
1324 ;
1325  return 0;
1326 }
1327 #endif //#ifndef TOLUA_DISABLE
1328
1329 /* get function: children of class  meshio::pmd::IK */
1330 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__IK_children
1331 static int tolua_get_meshio__pmd__IK_children(lua_State* tolua_S)
1332 {
1333   meshio::pmd::IK* self = (meshio::pmd::IK*)  tolua_tousertype(tolua_S,1,0);
1334 #ifndef TOLUA_RELEASE
1335   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'children'",NULL);
1336 #endif
1337    tolua_pushusertype(tolua_S,(void*)&self->children,"std::vector<unsigned short>");
1338  return 1;
1339 }
1340 #endif //#ifndef TOLUA_DISABLE
1341
1342 /* set function: children of class  meshio::pmd::IK */
1343 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__IK_children
1344 static int tolua_set_meshio__pmd__IK_children(lua_State* tolua_S)
1345 {
1346   meshio::pmd::IK* self = (meshio::pmd::IK*)  tolua_tousertype(tolua_S,1,0);
1347 #ifndef TOLUA_RELEASE
1348   tolua_Error tolua_err;
1349   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'children'",NULL);
1350   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"std::vector<unsigned short>",0,&tolua_err)))
1351    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1352 #endif
1353   self->children = *((std::vector<unsigned short>*)  tolua_tousertype(tolua_S,2,0))
1354 ;
1355  return 0;
1356 }
1357 #endif //#ifndef TOLUA_DISABLE
1358
1359 /* get function: name of class  meshio::pmd::Morph */
1360 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Morph_name
1361 static int tolua_get_meshio__pmd__Morph_name(lua_State* tolua_S)
1362 {
1363   meshio::pmd::Morph* self = (meshio::pmd::Morph*)  tolua_tousertype(tolua_S,1,0);
1364 #ifndef TOLUA_RELEASE
1365   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'name'",NULL);
1366 #endif
1367    tolua_pushusertype(tolua_S,(void*)&self->name,"meshio::fixed_string<20>");
1368  return 1;
1369 }
1370 #endif //#ifndef TOLUA_DISABLE
1371
1372 /* set function: name of class  meshio::pmd::Morph */
1373 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Morph_name
1374 static int tolua_set_meshio__pmd__Morph_name(lua_State* tolua_S)
1375 {
1376   meshio::pmd::Morph* self = (meshio::pmd::Morph*)  tolua_tousertype(tolua_S,1,0);
1377 #ifndef TOLUA_RELEASE
1378   tolua_Error tolua_err;
1379   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'name'",NULL);
1380   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::fixed_string<20>",0,&tolua_err)))
1381    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1382 #endif
1383   self->name = *((meshio::fixed_string<20>*)  tolua_tousertype(tolua_S,2,0))
1384 ;
1385  return 0;
1386 }
1387 #endif //#ifndef TOLUA_DISABLE
1388
1389 /* get function: vertex_count of class  meshio::pmd::Morph */
1390 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Morph_unsigned_vertex_count
1391 static int tolua_get_meshio__pmd__Morph_unsigned_vertex_count(lua_State* tolua_S)
1392 {
1393   meshio::pmd::Morph* self = (meshio::pmd::Morph*)  tolua_tousertype(tolua_S,1,0);
1394 #ifndef TOLUA_RELEASE
1395   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'vertex_count'",NULL);
1396 #endif
1397   tolua_pushnumber(tolua_S,(lua_Number)self->vertex_count);
1398  return 1;
1399 }
1400 #endif //#ifndef TOLUA_DISABLE
1401
1402 /* set function: vertex_count of class  meshio::pmd::Morph */
1403 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Morph_unsigned_vertex_count
1404 static int tolua_set_meshio__pmd__Morph_unsigned_vertex_count(lua_State* tolua_S)
1405 {
1406   meshio::pmd::Morph* self = (meshio::pmd::Morph*)  tolua_tousertype(tolua_S,1,0);
1407 #ifndef TOLUA_RELEASE
1408   tolua_Error tolua_err;
1409   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'vertex_count'",NULL);
1410   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
1411    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1412 #endif
1413   self->vertex_count = ((unsigned int)  tolua_tonumber(tolua_S,2,0))
1414 ;
1415  return 0;
1416 }
1417 #endif //#ifndef TOLUA_DISABLE
1418
1419 /* get function: type of class  meshio::pmd::Morph */
1420 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Morph_unsigned_type
1421 static int tolua_get_meshio__pmd__Morph_unsigned_type(lua_State* tolua_S)
1422 {
1423   meshio::pmd::Morph* self = (meshio::pmd::Morph*)  tolua_tousertype(tolua_S,1,0);
1424 #ifndef TOLUA_RELEASE
1425   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'type'",NULL);
1426 #endif
1427   tolua_pushnumber(tolua_S,(lua_Number)self->type);
1428  return 1;
1429 }
1430 #endif //#ifndef TOLUA_DISABLE
1431
1432 /* set function: type of class  meshio::pmd::Morph */
1433 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Morph_unsigned_type
1434 static int tolua_set_meshio__pmd__Morph_unsigned_type(lua_State* tolua_S)
1435 {
1436   meshio::pmd::Morph* self = (meshio::pmd::Morph*)  tolua_tousertype(tolua_S,1,0);
1437 #ifndef TOLUA_RELEASE
1438   tolua_Error tolua_err;
1439   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'type'",NULL);
1440   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
1441    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1442 #endif
1443   self->type = ((unsigned char)  tolua_tonumber(tolua_S,2,0))
1444 ;
1445  return 0;
1446 }
1447 #endif //#ifndef TOLUA_DISABLE
1448
1449 /* get function: indices of class  meshio::pmd::Morph */
1450 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Morph_indices
1451 static int tolua_get_meshio__pmd__Morph_indices(lua_State* tolua_S)
1452 {
1453   meshio::pmd::Morph* self = (meshio::pmd::Morph*)  tolua_tousertype(tolua_S,1,0);
1454 #ifndef TOLUA_RELEASE
1455   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'indices'",NULL);
1456 #endif
1457    tolua_pushusertype(tolua_S,(void*)&self->indices,"std::vector<unsigned int>");
1458  return 1;
1459 }
1460 #endif //#ifndef TOLUA_DISABLE
1461
1462 /* set function: indices of class  meshio::pmd::Morph */
1463 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Morph_indices
1464 static int tolua_set_meshio__pmd__Morph_indices(lua_State* tolua_S)
1465 {
1466   meshio::pmd::Morph* self = (meshio::pmd::Morph*)  tolua_tousertype(tolua_S,1,0);
1467 #ifndef TOLUA_RELEASE
1468   tolua_Error tolua_err;
1469   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'indices'",NULL);
1470   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"std::vector<unsigned int>",0,&tolua_err)))
1471    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1472 #endif
1473   self->indices = *((std::vector<unsigned int>*)  tolua_tousertype(tolua_S,2,0))
1474 ;
1475  return 0;
1476 }
1477 #endif //#ifndef TOLUA_DISABLE
1478
1479 /* get function: pos_list of class  meshio::pmd::Morph */
1480 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Morph_pos_list
1481 static int tolua_get_meshio__pmd__Morph_pos_list(lua_State* tolua_S)
1482 {
1483   meshio::pmd::Morph* self = (meshio::pmd::Morph*)  tolua_tousertype(tolua_S,1,0);
1484 #ifndef TOLUA_RELEASE
1485   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'pos_list'",NULL);
1486 #endif
1487    tolua_pushusertype(tolua_S,(void*)&self->pos_list,"std::vector<meshio::Vector3>");
1488  return 1;
1489 }
1490 #endif //#ifndef TOLUA_DISABLE
1491
1492 /* set function: pos_list of class  meshio::pmd::Morph */
1493 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Morph_pos_list
1494 static int tolua_set_meshio__pmd__Morph_pos_list(lua_State* tolua_S)
1495 {
1496   meshio::pmd::Morph* self = (meshio::pmd::Morph*)  tolua_tousertype(tolua_S,1,0);
1497 #ifndef TOLUA_RELEASE
1498   tolua_Error tolua_err;
1499   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'pos_list'",NULL);
1500   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"std::vector<meshio::Vector3>",0,&tolua_err)))
1501    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1502 #endif
1503   self->pos_list = *((std::vector<meshio::Vector3>*)  tolua_tousertype(tolua_S,2,0))
1504 ;
1505  return 0;
1506 }
1507 #endif //#ifndef TOLUA_DISABLE
1508
1509 /* get function: english_name of class  meshio::pmd::Morph */
1510 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Morph_english_name
1511 static int tolua_get_meshio__pmd__Morph_english_name(lua_State* tolua_S)
1512 {
1513   meshio::pmd::Morph* self = (meshio::pmd::Morph*)  tolua_tousertype(tolua_S,1,0);
1514 #ifndef TOLUA_RELEASE
1515   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'english_name'",NULL);
1516 #endif
1517    tolua_pushusertype(tolua_S,(void*)&self->english_name,"meshio::fixed_string<20>");
1518  return 1;
1519 }
1520 #endif //#ifndef TOLUA_DISABLE
1521
1522 /* set function: english_name of class  meshio::pmd::Morph */
1523 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Morph_english_name
1524 static int tolua_set_meshio__pmd__Morph_english_name(lua_State* tolua_S)
1525 {
1526   meshio::pmd::Morph* self = (meshio::pmd::Morph*)  tolua_tousertype(tolua_S,1,0);
1527 #ifndef TOLUA_RELEASE
1528   tolua_Error tolua_err;
1529   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'english_name'",NULL);
1530   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::fixed_string<20>",0,&tolua_err)))
1531    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1532 #endif
1533   self->english_name = *((meshio::fixed_string<20>*)  tolua_tousertype(tolua_S,2,0))
1534 ;
1535  return 0;
1536 }
1537 #endif //#ifndef TOLUA_DISABLE
1538
1539 /* get function: name of class  meshio::pmd::BoneGroup */
1540 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__BoneGroup_name
1541 static int tolua_get_meshio__pmd__BoneGroup_name(lua_State* tolua_S)
1542 {
1543   meshio::pmd::BoneGroup* self = (meshio::pmd::BoneGroup*)  tolua_tousertype(tolua_S,1,0);
1544 #ifndef TOLUA_RELEASE
1545   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'name'",NULL);
1546 #endif
1547    tolua_pushusertype(tolua_S,(void*)&self->name,"meshio::fixed_string<50>");
1548  return 1;
1549 }
1550 #endif //#ifndef TOLUA_DISABLE
1551
1552 /* set function: name of class  meshio::pmd::BoneGroup */
1553 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__BoneGroup_name
1554 static int tolua_set_meshio__pmd__BoneGroup_name(lua_State* tolua_S)
1555 {
1556   meshio::pmd::BoneGroup* self = (meshio::pmd::BoneGroup*)  tolua_tousertype(tolua_S,1,0);
1557 #ifndef TOLUA_RELEASE
1558   tolua_Error tolua_err;
1559   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'name'",NULL);
1560   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::fixed_string<50>",0,&tolua_err)))
1561    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1562 #endif
1563   self->name = *((meshio::fixed_string<50>*)  tolua_tousertype(tolua_S,2,0))
1564 ;
1565  return 0;
1566 }
1567 #endif //#ifndef TOLUA_DISABLE
1568
1569 /* get function: english_name of class  meshio::pmd::BoneGroup */
1570 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__BoneGroup_english_name
1571 static int tolua_get_meshio__pmd__BoneGroup_english_name(lua_State* tolua_S)
1572 {
1573   meshio::pmd::BoneGroup* self = (meshio::pmd::BoneGroup*)  tolua_tousertype(tolua_S,1,0);
1574 #ifndef TOLUA_RELEASE
1575   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'english_name'",NULL);
1576 #endif
1577    tolua_pushusertype(tolua_S,(void*)&self->english_name,"meshio::fixed_string<50>");
1578  return 1;
1579 }
1580 #endif //#ifndef TOLUA_DISABLE
1581
1582 /* set function: english_name of class  meshio::pmd::BoneGroup */
1583 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__BoneGroup_english_name
1584 static int tolua_set_meshio__pmd__BoneGroup_english_name(lua_State* tolua_S)
1585 {
1586   meshio::pmd::BoneGroup* self = (meshio::pmd::BoneGroup*)  tolua_tousertype(tolua_S,1,0);
1587 #ifndef TOLUA_RELEASE
1588   tolua_Error tolua_err;
1589   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'english_name'",NULL);
1590   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::fixed_string<50>",0,&tolua_err)))
1591    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1592 #endif
1593   self->english_name = *((meshio::fixed_string<50>*)  tolua_tousertype(tolua_S,2,0))
1594 ;
1595  return 0;
1596 }
1597 #endif //#ifndef TOLUA_DISABLE
1598
1599 /* get function: name of class  meshio::pmd::RigidBody */
1600 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__RigidBody_name
1601 static int tolua_get_meshio__pmd__RigidBody_name(lua_State* tolua_S)
1602 {
1603   meshio::pmd::RigidBody* self = (meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,1,0);
1604 #ifndef TOLUA_RELEASE
1605   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'name'",NULL);
1606 #endif
1607    tolua_pushusertype(tolua_S,(void*)&self->name,"meshio::fixed_string<20>");
1608  return 1;
1609 }
1610 #endif //#ifndef TOLUA_DISABLE
1611
1612 /* set function: name of class  meshio::pmd::RigidBody */
1613 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__RigidBody_name
1614 static int tolua_set_meshio__pmd__RigidBody_name(lua_State* tolua_S)
1615 {
1616   meshio::pmd::RigidBody* self = (meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,1,0);
1617 #ifndef TOLUA_RELEASE
1618   tolua_Error tolua_err;
1619   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'name'",NULL);
1620   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::fixed_string<20>",0,&tolua_err)))
1621    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1622 #endif
1623   self->name = *((meshio::fixed_string<20>*)  tolua_tousertype(tolua_S,2,0))
1624 ;
1625  return 0;
1626 }
1627 #endif //#ifndef TOLUA_DISABLE
1628
1629 /* get function: boneIndex of class  meshio::pmd::RigidBody */
1630 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__RigidBody_unsigned_boneIndex
1631 static int tolua_get_meshio__pmd__RigidBody_unsigned_boneIndex(lua_State* tolua_S)
1632 {
1633   meshio::pmd::RigidBody* self = (meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,1,0);
1634 #ifndef TOLUA_RELEASE
1635   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'boneIndex'",NULL);
1636 #endif
1637   tolua_pushnumber(tolua_S,(lua_Number)self->boneIndex);
1638  return 1;
1639 }
1640 #endif //#ifndef TOLUA_DISABLE
1641
1642 /* set function: boneIndex of class  meshio::pmd::RigidBody */
1643 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__RigidBody_unsigned_boneIndex
1644 static int tolua_set_meshio__pmd__RigidBody_unsigned_boneIndex(lua_State* tolua_S)
1645 {
1646   meshio::pmd::RigidBody* self = (meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,1,0);
1647 #ifndef TOLUA_RELEASE
1648   tolua_Error tolua_err;
1649   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'boneIndex'",NULL);
1650   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
1651    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1652 #endif
1653   self->boneIndex = ((unsigned short)  tolua_tonumber(tolua_S,2,0))
1654 ;
1655  return 0;
1656 }
1657 #endif //#ifndef TOLUA_DISABLE
1658
1659 /* get function: group of class  meshio::pmd::RigidBody */
1660 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__RigidBody_unsigned_group
1661 static int tolua_get_meshio__pmd__RigidBody_unsigned_group(lua_State* tolua_S)
1662 {
1663   meshio::pmd::RigidBody* self = (meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,1,0);
1664 #ifndef TOLUA_RELEASE
1665   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'group'",NULL);
1666 #endif
1667   tolua_pushnumber(tolua_S,(lua_Number)self->group);
1668  return 1;
1669 }
1670 #endif //#ifndef TOLUA_DISABLE
1671
1672 /* set function: group of class  meshio::pmd::RigidBody */
1673 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__RigidBody_unsigned_group
1674 static int tolua_set_meshio__pmd__RigidBody_unsigned_group(lua_State* tolua_S)
1675 {
1676   meshio::pmd::RigidBody* self = (meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,1,0);
1677 #ifndef TOLUA_RELEASE
1678   tolua_Error tolua_err;
1679   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'group'",NULL);
1680   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
1681    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1682 #endif
1683   self->group = ((unsigned char)  tolua_tonumber(tolua_S,2,0))
1684 ;
1685  return 0;
1686 }
1687 #endif //#ifndef TOLUA_DISABLE
1688
1689 /* get function: target of class  meshio::pmd::RigidBody */
1690 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__RigidBody_unsigned_target
1691 static int tolua_get_meshio__pmd__RigidBody_unsigned_target(lua_State* tolua_S)
1692 {
1693   meshio::pmd::RigidBody* self = (meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,1,0);
1694 #ifndef TOLUA_RELEASE
1695   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'target'",NULL);
1696 #endif
1697   tolua_pushnumber(tolua_S,(lua_Number)self->target);
1698  return 1;
1699 }
1700 #endif //#ifndef TOLUA_DISABLE
1701
1702 /* set function: target of class  meshio::pmd::RigidBody */
1703 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__RigidBody_unsigned_target
1704 static int tolua_set_meshio__pmd__RigidBody_unsigned_target(lua_State* tolua_S)
1705 {
1706   meshio::pmd::RigidBody* self = (meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,1,0);
1707 #ifndef TOLUA_RELEASE
1708   tolua_Error tolua_err;
1709   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'target'",NULL);
1710   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
1711    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1712 #endif
1713   self->target = ((unsigned short)  tolua_tonumber(tolua_S,2,0))
1714 ;
1715  return 0;
1716 }
1717 #endif //#ifndef TOLUA_DISABLE
1718
1719 /* get function: shapeType of class  meshio::pmd::RigidBody */
1720 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__RigidBody_shapeType
1721 static int tolua_get_meshio__pmd__RigidBody_shapeType(lua_State* tolua_S)
1722 {
1723   meshio::pmd::RigidBody* self = (meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,1,0);
1724 #ifndef TOLUA_RELEASE
1725   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'shapeType'",NULL);
1726 #endif
1727   tolua_pushnumber(tolua_S,(lua_Number)self->shapeType);
1728  return 1;
1729 }
1730 #endif //#ifndef TOLUA_DISABLE
1731
1732 /* set function: shapeType of class  meshio::pmd::RigidBody */
1733 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__RigidBody_shapeType
1734 static int tolua_set_meshio__pmd__RigidBody_shapeType(lua_State* tolua_S)
1735 {
1736   meshio::pmd::RigidBody* self = (meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,1,0);
1737 #ifndef TOLUA_RELEASE
1738   tolua_Error tolua_err;
1739   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'shapeType'",NULL);
1740   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
1741    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1742 #endif
1743   self->shapeType = ((meshio::pmd::SHAPE_TYPE) (int)  tolua_tonumber(tolua_S,2,0))
1744 ;
1745  return 0;
1746 }
1747 #endif //#ifndef TOLUA_DISABLE
1748
1749 /* get function: w of class  meshio::pmd::RigidBody */
1750 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__RigidBody_w
1751 static int tolua_get_meshio__pmd__RigidBody_w(lua_State* tolua_S)
1752 {
1753   meshio::pmd::RigidBody* self = (meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,1,0);
1754 #ifndef TOLUA_RELEASE
1755   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'w'",NULL);
1756 #endif
1757   tolua_pushnumber(tolua_S,(lua_Number)self->w);
1758  return 1;
1759 }
1760 #endif //#ifndef TOLUA_DISABLE
1761
1762 /* set function: w of class  meshio::pmd::RigidBody */
1763 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__RigidBody_w
1764 static int tolua_set_meshio__pmd__RigidBody_w(lua_State* tolua_S)
1765 {
1766   meshio::pmd::RigidBody* self = (meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,1,0);
1767 #ifndef TOLUA_RELEASE
1768   tolua_Error tolua_err;
1769   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'w'",NULL);
1770   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
1771    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1772 #endif
1773   self->w = ((float)  tolua_tonumber(tolua_S,2,0))
1774 ;
1775  return 0;
1776 }
1777 #endif //#ifndef TOLUA_DISABLE
1778
1779 /* get function: h of class  meshio::pmd::RigidBody */
1780 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__RigidBody_h
1781 static int tolua_get_meshio__pmd__RigidBody_h(lua_State* tolua_S)
1782 {
1783   meshio::pmd::RigidBody* self = (meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,1,0);
1784 #ifndef TOLUA_RELEASE
1785   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'h'",NULL);
1786 #endif
1787   tolua_pushnumber(tolua_S,(lua_Number)self->h);
1788  return 1;
1789 }
1790 #endif //#ifndef TOLUA_DISABLE
1791
1792 /* set function: h of class  meshio::pmd::RigidBody */
1793 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__RigidBody_h
1794 static int tolua_set_meshio__pmd__RigidBody_h(lua_State* tolua_S)
1795 {
1796   meshio::pmd::RigidBody* self = (meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,1,0);
1797 #ifndef TOLUA_RELEASE
1798   tolua_Error tolua_err;
1799   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'h'",NULL);
1800   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
1801    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1802 #endif
1803   self->h = ((float)  tolua_tonumber(tolua_S,2,0))
1804 ;
1805  return 0;
1806 }
1807 #endif //#ifndef TOLUA_DISABLE
1808
1809 /* get function: d of class  meshio::pmd::RigidBody */
1810 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__RigidBody_d
1811 static int tolua_get_meshio__pmd__RigidBody_d(lua_State* tolua_S)
1812 {
1813   meshio::pmd::RigidBody* self = (meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,1,0);
1814 #ifndef TOLUA_RELEASE
1815   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd'",NULL);
1816 #endif
1817   tolua_pushnumber(tolua_S,(lua_Number)self->d);
1818  return 1;
1819 }
1820 #endif //#ifndef TOLUA_DISABLE
1821
1822 /* set function: d of class  meshio::pmd::RigidBody */
1823 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__RigidBody_d
1824 static int tolua_set_meshio__pmd__RigidBody_d(lua_State* tolua_S)
1825 {
1826   meshio::pmd::RigidBody* self = (meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,1,0);
1827 #ifndef TOLUA_RELEASE
1828   tolua_Error tolua_err;
1829   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd'",NULL);
1830   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
1831    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1832 #endif
1833   self->d = ((float)  tolua_tonumber(tolua_S,2,0))
1834 ;
1835  return 0;
1836 }
1837 #endif //#ifndef TOLUA_DISABLE
1838
1839 /* get function: position of class  meshio::pmd::RigidBody */
1840 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__RigidBody_position
1841 static int tolua_get_meshio__pmd__RigidBody_position(lua_State* tolua_S)
1842 {
1843   meshio::pmd::RigidBody* self = (meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,1,0);
1844 #ifndef TOLUA_RELEASE
1845   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'position'",NULL);
1846 #endif
1847    tolua_pushusertype(tolua_S,(void*)&self->position,"meshio::Vector3");
1848  return 1;
1849 }
1850 #endif //#ifndef TOLUA_DISABLE
1851
1852 /* set function: position of class  meshio::pmd::RigidBody */
1853 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__RigidBody_position
1854 static int tolua_set_meshio__pmd__RigidBody_position(lua_State* tolua_S)
1855 {
1856   meshio::pmd::RigidBody* self = (meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,1,0);
1857 #ifndef TOLUA_RELEASE
1858   tolua_Error tolua_err;
1859   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'position'",NULL);
1860   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::Vector3",0,&tolua_err)))
1861    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1862 #endif
1863   self->position = *((meshio::Vector3*)  tolua_tousertype(tolua_S,2,0))
1864 ;
1865  return 0;
1866 }
1867 #endif //#ifndef TOLUA_DISABLE
1868
1869 /* get function: rotation of class  meshio::pmd::RigidBody */
1870 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__RigidBody_rotation
1871 static int tolua_get_meshio__pmd__RigidBody_rotation(lua_State* tolua_S)
1872 {
1873   meshio::pmd::RigidBody* self = (meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,1,0);
1874 #ifndef TOLUA_RELEASE
1875   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'rotation'",NULL);
1876 #endif
1877    tolua_pushusertype(tolua_S,(void*)&self->rotation,"meshio::Vector3");
1878  return 1;
1879 }
1880 #endif //#ifndef TOLUA_DISABLE
1881
1882 /* set function: rotation of class  meshio::pmd::RigidBody */
1883 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__RigidBody_rotation
1884 static int tolua_set_meshio__pmd__RigidBody_rotation(lua_State* tolua_S)
1885 {
1886   meshio::pmd::RigidBody* self = (meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,1,0);
1887 #ifndef TOLUA_RELEASE
1888   tolua_Error tolua_err;
1889   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'rotation'",NULL);
1890   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::Vector3",0,&tolua_err)))
1891    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1892 #endif
1893   self->rotation = *((meshio::Vector3*)  tolua_tousertype(tolua_S,2,0))
1894 ;
1895  return 0;
1896 }
1897 #endif //#ifndef TOLUA_DISABLE
1898
1899 /* get function: weight of class  meshio::pmd::RigidBody */
1900 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__RigidBody_weight
1901 static int tolua_get_meshio__pmd__RigidBody_weight(lua_State* tolua_S)
1902 {
1903   meshio::pmd::RigidBody* self = (meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,1,0);
1904 #ifndef TOLUA_RELEASE
1905   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'weight'",NULL);
1906 #endif
1907   tolua_pushnumber(tolua_S,(lua_Number)self->weight);
1908  return 1;
1909 }
1910 #endif //#ifndef TOLUA_DISABLE
1911
1912 /* set function: weight of class  meshio::pmd::RigidBody */
1913 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__RigidBody_weight
1914 static int tolua_set_meshio__pmd__RigidBody_weight(lua_State* tolua_S)
1915 {
1916   meshio::pmd::RigidBody* self = (meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,1,0);
1917 #ifndef TOLUA_RELEASE
1918   tolua_Error tolua_err;
1919   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'weight'",NULL);
1920   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
1921    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1922 #endif
1923   self->weight = ((float)  tolua_tonumber(tolua_S,2,0))
1924 ;
1925  return 0;
1926 }
1927 #endif //#ifndef TOLUA_DISABLE
1928
1929 /* get function: linearDamping of class  meshio::pmd::RigidBody */
1930 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__RigidBody_linearDamping
1931 static int tolua_get_meshio__pmd__RigidBody_linearDamping(lua_State* tolua_S)
1932 {
1933   meshio::pmd::RigidBody* self = (meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,1,0);
1934 #ifndef TOLUA_RELEASE
1935   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'linearDamping'",NULL);
1936 #endif
1937   tolua_pushnumber(tolua_S,(lua_Number)self->linearDamping);
1938  return 1;
1939 }
1940 #endif //#ifndef TOLUA_DISABLE
1941
1942 /* set function: linearDamping of class  meshio::pmd::RigidBody */
1943 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__RigidBody_linearDamping
1944 static int tolua_set_meshio__pmd__RigidBody_linearDamping(lua_State* tolua_S)
1945 {
1946   meshio::pmd::RigidBody* self = (meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,1,0);
1947 #ifndef TOLUA_RELEASE
1948   tolua_Error tolua_err;
1949   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'linearDamping'",NULL);
1950   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
1951    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1952 #endif
1953   self->linearDamping = ((float)  tolua_tonumber(tolua_S,2,0))
1954 ;
1955  return 0;
1956 }
1957 #endif //#ifndef TOLUA_DISABLE
1958
1959 /* get function: angularDamping of class  meshio::pmd::RigidBody */
1960 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__RigidBody_angularDamping
1961 static int tolua_get_meshio__pmd__RigidBody_angularDamping(lua_State* tolua_S)
1962 {
1963   meshio::pmd::RigidBody* self = (meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,1,0);
1964 #ifndef TOLUA_RELEASE
1965   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'angularDamping'",NULL);
1966 #endif
1967   tolua_pushnumber(tolua_S,(lua_Number)self->angularDamping);
1968  return 1;
1969 }
1970 #endif //#ifndef TOLUA_DISABLE
1971
1972 /* set function: angularDamping of class  meshio::pmd::RigidBody */
1973 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__RigidBody_angularDamping
1974 static int tolua_set_meshio__pmd__RigidBody_angularDamping(lua_State* tolua_S)
1975 {
1976   meshio::pmd::RigidBody* self = (meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,1,0);
1977 #ifndef TOLUA_RELEASE
1978   tolua_Error tolua_err;
1979   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'angularDamping'",NULL);
1980   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
1981    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
1982 #endif
1983   self->angularDamping = ((float)  tolua_tonumber(tolua_S,2,0))
1984 ;
1985  return 0;
1986 }
1987 #endif //#ifndef TOLUA_DISABLE
1988
1989 /* get function: restitution of class  meshio::pmd::RigidBody */
1990 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__RigidBody_restitution
1991 static int tolua_get_meshio__pmd__RigidBody_restitution(lua_State* tolua_S)
1992 {
1993   meshio::pmd::RigidBody* self = (meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,1,0);
1994 #ifndef TOLUA_RELEASE
1995   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'restitution'",NULL);
1996 #endif
1997   tolua_pushnumber(tolua_S,(lua_Number)self->restitution);
1998  return 1;
1999 }
2000 #endif //#ifndef TOLUA_DISABLE
2001
2002 /* set function: restitution of class  meshio::pmd::RigidBody */
2003 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__RigidBody_restitution
2004 static int tolua_set_meshio__pmd__RigidBody_restitution(lua_State* tolua_S)
2005 {
2006   meshio::pmd::RigidBody* self = (meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,1,0);
2007 #ifndef TOLUA_RELEASE
2008   tolua_Error tolua_err;
2009   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'restitution'",NULL);
2010   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
2011    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
2012 #endif
2013   self->restitution = ((float)  tolua_tonumber(tolua_S,2,0))
2014 ;
2015  return 0;
2016 }
2017 #endif //#ifndef TOLUA_DISABLE
2018
2019 /* get function: friction of class  meshio::pmd::RigidBody */
2020 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__RigidBody_friction
2021 static int tolua_get_meshio__pmd__RigidBody_friction(lua_State* tolua_S)
2022 {
2023   meshio::pmd::RigidBody* self = (meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,1,0);
2024 #ifndef TOLUA_RELEASE
2025   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'friction'",NULL);
2026 #endif
2027   tolua_pushnumber(tolua_S,(lua_Number)self->friction);
2028  return 1;
2029 }
2030 #endif //#ifndef TOLUA_DISABLE
2031
2032 /* set function: friction of class  meshio::pmd::RigidBody */
2033 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__RigidBody_friction
2034 static int tolua_set_meshio__pmd__RigidBody_friction(lua_State* tolua_S)
2035 {
2036   meshio::pmd::RigidBody* self = (meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,1,0);
2037 #ifndef TOLUA_RELEASE
2038   tolua_Error tolua_err;
2039   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'friction'",NULL);
2040   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
2041    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
2042 #endif
2043   self->friction = ((float)  tolua_tonumber(tolua_S,2,0))
2044 ;
2045  return 0;
2046 }
2047 #endif //#ifndef TOLUA_DISABLE
2048
2049 /* get function: processType of class  meshio::pmd::RigidBody */
2050 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__RigidBody_processType
2051 static int tolua_get_meshio__pmd__RigidBody_processType(lua_State* tolua_S)
2052 {
2053   meshio::pmd::RigidBody* self = (meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,1,0);
2054 #ifndef TOLUA_RELEASE
2055   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'processType'",NULL);
2056 #endif
2057   tolua_pushnumber(tolua_S,(lua_Number)self->processType);
2058  return 1;
2059 }
2060 #endif //#ifndef TOLUA_DISABLE
2061
2062 /* set function: processType of class  meshio::pmd::RigidBody */
2063 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__RigidBody_processType
2064 static int tolua_set_meshio__pmd__RigidBody_processType(lua_State* tolua_S)
2065 {
2066   meshio::pmd::RigidBody* self = (meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,1,0);
2067 #ifndef TOLUA_RELEASE
2068   tolua_Error tolua_err;
2069   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'processType'",NULL);
2070   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
2071    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
2072 #endif
2073   self->processType = ((meshio::pmd::PROCESS_TYPE) (int)  tolua_tonumber(tolua_S,2,0))
2074 ;
2075  return 0;
2076 }
2077 #endif //#ifndef TOLUA_DISABLE
2078
2079 /* get function: name of class  meshio::pmd::Constraint */
2080 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Constraint_name
2081 static int tolua_get_meshio__pmd__Constraint_name(lua_State* tolua_S)
2082 {
2083   meshio::pmd::Constraint* self = (meshio::pmd::Constraint*)  tolua_tousertype(tolua_S,1,0);
2084 #ifndef TOLUA_RELEASE
2085   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'name'",NULL);
2086 #endif
2087    tolua_pushusertype(tolua_S,(void*)&self->name,"meshio::fixed_string<20>");
2088  return 1;
2089 }
2090 #endif //#ifndef TOLUA_DISABLE
2091
2092 /* set function: name of class  meshio::pmd::Constraint */
2093 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Constraint_name
2094 static int tolua_set_meshio__pmd__Constraint_name(lua_State* tolua_S)
2095 {
2096   meshio::pmd::Constraint* self = (meshio::pmd::Constraint*)  tolua_tousertype(tolua_S,1,0);
2097 #ifndef TOLUA_RELEASE
2098   tolua_Error tolua_err;
2099   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'name'",NULL);
2100   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::fixed_string<20>",0,&tolua_err)))
2101    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
2102 #endif
2103   self->name = *((meshio::fixed_string<20>*)  tolua_tousertype(tolua_S,2,0))
2104 ;
2105  return 0;
2106 }
2107 #endif //#ifndef TOLUA_DISABLE
2108
2109 /* get function: rigidA of class  meshio::pmd::Constraint */
2110 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Constraint_unsigned_rigidA
2111 static int tolua_get_meshio__pmd__Constraint_unsigned_rigidA(lua_State* tolua_S)
2112 {
2113   meshio::pmd::Constraint* self = (meshio::pmd::Constraint*)  tolua_tousertype(tolua_S,1,0);
2114 #ifndef TOLUA_RELEASE
2115   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'rigidA'",NULL);
2116 #endif
2117   tolua_pushnumber(tolua_S,(lua_Number)self->rigidA);
2118  return 1;
2119 }
2120 #endif //#ifndef TOLUA_DISABLE
2121
2122 /* set function: rigidA of class  meshio::pmd::Constraint */
2123 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Constraint_unsigned_rigidA
2124 static int tolua_set_meshio__pmd__Constraint_unsigned_rigidA(lua_State* tolua_S)
2125 {
2126   meshio::pmd::Constraint* self = (meshio::pmd::Constraint*)  tolua_tousertype(tolua_S,1,0);
2127 #ifndef TOLUA_RELEASE
2128   tolua_Error tolua_err;
2129   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'rigidA'",NULL);
2130   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
2131    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
2132 #endif
2133   self->rigidA = ((unsigned int)  tolua_tonumber(tolua_S,2,0))
2134 ;
2135  return 0;
2136 }
2137 #endif //#ifndef TOLUA_DISABLE
2138
2139 /* get function: rigidB of class  meshio::pmd::Constraint */
2140 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Constraint_unsigned_rigidB
2141 static int tolua_get_meshio__pmd__Constraint_unsigned_rigidB(lua_State* tolua_S)
2142 {
2143   meshio::pmd::Constraint* self = (meshio::pmd::Constraint*)  tolua_tousertype(tolua_S,1,0);
2144 #ifndef TOLUA_RELEASE
2145   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'rigidB'",NULL);
2146 #endif
2147   tolua_pushnumber(tolua_S,(lua_Number)self->rigidB);
2148  return 1;
2149 }
2150 #endif //#ifndef TOLUA_DISABLE
2151
2152 /* set function: rigidB of class  meshio::pmd::Constraint */
2153 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Constraint_unsigned_rigidB
2154 static int tolua_set_meshio__pmd__Constraint_unsigned_rigidB(lua_State* tolua_S)
2155 {
2156   meshio::pmd::Constraint* self = (meshio::pmd::Constraint*)  tolua_tousertype(tolua_S,1,0);
2157 #ifndef TOLUA_RELEASE
2158   tolua_Error tolua_err;
2159   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'rigidB'",NULL);
2160   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
2161    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
2162 #endif
2163   self->rigidB = ((unsigned int)  tolua_tonumber(tolua_S,2,0))
2164 ;
2165  return 0;
2166 }
2167 #endif //#ifndef TOLUA_DISABLE
2168
2169 /* get function: pos of class  meshio::pmd::Constraint */
2170 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Constraint_pos
2171 static int tolua_get_meshio__pmd__Constraint_pos(lua_State* tolua_S)
2172 {
2173   meshio::pmd::Constraint* self = (meshio::pmd::Constraint*)  tolua_tousertype(tolua_S,1,0);
2174 #ifndef TOLUA_RELEASE
2175   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'pos'",NULL);
2176 #endif
2177    tolua_pushusertype(tolua_S,(void*)&self->pos,"meshio::Vector3");
2178  return 1;
2179 }
2180 #endif //#ifndef TOLUA_DISABLE
2181
2182 /* set function: pos of class  meshio::pmd::Constraint */
2183 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Constraint_pos
2184 static int tolua_set_meshio__pmd__Constraint_pos(lua_State* tolua_S)
2185 {
2186   meshio::pmd::Constraint* self = (meshio::pmd::Constraint*)  tolua_tousertype(tolua_S,1,0);
2187 #ifndef TOLUA_RELEASE
2188   tolua_Error tolua_err;
2189   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'pos'",NULL);
2190   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::Vector3",0,&tolua_err)))
2191    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
2192 #endif
2193   self->pos = *((meshio::Vector3*)  tolua_tousertype(tolua_S,2,0))
2194 ;
2195  return 0;
2196 }
2197 #endif //#ifndef TOLUA_DISABLE
2198
2199 /* get function: rot of class  meshio::pmd::Constraint */
2200 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Constraint_rot
2201 static int tolua_get_meshio__pmd__Constraint_rot(lua_State* tolua_S)
2202 {
2203   meshio::pmd::Constraint* self = (meshio::pmd::Constraint*)  tolua_tousertype(tolua_S,1,0);
2204 #ifndef TOLUA_RELEASE
2205   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'rot'",NULL);
2206 #endif
2207    tolua_pushusertype(tolua_S,(void*)&self->rot,"meshio::Vector3");
2208  return 1;
2209 }
2210 #endif //#ifndef TOLUA_DISABLE
2211
2212 /* set function: rot of class  meshio::pmd::Constraint */
2213 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Constraint_rot
2214 static int tolua_set_meshio__pmd__Constraint_rot(lua_State* tolua_S)
2215 {
2216   meshio::pmd::Constraint* self = (meshio::pmd::Constraint*)  tolua_tousertype(tolua_S,1,0);
2217 #ifndef TOLUA_RELEASE
2218   tolua_Error tolua_err;
2219   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'rot'",NULL);
2220   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::Vector3",0,&tolua_err)))
2221    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
2222 #endif
2223   self->rot = *((meshio::Vector3*)  tolua_tousertype(tolua_S,2,0))
2224 ;
2225  return 0;
2226 }
2227 #endif //#ifndef TOLUA_DISABLE
2228
2229 /* get function: constraintPosMin of class  meshio::pmd::Constraint */
2230 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Constraint_constraintPosMin
2231 static int tolua_get_meshio__pmd__Constraint_constraintPosMin(lua_State* tolua_S)
2232 {
2233   meshio::pmd::Constraint* self = (meshio::pmd::Constraint*)  tolua_tousertype(tolua_S,1,0);
2234 #ifndef TOLUA_RELEASE
2235   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'constraintPosMin'",NULL);
2236 #endif
2237    tolua_pushusertype(tolua_S,(void*)&self->constraintPosMin,"meshio::Vector3");
2238  return 1;
2239 }
2240 #endif //#ifndef TOLUA_DISABLE
2241
2242 /* set function: constraintPosMin of class  meshio::pmd::Constraint */
2243 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Constraint_constraintPosMin
2244 static int tolua_set_meshio__pmd__Constraint_constraintPosMin(lua_State* tolua_S)
2245 {
2246   meshio::pmd::Constraint* self = (meshio::pmd::Constraint*)  tolua_tousertype(tolua_S,1,0);
2247 #ifndef TOLUA_RELEASE
2248   tolua_Error tolua_err;
2249   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'constraintPosMin'",NULL);
2250   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::Vector3",0,&tolua_err)))
2251    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
2252 #endif
2253   self->constraintPosMin = *((meshio::Vector3*)  tolua_tousertype(tolua_S,2,0))
2254 ;
2255  return 0;
2256 }
2257 #endif //#ifndef TOLUA_DISABLE
2258
2259 /* get function: constraintPosMax of class  meshio::pmd::Constraint */
2260 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Constraint_constraintPosMax
2261 static int tolua_get_meshio__pmd__Constraint_constraintPosMax(lua_State* tolua_S)
2262 {
2263   meshio::pmd::Constraint* self = (meshio::pmd::Constraint*)  tolua_tousertype(tolua_S,1,0);
2264 #ifndef TOLUA_RELEASE
2265   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'constraintPosMax'",NULL);
2266 #endif
2267    tolua_pushusertype(tolua_S,(void*)&self->constraintPosMax,"meshio::Vector3");
2268  return 1;
2269 }
2270 #endif //#ifndef TOLUA_DISABLE
2271
2272 /* set function: constraintPosMax of class  meshio::pmd::Constraint */
2273 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Constraint_constraintPosMax
2274 static int tolua_set_meshio__pmd__Constraint_constraintPosMax(lua_State* tolua_S)
2275 {
2276   meshio::pmd::Constraint* self = (meshio::pmd::Constraint*)  tolua_tousertype(tolua_S,1,0);
2277 #ifndef TOLUA_RELEASE
2278   tolua_Error tolua_err;
2279   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'constraintPosMax'",NULL);
2280   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::Vector3",0,&tolua_err)))
2281    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
2282 #endif
2283   self->constraintPosMax = *((meshio::Vector3*)  tolua_tousertype(tolua_S,2,0))
2284 ;
2285  return 0;
2286 }
2287 #endif //#ifndef TOLUA_DISABLE
2288
2289 /* get function: constraintRotMin of class  meshio::pmd::Constraint */
2290 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Constraint_constraintRotMin
2291 static int tolua_get_meshio__pmd__Constraint_constraintRotMin(lua_State* tolua_S)
2292 {
2293   meshio::pmd::Constraint* self = (meshio::pmd::Constraint*)  tolua_tousertype(tolua_S,1,0);
2294 #ifndef TOLUA_RELEASE
2295   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'constraintRotMin'",NULL);
2296 #endif
2297    tolua_pushusertype(tolua_S,(void*)&self->constraintRotMin,"meshio::Vector3");
2298  return 1;
2299 }
2300 #endif //#ifndef TOLUA_DISABLE
2301
2302 /* set function: constraintRotMin of class  meshio::pmd::Constraint */
2303 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Constraint_constraintRotMin
2304 static int tolua_set_meshio__pmd__Constraint_constraintRotMin(lua_State* tolua_S)
2305 {
2306   meshio::pmd::Constraint* self = (meshio::pmd::Constraint*)  tolua_tousertype(tolua_S,1,0);
2307 #ifndef TOLUA_RELEASE
2308   tolua_Error tolua_err;
2309   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'constraintRotMin'",NULL);
2310   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::Vector3",0,&tolua_err)))
2311    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
2312 #endif
2313   self->constraintRotMin = *((meshio::Vector3*)  tolua_tousertype(tolua_S,2,0))
2314 ;
2315  return 0;
2316 }
2317 #endif //#ifndef TOLUA_DISABLE
2318
2319 /* get function: constraintRotMax of class  meshio::pmd::Constraint */
2320 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Constraint_constraintRotMax
2321 static int tolua_get_meshio__pmd__Constraint_constraintRotMax(lua_State* tolua_S)
2322 {
2323   meshio::pmd::Constraint* self = (meshio::pmd::Constraint*)  tolua_tousertype(tolua_S,1,0);
2324 #ifndef TOLUA_RELEASE
2325   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'constraintRotMax'",NULL);
2326 #endif
2327    tolua_pushusertype(tolua_S,(void*)&self->constraintRotMax,"meshio::Vector3");
2328  return 1;
2329 }
2330 #endif //#ifndef TOLUA_DISABLE
2331
2332 /* set function: constraintRotMax of class  meshio::pmd::Constraint */
2333 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Constraint_constraintRotMax
2334 static int tolua_set_meshio__pmd__Constraint_constraintRotMax(lua_State* tolua_S)
2335 {
2336   meshio::pmd::Constraint* self = (meshio::pmd::Constraint*)  tolua_tousertype(tolua_S,1,0);
2337 #ifndef TOLUA_RELEASE
2338   tolua_Error tolua_err;
2339   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'constraintRotMax'",NULL);
2340   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::Vector3",0,&tolua_err)))
2341    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
2342 #endif
2343   self->constraintRotMax = *((meshio::Vector3*)  tolua_tousertype(tolua_S,2,0))
2344 ;
2345  return 0;
2346 }
2347 #endif //#ifndef TOLUA_DISABLE
2348
2349 /* get function: springPos of class  meshio::pmd::Constraint */
2350 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Constraint_springPos
2351 static int tolua_get_meshio__pmd__Constraint_springPos(lua_State* tolua_S)
2352 {
2353   meshio::pmd::Constraint* self = (meshio::pmd::Constraint*)  tolua_tousertype(tolua_S,1,0);
2354 #ifndef TOLUA_RELEASE
2355   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'springPos'",NULL);
2356 #endif
2357    tolua_pushusertype(tolua_S,(void*)&self->springPos,"meshio::Vector3");
2358  return 1;
2359 }
2360 #endif //#ifndef TOLUA_DISABLE
2361
2362 /* set function: springPos of class  meshio::pmd::Constraint */
2363 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Constraint_springPos
2364 static int tolua_set_meshio__pmd__Constraint_springPos(lua_State* tolua_S)
2365 {
2366   meshio::pmd::Constraint* self = (meshio::pmd::Constraint*)  tolua_tousertype(tolua_S,1,0);
2367 #ifndef TOLUA_RELEASE
2368   tolua_Error tolua_err;
2369   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'springPos'",NULL);
2370   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::Vector3",0,&tolua_err)))
2371    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
2372 #endif
2373   self->springPos = *((meshio::Vector3*)  tolua_tousertype(tolua_S,2,0))
2374 ;
2375  return 0;
2376 }
2377 #endif //#ifndef TOLUA_DISABLE
2378
2379 /* get function: springRot of class  meshio::pmd::Constraint */
2380 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__Constraint_springRot
2381 static int tolua_get_meshio__pmd__Constraint_springRot(lua_State* tolua_S)
2382 {
2383   meshio::pmd::Constraint* self = (meshio::pmd::Constraint*)  tolua_tousertype(tolua_S,1,0);
2384 #ifndef TOLUA_RELEASE
2385   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'springRot'",NULL);
2386 #endif
2387    tolua_pushusertype(tolua_S,(void*)&self->springRot,"meshio::Vector3");
2388  return 1;
2389 }
2390 #endif //#ifndef TOLUA_DISABLE
2391
2392 /* set function: springRot of class  meshio::pmd::Constraint */
2393 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__Constraint_springRot
2394 static int tolua_set_meshio__pmd__Constraint_springRot(lua_State* tolua_S)
2395 {
2396   meshio::pmd::Constraint* self = (meshio::pmd::Constraint*)  tolua_tousertype(tolua_S,1,0);
2397 #ifndef TOLUA_RELEASE
2398   tolua_Error tolua_err;
2399   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'springRot'",NULL);
2400   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::Vector3",0,&tolua_err)))
2401    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
2402 #endif
2403   self->springRot = *((meshio::Vector3*)  tolua_tousertype(tolua_S,2,0))
2404 ;
2405  return 0;
2406 }
2407 #endif //#ifndef TOLUA_DISABLE
2408
2409 /* get function: version of class  meshio::pmd::IO */
2410 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__IO_version
2411 static int tolua_get_meshio__pmd__IO_version(lua_State* tolua_S)
2412 {
2413   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2414 #ifndef TOLUA_RELEASE
2415   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'version'",NULL);
2416 #endif
2417   tolua_pushnumber(tolua_S,(lua_Number)self->version);
2418  return 1;
2419 }
2420 #endif //#ifndef TOLUA_DISABLE
2421
2422 /* set function: version of class  meshio::pmd::IO */
2423 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__IO_version
2424 static int tolua_set_meshio__pmd__IO_version(lua_State* tolua_S)
2425 {
2426   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2427 #ifndef TOLUA_RELEASE
2428   tolua_Error tolua_err;
2429   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'version'",NULL);
2430   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
2431    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
2432 #endif
2433   self->version = ((float)  tolua_tonumber(tolua_S,2,0))
2434 ;
2435  return 0;
2436 }
2437 #endif //#ifndef TOLUA_DISABLE
2438
2439 /* get function: name of class  meshio::pmd::IO */
2440 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__IO_name
2441 static int tolua_get_meshio__pmd__IO_name(lua_State* tolua_S)
2442 {
2443   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2444 #ifndef TOLUA_RELEASE
2445   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'name'",NULL);
2446 #endif
2447    tolua_pushusertype(tolua_S,(void*)&self->name,"meshio::fixed_string<20>");
2448  return 1;
2449 }
2450 #endif //#ifndef TOLUA_DISABLE
2451
2452 /* set function: name of class  meshio::pmd::IO */
2453 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__IO_name
2454 static int tolua_set_meshio__pmd__IO_name(lua_State* tolua_S)
2455 {
2456   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2457 #ifndef TOLUA_RELEASE
2458   tolua_Error tolua_err;
2459   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'name'",NULL);
2460   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::fixed_string<20>",0,&tolua_err)))
2461    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
2462 #endif
2463   self->name = *((meshio::fixed_string<20>*)  tolua_tousertype(tolua_S,2,0))
2464 ;
2465  return 0;
2466 }
2467 #endif //#ifndef TOLUA_DISABLE
2468
2469 /* get function: comment of class  meshio::pmd::IO */
2470 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__IO_comment
2471 static int tolua_get_meshio__pmd__IO_comment(lua_State* tolua_S)
2472 {
2473   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2474 #ifndef TOLUA_RELEASE
2475   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'comment'",NULL);
2476 #endif
2477    tolua_pushusertype(tolua_S,(void*)&self->comment,"meshio::fixed_string<256>");
2478  return 1;
2479 }
2480 #endif //#ifndef TOLUA_DISABLE
2481
2482 /* set function: comment of class  meshio::pmd::IO */
2483 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__IO_comment
2484 static int tolua_set_meshio__pmd__IO_comment(lua_State* tolua_S)
2485 {
2486   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2487 #ifndef TOLUA_RELEASE
2488   tolua_Error tolua_err;
2489   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'comment'",NULL);
2490   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::fixed_string<256>",0,&tolua_err)))
2491    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
2492 #endif
2493   self->comment = *((meshio::fixed_string<256>*)  tolua_tousertype(tolua_S,2,0))
2494 ;
2495  return 0;
2496 }
2497 #endif //#ifndef TOLUA_DISABLE
2498
2499 /* get function: vertices of class  meshio::pmd::IO */
2500 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__IO_vertices
2501 static int tolua_get_meshio__pmd__IO_vertices(lua_State* tolua_S)
2502 {
2503   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2504 #ifndef TOLUA_RELEASE
2505   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'vertices'",NULL);
2506 #endif
2507    tolua_pushusertype(tolua_S,(void*)&self->vertices,"std::vector<meshio::pmd::Vertex>");
2508  return 1;
2509 }
2510 #endif //#ifndef TOLUA_DISABLE
2511
2512 /* set function: vertices of class  meshio::pmd::IO */
2513 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__IO_vertices
2514 static int tolua_set_meshio__pmd__IO_vertices(lua_State* tolua_S)
2515 {
2516   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2517 #ifndef TOLUA_RELEASE
2518   tolua_Error tolua_err;
2519   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'vertices'",NULL);
2520   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"std::vector<meshio::pmd::Vertex>",0,&tolua_err)))
2521    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
2522 #endif
2523   self->vertices = *((std::vector<meshio::pmd::Vertex>*)  tolua_tousertype(tolua_S,2,0))
2524 ;
2525  return 0;
2526 }
2527 #endif //#ifndef TOLUA_DISABLE
2528
2529 /* get function: indices of class  meshio::pmd::IO */
2530 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__IO_indices
2531 static int tolua_get_meshio__pmd__IO_indices(lua_State* tolua_S)
2532 {
2533   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2534 #ifndef TOLUA_RELEASE
2535   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'indices'",NULL);
2536 #endif
2537    tolua_pushusertype(tolua_S,(void*)&self->indices,"std::vector<unsigned short>");
2538  return 1;
2539 }
2540 #endif //#ifndef TOLUA_DISABLE
2541
2542 /* set function: indices of class  meshio::pmd::IO */
2543 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__IO_indices
2544 static int tolua_set_meshio__pmd__IO_indices(lua_State* tolua_S)
2545 {
2546   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2547 #ifndef TOLUA_RELEASE
2548   tolua_Error tolua_err;
2549   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'indices'",NULL);
2550   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"std::vector<unsigned short>",0,&tolua_err)))
2551    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
2552 #endif
2553   self->indices = *((std::vector<unsigned short>*)  tolua_tousertype(tolua_S,2,0))
2554 ;
2555  return 0;
2556 }
2557 #endif //#ifndef TOLUA_DISABLE
2558
2559 /* get function: materials of class  meshio::pmd::IO */
2560 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__IO_materials
2561 static int tolua_get_meshio__pmd__IO_materials(lua_State* tolua_S)
2562 {
2563   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2564 #ifndef TOLUA_RELEASE
2565   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'materials'",NULL);
2566 #endif
2567    tolua_pushusertype(tolua_S,(void*)&self->materials,"std::vector<meshio::pmd::Material>");
2568  return 1;
2569 }
2570 #endif //#ifndef TOLUA_DISABLE
2571
2572 /* set function: materials of class  meshio::pmd::IO */
2573 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__IO_materials
2574 static int tolua_set_meshio__pmd__IO_materials(lua_State* tolua_S)
2575 {
2576   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2577 #ifndef TOLUA_RELEASE
2578   tolua_Error tolua_err;
2579   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'materials'",NULL);
2580   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"std::vector<meshio::pmd::Material>",0,&tolua_err)))
2581    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
2582 #endif
2583   self->materials = *((std::vector<meshio::pmd::Material>*)  tolua_tousertype(tolua_S,2,0))
2584 ;
2585  return 0;
2586 }
2587 #endif //#ifndef TOLUA_DISABLE
2588
2589 /* get function: bones of class  meshio::pmd::IO */
2590 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__IO_bones
2591 static int tolua_get_meshio__pmd__IO_bones(lua_State* tolua_S)
2592 {
2593   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2594 #ifndef TOLUA_RELEASE
2595   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'bones'",NULL);
2596 #endif
2597    tolua_pushusertype(tolua_S,(void*)&self->bones,"std::vector<meshio::pmd::Bone>");
2598  return 1;
2599 }
2600 #endif //#ifndef TOLUA_DISABLE
2601
2602 /* set function: bones of class  meshio::pmd::IO */
2603 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__IO_bones
2604 static int tolua_set_meshio__pmd__IO_bones(lua_State* tolua_S)
2605 {
2606   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2607 #ifndef TOLUA_RELEASE
2608   tolua_Error tolua_err;
2609   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'bones'",NULL);
2610   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"std::vector<meshio::pmd::Bone>",0,&tolua_err)))
2611    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
2612 #endif
2613   self->bones = *((std::vector<meshio::pmd::Bone>*)  tolua_tousertype(tolua_S,2,0))
2614 ;
2615  return 0;
2616 }
2617 #endif //#ifndef TOLUA_DISABLE
2618
2619 /* get function: ik_list of class  meshio::pmd::IO */
2620 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__IO_ik_list
2621 static int tolua_get_meshio__pmd__IO_ik_list(lua_State* tolua_S)
2622 {
2623   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2624 #ifndef TOLUA_RELEASE
2625   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ik_list'",NULL);
2626 #endif
2627    tolua_pushusertype(tolua_S,(void*)&self->ik_list,"std::vector<meshio::pmd::IK>");
2628  return 1;
2629 }
2630 #endif //#ifndef TOLUA_DISABLE
2631
2632 /* set function: ik_list of class  meshio::pmd::IO */
2633 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__IO_ik_list
2634 static int tolua_set_meshio__pmd__IO_ik_list(lua_State* tolua_S)
2635 {
2636   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2637 #ifndef TOLUA_RELEASE
2638   tolua_Error tolua_err;
2639   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ik_list'",NULL);
2640   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"std::vector<meshio::pmd::IK>",0,&tolua_err)))
2641    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
2642 #endif
2643   self->ik_list = *((std::vector<meshio::pmd::IK>*)  tolua_tousertype(tolua_S,2,0))
2644 ;
2645  return 0;
2646 }
2647 #endif //#ifndef TOLUA_DISABLE
2648
2649 /* get function: morph_list of class  meshio::pmd::IO */
2650 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__IO_morph_list
2651 static int tolua_get_meshio__pmd__IO_morph_list(lua_State* tolua_S)
2652 {
2653   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2654 #ifndef TOLUA_RELEASE
2655   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'morph_list'",NULL);
2656 #endif
2657    tolua_pushusertype(tolua_S,(void*)&self->morph_list,"std::vector<meshio::pmd::Morph>");
2658  return 1;
2659 }
2660 #endif //#ifndef TOLUA_DISABLE
2661
2662 /* set function: morph_list of class  meshio::pmd::IO */
2663 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__IO_morph_list
2664 static int tolua_set_meshio__pmd__IO_morph_list(lua_State* tolua_S)
2665 {
2666   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2667 #ifndef TOLUA_RELEASE
2668   tolua_Error tolua_err;
2669   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'morph_list'",NULL);
2670   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"std::vector<meshio::pmd::Morph>",0,&tolua_err)))
2671    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
2672 #endif
2673   self->morph_list = *((std::vector<meshio::pmd::Morph>*)  tolua_tousertype(tolua_S,2,0))
2674 ;
2675  return 0;
2676 }
2677 #endif //#ifndef TOLUA_DISABLE
2678
2679 /* get function: face_list of class  meshio::pmd::IO */
2680 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__IO_face_list
2681 static int tolua_get_meshio__pmd__IO_face_list(lua_State* tolua_S)
2682 {
2683   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2684 #ifndef TOLUA_RELEASE
2685   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'face_list'",NULL);
2686 #endif
2687    tolua_pushusertype(tolua_S,(void*)&self->face_list,"std::vector<unsigned short>");
2688  return 1;
2689 }
2690 #endif //#ifndef TOLUA_DISABLE
2691
2692 /* set function: face_list of class  meshio::pmd::IO */
2693 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__IO_face_list
2694 static int tolua_set_meshio__pmd__IO_face_list(lua_State* tolua_S)
2695 {
2696   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2697 #ifndef TOLUA_RELEASE
2698   tolua_Error tolua_err;
2699   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'face_list'",NULL);
2700   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"std::vector<unsigned short>",0,&tolua_err)))
2701    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
2702 #endif
2703   self->face_list = *((std::vector<unsigned short>*)  tolua_tousertype(tolua_S,2,0))
2704 ;
2705  return 0;
2706 }
2707 #endif //#ifndef TOLUA_DISABLE
2708
2709 /* get function: bone_group_list of class  meshio::pmd::IO */
2710 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__IO_bone_group_list
2711 static int tolua_get_meshio__pmd__IO_bone_group_list(lua_State* tolua_S)
2712 {
2713   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2714 #ifndef TOLUA_RELEASE
2715   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'bone_group_list'",NULL);
2716 #endif
2717    tolua_pushusertype(tolua_S,(void*)&self->bone_group_list,"std::vector<meshio::pmd::BoneGroup>");
2718  return 1;
2719 }
2720 #endif //#ifndef TOLUA_DISABLE
2721
2722 /* set function: bone_group_list of class  meshio::pmd::IO */
2723 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__IO_bone_group_list
2724 static int tolua_set_meshio__pmd__IO_bone_group_list(lua_State* tolua_S)
2725 {
2726   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2727 #ifndef TOLUA_RELEASE
2728   tolua_Error tolua_err;
2729   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'bone_group_list'",NULL);
2730   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"std::vector<meshio::pmd::BoneGroup>",0,&tolua_err)))
2731    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
2732 #endif
2733   self->bone_group_list = *((std::vector<meshio::pmd::BoneGroup>*)  tolua_tousertype(tolua_S,2,0))
2734 ;
2735  return 0;
2736 }
2737 #endif //#ifndef TOLUA_DISABLE
2738
2739 /* get function: bone_display_list of class  meshio::pmd::IO */
2740 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__IO_bone_display_list
2741 static int tolua_get_meshio__pmd__IO_bone_display_list(lua_State* tolua_S)
2742 {
2743   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2744 #ifndef TOLUA_RELEASE
2745   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'bone_display_list'",NULL);
2746 #endif
2747    tolua_pushusertype(tolua_S,(void*)&self->bone_display_list,"std::vector<std::pair<unsigned short,unsigned char> >");
2748  return 1;
2749 }
2750 #endif //#ifndef TOLUA_DISABLE
2751
2752 /* set function: bone_display_list of class  meshio::pmd::IO */
2753 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__IO_bone_display_list
2754 static int tolua_set_meshio__pmd__IO_bone_display_list(lua_State* tolua_S)
2755 {
2756   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2757 #ifndef TOLUA_RELEASE
2758   tolua_Error tolua_err;
2759   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'bone_display_list'",NULL);
2760   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"std::vector<std::pair<unsigned short,unsigned char> >",0,&tolua_err)))
2761    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
2762 #endif
2763   self->bone_display_list = *((std::vector<std::pair<unsigned short,unsigned char> >*)  tolua_tousertype(tolua_S,2,0))
2764 ;
2765  return 0;
2766 }
2767 #endif //#ifndef TOLUA_DISABLE
2768
2769 /* get function: toon_textures of class  meshio::pmd::IO */
2770 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__IO_toon_textures
2771 static int tolua_get_meshio__pmd__IO_toon_textures(lua_State* tolua_S)
2772 {
2773   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2774 #ifndef TOLUA_RELEASE
2775   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'toon_textures'",NULL);
2776 #endif
2777    tolua_pushusertype(tolua_S,(void*)&self->toon_textures,"std::array<meshio::fixed_string<100>,10>");
2778  return 1;
2779 }
2780 #endif //#ifndef TOLUA_DISABLE
2781
2782 /* set function: toon_textures of class  meshio::pmd::IO */
2783 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__IO_toon_textures
2784 static int tolua_set_meshio__pmd__IO_toon_textures(lua_State* tolua_S)
2785 {
2786   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2787 #ifndef TOLUA_RELEASE
2788   tolua_Error tolua_err;
2789   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'toon_textures'",NULL);
2790   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"std::array<meshio::fixed_string<100>,10>",0,&tolua_err)))
2791    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
2792 #endif
2793   self->toon_textures = *((std::array<meshio::fixed_string<100>,10>*)  tolua_tousertype(tolua_S,2,0))
2794 ;
2795  return 0;
2796 }
2797 #endif //#ifndef TOLUA_DISABLE
2798
2799 /* get function: rigidbodies of class  meshio::pmd::IO */
2800 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__IO_rigidbodies
2801 static int tolua_get_meshio__pmd__IO_rigidbodies(lua_State* tolua_S)
2802 {
2803   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2804 #ifndef TOLUA_RELEASE
2805   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'rigidbodies'",NULL);
2806 #endif
2807    tolua_pushusertype(tolua_S,(void*)&self->rigidbodies,"std::vector<meshio::pmd::RigidBody>");
2808  return 1;
2809 }
2810 #endif //#ifndef TOLUA_DISABLE
2811
2812 /* set function: rigidbodies of class  meshio::pmd::IO */
2813 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__IO_rigidbodies
2814 static int tolua_set_meshio__pmd__IO_rigidbodies(lua_State* tolua_S)
2815 {
2816   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2817 #ifndef TOLUA_RELEASE
2818   tolua_Error tolua_err;
2819   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'rigidbodies'",NULL);
2820   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"std::vector<meshio::pmd::RigidBody>",0,&tolua_err)))
2821    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
2822 #endif
2823   self->rigidbodies = *((std::vector<meshio::pmd::RigidBody>*)  tolua_tousertype(tolua_S,2,0))
2824 ;
2825  return 0;
2826 }
2827 #endif //#ifndef TOLUA_DISABLE
2828
2829 /* get function: constraints of class  meshio::pmd::IO */
2830 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__IO_constraints
2831 static int tolua_get_meshio__pmd__IO_constraints(lua_State* tolua_S)
2832 {
2833   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2834 #ifndef TOLUA_RELEASE
2835   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'constraints'",NULL);
2836 #endif
2837    tolua_pushusertype(tolua_S,(void*)&self->constraints,"std::vector<meshio::pmd::Constraint>");
2838  return 1;
2839 }
2840 #endif //#ifndef TOLUA_DISABLE
2841
2842 /* set function: constraints of class  meshio::pmd::IO */
2843 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__IO_constraints
2844 static int tolua_set_meshio__pmd__IO_constraints(lua_State* tolua_S)
2845 {
2846   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2847 #ifndef TOLUA_RELEASE
2848   tolua_Error tolua_err;
2849   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'constraints'",NULL);
2850   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"std::vector<meshio::pmd::Constraint>",0,&tolua_err)))
2851    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
2852 #endif
2853   self->constraints = *((std::vector<meshio::pmd::Constraint>*)  tolua_tousertype(tolua_S,2,0))
2854 ;
2855  return 0;
2856 }
2857 #endif //#ifndef TOLUA_DISABLE
2858
2859 /* get function: english_name of class  meshio::pmd::IO */
2860 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__IO_english_name
2861 static int tolua_get_meshio__pmd__IO_english_name(lua_State* tolua_S)
2862 {
2863   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2864 #ifndef TOLUA_RELEASE
2865   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'english_name'",NULL);
2866 #endif
2867    tolua_pushusertype(tolua_S,(void*)&self->english_name,"meshio::fixed_string<20>");
2868  return 1;
2869 }
2870 #endif //#ifndef TOLUA_DISABLE
2871
2872 /* set function: english_name of class  meshio::pmd::IO */
2873 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__IO_english_name
2874 static int tolua_set_meshio__pmd__IO_english_name(lua_State* tolua_S)
2875 {
2876   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2877 #ifndef TOLUA_RELEASE
2878   tolua_Error tolua_err;
2879   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'english_name'",NULL);
2880   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::fixed_string<20>",0,&tolua_err)))
2881    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
2882 #endif
2883   self->english_name = *((meshio::fixed_string<20>*)  tolua_tousertype(tolua_S,2,0))
2884 ;
2885  return 0;
2886 }
2887 #endif //#ifndef TOLUA_DISABLE
2888
2889 /* get function: english_comment of class  meshio::pmd::IO */
2890 #ifndef TOLUA_DISABLE_tolua_get_meshio__pmd__IO_english_comment
2891 static int tolua_get_meshio__pmd__IO_english_comment(lua_State* tolua_S)
2892 {
2893   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2894 #ifndef TOLUA_RELEASE
2895   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'english_comment'",NULL);
2896 #endif
2897    tolua_pushusertype(tolua_S,(void*)&self->english_comment,"meshio::fixed_string<256>");
2898  return 1;
2899 }
2900 #endif //#ifndef TOLUA_DISABLE
2901
2902 /* set function: english_comment of class  meshio::pmd::IO */
2903 #ifndef TOLUA_DISABLE_tolua_set_meshio__pmd__IO_english_comment
2904 static int tolua_set_meshio__pmd__IO_english_comment(lua_State* tolua_S)
2905 {
2906   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2907 #ifndef TOLUA_RELEASE
2908   tolua_Error tolua_err;
2909   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'english_comment'",NULL);
2910   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::fixed_string<256>",0,&tolua_err)))
2911    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
2912 #endif
2913   self->english_comment = *((meshio::fixed_string<256>*)  tolua_tousertype(tolua_S,2,0))
2914 ;
2915  return 0;
2916 }
2917 #endif //#ifndef TOLUA_DISABLE
2918
2919 /* method: new of class  meshio::pmd::IO */
2920 #ifndef TOLUA_DISABLE_tolua_lmeshio_meshio_pmd_IO_new00
2921 static int tolua_lmeshio_meshio_pmd_IO_new00(lua_State* tolua_S)
2922 {
2923 #ifndef TOLUA_RELEASE
2924  tolua_Error tolua_err;
2925  if (
2926      !tolua_isusertable(tolua_S,1,"meshio::pmd::IO",0,&tolua_err) ||
2927      !tolua_isnoobj(tolua_S,2,&tolua_err)
2928  )
2929   goto tolua_lerror;
2930  else
2931 #endif
2932  {
2933
2934
2935   {
2936    meshio::pmd::IO* tolua_ret = (meshio::pmd::IO*)  Mtolua_new((meshio::pmd::IO)());
2937     tolua_pushusertype(tolua_S,(void*)tolua_ret,"meshio::pmd::IO");
2938   }
2939
2940  }
2941  return 1;
2942 #ifndef TOLUA_RELEASE
2943  tolua_lerror:
2944  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
2945  return 0;
2946 #endif
2947 }
2948 #endif //#ifndef TOLUA_DISABLE
2949
2950 /* method: new_local of class  meshio::pmd::IO */
2951 #ifndef TOLUA_DISABLE_tolua_lmeshio_meshio_pmd_IO_new00_local
2952 static int tolua_lmeshio_meshio_pmd_IO_new00_local(lua_State* tolua_S)
2953 {
2954 #ifndef TOLUA_RELEASE
2955  tolua_Error tolua_err;
2956  if (
2957      !tolua_isusertable(tolua_S,1,"meshio::pmd::IO",0,&tolua_err) ||
2958      !tolua_isnoobj(tolua_S,2,&tolua_err)
2959  )
2960   goto tolua_lerror;
2961  else
2962 #endif
2963  {
2964
2965
2966   {
2967    meshio::pmd::IO* tolua_ret = (meshio::pmd::IO*)  Mtolua_new((meshio::pmd::IO)());
2968     tolua_pushusertype(tolua_S,(void*)tolua_ret,"meshio::pmd::IO");
2969     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
2970   }
2971
2972  }
2973  return 1;
2974 #ifndef TOLUA_RELEASE
2975  tolua_lerror:
2976  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
2977  return 0;
2978 #endif
2979 }
2980 #endif //#ifndef TOLUA_DISABLE
2981
2982 /* method: read of class  meshio::pmd::IO */
2983 #ifndef TOLUA_DISABLE_tolua_lmeshio_meshio_pmd_IO_read00
2984 static int tolua_lmeshio_meshio_pmd_IO_read00(lua_State* tolua_S)
2985 {
2986 #ifndef TOLUA_RELEASE
2987  tolua_Error tolua_err;
2988  if (
2989      !tolua_isusertype(tolua_S,1,"meshio::pmd::IO",0,&tolua_err) ||
2990      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
2991      !tolua_isnoobj(tolua_S,3,&tolua_err)
2992  )
2993   goto tolua_lerror;
2994  else
2995 #endif
2996  {
2997   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
2998   const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
2999 #ifndef TOLUA_RELEASE
3000   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'", NULL);
3001 #endif
3002   {
3003    bool tolua_ret = (bool)  self->read(path);
3004    tolua_pushboolean(tolua_S,(bool)tolua_ret);
3005
3006   }
3007
3008  }
3009  return 1;
3010 #ifndef TOLUA_RELEASE
3011  tolua_lerror:
3012  tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err);
3013  return 0;
3014 #endif
3015 }
3016 #endif //#ifndef TOLUA_DISABLE
3017
3018 /* method: write of class  meshio::pmd::IO */
3019 #ifndef TOLUA_DISABLE_tolua_lmeshio_meshio_pmd_IO_write00
3020 static int tolua_lmeshio_meshio_pmd_IO_write00(lua_State* tolua_S)
3021 {
3022 #ifndef TOLUA_RELEASE
3023  tolua_Error tolua_err;
3024  if (
3025      !tolua_isusertype(tolua_S,1,"meshio::pmd::IO",0,&tolua_err) ||
3026      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
3027      !tolua_isnoobj(tolua_S,3,&tolua_err)
3028  )
3029   goto tolua_lerror;
3030  else
3031 #endif
3032  {
3033   meshio::pmd::IO* self = (meshio::pmd::IO*)  tolua_tousertype(tolua_S,1,0);
3034   const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
3035 #ifndef TOLUA_RELEASE
3036   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'", NULL);
3037 #endif
3038   {
3039    bool tolua_ret = (bool)  self->write(path);
3040    tolua_pushboolean(tolua_S,(bool)tolua_ret);
3041
3042   }
3043
3044  }
3045  return 1;
3046 #ifndef TOLUA_RELEASE
3047  tolua_lerror:
3048  tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err);
3049  return 0;
3050 #endif
3051 }
3052 #endif //#ifndef TOLUA_DISABLE
3053
3054 /* get function: pos of class  meshio::mqo::Scene */
3055 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Scene_pos
3056 static int tolua_get_meshio__mqo__Scene_pos(lua_State* tolua_S)
3057 {
3058   meshio::mqo::Scene* self = (meshio::mqo::Scene*)  tolua_tousertype(tolua_S,1,0);
3059 #ifndef TOLUA_RELEASE
3060   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'pos'",NULL);
3061 #endif
3062    tolua_pushusertype(tolua_S,(void*)&self->pos,"meshio::Vector3");
3063  return 1;
3064 }
3065 #endif //#ifndef TOLUA_DISABLE
3066
3067 /* set function: pos of class  meshio::mqo::Scene */
3068 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Scene_pos
3069 static int tolua_set_meshio__mqo__Scene_pos(lua_State* tolua_S)
3070 {
3071   meshio::mqo::Scene* self = (meshio::mqo::Scene*)  tolua_tousertype(tolua_S,1,0);
3072 #ifndef TOLUA_RELEASE
3073   tolua_Error tolua_err;
3074   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'pos'",NULL);
3075   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::Vector3",0,&tolua_err)))
3076    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3077 #endif
3078   self->pos = *((meshio::Vector3*)  tolua_tousertype(tolua_S,2,0))
3079 ;
3080  return 0;
3081 }
3082 #endif //#ifndef TOLUA_DISABLE
3083
3084 /* get function: lookat of class  meshio::mqo::Scene */
3085 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Scene_lookat
3086 static int tolua_get_meshio__mqo__Scene_lookat(lua_State* tolua_S)
3087 {
3088   meshio::mqo::Scene* self = (meshio::mqo::Scene*)  tolua_tousertype(tolua_S,1,0);
3089 #ifndef TOLUA_RELEASE
3090   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'lookat'",NULL);
3091 #endif
3092    tolua_pushusertype(tolua_S,(void*)&self->lookat,"meshio::Vector3");
3093  return 1;
3094 }
3095 #endif //#ifndef TOLUA_DISABLE
3096
3097 /* set function: lookat of class  meshio::mqo::Scene */
3098 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Scene_lookat
3099 static int tolua_set_meshio__mqo__Scene_lookat(lua_State* tolua_S)
3100 {
3101   meshio::mqo::Scene* self = (meshio::mqo::Scene*)  tolua_tousertype(tolua_S,1,0);
3102 #ifndef TOLUA_RELEASE
3103   tolua_Error tolua_err;
3104   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'lookat'",NULL);
3105   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::Vector3",0,&tolua_err)))
3106    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3107 #endif
3108   self->lookat = *((meshio::Vector3*)  tolua_tousertype(tolua_S,2,0))
3109 ;
3110  return 0;
3111 }
3112 #endif //#ifndef TOLUA_DISABLE
3113
3114 /* get function: head of class  meshio::mqo::Scene */
3115 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Scene_head
3116 static int tolua_get_meshio__mqo__Scene_head(lua_State* tolua_S)
3117 {
3118   meshio::mqo::Scene* self = (meshio::mqo::Scene*)  tolua_tousertype(tolua_S,1,0);
3119 #ifndef TOLUA_RELEASE
3120   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'head'",NULL);
3121 #endif
3122   tolua_pushnumber(tolua_S,(lua_Number)self->head);
3123  return 1;
3124 }
3125 #endif //#ifndef TOLUA_DISABLE
3126
3127 /* set function: head of class  meshio::mqo::Scene */
3128 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Scene_head
3129 static int tolua_set_meshio__mqo__Scene_head(lua_State* tolua_S)
3130 {
3131   meshio::mqo::Scene* self = (meshio::mqo::Scene*)  tolua_tousertype(tolua_S,1,0);
3132 #ifndef TOLUA_RELEASE
3133   tolua_Error tolua_err;
3134   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'head'",NULL);
3135   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3136    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3137 #endif
3138   self->head = ((float)  tolua_tonumber(tolua_S,2,0))
3139 ;
3140  return 0;
3141 }
3142 #endif //#ifndef TOLUA_DISABLE
3143
3144 /* get function: pitch of class  meshio::mqo::Scene */
3145 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Scene_pitch
3146 static int tolua_get_meshio__mqo__Scene_pitch(lua_State* tolua_S)
3147 {
3148   meshio::mqo::Scene* self = (meshio::mqo::Scene*)  tolua_tousertype(tolua_S,1,0);
3149 #ifndef TOLUA_RELEASE
3150   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'pitch'",NULL);
3151 #endif
3152   tolua_pushnumber(tolua_S,(lua_Number)self->pitch);
3153  return 1;
3154 }
3155 #endif //#ifndef TOLUA_DISABLE
3156
3157 /* set function: pitch of class  meshio::mqo::Scene */
3158 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Scene_pitch
3159 static int tolua_set_meshio__mqo__Scene_pitch(lua_State* tolua_S)
3160 {
3161   meshio::mqo::Scene* self = (meshio::mqo::Scene*)  tolua_tousertype(tolua_S,1,0);
3162 #ifndef TOLUA_RELEASE
3163   tolua_Error tolua_err;
3164   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'pitch'",NULL);
3165   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3166    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3167 #endif
3168   self->pitch = ((float)  tolua_tonumber(tolua_S,2,0))
3169 ;
3170  return 0;
3171 }
3172 #endif //#ifndef TOLUA_DISABLE
3173
3174 /* get function: ortho of class  meshio::mqo::Scene */
3175 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Scene_ortho
3176 static int tolua_get_meshio__mqo__Scene_ortho(lua_State* tolua_S)
3177 {
3178   meshio::mqo::Scene* self = (meshio::mqo::Scene*)  tolua_tousertype(tolua_S,1,0);
3179 #ifndef TOLUA_RELEASE
3180   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ortho'",NULL);
3181 #endif
3182   tolua_pushnumber(tolua_S,(lua_Number)self->ortho);
3183  return 1;
3184 }
3185 #endif //#ifndef TOLUA_DISABLE
3186
3187 /* set function: ortho of class  meshio::mqo::Scene */
3188 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Scene_ortho
3189 static int tolua_set_meshio__mqo__Scene_ortho(lua_State* tolua_S)
3190 {
3191   meshio::mqo::Scene* self = (meshio::mqo::Scene*)  tolua_tousertype(tolua_S,1,0);
3192 #ifndef TOLUA_RELEASE
3193   tolua_Error tolua_err;
3194   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ortho'",NULL);
3195   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3196    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3197 #endif
3198   self->ortho = ((int)  tolua_tonumber(tolua_S,2,0))
3199 ;
3200  return 0;
3201 }
3202 #endif //#ifndef TOLUA_DISABLE
3203
3204 /* get function: zoom2 of class  meshio::mqo::Scene */
3205 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Scene_zoom2
3206 static int tolua_get_meshio__mqo__Scene_zoom2(lua_State* tolua_S)
3207 {
3208   meshio::mqo::Scene* self = (meshio::mqo::Scene*)  tolua_tousertype(tolua_S,1,0);
3209 #ifndef TOLUA_RELEASE
3210   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'zoom2'",NULL);
3211 #endif
3212   tolua_pushnumber(tolua_S,(lua_Number)self->zoom2);
3213  return 1;
3214 }
3215 #endif //#ifndef TOLUA_DISABLE
3216
3217 /* set function: zoom2 of class  meshio::mqo::Scene */
3218 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Scene_zoom2
3219 static int tolua_set_meshio__mqo__Scene_zoom2(lua_State* tolua_S)
3220 {
3221   meshio::mqo::Scene* self = (meshio::mqo::Scene*)  tolua_tousertype(tolua_S,1,0);
3222 #ifndef TOLUA_RELEASE
3223   tolua_Error tolua_err;
3224   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'zoom2'",NULL);
3225   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3226    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3227 #endif
3228   self->zoom2 = ((float)  tolua_tonumber(tolua_S,2,0))
3229 ;
3230  return 0;
3231 }
3232 #endif //#ifndef TOLUA_DISABLE
3233
3234 /* get function: ambient of class  meshio::mqo::Scene */
3235 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Scene_ambient
3236 static int tolua_get_meshio__mqo__Scene_ambient(lua_State* tolua_S)
3237 {
3238   meshio::mqo::Scene* self = (meshio::mqo::Scene*)  tolua_tousertype(tolua_S,1,0);
3239 #ifndef TOLUA_RELEASE
3240   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ambient'",NULL);
3241 #endif
3242    tolua_pushusertype(tolua_S,(void*)&self->ambient,"meshio::Vector3");
3243  return 1;
3244 }
3245 #endif //#ifndef TOLUA_DISABLE
3246
3247 /* set function: ambient of class  meshio::mqo::Scene */
3248 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Scene_ambient
3249 static int tolua_set_meshio__mqo__Scene_ambient(lua_State* tolua_S)
3250 {
3251   meshio::mqo::Scene* self = (meshio::mqo::Scene*)  tolua_tousertype(tolua_S,1,0);
3252 #ifndef TOLUA_RELEASE
3253   tolua_Error tolua_err;
3254   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ambient'",NULL);
3255   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::Vector3",0,&tolua_err)))
3256    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3257 #endif
3258   self->ambient = *((meshio::Vector3*)  tolua_tousertype(tolua_S,2,0))
3259 ;
3260  return 0;
3261 }
3262 #endif //#ifndef TOLUA_DISABLE
3263
3264 /* get function: name of class  meshio::mqo::Material */
3265 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Material_name
3266 static int tolua_get_meshio__mqo__Material_name(lua_State* tolua_S)
3267 {
3268   meshio::mqo::Material* self = (meshio::mqo::Material*)  tolua_tousertype(tolua_S,1,0);
3269 #ifndef TOLUA_RELEASE
3270   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'name'",NULL);
3271 #endif
3272   tolua_pushcppstring(tolua_S,(const char*)self->name);
3273  return 1;
3274 }
3275 #endif //#ifndef TOLUA_DISABLE
3276
3277 /* set function: name of class  meshio::mqo::Material */
3278 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Material_name
3279 static int tolua_set_meshio__mqo__Material_name(lua_State* tolua_S)
3280 {
3281   meshio::mqo::Material* self = (meshio::mqo::Material*)  tolua_tousertype(tolua_S,1,0);
3282 #ifndef TOLUA_RELEASE
3283   tolua_Error tolua_err;
3284   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'name'",NULL);
3285   if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
3286    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3287 #endif
3288   self->name = ((std::string)  tolua_tocppstring(tolua_S,2,0))
3289 ;
3290  return 0;
3291 }
3292 #endif //#ifndef TOLUA_DISABLE
3293
3294 /* get function: shader of class  meshio::mqo::Material */
3295 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Material_shader
3296 static int tolua_get_meshio__mqo__Material_shader(lua_State* tolua_S)
3297 {
3298   meshio::mqo::Material* self = (meshio::mqo::Material*)  tolua_tousertype(tolua_S,1,0);
3299 #ifndef TOLUA_RELEASE
3300   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'shader'",NULL);
3301 #endif
3302   tolua_pushnumber(tolua_S,(lua_Number)self->shader);
3303  return 1;
3304 }
3305 #endif //#ifndef TOLUA_DISABLE
3306
3307 /* set function: shader of class  meshio::mqo::Material */
3308 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Material_shader
3309 static int tolua_set_meshio__mqo__Material_shader(lua_State* tolua_S)
3310 {
3311   meshio::mqo::Material* self = (meshio::mqo::Material*)  tolua_tousertype(tolua_S,1,0);
3312 #ifndef TOLUA_RELEASE
3313   tolua_Error tolua_err;
3314   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'shader'",NULL);
3315   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3316    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3317 #endif
3318   self->shader = ((int)  tolua_tonumber(tolua_S,2,0))
3319 ;
3320  return 0;
3321 }
3322 #endif //#ifndef TOLUA_DISABLE
3323
3324 /* get function: color of class  meshio::mqo::Material */
3325 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Material_color
3326 static int tolua_get_meshio__mqo__Material_color(lua_State* tolua_S)
3327 {
3328   meshio::mqo::Material* self = (meshio::mqo::Material*)  tolua_tousertype(tolua_S,1,0);
3329 #ifndef TOLUA_RELEASE
3330   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'color'",NULL);
3331 #endif
3332    tolua_pushusertype(tolua_S,(void*)&self->color,"meshio::fRGBA");
3333  return 1;
3334 }
3335 #endif //#ifndef TOLUA_DISABLE
3336
3337 /* set function: color of class  meshio::mqo::Material */
3338 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Material_color
3339 static int tolua_set_meshio__mqo__Material_color(lua_State* tolua_S)
3340 {
3341   meshio::mqo::Material* self = (meshio::mqo::Material*)  tolua_tousertype(tolua_S,1,0);
3342 #ifndef TOLUA_RELEASE
3343   tolua_Error tolua_err;
3344   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'color'",NULL);
3345   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::fRGBA",0,&tolua_err)))
3346    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3347 #endif
3348   self->color = *((meshio::fRGBA*)  tolua_tousertype(tolua_S,2,0))
3349 ;
3350  return 0;
3351 }
3352 #endif //#ifndef TOLUA_DISABLE
3353
3354 /* get function: diffuse of class  meshio::mqo::Material */
3355 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Material_diffuse
3356 static int tolua_get_meshio__mqo__Material_diffuse(lua_State* tolua_S)
3357 {
3358   meshio::mqo::Material* self = (meshio::mqo::Material*)  tolua_tousertype(tolua_S,1,0);
3359 #ifndef TOLUA_RELEASE
3360   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'diffuse'",NULL);
3361 #endif
3362   tolua_pushnumber(tolua_S,(lua_Number)self->diffuse);
3363  return 1;
3364 }
3365 #endif //#ifndef TOLUA_DISABLE
3366
3367 /* set function: diffuse of class  meshio::mqo::Material */
3368 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Material_diffuse
3369 static int tolua_set_meshio__mqo__Material_diffuse(lua_State* tolua_S)
3370 {
3371   meshio::mqo::Material* self = (meshio::mqo::Material*)  tolua_tousertype(tolua_S,1,0);
3372 #ifndef TOLUA_RELEASE
3373   tolua_Error tolua_err;
3374   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'diffuse'",NULL);
3375   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3376    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3377 #endif
3378   self->diffuse = ((float)  tolua_tonumber(tolua_S,2,0))
3379 ;
3380  return 0;
3381 }
3382 #endif //#ifndef TOLUA_DISABLE
3383
3384 /* get function: ambient of class  meshio::mqo::Material */
3385 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Material_ambient
3386 static int tolua_get_meshio__mqo__Material_ambient(lua_State* tolua_S)
3387 {
3388   meshio::mqo::Material* self = (meshio::mqo::Material*)  tolua_tousertype(tolua_S,1,0);
3389 #ifndef TOLUA_RELEASE
3390   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ambient'",NULL);
3391 #endif
3392   tolua_pushnumber(tolua_S,(lua_Number)self->ambient);
3393  return 1;
3394 }
3395 #endif //#ifndef TOLUA_DISABLE
3396
3397 /* set function: ambient of class  meshio::mqo::Material */
3398 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Material_ambient
3399 static int tolua_set_meshio__mqo__Material_ambient(lua_State* tolua_S)
3400 {
3401   meshio::mqo::Material* self = (meshio::mqo::Material*)  tolua_tousertype(tolua_S,1,0);
3402 #ifndef TOLUA_RELEASE
3403   tolua_Error tolua_err;
3404   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'ambient'",NULL);
3405   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3406    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3407 #endif
3408   self->ambient = ((float)  tolua_tonumber(tolua_S,2,0))
3409 ;
3410  return 0;
3411 }
3412 #endif //#ifndef TOLUA_DISABLE
3413
3414 /* get function: emit of class  meshio::mqo::Material */
3415 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Material_emit
3416 static int tolua_get_meshio__mqo__Material_emit(lua_State* tolua_S)
3417 {
3418   meshio::mqo::Material* self = (meshio::mqo::Material*)  tolua_tousertype(tolua_S,1,0);
3419 #ifndef TOLUA_RELEASE
3420   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'emit'",NULL);
3421 #endif
3422   tolua_pushnumber(tolua_S,(lua_Number)self->emit);
3423  return 1;
3424 }
3425 #endif //#ifndef TOLUA_DISABLE
3426
3427 /* set function: emit of class  meshio::mqo::Material */
3428 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Material_emit
3429 static int tolua_set_meshio__mqo__Material_emit(lua_State* tolua_S)
3430 {
3431   meshio::mqo::Material* self = (meshio::mqo::Material*)  tolua_tousertype(tolua_S,1,0);
3432 #ifndef TOLUA_RELEASE
3433   tolua_Error tolua_err;
3434   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'emit'",NULL);
3435   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3436    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3437 #endif
3438   self->emit = ((float)  tolua_tonumber(tolua_S,2,0))
3439 ;
3440  return 0;
3441 }
3442 #endif //#ifndef TOLUA_DISABLE
3443
3444 /* get function: specular of class  meshio::mqo::Material */
3445 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Material_specular
3446 static int tolua_get_meshio__mqo__Material_specular(lua_State* tolua_S)
3447 {
3448   meshio::mqo::Material* self = (meshio::mqo::Material*)  tolua_tousertype(tolua_S,1,0);
3449 #ifndef TOLUA_RELEASE
3450   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'specular'",NULL);
3451 #endif
3452   tolua_pushnumber(tolua_S,(lua_Number)self->specular);
3453  return 1;
3454 }
3455 #endif //#ifndef TOLUA_DISABLE
3456
3457 /* set function: specular of class  meshio::mqo::Material */
3458 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Material_specular
3459 static int tolua_set_meshio__mqo__Material_specular(lua_State* tolua_S)
3460 {
3461   meshio::mqo::Material* self = (meshio::mqo::Material*)  tolua_tousertype(tolua_S,1,0);
3462 #ifndef TOLUA_RELEASE
3463   tolua_Error tolua_err;
3464   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'specular'",NULL);
3465   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3466    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3467 #endif
3468   self->specular = ((float)  tolua_tonumber(tolua_S,2,0))
3469 ;
3470  return 0;
3471 }
3472 #endif //#ifndef TOLUA_DISABLE
3473
3474 /* get function: power of class  meshio::mqo::Material */
3475 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Material_power
3476 static int tolua_get_meshio__mqo__Material_power(lua_State* tolua_S)
3477 {
3478   meshio::mqo::Material* self = (meshio::mqo::Material*)  tolua_tousertype(tolua_S,1,0);
3479 #ifndef TOLUA_RELEASE
3480   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'power'",NULL);
3481 #endif
3482   tolua_pushnumber(tolua_S,(lua_Number)self->power);
3483  return 1;
3484 }
3485 #endif //#ifndef TOLUA_DISABLE
3486
3487 /* set function: power of class  meshio::mqo::Material */
3488 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Material_power
3489 static int tolua_set_meshio__mqo__Material_power(lua_State* tolua_S)
3490 {
3491   meshio::mqo::Material* self = (meshio::mqo::Material*)  tolua_tousertype(tolua_S,1,0);
3492 #ifndef TOLUA_RELEASE
3493   tolua_Error tolua_err;
3494   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'power'",NULL);
3495   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3496    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3497 #endif
3498   self->power = ((float)  tolua_tonumber(tolua_S,2,0))
3499 ;
3500  return 0;
3501 }
3502 #endif //#ifndef TOLUA_DISABLE
3503
3504 /* get function: texture of class  meshio::mqo::Material */
3505 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Material_texture
3506 static int tolua_get_meshio__mqo__Material_texture(lua_State* tolua_S)
3507 {
3508   meshio::mqo::Material* self = (meshio::mqo::Material*)  tolua_tousertype(tolua_S,1,0);
3509 #ifndef TOLUA_RELEASE
3510   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'texture'",NULL);
3511 #endif
3512   tolua_pushcppstring(tolua_S,(const char*)self->texture);
3513  return 1;
3514 }
3515 #endif //#ifndef TOLUA_DISABLE
3516
3517 /* set function: texture of class  meshio::mqo::Material */
3518 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Material_texture
3519 static int tolua_set_meshio__mqo__Material_texture(lua_State* tolua_S)
3520 {
3521   meshio::mqo::Material* self = (meshio::mqo::Material*)  tolua_tousertype(tolua_S,1,0);
3522 #ifndef TOLUA_RELEASE
3523   tolua_Error tolua_err;
3524   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'texture'",NULL);
3525   if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
3526    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3527 #endif
3528   self->texture = ((std::string)  tolua_tocppstring(tolua_S,2,0))
3529 ;
3530  return 0;
3531 }
3532 #endif //#ifndef TOLUA_DISABLE
3533
3534 /* get function: alphamap of class  meshio::mqo::Material */
3535 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Material_alphamap
3536 static int tolua_get_meshio__mqo__Material_alphamap(lua_State* tolua_S)
3537 {
3538   meshio::mqo::Material* self = (meshio::mqo::Material*)  tolua_tousertype(tolua_S,1,0);
3539 #ifndef TOLUA_RELEASE
3540   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'alphamap'",NULL);
3541 #endif
3542   tolua_pushcppstring(tolua_S,(const char*)self->alphamap);
3543  return 1;
3544 }
3545 #endif //#ifndef TOLUA_DISABLE
3546
3547 /* set function: alphamap of class  meshio::mqo::Material */
3548 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Material_alphamap
3549 static int tolua_set_meshio__mqo__Material_alphamap(lua_State* tolua_S)
3550 {
3551   meshio::mqo::Material* self = (meshio::mqo::Material*)  tolua_tousertype(tolua_S,1,0);
3552 #ifndef TOLUA_RELEASE
3553   tolua_Error tolua_err;
3554   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'alphamap'",NULL);
3555   if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
3556    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3557 #endif
3558   self->alphamap = ((std::string)  tolua_tocppstring(tolua_S,2,0))
3559 ;
3560  return 0;
3561 }
3562 #endif //#ifndef TOLUA_DISABLE
3563
3564 /* get function: bumpmap of class  meshio::mqo::Material */
3565 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Material_bumpmap
3566 static int tolua_get_meshio__mqo__Material_bumpmap(lua_State* tolua_S)
3567 {
3568   meshio::mqo::Material* self = (meshio::mqo::Material*)  tolua_tousertype(tolua_S,1,0);
3569 #ifndef TOLUA_RELEASE
3570   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'bumpmap'",NULL);
3571 #endif
3572   tolua_pushcppstring(tolua_S,(const char*)self->bumpmap);
3573  return 1;
3574 }
3575 #endif //#ifndef TOLUA_DISABLE
3576
3577 /* set function: bumpmap of class  meshio::mqo::Material */
3578 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Material_bumpmap
3579 static int tolua_set_meshio__mqo__Material_bumpmap(lua_State* tolua_S)
3580 {
3581   meshio::mqo::Material* self = (meshio::mqo::Material*)  tolua_tousertype(tolua_S,1,0);
3582 #ifndef TOLUA_RELEASE
3583   tolua_Error tolua_err;
3584   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'bumpmap'",NULL);
3585   if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
3586    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3587 #endif
3588   self->bumpmap = ((std::string)  tolua_tocppstring(tolua_S,2,0))
3589 ;
3590  return 0;
3591 }
3592 #endif //#ifndef TOLUA_DISABLE
3593
3594 /* get function: vcol of class  meshio::mqo::Material */
3595 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Material_vcol
3596 static int tolua_get_meshio__mqo__Material_vcol(lua_State* tolua_S)
3597 {
3598   meshio::mqo::Material* self = (meshio::mqo::Material*)  tolua_tousertype(tolua_S,1,0);
3599 #ifndef TOLUA_RELEASE
3600   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'vcol'",NULL);
3601 #endif
3602   tolua_pushnumber(tolua_S,(lua_Number)self->vcol);
3603  return 1;
3604 }
3605 #endif //#ifndef TOLUA_DISABLE
3606
3607 /* set function: vcol of class  meshio::mqo::Material */
3608 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Material_vcol
3609 static int tolua_set_meshio__mqo__Material_vcol(lua_State* tolua_S)
3610 {
3611   meshio::mqo::Material* self = (meshio::mqo::Material*)  tolua_tousertype(tolua_S,1,0);
3612 #ifndef TOLUA_RELEASE
3613   tolua_Error tolua_err;
3614   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'vcol'",NULL);
3615   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3616    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3617 #endif
3618   self->vcol = ((int)  tolua_tonumber(tolua_S,2,0))
3619 ;
3620  return 0;
3621 }
3622 #endif //#ifndef TOLUA_DISABLE
3623
3624 /* get function: index_count of class  meshio::mqo::Face */
3625 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Face_unsigned_index_count
3626 static int tolua_get_meshio__mqo__Face_unsigned_index_count(lua_State* tolua_S)
3627 {
3628   meshio::mqo::Face* self = (meshio::mqo::Face*)  tolua_tousertype(tolua_S,1,0);
3629 #ifndef TOLUA_RELEASE
3630   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'index_count'",NULL);
3631 #endif
3632   tolua_pushnumber(tolua_S,(lua_Number)self->index_count);
3633  return 1;
3634 }
3635 #endif //#ifndef TOLUA_DISABLE
3636
3637 /* set function: index_count of class  meshio::mqo::Face */
3638 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Face_unsigned_index_count
3639 static int tolua_set_meshio__mqo__Face_unsigned_index_count(lua_State* tolua_S)
3640 {
3641   meshio::mqo::Face* self = (meshio::mqo::Face*)  tolua_tousertype(tolua_S,1,0);
3642 #ifndef TOLUA_RELEASE
3643   tolua_Error tolua_err;
3644   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'index_count'",NULL);
3645   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3646    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3647 #endif
3648   self->index_count = ((unsigned int)  tolua_tonumber(tolua_S,2,0))
3649 ;
3650  return 0;
3651 }
3652 #endif //#ifndef TOLUA_DISABLE
3653 /* get function: indices of class  meshio::mqo::Face */
3654 #ifndef TOLUA_DISABLE_tolua_get_lmeshio_meshio_mqo_Face_indices
3655 static int tolua_get_lmeshio_meshio_mqo_Face_indices(lua_State* tolua_S)
3656 {
3657  int tolua_index;
3658   meshio::mqo::Face* self;
3659  lua_pushstring(tolua_S,".self");
3660  lua_rawget(tolua_S,1);
3661  self = (meshio::mqo::Face*)  lua_touserdata(tolua_S,-1);
3662 #ifndef TOLUA_RELEASE
3663  {
3664   tolua_Error tolua_err;
3665   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3666    tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
3667  }
3668 #endif
3669  tolua_index = (int)tolua_tonumber(tolua_S,2,0);
3670 #ifndef TOLUA_RELEASE
3671  if (tolua_index<0 || tolua_index>=4)
3672   tolua_error(tolua_S,"array indexing out of range.",NULL);
3673 #endif
3674  tolua_pushnumber(tolua_S,(lua_Number)self->indices[tolua_index]);
3675  return 1;
3676 }
3677 #endif //#ifndef TOLUA_DISABLE
3678
3679
3680 /* set function: indices of class  meshio::mqo::Face */
3681 #ifndef TOLUA_DISABLE_tolua_set_lmeshio_meshio_mqo_Face_indices
3682 static int tolua_set_lmeshio_meshio_mqo_Face_indices(lua_State* tolua_S)
3683 {
3684  int tolua_index;
3685   meshio::mqo::Face* self;
3686  lua_pushstring(tolua_S,".self");
3687  lua_rawget(tolua_S,1);
3688  self = (meshio::mqo::Face*)  lua_touserdata(tolua_S,-1);
3689 #ifndef TOLUA_RELEASE
3690  {
3691   tolua_Error tolua_err;
3692   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3693    tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
3694  }
3695 #endif
3696  tolua_index = (int)tolua_tonumber(tolua_S,2,0);
3697 #ifndef TOLUA_RELEASE
3698  if (tolua_index<0 || tolua_index>=4)
3699   tolua_error(tolua_S,"array indexing out of range.",NULL);
3700 #endif
3701   self->indices[tolua_index] = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
3702  return 0;
3703 }
3704 #endif //#ifndef TOLUA_DISABLE
3705
3706
3707 /* get function: material_index of class  meshio::mqo::Face */
3708 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Face_unsigned_material_index
3709 static int tolua_get_meshio__mqo__Face_unsigned_material_index(lua_State* tolua_S)
3710 {
3711   meshio::mqo::Face* self = (meshio::mqo::Face*)  tolua_tousertype(tolua_S,1,0);
3712 #ifndef TOLUA_RELEASE
3713   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'material_index'",NULL);
3714 #endif
3715   tolua_pushnumber(tolua_S,(lua_Number)self->material_index);
3716  return 1;
3717 }
3718 #endif //#ifndef TOLUA_DISABLE
3719
3720 /* set function: material_index of class  meshio::mqo::Face */
3721 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Face_unsigned_material_index
3722 static int tolua_set_meshio__mqo__Face_unsigned_material_index(lua_State* tolua_S)
3723 {
3724   meshio::mqo::Face* self = (meshio::mqo::Face*)  tolua_tousertype(tolua_S,1,0);
3725 #ifndef TOLUA_RELEASE
3726   tolua_Error tolua_err;
3727   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'material_index'",NULL);
3728   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3729    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3730 #endif
3731   self->material_index = ((unsigned int)  tolua_tonumber(tolua_S,2,0))
3732 ;
3733  return 0;
3734 }
3735 #endif //#ifndef TOLUA_DISABLE
3736 /* get function: uv of class  meshio::mqo::Face */
3737 #ifndef TOLUA_DISABLE_tolua_get_lmeshio_meshio_mqo_Face_uv
3738 static int tolua_get_lmeshio_meshio_mqo_Face_uv(lua_State* tolua_S)
3739 {
3740  int tolua_index;
3741   meshio::mqo::Face* self;
3742  lua_pushstring(tolua_S,".self");
3743  lua_rawget(tolua_S,1);
3744  self = (meshio::mqo::Face*)  lua_touserdata(tolua_S,-1);
3745 #ifndef TOLUA_RELEASE
3746  {
3747   tolua_Error tolua_err;
3748   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3749    tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
3750  }
3751 #endif
3752  tolua_index = (int)tolua_tonumber(tolua_S,2,0);
3753 #ifndef TOLUA_RELEASE
3754  if (tolua_index<0 || tolua_index>=4)
3755   tolua_error(tolua_S,"array indexing out of range.",NULL);
3756 #endif
3757   tolua_pushusertype(tolua_S,(void*)&self->uv[tolua_index],"meshio::Vector2");
3758  return 1;
3759 }
3760 #endif //#ifndef TOLUA_DISABLE
3761
3762
3763 /* set function: uv of class  meshio::mqo::Face */
3764 #ifndef TOLUA_DISABLE_tolua_set_lmeshio_meshio_mqo_Face_uv
3765 static int tolua_set_lmeshio_meshio_mqo_Face_uv(lua_State* tolua_S)
3766 {
3767  int tolua_index;
3768   meshio::mqo::Face* self;
3769  lua_pushstring(tolua_S,".self");
3770  lua_rawget(tolua_S,1);
3771  self = (meshio::mqo::Face*)  lua_touserdata(tolua_S,-1);
3772 #ifndef TOLUA_RELEASE
3773  {
3774   tolua_Error tolua_err;
3775   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3776    tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
3777  }
3778 #endif
3779  tolua_index = (int)tolua_tonumber(tolua_S,2,0);
3780 #ifndef TOLUA_RELEASE
3781  if (tolua_index<0 || tolua_index>=4)
3782   tolua_error(tolua_S,"array indexing out of range.",NULL);
3783 #endif
3784   self->uv[tolua_index] = *((meshio::Vector2*)  tolua_tousertype(tolua_S,3,0));
3785  return 0;
3786 }
3787 #endif //#ifndef TOLUA_DISABLE
3788
3789 /* get function: color of class  meshio::mqo::Face */
3790 #ifndef TOLUA_DISABLE_tolua_get_lmeshio_meshio_mqo_Face_color
3791 static int tolua_get_lmeshio_meshio_mqo_Face_color(lua_State* tolua_S)
3792 {
3793  int tolua_index;
3794   meshio::mqo::Face* self;
3795  lua_pushstring(tolua_S,".self");
3796  lua_rawget(tolua_S,1);
3797  self = (meshio::mqo::Face*)  lua_touserdata(tolua_S,-1);
3798 #ifndef TOLUA_RELEASE
3799  {
3800   tolua_Error tolua_err;
3801   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3802    tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
3803  }
3804 #endif
3805  tolua_index = (int)tolua_tonumber(tolua_S,2,0);
3806 #ifndef TOLUA_RELEASE
3807  if (tolua_index<0 || tolua_index>=4)
3808   tolua_error(tolua_S,"array indexing out of range.",NULL);
3809 #endif
3810   tolua_pushusertype(tolua_S,(void*)&self->color[tolua_index],"meshio::fRGBA");
3811  return 1;
3812 }
3813 #endif //#ifndef TOLUA_DISABLE
3814
3815
3816 /* set function: color of class  meshio::mqo::Face */
3817 #ifndef TOLUA_DISABLE_tolua_set_lmeshio_meshio_mqo_Face_color
3818 static int tolua_set_lmeshio_meshio_mqo_Face_color(lua_State* tolua_S)
3819 {
3820  int tolua_index;
3821   meshio::mqo::Face* self;
3822  lua_pushstring(tolua_S,".self");
3823  lua_rawget(tolua_S,1);
3824  self = (meshio::mqo::Face*)  lua_touserdata(tolua_S,-1);
3825 #ifndef TOLUA_RELEASE
3826  {
3827   tolua_Error tolua_err;
3828   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3829    tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
3830  }
3831 #endif
3832  tolua_index = (int)tolua_tonumber(tolua_S,2,0);
3833 #ifndef TOLUA_RELEASE
3834  if (tolua_index<0 || tolua_index>=4)
3835   tolua_error(tolua_S,"array indexing out of range.",NULL);
3836 #endif
3837   self->color[tolua_index] = *((meshio::fRGBA*)  tolua_tousertype(tolua_S,3,0));
3838  return 0;
3839 }
3840 #endif //#ifndef TOLUA_DISABLE
3841
3842
3843 /* get function: name of class  meshio::mqo::Object */
3844 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Object_name
3845 static int tolua_get_meshio__mqo__Object_name(lua_State* tolua_S)
3846 {
3847   meshio::mqo::Object* self = (meshio::mqo::Object*)  tolua_tousertype(tolua_S,1,0);
3848 #ifndef TOLUA_RELEASE
3849   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'name'",NULL);
3850 #endif
3851   tolua_pushcppstring(tolua_S,(const char*)self->name);
3852  return 1;
3853 }
3854 #endif //#ifndef TOLUA_DISABLE
3855
3856 /* set function: name of class  meshio::mqo::Object */
3857 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Object_name
3858 static int tolua_set_meshio__mqo__Object_name(lua_State* tolua_S)
3859 {
3860   meshio::mqo::Object* self = (meshio::mqo::Object*)  tolua_tousertype(tolua_S,1,0);
3861 #ifndef TOLUA_RELEASE
3862   tolua_Error tolua_err;
3863   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'name'",NULL);
3864   if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
3865    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3866 #endif
3867   self->name = ((std::string)  tolua_tocppstring(tolua_S,2,0))
3868 ;
3869  return 0;
3870 }
3871 #endif //#ifndef TOLUA_DISABLE
3872
3873 /* get function: depth of class  meshio::mqo::Object */
3874 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Object_depth
3875 static int tolua_get_meshio__mqo__Object_depth(lua_State* tolua_S)
3876 {
3877   meshio::mqo::Object* self = (meshio::mqo::Object*)  tolua_tousertype(tolua_S,1,0);
3878 #ifndef TOLUA_RELEASE
3879   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'depth'",NULL);
3880 #endif
3881   tolua_pushnumber(tolua_S,(lua_Number)self->depth);
3882  return 1;
3883 }
3884 #endif //#ifndef TOLUA_DISABLE
3885
3886 /* set function: depth of class  meshio::mqo::Object */
3887 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Object_depth
3888 static int tolua_set_meshio__mqo__Object_depth(lua_State* tolua_S)
3889 {
3890   meshio::mqo::Object* self = (meshio::mqo::Object*)  tolua_tousertype(tolua_S,1,0);
3891 #ifndef TOLUA_RELEASE
3892   tolua_Error tolua_err;
3893   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'depth'",NULL);
3894   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3895    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3896 #endif
3897   self->depth = ((int)  tolua_tonumber(tolua_S,2,0))
3898 ;
3899  return 0;
3900 }
3901 #endif //#ifndef TOLUA_DISABLE
3902
3903 /* get function: folding of class  meshio::mqo::Object */
3904 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Object_folding
3905 static int tolua_get_meshio__mqo__Object_folding(lua_State* tolua_S)
3906 {
3907   meshio::mqo::Object* self = (meshio::mqo::Object*)  tolua_tousertype(tolua_S,1,0);
3908 #ifndef TOLUA_RELEASE
3909   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'folding'",NULL);
3910 #endif
3911   tolua_pushnumber(tolua_S,(lua_Number)self->folding);
3912  return 1;
3913 }
3914 #endif //#ifndef TOLUA_DISABLE
3915
3916 /* set function: folding of class  meshio::mqo::Object */
3917 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Object_folding
3918 static int tolua_set_meshio__mqo__Object_folding(lua_State* tolua_S)
3919 {
3920   meshio::mqo::Object* self = (meshio::mqo::Object*)  tolua_tousertype(tolua_S,1,0);
3921 #ifndef TOLUA_RELEASE
3922   tolua_Error tolua_err;
3923   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'folding'",NULL);
3924   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
3925    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3926 #endif
3927   self->folding = ((int)  tolua_tonumber(tolua_S,2,0))
3928 ;
3929  return 0;
3930 }
3931 #endif //#ifndef TOLUA_DISABLE
3932
3933 /* get function: scale of class  meshio::mqo::Object */
3934 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Object_scale
3935 static int tolua_get_meshio__mqo__Object_scale(lua_State* tolua_S)
3936 {
3937   meshio::mqo::Object* self = (meshio::mqo::Object*)  tolua_tousertype(tolua_S,1,0);
3938 #ifndef TOLUA_RELEASE
3939   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'scale'",NULL);
3940 #endif
3941    tolua_pushusertype(tolua_S,(void*)&self->scale,"meshio::Vector3");
3942  return 1;
3943 }
3944 #endif //#ifndef TOLUA_DISABLE
3945
3946 /* set function: scale of class  meshio::mqo::Object */
3947 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Object_scale
3948 static int tolua_set_meshio__mqo__Object_scale(lua_State* tolua_S)
3949 {
3950   meshio::mqo::Object* self = (meshio::mqo::Object*)  tolua_tousertype(tolua_S,1,0);
3951 #ifndef TOLUA_RELEASE
3952   tolua_Error tolua_err;
3953   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'scale'",NULL);
3954   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::Vector3",0,&tolua_err)))
3955    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3956 #endif
3957   self->scale = *((meshio::Vector3*)  tolua_tousertype(tolua_S,2,0))
3958 ;
3959  return 0;
3960 }
3961 #endif //#ifndef TOLUA_DISABLE
3962
3963 /* get function: rotation of class  meshio::mqo::Object */
3964 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Object_rotation
3965 static int tolua_get_meshio__mqo__Object_rotation(lua_State* tolua_S)
3966 {
3967   meshio::mqo::Object* self = (meshio::mqo::Object*)  tolua_tousertype(tolua_S,1,0);
3968 #ifndef TOLUA_RELEASE
3969   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'rotation'",NULL);
3970 #endif
3971    tolua_pushusertype(tolua_S,(void*)&self->rotation,"meshio::Vector3");
3972  return 1;
3973 }
3974 #endif //#ifndef TOLUA_DISABLE
3975
3976 /* set function: rotation of class  meshio::mqo::Object */
3977 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Object_rotation
3978 static int tolua_set_meshio__mqo__Object_rotation(lua_State* tolua_S)
3979 {
3980   meshio::mqo::Object* self = (meshio::mqo::Object*)  tolua_tousertype(tolua_S,1,0);
3981 #ifndef TOLUA_RELEASE
3982   tolua_Error tolua_err;
3983   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'rotation'",NULL);
3984   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::Vector3",0,&tolua_err)))
3985    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
3986 #endif
3987   self->rotation = *((meshio::Vector3*)  tolua_tousertype(tolua_S,2,0))
3988 ;
3989  return 0;
3990 }
3991 #endif //#ifndef TOLUA_DISABLE
3992
3993 /* get function: translation of class  meshio::mqo::Object */
3994 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Object_translation
3995 static int tolua_get_meshio__mqo__Object_translation(lua_State* tolua_S)
3996 {
3997   meshio::mqo::Object* self = (meshio::mqo::Object*)  tolua_tousertype(tolua_S,1,0);
3998 #ifndef TOLUA_RELEASE
3999   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'translation'",NULL);
4000 #endif
4001    tolua_pushusertype(tolua_S,(void*)&self->translation,"meshio::Vector3");
4002  return 1;
4003 }
4004 #endif //#ifndef TOLUA_DISABLE
4005
4006 /* set function: translation of class  meshio::mqo::Object */
4007 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Object_translation
4008 static int tolua_set_meshio__mqo__Object_translation(lua_State* tolua_S)
4009 {
4010   meshio::mqo::Object* self = (meshio::mqo::Object*)  tolua_tousertype(tolua_S,1,0);
4011 #ifndef TOLUA_RELEASE
4012   tolua_Error tolua_err;
4013   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'translation'",NULL);
4014   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::Vector3",0,&tolua_err)))
4015    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4016 #endif
4017   self->translation = *((meshio::Vector3*)  tolua_tousertype(tolua_S,2,0))
4018 ;
4019  return 0;
4020 }
4021 #endif //#ifndef TOLUA_DISABLE
4022
4023 /* get function: visible of class  meshio::mqo::Object */
4024 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Object_visible
4025 static int tolua_get_meshio__mqo__Object_visible(lua_State* tolua_S)
4026 {
4027   meshio::mqo::Object* self = (meshio::mqo::Object*)  tolua_tousertype(tolua_S,1,0);
4028 #ifndef TOLUA_RELEASE
4029   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'visible'",NULL);
4030 #endif
4031   tolua_pushnumber(tolua_S,(lua_Number)self->visible);
4032  return 1;
4033 }
4034 #endif //#ifndef TOLUA_DISABLE
4035
4036 /* set function: visible of class  meshio::mqo::Object */
4037 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Object_visible
4038 static int tolua_set_meshio__mqo__Object_visible(lua_State* tolua_S)
4039 {
4040   meshio::mqo::Object* self = (meshio::mqo::Object*)  tolua_tousertype(tolua_S,1,0);
4041 #ifndef TOLUA_RELEASE
4042   tolua_Error tolua_err;
4043   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'visible'",NULL);
4044   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
4045    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4046 #endif
4047   self->visible = ((int)  tolua_tonumber(tolua_S,2,0))
4048 ;
4049  return 0;
4050 }
4051 #endif //#ifndef TOLUA_DISABLE
4052
4053 /* get function: locking of class  meshio::mqo::Object */
4054 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Object_locking
4055 static int tolua_get_meshio__mqo__Object_locking(lua_State* tolua_S)
4056 {
4057   meshio::mqo::Object* self = (meshio::mqo::Object*)  tolua_tousertype(tolua_S,1,0);
4058 #ifndef TOLUA_RELEASE
4059   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'locking'",NULL);
4060 #endif
4061   tolua_pushnumber(tolua_S,(lua_Number)self->locking);
4062  return 1;
4063 }
4064 #endif //#ifndef TOLUA_DISABLE
4065
4066 /* set function: locking of class  meshio::mqo::Object */
4067 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Object_locking
4068 static int tolua_set_meshio__mqo__Object_locking(lua_State* tolua_S)
4069 {
4070   meshio::mqo::Object* self = (meshio::mqo::Object*)  tolua_tousertype(tolua_S,1,0);
4071 #ifndef TOLUA_RELEASE
4072   tolua_Error tolua_err;
4073   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'locking'",NULL);
4074   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
4075    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4076 #endif
4077   self->locking = ((int)  tolua_tonumber(tolua_S,2,0))
4078 ;
4079  return 0;
4080 }
4081 #endif //#ifndef TOLUA_DISABLE
4082
4083 /* get function: shading of class  meshio::mqo::Object */
4084 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Object_shading
4085 static int tolua_get_meshio__mqo__Object_shading(lua_State* tolua_S)
4086 {
4087   meshio::mqo::Object* self = (meshio::mqo::Object*)  tolua_tousertype(tolua_S,1,0);
4088 #ifndef TOLUA_RELEASE
4089   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'shading'",NULL);
4090 #endif
4091   tolua_pushnumber(tolua_S,(lua_Number)self->shading);
4092  return 1;
4093 }
4094 #endif //#ifndef TOLUA_DISABLE
4095
4096 /* set function: shading of class  meshio::mqo::Object */
4097 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Object_shading
4098 static int tolua_set_meshio__mqo__Object_shading(lua_State* tolua_S)
4099 {
4100   meshio::mqo::Object* self = (meshio::mqo::Object*)  tolua_tousertype(tolua_S,1,0);
4101 #ifndef TOLUA_RELEASE
4102   tolua_Error tolua_err;
4103   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'shading'",NULL);
4104   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
4105    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4106 #endif
4107   self->shading = ((int)  tolua_tonumber(tolua_S,2,0))
4108 ;
4109  return 0;
4110 }
4111 #endif //#ifndef TOLUA_DISABLE
4112
4113 /* get function: smoothing of class  meshio::mqo::Object */
4114 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Object_smoothing
4115 static int tolua_get_meshio__mqo__Object_smoothing(lua_State* tolua_S)
4116 {
4117   meshio::mqo::Object* self = (meshio::mqo::Object*)  tolua_tousertype(tolua_S,1,0);
4118 #ifndef TOLUA_RELEASE
4119   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'smoothing'",NULL);
4120 #endif
4121   tolua_pushnumber(tolua_S,(lua_Number)self->smoothing);
4122  return 1;
4123 }
4124 #endif //#ifndef TOLUA_DISABLE
4125
4126 /* set function: smoothing of class  meshio::mqo::Object */
4127 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Object_smoothing
4128 static int tolua_set_meshio__mqo__Object_smoothing(lua_State* tolua_S)
4129 {
4130   meshio::mqo::Object* self = (meshio::mqo::Object*)  tolua_tousertype(tolua_S,1,0);
4131 #ifndef TOLUA_RELEASE
4132   tolua_Error tolua_err;
4133   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'smoothing'",NULL);
4134   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
4135    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4136 #endif
4137   self->smoothing = ((float)  tolua_tonumber(tolua_S,2,0))
4138 ;
4139  return 0;
4140 }
4141 #endif //#ifndef TOLUA_DISABLE
4142
4143 /* get function: color of class  meshio::mqo::Object */
4144 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Object_color
4145 static int tolua_get_meshio__mqo__Object_color(lua_State* tolua_S)
4146 {
4147   meshio::mqo::Object* self = (meshio::mqo::Object*)  tolua_tousertype(tolua_S,1,0);
4148 #ifndef TOLUA_RELEASE
4149   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'color'",NULL);
4150 #endif
4151    tolua_pushusertype(tolua_S,(void*)&self->color,"meshio::Vector3");
4152  return 1;
4153 }
4154 #endif //#ifndef TOLUA_DISABLE
4155
4156 /* set function: color of class  meshio::mqo::Object */
4157 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Object_color
4158 static int tolua_set_meshio__mqo__Object_color(lua_State* tolua_S)
4159 {
4160   meshio::mqo::Object* self = (meshio::mqo::Object*)  tolua_tousertype(tolua_S,1,0);
4161 #ifndef TOLUA_RELEASE
4162   tolua_Error tolua_err;
4163   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'color'",NULL);
4164   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::Vector3",0,&tolua_err)))
4165    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4166 #endif
4167   self->color = *((meshio::Vector3*)  tolua_tousertype(tolua_S,2,0))
4168 ;
4169  return 0;
4170 }
4171 #endif //#ifndef TOLUA_DISABLE
4172
4173 /* get function: color_type of class  meshio::mqo::Object */
4174 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Object_color_type
4175 static int tolua_get_meshio__mqo__Object_color_type(lua_State* tolua_S)
4176 {
4177   meshio::mqo::Object* self = (meshio::mqo::Object*)  tolua_tousertype(tolua_S,1,0);
4178 #ifndef TOLUA_RELEASE
4179   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'color_type'",NULL);
4180 #endif
4181   tolua_pushnumber(tolua_S,(lua_Number)self->color_type);
4182  return 1;
4183 }
4184 #endif //#ifndef TOLUA_DISABLE
4185
4186 /* set function: color_type of class  meshio::mqo::Object */
4187 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Object_color_type
4188 static int tolua_set_meshio__mqo__Object_color_type(lua_State* tolua_S)
4189 {
4190   meshio::mqo::Object* self = (meshio::mqo::Object*)  tolua_tousertype(tolua_S,1,0);
4191 #ifndef TOLUA_RELEASE
4192   tolua_Error tolua_err;
4193   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'color_type'",NULL);
4194   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
4195    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4196 #endif
4197   self->color_type = ((int)  tolua_tonumber(tolua_S,2,0))
4198 ;
4199  return 0;
4200 }
4201 #endif //#ifndef TOLUA_DISABLE
4202
4203 /* get function: mirror of class  meshio::mqo::Object */
4204 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Object_mirror
4205 static int tolua_get_meshio__mqo__Object_mirror(lua_State* tolua_S)
4206 {
4207   meshio::mqo::Object* self = (meshio::mqo::Object*)  tolua_tousertype(tolua_S,1,0);
4208 #ifndef TOLUA_RELEASE
4209   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'mirror'",NULL);
4210 #endif
4211   tolua_pushnumber(tolua_S,(lua_Number)self->mirror);
4212  return 1;
4213 }
4214 #endif //#ifndef TOLUA_DISABLE
4215
4216 /* set function: mirror of class  meshio::mqo::Object */
4217 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Object_mirror
4218 static int tolua_set_meshio__mqo__Object_mirror(lua_State* tolua_S)
4219 {
4220   meshio::mqo::Object* self = (meshio::mqo::Object*)  tolua_tousertype(tolua_S,1,0);
4221 #ifndef TOLUA_RELEASE
4222   tolua_Error tolua_err;
4223   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'mirror'",NULL);
4224   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
4225    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4226 #endif
4227   self->mirror = ((int)  tolua_tonumber(tolua_S,2,0))
4228 ;
4229  return 0;
4230 }
4231 #endif //#ifndef TOLUA_DISABLE
4232
4233 /* get function: vertices of class  meshio::mqo::Object */
4234 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Object_vertices
4235 static int tolua_get_meshio__mqo__Object_vertices(lua_State* tolua_S)
4236 {
4237   meshio::mqo::Object* self = (meshio::mqo::Object*)  tolua_tousertype(tolua_S,1,0);
4238 #ifndef TOLUA_RELEASE
4239   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'vertices'",NULL);
4240 #endif
4241    tolua_pushusertype(tolua_S,(void*)&self->vertices,"std::vector<meshio::Vector3>");
4242  return 1;
4243 }
4244 #endif //#ifndef TOLUA_DISABLE
4245
4246 /* set function: vertices of class  meshio::mqo::Object */
4247 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Object_vertices
4248 static int tolua_set_meshio__mqo__Object_vertices(lua_State* tolua_S)
4249 {
4250   meshio::mqo::Object* self = (meshio::mqo::Object*)  tolua_tousertype(tolua_S,1,0);
4251 #ifndef TOLUA_RELEASE
4252   tolua_Error tolua_err;
4253   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'vertices'",NULL);
4254   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"std::vector<meshio::Vector3>",0,&tolua_err)))
4255    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4256 #endif
4257   self->vertices = *((std::vector<meshio::Vector3>*)  tolua_tousertype(tolua_S,2,0))
4258 ;
4259  return 0;
4260 }
4261 #endif //#ifndef TOLUA_DISABLE
4262
4263 /* get function: faces of class  meshio::mqo::Object */
4264 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__Object_faces
4265 static int tolua_get_meshio__mqo__Object_faces(lua_State* tolua_S)
4266 {
4267   meshio::mqo::Object* self = (meshio::mqo::Object*)  tolua_tousertype(tolua_S,1,0);
4268 #ifndef TOLUA_RELEASE
4269   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'faces'",NULL);
4270 #endif
4271    tolua_pushusertype(tolua_S,(void*)&self->faces,"std::vector<meshio::mqo::Face>");
4272  return 1;
4273 }
4274 #endif //#ifndef TOLUA_DISABLE
4275
4276 /* set function: faces of class  meshio::mqo::Object */
4277 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__Object_faces
4278 static int tolua_set_meshio__mqo__Object_faces(lua_State* tolua_S)
4279 {
4280   meshio::mqo::Object* self = (meshio::mqo::Object*)  tolua_tousertype(tolua_S,1,0);
4281 #ifndef TOLUA_RELEASE
4282   tolua_Error tolua_err;
4283   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'faces'",NULL);
4284   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"std::vector<meshio::mqo::Face>",0,&tolua_err)))
4285    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4286 #endif
4287   self->faces = *((std::vector<meshio::mqo::Face>*)  tolua_tousertype(tolua_S,2,0))
4288 ;
4289  return 0;
4290 }
4291 #endif //#ifndef TOLUA_DISABLE
4292
4293 /* get function: scene of class  meshio::mqo::IO */
4294 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__IO_scene
4295 static int tolua_get_meshio__mqo__IO_scene(lua_State* tolua_S)
4296 {
4297   meshio::mqo::IO* self = (meshio::mqo::IO*)  tolua_tousertype(tolua_S,1,0);
4298 #ifndef TOLUA_RELEASE
4299   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'scene'",NULL);
4300 #endif
4301    tolua_pushusertype(tolua_S,(void*)&self->scene,"meshio::mqo::Scene");
4302  return 1;
4303 }
4304 #endif //#ifndef TOLUA_DISABLE
4305
4306 /* set function: scene of class  meshio::mqo::IO */
4307 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__IO_scene
4308 static int tolua_set_meshio__mqo__IO_scene(lua_State* tolua_S)
4309 {
4310   meshio::mqo::IO* self = (meshio::mqo::IO*)  tolua_tousertype(tolua_S,1,0);
4311 #ifndef TOLUA_RELEASE
4312   tolua_Error tolua_err;
4313   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'scene'",NULL);
4314   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::mqo::Scene",0,&tolua_err)))
4315    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4316 #endif
4317   self->scene = *((meshio::mqo::Scene*)  tolua_tousertype(tolua_S,2,0))
4318 ;
4319  return 0;
4320 }
4321 #endif //#ifndef TOLUA_DISABLE
4322
4323 /* get function: materials of class  meshio::mqo::IO */
4324 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__IO_materials
4325 static int tolua_get_meshio__mqo__IO_materials(lua_State* tolua_S)
4326 {
4327   meshio::mqo::IO* self = (meshio::mqo::IO*)  tolua_tousertype(tolua_S,1,0);
4328 #ifndef TOLUA_RELEASE
4329   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'materials'",NULL);
4330 #endif
4331    tolua_pushusertype(tolua_S,(void*)&self->materials,"std::vector<meshio::mqo::Material>");
4332  return 1;
4333 }
4334 #endif //#ifndef TOLUA_DISABLE
4335
4336 /* set function: materials of class  meshio::mqo::IO */
4337 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__IO_materials
4338 static int tolua_set_meshio__mqo__IO_materials(lua_State* tolua_S)
4339 {
4340   meshio::mqo::IO* self = (meshio::mqo::IO*)  tolua_tousertype(tolua_S,1,0);
4341 #ifndef TOLUA_RELEASE
4342   tolua_Error tolua_err;
4343   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'materials'",NULL);
4344   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"std::vector<meshio::mqo::Material>",0,&tolua_err)))
4345    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4346 #endif
4347   self->materials = *((std::vector<meshio::mqo::Material>*)  tolua_tousertype(tolua_S,2,0))
4348 ;
4349  return 0;
4350 }
4351 #endif //#ifndef TOLUA_DISABLE
4352
4353 /* get function: objects of class  meshio::mqo::IO */
4354 #ifndef TOLUA_DISABLE_tolua_get_meshio__mqo__IO_objects
4355 static int tolua_get_meshio__mqo__IO_objects(lua_State* tolua_S)
4356 {
4357   meshio::mqo::IO* self = (meshio::mqo::IO*)  tolua_tousertype(tolua_S,1,0);
4358 #ifndef TOLUA_RELEASE
4359   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'objects'",NULL);
4360 #endif
4361    tolua_pushusertype(tolua_S,(void*)&self->objects,"std::vector<meshio::mqo::Object>");
4362  return 1;
4363 }
4364 #endif //#ifndef TOLUA_DISABLE
4365
4366 /* set function: objects of class  meshio::mqo::IO */
4367 #ifndef TOLUA_DISABLE_tolua_set_meshio__mqo__IO_objects
4368 static int tolua_set_meshio__mqo__IO_objects(lua_State* tolua_S)
4369 {
4370   meshio::mqo::IO* self = (meshio::mqo::IO*)  tolua_tousertype(tolua_S,1,0);
4371 #ifndef TOLUA_RELEASE
4372   tolua_Error tolua_err;
4373   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'objects'",NULL);
4374   if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"std::vector<meshio::mqo::Object>",0,&tolua_err)))
4375    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4376 #endif
4377   self->objects = *((std::vector<meshio::mqo::Object>*)  tolua_tousertype(tolua_S,2,0))
4378 ;
4379  return 0;
4380 }
4381 #endif //#ifndef TOLUA_DISABLE
4382
4383 /* method: new of class  meshio::mqo::IO */
4384 #ifndef TOLUA_DISABLE_tolua_lmeshio_meshio_mqo_IO_new00
4385 static int tolua_lmeshio_meshio_mqo_IO_new00(lua_State* tolua_S)
4386 {
4387 #ifndef TOLUA_RELEASE
4388  tolua_Error tolua_err;
4389  if (
4390      !tolua_isusertable(tolua_S,1,"meshio::mqo::IO",0,&tolua_err) ||
4391      !tolua_isnoobj(tolua_S,2,&tolua_err)
4392  )
4393   goto tolua_lerror;
4394  else
4395 #endif
4396  {
4397
4398
4399   {
4400    meshio::mqo::IO* tolua_ret = (meshio::mqo::IO*)  Mtolua_new((meshio::mqo::IO)());
4401     tolua_pushusertype(tolua_S,(void*)tolua_ret,"meshio::mqo::IO");
4402   }
4403
4404  }
4405  return 1;
4406 #ifndef TOLUA_RELEASE
4407  tolua_lerror:
4408  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
4409  return 0;
4410 #endif
4411 }
4412 #endif //#ifndef TOLUA_DISABLE
4413
4414 /* method: new_local of class  meshio::mqo::IO */
4415 #ifndef TOLUA_DISABLE_tolua_lmeshio_meshio_mqo_IO_new00_local
4416 static int tolua_lmeshio_meshio_mqo_IO_new00_local(lua_State* tolua_S)
4417 {
4418 #ifndef TOLUA_RELEASE
4419  tolua_Error tolua_err;
4420  if (
4421      !tolua_isusertable(tolua_S,1,"meshio::mqo::IO",0,&tolua_err) ||
4422      !tolua_isnoobj(tolua_S,2,&tolua_err)
4423  )
4424   goto tolua_lerror;
4425  else
4426 #endif
4427  {
4428
4429
4430   {
4431    meshio::mqo::IO* tolua_ret = (meshio::mqo::IO*)  Mtolua_new((meshio::mqo::IO)());
4432     tolua_pushusertype(tolua_S,(void*)tolua_ret,"meshio::mqo::IO");
4433     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
4434   }
4435
4436  }
4437  return 1;
4438 #ifndef TOLUA_RELEASE
4439  tolua_lerror:
4440  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
4441  return 0;
4442 #endif
4443 }
4444 #endif //#ifndef TOLUA_DISABLE
4445
4446 /* method: read of class  meshio::mqo::IO */
4447 #ifndef TOLUA_DISABLE_tolua_lmeshio_meshio_mqo_IO_read00
4448 static int tolua_lmeshio_meshio_mqo_IO_read00(lua_State* tolua_S)
4449 {
4450 #ifndef TOLUA_RELEASE
4451  tolua_Error tolua_err;
4452  if (
4453      !tolua_isusertype(tolua_S,1,"meshio::mqo::IO",0,&tolua_err) ||
4454      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
4455      !tolua_isnoobj(tolua_S,3,&tolua_err)
4456  )
4457   goto tolua_lerror;
4458  else
4459 #endif
4460  {
4461   meshio::mqo::IO* self = (meshio::mqo::IO*)  tolua_tousertype(tolua_S,1,0);
4462   const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
4463 #ifndef TOLUA_RELEASE
4464   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'read'", NULL);
4465 #endif
4466   {
4467    bool tolua_ret = (bool)  self->read(path);
4468    tolua_pushboolean(tolua_S,(bool)tolua_ret);
4469
4470   }
4471
4472  }
4473  return 1;
4474 #ifndef TOLUA_RELEASE
4475  tolua_lerror:
4476  tolua_error(tolua_S,"#ferror in function 'read'.",&tolua_err);
4477  return 0;
4478 #endif
4479 }
4480 #endif //#ifndef TOLUA_DISABLE
4481
4482 /* method: write of class  meshio::mqo::IO */
4483 #ifndef TOLUA_DISABLE_tolua_lmeshio_meshio_mqo_IO_write00
4484 static int tolua_lmeshio_meshio_mqo_IO_write00(lua_State* tolua_S)
4485 {
4486 #ifndef TOLUA_RELEASE
4487  tolua_Error tolua_err;
4488  if (
4489      !tolua_isusertype(tolua_S,1,"meshio::mqo::IO",0,&tolua_err) ||
4490      !tolua_isstring(tolua_S,2,0,&tolua_err) ||
4491      !tolua_isnoobj(tolua_S,3,&tolua_err)
4492  )
4493   goto tolua_lerror;
4494  else
4495 #endif
4496  {
4497   meshio::mqo::IO* self = (meshio::mqo::IO*)  tolua_tousertype(tolua_S,1,0);
4498   const char* path = ((const char*)  tolua_tostring(tolua_S,2,0));
4499 #ifndef TOLUA_RELEASE
4500   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'write'", NULL);
4501 #endif
4502   {
4503    bool tolua_ret = (bool)  self->write(path);
4504    tolua_pushboolean(tolua_S,(bool)tolua_ret);
4505
4506   }
4507
4508  }
4509  return 1;
4510 #ifndef TOLUA_RELEASE
4511  tolua_lerror:
4512  tolua_error(tolua_S,"#ferror in function 'write'.",&tolua_err);
4513  return 0;
4514 #endif
4515 }
4516 #endif //#ifndef TOLUA_DISABLE
4517
4518 /* get function: x of class  meshio::Vector2 */
4519 #ifndef TOLUA_DISABLE_tolua_get_meshio__Vector2_x
4520 static int tolua_get_meshio__Vector2_x(lua_State* tolua_S)
4521 {
4522   meshio::Vector2* self = (meshio::Vector2*)  tolua_tousertype(tolua_S,1,0);
4523 #ifndef TOLUA_RELEASE
4524   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'x'",NULL);
4525 #endif
4526   tolua_pushnumber(tolua_S,(lua_Number)self->x);
4527  return 1;
4528 }
4529 #endif //#ifndef TOLUA_DISABLE
4530
4531 /* set function: x of class  meshio::Vector2 */
4532 #ifndef TOLUA_DISABLE_tolua_set_meshio__Vector2_x
4533 static int tolua_set_meshio__Vector2_x(lua_State* tolua_S)
4534 {
4535   meshio::Vector2* self = (meshio::Vector2*)  tolua_tousertype(tolua_S,1,0);
4536 #ifndef TOLUA_RELEASE
4537   tolua_Error tolua_err;
4538   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'x'",NULL);
4539   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
4540    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4541 #endif
4542   self->x = ((float)  tolua_tonumber(tolua_S,2,0))
4543 ;
4544  return 0;
4545 }
4546 #endif //#ifndef TOLUA_DISABLE
4547
4548 /* get function: y of class  meshio::Vector2 */
4549 #ifndef TOLUA_DISABLE_tolua_get_meshio__Vector2_y
4550 static int tolua_get_meshio__Vector2_y(lua_State* tolua_S)
4551 {
4552   meshio::Vector2* self = (meshio::Vector2*)  tolua_tousertype(tolua_S,1,0);
4553 #ifndef TOLUA_RELEASE
4554   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'y'",NULL);
4555 #endif
4556   tolua_pushnumber(tolua_S,(lua_Number)self->y);
4557  return 1;
4558 }
4559 #endif //#ifndef TOLUA_DISABLE
4560
4561 /* set function: y of class  meshio::Vector2 */
4562 #ifndef TOLUA_DISABLE_tolua_set_meshio__Vector2_y
4563 static int tolua_set_meshio__Vector2_y(lua_State* tolua_S)
4564 {
4565   meshio::Vector2* self = (meshio::Vector2*)  tolua_tousertype(tolua_S,1,0);
4566 #ifndef TOLUA_RELEASE
4567   tolua_Error tolua_err;
4568   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'y'",NULL);
4569   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
4570    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4571 #endif
4572   self->y = ((float)  tolua_tonumber(tolua_S,2,0))
4573 ;
4574  return 0;
4575 }
4576 #endif //#ifndef TOLUA_DISABLE
4577
4578 /* method: new of class  meshio::Vector2 */
4579 #ifndef TOLUA_DISABLE_tolua_lmeshio_meshio_Vector2_new00
4580 static int tolua_lmeshio_meshio_Vector2_new00(lua_State* tolua_S)
4581 {
4582 #ifndef TOLUA_RELEASE
4583  tolua_Error tolua_err;
4584  if (
4585      !tolua_isusertable(tolua_S,1,"meshio::Vector2",0,&tolua_err) ||
4586      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
4587      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
4588      !tolua_isnoobj(tolua_S,4,&tolua_err)
4589  )
4590   goto tolua_lerror;
4591  else
4592 #endif
4593  {
4594
4595   float _x = ((float)  tolua_tonumber(tolua_S,2,0));
4596   float _y = ((float)  tolua_tonumber(tolua_S,3,0));
4597
4598   {
4599    meshio::Vector2* tolua_ret = (meshio::Vector2*)  Mtolua_new((meshio::Vector2)(_x,_y));
4600     tolua_pushusertype(tolua_S,(void*)tolua_ret,"meshio::Vector2");
4601
4602
4603   }
4604
4605  }
4606  return 1;
4607 #ifndef TOLUA_RELEASE
4608  tolua_lerror:
4609  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
4610  return 0;
4611 #endif
4612 }
4613 #endif //#ifndef TOLUA_DISABLE
4614
4615 /* method: new_local of class  meshio::Vector2 */
4616 #ifndef TOLUA_DISABLE_tolua_lmeshio_meshio_Vector2_new00_local
4617 static int tolua_lmeshio_meshio_Vector2_new00_local(lua_State* tolua_S)
4618 {
4619 #ifndef TOLUA_RELEASE
4620  tolua_Error tolua_err;
4621  if (
4622      !tolua_isusertable(tolua_S,1,"meshio::Vector2",0,&tolua_err) ||
4623      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
4624      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
4625      !tolua_isnoobj(tolua_S,4,&tolua_err)
4626  )
4627   goto tolua_lerror;
4628  else
4629 #endif
4630  {
4631
4632   float _x = ((float)  tolua_tonumber(tolua_S,2,0));
4633   float _y = ((float)  tolua_tonumber(tolua_S,3,0));
4634
4635   {
4636    meshio::Vector2* tolua_ret = (meshio::Vector2*)  Mtolua_new((meshio::Vector2)(_x,_y));
4637     tolua_pushusertype(tolua_S,(void*)tolua_ret,"meshio::Vector2");
4638     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
4639
4640
4641   }
4642
4643  }
4644  return 1;
4645 #ifndef TOLUA_RELEASE
4646  tolua_lerror:
4647  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
4648  return 0;
4649 #endif
4650 }
4651 #endif //#ifndef TOLUA_DISABLE
4652
4653 /* get function: x of class  meshio::Vector3 */
4654 #ifndef TOLUA_DISABLE_tolua_get_meshio__Vector3_x
4655 static int tolua_get_meshio__Vector3_x(lua_State* tolua_S)
4656 {
4657   meshio::Vector3* self = (meshio::Vector3*)  tolua_tousertype(tolua_S,1,0);
4658 #ifndef TOLUA_RELEASE
4659   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'x'",NULL);
4660 #endif
4661   tolua_pushnumber(tolua_S,(lua_Number)self->x);
4662  return 1;
4663 }
4664 #endif //#ifndef TOLUA_DISABLE
4665
4666 /* set function: x of class  meshio::Vector3 */
4667 #ifndef TOLUA_DISABLE_tolua_set_meshio__Vector3_x
4668 static int tolua_set_meshio__Vector3_x(lua_State* tolua_S)
4669 {
4670   meshio::Vector3* self = (meshio::Vector3*)  tolua_tousertype(tolua_S,1,0);
4671 #ifndef TOLUA_RELEASE
4672   tolua_Error tolua_err;
4673   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'x'",NULL);
4674   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
4675    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4676 #endif
4677   self->x = ((float)  tolua_tonumber(tolua_S,2,0))
4678 ;
4679  return 0;
4680 }
4681 #endif //#ifndef TOLUA_DISABLE
4682
4683 /* get function: y of class  meshio::Vector3 */
4684 #ifndef TOLUA_DISABLE_tolua_get_meshio__Vector3_y
4685 static int tolua_get_meshio__Vector3_y(lua_State* tolua_S)
4686 {
4687   meshio::Vector3* self = (meshio::Vector3*)  tolua_tousertype(tolua_S,1,0);
4688 #ifndef TOLUA_RELEASE
4689   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'y'",NULL);
4690 #endif
4691   tolua_pushnumber(tolua_S,(lua_Number)self->y);
4692  return 1;
4693 }
4694 #endif //#ifndef TOLUA_DISABLE
4695
4696 /* set function: y of class  meshio::Vector3 */
4697 #ifndef TOLUA_DISABLE_tolua_set_meshio__Vector3_y
4698 static int tolua_set_meshio__Vector3_y(lua_State* tolua_S)
4699 {
4700   meshio::Vector3* self = (meshio::Vector3*)  tolua_tousertype(tolua_S,1,0);
4701 #ifndef TOLUA_RELEASE
4702   tolua_Error tolua_err;
4703   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'y'",NULL);
4704   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
4705    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4706 #endif
4707   self->y = ((float)  tolua_tonumber(tolua_S,2,0))
4708 ;
4709  return 0;
4710 }
4711 #endif //#ifndef TOLUA_DISABLE
4712
4713 /* get function: z of class  meshio::Vector3 */
4714 #ifndef TOLUA_DISABLE_tolua_get_meshio__Vector3_z
4715 static int tolua_get_meshio__Vector3_z(lua_State* tolua_S)
4716 {
4717   meshio::Vector3* self = (meshio::Vector3*)  tolua_tousertype(tolua_S,1,0);
4718 #ifndef TOLUA_RELEASE
4719   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'z'",NULL);
4720 #endif
4721   tolua_pushnumber(tolua_S,(lua_Number)self->z);
4722  return 1;
4723 }
4724 #endif //#ifndef TOLUA_DISABLE
4725
4726 /* set function: z of class  meshio::Vector3 */
4727 #ifndef TOLUA_DISABLE_tolua_set_meshio__Vector3_z
4728 static int tolua_set_meshio__Vector3_z(lua_State* tolua_S)
4729 {
4730   meshio::Vector3* self = (meshio::Vector3*)  tolua_tousertype(tolua_S,1,0);
4731 #ifndef TOLUA_RELEASE
4732   tolua_Error tolua_err;
4733   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'z'",NULL);
4734   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
4735    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4736 #endif
4737   self->z = ((float)  tolua_tonumber(tolua_S,2,0))
4738 ;
4739  return 0;
4740 }
4741 #endif //#ifndef TOLUA_DISABLE
4742
4743 /* method: new of class  meshio::Vector3 */
4744 #ifndef TOLUA_DISABLE_tolua_lmeshio_meshio_Vector3_new00
4745 static int tolua_lmeshio_meshio_Vector3_new00(lua_State* tolua_S)
4746 {
4747 #ifndef TOLUA_RELEASE
4748  tolua_Error tolua_err;
4749  if (
4750      !tolua_isusertable(tolua_S,1,"meshio::Vector3",0,&tolua_err) ||
4751      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
4752      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
4753      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
4754      !tolua_isnoobj(tolua_S,5,&tolua_err)
4755  )
4756   goto tolua_lerror;
4757  else
4758 #endif
4759  {
4760
4761   float _x = ((float)  tolua_tonumber(tolua_S,2,0));
4762   float _y = ((float)  tolua_tonumber(tolua_S,3,0));
4763   float _z = ((float)  tolua_tonumber(tolua_S,4,0));
4764
4765   {
4766    meshio::Vector3* tolua_ret = (meshio::Vector3*)  Mtolua_new((meshio::Vector3)(_x,_y,_z));
4767     tolua_pushusertype(tolua_S,(void*)tolua_ret,"meshio::Vector3");
4768
4769
4770
4771   }
4772
4773  }
4774  return 1;
4775 #ifndef TOLUA_RELEASE
4776  tolua_lerror:
4777  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
4778  return 0;
4779 #endif
4780 }
4781 #endif //#ifndef TOLUA_DISABLE
4782
4783 /* method: new_local of class  meshio::Vector3 */
4784 #ifndef TOLUA_DISABLE_tolua_lmeshio_meshio_Vector3_new00_local
4785 static int tolua_lmeshio_meshio_Vector3_new00_local(lua_State* tolua_S)
4786 {
4787 #ifndef TOLUA_RELEASE
4788  tolua_Error tolua_err;
4789  if (
4790      !tolua_isusertable(tolua_S,1,"meshio::Vector3",0,&tolua_err) ||
4791      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
4792      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
4793      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
4794      !tolua_isnoobj(tolua_S,5,&tolua_err)
4795  )
4796   goto tolua_lerror;
4797  else
4798 #endif
4799  {
4800
4801   float _x = ((float)  tolua_tonumber(tolua_S,2,0));
4802   float _y = ((float)  tolua_tonumber(tolua_S,3,0));
4803   float _z = ((float)  tolua_tonumber(tolua_S,4,0));
4804
4805   {
4806    meshio::Vector3* tolua_ret = (meshio::Vector3*)  Mtolua_new((meshio::Vector3)(_x,_y,_z));
4807     tolua_pushusertype(tolua_S,(void*)tolua_ret,"meshio::Vector3");
4808     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
4809
4810
4811
4812   }
4813
4814  }
4815  return 1;
4816 #ifndef TOLUA_RELEASE
4817  tolua_lerror:
4818  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
4819  return 0;
4820 #endif
4821 }
4822 #endif //#ifndef TOLUA_DISABLE
4823
4824 /* method: operator== of class  meshio::Vector3 */
4825 #ifndef TOLUA_DISABLE_tolua_lmeshio_meshio_Vector3__eq00
4826 static int tolua_lmeshio_meshio_Vector3__eq00(lua_State* tolua_S)
4827 {
4828 #ifndef TOLUA_RELEASE
4829  tolua_Error tolua_err;
4830  if (
4831      !tolua_isusertype(tolua_S,1,"const meshio::Vector3",0,&tolua_err) ||
4832      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const meshio::Vector3",0,&tolua_err)) ||
4833      !tolua_isnoobj(tolua_S,3,&tolua_err)
4834  )
4835   goto tolua_lerror;
4836  else
4837 #endif
4838  {
4839   const meshio::Vector3* self = (const meshio::Vector3*)  tolua_tousertype(tolua_S,1,0);
4840   const meshio::Vector3* rhs = ((const meshio::Vector3*)  tolua_tousertype(tolua_S,2,0));
4841 #ifndef TOLUA_RELEASE
4842   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", NULL);
4843 #endif
4844   {
4845    bool tolua_ret = (bool)  self->operator==(*rhs);
4846    tolua_pushboolean(tolua_S,(bool)tolua_ret);
4847
4848   }
4849
4850  }
4851  return 1;
4852 #ifndef TOLUA_RELEASE
4853  tolua_lerror:
4854  tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
4855  return 0;
4856 #endif
4857 }
4858 #endif //#ifndef TOLUA_DISABLE
4859
4860 /* method: operator+ of class  meshio::Vector3 */
4861 #ifndef TOLUA_DISABLE_tolua_lmeshio_meshio_Vector3__add00
4862 static int tolua_lmeshio_meshio_Vector3__add00(lua_State* tolua_S)
4863 {
4864 #ifndef TOLUA_RELEASE
4865  tolua_Error tolua_err;
4866  if (
4867      !tolua_isusertype(tolua_S,1,"meshio::Vector3",0,&tolua_err) ||
4868      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const meshio::Vector3",0,&tolua_err)) ||
4869      !tolua_isnoobj(tolua_S,3,&tolua_err)
4870  )
4871   goto tolua_lerror;
4872  else
4873 #endif
4874  {
4875   meshio::Vector3* self = (meshio::Vector3*)  tolua_tousertype(tolua_S,1,0);
4876   const meshio::Vector3* rhs = ((const meshio::Vector3*)  tolua_tousertype(tolua_S,2,0));
4877 #ifndef TOLUA_RELEASE
4878   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator+'", NULL);
4879 #endif
4880   {
4881    meshio::Vector3 tolua_ret = (meshio::Vector3)  self->operator+(*rhs);
4882    {
4883 #ifdef __cplusplus
4884     void* tolua_obj = Mtolua_new((meshio::Vector3)(tolua_ret));
4885      tolua_pushusertype(tolua_S,tolua_obj,"meshio::Vector3");
4886     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
4887 #else
4888     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(meshio::Vector3));
4889      tolua_pushusertype(tolua_S,tolua_obj,"meshio::Vector3");
4890     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
4891 #endif
4892    }
4893
4894   }
4895
4896  }
4897  return 1;
4898 #ifndef TOLUA_RELEASE
4899  tolua_lerror:
4900  tolua_error(tolua_S,"#ferror in function '.add'.",&tolua_err);
4901  return 0;
4902 #endif
4903 }
4904 #endif //#ifndef TOLUA_DISABLE
4905
4906 /* method: operator- of class  meshio::Vector3 */
4907 #ifndef TOLUA_DISABLE_tolua_lmeshio_meshio_Vector3__sub00
4908 static int tolua_lmeshio_meshio_Vector3__sub00(lua_State* tolua_S)
4909 {
4910 #ifndef TOLUA_RELEASE
4911  tolua_Error tolua_err;
4912  if (
4913      !tolua_isusertype(tolua_S,1,"meshio::Vector3",0,&tolua_err) ||
4914      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const meshio::Vector3",0,&tolua_err)) ||
4915      !tolua_isnoobj(tolua_S,3,&tolua_err)
4916  )
4917   goto tolua_lerror;
4918  else
4919 #endif
4920  {
4921   meshio::Vector3* self = (meshio::Vector3*)  tolua_tousertype(tolua_S,1,0);
4922   const meshio::Vector3* rhs = ((const meshio::Vector3*)  tolua_tousertype(tolua_S,2,0));
4923 #ifndef TOLUA_RELEASE
4924   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator-'", NULL);
4925 #endif
4926   {
4927    meshio::Vector3 tolua_ret = (meshio::Vector3)  self->operator-(*rhs);
4928    {
4929 #ifdef __cplusplus
4930     void* tolua_obj = Mtolua_new((meshio::Vector3)(tolua_ret));
4931      tolua_pushusertype(tolua_S,tolua_obj,"meshio::Vector3");
4932     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
4933 #else
4934     void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(meshio::Vector3));
4935      tolua_pushusertype(tolua_S,tolua_obj,"meshio::Vector3");
4936     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
4937 #endif
4938    }
4939
4940   }
4941
4942  }
4943  return 1;
4944 #ifndef TOLUA_RELEASE
4945  tolua_lerror:
4946  tolua_error(tolua_S,"#ferror in function '.sub'.",&tolua_err);
4947  return 0;
4948 #endif
4949 }
4950 #endif //#ifndef TOLUA_DISABLE
4951
4952 /* get function: x of class  meshio::Vector4 */
4953 #ifndef TOLUA_DISABLE_tolua_get_meshio__Vector4_x
4954 static int tolua_get_meshio__Vector4_x(lua_State* tolua_S)
4955 {
4956   meshio::Vector4* self = (meshio::Vector4*)  tolua_tousertype(tolua_S,1,0);
4957 #ifndef TOLUA_RELEASE
4958   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'x'",NULL);
4959 #endif
4960   tolua_pushnumber(tolua_S,(lua_Number)self->x);
4961  return 1;
4962 }
4963 #endif //#ifndef TOLUA_DISABLE
4964
4965 /* set function: x of class  meshio::Vector4 */
4966 #ifndef TOLUA_DISABLE_tolua_set_meshio__Vector4_x
4967 static int tolua_set_meshio__Vector4_x(lua_State* tolua_S)
4968 {
4969   meshio::Vector4* self = (meshio::Vector4*)  tolua_tousertype(tolua_S,1,0);
4970 #ifndef TOLUA_RELEASE
4971   tolua_Error tolua_err;
4972   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'x'",NULL);
4973   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
4974    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
4975 #endif
4976   self->x = ((float)  tolua_tonumber(tolua_S,2,0))
4977 ;
4978  return 0;
4979 }
4980 #endif //#ifndef TOLUA_DISABLE
4981
4982 /* get function: y of class  meshio::Vector4 */
4983 #ifndef TOLUA_DISABLE_tolua_get_meshio__Vector4_y
4984 static int tolua_get_meshio__Vector4_y(lua_State* tolua_S)
4985 {
4986   meshio::Vector4* self = (meshio::Vector4*)  tolua_tousertype(tolua_S,1,0);
4987 #ifndef TOLUA_RELEASE
4988   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'y'",NULL);
4989 #endif
4990   tolua_pushnumber(tolua_S,(lua_Number)self->y);
4991  return 1;
4992 }
4993 #endif //#ifndef TOLUA_DISABLE
4994
4995 /* set function: y of class  meshio::Vector4 */
4996 #ifndef TOLUA_DISABLE_tolua_set_meshio__Vector4_y
4997 static int tolua_set_meshio__Vector4_y(lua_State* tolua_S)
4998 {
4999   meshio::Vector4* self = (meshio::Vector4*)  tolua_tousertype(tolua_S,1,0);
5000 #ifndef TOLUA_RELEASE
5001   tolua_Error tolua_err;
5002   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'y'",NULL);
5003   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
5004    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
5005 #endif
5006   self->y = ((float)  tolua_tonumber(tolua_S,2,0))
5007 ;
5008  return 0;
5009 }
5010 #endif //#ifndef TOLUA_DISABLE
5011
5012 /* get function: z of class  meshio::Vector4 */
5013 #ifndef TOLUA_DISABLE_tolua_get_meshio__Vector4_z
5014 static int tolua_get_meshio__Vector4_z(lua_State* tolua_S)
5015 {
5016   meshio::Vector4* self = (meshio::Vector4*)  tolua_tousertype(tolua_S,1,0);
5017 #ifndef TOLUA_RELEASE
5018   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'z'",NULL);
5019 #endif
5020   tolua_pushnumber(tolua_S,(lua_Number)self->z);
5021  return 1;
5022 }
5023 #endif //#ifndef TOLUA_DISABLE
5024
5025 /* set function: z of class  meshio::Vector4 */
5026 #ifndef TOLUA_DISABLE_tolua_set_meshio__Vector4_z
5027 static int tolua_set_meshio__Vector4_z(lua_State* tolua_S)
5028 {
5029   meshio::Vector4* self = (meshio::Vector4*)  tolua_tousertype(tolua_S,1,0);
5030 #ifndef TOLUA_RELEASE
5031   tolua_Error tolua_err;
5032   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'z'",NULL);
5033   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
5034    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
5035 #endif
5036   self->z = ((float)  tolua_tonumber(tolua_S,2,0))
5037 ;
5038  return 0;
5039 }
5040 #endif //#ifndef TOLUA_DISABLE
5041
5042 /* get function: w of class  meshio::Vector4 */
5043 #ifndef TOLUA_DISABLE_tolua_get_meshio__Vector4_w
5044 static int tolua_get_meshio__Vector4_w(lua_State* tolua_S)
5045 {
5046   meshio::Vector4* self = (meshio::Vector4*)  tolua_tousertype(tolua_S,1,0);
5047 #ifndef TOLUA_RELEASE
5048   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'w'",NULL);
5049 #endif
5050   tolua_pushnumber(tolua_S,(lua_Number)self->w);
5051  return 1;
5052 }
5053 #endif //#ifndef TOLUA_DISABLE
5054
5055 /* set function: w of class  meshio::Vector4 */
5056 #ifndef TOLUA_DISABLE_tolua_set_meshio__Vector4_w
5057 static int tolua_set_meshio__Vector4_w(lua_State* tolua_S)
5058 {
5059   meshio::Vector4* self = (meshio::Vector4*)  tolua_tousertype(tolua_S,1,0);
5060 #ifndef TOLUA_RELEASE
5061   tolua_Error tolua_err;
5062   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'w'",NULL);
5063   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
5064    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
5065 #endif
5066   self->w = ((float)  tolua_tonumber(tolua_S,2,0))
5067 ;
5068  return 0;
5069 }
5070 #endif //#ifndef TOLUA_DISABLE
5071
5072 /* method: new of class  meshio::Vector4 */
5073 #ifndef TOLUA_DISABLE_tolua_lmeshio_meshio_Vector4_new00
5074 static int tolua_lmeshio_meshio_Vector4_new00(lua_State* tolua_S)
5075 {
5076 #ifndef TOLUA_RELEASE
5077  tolua_Error tolua_err;
5078  if (
5079      !tolua_isusertable(tolua_S,1,"meshio::Vector4",0,&tolua_err) ||
5080      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
5081      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
5082      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
5083      !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
5084      !tolua_isnoobj(tolua_S,6,&tolua_err)
5085  )
5086   goto tolua_lerror;
5087  else
5088 #endif
5089  {
5090
5091   float _x = ((float)  tolua_tonumber(tolua_S,2,0));
5092   float _y = ((float)  tolua_tonumber(tolua_S,3,0));
5093   float _z = ((float)  tolua_tonumber(tolua_S,4,0));
5094   float _w = ((float)  tolua_tonumber(tolua_S,5,0));
5095
5096   {
5097    meshio::Vector4* tolua_ret = (meshio::Vector4*)  Mtolua_new((meshio::Vector4)(_x,_y,_z,_w));
5098     tolua_pushusertype(tolua_S,(void*)tolua_ret,"meshio::Vector4");
5099
5100
5101
5102
5103   }
5104
5105  }
5106  return 1;
5107 #ifndef TOLUA_RELEASE
5108  tolua_lerror:
5109  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
5110  return 0;
5111 #endif
5112 }
5113 #endif //#ifndef TOLUA_DISABLE
5114
5115 /* method: new_local of class  meshio::Vector4 */
5116 #ifndef TOLUA_DISABLE_tolua_lmeshio_meshio_Vector4_new00_local
5117 static int tolua_lmeshio_meshio_Vector4_new00_local(lua_State* tolua_S)
5118 {
5119 #ifndef TOLUA_RELEASE
5120  tolua_Error tolua_err;
5121  if (
5122      !tolua_isusertable(tolua_S,1,"meshio::Vector4",0,&tolua_err) ||
5123      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
5124      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
5125      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
5126      !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
5127      !tolua_isnoobj(tolua_S,6,&tolua_err)
5128  )
5129   goto tolua_lerror;
5130  else
5131 #endif
5132  {
5133
5134   float _x = ((float)  tolua_tonumber(tolua_S,2,0));
5135   float _y = ((float)  tolua_tonumber(tolua_S,3,0));
5136   float _z = ((float)  tolua_tonumber(tolua_S,4,0));
5137   float _w = ((float)  tolua_tonumber(tolua_S,5,0));
5138
5139   {
5140    meshio::Vector4* tolua_ret = (meshio::Vector4*)  Mtolua_new((meshio::Vector4)(_x,_y,_z,_w));
5141     tolua_pushusertype(tolua_S,(void*)tolua_ret,"meshio::Vector4");
5142     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
5143
5144
5145
5146
5147   }
5148
5149  }
5150  return 1;
5151 #ifndef TOLUA_RELEASE
5152  tolua_lerror:
5153  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
5154  return 0;
5155 #endif
5156 }
5157 #endif //#ifndef TOLUA_DISABLE
5158
5159 /* get function: x of class  meshio::Quaternion */
5160 #ifndef TOLUA_DISABLE_tolua_get_meshio__Quaternion_x
5161 static int tolua_get_meshio__Quaternion_x(lua_State* tolua_S)
5162 {
5163   meshio::Quaternion* self = (meshio::Quaternion*)  tolua_tousertype(tolua_S,1,0);
5164 #ifndef TOLUA_RELEASE
5165   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'x'",NULL);
5166 #endif
5167   tolua_pushnumber(tolua_S,(lua_Number)self->x);
5168  return 1;
5169 }
5170 #endif //#ifndef TOLUA_DISABLE
5171
5172 /* set function: x of class  meshio::Quaternion */
5173 #ifndef TOLUA_DISABLE_tolua_set_meshio__Quaternion_x
5174 static int tolua_set_meshio__Quaternion_x(lua_State* tolua_S)
5175 {
5176   meshio::Quaternion* self = (meshio::Quaternion*)  tolua_tousertype(tolua_S,1,0);
5177 #ifndef TOLUA_RELEASE
5178   tolua_Error tolua_err;
5179   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'x'",NULL);
5180   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
5181    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
5182 #endif
5183   self->x = ((float)  tolua_tonumber(tolua_S,2,0))
5184 ;
5185  return 0;
5186 }
5187 #endif //#ifndef TOLUA_DISABLE
5188
5189 /* get function: y of class  meshio::Quaternion */
5190 #ifndef TOLUA_DISABLE_tolua_get_meshio__Quaternion_y
5191 static int tolua_get_meshio__Quaternion_y(lua_State* tolua_S)
5192 {
5193   meshio::Quaternion* self = (meshio::Quaternion*)  tolua_tousertype(tolua_S,1,0);
5194 #ifndef TOLUA_RELEASE
5195   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'y'",NULL);
5196 #endif
5197   tolua_pushnumber(tolua_S,(lua_Number)self->y);
5198  return 1;
5199 }
5200 #endif //#ifndef TOLUA_DISABLE
5201
5202 /* set function: y of class  meshio::Quaternion */
5203 #ifndef TOLUA_DISABLE_tolua_set_meshio__Quaternion_y
5204 static int tolua_set_meshio__Quaternion_y(lua_State* tolua_S)
5205 {
5206   meshio::Quaternion* self = (meshio::Quaternion*)  tolua_tousertype(tolua_S,1,0);
5207 #ifndef TOLUA_RELEASE
5208   tolua_Error tolua_err;
5209   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'y'",NULL);
5210   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
5211    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
5212 #endif
5213   self->y = ((float)  tolua_tonumber(tolua_S,2,0))
5214 ;
5215  return 0;
5216 }
5217 #endif //#ifndef TOLUA_DISABLE
5218
5219 /* get function: z of class  meshio::Quaternion */
5220 #ifndef TOLUA_DISABLE_tolua_get_meshio__Quaternion_z
5221 static int tolua_get_meshio__Quaternion_z(lua_State* tolua_S)
5222 {
5223   meshio::Quaternion* self = (meshio::Quaternion*)  tolua_tousertype(tolua_S,1,0);
5224 #ifndef TOLUA_RELEASE
5225   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'z'",NULL);
5226 #endif
5227   tolua_pushnumber(tolua_S,(lua_Number)self->z);
5228  return 1;
5229 }
5230 #endif //#ifndef TOLUA_DISABLE
5231
5232 /* set function: z of class  meshio::Quaternion */
5233 #ifndef TOLUA_DISABLE_tolua_set_meshio__Quaternion_z
5234 static int tolua_set_meshio__Quaternion_z(lua_State* tolua_S)
5235 {
5236   meshio::Quaternion* self = (meshio::Quaternion*)  tolua_tousertype(tolua_S,1,0);
5237 #ifndef TOLUA_RELEASE
5238   tolua_Error tolua_err;
5239   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'z'",NULL);
5240   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
5241    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
5242 #endif
5243   self->z = ((float)  tolua_tonumber(tolua_S,2,0))
5244 ;
5245  return 0;
5246 }
5247 #endif //#ifndef TOLUA_DISABLE
5248
5249 /* get function: w of class  meshio::Quaternion */
5250 #ifndef TOLUA_DISABLE_tolua_get_meshio__Quaternion_w
5251 static int tolua_get_meshio__Quaternion_w(lua_State* tolua_S)
5252 {
5253   meshio::Quaternion* self = (meshio::Quaternion*)  tolua_tousertype(tolua_S,1,0);
5254 #ifndef TOLUA_RELEASE
5255   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'w'",NULL);
5256 #endif
5257   tolua_pushnumber(tolua_S,(lua_Number)self->w);
5258  return 1;
5259 }
5260 #endif //#ifndef TOLUA_DISABLE
5261
5262 /* set function: w of class  meshio::Quaternion */
5263 #ifndef TOLUA_DISABLE_tolua_set_meshio__Quaternion_w
5264 static int tolua_set_meshio__Quaternion_w(lua_State* tolua_S)
5265 {
5266   meshio::Quaternion* self = (meshio::Quaternion*)  tolua_tousertype(tolua_S,1,0);
5267 #ifndef TOLUA_RELEASE
5268   tolua_Error tolua_err;
5269   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'w'",NULL);
5270   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
5271    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
5272 #endif
5273   self->w = ((float)  tolua_tonumber(tolua_S,2,0))
5274 ;
5275  return 0;
5276 }
5277 #endif //#ifndef TOLUA_DISABLE
5278
5279 /* method: new of class  meshio::Quaternion */
5280 #ifndef TOLUA_DISABLE_tolua_lmeshio_meshio_Quaternion_new00
5281 static int tolua_lmeshio_meshio_Quaternion_new00(lua_State* tolua_S)
5282 {
5283 #ifndef TOLUA_RELEASE
5284  tolua_Error tolua_err;
5285  if (
5286      !tolua_isusertable(tolua_S,1,"meshio::Quaternion",0,&tolua_err) ||
5287      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
5288      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
5289      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
5290      !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
5291      !tolua_isnoobj(tolua_S,6,&tolua_err)
5292  )
5293   goto tolua_lerror;
5294  else
5295 #endif
5296  {
5297
5298   float _x = ((float)  tolua_tonumber(tolua_S,2,0));
5299   float _y = ((float)  tolua_tonumber(tolua_S,3,0));
5300   float _z = ((float)  tolua_tonumber(tolua_S,4,0));
5301   float _w = ((float)  tolua_tonumber(tolua_S,5,0));
5302
5303   {
5304    meshio::Quaternion* tolua_ret = (meshio::Quaternion*)  Mtolua_new((meshio::Quaternion)(_x,_y,_z,_w));
5305     tolua_pushusertype(tolua_S,(void*)tolua_ret,"meshio::Quaternion");
5306
5307
5308
5309
5310   }
5311
5312  }
5313  return 1;
5314 #ifndef TOLUA_RELEASE
5315  tolua_lerror:
5316  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
5317  return 0;
5318 #endif
5319 }
5320 #endif //#ifndef TOLUA_DISABLE
5321
5322 /* method: new_local of class  meshio::Quaternion */
5323 #ifndef TOLUA_DISABLE_tolua_lmeshio_meshio_Quaternion_new00_local
5324 static int tolua_lmeshio_meshio_Quaternion_new00_local(lua_State* tolua_S)
5325 {
5326 #ifndef TOLUA_RELEASE
5327  tolua_Error tolua_err;
5328  if (
5329      !tolua_isusertable(tolua_S,1,"meshio::Quaternion",0,&tolua_err) ||
5330      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
5331      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
5332      !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
5333      !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
5334      !tolua_isnoobj(tolua_S,6,&tolua_err)
5335  )
5336   goto tolua_lerror;
5337  else
5338 #endif
5339  {
5340
5341   float _x = ((float)  tolua_tonumber(tolua_S,2,0));
5342   float _y = ((float)  tolua_tonumber(tolua_S,3,0));
5343   float _z = ((float)  tolua_tonumber(tolua_S,4,0));
5344   float _w = ((float)  tolua_tonumber(tolua_S,5,0));
5345
5346   {
5347    meshio::Quaternion* tolua_ret = (meshio::Quaternion*)  Mtolua_new((meshio::Quaternion)(_x,_y,_z,_w));
5348     tolua_pushusertype(tolua_S,(void*)tolua_ret,"meshio::Quaternion");
5349     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
5350
5351
5352
5353
5354   }
5355
5356  }
5357  return 1;
5358 #ifndef TOLUA_RELEASE
5359  tolua_lerror:
5360  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
5361  return 0;
5362 #endif
5363 }
5364 #endif //#ifndef TOLUA_DISABLE
5365
5366 /* method: dot of class  meshio::Quaternion */
5367 #ifndef TOLUA_DISABLE_tolua_lmeshio_meshio_Quaternion_dot00
5368 static int tolua_lmeshio_meshio_Quaternion_dot00(lua_State* tolua_S)
5369 {
5370 #ifndef TOLUA_RELEASE
5371  tolua_Error tolua_err;
5372  if (
5373      !tolua_isusertype(tolua_S,1,"meshio::Quaternion",0,&tolua_err) ||
5374      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const meshio::Quaternion",0,&tolua_err)) ||
5375      !tolua_isnoobj(tolua_S,3,&tolua_err)
5376  )
5377   goto tolua_lerror;
5378  else
5379 #endif
5380  {
5381   meshio::Quaternion* self = (meshio::Quaternion*)  tolua_tousertype(tolua_S,1,0);
5382   const meshio::Quaternion* rhs = ((const meshio::Quaternion*)  tolua_tousertype(tolua_S,2,0));
5383 #ifndef TOLUA_RELEASE
5384   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'dot'", NULL);
5385 #endif
5386   {
5387    float tolua_ret = (float)  self->dot(*rhs);
5388    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
5389
5390   }
5391
5392  }
5393  return 1;
5394 #ifndef TOLUA_RELEASE
5395  tolua_lerror:
5396  tolua_error(tolua_S,"#ferror in function 'dot'.",&tolua_err);
5397  return 0;
5398 #endif
5399 }
5400 #endif //#ifndef TOLUA_DISABLE
5401
5402 /* get function: r of class  meshio::fRGBA */
5403 #ifndef TOLUA_DISABLE_tolua_get_meshio__fRGBA_r
5404 static int tolua_get_meshio__fRGBA_r(lua_State* tolua_S)
5405 {
5406   meshio::fRGBA* self = (meshio::fRGBA*)  tolua_tousertype(tolua_S,1,0);
5407 #ifndef TOLUA_RELEASE
5408   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'r'",NULL);
5409 #endif
5410   tolua_pushnumber(tolua_S,(lua_Number)self->r);
5411  return 1;
5412 }
5413 #endif //#ifndef TOLUA_DISABLE
5414
5415 /* set function: r of class  meshio::fRGBA */
5416 #ifndef TOLUA_DISABLE_tolua_set_meshio__fRGBA_r
5417 static int tolua_set_meshio__fRGBA_r(lua_State* tolua_S)
5418 {
5419   meshio::fRGBA* self = (meshio::fRGBA*)  tolua_tousertype(tolua_S,1,0);
5420 #ifndef TOLUA_RELEASE
5421   tolua_Error tolua_err;
5422   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'r'",NULL);
5423   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
5424    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
5425 #endif
5426   self->r = ((float)  tolua_tonumber(tolua_S,2,0))
5427 ;
5428  return 0;
5429 }
5430 #endif //#ifndef TOLUA_DISABLE
5431
5432 /* get function: g of class  meshio::fRGBA */
5433 #ifndef TOLUA_DISABLE_tolua_get_meshio__fRGBA_g
5434 static int tolua_get_meshio__fRGBA_g(lua_State* tolua_S)
5435 {
5436   meshio::fRGBA* self = (meshio::fRGBA*)  tolua_tousertype(tolua_S,1,0);
5437 #ifndef TOLUA_RELEASE
5438   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'g'",NULL);
5439 #endif
5440   tolua_pushnumber(tolua_S,(lua_Number)self->g);
5441  return 1;
5442 }
5443 #endif //#ifndef TOLUA_DISABLE
5444
5445 /* set function: g of class  meshio::fRGBA */
5446 #ifndef TOLUA_DISABLE_tolua_set_meshio__fRGBA_g
5447 static int tolua_set_meshio__fRGBA_g(lua_State* tolua_S)
5448 {
5449   meshio::fRGBA* self = (meshio::fRGBA*)  tolua_tousertype(tolua_S,1,0);
5450 #ifndef TOLUA_RELEASE
5451   tolua_Error tolua_err;
5452   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'g'",NULL);
5453   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
5454    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
5455 #endif
5456   self->g = ((float)  tolua_tonumber(tolua_S,2,0))
5457 ;
5458  return 0;
5459 }
5460 #endif //#ifndef TOLUA_DISABLE
5461
5462 /* get function: b of class  meshio::fRGBA */
5463 #ifndef TOLUA_DISABLE_tolua_get_meshio__fRGBA_b
5464 static int tolua_get_meshio__fRGBA_b(lua_State* tolua_S)
5465 {
5466   meshio::fRGBA* self = (meshio::fRGBA*)  tolua_tousertype(tolua_S,1,0);
5467 #ifndef TOLUA_RELEASE
5468   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'b'",NULL);
5469 #endif
5470   tolua_pushnumber(tolua_S,(lua_Number)self->b);
5471  return 1;
5472 }
5473 #endif //#ifndef TOLUA_DISABLE
5474
5475 /* set function: b of class  meshio::fRGBA */
5476 #ifndef TOLUA_DISABLE_tolua_set_meshio__fRGBA_b
5477 static int tolua_set_meshio__fRGBA_b(lua_State* tolua_S)
5478 {
5479   meshio::fRGBA* self = (meshio::fRGBA*)  tolua_tousertype(tolua_S,1,0);
5480 #ifndef TOLUA_RELEASE
5481   tolua_Error tolua_err;
5482   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'b'",NULL);
5483   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
5484    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
5485 #endif
5486   self->b = ((float)  tolua_tonumber(tolua_S,2,0))
5487 ;
5488  return 0;
5489 }
5490 #endif //#ifndef TOLUA_DISABLE
5491
5492 /* get function: a of class  meshio::fRGBA */
5493 #ifndef TOLUA_DISABLE_tolua_get_meshio__fRGBA_a
5494 static int tolua_get_meshio__fRGBA_a(lua_State* tolua_S)
5495 {
5496   meshio::fRGBA* self = (meshio::fRGBA*)  tolua_tousertype(tolua_S,1,0);
5497 #ifndef TOLUA_RELEASE
5498   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'a'",NULL);
5499 #endif
5500   tolua_pushnumber(tolua_S,(lua_Number)self->a);
5501  return 1;
5502 }
5503 #endif //#ifndef TOLUA_DISABLE
5504
5505 /* set function: a of class  meshio::fRGBA */
5506 #ifndef TOLUA_DISABLE_tolua_set_meshio__fRGBA_a
5507 static int tolua_set_meshio__fRGBA_a(lua_State* tolua_S)
5508 {
5509   meshio::fRGBA* self = (meshio::fRGBA*)  tolua_tousertype(tolua_S,1,0);
5510 #ifndef TOLUA_RELEASE
5511   tolua_Error tolua_err;
5512   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'a'",NULL);
5513   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
5514    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
5515 #endif
5516   self->a = ((float)  tolua_tonumber(tolua_S,2,0))
5517 ;
5518  return 0;
5519 }
5520 #endif //#ifndef TOLUA_DISABLE
5521
5522 /* method: str of class  meshio::fixed_string<20> */
5523 #ifndef TOLUA_DISABLE_tolua_lmeshio_meshio_fixed_string_20__str00
5524 static int tolua_lmeshio_meshio_fixed_string_20__str00(lua_State* tolua_S)
5525 {
5526 #ifndef TOLUA_RELEASE
5527  tolua_Error tolua_err;
5528  if (
5529      !tolua_isusertype(tolua_S,1,"const meshio::fixed_string<20>",0,&tolua_err) ||
5530      !tolua_isnoobj(tolua_S,2,&tolua_err)
5531  )
5532   goto tolua_lerror;
5533  else
5534 #endif
5535  {
5536   const meshio::fixed_string<20>* self = (const meshio::fixed_string<20>*)  tolua_tousertype(tolua_S,1,0);
5537 #ifndef TOLUA_RELEASE
5538   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'str'", NULL);
5539 #endif
5540   {
5541    std::string tolua_ret = (std::string)  self->str();
5542    tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
5543   }
5544
5545  }
5546  return 1;
5547 #ifndef TOLUA_RELEASE
5548  tolua_lerror:
5549  tolua_error(tolua_S,"#ferror in function 'str'.",&tolua_err);
5550  return 0;
5551 #endif
5552 }
5553 #endif //#ifndef TOLUA_DISABLE
5554
5555 /* method: assign of class  meshio::fixed_string<20> */
5556 #ifndef TOLUA_DISABLE_tolua_lmeshio_meshio_fixed_string_20__assign00
5557 static int tolua_lmeshio_meshio_fixed_string_20__assign00(lua_State* tolua_S)
5558 {
5559 #ifndef TOLUA_RELEASE
5560  tolua_Error tolua_err;
5561  if (
5562      !tolua_isusertype(tolua_S,1,"meshio::fixed_string<20>",0,&tolua_err) ||
5563      !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
5564      !tolua_isnoobj(tolua_S,3,&tolua_err)
5565  )
5566   goto tolua_lerror;
5567  else
5568 #endif
5569  {
5570   meshio::fixed_string<20>* self = (meshio::fixed_string<20>*)  tolua_tousertype(tolua_S,1,0);
5571   const std::string src = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
5572 #ifndef TOLUA_RELEASE
5573   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'assign'", NULL);
5574 #endif
5575   {
5576    self->assign(src);
5577    tolua_pushcppstring(tolua_S,(const char*)src);
5578   }
5579
5580  }
5581  return 1;
5582 #ifndef TOLUA_RELEASE
5583  tolua_lerror:
5584  tolua_error(tolua_S,"#ferror in function 'assign'.",&tolua_err);
5585  return 0;
5586 #endif
5587 }
5588 #endif //#ifndef TOLUA_DISABLE
5589
5590 /* method: str of class  meshio::fixed_string<50> */
5591 #ifndef TOLUA_DISABLE_tolua_lmeshio_meshio_fixed_string_50__str00
5592 static int tolua_lmeshio_meshio_fixed_string_50__str00(lua_State* tolua_S)
5593 {
5594 #ifndef TOLUA_RELEASE
5595  tolua_Error tolua_err;
5596  if (
5597      !tolua_isusertype(tolua_S,1,"const meshio::fixed_string<50>",0,&tolua_err) ||
5598      !tolua_isnoobj(tolua_S,2,&tolua_err)
5599  )
5600   goto tolua_lerror;
5601  else
5602 #endif
5603  {
5604   const meshio::fixed_string<50>* self = (const meshio::fixed_string<50>*)  tolua_tousertype(tolua_S,1,0);
5605 #ifndef TOLUA_RELEASE
5606   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'str'", NULL);
5607 #endif
5608   {
5609    std::string tolua_ret = (std::string)  self->str();
5610    tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
5611   }
5612
5613  }
5614  return 1;
5615 #ifndef TOLUA_RELEASE
5616  tolua_lerror:
5617  tolua_error(tolua_S,"#ferror in function 'str'.",&tolua_err);
5618  return 0;
5619 #endif
5620 }
5621 #endif //#ifndef TOLUA_DISABLE
5622
5623 /* method: assign of class  meshio::fixed_string<50> */
5624 #ifndef TOLUA_DISABLE_tolua_lmeshio_meshio_fixed_string_50__assign00
5625 static int tolua_lmeshio_meshio_fixed_string_50__assign00(lua_State* tolua_S)
5626 {
5627 #ifndef TOLUA_RELEASE
5628  tolua_Error tolua_err;
5629  if (
5630      !tolua_isusertype(tolua_S,1,"meshio::fixed_string<50>",0,&tolua_err) ||
5631      !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
5632      !tolua_isnoobj(tolua_S,3,&tolua_err)
5633  )
5634   goto tolua_lerror;
5635  else
5636 #endif
5637  {
5638   meshio::fixed_string<50>* self = (meshio::fixed_string<50>*)  tolua_tousertype(tolua_S,1,0);
5639   const std::string src = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
5640 #ifndef TOLUA_RELEASE
5641   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'assign'", NULL);
5642 #endif
5643   {
5644    self->assign(src);
5645    tolua_pushcppstring(tolua_S,(const char*)src);
5646   }
5647
5648  }
5649  return 1;
5650 #ifndef TOLUA_RELEASE
5651  tolua_lerror:
5652  tolua_error(tolua_S,"#ferror in function 'assign'.",&tolua_err);
5653  return 0;
5654 #endif
5655 }
5656 #endif //#ifndef TOLUA_DISABLE
5657
5658 /* method: str of class  meshio::fixed_string<100> */
5659 #ifndef TOLUA_DISABLE_tolua_lmeshio_meshio_fixed_string_100__str00
5660 static int tolua_lmeshio_meshio_fixed_string_100__str00(lua_State* tolua_S)
5661 {
5662 #ifndef TOLUA_RELEASE
5663  tolua_Error tolua_err;
5664  if (
5665      !tolua_isusertype(tolua_S,1,"const meshio::fixed_string<100>",0,&tolua_err) ||
5666      !tolua_isnoobj(tolua_S,2,&tolua_err)
5667  )
5668   goto tolua_lerror;
5669  else
5670 #endif
5671  {
5672   const meshio::fixed_string<100>* self = (const meshio::fixed_string<100>*)  tolua_tousertype(tolua_S,1,0);
5673 #ifndef TOLUA_RELEASE
5674   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'str'", NULL);
5675 #endif
5676   {
5677    std::string tolua_ret = (std::string)  self->str();
5678    tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
5679   }
5680
5681  }
5682  return 1;
5683 #ifndef TOLUA_RELEASE
5684  tolua_lerror:
5685  tolua_error(tolua_S,"#ferror in function 'str'.",&tolua_err);
5686  return 0;
5687 #endif
5688 }
5689 #endif //#ifndef TOLUA_DISABLE
5690
5691 /* method: assign of class  meshio::fixed_string<100> */
5692 #ifndef TOLUA_DISABLE_tolua_lmeshio_meshio_fixed_string_100__assign00
5693 static int tolua_lmeshio_meshio_fixed_string_100__assign00(lua_State* tolua_S)
5694 {
5695 #ifndef TOLUA_RELEASE
5696  tolua_Error tolua_err;
5697  if (
5698      !tolua_isusertype(tolua_S,1,"meshio::fixed_string<100>",0,&tolua_err) ||
5699      !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
5700      !tolua_isnoobj(tolua_S,3,&tolua_err)
5701  )
5702   goto tolua_lerror;
5703  else
5704 #endif
5705  {
5706   meshio::fixed_string<100>* self = (meshio::fixed_string<100>*)  tolua_tousertype(tolua_S,1,0);
5707   const std::string src = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
5708 #ifndef TOLUA_RELEASE
5709   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'assign'", NULL);
5710 #endif
5711   {
5712    self->assign(src);
5713    tolua_pushcppstring(tolua_S,(const char*)src);
5714   }
5715
5716  }
5717  return 1;
5718 #ifndef TOLUA_RELEASE
5719  tolua_lerror:
5720  tolua_error(tolua_S,"#ferror in function 'assign'.",&tolua_err);
5721  return 0;
5722 #endif
5723 }
5724 #endif //#ifndef TOLUA_DISABLE
5725
5726 /* method: str of class  meshio::fixed_string<256> */
5727 #ifndef TOLUA_DISABLE_tolua_lmeshio_meshio_fixed_string_256__str00
5728 static int tolua_lmeshio_meshio_fixed_string_256__str00(lua_State* tolua_S)
5729 {
5730 #ifndef TOLUA_RELEASE
5731  tolua_Error tolua_err;
5732  if (
5733      !tolua_isusertype(tolua_S,1,"const meshio::fixed_string<256>",0,&tolua_err) ||
5734      !tolua_isnoobj(tolua_S,2,&tolua_err)
5735  )
5736   goto tolua_lerror;
5737  else
5738 #endif
5739  {
5740   const meshio::fixed_string<256>* self = (const meshio::fixed_string<256>*)  tolua_tousertype(tolua_S,1,0);
5741 #ifndef TOLUA_RELEASE
5742   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'str'", NULL);
5743 #endif
5744   {
5745    std::string tolua_ret = (std::string)  self->str();
5746    tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
5747   }
5748
5749  }
5750  return 1;
5751 #ifndef TOLUA_RELEASE
5752  tolua_lerror:
5753  tolua_error(tolua_S,"#ferror in function 'str'.",&tolua_err);
5754  return 0;
5755 #endif
5756 }
5757 #endif //#ifndef TOLUA_DISABLE
5758
5759 /* method: assign of class  meshio::fixed_string<256> */
5760 #ifndef TOLUA_DISABLE_tolua_lmeshio_meshio_fixed_string_256__assign00
5761 static int tolua_lmeshio_meshio_fixed_string_256__assign00(lua_State* tolua_S)
5762 {
5763 #ifndef TOLUA_RELEASE
5764  tolua_Error tolua_err;
5765  if (
5766      !tolua_isusertype(tolua_S,1,"meshio::fixed_string<256>",0,&tolua_err) ||
5767      !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
5768      !tolua_isnoobj(tolua_S,3,&tolua_err)
5769  )
5770   goto tolua_lerror;
5771  else
5772 #endif
5773  {
5774   meshio::fixed_string<256>* self = (meshio::fixed_string<256>*)  tolua_tousertype(tolua_S,1,0);
5775   const std::string src = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
5776 #ifndef TOLUA_RELEASE
5777   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'assign'", NULL);
5778 #endif
5779   {
5780    self->assign(src);
5781    tolua_pushcppstring(tolua_S,(const char*)src);
5782   }
5783
5784  }
5785  return 1;
5786 #ifndef TOLUA_RELEASE
5787  tolua_lerror:
5788  tolua_error(tolua_S,"#ferror in function 'assign'.",&tolua_err);
5789  return 0;
5790 #endif
5791 }
5792 #endif //#ifndef TOLUA_DISABLE
5793
5794 /* method: new of class  std::vector<meshio::pmd::Bone*> */
5795 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Bone___new00
5796 static int tolua_lmeshio_std_vector_meshio__pmd__Bone___new00(lua_State* tolua_S)
5797 {
5798 #ifndef TOLUA_RELEASE
5799  tolua_Error tolua_err;
5800  if (
5801      !tolua_isusertable(tolua_S,1,"std::vector<meshio::pmd::Bone*>",0,&tolua_err) ||
5802      !tolua_isnoobj(tolua_S,2,&tolua_err)
5803  )
5804   goto tolua_lerror;
5805  else
5806 #endif
5807  {
5808
5809
5810   {
5811    std::vector<meshio::pmd::Bone>* tolua_ret = (std::vector<meshio::pmd::Bone>*)  Mtolua_new((std::vector<meshio::pmd::Bone>)());
5812     tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<meshio::pmd::Bone>");
5813   }
5814
5815  }
5816  return 1;
5817 #ifndef TOLUA_RELEASE
5818  tolua_lerror:
5819  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
5820  return 0;
5821 #endif
5822 }
5823 #endif //#ifndef TOLUA_DISABLE
5824
5825 /* method: new_local of class  std::vector<meshio::pmd::Bone*> */
5826 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Bone___new00_local
5827 static int tolua_lmeshio_std_vector_meshio__pmd__Bone___new00_local(lua_State* tolua_S)
5828 {
5829 #ifndef TOLUA_RELEASE
5830  tolua_Error tolua_err;
5831  if (
5832      !tolua_isusertable(tolua_S,1,"std::vector<meshio::pmd::Bone*>",0,&tolua_err) ||
5833      !tolua_isnoobj(tolua_S,2,&tolua_err)
5834  )
5835   goto tolua_lerror;
5836  else
5837 #endif
5838  {
5839
5840
5841   {
5842    std::vector<meshio::pmd::Bone>* tolua_ret = (std::vector<meshio::pmd::Bone>*)  Mtolua_new((std::vector<meshio::pmd::Bone>)());
5843     tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<meshio::pmd::Bone>");
5844     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
5845   }
5846
5847  }
5848  return 1;
5849 #ifndef TOLUA_RELEASE
5850  tolua_lerror:
5851  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
5852  return 0;
5853 #endif
5854 }
5855 #endif //#ifndef TOLUA_DISABLE
5856
5857 /* method: size of class  std::vector<meshio::pmd::Bone*> */
5858 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Bone___size00
5859 static int tolua_lmeshio_std_vector_meshio__pmd__Bone___size00(lua_State* tolua_S)
5860 {
5861 #ifndef TOLUA_RELEASE
5862  tolua_Error tolua_err;
5863  if (
5864      !tolua_isusertype(tolua_S,1,"const std::vector<meshio::pmd::Bone*>",0,&tolua_err) ||
5865      !tolua_isnoobj(tolua_S,2,&tolua_err)
5866  )
5867   goto tolua_lerror;
5868  else
5869 #endif
5870  {
5871   const std::vector<meshio::pmd::Bone*>* self = (const std::vector<meshio::pmd::Bone*>*)  tolua_tousertype(tolua_S,1,0);
5872 #ifndef TOLUA_RELEASE
5873   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
5874 #endif
5875   {
5876    unsigned int tolua_ret = (unsigned int)  self->size();
5877    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
5878   }
5879
5880  }
5881  return 1;
5882 #ifndef TOLUA_RELEASE
5883  tolua_lerror:
5884  tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
5885  return 0;
5886 #endif
5887 }
5888 #endif //#ifndef TOLUA_DISABLE
5889
5890 /* method: push_back of class  std::vector<meshio::pmd::Bone*> */
5891 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Bone___push_back00
5892 static int tolua_lmeshio_std_vector_meshio__pmd__Bone___push_back00(lua_State* tolua_S)
5893 {
5894 #ifndef TOLUA_RELEASE
5895  tolua_Error tolua_err;
5896  if (
5897      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::Bone*>",0,&tolua_err) ||
5898      !tolua_isusertype(tolua_S,2,"meshio::pmd::Bone",0,&tolua_err) ||
5899      !tolua_isnoobj(tolua_S,3,&tolua_err)
5900  )
5901   goto tolua_lerror;
5902  else
5903 #endif
5904  {
5905   std::vector<meshio::pmd::Bone*>* self = (std::vector<meshio::pmd::Bone*>*)  tolua_tousertype(tolua_S,1,0);
5906   meshio::pmd::Bone* value = ((meshio::pmd::Bone*)  tolua_tousertype(tolua_S,2,0));
5907 #ifndef TOLUA_RELEASE
5908   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
5909 #endif
5910   {
5911    self->push_back(value);
5912    tolua_pushusertype(tolua_S,(void*)value,"meshio::pmd::Bone");
5913   }
5914
5915  }
5916  return 1;
5917 #ifndef TOLUA_RELEASE
5918  tolua_lerror:
5919  tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
5920  return 0;
5921 #endif
5922 }
5923 #endif //#ifndef TOLUA_DISABLE
5924
5925 /* method: back of class  std::vector<meshio::pmd::Bone*> */
5926 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Bone___back00
5927 static int tolua_lmeshio_std_vector_meshio__pmd__Bone___back00(lua_State* tolua_S)
5928 {
5929 #ifndef TOLUA_RELEASE
5930  tolua_Error tolua_err;
5931  if (
5932      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::Bone*>",0,&tolua_err) ||
5933      !tolua_isnoobj(tolua_S,2,&tolua_err)
5934  )
5935   goto tolua_lerror;
5936  else
5937 #endif
5938  {
5939   std::vector<meshio::pmd::Bone*>* self = (std::vector<meshio::pmd::Bone*>*)  tolua_tousertype(tolua_S,1,0);
5940 #ifndef TOLUA_RELEASE
5941   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'back'", NULL);
5942 #endif
5943   {
5944    meshio::pmd::Bone*& tolua_ret = (meshio::pmd::Bone*&)  self->back();
5945     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::pmd::Bone*");
5946   }
5947
5948  }
5949  return 1;
5950 #ifndef TOLUA_RELEASE
5951  tolua_lerror:
5952  tolua_error(tolua_S,"#ferror in function 'back'.",&tolua_err);
5953  return 0;
5954 #endif
5955 }
5956 #endif //#ifndef TOLUA_DISABLE
5957
5958 /* method: operator[] of class  std::vector<meshio::pmd::Bone*> */
5959 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Bone____geti00
5960 static int tolua_lmeshio_std_vector_meshio__pmd__Bone____geti00(lua_State* tolua_S)
5961 {
5962 #ifndef TOLUA_RELEASE
5963  tolua_Error tolua_err;
5964  if (
5965      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::Bone*>",0,&tolua_err) ||
5966      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
5967      !tolua_isnoobj(tolua_S,3,&tolua_err)
5968  )
5969   goto tolua_lerror;
5970  else
5971 #endif
5972  {
5973   std::vector<meshio::pmd::Bone*>* self = (std::vector<meshio::pmd::Bone*>*)  tolua_tousertype(tolua_S,1,0);
5974   int index = ((int)  tolua_tonumber(tolua_S,2,0));
5975 #ifndef TOLUA_RELEASE
5976   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
5977 #endif
5978   {
5979    meshio::pmd::Bone*& tolua_ret = (meshio::pmd::Bone*&)  self->operator[](index);
5980     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::pmd::Bone*");
5981
5982   }
5983
5984  }
5985  return 1;
5986 #ifndef TOLUA_RELEASE
5987  tolua_lerror:
5988  tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
5989  return 0;
5990 #endif
5991 }
5992 #endif //#ifndef TOLUA_DISABLE
5993
5994 /* method: operator&[] of class  std::vector<meshio::pmd::Bone*> */
5995 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Bone____seti00
5996 static int tolua_lmeshio_std_vector_meshio__pmd__Bone____seti00(lua_State* tolua_S)
5997 {
5998 #ifndef TOLUA_RELEASE
5999  tolua_Error tolua_err;
6000  if (
6001      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::Bone*>",0,&tolua_err) ||
6002      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
6003      !tolua_isusertype(tolua_S,3,"meshio::pmd::Bone",0,&tolua_err) ||
6004      !tolua_isnoobj(tolua_S,4,&tolua_err)
6005  )
6006   goto tolua_lerror;
6007  else
6008 #endif
6009  {
6010   std::vector<meshio::pmd::Bone*>* self = (std::vector<meshio::pmd::Bone*>*)  tolua_tousertype(tolua_S,1,0);
6011   int index = ((int)  tolua_tonumber(tolua_S,2,0));
6012   meshio::pmd::Bone* tolua_value = ((meshio::pmd::Bone*)  tolua_tousertype(tolua_S,3,0));
6013 #ifndef TOLUA_RELEASE
6014   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
6015 #endif
6016   self->operator[](index) =  tolua_value;
6017  }
6018  return 0;
6019 #ifndef TOLUA_RELEASE
6020  tolua_lerror:
6021  tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
6022  return 0;
6023 #endif
6024 }
6025 #endif //#ifndef TOLUA_DISABLE
6026
6027 /* stl foreachi: class  std::vector<meshio::pmd::Bone*> */
6028 #ifndef TOLUA_DISABLE_tolua_lmeshio_std__vector_meshio__pmd__Bone___iterator
6029 static int tolua_lmeshio_std__vector_meshio__pmd__Bone___iterator_gc(lua_State* tolua_S)
6030 {
6031     //printf("tolua_lmeshio_std__vector_meshio__pmd__Bone___iterator_gc\n");
6032     std::pair<std::vector<meshio::pmd::Bone*>::iterator, std::vector<meshio::pmd::Bone*>::iterator> *range=(std::pair<std::vector<meshio::pmd::Bone*>::iterator, std::vector<meshio::pmd::Bone*>::iterator>*)lua_touserdata(tolua_S, 1);
6033     range->~pair<std::vector<meshio::pmd::Bone*>::iterator, std::vector<meshio::pmd::Bone*>::iterator>();
6034     return 0;
6035 }
6036
6037 static int tolua_lmeshio_std__vector_meshio__pmd__Bone___iterator_internal(lua_State* tolua_S)
6038 {
6039   std::pair<std::vector<meshio::pmd::Bone*>::iterator, std::vector<meshio::pmd::Bone*>::iterator> *range=(std::pair<std::vector<meshio::pmd::Bone*>::iterator, std::vector<meshio::pmd::Bone*>::iterator>*)lua_touserdata(tolua_S, lua_upvalueindex(1));
6040   if(range->first==range->second){
6041       return 0;
6042   }
6043   int index=lua_tonumber(tolua_S, lua_upvalueindex(2));
6044   tolua_pushnumber(tolua_S, index);
6045   // update index
6046   tolua_pushnumber(tolua_S, index+1);
6047   lua_replace(tolua_S, lua_upvalueindex(2));
6048
6049   //tolua_pushusertype(tolua_S, &(*range->first++), "meshio::pmd::Bone*");
6050    meshio::pmd::Bone*& tolua_ret = (meshio::pmd::Bone*&) *range->first++;
6051     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::pmd::Bone*");
6052
6053   return 2;
6054 }
6055
6056 static int tolua_lmeshio_std__vector_meshio__pmd__Bone___iterator(lua_State* tolua_S)
6057 {
6058 #ifndef TOLUA_RELEASE
6059  tolua_Error tolua_err;
6060  if (
6061      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::Bone*>",0,&tolua_err) ||
6062      !tolua_isnoobj(tolua_S,2,&tolua_err)
6063  )
6064   goto tolua_lerror;
6065  else
6066 #endif
6067  {
6068   std::vector<meshio::pmd::Bone*>* self = (std::vector<meshio::pmd::Bone*>*)  tolua_tousertype(tolua_S,1,0);
6069 #ifndef TOLUA_RELEASE
6070   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'foreachi'", NULL);
6071 #endif
6072   {
6073     std::pair<std::vector<meshio::pmd::Bone*>::iterator, std::vector<meshio::pmd::Bone*>::iterator>* range=(std::pair<std::vector<meshio::pmd::Bone*>::iterator, std::vector<meshio::pmd::Bone*>::iterator>*)lua_newuserdata(tolua_S, sizeof(std::pair<std::vector<meshio::pmd::Bone*>::iterator, std::vector<meshio::pmd::Bone*>::iterator>));
6074     *range=std::make_pair(self->begin(), self->end());
6075     luaL_getmetatable(tolua_S, "std::pair<std::vector<meshio::pmd::Bone*>::iterator, std::vector<meshio::pmd::Bone*>::iterator>");
6076     lua_setmetatable(tolua_S, -2);
6077     lua_pushnumber(tolua_S, 0);
6078     // gc
6079     lua_pushcclosure(tolua_S, tolua_lmeshio_std__vector_meshio__pmd__Bone___iterator_internal, 2);
6080   }
6081  }
6082  return 1;
6083 #ifndef TOLUA_RELEASE
6084  tolua_lerror:
6085  tolua_error(tolua_S,"#ferror in function 'foreachi'.",&tolua_err);
6086  return 0;
6087 #endif
6088 }
6089 #endif //#ifndef TOLUA_DISABLE
6090
6091
6092 /* method: new of class  std::vector<unsigned short> */
6093 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_unsigned_short__new00
6094 static int tolua_lmeshio_std_vector_unsigned_short__new00(lua_State* tolua_S)
6095 {
6096 #ifndef TOLUA_RELEASE
6097  tolua_Error tolua_err;
6098  if (
6099      !tolua_isusertable(tolua_S,1,"std::vector<unsigned short>",0,&tolua_err) ||
6100      !tolua_isnoobj(tolua_S,2,&tolua_err)
6101  )
6102   goto tolua_lerror;
6103  else
6104 #endif
6105  {
6106
6107
6108   {
6109    std::vector<unsigned short>* tolua_ret = (std::vector<unsigned short>*)  Mtolua_new((std::vector<unsigned short>)());
6110     tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<unsigned short>");
6111   }
6112
6113  }
6114  return 1;
6115 #ifndef TOLUA_RELEASE
6116  tolua_lerror:
6117  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
6118  return 0;
6119 #endif
6120 }
6121 #endif //#ifndef TOLUA_DISABLE
6122
6123 /* method: new_local of class  std::vector<unsigned short> */
6124 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_unsigned_short__new00_local
6125 static int tolua_lmeshio_std_vector_unsigned_short__new00_local(lua_State* tolua_S)
6126 {
6127 #ifndef TOLUA_RELEASE
6128  tolua_Error tolua_err;
6129  if (
6130      !tolua_isusertable(tolua_S,1,"std::vector<unsigned short>",0,&tolua_err) ||
6131      !tolua_isnoobj(tolua_S,2,&tolua_err)
6132  )
6133   goto tolua_lerror;
6134  else
6135 #endif
6136  {
6137
6138
6139   {
6140    std::vector<unsigned short>* tolua_ret = (std::vector<unsigned short>*)  Mtolua_new((std::vector<unsigned short>)());
6141     tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<unsigned short>");
6142     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
6143   }
6144
6145  }
6146  return 1;
6147 #ifndef TOLUA_RELEASE
6148  tolua_lerror:
6149  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
6150  return 0;
6151 #endif
6152 }
6153 #endif //#ifndef TOLUA_DISABLE
6154
6155 /* method: size of class  std::vector<unsigned short> */
6156 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_unsigned_short__size00
6157 static int tolua_lmeshio_std_vector_unsigned_short__size00(lua_State* tolua_S)
6158 {
6159 #ifndef TOLUA_RELEASE
6160  tolua_Error tolua_err;
6161  if (
6162      !tolua_isusertype(tolua_S,1,"const std::vector<unsigned short>",0,&tolua_err) ||
6163      !tolua_isnoobj(tolua_S,2,&tolua_err)
6164  )
6165   goto tolua_lerror;
6166  else
6167 #endif
6168  {
6169   const std::vector<unsigned short>* self = (const std::vector<unsigned short>*)  tolua_tousertype(tolua_S,1,0);
6170 #ifndef TOLUA_RELEASE
6171   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
6172 #endif
6173   {
6174    unsigned int tolua_ret = (unsigned int)  self->size();
6175    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
6176   }
6177
6178  }
6179  return 1;
6180 #ifndef TOLUA_RELEASE
6181  tolua_lerror:
6182  tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
6183  return 0;
6184 #endif
6185 }
6186 #endif //#ifndef TOLUA_DISABLE
6187
6188 /* method: push_back of class  std::vector<unsigned short> */
6189 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_unsigned_short__push_back00
6190 static int tolua_lmeshio_std_vector_unsigned_short__push_back00(lua_State* tolua_S)
6191 {
6192 #ifndef TOLUA_RELEASE
6193  tolua_Error tolua_err;
6194  if (
6195      !tolua_isusertype(tolua_S,1,"std::vector<unsigned short>",0,&tolua_err) ||
6196      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
6197      !tolua_isnoobj(tolua_S,3,&tolua_err)
6198  )
6199   goto tolua_lerror;
6200  else
6201 #endif
6202  {
6203   std::vector<unsigned short>* self = (std::vector<unsigned short>*)  tolua_tousertype(tolua_S,1,0);
6204   unsigned short value = ((unsigned short)  tolua_tonumber(tolua_S,2,0));
6205 #ifndef TOLUA_RELEASE
6206   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
6207 #endif
6208   {
6209    self->push_back(value);
6210    tolua_pushnumber(tolua_S,(lua_Number)value);
6211   }
6212
6213  }
6214  return 1;
6215 #ifndef TOLUA_RELEASE
6216  tolua_lerror:
6217  tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
6218  return 0;
6219 #endif
6220 }
6221 #endif //#ifndef TOLUA_DISABLE
6222
6223 /* method: back of class  std::vector<unsigned short> */
6224 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_unsigned_short__back00
6225 static int tolua_lmeshio_std_vector_unsigned_short__back00(lua_State* tolua_S)
6226 {
6227 #ifndef TOLUA_RELEASE
6228  tolua_Error tolua_err;
6229  if (
6230      !tolua_isusertype(tolua_S,1,"std::vector<unsigned short>",0,&tolua_err) ||
6231      !tolua_isnoobj(tolua_S,2,&tolua_err)
6232  )
6233   goto tolua_lerror;
6234  else
6235 #endif
6236  {
6237   std::vector<unsigned short>* self = (std::vector<unsigned short>*)  tolua_tousertype(tolua_S,1,0);
6238 #ifndef TOLUA_RELEASE
6239   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'back'", NULL);
6240 #endif
6241   {
6242    unsigned short& tolua_ret = (unsigned short&)  self->back();
6243    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
6244   }
6245
6246  }
6247  return 1;
6248 #ifndef TOLUA_RELEASE
6249  tolua_lerror:
6250  tolua_error(tolua_S,"#ferror in function 'back'.",&tolua_err);
6251  return 0;
6252 #endif
6253 }
6254 #endif //#ifndef TOLUA_DISABLE
6255
6256 /* method: operator[] of class  std::vector<unsigned short> */
6257 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_unsigned_short___geti00
6258 static int tolua_lmeshio_std_vector_unsigned_short___geti00(lua_State* tolua_S)
6259 {
6260 #ifndef TOLUA_RELEASE
6261  tolua_Error tolua_err;
6262  if (
6263      !tolua_isusertype(tolua_S,1,"std::vector<unsigned short>",0,&tolua_err) ||
6264      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
6265      !tolua_isnoobj(tolua_S,3,&tolua_err)
6266  )
6267   goto tolua_lerror;
6268  else
6269 #endif
6270  {
6271   std::vector<unsigned short>* self = (std::vector<unsigned short>*)  tolua_tousertype(tolua_S,1,0);
6272   int index = ((int)  tolua_tonumber(tolua_S,2,0));
6273 #ifndef TOLUA_RELEASE
6274   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
6275 #endif
6276   {
6277    unsigned short& tolua_ret = (unsigned short&)  self->operator[](index);
6278    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
6279
6280   }
6281
6282  }
6283  return 1;
6284 #ifndef TOLUA_RELEASE
6285  tolua_lerror:
6286  tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
6287  return 0;
6288 #endif
6289 }
6290 #endif //#ifndef TOLUA_DISABLE
6291
6292 /* method: operator&[] of class  std::vector<unsigned short> */
6293 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_unsigned_short___seti00
6294 static int tolua_lmeshio_std_vector_unsigned_short___seti00(lua_State* tolua_S)
6295 {
6296 #ifndef TOLUA_RELEASE
6297  tolua_Error tolua_err;
6298  if (
6299      !tolua_isusertype(tolua_S,1,"std::vector<unsigned short>",0,&tolua_err) ||
6300      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
6301      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
6302      !tolua_isnoobj(tolua_S,4,&tolua_err)
6303  )
6304   goto tolua_lerror;
6305  else
6306 #endif
6307  {
6308   std::vector<unsigned short>* self = (std::vector<unsigned short>*)  tolua_tousertype(tolua_S,1,0);
6309   int index = ((int)  tolua_tonumber(tolua_S,2,0));
6310   unsigned short tolua_value = ((unsigned short)  tolua_tonumber(tolua_S,3,0));
6311 #ifndef TOLUA_RELEASE
6312   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
6313 #endif
6314   self->operator[](index) =  tolua_value;
6315  }
6316  return 0;
6317 #ifndef TOLUA_RELEASE
6318  tolua_lerror:
6319  tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
6320  return 0;
6321 #endif
6322 }
6323 #endif //#ifndef TOLUA_DISABLE
6324
6325 /* stl foreachi: class  std::vector<unsigned short> */
6326 #ifndef TOLUA_DISABLE_tolua_lmeshio_std__vector_unsigned_short__iterator
6327 static int tolua_lmeshio_std__vector_unsigned_short__iterator_gc(lua_State* tolua_S)
6328 {
6329     //printf("tolua_lmeshio_std__vector_unsigned_short__iterator_gc\n");
6330     std::pair<std::vector<unsigned short>::iterator, std::vector<unsigned short>::iterator> *range=(std::pair<std::vector<unsigned short>::iterator, std::vector<unsigned short>::iterator>*)lua_touserdata(tolua_S, 1);
6331     range->~pair<std::vector<unsigned short>::iterator, std::vector<unsigned short>::iterator>();
6332     return 0;
6333 }
6334
6335 static int tolua_lmeshio_std__vector_unsigned_short__iterator_internal(lua_State* tolua_S)
6336 {
6337   std::pair<std::vector<unsigned short>::iterator, std::vector<unsigned short>::iterator> *range=(std::pair<std::vector<unsigned short>::iterator, std::vector<unsigned short>::iterator>*)lua_touserdata(tolua_S, lua_upvalueindex(1));
6338   if(range->first==range->second){
6339       return 0;
6340   }
6341   int index=lua_tonumber(tolua_S, lua_upvalueindex(2));
6342   tolua_pushnumber(tolua_S, index);
6343   // update index
6344   tolua_pushnumber(tolua_S, index+1);
6345   lua_replace(tolua_S, lua_upvalueindex(2));
6346
6347   //tolua_pushusertype(tolua_S, &(*range->first++), "unsigned short");
6348    unsigned short& tolua_ret = (unsigned short&) *range->first++;
6349    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
6350
6351   return 2;
6352 }
6353
6354 static int tolua_lmeshio_std__vector_unsigned_short__iterator(lua_State* tolua_S)
6355 {
6356 #ifndef TOLUA_RELEASE
6357  tolua_Error tolua_err;
6358  if (
6359      !tolua_isusertype(tolua_S,1,"std::vector<unsigned short>",0,&tolua_err) ||
6360      !tolua_isnoobj(tolua_S,2,&tolua_err)
6361  )
6362   goto tolua_lerror;
6363  else
6364 #endif
6365  {
6366   std::vector<unsigned short>* self = (std::vector<unsigned short>*)  tolua_tousertype(tolua_S,1,0);
6367 #ifndef TOLUA_RELEASE
6368   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'foreachi'", NULL);
6369 #endif
6370   {
6371     std::pair<std::vector<unsigned short>::iterator, std::vector<unsigned short>::iterator>* range=(std::pair<std::vector<unsigned short>::iterator, std::vector<unsigned short>::iterator>*)lua_newuserdata(tolua_S, sizeof(std::pair<std::vector<unsigned short>::iterator, std::vector<unsigned short>::iterator>));
6372     *range=std::make_pair(self->begin(), self->end());
6373     luaL_getmetatable(tolua_S, "std::pair<std::vector<unsigned short>::iterator, std::vector<unsigned short>::iterator>");
6374     lua_setmetatable(tolua_S, -2);
6375     lua_pushnumber(tolua_S, 0);
6376     // gc
6377     lua_pushcclosure(tolua_S, tolua_lmeshio_std__vector_unsigned_short__iterator_internal, 2);
6378   }
6379  }
6380  return 1;
6381 #ifndef TOLUA_RELEASE
6382  tolua_lerror:
6383  tolua_error(tolua_S,"#ferror in function 'foreachi'.",&tolua_err);
6384  return 0;
6385 #endif
6386 }
6387 #endif //#ifndef TOLUA_DISABLE
6388
6389
6390 /* method: new of class  std::vector<unsigned int> */
6391 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_unsigned_int__new00
6392 static int tolua_lmeshio_std_vector_unsigned_int__new00(lua_State* tolua_S)
6393 {
6394 #ifndef TOLUA_RELEASE
6395  tolua_Error tolua_err;
6396  if (
6397      !tolua_isusertable(tolua_S,1,"std::vector<unsigned int>",0,&tolua_err) ||
6398      !tolua_isnoobj(tolua_S,2,&tolua_err)
6399  )
6400   goto tolua_lerror;
6401  else
6402 #endif
6403  {
6404
6405
6406   {
6407    std::vector<unsigned int>* tolua_ret = (std::vector<unsigned int>*)  Mtolua_new((std::vector<unsigned int>)());
6408     tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<unsigned int>");
6409   }
6410
6411  }
6412  return 1;
6413 #ifndef TOLUA_RELEASE
6414  tolua_lerror:
6415  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
6416  return 0;
6417 #endif
6418 }
6419 #endif //#ifndef TOLUA_DISABLE
6420
6421 /* method: new_local of class  std::vector<unsigned int> */
6422 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_unsigned_int__new00_local
6423 static int tolua_lmeshio_std_vector_unsigned_int__new00_local(lua_State* tolua_S)
6424 {
6425 #ifndef TOLUA_RELEASE
6426  tolua_Error tolua_err;
6427  if (
6428      !tolua_isusertable(tolua_S,1,"std::vector<unsigned int>",0,&tolua_err) ||
6429      !tolua_isnoobj(tolua_S,2,&tolua_err)
6430  )
6431   goto tolua_lerror;
6432  else
6433 #endif
6434  {
6435
6436
6437   {
6438    std::vector<unsigned int>* tolua_ret = (std::vector<unsigned int>*)  Mtolua_new((std::vector<unsigned int>)());
6439     tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<unsigned int>");
6440     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
6441   }
6442
6443  }
6444  return 1;
6445 #ifndef TOLUA_RELEASE
6446  tolua_lerror:
6447  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
6448  return 0;
6449 #endif
6450 }
6451 #endif //#ifndef TOLUA_DISABLE
6452
6453 /* method: size of class  std::vector<unsigned int> */
6454 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_unsigned_int__size00
6455 static int tolua_lmeshio_std_vector_unsigned_int__size00(lua_State* tolua_S)
6456 {
6457 #ifndef TOLUA_RELEASE
6458  tolua_Error tolua_err;
6459  if (
6460      !tolua_isusertype(tolua_S,1,"const std::vector<unsigned int>",0,&tolua_err) ||
6461      !tolua_isnoobj(tolua_S,2,&tolua_err)
6462  )
6463   goto tolua_lerror;
6464  else
6465 #endif
6466  {
6467   const std::vector<unsigned int>* self = (const std::vector<unsigned int>*)  tolua_tousertype(tolua_S,1,0);
6468 #ifndef TOLUA_RELEASE
6469   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
6470 #endif
6471   {
6472    unsigned int tolua_ret = (unsigned int)  self->size();
6473    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
6474   }
6475
6476  }
6477  return 1;
6478 #ifndef TOLUA_RELEASE
6479  tolua_lerror:
6480  tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
6481  return 0;
6482 #endif
6483 }
6484 #endif //#ifndef TOLUA_DISABLE
6485
6486 /* method: push_back of class  std::vector<unsigned int> */
6487 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_unsigned_int__push_back00
6488 static int tolua_lmeshio_std_vector_unsigned_int__push_back00(lua_State* tolua_S)
6489 {
6490 #ifndef TOLUA_RELEASE
6491  tolua_Error tolua_err;
6492  if (
6493      !tolua_isusertype(tolua_S,1,"std::vector<unsigned int>",0,&tolua_err) ||
6494      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
6495      !tolua_isnoobj(tolua_S,3,&tolua_err)
6496  )
6497   goto tolua_lerror;
6498  else
6499 #endif
6500  {
6501   std::vector<unsigned int>* self = (std::vector<unsigned int>*)  tolua_tousertype(tolua_S,1,0);
6502   unsigned int value = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
6503 #ifndef TOLUA_RELEASE
6504   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
6505 #endif
6506   {
6507    self->push_back(value);
6508    tolua_pushnumber(tolua_S,(lua_Number)value);
6509   }
6510
6511  }
6512  return 1;
6513 #ifndef TOLUA_RELEASE
6514  tolua_lerror:
6515  tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
6516  return 0;
6517 #endif
6518 }
6519 #endif //#ifndef TOLUA_DISABLE
6520
6521 /* method: back of class  std::vector<unsigned int> */
6522 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_unsigned_int__back00
6523 static int tolua_lmeshio_std_vector_unsigned_int__back00(lua_State* tolua_S)
6524 {
6525 #ifndef TOLUA_RELEASE
6526  tolua_Error tolua_err;
6527  if (
6528      !tolua_isusertype(tolua_S,1,"std::vector<unsigned int>",0,&tolua_err) ||
6529      !tolua_isnoobj(tolua_S,2,&tolua_err)
6530  )
6531   goto tolua_lerror;
6532  else
6533 #endif
6534  {
6535   std::vector<unsigned int>* self = (std::vector<unsigned int>*)  tolua_tousertype(tolua_S,1,0);
6536 #ifndef TOLUA_RELEASE
6537   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'back'", NULL);
6538 #endif
6539   {
6540    unsigned int& tolua_ret = (unsigned int&)  self->back();
6541    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
6542   }
6543
6544  }
6545  return 1;
6546 #ifndef TOLUA_RELEASE
6547  tolua_lerror:
6548  tolua_error(tolua_S,"#ferror in function 'back'.",&tolua_err);
6549  return 0;
6550 #endif
6551 }
6552 #endif //#ifndef TOLUA_DISABLE
6553
6554 /* method: operator[] of class  std::vector<unsigned int> */
6555 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_unsigned_int___geti00
6556 static int tolua_lmeshio_std_vector_unsigned_int___geti00(lua_State* tolua_S)
6557 {
6558 #ifndef TOLUA_RELEASE
6559  tolua_Error tolua_err;
6560  if (
6561      !tolua_isusertype(tolua_S,1,"std::vector<unsigned int>",0,&tolua_err) ||
6562      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
6563      !tolua_isnoobj(tolua_S,3,&tolua_err)
6564  )
6565   goto tolua_lerror;
6566  else
6567 #endif
6568  {
6569   std::vector<unsigned int>* self = (std::vector<unsigned int>*)  tolua_tousertype(tolua_S,1,0);
6570   int index = ((int)  tolua_tonumber(tolua_S,2,0));
6571 #ifndef TOLUA_RELEASE
6572   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
6573 #endif
6574   {
6575    unsigned int& tolua_ret = (unsigned int&)  self->operator[](index);
6576    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
6577
6578   }
6579
6580  }
6581  return 1;
6582 #ifndef TOLUA_RELEASE
6583  tolua_lerror:
6584  tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
6585  return 0;
6586 #endif
6587 }
6588 #endif //#ifndef TOLUA_DISABLE
6589
6590 /* method: operator&[] of class  std::vector<unsigned int> */
6591 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_unsigned_int___seti00
6592 static int tolua_lmeshio_std_vector_unsigned_int___seti00(lua_State* tolua_S)
6593 {
6594 #ifndef TOLUA_RELEASE
6595  tolua_Error tolua_err;
6596  if (
6597      !tolua_isusertype(tolua_S,1,"std::vector<unsigned int>",0,&tolua_err) ||
6598      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
6599      !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
6600      !tolua_isnoobj(tolua_S,4,&tolua_err)
6601  )
6602   goto tolua_lerror;
6603  else
6604 #endif
6605  {
6606   std::vector<unsigned int>* self = (std::vector<unsigned int>*)  tolua_tousertype(tolua_S,1,0);
6607   int index = ((int)  tolua_tonumber(tolua_S,2,0));
6608   unsigned int tolua_value = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
6609 #ifndef TOLUA_RELEASE
6610   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
6611 #endif
6612   self->operator[](index) =  tolua_value;
6613  }
6614  return 0;
6615 #ifndef TOLUA_RELEASE
6616  tolua_lerror:
6617  tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
6618  return 0;
6619 #endif
6620 }
6621 #endif //#ifndef TOLUA_DISABLE
6622
6623 /* stl foreachi: class  std::vector<unsigned int> */
6624 #ifndef TOLUA_DISABLE_tolua_lmeshio_std__vector_unsigned_int__iterator
6625 static int tolua_lmeshio_std__vector_unsigned_int__iterator_gc(lua_State* tolua_S)
6626 {
6627     //printf("tolua_lmeshio_std__vector_unsigned_int__iterator_gc\n");
6628     std::pair<std::vector<unsigned int>::iterator, std::vector<unsigned int>::iterator> *range=(std::pair<std::vector<unsigned int>::iterator, std::vector<unsigned int>::iterator>*)lua_touserdata(tolua_S, 1);
6629     range->~pair<std::vector<unsigned int>::iterator, std::vector<unsigned int>::iterator>();
6630     return 0;
6631 }
6632
6633 static int tolua_lmeshio_std__vector_unsigned_int__iterator_internal(lua_State* tolua_S)
6634 {
6635   std::pair<std::vector<unsigned int>::iterator, std::vector<unsigned int>::iterator> *range=(std::pair<std::vector<unsigned int>::iterator, std::vector<unsigned int>::iterator>*)lua_touserdata(tolua_S, lua_upvalueindex(1));
6636   if(range->first==range->second){
6637       return 0;
6638   }
6639   int index=lua_tonumber(tolua_S, lua_upvalueindex(2));
6640   tolua_pushnumber(tolua_S, index);
6641   // update index
6642   tolua_pushnumber(tolua_S, index+1);
6643   lua_replace(tolua_S, lua_upvalueindex(2));
6644
6645   //tolua_pushusertype(tolua_S, &(*range->first++), "unsigned int");
6646    unsigned int& tolua_ret = (unsigned int&) *range->first++;
6647    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
6648
6649   return 2;
6650 }
6651
6652 static int tolua_lmeshio_std__vector_unsigned_int__iterator(lua_State* tolua_S)
6653 {
6654 #ifndef TOLUA_RELEASE
6655  tolua_Error tolua_err;
6656  if (
6657      !tolua_isusertype(tolua_S,1,"std::vector<unsigned int>",0,&tolua_err) ||
6658      !tolua_isnoobj(tolua_S,2,&tolua_err)
6659  )
6660   goto tolua_lerror;
6661  else
6662 #endif
6663  {
6664   std::vector<unsigned int>* self = (std::vector<unsigned int>*)  tolua_tousertype(tolua_S,1,0);
6665 #ifndef TOLUA_RELEASE
6666   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'foreachi'", NULL);
6667 #endif
6668   {
6669     std::pair<std::vector<unsigned int>::iterator, std::vector<unsigned int>::iterator>* range=(std::pair<std::vector<unsigned int>::iterator, std::vector<unsigned int>::iterator>*)lua_newuserdata(tolua_S, sizeof(std::pair<std::vector<unsigned int>::iterator, std::vector<unsigned int>::iterator>));
6670     *range=std::make_pair(self->begin(), self->end());
6671     luaL_getmetatable(tolua_S, "std::pair<std::vector<unsigned int>::iterator, std::vector<unsigned int>::iterator>");
6672     lua_setmetatable(tolua_S, -2);
6673     lua_pushnumber(tolua_S, 0);
6674     // gc
6675     lua_pushcclosure(tolua_S, tolua_lmeshio_std__vector_unsigned_int__iterator_internal, 2);
6676   }
6677  }
6678  return 1;
6679 #ifndef TOLUA_RELEASE
6680  tolua_lerror:
6681  tolua_error(tolua_S,"#ferror in function 'foreachi'.",&tolua_err);
6682  return 0;
6683 #endif
6684 }
6685 #endif //#ifndef TOLUA_DISABLE
6686
6687
6688 /* method: new of class  std::vector<meshio::Vector3> */
6689 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__Vector3__new00
6690 static int tolua_lmeshio_std_vector_meshio__Vector3__new00(lua_State* tolua_S)
6691 {
6692 #ifndef TOLUA_RELEASE
6693  tolua_Error tolua_err;
6694  if (
6695      !tolua_isusertable(tolua_S,1,"std::vector<meshio::Vector3>",0,&tolua_err) ||
6696      !tolua_isnoobj(tolua_S,2,&tolua_err)
6697  )
6698   goto tolua_lerror;
6699  else
6700 #endif
6701  {
6702
6703
6704   {
6705    std::vector<meshio::Vector3>* tolua_ret = (std::vector<meshio::Vector3>*)  Mtolua_new((std::vector<meshio::Vector3>)());
6706     tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<meshio::Vector3>");
6707   }
6708
6709  }
6710  return 1;
6711 #ifndef TOLUA_RELEASE
6712  tolua_lerror:
6713  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
6714  return 0;
6715 #endif
6716 }
6717 #endif //#ifndef TOLUA_DISABLE
6718
6719 /* method: new_local of class  std::vector<meshio::Vector3> */
6720 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__Vector3__new00_local
6721 static int tolua_lmeshio_std_vector_meshio__Vector3__new00_local(lua_State* tolua_S)
6722 {
6723 #ifndef TOLUA_RELEASE
6724  tolua_Error tolua_err;
6725  if (
6726      !tolua_isusertable(tolua_S,1,"std::vector<meshio::Vector3>",0,&tolua_err) ||
6727      !tolua_isnoobj(tolua_S,2,&tolua_err)
6728  )
6729   goto tolua_lerror;
6730  else
6731 #endif
6732  {
6733
6734
6735   {
6736    std::vector<meshio::Vector3>* tolua_ret = (std::vector<meshio::Vector3>*)  Mtolua_new((std::vector<meshio::Vector3>)());
6737     tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<meshio::Vector3>");
6738     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
6739   }
6740
6741  }
6742  return 1;
6743 #ifndef TOLUA_RELEASE
6744  tolua_lerror:
6745  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
6746  return 0;
6747 #endif
6748 }
6749 #endif //#ifndef TOLUA_DISABLE
6750
6751 /* method: size of class  std::vector<meshio::Vector3> */
6752 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__Vector3__size00
6753 static int tolua_lmeshio_std_vector_meshio__Vector3__size00(lua_State* tolua_S)
6754 {
6755 #ifndef TOLUA_RELEASE
6756  tolua_Error tolua_err;
6757  if (
6758      !tolua_isusertype(tolua_S,1,"const std::vector<meshio::Vector3>",0,&tolua_err) ||
6759      !tolua_isnoobj(tolua_S,2,&tolua_err)
6760  )
6761   goto tolua_lerror;
6762  else
6763 #endif
6764  {
6765   const std::vector<meshio::Vector3>* self = (const std::vector<meshio::Vector3>*)  tolua_tousertype(tolua_S,1,0);
6766 #ifndef TOLUA_RELEASE
6767   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
6768 #endif
6769   {
6770    unsigned int tolua_ret = (unsigned int)  self->size();
6771    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
6772   }
6773
6774  }
6775  return 1;
6776 #ifndef TOLUA_RELEASE
6777  tolua_lerror:
6778  tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
6779  return 0;
6780 #endif
6781 }
6782 #endif //#ifndef TOLUA_DISABLE
6783
6784 /* method: push_back of class  std::vector<meshio::Vector3> */
6785 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__Vector3__push_back00
6786 static int tolua_lmeshio_std_vector_meshio__Vector3__push_back00(lua_State* tolua_S)
6787 {
6788 #ifndef TOLUA_RELEASE
6789  tolua_Error tolua_err;
6790  if (
6791      !tolua_isusertype(tolua_S,1,"std::vector<meshio::Vector3>",0,&tolua_err) ||
6792      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::Vector3",0,&tolua_err)) ||
6793      !tolua_isnoobj(tolua_S,3,&tolua_err)
6794  )
6795   goto tolua_lerror;
6796  else
6797 #endif
6798  {
6799   std::vector<meshio::Vector3>* self = (std::vector<meshio::Vector3>*)  tolua_tousertype(tolua_S,1,0);
6800   meshio::Vector3* value = ((meshio::Vector3*)  tolua_tousertype(tolua_S,2,0));
6801 #ifndef TOLUA_RELEASE
6802   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
6803 #endif
6804   {
6805    self->push_back(*value);
6806
6807   }
6808
6809  }
6810  return 0;
6811 #ifndef TOLUA_RELEASE
6812  tolua_lerror:
6813  tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
6814  return 0;
6815 #endif
6816 }
6817 #endif //#ifndef TOLUA_DISABLE
6818
6819 /* method: back of class  std::vector<meshio::Vector3> */
6820 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__Vector3__back00
6821 static int tolua_lmeshio_std_vector_meshio__Vector3__back00(lua_State* tolua_S)
6822 {
6823 #ifndef TOLUA_RELEASE
6824  tolua_Error tolua_err;
6825  if (
6826      !tolua_isusertype(tolua_S,1,"std::vector<meshio::Vector3>",0,&tolua_err) ||
6827      !tolua_isnoobj(tolua_S,2,&tolua_err)
6828  )
6829   goto tolua_lerror;
6830  else
6831 #endif
6832  {
6833   std::vector<meshio::Vector3>* self = (std::vector<meshio::Vector3>*)  tolua_tousertype(tolua_S,1,0);
6834 #ifndef TOLUA_RELEASE
6835   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'back'", NULL);
6836 #endif
6837   {
6838    meshio::Vector3& tolua_ret = (meshio::Vector3&)  self->back();
6839     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::Vector3");
6840   }
6841
6842  }
6843  return 1;
6844 #ifndef TOLUA_RELEASE
6845  tolua_lerror:
6846  tolua_error(tolua_S,"#ferror in function 'back'.",&tolua_err);
6847  return 0;
6848 #endif
6849 }
6850 #endif //#ifndef TOLUA_DISABLE
6851
6852 /* method: operator[] of class  std::vector<meshio::Vector3> */
6853 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__Vector3___geti00
6854 static int tolua_lmeshio_std_vector_meshio__Vector3___geti00(lua_State* tolua_S)
6855 {
6856 #ifndef TOLUA_RELEASE
6857  tolua_Error tolua_err;
6858  if (
6859      !tolua_isusertype(tolua_S,1,"std::vector<meshio::Vector3>",0,&tolua_err) ||
6860      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
6861      !tolua_isnoobj(tolua_S,3,&tolua_err)
6862  )
6863   goto tolua_lerror;
6864  else
6865 #endif
6866  {
6867   std::vector<meshio::Vector3>* self = (std::vector<meshio::Vector3>*)  tolua_tousertype(tolua_S,1,0);
6868   int index = ((int)  tolua_tonumber(tolua_S,2,0));
6869 #ifndef TOLUA_RELEASE
6870   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
6871 #endif
6872   {
6873    meshio::Vector3& tolua_ret = (meshio::Vector3&)  self->operator[](index);
6874     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::Vector3");
6875
6876   }
6877
6878  }
6879  return 1;
6880 #ifndef TOLUA_RELEASE
6881  tolua_lerror:
6882  tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
6883  return 0;
6884 #endif
6885 }
6886 #endif //#ifndef TOLUA_DISABLE
6887
6888 /* method: operator&[] of class  std::vector<meshio::Vector3> */
6889 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__Vector3___seti00
6890 static int tolua_lmeshio_std_vector_meshio__Vector3___seti00(lua_State* tolua_S)
6891 {
6892 #ifndef TOLUA_RELEASE
6893  tolua_Error tolua_err;
6894  if (
6895      !tolua_isusertype(tolua_S,1,"std::vector<meshio::Vector3>",0,&tolua_err) ||
6896      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
6897      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"meshio::Vector3",0,&tolua_err)) ||
6898      !tolua_isnoobj(tolua_S,4,&tolua_err)
6899  )
6900   goto tolua_lerror;
6901  else
6902 #endif
6903  {
6904   std::vector<meshio::Vector3>* self = (std::vector<meshio::Vector3>*)  tolua_tousertype(tolua_S,1,0);
6905   int index = ((int)  tolua_tonumber(tolua_S,2,0));
6906   meshio::Vector3 tolua_value = *((meshio::Vector3*)  tolua_tousertype(tolua_S,3,0));
6907 #ifndef TOLUA_RELEASE
6908   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
6909 #endif
6910   self->operator[](index) =  tolua_value;
6911  }
6912  return 0;
6913 #ifndef TOLUA_RELEASE
6914  tolua_lerror:
6915  tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
6916  return 0;
6917 #endif
6918 }
6919 #endif //#ifndef TOLUA_DISABLE
6920
6921 /* stl foreachi: class  std::vector<meshio::Vector3> */
6922 #ifndef TOLUA_DISABLE_tolua_lmeshio_std__vector_meshio__Vector3__iterator
6923 static int tolua_lmeshio_std__vector_meshio__Vector3__iterator_gc(lua_State* tolua_S)
6924 {
6925     //printf("tolua_lmeshio_std__vector_meshio__Vector3__iterator_gc\n");
6926     std::pair<std::vector<meshio::Vector3>::iterator, std::vector<meshio::Vector3>::iterator> *range=(std::pair<std::vector<meshio::Vector3>::iterator, std::vector<meshio::Vector3>::iterator>*)lua_touserdata(tolua_S, 1);
6927     range->~pair<std::vector<meshio::Vector3>::iterator, std::vector<meshio::Vector3>::iterator>();
6928     return 0;
6929 }
6930
6931 static int tolua_lmeshio_std__vector_meshio__Vector3__iterator_internal(lua_State* tolua_S)
6932 {
6933   std::pair<std::vector<meshio::Vector3>::iterator, std::vector<meshio::Vector3>::iterator> *range=(std::pair<std::vector<meshio::Vector3>::iterator, std::vector<meshio::Vector3>::iterator>*)lua_touserdata(tolua_S, lua_upvalueindex(1));
6934   if(range->first==range->second){
6935       return 0;
6936   }
6937   int index=lua_tonumber(tolua_S, lua_upvalueindex(2));
6938   tolua_pushnumber(tolua_S, index);
6939   // update index
6940   tolua_pushnumber(tolua_S, index+1);
6941   lua_replace(tolua_S, lua_upvalueindex(2));
6942
6943   //tolua_pushusertype(tolua_S, &(*range->first++), "meshio::Vector3");
6944    meshio::Vector3& tolua_ret = (meshio::Vector3&) *range->first++;
6945     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::Vector3");
6946
6947   return 2;
6948 }
6949
6950 static int tolua_lmeshio_std__vector_meshio__Vector3__iterator(lua_State* tolua_S)
6951 {
6952 #ifndef TOLUA_RELEASE
6953  tolua_Error tolua_err;
6954  if (
6955      !tolua_isusertype(tolua_S,1,"std::vector<meshio::Vector3>",0,&tolua_err) ||
6956      !tolua_isnoobj(tolua_S,2,&tolua_err)
6957  )
6958   goto tolua_lerror;
6959  else
6960 #endif
6961  {
6962   std::vector<meshio::Vector3>* self = (std::vector<meshio::Vector3>*)  tolua_tousertype(tolua_S,1,0);
6963 #ifndef TOLUA_RELEASE
6964   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'foreachi'", NULL);
6965 #endif
6966   {
6967     std::pair<std::vector<meshio::Vector3>::iterator, std::vector<meshio::Vector3>::iterator>* range=(std::pair<std::vector<meshio::Vector3>::iterator, std::vector<meshio::Vector3>::iterator>*)lua_newuserdata(tolua_S, sizeof(std::pair<std::vector<meshio::Vector3>::iterator, std::vector<meshio::Vector3>::iterator>));
6968     *range=std::make_pair(self->begin(), self->end());
6969     luaL_getmetatable(tolua_S, "std::pair<std::vector<meshio::Vector3>::iterator, std::vector<meshio::Vector3>::iterator>");
6970     lua_setmetatable(tolua_S, -2);
6971     lua_pushnumber(tolua_S, 0);
6972     // gc
6973     lua_pushcclosure(tolua_S, tolua_lmeshio_std__vector_meshio__Vector3__iterator_internal, 2);
6974   }
6975  }
6976  return 1;
6977 #ifndef TOLUA_RELEASE
6978  tolua_lerror:
6979  tolua_error(tolua_S,"#ferror in function 'foreachi'.",&tolua_err);
6980  return 0;
6981 #endif
6982 }
6983 #endif //#ifndef TOLUA_DISABLE
6984
6985
6986 /* method: new of class  std::vector<meshio::pmd::Vertex> */
6987 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Vertex__new00
6988 static int tolua_lmeshio_std_vector_meshio__pmd__Vertex__new00(lua_State* tolua_S)
6989 {
6990 #ifndef TOLUA_RELEASE
6991  tolua_Error tolua_err;
6992  if (
6993      !tolua_isusertable(tolua_S,1,"std::vector<meshio::pmd::Vertex>",0,&tolua_err) ||
6994      !tolua_isnoobj(tolua_S,2,&tolua_err)
6995  )
6996   goto tolua_lerror;
6997  else
6998 #endif
6999  {
7000
7001
7002   {
7003    std::vector<meshio::pmd::Vertex>* tolua_ret = (std::vector<meshio::pmd::Vertex>*)  Mtolua_new((std::vector<meshio::pmd::Vertex>)());
7004     tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<meshio::pmd::Vertex>");
7005   }
7006
7007  }
7008  return 1;
7009 #ifndef TOLUA_RELEASE
7010  tolua_lerror:
7011  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
7012  return 0;
7013 #endif
7014 }
7015 #endif //#ifndef TOLUA_DISABLE
7016
7017 /* method: new_local of class  std::vector<meshio::pmd::Vertex> */
7018 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Vertex__new00_local
7019 static int tolua_lmeshio_std_vector_meshio__pmd__Vertex__new00_local(lua_State* tolua_S)
7020 {
7021 #ifndef TOLUA_RELEASE
7022  tolua_Error tolua_err;
7023  if (
7024      !tolua_isusertable(tolua_S,1,"std::vector<meshio::pmd::Vertex>",0,&tolua_err) ||
7025      !tolua_isnoobj(tolua_S,2,&tolua_err)
7026  )
7027   goto tolua_lerror;
7028  else
7029 #endif
7030  {
7031
7032
7033   {
7034    std::vector<meshio::pmd::Vertex>* tolua_ret = (std::vector<meshio::pmd::Vertex>*)  Mtolua_new((std::vector<meshio::pmd::Vertex>)());
7035     tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<meshio::pmd::Vertex>");
7036     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
7037   }
7038
7039  }
7040  return 1;
7041 #ifndef TOLUA_RELEASE
7042  tolua_lerror:
7043  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
7044  return 0;
7045 #endif
7046 }
7047 #endif //#ifndef TOLUA_DISABLE
7048
7049 /* method: size of class  std::vector<meshio::pmd::Vertex> */
7050 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Vertex__size00
7051 static int tolua_lmeshio_std_vector_meshio__pmd__Vertex__size00(lua_State* tolua_S)
7052 {
7053 #ifndef TOLUA_RELEASE
7054  tolua_Error tolua_err;
7055  if (
7056      !tolua_isusertype(tolua_S,1,"const std::vector<meshio::pmd::Vertex>",0,&tolua_err) ||
7057      !tolua_isnoobj(tolua_S,2,&tolua_err)
7058  )
7059   goto tolua_lerror;
7060  else
7061 #endif
7062  {
7063   const std::vector<meshio::pmd::Vertex>* self = (const std::vector<meshio::pmd::Vertex>*)  tolua_tousertype(tolua_S,1,0);
7064 #ifndef TOLUA_RELEASE
7065   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
7066 #endif
7067   {
7068    unsigned int tolua_ret = (unsigned int)  self->size();
7069    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
7070   }
7071
7072  }
7073  return 1;
7074 #ifndef TOLUA_RELEASE
7075  tolua_lerror:
7076  tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
7077  return 0;
7078 #endif
7079 }
7080 #endif //#ifndef TOLUA_DISABLE
7081
7082 /* method: push_back of class  std::vector<meshio::pmd::Vertex> */
7083 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Vertex__push_back00
7084 static int tolua_lmeshio_std_vector_meshio__pmd__Vertex__push_back00(lua_State* tolua_S)
7085 {
7086 #ifndef TOLUA_RELEASE
7087  tolua_Error tolua_err;
7088  if (
7089      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::Vertex>",0,&tolua_err) ||
7090      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::pmd::Vertex",0,&tolua_err)) ||
7091      !tolua_isnoobj(tolua_S,3,&tolua_err)
7092  )
7093   goto tolua_lerror;
7094  else
7095 #endif
7096  {
7097   std::vector<meshio::pmd::Vertex>* self = (std::vector<meshio::pmd::Vertex>*)  tolua_tousertype(tolua_S,1,0);
7098   meshio::pmd::Vertex* value = ((meshio::pmd::Vertex*)  tolua_tousertype(tolua_S,2,0));
7099 #ifndef TOLUA_RELEASE
7100   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
7101 #endif
7102   {
7103    self->push_back(*value);
7104
7105   }
7106
7107  }
7108  return 0;
7109 #ifndef TOLUA_RELEASE
7110  tolua_lerror:
7111  tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
7112  return 0;
7113 #endif
7114 }
7115 #endif //#ifndef TOLUA_DISABLE
7116
7117 /* method: back of class  std::vector<meshio::pmd::Vertex> */
7118 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Vertex__back00
7119 static int tolua_lmeshio_std_vector_meshio__pmd__Vertex__back00(lua_State* tolua_S)
7120 {
7121 #ifndef TOLUA_RELEASE
7122  tolua_Error tolua_err;
7123  if (
7124      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::Vertex>",0,&tolua_err) ||
7125      !tolua_isnoobj(tolua_S,2,&tolua_err)
7126  )
7127   goto tolua_lerror;
7128  else
7129 #endif
7130  {
7131   std::vector<meshio::pmd::Vertex>* self = (std::vector<meshio::pmd::Vertex>*)  tolua_tousertype(tolua_S,1,0);
7132 #ifndef TOLUA_RELEASE
7133   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'back'", NULL);
7134 #endif
7135   {
7136    meshio::pmd::Vertex& tolua_ret = (meshio::pmd::Vertex&)  self->back();
7137     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::pmd::Vertex");
7138   }
7139
7140  }
7141  return 1;
7142 #ifndef TOLUA_RELEASE
7143  tolua_lerror:
7144  tolua_error(tolua_S,"#ferror in function 'back'.",&tolua_err);
7145  return 0;
7146 #endif
7147 }
7148 #endif //#ifndef TOLUA_DISABLE
7149
7150 /* method: operator[] of class  std::vector<meshio::pmd::Vertex> */
7151 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Vertex___geti00
7152 static int tolua_lmeshio_std_vector_meshio__pmd__Vertex___geti00(lua_State* tolua_S)
7153 {
7154 #ifndef TOLUA_RELEASE
7155  tolua_Error tolua_err;
7156  if (
7157      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::Vertex>",0,&tolua_err) ||
7158      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
7159      !tolua_isnoobj(tolua_S,3,&tolua_err)
7160  )
7161   goto tolua_lerror;
7162  else
7163 #endif
7164  {
7165   std::vector<meshio::pmd::Vertex>* self = (std::vector<meshio::pmd::Vertex>*)  tolua_tousertype(tolua_S,1,0);
7166   int index = ((int)  tolua_tonumber(tolua_S,2,0));
7167 #ifndef TOLUA_RELEASE
7168   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
7169 #endif
7170   {
7171    meshio::pmd::Vertex& tolua_ret = (meshio::pmd::Vertex&)  self->operator[](index);
7172     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::pmd::Vertex");
7173
7174   }
7175
7176  }
7177  return 1;
7178 #ifndef TOLUA_RELEASE
7179  tolua_lerror:
7180  tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
7181  return 0;
7182 #endif
7183 }
7184 #endif //#ifndef TOLUA_DISABLE
7185
7186 /* method: operator&[] of class  std::vector<meshio::pmd::Vertex> */
7187 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Vertex___seti00
7188 static int tolua_lmeshio_std_vector_meshio__pmd__Vertex___seti00(lua_State* tolua_S)
7189 {
7190 #ifndef TOLUA_RELEASE
7191  tolua_Error tolua_err;
7192  if (
7193      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::Vertex>",0,&tolua_err) ||
7194      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
7195      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"meshio::pmd::Vertex",0,&tolua_err)) ||
7196      !tolua_isnoobj(tolua_S,4,&tolua_err)
7197  )
7198   goto tolua_lerror;
7199  else
7200 #endif
7201  {
7202   std::vector<meshio::pmd::Vertex>* self = (std::vector<meshio::pmd::Vertex>*)  tolua_tousertype(tolua_S,1,0);
7203   int index = ((int)  tolua_tonumber(tolua_S,2,0));
7204   meshio::pmd::Vertex tolua_value = *((meshio::pmd::Vertex*)  tolua_tousertype(tolua_S,3,0));
7205 #ifndef TOLUA_RELEASE
7206   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
7207 #endif
7208   self->operator[](index) =  tolua_value;
7209  }
7210  return 0;
7211 #ifndef TOLUA_RELEASE
7212  tolua_lerror:
7213  tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
7214  return 0;
7215 #endif
7216 }
7217 #endif //#ifndef TOLUA_DISABLE
7218
7219 /* stl foreachi: class  std::vector<meshio::pmd::Vertex> */
7220 #ifndef TOLUA_DISABLE_tolua_lmeshio_std__vector_meshio__pmd__Vertex__iterator
7221 static int tolua_lmeshio_std__vector_meshio__pmd__Vertex__iterator_gc(lua_State* tolua_S)
7222 {
7223     //printf("tolua_lmeshio_std__vector_meshio__pmd__Vertex__iterator_gc\n");
7224     std::pair<std::vector<meshio::pmd::Vertex>::iterator, std::vector<meshio::pmd::Vertex>::iterator> *range=(std::pair<std::vector<meshio::pmd::Vertex>::iterator, std::vector<meshio::pmd::Vertex>::iterator>*)lua_touserdata(tolua_S, 1);
7225     range->~pair<std::vector<meshio::pmd::Vertex>::iterator, std::vector<meshio::pmd::Vertex>::iterator>();
7226     return 0;
7227 }
7228
7229 static int tolua_lmeshio_std__vector_meshio__pmd__Vertex__iterator_internal(lua_State* tolua_S)
7230 {
7231   std::pair<std::vector<meshio::pmd::Vertex>::iterator, std::vector<meshio::pmd::Vertex>::iterator> *range=(std::pair<std::vector<meshio::pmd::Vertex>::iterator, std::vector<meshio::pmd::Vertex>::iterator>*)lua_touserdata(tolua_S, lua_upvalueindex(1));
7232   if(range->first==range->second){
7233       return 0;
7234   }
7235   int index=lua_tonumber(tolua_S, lua_upvalueindex(2));
7236   tolua_pushnumber(tolua_S, index);
7237   // update index
7238   tolua_pushnumber(tolua_S, index+1);
7239   lua_replace(tolua_S, lua_upvalueindex(2));
7240
7241   //tolua_pushusertype(tolua_S, &(*range->first++), "meshio::pmd::Vertex");
7242    meshio::pmd::Vertex& tolua_ret = (meshio::pmd::Vertex&) *range->first++;
7243     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::pmd::Vertex");
7244
7245   return 2;
7246 }
7247
7248 static int tolua_lmeshio_std__vector_meshio__pmd__Vertex__iterator(lua_State* tolua_S)
7249 {
7250 #ifndef TOLUA_RELEASE
7251  tolua_Error tolua_err;
7252  if (
7253      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::Vertex>",0,&tolua_err) ||
7254      !tolua_isnoobj(tolua_S,2,&tolua_err)
7255  )
7256   goto tolua_lerror;
7257  else
7258 #endif
7259  {
7260   std::vector<meshio::pmd::Vertex>* self = (std::vector<meshio::pmd::Vertex>*)  tolua_tousertype(tolua_S,1,0);
7261 #ifndef TOLUA_RELEASE
7262   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'foreachi'", NULL);
7263 #endif
7264   {
7265     std::pair<std::vector<meshio::pmd::Vertex>::iterator, std::vector<meshio::pmd::Vertex>::iterator>* range=(std::pair<std::vector<meshio::pmd::Vertex>::iterator, std::vector<meshio::pmd::Vertex>::iterator>*)lua_newuserdata(tolua_S, sizeof(std::pair<std::vector<meshio::pmd::Vertex>::iterator, std::vector<meshio::pmd::Vertex>::iterator>));
7266     *range=std::make_pair(self->begin(), self->end());
7267     luaL_getmetatable(tolua_S, "std::pair<std::vector<meshio::pmd::Vertex>::iterator, std::vector<meshio::pmd::Vertex>::iterator>");
7268     lua_setmetatable(tolua_S, -2);
7269     lua_pushnumber(tolua_S, 0);
7270     // gc
7271     lua_pushcclosure(tolua_S, tolua_lmeshio_std__vector_meshio__pmd__Vertex__iterator_internal, 2);
7272   }
7273  }
7274  return 1;
7275 #ifndef TOLUA_RELEASE
7276  tolua_lerror:
7277  tolua_error(tolua_S,"#ferror in function 'foreachi'.",&tolua_err);
7278  return 0;
7279 #endif
7280 }
7281 #endif //#ifndef TOLUA_DISABLE
7282
7283
7284 /* method: new of class  std::vector<meshio::pmd::Material> */
7285 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Material__new00
7286 static int tolua_lmeshio_std_vector_meshio__pmd__Material__new00(lua_State* tolua_S)
7287 {
7288 #ifndef TOLUA_RELEASE
7289  tolua_Error tolua_err;
7290  if (
7291      !tolua_isusertable(tolua_S,1,"std::vector<meshio::pmd::Material>",0,&tolua_err) ||
7292      !tolua_isnoobj(tolua_S,2,&tolua_err)
7293  )
7294   goto tolua_lerror;
7295  else
7296 #endif
7297  {
7298
7299
7300   {
7301    std::vector<meshio::pmd::Material>* tolua_ret = (std::vector<meshio::pmd::Material>*)  Mtolua_new((std::vector<meshio::pmd::Material>)());
7302     tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<meshio::pmd::Material>");
7303   }
7304
7305  }
7306  return 1;
7307 #ifndef TOLUA_RELEASE
7308  tolua_lerror:
7309  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
7310  return 0;
7311 #endif
7312 }
7313 #endif //#ifndef TOLUA_DISABLE
7314
7315 /* method: new_local of class  std::vector<meshio::pmd::Material> */
7316 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Material__new00_local
7317 static int tolua_lmeshio_std_vector_meshio__pmd__Material__new00_local(lua_State* tolua_S)
7318 {
7319 #ifndef TOLUA_RELEASE
7320  tolua_Error tolua_err;
7321  if (
7322      !tolua_isusertable(tolua_S,1,"std::vector<meshio::pmd::Material>",0,&tolua_err) ||
7323      !tolua_isnoobj(tolua_S,2,&tolua_err)
7324  )
7325   goto tolua_lerror;
7326  else
7327 #endif
7328  {
7329
7330
7331   {
7332    std::vector<meshio::pmd::Material>* tolua_ret = (std::vector<meshio::pmd::Material>*)  Mtolua_new((std::vector<meshio::pmd::Material>)());
7333     tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<meshio::pmd::Material>");
7334     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
7335   }
7336
7337  }
7338  return 1;
7339 #ifndef TOLUA_RELEASE
7340  tolua_lerror:
7341  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
7342  return 0;
7343 #endif
7344 }
7345 #endif //#ifndef TOLUA_DISABLE
7346
7347 /* method: size of class  std::vector<meshio::pmd::Material> */
7348 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Material__size00
7349 static int tolua_lmeshio_std_vector_meshio__pmd__Material__size00(lua_State* tolua_S)
7350 {
7351 #ifndef TOLUA_RELEASE
7352  tolua_Error tolua_err;
7353  if (
7354      !tolua_isusertype(tolua_S,1,"const std::vector<meshio::pmd::Material>",0,&tolua_err) ||
7355      !tolua_isnoobj(tolua_S,2,&tolua_err)
7356  )
7357   goto tolua_lerror;
7358  else
7359 #endif
7360  {
7361   const std::vector<meshio::pmd::Material>* self = (const std::vector<meshio::pmd::Material>*)  tolua_tousertype(tolua_S,1,0);
7362 #ifndef TOLUA_RELEASE
7363   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
7364 #endif
7365   {
7366    unsigned int tolua_ret = (unsigned int)  self->size();
7367    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
7368   }
7369
7370  }
7371  return 1;
7372 #ifndef TOLUA_RELEASE
7373  tolua_lerror:
7374  tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
7375  return 0;
7376 #endif
7377 }
7378 #endif //#ifndef TOLUA_DISABLE
7379
7380 /* method: push_back of class  std::vector<meshio::pmd::Material> */
7381 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Material__push_back00
7382 static int tolua_lmeshio_std_vector_meshio__pmd__Material__push_back00(lua_State* tolua_S)
7383 {
7384 #ifndef TOLUA_RELEASE
7385  tolua_Error tolua_err;
7386  if (
7387      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::Material>",0,&tolua_err) ||
7388      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::pmd::Material",0,&tolua_err)) ||
7389      !tolua_isnoobj(tolua_S,3,&tolua_err)
7390  )
7391   goto tolua_lerror;
7392  else
7393 #endif
7394  {
7395   std::vector<meshio::pmd::Material>* self = (std::vector<meshio::pmd::Material>*)  tolua_tousertype(tolua_S,1,0);
7396   meshio::pmd::Material* value = ((meshio::pmd::Material*)  tolua_tousertype(tolua_S,2,0));
7397 #ifndef TOLUA_RELEASE
7398   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
7399 #endif
7400   {
7401    self->push_back(*value);
7402
7403   }
7404
7405  }
7406  return 0;
7407 #ifndef TOLUA_RELEASE
7408  tolua_lerror:
7409  tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
7410  return 0;
7411 #endif
7412 }
7413 #endif //#ifndef TOLUA_DISABLE
7414
7415 /* method: back of class  std::vector<meshio::pmd::Material> */
7416 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Material__back00
7417 static int tolua_lmeshio_std_vector_meshio__pmd__Material__back00(lua_State* tolua_S)
7418 {
7419 #ifndef TOLUA_RELEASE
7420  tolua_Error tolua_err;
7421  if (
7422      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::Material>",0,&tolua_err) ||
7423      !tolua_isnoobj(tolua_S,2,&tolua_err)
7424  )
7425   goto tolua_lerror;
7426  else
7427 #endif
7428  {
7429   std::vector<meshio::pmd::Material>* self = (std::vector<meshio::pmd::Material>*)  tolua_tousertype(tolua_S,1,0);
7430 #ifndef TOLUA_RELEASE
7431   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'back'", NULL);
7432 #endif
7433   {
7434    meshio::pmd::Material& tolua_ret = (meshio::pmd::Material&)  self->back();
7435     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::pmd::Material");
7436   }
7437
7438  }
7439  return 1;
7440 #ifndef TOLUA_RELEASE
7441  tolua_lerror:
7442  tolua_error(tolua_S,"#ferror in function 'back'.",&tolua_err);
7443  return 0;
7444 #endif
7445 }
7446 #endif //#ifndef TOLUA_DISABLE
7447
7448 /* method: operator[] of class  std::vector<meshio::pmd::Material> */
7449 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Material___geti00
7450 static int tolua_lmeshio_std_vector_meshio__pmd__Material___geti00(lua_State* tolua_S)
7451 {
7452 #ifndef TOLUA_RELEASE
7453  tolua_Error tolua_err;
7454  if (
7455      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::Material>",0,&tolua_err) ||
7456      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
7457      !tolua_isnoobj(tolua_S,3,&tolua_err)
7458  )
7459   goto tolua_lerror;
7460  else
7461 #endif
7462  {
7463   std::vector<meshio::pmd::Material>* self = (std::vector<meshio::pmd::Material>*)  tolua_tousertype(tolua_S,1,0);
7464   int index = ((int)  tolua_tonumber(tolua_S,2,0));
7465 #ifndef TOLUA_RELEASE
7466   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
7467 #endif
7468   {
7469    meshio::pmd::Material& tolua_ret = (meshio::pmd::Material&)  self->operator[](index);
7470     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::pmd::Material");
7471
7472   }
7473
7474  }
7475  return 1;
7476 #ifndef TOLUA_RELEASE
7477  tolua_lerror:
7478  tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
7479  return 0;
7480 #endif
7481 }
7482 #endif //#ifndef TOLUA_DISABLE
7483
7484 /* method: operator&[] of class  std::vector<meshio::pmd::Material> */
7485 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Material___seti00
7486 static int tolua_lmeshio_std_vector_meshio__pmd__Material___seti00(lua_State* tolua_S)
7487 {
7488 #ifndef TOLUA_RELEASE
7489  tolua_Error tolua_err;
7490  if (
7491      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::Material>",0,&tolua_err) ||
7492      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
7493      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"meshio::pmd::Material",0,&tolua_err)) ||
7494      !tolua_isnoobj(tolua_S,4,&tolua_err)
7495  )
7496   goto tolua_lerror;
7497  else
7498 #endif
7499  {
7500   std::vector<meshio::pmd::Material>* self = (std::vector<meshio::pmd::Material>*)  tolua_tousertype(tolua_S,1,0);
7501   int index = ((int)  tolua_tonumber(tolua_S,2,0));
7502   meshio::pmd::Material tolua_value = *((meshio::pmd::Material*)  tolua_tousertype(tolua_S,3,0));
7503 #ifndef TOLUA_RELEASE
7504   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
7505 #endif
7506   self->operator[](index) =  tolua_value;
7507  }
7508  return 0;
7509 #ifndef TOLUA_RELEASE
7510  tolua_lerror:
7511  tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
7512  return 0;
7513 #endif
7514 }
7515 #endif //#ifndef TOLUA_DISABLE
7516
7517 /* stl foreachi: class  std::vector<meshio::pmd::Material> */
7518 #ifndef TOLUA_DISABLE_tolua_lmeshio_std__vector_meshio__pmd__Material__iterator
7519 static int tolua_lmeshio_std__vector_meshio__pmd__Material__iterator_gc(lua_State* tolua_S)
7520 {
7521     //printf("tolua_lmeshio_std__vector_meshio__pmd__Material__iterator_gc\n");
7522     std::pair<std::vector<meshio::pmd::Material>::iterator, std::vector<meshio::pmd::Material>::iterator> *range=(std::pair<std::vector<meshio::pmd::Material>::iterator, std::vector<meshio::pmd::Material>::iterator>*)lua_touserdata(tolua_S, 1);
7523     range->~pair<std::vector<meshio::pmd::Material>::iterator, std::vector<meshio::pmd::Material>::iterator>();
7524     return 0;
7525 }
7526
7527 static int tolua_lmeshio_std__vector_meshio__pmd__Material__iterator_internal(lua_State* tolua_S)
7528 {
7529   std::pair<std::vector<meshio::pmd::Material>::iterator, std::vector<meshio::pmd::Material>::iterator> *range=(std::pair<std::vector<meshio::pmd::Material>::iterator, std::vector<meshio::pmd::Material>::iterator>*)lua_touserdata(tolua_S, lua_upvalueindex(1));
7530   if(range->first==range->second){
7531       return 0;
7532   }
7533   int index=lua_tonumber(tolua_S, lua_upvalueindex(2));
7534   tolua_pushnumber(tolua_S, index);
7535   // update index
7536   tolua_pushnumber(tolua_S, index+1);
7537   lua_replace(tolua_S, lua_upvalueindex(2));
7538
7539   //tolua_pushusertype(tolua_S, &(*range->first++), "meshio::pmd::Material");
7540    meshio::pmd::Material& tolua_ret = (meshio::pmd::Material&) *range->first++;
7541     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::pmd::Material");
7542
7543   return 2;
7544 }
7545
7546 static int tolua_lmeshio_std__vector_meshio__pmd__Material__iterator(lua_State* tolua_S)
7547 {
7548 #ifndef TOLUA_RELEASE
7549  tolua_Error tolua_err;
7550  if (
7551      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::Material>",0,&tolua_err) ||
7552      !tolua_isnoobj(tolua_S,2,&tolua_err)
7553  )
7554   goto tolua_lerror;
7555  else
7556 #endif
7557  {
7558   std::vector<meshio::pmd::Material>* self = (std::vector<meshio::pmd::Material>*)  tolua_tousertype(tolua_S,1,0);
7559 #ifndef TOLUA_RELEASE
7560   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'foreachi'", NULL);
7561 #endif
7562   {
7563     std::pair<std::vector<meshio::pmd::Material>::iterator, std::vector<meshio::pmd::Material>::iterator>* range=(std::pair<std::vector<meshio::pmd::Material>::iterator, std::vector<meshio::pmd::Material>::iterator>*)lua_newuserdata(tolua_S, sizeof(std::pair<std::vector<meshio::pmd::Material>::iterator, std::vector<meshio::pmd::Material>::iterator>));
7564     *range=std::make_pair(self->begin(), self->end());
7565     luaL_getmetatable(tolua_S, "std::pair<std::vector<meshio::pmd::Material>::iterator, std::vector<meshio::pmd::Material>::iterator>");
7566     lua_setmetatable(tolua_S, -2);
7567     lua_pushnumber(tolua_S, 0);
7568     // gc
7569     lua_pushcclosure(tolua_S, tolua_lmeshio_std__vector_meshio__pmd__Material__iterator_internal, 2);
7570   }
7571  }
7572  return 1;
7573 #ifndef TOLUA_RELEASE
7574  tolua_lerror:
7575  tolua_error(tolua_S,"#ferror in function 'foreachi'.",&tolua_err);
7576  return 0;
7577 #endif
7578 }
7579 #endif //#ifndef TOLUA_DISABLE
7580
7581
7582 /* method: new of class  std::vector<meshio::pmd::Bone> */
7583 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Bone__new00
7584 static int tolua_lmeshio_std_vector_meshio__pmd__Bone__new00(lua_State* tolua_S)
7585 {
7586 #ifndef TOLUA_RELEASE
7587  tolua_Error tolua_err;
7588  if (
7589      !tolua_isusertable(tolua_S,1,"std::vector<meshio::pmd::Bone>",0,&tolua_err) ||
7590      !tolua_isnoobj(tolua_S,2,&tolua_err)
7591  )
7592   goto tolua_lerror;
7593  else
7594 #endif
7595  {
7596
7597
7598   {
7599    std::vector<meshio::pmd::Bone>* tolua_ret = (std::vector<meshio::pmd::Bone>*)  Mtolua_new((std::vector<meshio::pmd::Bone>)());
7600     tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<meshio::pmd::Bone>");
7601   }
7602
7603  }
7604  return 1;
7605 #ifndef TOLUA_RELEASE
7606  tolua_lerror:
7607  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
7608  return 0;
7609 #endif
7610 }
7611 #endif //#ifndef TOLUA_DISABLE
7612
7613 /* method: new_local of class  std::vector<meshio::pmd::Bone> */
7614 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Bone__new00_local
7615 static int tolua_lmeshio_std_vector_meshio__pmd__Bone__new00_local(lua_State* tolua_S)
7616 {
7617 #ifndef TOLUA_RELEASE
7618  tolua_Error tolua_err;
7619  if (
7620      !tolua_isusertable(tolua_S,1,"std::vector<meshio::pmd::Bone>",0,&tolua_err) ||
7621      !tolua_isnoobj(tolua_S,2,&tolua_err)
7622  )
7623   goto tolua_lerror;
7624  else
7625 #endif
7626  {
7627
7628
7629   {
7630    std::vector<meshio::pmd::Bone>* tolua_ret = (std::vector<meshio::pmd::Bone>*)  Mtolua_new((std::vector<meshio::pmd::Bone>)());
7631     tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<meshio::pmd::Bone>");
7632     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
7633   }
7634
7635  }
7636  return 1;
7637 #ifndef TOLUA_RELEASE
7638  tolua_lerror:
7639  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
7640  return 0;
7641 #endif
7642 }
7643 #endif //#ifndef TOLUA_DISABLE
7644
7645 /* method: size of class  std::vector<meshio::pmd::Bone> */
7646 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Bone__size00
7647 static int tolua_lmeshio_std_vector_meshio__pmd__Bone__size00(lua_State* tolua_S)
7648 {
7649 #ifndef TOLUA_RELEASE
7650  tolua_Error tolua_err;
7651  if (
7652      !tolua_isusertype(tolua_S,1,"const std::vector<meshio::pmd::Bone>",0,&tolua_err) ||
7653      !tolua_isnoobj(tolua_S,2,&tolua_err)
7654  )
7655   goto tolua_lerror;
7656  else
7657 #endif
7658  {
7659   const std::vector<meshio::pmd::Bone>* self = (const std::vector<meshio::pmd::Bone>*)  tolua_tousertype(tolua_S,1,0);
7660 #ifndef TOLUA_RELEASE
7661   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
7662 #endif
7663   {
7664    unsigned int tolua_ret = (unsigned int)  self->size();
7665    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
7666   }
7667
7668  }
7669  return 1;
7670 #ifndef TOLUA_RELEASE
7671  tolua_lerror:
7672  tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
7673  return 0;
7674 #endif
7675 }
7676 #endif //#ifndef TOLUA_DISABLE
7677
7678 /* method: push_back of class  std::vector<meshio::pmd::Bone> */
7679 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Bone__push_back00
7680 static int tolua_lmeshio_std_vector_meshio__pmd__Bone__push_back00(lua_State* tolua_S)
7681 {
7682 #ifndef TOLUA_RELEASE
7683  tolua_Error tolua_err;
7684  if (
7685      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::Bone>",0,&tolua_err) ||
7686      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::pmd::Bone",0,&tolua_err)) ||
7687      !tolua_isnoobj(tolua_S,3,&tolua_err)
7688  )
7689   goto tolua_lerror;
7690  else
7691 #endif
7692  {
7693   std::vector<meshio::pmd::Bone>* self = (std::vector<meshio::pmd::Bone>*)  tolua_tousertype(tolua_S,1,0);
7694   meshio::pmd::Bone* value = ((meshio::pmd::Bone*)  tolua_tousertype(tolua_S,2,0));
7695 #ifndef TOLUA_RELEASE
7696   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
7697 #endif
7698   {
7699    self->push_back(*value);
7700
7701   }
7702
7703  }
7704  return 0;
7705 #ifndef TOLUA_RELEASE
7706  tolua_lerror:
7707  tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
7708  return 0;
7709 #endif
7710 }
7711 #endif //#ifndef TOLUA_DISABLE
7712
7713 /* method: back of class  std::vector<meshio::pmd::Bone> */
7714 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Bone__back00
7715 static int tolua_lmeshio_std_vector_meshio__pmd__Bone__back00(lua_State* tolua_S)
7716 {
7717 #ifndef TOLUA_RELEASE
7718  tolua_Error tolua_err;
7719  if (
7720      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::Bone>",0,&tolua_err) ||
7721      !tolua_isnoobj(tolua_S,2,&tolua_err)
7722  )
7723   goto tolua_lerror;
7724  else
7725 #endif
7726  {
7727   std::vector<meshio::pmd::Bone>* self = (std::vector<meshio::pmd::Bone>*)  tolua_tousertype(tolua_S,1,0);
7728 #ifndef TOLUA_RELEASE
7729   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'back'", NULL);
7730 #endif
7731   {
7732    meshio::pmd::Bone& tolua_ret = (meshio::pmd::Bone&)  self->back();
7733     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::pmd::Bone");
7734   }
7735
7736  }
7737  return 1;
7738 #ifndef TOLUA_RELEASE
7739  tolua_lerror:
7740  tolua_error(tolua_S,"#ferror in function 'back'.",&tolua_err);
7741  return 0;
7742 #endif
7743 }
7744 #endif //#ifndef TOLUA_DISABLE
7745
7746 /* method: operator[] of class  std::vector<meshio::pmd::Bone> */
7747 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Bone___geti00
7748 static int tolua_lmeshio_std_vector_meshio__pmd__Bone___geti00(lua_State* tolua_S)
7749 {
7750 #ifndef TOLUA_RELEASE
7751  tolua_Error tolua_err;
7752  if (
7753      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::Bone>",0,&tolua_err) ||
7754      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
7755      !tolua_isnoobj(tolua_S,3,&tolua_err)
7756  )
7757   goto tolua_lerror;
7758  else
7759 #endif
7760  {
7761   std::vector<meshio::pmd::Bone>* self = (std::vector<meshio::pmd::Bone>*)  tolua_tousertype(tolua_S,1,0);
7762   int index = ((int)  tolua_tonumber(tolua_S,2,0));
7763 #ifndef TOLUA_RELEASE
7764   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
7765 #endif
7766   {
7767    meshio::pmd::Bone& tolua_ret = (meshio::pmd::Bone&)  self->operator[](index);
7768     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::pmd::Bone");
7769
7770   }
7771
7772  }
7773  return 1;
7774 #ifndef TOLUA_RELEASE
7775  tolua_lerror:
7776  tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
7777  return 0;
7778 #endif
7779 }
7780 #endif //#ifndef TOLUA_DISABLE
7781
7782 /* method: operator&[] of class  std::vector<meshio::pmd::Bone> */
7783 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Bone___seti00
7784 static int tolua_lmeshio_std_vector_meshio__pmd__Bone___seti00(lua_State* tolua_S)
7785 {
7786 #ifndef TOLUA_RELEASE
7787  tolua_Error tolua_err;
7788  if (
7789      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::Bone>",0,&tolua_err) ||
7790      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
7791      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"meshio::pmd::Bone",0,&tolua_err)) ||
7792      !tolua_isnoobj(tolua_S,4,&tolua_err)
7793  )
7794   goto tolua_lerror;
7795  else
7796 #endif
7797  {
7798   std::vector<meshio::pmd::Bone>* self = (std::vector<meshio::pmd::Bone>*)  tolua_tousertype(tolua_S,1,0);
7799   int index = ((int)  tolua_tonumber(tolua_S,2,0));
7800   meshio::pmd::Bone tolua_value = *((meshio::pmd::Bone*)  tolua_tousertype(tolua_S,3,0));
7801 #ifndef TOLUA_RELEASE
7802   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
7803 #endif
7804   self->operator[](index) =  tolua_value;
7805  }
7806  return 0;
7807 #ifndef TOLUA_RELEASE
7808  tolua_lerror:
7809  tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
7810  return 0;
7811 #endif
7812 }
7813 #endif //#ifndef TOLUA_DISABLE
7814
7815 /* stl foreachi: class  std::vector<meshio::pmd::Bone> */
7816 #ifndef TOLUA_DISABLE_tolua_lmeshio_std__vector_meshio__pmd__Bone__iterator
7817 static int tolua_lmeshio_std__vector_meshio__pmd__Bone__iterator_gc(lua_State* tolua_S)
7818 {
7819     //printf("tolua_lmeshio_std__vector_meshio__pmd__Bone__iterator_gc\n");
7820     std::pair<std::vector<meshio::pmd::Bone>::iterator, std::vector<meshio::pmd::Bone>::iterator> *range=(std::pair<std::vector<meshio::pmd::Bone>::iterator, std::vector<meshio::pmd::Bone>::iterator>*)lua_touserdata(tolua_S, 1);
7821     range->~pair<std::vector<meshio::pmd::Bone>::iterator, std::vector<meshio::pmd::Bone>::iterator>();
7822     return 0;
7823 }
7824
7825 static int tolua_lmeshio_std__vector_meshio__pmd__Bone__iterator_internal(lua_State* tolua_S)
7826 {
7827   std::pair<std::vector<meshio::pmd::Bone>::iterator, std::vector<meshio::pmd::Bone>::iterator> *range=(std::pair<std::vector<meshio::pmd::Bone>::iterator, std::vector<meshio::pmd::Bone>::iterator>*)lua_touserdata(tolua_S, lua_upvalueindex(1));
7828   if(range->first==range->second){
7829       return 0;
7830   }
7831   int index=lua_tonumber(tolua_S, lua_upvalueindex(2));
7832   tolua_pushnumber(tolua_S, index);
7833   // update index
7834   tolua_pushnumber(tolua_S, index+1);
7835   lua_replace(tolua_S, lua_upvalueindex(2));
7836
7837   //tolua_pushusertype(tolua_S, &(*range->first++), "meshio::pmd::Bone");
7838    meshio::pmd::Bone& tolua_ret = (meshio::pmd::Bone&) *range->first++;
7839     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::pmd::Bone");
7840
7841   return 2;
7842 }
7843
7844 static int tolua_lmeshio_std__vector_meshio__pmd__Bone__iterator(lua_State* tolua_S)
7845 {
7846 #ifndef TOLUA_RELEASE
7847  tolua_Error tolua_err;
7848  if (
7849      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::Bone>",0,&tolua_err) ||
7850      !tolua_isnoobj(tolua_S,2,&tolua_err)
7851  )
7852   goto tolua_lerror;
7853  else
7854 #endif
7855  {
7856   std::vector<meshio::pmd::Bone>* self = (std::vector<meshio::pmd::Bone>*)  tolua_tousertype(tolua_S,1,0);
7857 #ifndef TOLUA_RELEASE
7858   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'foreachi'", NULL);
7859 #endif
7860   {
7861     std::pair<std::vector<meshio::pmd::Bone>::iterator, std::vector<meshio::pmd::Bone>::iterator>* range=(std::pair<std::vector<meshio::pmd::Bone>::iterator, std::vector<meshio::pmd::Bone>::iterator>*)lua_newuserdata(tolua_S, sizeof(std::pair<std::vector<meshio::pmd::Bone>::iterator, std::vector<meshio::pmd::Bone>::iterator>));
7862     *range=std::make_pair(self->begin(), self->end());
7863     luaL_getmetatable(tolua_S, "std::pair<std::vector<meshio::pmd::Bone>::iterator, std::vector<meshio::pmd::Bone>::iterator>");
7864     lua_setmetatable(tolua_S, -2);
7865     lua_pushnumber(tolua_S, 0);
7866     // gc
7867     lua_pushcclosure(tolua_S, tolua_lmeshio_std__vector_meshio__pmd__Bone__iterator_internal, 2);
7868   }
7869  }
7870  return 1;
7871 #ifndef TOLUA_RELEASE
7872  tolua_lerror:
7873  tolua_error(tolua_S,"#ferror in function 'foreachi'.",&tolua_err);
7874  return 0;
7875 #endif
7876 }
7877 #endif //#ifndef TOLUA_DISABLE
7878
7879
7880 /* method: new of class  std::vector<meshio::pmd::IK> */
7881 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__IK__new00
7882 static int tolua_lmeshio_std_vector_meshio__pmd__IK__new00(lua_State* tolua_S)
7883 {
7884 #ifndef TOLUA_RELEASE
7885  tolua_Error tolua_err;
7886  if (
7887      !tolua_isusertable(tolua_S,1,"std::vector<meshio::pmd::IK>",0,&tolua_err) ||
7888      !tolua_isnoobj(tolua_S,2,&tolua_err)
7889  )
7890   goto tolua_lerror;
7891  else
7892 #endif
7893  {
7894
7895
7896   {
7897    std::vector<meshio::pmd::IK>* tolua_ret = (std::vector<meshio::pmd::IK>*)  Mtolua_new((std::vector<meshio::pmd::IK>)());
7898     tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<meshio::pmd::IK>");
7899   }
7900
7901  }
7902  return 1;
7903 #ifndef TOLUA_RELEASE
7904  tolua_lerror:
7905  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
7906  return 0;
7907 #endif
7908 }
7909 #endif //#ifndef TOLUA_DISABLE
7910
7911 /* method: new_local of class  std::vector<meshio::pmd::IK> */
7912 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__IK__new00_local
7913 static int tolua_lmeshio_std_vector_meshio__pmd__IK__new00_local(lua_State* tolua_S)
7914 {
7915 #ifndef TOLUA_RELEASE
7916  tolua_Error tolua_err;
7917  if (
7918      !tolua_isusertable(tolua_S,1,"std::vector<meshio::pmd::IK>",0,&tolua_err) ||
7919      !tolua_isnoobj(tolua_S,2,&tolua_err)
7920  )
7921   goto tolua_lerror;
7922  else
7923 #endif
7924  {
7925
7926
7927   {
7928    std::vector<meshio::pmd::IK>* tolua_ret = (std::vector<meshio::pmd::IK>*)  Mtolua_new((std::vector<meshio::pmd::IK>)());
7929     tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<meshio::pmd::IK>");
7930     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
7931   }
7932
7933  }
7934  return 1;
7935 #ifndef TOLUA_RELEASE
7936  tolua_lerror:
7937  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
7938  return 0;
7939 #endif
7940 }
7941 #endif //#ifndef TOLUA_DISABLE
7942
7943 /* method: size of class  std::vector<meshio::pmd::IK> */
7944 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__IK__size00
7945 static int tolua_lmeshio_std_vector_meshio__pmd__IK__size00(lua_State* tolua_S)
7946 {
7947 #ifndef TOLUA_RELEASE
7948  tolua_Error tolua_err;
7949  if (
7950      !tolua_isusertype(tolua_S,1,"const std::vector<meshio::pmd::IK>",0,&tolua_err) ||
7951      !tolua_isnoobj(tolua_S,2,&tolua_err)
7952  )
7953   goto tolua_lerror;
7954  else
7955 #endif
7956  {
7957   const std::vector<meshio::pmd::IK>* self = (const std::vector<meshio::pmd::IK>*)  tolua_tousertype(tolua_S,1,0);
7958 #ifndef TOLUA_RELEASE
7959   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
7960 #endif
7961   {
7962    unsigned int tolua_ret = (unsigned int)  self->size();
7963    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
7964   }
7965
7966  }
7967  return 1;
7968 #ifndef TOLUA_RELEASE
7969  tolua_lerror:
7970  tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
7971  return 0;
7972 #endif
7973 }
7974 #endif //#ifndef TOLUA_DISABLE
7975
7976 /* method: push_back of class  std::vector<meshio::pmd::IK> */
7977 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__IK__push_back00
7978 static int tolua_lmeshio_std_vector_meshio__pmd__IK__push_back00(lua_State* tolua_S)
7979 {
7980 #ifndef TOLUA_RELEASE
7981  tolua_Error tolua_err;
7982  if (
7983      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::IK>",0,&tolua_err) ||
7984      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::pmd::IK",0,&tolua_err)) ||
7985      !tolua_isnoobj(tolua_S,3,&tolua_err)
7986  )
7987   goto tolua_lerror;
7988  else
7989 #endif
7990  {
7991   std::vector<meshio::pmd::IK>* self = (std::vector<meshio::pmd::IK>*)  tolua_tousertype(tolua_S,1,0);
7992   meshio::pmd::IK* value = ((meshio::pmd::IK*)  tolua_tousertype(tolua_S,2,0));
7993 #ifndef TOLUA_RELEASE
7994   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
7995 #endif
7996   {
7997    self->push_back(*value);
7998
7999   }
8000
8001  }
8002  return 0;
8003 #ifndef TOLUA_RELEASE
8004  tolua_lerror:
8005  tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
8006  return 0;
8007 #endif
8008 }
8009 #endif //#ifndef TOLUA_DISABLE
8010
8011 /* method: back of class  std::vector<meshio::pmd::IK> */
8012 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__IK__back00
8013 static int tolua_lmeshio_std_vector_meshio__pmd__IK__back00(lua_State* tolua_S)
8014 {
8015 #ifndef TOLUA_RELEASE
8016  tolua_Error tolua_err;
8017  if (
8018      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::IK>",0,&tolua_err) ||
8019      !tolua_isnoobj(tolua_S,2,&tolua_err)
8020  )
8021   goto tolua_lerror;
8022  else
8023 #endif
8024  {
8025   std::vector<meshio::pmd::IK>* self = (std::vector<meshio::pmd::IK>*)  tolua_tousertype(tolua_S,1,0);
8026 #ifndef TOLUA_RELEASE
8027   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'back'", NULL);
8028 #endif
8029   {
8030    meshio::pmd::IK& tolua_ret = (meshio::pmd::IK&)  self->back();
8031     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::pmd::IK");
8032   }
8033
8034  }
8035  return 1;
8036 #ifndef TOLUA_RELEASE
8037  tolua_lerror:
8038  tolua_error(tolua_S,"#ferror in function 'back'.",&tolua_err);
8039  return 0;
8040 #endif
8041 }
8042 #endif //#ifndef TOLUA_DISABLE
8043
8044 /* method: operator[] of class  std::vector<meshio::pmd::IK> */
8045 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__IK___geti00
8046 static int tolua_lmeshio_std_vector_meshio__pmd__IK___geti00(lua_State* tolua_S)
8047 {
8048 #ifndef TOLUA_RELEASE
8049  tolua_Error tolua_err;
8050  if (
8051      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::IK>",0,&tolua_err) ||
8052      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
8053      !tolua_isnoobj(tolua_S,3,&tolua_err)
8054  )
8055   goto tolua_lerror;
8056  else
8057 #endif
8058  {
8059   std::vector<meshio::pmd::IK>* self = (std::vector<meshio::pmd::IK>*)  tolua_tousertype(tolua_S,1,0);
8060   int index = ((int)  tolua_tonumber(tolua_S,2,0));
8061 #ifndef TOLUA_RELEASE
8062   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
8063 #endif
8064   {
8065    meshio::pmd::IK& tolua_ret = (meshio::pmd::IK&)  self->operator[](index);
8066     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::pmd::IK");
8067
8068   }
8069
8070  }
8071  return 1;
8072 #ifndef TOLUA_RELEASE
8073  tolua_lerror:
8074  tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
8075  return 0;
8076 #endif
8077 }
8078 #endif //#ifndef TOLUA_DISABLE
8079
8080 /* method: operator&[] of class  std::vector<meshio::pmd::IK> */
8081 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__IK___seti00
8082 static int tolua_lmeshio_std_vector_meshio__pmd__IK___seti00(lua_State* tolua_S)
8083 {
8084 #ifndef TOLUA_RELEASE
8085  tolua_Error tolua_err;
8086  if (
8087      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::IK>",0,&tolua_err) ||
8088      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
8089      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"meshio::pmd::IK",0,&tolua_err)) ||
8090      !tolua_isnoobj(tolua_S,4,&tolua_err)
8091  )
8092   goto tolua_lerror;
8093  else
8094 #endif
8095  {
8096   std::vector<meshio::pmd::IK>* self = (std::vector<meshio::pmd::IK>*)  tolua_tousertype(tolua_S,1,0);
8097   int index = ((int)  tolua_tonumber(tolua_S,2,0));
8098   meshio::pmd::IK tolua_value = *((meshio::pmd::IK*)  tolua_tousertype(tolua_S,3,0));
8099 #ifndef TOLUA_RELEASE
8100   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
8101 #endif
8102   self->operator[](index) =  tolua_value;
8103  }
8104  return 0;
8105 #ifndef TOLUA_RELEASE
8106  tolua_lerror:
8107  tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
8108  return 0;
8109 #endif
8110 }
8111 #endif //#ifndef TOLUA_DISABLE
8112
8113 /* stl foreachi: class  std::vector<meshio::pmd::IK> */
8114 #ifndef TOLUA_DISABLE_tolua_lmeshio_std__vector_meshio__pmd__IK__iterator
8115 static int tolua_lmeshio_std__vector_meshio__pmd__IK__iterator_gc(lua_State* tolua_S)
8116 {
8117     //printf("tolua_lmeshio_std__vector_meshio__pmd__IK__iterator_gc\n");
8118     std::pair<std::vector<meshio::pmd::IK>::iterator, std::vector<meshio::pmd::IK>::iterator> *range=(std::pair<std::vector<meshio::pmd::IK>::iterator, std::vector<meshio::pmd::IK>::iterator>*)lua_touserdata(tolua_S, 1);
8119     range->~pair<std::vector<meshio::pmd::IK>::iterator, std::vector<meshio::pmd::IK>::iterator>();
8120     return 0;
8121 }
8122
8123 static int tolua_lmeshio_std__vector_meshio__pmd__IK__iterator_internal(lua_State* tolua_S)
8124 {
8125   std::pair<std::vector<meshio::pmd::IK>::iterator, std::vector<meshio::pmd::IK>::iterator> *range=(std::pair<std::vector<meshio::pmd::IK>::iterator, std::vector<meshio::pmd::IK>::iterator>*)lua_touserdata(tolua_S, lua_upvalueindex(1));
8126   if(range->first==range->second){
8127       return 0;
8128   }
8129   int index=lua_tonumber(tolua_S, lua_upvalueindex(2));
8130   tolua_pushnumber(tolua_S, index);
8131   // update index
8132   tolua_pushnumber(tolua_S, index+1);
8133   lua_replace(tolua_S, lua_upvalueindex(2));
8134
8135   //tolua_pushusertype(tolua_S, &(*range->first++), "meshio::pmd::IK");
8136    meshio::pmd::IK& tolua_ret = (meshio::pmd::IK&) *range->first++;
8137     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::pmd::IK");
8138
8139   return 2;
8140 }
8141
8142 static int tolua_lmeshio_std__vector_meshio__pmd__IK__iterator(lua_State* tolua_S)
8143 {
8144 #ifndef TOLUA_RELEASE
8145  tolua_Error tolua_err;
8146  if (
8147      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::IK>",0,&tolua_err) ||
8148      !tolua_isnoobj(tolua_S,2,&tolua_err)
8149  )
8150   goto tolua_lerror;
8151  else
8152 #endif
8153  {
8154   std::vector<meshio::pmd::IK>* self = (std::vector<meshio::pmd::IK>*)  tolua_tousertype(tolua_S,1,0);
8155 #ifndef TOLUA_RELEASE
8156   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'foreachi'", NULL);
8157 #endif
8158   {
8159     std::pair<std::vector<meshio::pmd::IK>::iterator, std::vector<meshio::pmd::IK>::iterator>* range=(std::pair<std::vector<meshio::pmd::IK>::iterator, std::vector<meshio::pmd::IK>::iterator>*)lua_newuserdata(tolua_S, sizeof(std::pair<std::vector<meshio::pmd::IK>::iterator, std::vector<meshio::pmd::IK>::iterator>));
8160     *range=std::make_pair(self->begin(), self->end());
8161     luaL_getmetatable(tolua_S, "std::pair<std::vector<meshio::pmd::IK>::iterator, std::vector<meshio::pmd::IK>::iterator>");
8162     lua_setmetatable(tolua_S, -2);
8163     lua_pushnumber(tolua_S, 0);
8164     // gc
8165     lua_pushcclosure(tolua_S, tolua_lmeshio_std__vector_meshio__pmd__IK__iterator_internal, 2);
8166   }
8167  }
8168  return 1;
8169 #ifndef TOLUA_RELEASE
8170  tolua_lerror:
8171  tolua_error(tolua_S,"#ferror in function 'foreachi'.",&tolua_err);
8172  return 0;
8173 #endif
8174 }
8175 #endif //#ifndef TOLUA_DISABLE
8176
8177
8178 /* method: new of class  std::vector<meshio::pmd::Morph> */
8179 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Morph__new00
8180 static int tolua_lmeshio_std_vector_meshio__pmd__Morph__new00(lua_State* tolua_S)
8181 {
8182 #ifndef TOLUA_RELEASE
8183  tolua_Error tolua_err;
8184  if (
8185      !tolua_isusertable(tolua_S,1,"std::vector<meshio::pmd::Morph>",0,&tolua_err) ||
8186      !tolua_isnoobj(tolua_S,2,&tolua_err)
8187  )
8188   goto tolua_lerror;
8189  else
8190 #endif
8191  {
8192
8193
8194   {
8195    std::vector<meshio::pmd::Morph>* tolua_ret = (std::vector<meshio::pmd::Morph>*)  Mtolua_new((std::vector<meshio::pmd::Morph>)());
8196     tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<meshio::pmd::Morph>");
8197   }
8198
8199  }
8200  return 1;
8201 #ifndef TOLUA_RELEASE
8202  tolua_lerror:
8203  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
8204  return 0;
8205 #endif
8206 }
8207 #endif //#ifndef TOLUA_DISABLE
8208
8209 /* method: new_local of class  std::vector<meshio::pmd::Morph> */
8210 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Morph__new00_local
8211 static int tolua_lmeshio_std_vector_meshio__pmd__Morph__new00_local(lua_State* tolua_S)
8212 {
8213 #ifndef TOLUA_RELEASE
8214  tolua_Error tolua_err;
8215  if (
8216      !tolua_isusertable(tolua_S,1,"std::vector<meshio::pmd::Morph>",0,&tolua_err) ||
8217      !tolua_isnoobj(tolua_S,2,&tolua_err)
8218  )
8219   goto tolua_lerror;
8220  else
8221 #endif
8222  {
8223
8224
8225   {
8226    std::vector<meshio::pmd::Morph>* tolua_ret = (std::vector<meshio::pmd::Morph>*)  Mtolua_new((std::vector<meshio::pmd::Morph>)());
8227     tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<meshio::pmd::Morph>");
8228     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
8229   }
8230
8231  }
8232  return 1;
8233 #ifndef TOLUA_RELEASE
8234  tolua_lerror:
8235  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
8236  return 0;
8237 #endif
8238 }
8239 #endif //#ifndef TOLUA_DISABLE
8240
8241 /* method: size of class  std::vector<meshio::pmd::Morph> */
8242 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Morph__size00
8243 static int tolua_lmeshio_std_vector_meshio__pmd__Morph__size00(lua_State* tolua_S)
8244 {
8245 #ifndef TOLUA_RELEASE
8246  tolua_Error tolua_err;
8247  if (
8248      !tolua_isusertype(tolua_S,1,"const std::vector<meshio::pmd::Morph>",0,&tolua_err) ||
8249      !tolua_isnoobj(tolua_S,2,&tolua_err)
8250  )
8251   goto tolua_lerror;
8252  else
8253 #endif
8254  {
8255   const std::vector<meshio::pmd::Morph>* self = (const std::vector<meshio::pmd::Morph>*)  tolua_tousertype(tolua_S,1,0);
8256 #ifndef TOLUA_RELEASE
8257   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
8258 #endif
8259   {
8260    unsigned int tolua_ret = (unsigned int)  self->size();
8261    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
8262   }
8263
8264  }
8265  return 1;
8266 #ifndef TOLUA_RELEASE
8267  tolua_lerror:
8268  tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
8269  return 0;
8270 #endif
8271 }
8272 #endif //#ifndef TOLUA_DISABLE
8273
8274 /* method: push_back of class  std::vector<meshio::pmd::Morph> */
8275 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Morph__push_back00
8276 static int tolua_lmeshio_std_vector_meshio__pmd__Morph__push_back00(lua_State* tolua_S)
8277 {
8278 #ifndef TOLUA_RELEASE
8279  tolua_Error tolua_err;
8280  if (
8281      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::Morph>",0,&tolua_err) ||
8282      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::pmd::Morph",0,&tolua_err)) ||
8283      !tolua_isnoobj(tolua_S,3,&tolua_err)
8284  )
8285   goto tolua_lerror;
8286  else
8287 #endif
8288  {
8289   std::vector<meshio::pmd::Morph>* self = (std::vector<meshio::pmd::Morph>*)  tolua_tousertype(tolua_S,1,0);
8290   meshio::pmd::Morph* value = ((meshio::pmd::Morph*)  tolua_tousertype(tolua_S,2,0));
8291 #ifndef TOLUA_RELEASE
8292   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
8293 #endif
8294   {
8295    self->push_back(*value);
8296
8297   }
8298
8299  }
8300  return 0;
8301 #ifndef TOLUA_RELEASE
8302  tolua_lerror:
8303  tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
8304  return 0;
8305 #endif
8306 }
8307 #endif //#ifndef TOLUA_DISABLE
8308
8309 /* method: back of class  std::vector<meshio::pmd::Morph> */
8310 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Morph__back00
8311 static int tolua_lmeshio_std_vector_meshio__pmd__Morph__back00(lua_State* tolua_S)
8312 {
8313 #ifndef TOLUA_RELEASE
8314  tolua_Error tolua_err;
8315  if (
8316      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::Morph>",0,&tolua_err) ||
8317      !tolua_isnoobj(tolua_S,2,&tolua_err)
8318  )
8319   goto tolua_lerror;
8320  else
8321 #endif
8322  {
8323   std::vector<meshio::pmd::Morph>* self = (std::vector<meshio::pmd::Morph>*)  tolua_tousertype(tolua_S,1,0);
8324 #ifndef TOLUA_RELEASE
8325   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'back'", NULL);
8326 #endif
8327   {
8328    meshio::pmd::Morph& tolua_ret = (meshio::pmd::Morph&)  self->back();
8329     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::pmd::Morph");
8330   }
8331
8332  }
8333  return 1;
8334 #ifndef TOLUA_RELEASE
8335  tolua_lerror:
8336  tolua_error(tolua_S,"#ferror in function 'back'.",&tolua_err);
8337  return 0;
8338 #endif
8339 }
8340 #endif //#ifndef TOLUA_DISABLE
8341
8342 /* method: operator[] of class  std::vector<meshio::pmd::Morph> */
8343 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Morph___geti00
8344 static int tolua_lmeshio_std_vector_meshio__pmd__Morph___geti00(lua_State* tolua_S)
8345 {
8346 #ifndef TOLUA_RELEASE
8347  tolua_Error tolua_err;
8348  if (
8349      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::Morph>",0,&tolua_err) ||
8350      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
8351      !tolua_isnoobj(tolua_S,3,&tolua_err)
8352  )
8353   goto tolua_lerror;
8354  else
8355 #endif
8356  {
8357   std::vector<meshio::pmd::Morph>* self = (std::vector<meshio::pmd::Morph>*)  tolua_tousertype(tolua_S,1,0);
8358   int index = ((int)  tolua_tonumber(tolua_S,2,0));
8359 #ifndef TOLUA_RELEASE
8360   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
8361 #endif
8362   {
8363    meshio::pmd::Morph& tolua_ret = (meshio::pmd::Morph&)  self->operator[](index);
8364     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::pmd::Morph");
8365
8366   }
8367
8368  }
8369  return 1;
8370 #ifndef TOLUA_RELEASE
8371  tolua_lerror:
8372  tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
8373  return 0;
8374 #endif
8375 }
8376 #endif //#ifndef TOLUA_DISABLE
8377
8378 /* method: operator&[] of class  std::vector<meshio::pmd::Morph> */
8379 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Morph___seti00
8380 static int tolua_lmeshio_std_vector_meshio__pmd__Morph___seti00(lua_State* tolua_S)
8381 {
8382 #ifndef TOLUA_RELEASE
8383  tolua_Error tolua_err;
8384  if (
8385      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::Morph>",0,&tolua_err) ||
8386      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
8387      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"meshio::pmd::Morph",0,&tolua_err)) ||
8388      !tolua_isnoobj(tolua_S,4,&tolua_err)
8389  )
8390   goto tolua_lerror;
8391  else
8392 #endif
8393  {
8394   std::vector<meshio::pmd::Morph>* self = (std::vector<meshio::pmd::Morph>*)  tolua_tousertype(tolua_S,1,0);
8395   int index = ((int)  tolua_tonumber(tolua_S,2,0));
8396   meshio::pmd::Morph tolua_value = *((meshio::pmd::Morph*)  tolua_tousertype(tolua_S,3,0));
8397 #ifndef TOLUA_RELEASE
8398   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
8399 #endif
8400   self->operator[](index) =  tolua_value;
8401  }
8402  return 0;
8403 #ifndef TOLUA_RELEASE
8404  tolua_lerror:
8405  tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
8406  return 0;
8407 #endif
8408 }
8409 #endif //#ifndef TOLUA_DISABLE
8410
8411 /* stl foreachi: class  std::vector<meshio::pmd::Morph> */
8412 #ifndef TOLUA_DISABLE_tolua_lmeshio_std__vector_meshio__pmd__Morph__iterator
8413 static int tolua_lmeshio_std__vector_meshio__pmd__Morph__iterator_gc(lua_State* tolua_S)
8414 {
8415     //printf("tolua_lmeshio_std__vector_meshio__pmd__Morph__iterator_gc\n");
8416     std::pair<std::vector<meshio::pmd::Morph>::iterator, std::vector<meshio::pmd::Morph>::iterator> *range=(std::pair<std::vector<meshio::pmd::Morph>::iterator, std::vector<meshio::pmd::Morph>::iterator>*)lua_touserdata(tolua_S, 1);
8417     range->~pair<std::vector<meshio::pmd::Morph>::iterator, std::vector<meshio::pmd::Morph>::iterator>();
8418     return 0;
8419 }
8420
8421 static int tolua_lmeshio_std__vector_meshio__pmd__Morph__iterator_internal(lua_State* tolua_S)
8422 {
8423   std::pair<std::vector<meshio::pmd::Morph>::iterator, std::vector<meshio::pmd::Morph>::iterator> *range=(std::pair<std::vector<meshio::pmd::Morph>::iterator, std::vector<meshio::pmd::Morph>::iterator>*)lua_touserdata(tolua_S, lua_upvalueindex(1));
8424   if(range->first==range->second){
8425       return 0;
8426   }
8427   int index=lua_tonumber(tolua_S, lua_upvalueindex(2));
8428   tolua_pushnumber(tolua_S, index);
8429   // update index
8430   tolua_pushnumber(tolua_S, index+1);
8431   lua_replace(tolua_S, lua_upvalueindex(2));
8432
8433   //tolua_pushusertype(tolua_S, &(*range->first++), "meshio::pmd::Morph");
8434    meshio::pmd::Morph& tolua_ret = (meshio::pmd::Morph&) *range->first++;
8435     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::pmd::Morph");
8436
8437   return 2;
8438 }
8439
8440 static int tolua_lmeshio_std__vector_meshio__pmd__Morph__iterator(lua_State* tolua_S)
8441 {
8442 #ifndef TOLUA_RELEASE
8443  tolua_Error tolua_err;
8444  if (
8445      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::Morph>",0,&tolua_err) ||
8446      !tolua_isnoobj(tolua_S,2,&tolua_err)
8447  )
8448   goto tolua_lerror;
8449  else
8450 #endif
8451  {
8452   std::vector<meshio::pmd::Morph>* self = (std::vector<meshio::pmd::Morph>*)  tolua_tousertype(tolua_S,1,0);
8453 #ifndef TOLUA_RELEASE
8454   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'foreachi'", NULL);
8455 #endif
8456   {
8457     std::pair<std::vector<meshio::pmd::Morph>::iterator, std::vector<meshio::pmd::Morph>::iterator>* range=(std::pair<std::vector<meshio::pmd::Morph>::iterator, std::vector<meshio::pmd::Morph>::iterator>*)lua_newuserdata(tolua_S, sizeof(std::pair<std::vector<meshio::pmd::Morph>::iterator, std::vector<meshio::pmd::Morph>::iterator>));
8458     *range=std::make_pair(self->begin(), self->end());
8459     luaL_getmetatable(tolua_S, "std::pair<std::vector<meshio::pmd::Morph>::iterator, std::vector<meshio::pmd::Morph>::iterator>");
8460     lua_setmetatable(tolua_S, -2);
8461     lua_pushnumber(tolua_S, 0);
8462     // gc
8463     lua_pushcclosure(tolua_S, tolua_lmeshio_std__vector_meshio__pmd__Morph__iterator_internal, 2);
8464   }
8465  }
8466  return 1;
8467 #ifndef TOLUA_RELEASE
8468  tolua_lerror:
8469  tolua_error(tolua_S,"#ferror in function 'foreachi'.",&tolua_err);
8470  return 0;
8471 #endif
8472 }
8473 #endif //#ifndef TOLUA_DISABLE
8474
8475
8476 /* method: new of class  std::vector<meshio::pmd::BoneGroup> */
8477 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__BoneGroup__new00
8478 static int tolua_lmeshio_std_vector_meshio__pmd__BoneGroup__new00(lua_State* tolua_S)
8479 {
8480 #ifndef TOLUA_RELEASE
8481  tolua_Error tolua_err;
8482  if (
8483      !tolua_isusertable(tolua_S,1,"std::vector<meshio::pmd::BoneGroup>",0,&tolua_err) ||
8484      !tolua_isnoobj(tolua_S,2,&tolua_err)
8485  )
8486   goto tolua_lerror;
8487  else
8488 #endif
8489  {
8490
8491
8492   {
8493    std::vector<meshio::pmd::BoneGroup>* tolua_ret = (std::vector<meshio::pmd::BoneGroup>*)  Mtolua_new((std::vector<meshio::pmd::BoneGroup>)());
8494     tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<meshio::pmd::BoneGroup>");
8495   }
8496
8497  }
8498  return 1;
8499 #ifndef TOLUA_RELEASE
8500  tolua_lerror:
8501  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
8502  return 0;
8503 #endif
8504 }
8505 #endif //#ifndef TOLUA_DISABLE
8506
8507 /* method: new_local of class  std::vector<meshio::pmd::BoneGroup> */
8508 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__BoneGroup__new00_local
8509 static int tolua_lmeshio_std_vector_meshio__pmd__BoneGroup__new00_local(lua_State* tolua_S)
8510 {
8511 #ifndef TOLUA_RELEASE
8512  tolua_Error tolua_err;
8513  if (
8514      !tolua_isusertable(tolua_S,1,"std::vector<meshio::pmd::BoneGroup>",0,&tolua_err) ||
8515      !tolua_isnoobj(tolua_S,2,&tolua_err)
8516  )
8517   goto tolua_lerror;
8518  else
8519 #endif
8520  {
8521
8522
8523   {
8524    std::vector<meshio::pmd::BoneGroup>* tolua_ret = (std::vector<meshio::pmd::BoneGroup>*)  Mtolua_new((std::vector<meshio::pmd::BoneGroup>)());
8525     tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<meshio::pmd::BoneGroup>");
8526     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
8527   }
8528
8529  }
8530  return 1;
8531 #ifndef TOLUA_RELEASE
8532  tolua_lerror:
8533  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
8534  return 0;
8535 #endif
8536 }
8537 #endif //#ifndef TOLUA_DISABLE
8538
8539 /* method: size of class  std::vector<meshio::pmd::BoneGroup> */
8540 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__BoneGroup__size00
8541 static int tolua_lmeshio_std_vector_meshio__pmd__BoneGroup__size00(lua_State* tolua_S)
8542 {
8543 #ifndef TOLUA_RELEASE
8544  tolua_Error tolua_err;
8545  if (
8546      !tolua_isusertype(tolua_S,1,"const std::vector<meshio::pmd::BoneGroup>",0,&tolua_err) ||
8547      !tolua_isnoobj(tolua_S,2,&tolua_err)
8548  )
8549   goto tolua_lerror;
8550  else
8551 #endif
8552  {
8553   const std::vector<meshio::pmd::BoneGroup>* self = (const std::vector<meshio::pmd::BoneGroup>*)  tolua_tousertype(tolua_S,1,0);
8554 #ifndef TOLUA_RELEASE
8555   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
8556 #endif
8557   {
8558    unsigned int tolua_ret = (unsigned int)  self->size();
8559    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
8560   }
8561
8562  }
8563  return 1;
8564 #ifndef TOLUA_RELEASE
8565  tolua_lerror:
8566  tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
8567  return 0;
8568 #endif
8569 }
8570 #endif //#ifndef TOLUA_DISABLE
8571
8572 /* method: push_back of class  std::vector<meshio::pmd::BoneGroup> */
8573 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__BoneGroup__push_back00
8574 static int tolua_lmeshio_std_vector_meshio__pmd__BoneGroup__push_back00(lua_State* tolua_S)
8575 {
8576 #ifndef TOLUA_RELEASE
8577  tolua_Error tolua_err;
8578  if (
8579      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::BoneGroup>",0,&tolua_err) ||
8580      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::pmd::BoneGroup",0,&tolua_err)) ||
8581      !tolua_isnoobj(tolua_S,3,&tolua_err)
8582  )
8583   goto tolua_lerror;
8584  else
8585 #endif
8586  {
8587   std::vector<meshio::pmd::BoneGroup>* self = (std::vector<meshio::pmd::BoneGroup>*)  tolua_tousertype(tolua_S,1,0);
8588   meshio::pmd::BoneGroup* value = ((meshio::pmd::BoneGroup*)  tolua_tousertype(tolua_S,2,0));
8589 #ifndef TOLUA_RELEASE
8590   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
8591 #endif
8592   {
8593    self->push_back(*value);
8594
8595   }
8596
8597  }
8598  return 0;
8599 #ifndef TOLUA_RELEASE
8600  tolua_lerror:
8601  tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
8602  return 0;
8603 #endif
8604 }
8605 #endif //#ifndef TOLUA_DISABLE
8606
8607 /* method: back of class  std::vector<meshio::pmd::BoneGroup> */
8608 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__BoneGroup__back00
8609 static int tolua_lmeshio_std_vector_meshio__pmd__BoneGroup__back00(lua_State* tolua_S)
8610 {
8611 #ifndef TOLUA_RELEASE
8612  tolua_Error tolua_err;
8613  if (
8614      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::BoneGroup>",0,&tolua_err) ||
8615      !tolua_isnoobj(tolua_S,2,&tolua_err)
8616  )
8617   goto tolua_lerror;
8618  else
8619 #endif
8620  {
8621   std::vector<meshio::pmd::BoneGroup>* self = (std::vector<meshio::pmd::BoneGroup>*)  tolua_tousertype(tolua_S,1,0);
8622 #ifndef TOLUA_RELEASE
8623   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'back'", NULL);
8624 #endif
8625   {
8626    meshio::pmd::BoneGroup& tolua_ret = (meshio::pmd::BoneGroup&)  self->back();
8627     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::pmd::BoneGroup");
8628   }
8629
8630  }
8631  return 1;
8632 #ifndef TOLUA_RELEASE
8633  tolua_lerror:
8634  tolua_error(tolua_S,"#ferror in function 'back'.",&tolua_err);
8635  return 0;
8636 #endif
8637 }
8638 #endif //#ifndef TOLUA_DISABLE
8639
8640 /* method: operator[] of class  std::vector<meshio::pmd::BoneGroup> */
8641 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__BoneGroup___geti00
8642 static int tolua_lmeshio_std_vector_meshio__pmd__BoneGroup___geti00(lua_State* tolua_S)
8643 {
8644 #ifndef TOLUA_RELEASE
8645  tolua_Error tolua_err;
8646  if (
8647      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::BoneGroup>",0,&tolua_err) ||
8648      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
8649      !tolua_isnoobj(tolua_S,3,&tolua_err)
8650  )
8651   goto tolua_lerror;
8652  else
8653 #endif
8654  {
8655   std::vector<meshio::pmd::BoneGroup>* self = (std::vector<meshio::pmd::BoneGroup>*)  tolua_tousertype(tolua_S,1,0);
8656   int index = ((int)  tolua_tonumber(tolua_S,2,0));
8657 #ifndef TOLUA_RELEASE
8658   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
8659 #endif
8660   {
8661    meshio::pmd::BoneGroup& tolua_ret = (meshio::pmd::BoneGroup&)  self->operator[](index);
8662     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::pmd::BoneGroup");
8663
8664   }
8665
8666  }
8667  return 1;
8668 #ifndef TOLUA_RELEASE
8669  tolua_lerror:
8670  tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
8671  return 0;
8672 #endif
8673 }
8674 #endif //#ifndef TOLUA_DISABLE
8675
8676 /* method: operator&[] of class  std::vector<meshio::pmd::BoneGroup> */
8677 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__BoneGroup___seti00
8678 static int tolua_lmeshio_std_vector_meshio__pmd__BoneGroup___seti00(lua_State* tolua_S)
8679 {
8680 #ifndef TOLUA_RELEASE
8681  tolua_Error tolua_err;
8682  if (
8683      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::BoneGroup>",0,&tolua_err) ||
8684      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
8685      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"meshio::pmd::BoneGroup",0,&tolua_err)) ||
8686      !tolua_isnoobj(tolua_S,4,&tolua_err)
8687  )
8688   goto tolua_lerror;
8689  else
8690 #endif
8691  {
8692   std::vector<meshio::pmd::BoneGroup>* self = (std::vector<meshio::pmd::BoneGroup>*)  tolua_tousertype(tolua_S,1,0);
8693   int index = ((int)  tolua_tonumber(tolua_S,2,0));
8694   meshio::pmd::BoneGroup tolua_value = *((meshio::pmd::BoneGroup*)  tolua_tousertype(tolua_S,3,0));
8695 #ifndef TOLUA_RELEASE
8696   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
8697 #endif
8698   self->operator[](index) =  tolua_value;
8699  }
8700  return 0;
8701 #ifndef TOLUA_RELEASE
8702  tolua_lerror:
8703  tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
8704  return 0;
8705 #endif
8706 }
8707 #endif //#ifndef TOLUA_DISABLE
8708
8709 /* stl foreachi: class  std::vector<meshio::pmd::BoneGroup> */
8710 #ifndef TOLUA_DISABLE_tolua_lmeshio_std__vector_meshio__pmd__BoneGroup__iterator
8711 static int tolua_lmeshio_std__vector_meshio__pmd__BoneGroup__iterator_gc(lua_State* tolua_S)
8712 {
8713     //printf("tolua_lmeshio_std__vector_meshio__pmd__BoneGroup__iterator_gc\n");
8714     std::pair<std::vector<meshio::pmd::BoneGroup>::iterator, std::vector<meshio::pmd::BoneGroup>::iterator> *range=(std::pair<std::vector<meshio::pmd::BoneGroup>::iterator, std::vector<meshio::pmd::BoneGroup>::iterator>*)lua_touserdata(tolua_S, 1);
8715     range->~pair<std::vector<meshio::pmd::BoneGroup>::iterator, std::vector<meshio::pmd::BoneGroup>::iterator>();
8716     return 0;
8717 }
8718
8719 static int tolua_lmeshio_std__vector_meshio__pmd__BoneGroup__iterator_internal(lua_State* tolua_S)
8720 {
8721   std::pair<std::vector<meshio::pmd::BoneGroup>::iterator, std::vector<meshio::pmd::BoneGroup>::iterator> *range=(std::pair<std::vector<meshio::pmd::BoneGroup>::iterator, std::vector<meshio::pmd::BoneGroup>::iterator>*)lua_touserdata(tolua_S, lua_upvalueindex(1));
8722   if(range->first==range->second){
8723       return 0;
8724   }
8725   int index=lua_tonumber(tolua_S, lua_upvalueindex(2));
8726   tolua_pushnumber(tolua_S, index);
8727   // update index
8728   tolua_pushnumber(tolua_S, index+1);
8729   lua_replace(tolua_S, lua_upvalueindex(2));
8730
8731   //tolua_pushusertype(tolua_S, &(*range->first++), "meshio::pmd::BoneGroup");
8732    meshio::pmd::BoneGroup& tolua_ret = (meshio::pmd::BoneGroup&) *range->first++;
8733     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::pmd::BoneGroup");
8734
8735   return 2;
8736 }
8737
8738 static int tolua_lmeshio_std__vector_meshio__pmd__BoneGroup__iterator(lua_State* tolua_S)
8739 {
8740 #ifndef TOLUA_RELEASE
8741  tolua_Error tolua_err;
8742  if (
8743      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::BoneGroup>",0,&tolua_err) ||
8744      !tolua_isnoobj(tolua_S,2,&tolua_err)
8745  )
8746   goto tolua_lerror;
8747  else
8748 #endif
8749  {
8750   std::vector<meshio::pmd::BoneGroup>* self = (std::vector<meshio::pmd::BoneGroup>*)  tolua_tousertype(tolua_S,1,0);
8751 #ifndef TOLUA_RELEASE
8752   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'foreachi'", NULL);
8753 #endif
8754   {
8755     std::pair<std::vector<meshio::pmd::BoneGroup>::iterator, std::vector<meshio::pmd::BoneGroup>::iterator>* range=(std::pair<std::vector<meshio::pmd::BoneGroup>::iterator, std::vector<meshio::pmd::BoneGroup>::iterator>*)lua_newuserdata(tolua_S, sizeof(std::pair<std::vector<meshio::pmd::BoneGroup>::iterator, std::vector<meshio::pmd::BoneGroup>::iterator>));
8756     *range=std::make_pair(self->begin(), self->end());
8757     luaL_getmetatable(tolua_S, "std::pair<std::vector<meshio::pmd::BoneGroup>::iterator, std::vector<meshio::pmd::BoneGroup>::iterator>");
8758     lua_setmetatable(tolua_S, -2);
8759     lua_pushnumber(tolua_S, 0);
8760     // gc
8761     lua_pushcclosure(tolua_S, tolua_lmeshio_std__vector_meshio__pmd__BoneGroup__iterator_internal, 2);
8762   }
8763  }
8764  return 1;
8765 #ifndef TOLUA_RELEASE
8766  tolua_lerror:
8767  tolua_error(tolua_S,"#ferror in function 'foreachi'.",&tolua_err);
8768  return 0;
8769 #endif
8770 }
8771 #endif //#ifndef TOLUA_DISABLE
8772
8773
8774 /* method: new of class  std::vector<std::pair<unsigned short,unsigned char> > */
8775 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_std__pair_unsigned_short_unsigned_char____new00
8776 static int tolua_lmeshio_std_vector_std__pair_unsigned_short_unsigned_char____new00(lua_State* tolua_S)
8777 {
8778 #ifndef TOLUA_RELEASE
8779  tolua_Error tolua_err;
8780  if (
8781      !tolua_isusertable(tolua_S,1,"std::vector<std::pair<unsigned short,unsigned char> >",0,&tolua_err) ||
8782      !tolua_isnoobj(tolua_S,2,&tolua_err)
8783  )
8784   goto tolua_lerror;
8785  else
8786 #endif
8787  {
8788
8789
8790   {
8791    std::vector<std::pair<unsigned short,unsigned char> >* tolua_ret = (std::vector<std::pair<unsigned short,unsigned char> >*)  Mtolua_new((std::vector<std::pair<unsigned short,unsigned char> >)());
8792     tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<std::pair<unsigned short,unsigned char> >");
8793   }
8794
8795  }
8796  return 1;
8797 #ifndef TOLUA_RELEASE
8798  tolua_lerror:
8799  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
8800  return 0;
8801 #endif
8802 }
8803 #endif //#ifndef TOLUA_DISABLE
8804
8805 /* method: new_local of class  std::vector<std::pair<unsigned short,unsigned char> > */
8806 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_std__pair_unsigned_short_unsigned_char____new00_local
8807 static int tolua_lmeshio_std_vector_std__pair_unsigned_short_unsigned_char____new00_local(lua_State* tolua_S)
8808 {
8809 #ifndef TOLUA_RELEASE
8810  tolua_Error tolua_err;
8811  if (
8812      !tolua_isusertable(tolua_S,1,"std::vector<std::pair<unsigned short,unsigned char> >",0,&tolua_err) ||
8813      !tolua_isnoobj(tolua_S,2,&tolua_err)
8814  )
8815   goto tolua_lerror;
8816  else
8817 #endif
8818  {
8819
8820
8821   {
8822    std::vector<std::pair<unsigned short,unsigned char> >* tolua_ret = (std::vector<std::pair<unsigned short,unsigned char> >*)  Mtolua_new((std::vector<std::pair<unsigned short,unsigned char> >)());
8823     tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<std::pair<unsigned short,unsigned char> >");
8824     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
8825   }
8826
8827  }
8828  return 1;
8829 #ifndef TOLUA_RELEASE
8830  tolua_lerror:
8831  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
8832  return 0;
8833 #endif
8834 }
8835 #endif //#ifndef TOLUA_DISABLE
8836
8837 /* method: size of class  std::vector<std::pair<unsigned short,unsigned char> > */
8838 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_std__pair_unsigned_short_unsigned_char____size00
8839 static int tolua_lmeshio_std_vector_std__pair_unsigned_short_unsigned_char____size00(lua_State* tolua_S)
8840 {
8841 #ifndef TOLUA_RELEASE
8842  tolua_Error tolua_err;
8843  if (
8844      !tolua_isusertype(tolua_S,1,"const std::vector<std::pair<unsigned short,unsigned char> >",0,&tolua_err) ||
8845      !tolua_isnoobj(tolua_S,2,&tolua_err)
8846  )
8847   goto tolua_lerror;
8848  else
8849 #endif
8850  {
8851   const std::vector<std::pair<unsigned short,unsigned char> >* self = (const std::vector<std::pair<unsigned short,unsigned char> >*)  tolua_tousertype(tolua_S,1,0);
8852 #ifndef TOLUA_RELEASE
8853   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
8854 #endif
8855   {
8856    unsigned int tolua_ret = (unsigned int)  self->size();
8857    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
8858   }
8859
8860  }
8861  return 1;
8862 #ifndef TOLUA_RELEASE
8863  tolua_lerror:
8864  tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
8865  return 0;
8866 #endif
8867 }
8868 #endif //#ifndef TOLUA_DISABLE
8869
8870 /* method: push_back of class  std::vector<std::pair<unsigned short,unsigned char> > */
8871 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_std__pair_unsigned_short_unsigned_char____push_back00
8872 static int tolua_lmeshio_std_vector_std__pair_unsigned_short_unsigned_char____push_back00(lua_State* tolua_S)
8873 {
8874 #ifndef TOLUA_RELEASE
8875  tolua_Error tolua_err;
8876  if (
8877      !tolua_isusertype(tolua_S,1,"std::vector<std::pair<unsigned short,unsigned char> >",0,&tolua_err) ||
8878      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"std::pair<unsigned short,unsigned char>",0,&tolua_err)) ||
8879      !tolua_isnoobj(tolua_S,3,&tolua_err)
8880  )
8881   goto tolua_lerror;
8882  else
8883 #endif
8884  {
8885   std::vector<std::pair<unsigned short,unsigned char> >* self = (std::vector<std::pair<unsigned short,unsigned char> >*)  tolua_tousertype(tolua_S,1,0);
8886   std::pair<unsigned short,unsigned char>* value = ((std::pair<unsigned short,unsigned char>*)  tolua_tousertype(tolua_S,2,0));
8887 #ifndef TOLUA_RELEASE
8888   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
8889 #endif
8890   {
8891    self->push_back(*value);
8892
8893   }
8894
8895  }
8896  return 0;
8897 #ifndef TOLUA_RELEASE
8898  tolua_lerror:
8899  tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
8900  return 0;
8901 #endif
8902 }
8903 #endif //#ifndef TOLUA_DISABLE
8904
8905 /* method: back of class  std::vector<std::pair<unsigned short,unsigned char> > */
8906 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_std__pair_unsigned_short_unsigned_char____back00
8907 static int tolua_lmeshio_std_vector_std__pair_unsigned_short_unsigned_char____back00(lua_State* tolua_S)
8908 {
8909 #ifndef TOLUA_RELEASE
8910  tolua_Error tolua_err;
8911  if (
8912      !tolua_isusertype(tolua_S,1,"std::vector<std::pair<unsigned short,unsigned char> >",0,&tolua_err) ||
8913      !tolua_isnoobj(tolua_S,2,&tolua_err)
8914  )
8915   goto tolua_lerror;
8916  else
8917 #endif
8918  {
8919   std::vector<std::pair<unsigned short,unsigned char> >* self = (std::vector<std::pair<unsigned short,unsigned char> >*)  tolua_tousertype(tolua_S,1,0);
8920 #ifndef TOLUA_RELEASE
8921   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'back'", NULL);
8922 #endif
8923   {
8924    std::pair<unsigned short,unsigned char>& tolua_ret = (std::pair<unsigned short,unsigned char>&)  self->back();
8925     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"std::pair<unsigned short,unsigned char>");
8926   }
8927
8928  }
8929  return 1;
8930 #ifndef TOLUA_RELEASE
8931  tolua_lerror:
8932  tolua_error(tolua_S,"#ferror in function 'back'.",&tolua_err);
8933  return 0;
8934 #endif
8935 }
8936 #endif //#ifndef TOLUA_DISABLE
8937
8938 /* method: operator[] of class  std::vector<std::pair<unsigned short,unsigned char> > */
8939 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_std__pair_unsigned_short_unsigned_char_____geti00
8940 static int tolua_lmeshio_std_vector_std__pair_unsigned_short_unsigned_char_____geti00(lua_State* tolua_S)
8941 {
8942 #ifndef TOLUA_RELEASE
8943  tolua_Error tolua_err;
8944  if (
8945      !tolua_isusertype(tolua_S,1,"std::vector<std::pair<unsigned short,unsigned char> >",0,&tolua_err) ||
8946      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
8947      !tolua_isnoobj(tolua_S,3,&tolua_err)
8948  )
8949   goto tolua_lerror;
8950  else
8951 #endif
8952  {
8953   std::vector<std::pair<unsigned short,unsigned char> >* self = (std::vector<std::pair<unsigned short,unsigned char> >*)  tolua_tousertype(tolua_S,1,0);
8954   int index = ((int)  tolua_tonumber(tolua_S,2,0));
8955 #ifndef TOLUA_RELEASE
8956   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
8957 #endif
8958   {
8959    std::pair<unsigned short,unsigned char>& tolua_ret = (std::pair<unsigned short,unsigned char>&)  self->operator[](index);
8960     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"std::pair<unsigned short,unsigned char>");
8961
8962   }
8963
8964  }
8965  return 1;
8966 #ifndef TOLUA_RELEASE
8967  tolua_lerror:
8968  tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
8969  return 0;
8970 #endif
8971 }
8972 #endif //#ifndef TOLUA_DISABLE
8973
8974 /* method: operator&[] of class  std::vector<std::pair<unsigned short,unsigned char> > */
8975 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_std__pair_unsigned_short_unsigned_char_____seti00
8976 static int tolua_lmeshio_std_vector_std__pair_unsigned_short_unsigned_char_____seti00(lua_State* tolua_S)
8977 {
8978 #ifndef TOLUA_RELEASE
8979  tolua_Error tolua_err;
8980  if (
8981      !tolua_isusertype(tolua_S,1,"std::vector<std::pair<unsigned short,unsigned char> >",0,&tolua_err) ||
8982      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
8983      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"std::pair<unsigned short,unsigned char>",0,&tolua_err)) ||
8984      !tolua_isnoobj(tolua_S,4,&tolua_err)
8985  )
8986   goto tolua_lerror;
8987  else
8988 #endif
8989  {
8990   std::vector<std::pair<unsigned short,unsigned char> >* self = (std::vector<std::pair<unsigned short,unsigned char> >*)  tolua_tousertype(tolua_S,1,0);
8991   int index = ((int)  tolua_tonumber(tolua_S,2,0));
8992   std::pair<unsigned short,unsigned char> tolua_value = *((std::pair<unsigned short,unsigned char>*)  tolua_tousertype(tolua_S,3,0));
8993 #ifndef TOLUA_RELEASE
8994   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
8995 #endif
8996   self->operator[](index) =  tolua_value;
8997  }
8998  return 0;
8999 #ifndef TOLUA_RELEASE
9000  tolua_lerror:
9001  tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
9002  return 0;
9003 #endif
9004 }
9005 #endif //#ifndef TOLUA_DISABLE
9006
9007 /* stl foreachi: class  std::vector<std::pair<unsigned short,unsigned char> > */
9008 #ifndef TOLUA_DISABLE_tolua_lmeshio_std__vector_std__pair_unsigned_short_unsigned_char____iterator
9009 static int tolua_lmeshio_std__vector_std__pair_unsigned_short_unsigned_char____iterator_gc(lua_State* tolua_S)
9010 {
9011     //printf("tolua_lmeshio_std__vector_std__pair_unsigned_short_unsigned_char____iterator_gc\n");
9012     std::pair<std::vector<std::pair<unsigned short,unsigned char> >::iterator, std::vector<std::pair<unsigned short,unsigned char> >::iterator> *range=(std::pair<std::vector<std::pair<unsigned short,unsigned char> >::iterator, std::vector<std::pair<unsigned short,unsigned char> >::iterator>*)lua_touserdata(tolua_S, 1);
9013     range->~pair<std::vector<std::pair<unsigned short,unsigned char> >::iterator, std::vector<std::pair<unsigned short,unsigned char> >::iterator>();
9014     return 0;
9015 }
9016
9017 static int tolua_lmeshio_std__vector_std__pair_unsigned_short_unsigned_char____iterator_internal(lua_State* tolua_S)
9018 {
9019   std::pair<std::vector<std::pair<unsigned short,unsigned char> >::iterator, std::vector<std::pair<unsigned short,unsigned char> >::iterator> *range=(std::pair<std::vector<std::pair<unsigned short,unsigned char> >::iterator, std::vector<std::pair<unsigned short,unsigned char> >::iterator>*)lua_touserdata(tolua_S, lua_upvalueindex(1));
9020   if(range->first==range->second){
9021       return 0;
9022   }
9023   int index=lua_tonumber(tolua_S, lua_upvalueindex(2));
9024   tolua_pushnumber(tolua_S, index);
9025   // update index
9026   tolua_pushnumber(tolua_S, index+1);
9027   lua_replace(tolua_S, lua_upvalueindex(2));
9028
9029   //tolua_pushusertype(tolua_S, &(*range->first++), "std::pair<unsigned short,unsigned char> ");
9030    std::pair<unsigned short,unsigned char>& tolua_ret = (std::pair<unsigned short,unsigned char>&) *range->first++;
9031     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"std::pair<unsigned short,unsigned char>");
9032
9033   return 2;
9034 }
9035
9036 static int tolua_lmeshio_std__vector_std__pair_unsigned_short_unsigned_char____iterator(lua_State* tolua_S)
9037 {
9038 #ifndef TOLUA_RELEASE
9039  tolua_Error tolua_err;
9040  if (
9041      !tolua_isusertype(tolua_S,1,"std::vector<std::pair<unsigned short,unsigned char> >",0,&tolua_err) ||
9042      !tolua_isnoobj(tolua_S,2,&tolua_err)
9043  )
9044   goto tolua_lerror;
9045  else
9046 #endif
9047  {
9048   std::vector<std::pair<unsigned short,unsigned char> >* self = (std::vector<std::pair<unsigned short,unsigned char> >*)  tolua_tousertype(tolua_S,1,0);
9049 #ifndef TOLUA_RELEASE
9050   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'foreachi'", NULL);
9051 #endif
9052   {
9053     std::pair<std::vector<std::pair<unsigned short,unsigned char> >::iterator, std::vector<std::pair<unsigned short,unsigned char> >::iterator>* range=(std::pair<std::vector<std::pair<unsigned short,unsigned char> >::iterator, std::vector<std::pair<unsigned short,unsigned char> >::iterator>*)lua_newuserdata(tolua_S, sizeof(std::pair<std::vector<std::pair<unsigned short,unsigned char> >::iterator, std::vector<std::pair<unsigned short,unsigned char> >::iterator>));
9054     *range=std::make_pair(self->begin(), self->end());
9055     luaL_getmetatable(tolua_S, "std::pair<std::vector<std::pair<unsigned short,unsigned char> >::iterator, std::vector<std::pair<unsigned short,unsigned char> >::iterator>");
9056     lua_setmetatable(tolua_S, -2);
9057     lua_pushnumber(tolua_S, 0);
9058     // gc
9059     lua_pushcclosure(tolua_S, tolua_lmeshio_std__vector_std__pair_unsigned_short_unsigned_char____iterator_internal, 2);
9060   }
9061  }
9062  return 1;
9063 #ifndef TOLUA_RELEASE
9064  tolua_lerror:
9065  tolua_error(tolua_S,"#ferror in function 'foreachi'.",&tolua_err);
9066  return 0;
9067 #endif
9068 }
9069 #endif //#ifndef TOLUA_DISABLE
9070
9071
9072 /* method: new of class  std::vector<meshio::pmd::RigidBody> */
9073 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__RigidBody__new00
9074 static int tolua_lmeshio_std_vector_meshio__pmd__RigidBody__new00(lua_State* tolua_S)
9075 {
9076 #ifndef TOLUA_RELEASE
9077  tolua_Error tolua_err;
9078  if (
9079      !tolua_isusertable(tolua_S,1,"std::vector<meshio::pmd::RigidBody>",0,&tolua_err) ||
9080      !tolua_isnoobj(tolua_S,2,&tolua_err)
9081  )
9082   goto tolua_lerror;
9083  else
9084 #endif
9085  {
9086
9087
9088   {
9089    std::vector<meshio::pmd::RigidBody>* tolua_ret = (std::vector<meshio::pmd::RigidBody>*)  Mtolua_new((std::vector<meshio::pmd::RigidBody>)());
9090     tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<meshio::pmd::RigidBody>");
9091   }
9092
9093  }
9094  return 1;
9095 #ifndef TOLUA_RELEASE
9096  tolua_lerror:
9097  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
9098  return 0;
9099 #endif
9100 }
9101 #endif //#ifndef TOLUA_DISABLE
9102
9103 /* method: new_local of class  std::vector<meshio::pmd::RigidBody> */
9104 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__RigidBody__new00_local
9105 static int tolua_lmeshio_std_vector_meshio__pmd__RigidBody__new00_local(lua_State* tolua_S)
9106 {
9107 #ifndef TOLUA_RELEASE
9108  tolua_Error tolua_err;
9109  if (
9110      !tolua_isusertable(tolua_S,1,"std::vector<meshio::pmd::RigidBody>",0,&tolua_err) ||
9111      !tolua_isnoobj(tolua_S,2,&tolua_err)
9112  )
9113   goto tolua_lerror;
9114  else
9115 #endif
9116  {
9117
9118
9119   {
9120    std::vector<meshio::pmd::RigidBody>* tolua_ret = (std::vector<meshio::pmd::RigidBody>*)  Mtolua_new((std::vector<meshio::pmd::RigidBody>)());
9121     tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<meshio::pmd::RigidBody>");
9122     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
9123   }
9124
9125  }
9126  return 1;
9127 #ifndef TOLUA_RELEASE
9128  tolua_lerror:
9129  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
9130  return 0;
9131 #endif
9132 }
9133 #endif //#ifndef TOLUA_DISABLE
9134
9135 /* method: size of class  std::vector<meshio::pmd::RigidBody> */
9136 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__RigidBody__size00
9137 static int tolua_lmeshio_std_vector_meshio__pmd__RigidBody__size00(lua_State* tolua_S)
9138 {
9139 #ifndef TOLUA_RELEASE
9140  tolua_Error tolua_err;
9141  if (
9142      !tolua_isusertype(tolua_S,1,"const std::vector<meshio::pmd::RigidBody>",0,&tolua_err) ||
9143      !tolua_isnoobj(tolua_S,2,&tolua_err)
9144  )
9145   goto tolua_lerror;
9146  else
9147 #endif
9148  {
9149   const std::vector<meshio::pmd::RigidBody>* self = (const std::vector<meshio::pmd::RigidBody>*)  tolua_tousertype(tolua_S,1,0);
9150 #ifndef TOLUA_RELEASE
9151   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
9152 #endif
9153   {
9154    unsigned int tolua_ret = (unsigned int)  self->size();
9155    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
9156   }
9157
9158  }
9159  return 1;
9160 #ifndef TOLUA_RELEASE
9161  tolua_lerror:
9162  tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
9163  return 0;
9164 #endif
9165 }
9166 #endif //#ifndef TOLUA_DISABLE
9167
9168 /* method: push_back of class  std::vector<meshio::pmd::RigidBody> */
9169 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__RigidBody__push_back00
9170 static int tolua_lmeshio_std_vector_meshio__pmd__RigidBody__push_back00(lua_State* tolua_S)
9171 {
9172 #ifndef TOLUA_RELEASE
9173  tolua_Error tolua_err;
9174  if (
9175      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::RigidBody>",0,&tolua_err) ||
9176      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::pmd::RigidBody",0,&tolua_err)) ||
9177      !tolua_isnoobj(tolua_S,3,&tolua_err)
9178  )
9179   goto tolua_lerror;
9180  else
9181 #endif
9182  {
9183   std::vector<meshio::pmd::RigidBody>* self = (std::vector<meshio::pmd::RigidBody>*)  tolua_tousertype(tolua_S,1,0);
9184   meshio::pmd::RigidBody* value = ((meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,2,0));
9185 #ifndef TOLUA_RELEASE
9186   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
9187 #endif
9188   {
9189    self->push_back(*value);
9190
9191   }
9192
9193  }
9194  return 0;
9195 #ifndef TOLUA_RELEASE
9196  tolua_lerror:
9197  tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
9198  return 0;
9199 #endif
9200 }
9201 #endif //#ifndef TOLUA_DISABLE
9202
9203 /* method: back of class  std::vector<meshio::pmd::RigidBody> */
9204 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__RigidBody__back00
9205 static int tolua_lmeshio_std_vector_meshio__pmd__RigidBody__back00(lua_State* tolua_S)
9206 {
9207 #ifndef TOLUA_RELEASE
9208  tolua_Error tolua_err;
9209  if (
9210      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::RigidBody>",0,&tolua_err) ||
9211      !tolua_isnoobj(tolua_S,2,&tolua_err)
9212  )
9213   goto tolua_lerror;
9214  else
9215 #endif
9216  {
9217   std::vector<meshio::pmd::RigidBody>* self = (std::vector<meshio::pmd::RigidBody>*)  tolua_tousertype(tolua_S,1,0);
9218 #ifndef TOLUA_RELEASE
9219   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'back'", NULL);
9220 #endif
9221   {
9222    meshio::pmd::RigidBody& tolua_ret = (meshio::pmd::RigidBody&)  self->back();
9223     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::pmd::RigidBody");
9224   }
9225
9226  }
9227  return 1;
9228 #ifndef TOLUA_RELEASE
9229  tolua_lerror:
9230  tolua_error(tolua_S,"#ferror in function 'back'.",&tolua_err);
9231  return 0;
9232 #endif
9233 }
9234 #endif //#ifndef TOLUA_DISABLE
9235
9236 /* method: operator[] of class  std::vector<meshio::pmd::RigidBody> */
9237 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__RigidBody___geti00
9238 static int tolua_lmeshio_std_vector_meshio__pmd__RigidBody___geti00(lua_State* tolua_S)
9239 {
9240 #ifndef TOLUA_RELEASE
9241  tolua_Error tolua_err;
9242  if (
9243      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::RigidBody>",0,&tolua_err) ||
9244      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
9245      !tolua_isnoobj(tolua_S,3,&tolua_err)
9246  )
9247   goto tolua_lerror;
9248  else
9249 #endif
9250  {
9251   std::vector<meshio::pmd::RigidBody>* self = (std::vector<meshio::pmd::RigidBody>*)  tolua_tousertype(tolua_S,1,0);
9252   int index = ((int)  tolua_tonumber(tolua_S,2,0));
9253 #ifndef TOLUA_RELEASE
9254   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
9255 #endif
9256   {
9257    meshio::pmd::RigidBody& tolua_ret = (meshio::pmd::RigidBody&)  self->operator[](index);
9258     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::pmd::RigidBody");
9259
9260   }
9261
9262  }
9263  return 1;
9264 #ifndef TOLUA_RELEASE
9265  tolua_lerror:
9266  tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
9267  return 0;
9268 #endif
9269 }
9270 #endif //#ifndef TOLUA_DISABLE
9271
9272 /* method: operator&[] of class  std::vector<meshio::pmd::RigidBody> */
9273 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__RigidBody___seti00
9274 static int tolua_lmeshio_std_vector_meshio__pmd__RigidBody___seti00(lua_State* tolua_S)
9275 {
9276 #ifndef TOLUA_RELEASE
9277  tolua_Error tolua_err;
9278  if (
9279      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::RigidBody>",0,&tolua_err) ||
9280      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
9281      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"meshio::pmd::RigidBody",0,&tolua_err)) ||
9282      !tolua_isnoobj(tolua_S,4,&tolua_err)
9283  )
9284   goto tolua_lerror;
9285  else
9286 #endif
9287  {
9288   std::vector<meshio::pmd::RigidBody>* self = (std::vector<meshio::pmd::RigidBody>*)  tolua_tousertype(tolua_S,1,0);
9289   int index = ((int)  tolua_tonumber(tolua_S,2,0));
9290   meshio::pmd::RigidBody tolua_value = *((meshio::pmd::RigidBody*)  tolua_tousertype(tolua_S,3,0));
9291 #ifndef TOLUA_RELEASE
9292   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
9293 #endif
9294   self->operator[](index) =  tolua_value;
9295  }
9296  return 0;
9297 #ifndef TOLUA_RELEASE
9298  tolua_lerror:
9299  tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
9300  return 0;
9301 #endif
9302 }
9303 #endif //#ifndef TOLUA_DISABLE
9304
9305 /* stl foreachi: class  std::vector<meshio::pmd::RigidBody> */
9306 #ifndef TOLUA_DISABLE_tolua_lmeshio_std__vector_meshio__pmd__RigidBody__iterator
9307 static int tolua_lmeshio_std__vector_meshio__pmd__RigidBody__iterator_gc(lua_State* tolua_S)
9308 {
9309     //printf("tolua_lmeshio_std__vector_meshio__pmd__RigidBody__iterator_gc\n");
9310     std::pair<std::vector<meshio::pmd::RigidBody>::iterator, std::vector<meshio::pmd::RigidBody>::iterator> *range=(std::pair<std::vector<meshio::pmd::RigidBody>::iterator, std::vector<meshio::pmd::RigidBody>::iterator>*)lua_touserdata(tolua_S, 1);
9311     range->~pair<std::vector<meshio::pmd::RigidBody>::iterator, std::vector<meshio::pmd::RigidBody>::iterator>();
9312     return 0;
9313 }
9314
9315 static int tolua_lmeshio_std__vector_meshio__pmd__RigidBody__iterator_internal(lua_State* tolua_S)
9316 {
9317   std::pair<std::vector<meshio::pmd::RigidBody>::iterator, std::vector<meshio::pmd::RigidBody>::iterator> *range=(std::pair<std::vector<meshio::pmd::RigidBody>::iterator, std::vector<meshio::pmd::RigidBody>::iterator>*)lua_touserdata(tolua_S, lua_upvalueindex(1));
9318   if(range->first==range->second){
9319       return 0;
9320   }
9321   int index=lua_tonumber(tolua_S, lua_upvalueindex(2));
9322   tolua_pushnumber(tolua_S, index);
9323   // update index
9324   tolua_pushnumber(tolua_S, index+1);
9325   lua_replace(tolua_S, lua_upvalueindex(2));
9326
9327   //tolua_pushusertype(tolua_S, &(*range->first++), "meshio::pmd::RigidBody");
9328    meshio::pmd::RigidBody& tolua_ret = (meshio::pmd::RigidBody&) *range->first++;
9329     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::pmd::RigidBody");
9330
9331   return 2;
9332 }
9333
9334 static int tolua_lmeshio_std__vector_meshio__pmd__RigidBody__iterator(lua_State* tolua_S)
9335 {
9336 #ifndef TOLUA_RELEASE
9337  tolua_Error tolua_err;
9338  if (
9339      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::RigidBody>",0,&tolua_err) ||
9340      !tolua_isnoobj(tolua_S,2,&tolua_err)
9341  )
9342   goto tolua_lerror;
9343  else
9344 #endif
9345  {
9346   std::vector<meshio::pmd::RigidBody>* self = (std::vector<meshio::pmd::RigidBody>*)  tolua_tousertype(tolua_S,1,0);
9347 #ifndef TOLUA_RELEASE
9348   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'foreachi'", NULL);
9349 #endif
9350   {
9351     std::pair<std::vector<meshio::pmd::RigidBody>::iterator, std::vector<meshio::pmd::RigidBody>::iterator>* range=(std::pair<std::vector<meshio::pmd::RigidBody>::iterator, std::vector<meshio::pmd::RigidBody>::iterator>*)lua_newuserdata(tolua_S, sizeof(std::pair<std::vector<meshio::pmd::RigidBody>::iterator, std::vector<meshio::pmd::RigidBody>::iterator>));
9352     *range=std::make_pair(self->begin(), self->end());
9353     luaL_getmetatable(tolua_S, "std::pair<std::vector<meshio::pmd::RigidBody>::iterator, std::vector<meshio::pmd::RigidBody>::iterator>");
9354     lua_setmetatable(tolua_S, -2);
9355     lua_pushnumber(tolua_S, 0);
9356     // gc
9357     lua_pushcclosure(tolua_S, tolua_lmeshio_std__vector_meshio__pmd__RigidBody__iterator_internal, 2);
9358   }
9359  }
9360  return 1;
9361 #ifndef TOLUA_RELEASE
9362  tolua_lerror:
9363  tolua_error(tolua_S,"#ferror in function 'foreachi'.",&tolua_err);
9364  return 0;
9365 #endif
9366 }
9367 #endif //#ifndef TOLUA_DISABLE
9368
9369
9370 /* method: new of class  std::vector<meshio::pmd::Constraint> */
9371 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Constraint__new00
9372 static int tolua_lmeshio_std_vector_meshio__pmd__Constraint__new00(lua_State* tolua_S)
9373 {
9374 #ifndef TOLUA_RELEASE
9375  tolua_Error tolua_err;
9376  if (
9377      !tolua_isusertable(tolua_S,1,"std::vector<meshio::pmd::Constraint>",0,&tolua_err) ||
9378      !tolua_isnoobj(tolua_S,2,&tolua_err)
9379  )
9380   goto tolua_lerror;
9381  else
9382 #endif
9383  {
9384
9385
9386   {
9387    std::vector<meshio::pmd::Constraint>* tolua_ret = (std::vector<meshio::pmd::Constraint>*)  Mtolua_new((std::vector<meshio::pmd::Constraint>)());
9388     tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<meshio::pmd::Constraint>");
9389   }
9390
9391  }
9392  return 1;
9393 #ifndef TOLUA_RELEASE
9394  tolua_lerror:
9395  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
9396  return 0;
9397 #endif
9398 }
9399 #endif //#ifndef TOLUA_DISABLE
9400
9401 /* method: new_local of class  std::vector<meshio::pmd::Constraint> */
9402 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Constraint__new00_local
9403 static int tolua_lmeshio_std_vector_meshio__pmd__Constraint__new00_local(lua_State* tolua_S)
9404 {
9405 #ifndef TOLUA_RELEASE
9406  tolua_Error tolua_err;
9407  if (
9408      !tolua_isusertable(tolua_S,1,"std::vector<meshio::pmd::Constraint>",0,&tolua_err) ||
9409      !tolua_isnoobj(tolua_S,2,&tolua_err)
9410  )
9411   goto tolua_lerror;
9412  else
9413 #endif
9414  {
9415
9416
9417   {
9418    std::vector<meshio::pmd::Constraint>* tolua_ret = (std::vector<meshio::pmd::Constraint>*)  Mtolua_new((std::vector<meshio::pmd::Constraint>)());
9419     tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<meshio::pmd::Constraint>");
9420     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
9421   }
9422
9423  }
9424  return 1;
9425 #ifndef TOLUA_RELEASE
9426  tolua_lerror:
9427  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
9428  return 0;
9429 #endif
9430 }
9431 #endif //#ifndef TOLUA_DISABLE
9432
9433 /* method: size of class  std::vector<meshio::pmd::Constraint> */
9434 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Constraint__size00
9435 static int tolua_lmeshio_std_vector_meshio__pmd__Constraint__size00(lua_State* tolua_S)
9436 {
9437 #ifndef TOLUA_RELEASE
9438  tolua_Error tolua_err;
9439  if (
9440      !tolua_isusertype(tolua_S,1,"const std::vector<meshio::pmd::Constraint>",0,&tolua_err) ||
9441      !tolua_isnoobj(tolua_S,2,&tolua_err)
9442  )
9443   goto tolua_lerror;
9444  else
9445 #endif
9446  {
9447   const std::vector<meshio::pmd::Constraint>* self = (const std::vector<meshio::pmd::Constraint>*)  tolua_tousertype(tolua_S,1,0);
9448 #ifndef TOLUA_RELEASE
9449   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
9450 #endif
9451   {
9452    unsigned int tolua_ret = (unsigned int)  self->size();
9453    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
9454   }
9455
9456  }
9457  return 1;
9458 #ifndef TOLUA_RELEASE
9459  tolua_lerror:
9460  tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
9461  return 0;
9462 #endif
9463 }
9464 #endif //#ifndef TOLUA_DISABLE
9465
9466 /* method: push_back of class  std::vector<meshio::pmd::Constraint> */
9467 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Constraint__push_back00
9468 static int tolua_lmeshio_std_vector_meshio__pmd__Constraint__push_back00(lua_State* tolua_S)
9469 {
9470 #ifndef TOLUA_RELEASE
9471  tolua_Error tolua_err;
9472  if (
9473      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::Constraint>",0,&tolua_err) ||
9474      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::pmd::Constraint",0,&tolua_err)) ||
9475      !tolua_isnoobj(tolua_S,3,&tolua_err)
9476  )
9477   goto tolua_lerror;
9478  else
9479 #endif
9480  {
9481   std::vector<meshio::pmd::Constraint>* self = (std::vector<meshio::pmd::Constraint>*)  tolua_tousertype(tolua_S,1,0);
9482   meshio::pmd::Constraint* value = ((meshio::pmd::Constraint*)  tolua_tousertype(tolua_S,2,0));
9483 #ifndef TOLUA_RELEASE
9484   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
9485 #endif
9486   {
9487    self->push_back(*value);
9488
9489   }
9490
9491  }
9492  return 0;
9493 #ifndef TOLUA_RELEASE
9494  tolua_lerror:
9495  tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
9496  return 0;
9497 #endif
9498 }
9499 #endif //#ifndef TOLUA_DISABLE
9500
9501 /* method: back of class  std::vector<meshio::pmd::Constraint> */
9502 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Constraint__back00
9503 static int tolua_lmeshio_std_vector_meshio__pmd__Constraint__back00(lua_State* tolua_S)
9504 {
9505 #ifndef TOLUA_RELEASE
9506  tolua_Error tolua_err;
9507  if (
9508      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::Constraint>",0,&tolua_err) ||
9509      !tolua_isnoobj(tolua_S,2,&tolua_err)
9510  )
9511   goto tolua_lerror;
9512  else
9513 #endif
9514  {
9515   std::vector<meshio::pmd::Constraint>* self = (std::vector<meshio::pmd::Constraint>*)  tolua_tousertype(tolua_S,1,0);
9516 #ifndef TOLUA_RELEASE
9517   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'back'", NULL);
9518 #endif
9519   {
9520    meshio::pmd::Constraint& tolua_ret = (meshio::pmd::Constraint&)  self->back();
9521     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::pmd::Constraint");
9522   }
9523
9524  }
9525  return 1;
9526 #ifndef TOLUA_RELEASE
9527  tolua_lerror:
9528  tolua_error(tolua_S,"#ferror in function 'back'.",&tolua_err);
9529  return 0;
9530 #endif
9531 }
9532 #endif //#ifndef TOLUA_DISABLE
9533
9534 /* method: operator[] of class  std::vector<meshio::pmd::Constraint> */
9535 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Constraint___geti00
9536 static int tolua_lmeshio_std_vector_meshio__pmd__Constraint___geti00(lua_State* tolua_S)
9537 {
9538 #ifndef TOLUA_RELEASE
9539  tolua_Error tolua_err;
9540  if (
9541      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::Constraint>",0,&tolua_err) ||
9542      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
9543      !tolua_isnoobj(tolua_S,3,&tolua_err)
9544  )
9545   goto tolua_lerror;
9546  else
9547 #endif
9548  {
9549   std::vector<meshio::pmd::Constraint>* self = (std::vector<meshio::pmd::Constraint>*)  tolua_tousertype(tolua_S,1,0);
9550   int index = ((int)  tolua_tonumber(tolua_S,2,0));
9551 #ifndef TOLUA_RELEASE
9552   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
9553 #endif
9554   {
9555    meshio::pmd::Constraint& tolua_ret = (meshio::pmd::Constraint&)  self->operator[](index);
9556     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::pmd::Constraint");
9557
9558   }
9559
9560  }
9561  return 1;
9562 #ifndef TOLUA_RELEASE
9563  tolua_lerror:
9564  tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
9565  return 0;
9566 #endif
9567 }
9568 #endif //#ifndef TOLUA_DISABLE
9569
9570 /* method: operator&[] of class  std::vector<meshio::pmd::Constraint> */
9571 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__pmd__Constraint___seti00
9572 static int tolua_lmeshio_std_vector_meshio__pmd__Constraint___seti00(lua_State* tolua_S)
9573 {
9574 #ifndef TOLUA_RELEASE
9575  tolua_Error tolua_err;
9576  if (
9577      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::Constraint>",0,&tolua_err) ||
9578      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
9579      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"meshio::pmd::Constraint",0,&tolua_err)) ||
9580      !tolua_isnoobj(tolua_S,4,&tolua_err)
9581  )
9582   goto tolua_lerror;
9583  else
9584 #endif
9585  {
9586   std::vector<meshio::pmd::Constraint>* self = (std::vector<meshio::pmd::Constraint>*)  tolua_tousertype(tolua_S,1,0);
9587   int index = ((int)  tolua_tonumber(tolua_S,2,0));
9588   meshio::pmd::Constraint tolua_value = *((meshio::pmd::Constraint*)  tolua_tousertype(tolua_S,3,0));
9589 #ifndef TOLUA_RELEASE
9590   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
9591 #endif
9592   self->operator[](index) =  tolua_value;
9593  }
9594  return 0;
9595 #ifndef TOLUA_RELEASE
9596  tolua_lerror:
9597  tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
9598  return 0;
9599 #endif
9600 }
9601 #endif //#ifndef TOLUA_DISABLE
9602
9603 /* stl foreachi: class  std::vector<meshio::pmd::Constraint> */
9604 #ifndef TOLUA_DISABLE_tolua_lmeshio_std__vector_meshio__pmd__Constraint__iterator
9605 static int tolua_lmeshio_std__vector_meshio__pmd__Constraint__iterator_gc(lua_State* tolua_S)
9606 {
9607     //printf("tolua_lmeshio_std__vector_meshio__pmd__Constraint__iterator_gc\n");
9608     std::pair<std::vector<meshio::pmd::Constraint>::iterator, std::vector<meshio::pmd::Constraint>::iterator> *range=(std::pair<std::vector<meshio::pmd::Constraint>::iterator, std::vector<meshio::pmd::Constraint>::iterator>*)lua_touserdata(tolua_S, 1);
9609     range->~pair<std::vector<meshio::pmd::Constraint>::iterator, std::vector<meshio::pmd::Constraint>::iterator>();
9610     return 0;
9611 }
9612
9613 static int tolua_lmeshio_std__vector_meshio__pmd__Constraint__iterator_internal(lua_State* tolua_S)
9614 {
9615   std::pair<std::vector<meshio::pmd::Constraint>::iterator, std::vector<meshio::pmd::Constraint>::iterator> *range=(std::pair<std::vector<meshio::pmd::Constraint>::iterator, std::vector<meshio::pmd::Constraint>::iterator>*)lua_touserdata(tolua_S, lua_upvalueindex(1));
9616   if(range->first==range->second){
9617       return 0;
9618   }
9619   int index=lua_tonumber(tolua_S, lua_upvalueindex(2));
9620   tolua_pushnumber(tolua_S, index);
9621   // update index
9622   tolua_pushnumber(tolua_S, index+1);
9623   lua_replace(tolua_S, lua_upvalueindex(2));
9624
9625   //tolua_pushusertype(tolua_S, &(*range->first++), "meshio::pmd::Constraint");
9626    meshio::pmd::Constraint& tolua_ret = (meshio::pmd::Constraint&) *range->first++;
9627     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::pmd::Constraint");
9628
9629   return 2;
9630 }
9631
9632 static int tolua_lmeshio_std__vector_meshio__pmd__Constraint__iterator(lua_State* tolua_S)
9633 {
9634 #ifndef TOLUA_RELEASE
9635  tolua_Error tolua_err;
9636  if (
9637      !tolua_isusertype(tolua_S,1,"std::vector<meshio::pmd::Constraint>",0,&tolua_err) ||
9638      !tolua_isnoobj(tolua_S,2,&tolua_err)
9639  )
9640   goto tolua_lerror;
9641  else
9642 #endif
9643  {
9644   std::vector<meshio::pmd::Constraint>* self = (std::vector<meshio::pmd::Constraint>*)  tolua_tousertype(tolua_S,1,0);
9645 #ifndef TOLUA_RELEASE
9646   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'foreachi'", NULL);
9647 #endif
9648   {
9649     std::pair<std::vector<meshio::pmd::Constraint>::iterator, std::vector<meshio::pmd::Constraint>::iterator>* range=(std::pair<std::vector<meshio::pmd::Constraint>::iterator, std::vector<meshio::pmd::Constraint>::iterator>*)lua_newuserdata(tolua_S, sizeof(std::pair<std::vector<meshio::pmd::Constraint>::iterator, std::vector<meshio::pmd::Constraint>::iterator>));
9650     *range=std::make_pair(self->begin(), self->end());
9651     luaL_getmetatable(tolua_S, "std::pair<std::vector<meshio::pmd::Constraint>::iterator, std::vector<meshio::pmd::Constraint>::iterator>");
9652     lua_setmetatable(tolua_S, -2);
9653     lua_pushnumber(tolua_S, 0);
9654     // gc
9655     lua_pushcclosure(tolua_S, tolua_lmeshio_std__vector_meshio__pmd__Constraint__iterator_internal, 2);
9656   }
9657  }
9658  return 1;
9659 #ifndef TOLUA_RELEASE
9660  tolua_lerror:
9661  tolua_error(tolua_S,"#ferror in function 'foreachi'.",&tolua_err);
9662  return 0;
9663 #endif
9664 }
9665 #endif //#ifndef TOLUA_DISABLE
9666
9667
9668 /* method: new of class  std::vector<meshio::mqo::Face> */
9669 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__mqo__Face__new00
9670 static int tolua_lmeshio_std_vector_meshio__mqo__Face__new00(lua_State* tolua_S)
9671 {
9672 #ifndef TOLUA_RELEASE
9673  tolua_Error tolua_err;
9674  if (
9675      !tolua_isusertable(tolua_S,1,"std::vector<meshio::mqo::Face>",0,&tolua_err) ||
9676      !tolua_isnoobj(tolua_S,2,&tolua_err)
9677  )
9678   goto tolua_lerror;
9679  else
9680 #endif
9681  {
9682
9683
9684   {
9685    std::vector<meshio::mqo::Face>* tolua_ret = (std::vector<meshio::mqo::Face>*)  Mtolua_new((std::vector<meshio::mqo::Face>)());
9686     tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<meshio::mqo::Face>");
9687   }
9688
9689  }
9690  return 1;
9691 #ifndef TOLUA_RELEASE
9692  tolua_lerror:
9693  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
9694  return 0;
9695 #endif
9696 }
9697 #endif //#ifndef TOLUA_DISABLE
9698
9699 /* method: new_local of class  std::vector<meshio::mqo::Face> */
9700 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__mqo__Face__new00_local
9701 static int tolua_lmeshio_std_vector_meshio__mqo__Face__new00_local(lua_State* tolua_S)
9702 {
9703 #ifndef TOLUA_RELEASE
9704  tolua_Error tolua_err;
9705  if (
9706      !tolua_isusertable(tolua_S,1,"std::vector<meshio::mqo::Face>",0,&tolua_err) ||
9707      !tolua_isnoobj(tolua_S,2,&tolua_err)
9708  )
9709   goto tolua_lerror;
9710  else
9711 #endif
9712  {
9713
9714
9715   {
9716    std::vector<meshio::mqo::Face>* tolua_ret = (std::vector<meshio::mqo::Face>*)  Mtolua_new((std::vector<meshio::mqo::Face>)());
9717     tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<meshio::mqo::Face>");
9718     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
9719   }
9720
9721  }
9722  return 1;
9723 #ifndef TOLUA_RELEASE
9724  tolua_lerror:
9725  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
9726  return 0;
9727 #endif
9728 }
9729 #endif //#ifndef TOLUA_DISABLE
9730
9731 /* method: size of class  std::vector<meshio::mqo::Face> */
9732 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__mqo__Face__size00
9733 static int tolua_lmeshio_std_vector_meshio__mqo__Face__size00(lua_State* tolua_S)
9734 {
9735 #ifndef TOLUA_RELEASE
9736  tolua_Error tolua_err;
9737  if (
9738      !tolua_isusertype(tolua_S,1,"const std::vector<meshio::mqo::Face>",0,&tolua_err) ||
9739      !tolua_isnoobj(tolua_S,2,&tolua_err)
9740  )
9741   goto tolua_lerror;
9742  else
9743 #endif
9744  {
9745   const std::vector<meshio::mqo::Face>* self = (const std::vector<meshio::mqo::Face>*)  tolua_tousertype(tolua_S,1,0);
9746 #ifndef TOLUA_RELEASE
9747   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
9748 #endif
9749   {
9750    unsigned int tolua_ret = (unsigned int)  self->size();
9751    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
9752   }
9753
9754  }
9755  return 1;
9756 #ifndef TOLUA_RELEASE
9757  tolua_lerror:
9758  tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
9759  return 0;
9760 #endif
9761 }
9762 #endif //#ifndef TOLUA_DISABLE
9763
9764 /* method: push_back of class  std::vector<meshio::mqo::Face> */
9765 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__mqo__Face__push_back00
9766 static int tolua_lmeshio_std_vector_meshio__mqo__Face__push_back00(lua_State* tolua_S)
9767 {
9768 #ifndef TOLUA_RELEASE
9769  tolua_Error tolua_err;
9770  if (
9771      !tolua_isusertype(tolua_S,1,"std::vector<meshio::mqo::Face>",0,&tolua_err) ||
9772      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::mqo::Face",0,&tolua_err)) ||
9773      !tolua_isnoobj(tolua_S,3,&tolua_err)
9774  )
9775   goto tolua_lerror;
9776  else
9777 #endif
9778  {
9779   std::vector<meshio::mqo::Face>* self = (std::vector<meshio::mqo::Face>*)  tolua_tousertype(tolua_S,1,0);
9780   meshio::mqo::Face* value = ((meshio::mqo::Face*)  tolua_tousertype(tolua_S,2,0));
9781 #ifndef TOLUA_RELEASE
9782   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
9783 #endif
9784   {
9785    self->push_back(*value);
9786
9787   }
9788
9789  }
9790  return 0;
9791 #ifndef TOLUA_RELEASE
9792  tolua_lerror:
9793  tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
9794  return 0;
9795 #endif
9796 }
9797 #endif //#ifndef TOLUA_DISABLE
9798
9799 /* method: back of class  std::vector<meshio::mqo::Face> */
9800 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__mqo__Face__back00
9801 static int tolua_lmeshio_std_vector_meshio__mqo__Face__back00(lua_State* tolua_S)
9802 {
9803 #ifndef TOLUA_RELEASE
9804  tolua_Error tolua_err;
9805  if (
9806      !tolua_isusertype(tolua_S,1,"std::vector<meshio::mqo::Face>",0,&tolua_err) ||
9807      !tolua_isnoobj(tolua_S,2,&tolua_err)
9808  )
9809   goto tolua_lerror;
9810  else
9811 #endif
9812  {
9813   std::vector<meshio::mqo::Face>* self = (std::vector<meshio::mqo::Face>*)  tolua_tousertype(tolua_S,1,0);
9814 #ifndef TOLUA_RELEASE
9815   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'back'", NULL);
9816 #endif
9817   {
9818    meshio::mqo::Face& tolua_ret = (meshio::mqo::Face&)  self->back();
9819     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::mqo::Face");
9820   }
9821
9822  }
9823  return 1;
9824 #ifndef TOLUA_RELEASE
9825  tolua_lerror:
9826  tolua_error(tolua_S,"#ferror in function 'back'.",&tolua_err);
9827  return 0;
9828 #endif
9829 }
9830 #endif //#ifndef TOLUA_DISABLE
9831
9832 /* method: operator[] of class  std::vector<meshio::mqo::Face> */
9833 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__mqo__Face___geti00
9834 static int tolua_lmeshio_std_vector_meshio__mqo__Face___geti00(lua_State* tolua_S)
9835 {
9836 #ifndef TOLUA_RELEASE
9837  tolua_Error tolua_err;
9838  if (
9839      !tolua_isusertype(tolua_S,1,"std::vector<meshio::mqo::Face>",0,&tolua_err) ||
9840      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
9841      !tolua_isnoobj(tolua_S,3,&tolua_err)
9842  )
9843   goto tolua_lerror;
9844  else
9845 #endif
9846  {
9847   std::vector<meshio::mqo::Face>* self = (std::vector<meshio::mqo::Face>*)  tolua_tousertype(tolua_S,1,0);
9848   int index = ((int)  tolua_tonumber(tolua_S,2,0));
9849 #ifndef TOLUA_RELEASE
9850   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
9851 #endif
9852   {
9853    meshio::mqo::Face& tolua_ret = (meshio::mqo::Face&)  self->operator[](index);
9854     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::mqo::Face");
9855
9856   }
9857
9858  }
9859  return 1;
9860 #ifndef TOLUA_RELEASE
9861  tolua_lerror:
9862  tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
9863  return 0;
9864 #endif
9865 }
9866 #endif //#ifndef TOLUA_DISABLE
9867
9868 /* method: operator&[] of class  std::vector<meshio::mqo::Face> */
9869 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__mqo__Face___seti00
9870 static int tolua_lmeshio_std_vector_meshio__mqo__Face___seti00(lua_State* tolua_S)
9871 {
9872 #ifndef TOLUA_RELEASE
9873  tolua_Error tolua_err;
9874  if (
9875      !tolua_isusertype(tolua_S,1,"std::vector<meshio::mqo::Face>",0,&tolua_err) ||
9876      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
9877      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"meshio::mqo::Face",0,&tolua_err)) ||
9878      !tolua_isnoobj(tolua_S,4,&tolua_err)
9879  )
9880   goto tolua_lerror;
9881  else
9882 #endif
9883  {
9884   std::vector<meshio::mqo::Face>* self = (std::vector<meshio::mqo::Face>*)  tolua_tousertype(tolua_S,1,0);
9885   int index = ((int)  tolua_tonumber(tolua_S,2,0));
9886   meshio::mqo::Face tolua_value = *((meshio::mqo::Face*)  tolua_tousertype(tolua_S,3,0));
9887 #ifndef TOLUA_RELEASE
9888   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
9889 #endif
9890   self->operator[](index) =  tolua_value;
9891  }
9892  return 0;
9893 #ifndef TOLUA_RELEASE
9894  tolua_lerror:
9895  tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
9896  return 0;
9897 #endif
9898 }
9899 #endif //#ifndef TOLUA_DISABLE
9900
9901 /* stl foreachi: class  std::vector<meshio::mqo::Face> */
9902 #ifndef TOLUA_DISABLE_tolua_lmeshio_std__vector_meshio__mqo__Face__iterator
9903 static int tolua_lmeshio_std__vector_meshio__mqo__Face__iterator_gc(lua_State* tolua_S)
9904 {
9905     //printf("tolua_lmeshio_std__vector_meshio__mqo__Face__iterator_gc\n");
9906     std::pair<std::vector<meshio::mqo::Face>::iterator, std::vector<meshio::mqo::Face>::iterator> *range=(std::pair<std::vector<meshio::mqo::Face>::iterator, std::vector<meshio::mqo::Face>::iterator>*)lua_touserdata(tolua_S, 1);
9907     range->~pair<std::vector<meshio::mqo::Face>::iterator, std::vector<meshio::mqo::Face>::iterator>();
9908     return 0;
9909 }
9910
9911 static int tolua_lmeshio_std__vector_meshio__mqo__Face__iterator_internal(lua_State* tolua_S)
9912 {
9913   std::pair<std::vector<meshio::mqo::Face>::iterator, std::vector<meshio::mqo::Face>::iterator> *range=(std::pair<std::vector<meshio::mqo::Face>::iterator, std::vector<meshio::mqo::Face>::iterator>*)lua_touserdata(tolua_S, lua_upvalueindex(1));
9914   if(range->first==range->second){
9915       return 0;
9916   }
9917   int index=lua_tonumber(tolua_S, lua_upvalueindex(2));
9918   tolua_pushnumber(tolua_S, index);
9919   // update index
9920   tolua_pushnumber(tolua_S, index+1);
9921   lua_replace(tolua_S, lua_upvalueindex(2));
9922
9923   //tolua_pushusertype(tolua_S, &(*range->first++), "meshio::mqo::Face");
9924    meshio::mqo::Face& tolua_ret = (meshio::mqo::Face&) *range->first++;
9925     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::mqo::Face");
9926
9927   return 2;
9928 }
9929
9930 static int tolua_lmeshio_std__vector_meshio__mqo__Face__iterator(lua_State* tolua_S)
9931 {
9932 #ifndef TOLUA_RELEASE
9933  tolua_Error tolua_err;
9934  if (
9935      !tolua_isusertype(tolua_S,1,"std::vector<meshio::mqo::Face>",0,&tolua_err) ||
9936      !tolua_isnoobj(tolua_S,2,&tolua_err)
9937  )
9938   goto tolua_lerror;
9939  else
9940 #endif
9941  {
9942   std::vector<meshio::mqo::Face>* self = (std::vector<meshio::mqo::Face>*)  tolua_tousertype(tolua_S,1,0);
9943 #ifndef TOLUA_RELEASE
9944   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'foreachi'", NULL);
9945 #endif
9946   {
9947     std::pair<std::vector<meshio::mqo::Face>::iterator, std::vector<meshio::mqo::Face>::iterator>* range=(std::pair<std::vector<meshio::mqo::Face>::iterator, std::vector<meshio::mqo::Face>::iterator>*)lua_newuserdata(tolua_S, sizeof(std::pair<std::vector<meshio::mqo::Face>::iterator, std::vector<meshio::mqo::Face>::iterator>));
9948     *range=std::make_pair(self->begin(), self->end());
9949     luaL_getmetatable(tolua_S, "std::pair<std::vector<meshio::mqo::Face>::iterator, std::vector<meshio::mqo::Face>::iterator>");
9950     lua_setmetatable(tolua_S, -2);
9951     lua_pushnumber(tolua_S, 0);
9952     // gc
9953     lua_pushcclosure(tolua_S, tolua_lmeshio_std__vector_meshio__mqo__Face__iterator_internal, 2);
9954   }
9955  }
9956  return 1;
9957 #ifndef TOLUA_RELEASE
9958  tolua_lerror:
9959  tolua_error(tolua_S,"#ferror in function 'foreachi'.",&tolua_err);
9960  return 0;
9961 #endif
9962 }
9963 #endif //#ifndef TOLUA_DISABLE
9964
9965
9966 /* method: new of class  std::vector<meshio::mqo::Material> */
9967 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__mqo__Material__new00
9968 static int tolua_lmeshio_std_vector_meshio__mqo__Material__new00(lua_State* tolua_S)
9969 {
9970 #ifndef TOLUA_RELEASE
9971  tolua_Error tolua_err;
9972  if (
9973      !tolua_isusertable(tolua_S,1,"std::vector<meshio::mqo::Material>",0,&tolua_err) ||
9974      !tolua_isnoobj(tolua_S,2,&tolua_err)
9975  )
9976   goto tolua_lerror;
9977  else
9978 #endif
9979  {
9980
9981
9982   {
9983    std::vector<meshio::mqo::Material>* tolua_ret = (std::vector<meshio::mqo::Material>*)  Mtolua_new((std::vector<meshio::mqo::Material>)());
9984     tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<meshio::mqo::Material>");
9985   }
9986
9987  }
9988  return 1;
9989 #ifndef TOLUA_RELEASE
9990  tolua_lerror:
9991  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
9992  return 0;
9993 #endif
9994 }
9995 #endif //#ifndef TOLUA_DISABLE
9996
9997 /* method: new_local of class  std::vector<meshio::mqo::Material> */
9998 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__mqo__Material__new00_local
9999 static int tolua_lmeshio_std_vector_meshio__mqo__Material__new00_local(lua_State* tolua_S)
10000 {
10001 #ifndef TOLUA_RELEASE
10002  tolua_Error tolua_err;
10003  if (
10004      !tolua_isusertable(tolua_S,1,"std::vector<meshio::mqo::Material>",0,&tolua_err) ||
10005      !tolua_isnoobj(tolua_S,2,&tolua_err)
10006  )
10007   goto tolua_lerror;
10008  else
10009 #endif
10010  {
10011
10012
10013   {
10014    std::vector<meshio::mqo::Material>* tolua_ret = (std::vector<meshio::mqo::Material>*)  Mtolua_new((std::vector<meshio::mqo::Material>)());
10015     tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<meshio::mqo::Material>");
10016     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
10017   }
10018
10019  }
10020  return 1;
10021 #ifndef TOLUA_RELEASE
10022  tolua_lerror:
10023  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
10024  return 0;
10025 #endif
10026 }
10027 #endif //#ifndef TOLUA_DISABLE
10028
10029 /* method: size of class  std::vector<meshio::mqo::Material> */
10030 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__mqo__Material__size00
10031 static int tolua_lmeshio_std_vector_meshio__mqo__Material__size00(lua_State* tolua_S)
10032 {
10033 #ifndef TOLUA_RELEASE
10034  tolua_Error tolua_err;
10035  if (
10036      !tolua_isusertype(tolua_S,1,"const std::vector<meshio::mqo::Material>",0,&tolua_err) ||
10037      !tolua_isnoobj(tolua_S,2,&tolua_err)
10038  )
10039   goto tolua_lerror;
10040  else
10041 #endif
10042  {
10043   const std::vector<meshio::mqo::Material>* self = (const std::vector<meshio::mqo::Material>*)  tolua_tousertype(tolua_S,1,0);
10044 #ifndef TOLUA_RELEASE
10045   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
10046 #endif
10047   {
10048    unsigned int tolua_ret = (unsigned int)  self->size();
10049    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
10050   }
10051
10052  }
10053  return 1;
10054 #ifndef TOLUA_RELEASE
10055  tolua_lerror:
10056  tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
10057  return 0;
10058 #endif
10059 }
10060 #endif //#ifndef TOLUA_DISABLE
10061
10062 /* method: push_back of class  std::vector<meshio::mqo::Material> */
10063 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__mqo__Material__push_back00
10064 static int tolua_lmeshio_std_vector_meshio__mqo__Material__push_back00(lua_State* tolua_S)
10065 {
10066 #ifndef TOLUA_RELEASE
10067  tolua_Error tolua_err;
10068  if (
10069      !tolua_isusertype(tolua_S,1,"std::vector<meshio::mqo::Material>",0,&tolua_err) ||
10070      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::mqo::Material",0,&tolua_err)) ||
10071      !tolua_isnoobj(tolua_S,3,&tolua_err)
10072  )
10073   goto tolua_lerror;
10074  else
10075 #endif
10076  {
10077   std::vector<meshio::mqo::Material>* self = (std::vector<meshio::mqo::Material>*)  tolua_tousertype(tolua_S,1,0);
10078   meshio::mqo::Material* value = ((meshio::mqo::Material*)  tolua_tousertype(tolua_S,2,0));
10079 #ifndef TOLUA_RELEASE
10080   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
10081 #endif
10082   {
10083    self->push_back(*value);
10084
10085   }
10086
10087  }
10088  return 0;
10089 #ifndef TOLUA_RELEASE
10090  tolua_lerror:
10091  tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
10092  return 0;
10093 #endif
10094 }
10095 #endif //#ifndef TOLUA_DISABLE
10096
10097 /* method: back of class  std::vector<meshio::mqo::Material> */
10098 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__mqo__Material__back00
10099 static int tolua_lmeshio_std_vector_meshio__mqo__Material__back00(lua_State* tolua_S)
10100 {
10101 #ifndef TOLUA_RELEASE
10102  tolua_Error tolua_err;
10103  if (
10104      !tolua_isusertype(tolua_S,1,"std::vector<meshio::mqo::Material>",0,&tolua_err) ||
10105      !tolua_isnoobj(tolua_S,2,&tolua_err)
10106  )
10107   goto tolua_lerror;
10108  else
10109 #endif
10110  {
10111   std::vector<meshio::mqo::Material>* self = (std::vector<meshio::mqo::Material>*)  tolua_tousertype(tolua_S,1,0);
10112 #ifndef TOLUA_RELEASE
10113   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'back'", NULL);
10114 #endif
10115   {
10116    meshio::mqo::Material& tolua_ret = (meshio::mqo::Material&)  self->back();
10117     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::mqo::Material");
10118   }
10119
10120  }
10121  return 1;
10122 #ifndef TOLUA_RELEASE
10123  tolua_lerror:
10124  tolua_error(tolua_S,"#ferror in function 'back'.",&tolua_err);
10125  return 0;
10126 #endif
10127 }
10128 #endif //#ifndef TOLUA_DISABLE
10129
10130 /* method: operator[] of class  std::vector<meshio::mqo::Material> */
10131 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__mqo__Material___geti00
10132 static int tolua_lmeshio_std_vector_meshio__mqo__Material___geti00(lua_State* tolua_S)
10133 {
10134 #ifndef TOLUA_RELEASE
10135  tolua_Error tolua_err;
10136  if (
10137      !tolua_isusertype(tolua_S,1,"std::vector<meshio::mqo::Material>",0,&tolua_err) ||
10138      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
10139      !tolua_isnoobj(tolua_S,3,&tolua_err)
10140  )
10141   goto tolua_lerror;
10142  else
10143 #endif
10144  {
10145   std::vector<meshio::mqo::Material>* self = (std::vector<meshio::mqo::Material>*)  tolua_tousertype(tolua_S,1,0);
10146   int index = ((int)  tolua_tonumber(tolua_S,2,0));
10147 #ifndef TOLUA_RELEASE
10148   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
10149 #endif
10150   {
10151    meshio::mqo::Material& tolua_ret = (meshio::mqo::Material&)  self->operator[](index);
10152     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::mqo::Material");
10153
10154   }
10155
10156  }
10157  return 1;
10158 #ifndef TOLUA_RELEASE
10159  tolua_lerror:
10160  tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
10161  return 0;
10162 #endif
10163 }
10164 #endif //#ifndef TOLUA_DISABLE
10165
10166 /* method: operator&[] of class  std::vector<meshio::mqo::Material> */
10167 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__mqo__Material___seti00
10168 static int tolua_lmeshio_std_vector_meshio__mqo__Material___seti00(lua_State* tolua_S)
10169 {
10170 #ifndef TOLUA_RELEASE
10171  tolua_Error tolua_err;
10172  if (
10173      !tolua_isusertype(tolua_S,1,"std::vector<meshio::mqo::Material>",0,&tolua_err) ||
10174      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
10175      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"meshio::mqo::Material",0,&tolua_err)) ||
10176      !tolua_isnoobj(tolua_S,4,&tolua_err)
10177  )
10178   goto tolua_lerror;
10179  else
10180 #endif
10181  {
10182   std::vector<meshio::mqo::Material>* self = (std::vector<meshio::mqo::Material>*)  tolua_tousertype(tolua_S,1,0);
10183   int index = ((int)  tolua_tonumber(tolua_S,2,0));
10184   meshio::mqo::Material tolua_value = *((meshio::mqo::Material*)  tolua_tousertype(tolua_S,3,0));
10185 #ifndef TOLUA_RELEASE
10186   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
10187 #endif
10188   self->operator[](index) =  tolua_value;
10189  }
10190  return 0;
10191 #ifndef TOLUA_RELEASE
10192  tolua_lerror:
10193  tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
10194  return 0;
10195 #endif
10196 }
10197 #endif //#ifndef TOLUA_DISABLE
10198
10199 /* stl foreachi: class  std::vector<meshio::mqo::Material> */
10200 #ifndef TOLUA_DISABLE_tolua_lmeshio_std__vector_meshio__mqo__Material__iterator
10201 static int tolua_lmeshio_std__vector_meshio__mqo__Material__iterator_gc(lua_State* tolua_S)
10202 {
10203     //printf("tolua_lmeshio_std__vector_meshio__mqo__Material__iterator_gc\n");
10204     std::pair<std::vector<meshio::mqo::Material>::iterator, std::vector<meshio::mqo::Material>::iterator> *range=(std::pair<std::vector<meshio::mqo::Material>::iterator, std::vector<meshio::mqo::Material>::iterator>*)lua_touserdata(tolua_S, 1);
10205     range->~pair<std::vector<meshio::mqo::Material>::iterator, std::vector<meshio::mqo::Material>::iterator>();
10206     return 0;
10207 }
10208
10209 static int tolua_lmeshio_std__vector_meshio__mqo__Material__iterator_internal(lua_State* tolua_S)
10210 {
10211   std::pair<std::vector<meshio::mqo::Material>::iterator, std::vector<meshio::mqo::Material>::iterator> *range=(std::pair<std::vector<meshio::mqo::Material>::iterator, std::vector<meshio::mqo::Material>::iterator>*)lua_touserdata(tolua_S, lua_upvalueindex(1));
10212   if(range->first==range->second){
10213       return 0;
10214   }
10215   int index=lua_tonumber(tolua_S, lua_upvalueindex(2));
10216   tolua_pushnumber(tolua_S, index);
10217   // update index
10218   tolua_pushnumber(tolua_S, index+1);
10219   lua_replace(tolua_S, lua_upvalueindex(2));
10220
10221   //tolua_pushusertype(tolua_S, &(*range->first++), "meshio::mqo::Material");
10222    meshio::mqo::Material& tolua_ret = (meshio::mqo::Material&) *range->first++;
10223     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::mqo::Material");
10224
10225   return 2;
10226 }
10227
10228 static int tolua_lmeshio_std__vector_meshio__mqo__Material__iterator(lua_State* tolua_S)
10229 {
10230 #ifndef TOLUA_RELEASE
10231  tolua_Error tolua_err;
10232  if (
10233      !tolua_isusertype(tolua_S,1,"std::vector<meshio::mqo::Material>",0,&tolua_err) ||
10234      !tolua_isnoobj(tolua_S,2,&tolua_err)
10235  )
10236   goto tolua_lerror;
10237  else
10238 #endif
10239  {
10240   std::vector<meshio::mqo::Material>* self = (std::vector<meshio::mqo::Material>*)  tolua_tousertype(tolua_S,1,0);
10241 #ifndef TOLUA_RELEASE
10242   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'foreachi'", NULL);
10243 #endif
10244   {
10245     std::pair<std::vector<meshio::mqo::Material>::iterator, std::vector<meshio::mqo::Material>::iterator>* range=(std::pair<std::vector<meshio::mqo::Material>::iterator, std::vector<meshio::mqo::Material>::iterator>*)lua_newuserdata(tolua_S, sizeof(std::pair<std::vector<meshio::mqo::Material>::iterator, std::vector<meshio::mqo::Material>::iterator>));
10246     *range=std::make_pair(self->begin(), self->end());
10247     luaL_getmetatable(tolua_S, "std::pair<std::vector<meshio::mqo::Material>::iterator, std::vector<meshio::mqo::Material>::iterator>");
10248     lua_setmetatable(tolua_S, -2);
10249     lua_pushnumber(tolua_S, 0);
10250     // gc
10251     lua_pushcclosure(tolua_S, tolua_lmeshio_std__vector_meshio__mqo__Material__iterator_internal, 2);
10252   }
10253  }
10254  return 1;
10255 #ifndef TOLUA_RELEASE
10256  tolua_lerror:
10257  tolua_error(tolua_S,"#ferror in function 'foreachi'.",&tolua_err);
10258  return 0;
10259 #endif
10260 }
10261 #endif //#ifndef TOLUA_DISABLE
10262
10263
10264 /* method: new of class  std::vector<meshio::mqo::Object> */
10265 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__mqo__Object__new00
10266 static int tolua_lmeshio_std_vector_meshio__mqo__Object__new00(lua_State* tolua_S)
10267 {
10268 #ifndef TOLUA_RELEASE
10269  tolua_Error tolua_err;
10270  if (
10271      !tolua_isusertable(tolua_S,1,"std::vector<meshio::mqo::Object>",0,&tolua_err) ||
10272      !tolua_isnoobj(tolua_S,2,&tolua_err)
10273  )
10274   goto tolua_lerror;
10275  else
10276 #endif
10277  {
10278
10279
10280   {
10281    std::vector<meshio::mqo::Object>* tolua_ret = (std::vector<meshio::mqo::Object>*)  Mtolua_new((std::vector<meshio::mqo::Object>)());
10282     tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<meshio::mqo::Object>");
10283   }
10284
10285  }
10286  return 1;
10287 #ifndef TOLUA_RELEASE
10288  tolua_lerror:
10289  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
10290  return 0;
10291 #endif
10292 }
10293 #endif //#ifndef TOLUA_DISABLE
10294
10295 /* method: new_local of class  std::vector<meshio::mqo::Object> */
10296 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__mqo__Object__new00_local
10297 static int tolua_lmeshio_std_vector_meshio__mqo__Object__new00_local(lua_State* tolua_S)
10298 {
10299 #ifndef TOLUA_RELEASE
10300  tolua_Error tolua_err;
10301  if (
10302      !tolua_isusertable(tolua_S,1,"std::vector<meshio::mqo::Object>",0,&tolua_err) ||
10303      !tolua_isnoobj(tolua_S,2,&tolua_err)
10304  )
10305   goto tolua_lerror;
10306  else
10307 #endif
10308  {
10309
10310
10311   {
10312    std::vector<meshio::mqo::Object>* tolua_ret = (std::vector<meshio::mqo::Object>*)  Mtolua_new((std::vector<meshio::mqo::Object>)());
10313     tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::vector<meshio::mqo::Object>");
10314     tolua_register_gc(tolua_S,lua_gettop(tolua_S));
10315   }
10316
10317  }
10318  return 1;
10319 #ifndef TOLUA_RELEASE
10320  tolua_lerror:
10321  tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
10322  return 0;
10323 #endif
10324 }
10325 #endif //#ifndef TOLUA_DISABLE
10326
10327 /* method: size of class  std::vector<meshio::mqo::Object> */
10328 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__mqo__Object__size00
10329 static int tolua_lmeshio_std_vector_meshio__mqo__Object__size00(lua_State* tolua_S)
10330 {
10331 #ifndef TOLUA_RELEASE
10332  tolua_Error tolua_err;
10333  if (
10334      !tolua_isusertype(tolua_S,1,"const std::vector<meshio::mqo::Object>",0,&tolua_err) ||
10335      !tolua_isnoobj(tolua_S,2,&tolua_err)
10336  )
10337   goto tolua_lerror;
10338  else
10339 #endif
10340  {
10341   const std::vector<meshio::mqo::Object>* self = (const std::vector<meshio::mqo::Object>*)  tolua_tousertype(tolua_S,1,0);
10342 #ifndef TOLUA_RELEASE
10343   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
10344 #endif
10345   {
10346    unsigned int tolua_ret = (unsigned int)  self->size();
10347    tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
10348   }
10349
10350  }
10351  return 1;
10352 #ifndef TOLUA_RELEASE
10353  tolua_lerror:
10354  tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
10355  return 0;
10356 #endif
10357 }
10358 #endif //#ifndef TOLUA_DISABLE
10359
10360 /* method: push_back of class  std::vector<meshio::mqo::Object> */
10361 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__mqo__Object__push_back00
10362 static int tolua_lmeshio_std_vector_meshio__mqo__Object__push_back00(lua_State* tolua_S)
10363 {
10364 #ifndef TOLUA_RELEASE
10365  tolua_Error tolua_err;
10366  if (
10367      !tolua_isusertype(tolua_S,1,"std::vector<meshio::mqo::Object>",0,&tolua_err) ||
10368      (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"meshio::mqo::Object",0,&tolua_err)) ||
10369      !tolua_isnoobj(tolua_S,3,&tolua_err)
10370  )
10371   goto tolua_lerror;
10372  else
10373 #endif
10374  {
10375   std::vector<meshio::mqo::Object>* self = (std::vector<meshio::mqo::Object>*)  tolua_tousertype(tolua_S,1,0);
10376   meshio::mqo::Object* value = ((meshio::mqo::Object*)  tolua_tousertype(tolua_S,2,0));
10377 #ifndef TOLUA_RELEASE
10378   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'", NULL);
10379 #endif
10380   {
10381    self->push_back(*value);
10382
10383   }
10384
10385  }
10386  return 0;
10387 #ifndef TOLUA_RELEASE
10388  tolua_lerror:
10389  tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
10390  return 0;
10391 #endif
10392 }
10393 #endif //#ifndef TOLUA_DISABLE
10394
10395 /* method: back of class  std::vector<meshio::mqo::Object> */
10396 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__mqo__Object__back00
10397 static int tolua_lmeshio_std_vector_meshio__mqo__Object__back00(lua_State* tolua_S)
10398 {
10399 #ifndef TOLUA_RELEASE
10400  tolua_Error tolua_err;
10401  if (
10402      !tolua_isusertype(tolua_S,1,"std::vector<meshio::mqo::Object>",0,&tolua_err) ||
10403      !tolua_isnoobj(tolua_S,2,&tolua_err)
10404  )
10405   goto tolua_lerror;
10406  else
10407 #endif
10408  {
10409   std::vector<meshio::mqo::Object>* self = (std::vector<meshio::mqo::Object>*)  tolua_tousertype(tolua_S,1,0);
10410 #ifndef TOLUA_RELEASE
10411   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'back'", NULL);
10412 #endif
10413   {
10414    meshio::mqo::Object& tolua_ret = (meshio::mqo::Object&)  self->back();
10415     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::mqo::Object");
10416   }
10417
10418  }
10419  return 1;
10420 #ifndef TOLUA_RELEASE
10421  tolua_lerror:
10422  tolua_error(tolua_S,"#ferror in function 'back'.",&tolua_err);
10423  return 0;
10424 #endif
10425 }
10426 #endif //#ifndef TOLUA_DISABLE
10427
10428 /* method: operator[] of class  std::vector<meshio::mqo::Object> */
10429 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__mqo__Object___geti00
10430 static int tolua_lmeshio_std_vector_meshio__mqo__Object___geti00(lua_State* tolua_S)
10431 {
10432 #ifndef TOLUA_RELEASE
10433  tolua_Error tolua_err;
10434  if (
10435      !tolua_isusertype(tolua_S,1,"std::vector<meshio::mqo::Object>",0,&tolua_err) ||
10436      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
10437      !tolua_isnoobj(tolua_S,3,&tolua_err)
10438  )
10439   goto tolua_lerror;
10440  else
10441 #endif
10442  {
10443   std::vector<meshio::mqo::Object>* self = (std::vector<meshio::mqo::Object>*)  tolua_tousertype(tolua_S,1,0);
10444   int index = ((int)  tolua_tonumber(tolua_S,2,0));
10445 #ifndef TOLUA_RELEASE
10446   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'", NULL);
10447 #endif
10448   {
10449    meshio::mqo::Object& tolua_ret = (meshio::mqo::Object&)  self->operator[](index);
10450     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::mqo::Object");
10451
10452   }
10453
10454  }
10455  return 1;
10456 #ifndef TOLUA_RELEASE
10457  tolua_lerror:
10458  tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
10459  return 0;
10460 #endif
10461 }
10462 #endif //#ifndef TOLUA_DISABLE
10463
10464 /* method: operator&[] of class  std::vector<meshio::mqo::Object> */
10465 #ifndef TOLUA_DISABLE_tolua_lmeshio_std_vector_meshio__mqo__Object___seti00
10466 static int tolua_lmeshio_std_vector_meshio__mqo__Object___seti00(lua_State* tolua_S)
10467 {
10468 #ifndef TOLUA_RELEASE
10469  tolua_Error tolua_err;
10470  if (
10471      !tolua_isusertype(tolua_S,1,"std::vector<meshio::mqo::Object>",0,&tolua_err) ||
10472      !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
10473      (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"meshio::mqo::Object",0,&tolua_err)) ||
10474      !tolua_isnoobj(tolua_S,4,&tolua_err)
10475  )
10476   goto tolua_lerror;
10477  else
10478 #endif
10479  {
10480   std::vector<meshio::mqo::Object>* self = (std::vector<meshio::mqo::Object>*)  tolua_tousertype(tolua_S,1,0);
10481   int index = ((int)  tolua_tonumber(tolua_S,2,0));
10482   meshio::mqo::Object tolua_value = *((meshio::mqo::Object*)  tolua_tousertype(tolua_S,3,0));
10483 #ifndef TOLUA_RELEASE
10484   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'", NULL);
10485 #endif
10486   self->operator[](index) =  tolua_value;
10487  }
10488  return 0;
10489 #ifndef TOLUA_RELEASE
10490  tolua_lerror:
10491  tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
10492  return 0;
10493 #endif
10494 }
10495 #endif //#ifndef TOLUA_DISABLE
10496
10497 /* stl foreachi: class  std::vector<meshio::mqo::Object> */
10498 #ifndef TOLUA_DISABLE_tolua_lmeshio_std__vector_meshio__mqo__Object__iterator
10499 static int tolua_lmeshio_std__vector_meshio__mqo__Object__iterator_gc(lua_State* tolua_S)
10500 {
10501     //printf("tolua_lmeshio_std__vector_meshio__mqo__Object__iterator_gc\n");
10502     std::pair<std::vector<meshio::mqo::Object>::iterator, std::vector<meshio::mqo::Object>::iterator> *range=(std::pair<std::vector<meshio::mqo::Object>::iterator, std::vector<meshio::mqo::Object>::iterator>*)lua_touserdata(tolua_S, 1);
10503     range->~pair<std::vector<meshio::mqo::Object>::iterator, std::vector<meshio::mqo::Object>::iterator>();
10504     return 0;
10505 }
10506
10507 static int tolua_lmeshio_std__vector_meshio__mqo__Object__iterator_internal(lua_State* tolua_S)
10508 {
10509   std::pair<std::vector<meshio::mqo::Object>::iterator, std::vector<meshio::mqo::Object>::iterator> *range=(std::pair<std::vector<meshio::mqo::Object>::iterator, std::vector<meshio::mqo::Object>::iterator>*)lua_touserdata(tolua_S, lua_upvalueindex(1));
10510   if(range->first==range->second){
10511       return 0;
10512   }
10513   int index=lua_tonumber(tolua_S, lua_upvalueindex(2));
10514   tolua_pushnumber(tolua_S, index);
10515   // update index
10516   tolua_pushnumber(tolua_S, index+1);
10517   lua_replace(tolua_S, lua_upvalueindex(2));
10518
10519   //tolua_pushusertype(tolua_S, &(*range->first++), "meshio::mqo::Object");
10520    meshio::mqo::Object& tolua_ret = (meshio::mqo::Object&) *range->first++;
10521     tolua_pushusertype(tolua_S,(void*)&tolua_ret,"meshio::mqo::Object");
10522
10523   return 2;
10524 }
10525
10526 static int tolua_lmeshio_std__vector_meshio__mqo__Object__iterator(lua_State* tolua_S)
10527 {
10528 #ifndef TOLUA_RELEASE
10529  tolua_Error tolua_err;
10530  if (
10531      !tolua_isusertype(tolua_S,1,"std::vector<meshio::mqo::Object>",0,&tolua_err) ||
10532      !tolua_isnoobj(tolua_S,2,&tolua_err)
10533  )
10534   goto tolua_lerror;
10535  else
10536 #endif
10537  {
10538   std::vector<meshio::mqo::Object>* self = (std::vector<meshio::mqo::Object>*)  tolua_tousertype(tolua_S,1,0);
10539 #ifndef TOLUA_RELEASE
10540   if (!self) tolua_error(tolua_S,"invalid 'self' in function 'foreachi'", NULL);
10541 #endif
10542   {
10543     std::pair<std::vector<meshio::mqo::Object>::iterator, std::vector<meshio::mqo::Object>::iterator>* range=(std::pair<std::vector<meshio::mqo::Object>::iterator, std::vector<meshio::mqo::Object>::iterator>*)lua_newuserdata(tolua_S, sizeof(std::pair<std::vector<meshio::mqo::Object>::iterator, std::vector<meshio::mqo::Object>::iterator>));
10544     *range=std::make_pair(self->begin(), self->end());
10545     luaL_getmetatable(tolua_S, "std::pair<std::vector<meshio::mqo::Object>::iterator, std::vector<meshio::mqo::Object>::iterator>");
10546     lua_setmetatable(tolua_S, -2);
10547     lua_pushnumber(tolua_S, 0);
10548     // gc
10549     lua_pushcclosure(tolua_S, tolua_lmeshio_std__vector_meshio__mqo__Object__iterator_internal, 2);
10550   }
10551  }
10552  return 1;
10553 #ifndef TOLUA_RELEASE
10554  tolua_lerror:
10555  tolua_error(tolua_S,"#ferror in function 'foreachi'.",&tolua_err);
10556  return 0;
10557 #endif
10558 }
10559 #endif //#ifndef TOLUA_DISABLE
10560
10561
10562 /* get function: first of class  std::pair<unsigned short,unsigned char> */
10563 #ifndef TOLUA_DISABLE_tolua_get_std__pair_unsigned_short_unsigned_char__unsigned_first
10564 static int tolua_get_std__pair_unsigned_short_unsigned_char__unsigned_first(lua_State* tolua_S)
10565 {
10566   std::pair<unsigned short,unsigned char>* self = (std::pair<unsigned short,unsigned char>*)  tolua_tousertype(tolua_S,1,0);
10567 #ifndef TOLUA_RELEASE
10568   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'first'",NULL);
10569 #endif
10570   tolua_pushnumber(tolua_S,(lua_Number)self->first);
10571  return 1;
10572 }
10573 #endif //#ifndef TOLUA_DISABLE
10574
10575 /* set function: first of class  std::pair<unsigned short,unsigned char> */
10576 #ifndef TOLUA_DISABLE_tolua_set_std__pair_unsigned_short_unsigned_char__unsigned_first
10577 static int tolua_set_std__pair_unsigned_short_unsigned_char__unsigned_first(lua_State* tolua_S)
10578 {
10579   std::pair<unsigned short,unsigned char>* self = (std::pair<unsigned short,unsigned char>*)  tolua_tousertype(tolua_S,1,0);
10580 #ifndef TOLUA_RELEASE
10581   tolua_Error tolua_err;
10582   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'first'",NULL);
10583   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
10584    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
10585 #endif
10586   self->first = ((unsigned short)  tolua_tonumber(tolua_S,2,0))
10587 ;
10588  return 0;
10589 }
10590 #endif //#ifndef TOLUA_DISABLE
10591
10592 /* get function: second of class  std::pair<unsigned short,unsigned char> */
10593 #ifndef TOLUA_DISABLE_tolua_get_std__pair_unsigned_short_unsigned_char__unsigned_second
10594 static int tolua_get_std__pair_unsigned_short_unsigned_char__unsigned_second(lua_State* tolua_S)
10595 {
10596   std::pair<unsigned short,unsigned char>* self = (std::pair<unsigned short,unsigned char>*)  tolua_tousertype(tolua_S,1,0);
10597 #ifndef TOLUA_RELEASE
10598   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'second'",NULL);
10599 #endif
10600   tolua_pushnumber(tolua_S,(lua_Number)self->second);
10601  return 1;
10602 }
10603 #endif //#ifndef TOLUA_DISABLE
10604
10605 /* set function: second of class  std::pair<unsigned short,unsigned char> */
10606 #ifndef TOLUA_DISABLE_tolua_set_std__pair_unsigned_short_unsigned_char__unsigned_second
10607 static int tolua_set_std__pair_unsigned_short_unsigned_char__unsigned_second(lua_State* tolua_S)
10608 {
10609   std::pair<unsigned short,unsigned char>* self = (std::pair<unsigned short,unsigned char>*)  tolua_tousertype(tolua_S,1,0);
10610 #ifndef TOLUA_RELEASE
10611   tolua_Error tolua_err;
10612   if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'second'",NULL);
10613   if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
10614    tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
10615 #endif
10616   self->second = ((unsigned char)  tolua_tonumber(tolua_S,2,0))
10617 ;
10618  return 0;
10619 }
10620 #endif //#ifndef TOLUA_DISABLE
10621
10622 /* Open function */
10623 TOLUA_API int tolua_lmeshio_open (lua_State* tolua_S)
10624 {
10625  tolua_open(tolua_S);
10626  tolua_reg_types(tolua_S);
10627  tolua_module(tolua_S,NULL,0);
10628  tolua_beginmodule(tolua_S,NULL);
10629   tolua_module(tolua_S,"meshio",0);
10630   tolua_beginmodule(tolua_S,"meshio");
10631    tolua_module(tolua_S,"pmd",0);
10632    tolua_beginmodule(tolua_S,"pmd");
10633     #ifdef __cplusplus
10634     tolua_cclass(tolua_S,"Vertex","meshio::pmd::Vertex","",tolua_collect_meshio__pmd__Vertex);
10635     #else
10636     tolua_cclass(tolua_S,"Vertex","meshio::pmd::Vertex","",NULL);
10637     #endif
10638     tolua_beginmodule(tolua_S,"Vertex");
10639      tolua_variable(tolua_S,"pos",tolua_get_meshio__pmd__Vertex_pos,tolua_set_meshio__pmd__Vertex_pos);
10640      tolua_variable(tolua_S,"normal",tolua_get_meshio__pmd__Vertex_normal,tolua_set_meshio__pmd__Vertex_normal);
10641      tolua_variable(tolua_S,"uv",tolua_get_meshio__pmd__Vertex_uv,tolua_set_meshio__pmd__Vertex_uv);
10642      tolua_variable(tolua_S,"bone0",tolua_get_meshio__pmd__Vertex_unsigned_bone0,tolua_set_meshio__pmd__Vertex_unsigned_bone0);
10643      tolua_variable(tolua_S,"bone1",tolua_get_meshio__pmd__Vertex_unsigned_bone1,tolua_set_meshio__pmd__Vertex_unsigned_bone1);
10644      tolua_variable(tolua_S,"weight0",tolua_get_meshio__pmd__Vertex_unsigned_weight0,tolua_set_meshio__pmd__Vertex_unsigned_weight0);
10645      tolua_variable(tolua_S,"edge_flag",tolua_get_meshio__pmd__Vertex_unsigned_edge_flag,tolua_set_meshio__pmd__Vertex_unsigned_edge_flag);
10646     tolua_endmodule(tolua_S);
10647     #ifdef __cplusplus
10648     tolua_cclass(tolua_S,"Material","meshio::pmd::Material","",tolua_collect_meshio__pmd__Material);
10649     #else
10650     tolua_cclass(tolua_S,"Material","meshio::pmd::Material","",NULL);
10651     #endif
10652     tolua_beginmodule(tolua_S,"Material");
10653      tolua_variable(tolua_S,"diffuse",tolua_get_meshio__pmd__Material_diffuse,tolua_set_meshio__pmd__Material_diffuse);
10654      tolua_variable(tolua_S,"shinness",tolua_get_meshio__pmd__Material_shinness,tolua_set_meshio__pmd__Material_shinness);
10655      tolua_variable(tolua_S,"specular",tolua_get_meshio__pmd__Material_specular,tolua_set_meshio__pmd__Material_specular);
10656      tolua_variable(tolua_S,"ambient",tolua_get_meshio__pmd__Material_ambient,tolua_set_meshio__pmd__Material_ambient);
10657      tolua_variable(tolua_S,"toon_index",tolua_get_meshio__pmd__Material_unsigned_toon_index,tolua_set_meshio__pmd__Material_unsigned_toon_index);
10658      tolua_variable(tolua_S,"flag",tolua_get_meshio__pmd__Material_unsigned_flag,tolua_set_meshio__pmd__Material_unsigned_flag);
10659      tolua_variable(tolua_S,"vertex_count",tolua_get_meshio__pmd__Material_unsigned_vertex_count,tolua_set_meshio__pmd__Material_unsigned_vertex_count);
10660      tolua_variable(tolua_S,"texture",tolua_get_meshio__pmd__Material_texture,tolua_set_meshio__pmd__Material_texture);
10661     tolua_endmodule(tolua_S);
10662     tolua_constant(tolua_S,"BONE_ROTATE",meshio::pmd::BONE_ROTATE);
10663     tolua_constant(tolua_S,"BONE_ROTATE_MOVE",meshio::pmd::BONE_ROTATE_MOVE);
10664     tolua_constant(tolua_S,"BONE_IK",meshio::pmd::BONE_IK);
10665     tolua_constant(tolua_S,"BONE_UNKNOWN",meshio::pmd::BONE_UNKNOWN);
10666     tolua_constant(tolua_S,"BONE_IK_INFLUENCED",meshio::pmd::BONE_IK_INFLUENCED);
10667     tolua_constant(tolua_S,"BONE_ROTATE_INFLUENCED",meshio::pmd::BONE_ROTATE_INFLUENCED);
10668     tolua_constant(tolua_S,"BONE_IK_CONNECT",meshio::pmd::BONE_IK_CONNECT);
10669     tolua_constant(tolua_S,"BONE_INVISIBLE",meshio::pmd::BONE_INVISIBLE);
10670     tolua_constant(tolua_S,"BONE_TWIST",meshio::pmd::BONE_TWIST);
10671     tolua_constant(tolua_S,"BONE_REVOLVE",meshio::pmd::BONE_REVOLVE);
10672     #ifdef __cplusplus
10673     tolua_cclass(tolua_S,"Bone","meshio::pmd::Bone","",tolua_collect_meshio__pmd__Bone);
10674     #else
10675     tolua_cclass(tolua_S,"Bone","meshio::pmd::Bone","",NULL);
10676     #endif
10677     tolua_beginmodule(tolua_S,"Bone");
10678      tolua_variable(tolua_S,"name",tolua_get_meshio__pmd__Bone_name,tolua_set_meshio__pmd__Bone_name);
10679      tolua_variable(tolua_S,"parent_index",tolua_get_meshio__pmd__Bone_unsigned_parent_index,tolua_set_meshio__pmd__Bone_unsigned_parent_index);
10680      tolua_variable(tolua_S,"tail_index",tolua_get_meshio__pmd__Bone_unsigned_tail_index,tolua_set_meshio__pmd__Bone_unsigned_tail_index);
10681      tolua_variable(tolua_S,"type",tolua_get_meshio__pmd__Bone_type,tolua_set_meshio__pmd__Bone_type);
10682      tolua_variable(tolua_S,"ik_index",tolua_get_meshio__pmd__Bone_unsigned_ik_index,tolua_set_meshio__pmd__Bone_unsigned_ik_index);
10683      tolua_variable(tolua_S,"pos",tolua_get_meshio__pmd__Bone_pos,tolua_set_meshio__pmd__Bone_pos);
10684      tolua_variable(tolua_S,"english_name",tolua_get_meshio__pmd__Bone_english_name,tolua_set_meshio__pmd__Bone_english_name);
10685      tolua_variable(tolua_S,"parent",tolua_get_meshio__pmd__Bone_parent_ptr,tolua_set_meshio__pmd__Bone_parent_ptr);
10686      tolua_variable(tolua_S,"tail",tolua_get_meshio__pmd__Bone_tail,tolua_set_meshio__pmd__Bone_tail);
10687      tolua_variable(tolua_S,"children",tolua_get_meshio__pmd__Bone_children,tolua_set_meshio__pmd__Bone_children);
10688      tolua_variable(tolua_S,"index",tolua_get_meshio__pmd__Bone_unsigned_index,tolua_set_meshio__pmd__Bone_unsigned_index);
10689      tolua_function(tolua_S,"new",tolua_lmeshio_meshio_pmd_Bone_new00);
10690      tolua_function(tolua_S,"new_local",tolua_lmeshio_meshio_pmd_Bone_new00_local);
10691      tolua_function(tolua_S,".call",tolua_lmeshio_meshio_pmd_Bone_new00_local);
10692     tolua_endmodule(tolua_S);
10693     #ifdef __cplusplus
10694     tolua_cclass(tolua_S,"IK","meshio::pmd::IK","",tolua_collect_meshio__pmd__IK);
10695     #else
10696     tolua_cclass(tolua_S,"IK","meshio::pmd::IK","",NULL);
10697     #endif
10698     tolua_beginmodule(tolua_S,"IK");
10699      tolua_variable(tolua_S,"index",tolua_get_meshio__pmd__IK_unsigned_index,tolua_set_meshio__pmd__IK_unsigned_index);
10700      tolua_variable(tolua_S,"target",tolua_get_meshio__pmd__IK_unsigned_target,tolua_set_meshio__pmd__IK_unsigned_target);
10701      tolua_variable(tolua_S,"length",tolua_get_meshio__pmd__IK_unsigned_length,tolua_set_meshio__pmd__IK_unsigned_length);
10702      tolua_variable(tolua_S,"iterations",tolua_get_meshio__pmd__IK_unsigned_iterations,tolua_set_meshio__pmd__IK_unsigned_iterations);
10703      tolua_variable(tolua_S,"weight",tolua_get_meshio__pmd__IK_weight,tolua_set_meshio__pmd__IK_weight);
10704      tolua_variable(tolua_S,"children",tolua_get_meshio__pmd__IK_children,tolua_set_meshio__pmd__IK_children);
10705     tolua_endmodule(tolua_S);
10706     tolua_constant(tolua_S,"MORPH_BASE",meshio::pmd::MORPH_BASE);
10707     tolua_constant(tolua_S,"MORPH_MAYU",meshio::pmd::MORPH_MAYU);
10708     tolua_constant(tolua_S,"MORPH_ME",meshio::pmd::MORPH_ME);
10709     tolua_constant(tolua_S,"MORPH_LIP",meshio::pmd::MORPH_LIP);
10710     tolua_constant(tolua_S,"MORPH_OTHER",meshio::pmd::MORPH_OTHER);
10711     #ifdef __cplusplus
10712     tolua_cclass(tolua_S,"Morph","meshio::pmd::Morph","",tolua_collect_meshio__pmd__Morph);
10713     #else
10714     tolua_cclass(tolua_S,"Morph","meshio::pmd::Morph","",NULL);
10715     #endif
10716     tolua_beginmodule(tolua_S,"Morph");
10717      tolua_variable(tolua_S,"name",tolua_get_meshio__pmd__Morph_name,tolua_set_meshio__pmd__Morph_name);
10718      tolua_variable(tolua_S,"vertex_count",tolua_get_meshio__pmd__Morph_unsigned_vertex_count,tolua_set_meshio__pmd__Morph_unsigned_vertex_count);
10719      tolua_variable(tolua_S,"type",tolua_get_meshio__pmd__Morph_unsigned_type,tolua_set_meshio__pmd__Morph_unsigned_type);
10720      tolua_variable(tolua_S,"indices",tolua_get_meshio__pmd__Morph_indices,tolua_set_meshio__pmd__Morph_indices);
10721      tolua_variable(tolua_S,"pos_list",tolua_get_meshio__pmd__Morph_pos_list,tolua_set_meshio__pmd__Morph_pos_list);
10722      tolua_variable(tolua_S,"english_name",tolua_get_meshio__pmd__Morph_english_name,tolua_set_meshio__pmd__Morph_english_name);
10723     tolua_endmodule(tolua_S);
10724     #ifdef __cplusplus
10725     tolua_cclass(tolua_S,"BoneGroup","meshio::pmd::BoneGroup","",tolua_collect_meshio__pmd__BoneGroup);
10726     #else
10727     tolua_cclass(tolua_S,"BoneGroup","meshio::pmd::BoneGroup","",NULL);
10728     #endif
10729     tolua_beginmodule(tolua_S,"BoneGroup");
10730      tolua_variable(tolua_S,"name",tolua_get_meshio__pmd__BoneGroup_name,tolua_set_meshio__pmd__BoneGroup_name);
10731      tolua_variable(tolua_S,"english_name",tolua_get_meshio__pmd__BoneGroup_english_name,tolua_set_meshio__pmd__BoneGroup_english_name);
10732     tolua_endmodule(tolua_S);
10733     tolua_constant(tolua_S,"SHAPE_SPHERE",meshio::pmd::SHAPE_SPHERE);
10734     tolua_constant(tolua_S,"SHAPE_BOX",meshio::pmd::SHAPE_BOX);
10735     tolua_constant(tolua_S,"SHAPE_CAPSULE",meshio::pmd::SHAPE_CAPSULE);
10736     tolua_constant(tolua_S,"RIGIDBODY_KINEMATICS",meshio::pmd::RIGIDBODY_KINEMATICS);
10737     tolua_constant(tolua_S,"RIGIDBODY_PHYSICS",meshio::pmd::RIGIDBODY_PHYSICS);
10738     tolua_constant(tolua_S,"RIGIDBODY_PHYSICS_WITH_BONE",meshio::pmd::RIGIDBODY_PHYSICS_WITH_BONE);
10739     #ifdef __cplusplus
10740     tolua_cclass(tolua_S,"RigidBody","meshio::pmd::RigidBody","",tolua_collect_meshio__pmd__RigidBody);
10741     #else
10742     tolua_cclass(tolua_S,"RigidBody","meshio::pmd::RigidBody","",NULL);
10743     #endif
10744     tolua_beginmodule(tolua_S,"RigidBody");
10745      tolua_variable(tolua_S,"name",tolua_get_meshio__pmd__RigidBody_name,tolua_set_meshio__pmd__RigidBody_name);
10746      tolua_variable(tolua_S,"boneIndex",tolua_get_meshio__pmd__RigidBody_unsigned_boneIndex,tolua_set_meshio__pmd__RigidBody_unsigned_boneIndex);
10747      tolua_variable(tolua_S,"group",tolua_get_meshio__pmd__RigidBody_unsigned_group,tolua_set_meshio__pmd__RigidBody_unsigned_group);
10748      tolua_variable(tolua_S,"target",tolua_get_meshio__pmd__RigidBody_unsigned_target,tolua_set_meshio__pmd__RigidBody_unsigned_target);
10749      tolua_variable(tolua_S,"shapeType",tolua_get_meshio__pmd__RigidBody_shapeType,tolua_set_meshio__pmd__RigidBody_shapeType);
10750      tolua_variable(tolua_S,"w",tolua_get_meshio__pmd__RigidBody_w,tolua_set_meshio__pmd__RigidBody_w);
10751      tolua_variable(tolua_S,"h",tolua_get_meshio__pmd__RigidBody_h,tolua_set_meshio__pmd__RigidBody_h);
10752      tolua_variable(tolua_S,"d",tolua_get_meshio__pmd__RigidBody_d,tolua_set_meshio__pmd__RigidBody_d);
10753      tolua_variable(tolua_S,"position",tolua_get_meshio__pmd__RigidBody_position,tolua_set_meshio__pmd__RigidBody_position);
10754      tolua_variable(tolua_S,"rotation",tolua_get_meshio__pmd__RigidBody_rotation,tolua_set_meshio__pmd__RigidBody_rotation);
10755      tolua_variable(tolua_S,"weight",tolua_get_meshio__pmd__RigidBody_weight,tolua_set_meshio__pmd__RigidBody_weight);
10756      tolua_variable(tolua_S,"linearDamping",tolua_get_meshio__pmd__RigidBody_linearDamping,tolua_set_meshio__pmd__RigidBody_linearDamping);
10757      tolua_variable(tolua_S,"angularDamping",tolua_get_meshio__pmd__RigidBody_angularDamping,tolua_set_meshio__pmd__RigidBody_angularDamping);
10758      tolua_variable(tolua_S,"restitution",tolua_get_meshio__pmd__RigidBody_restitution,tolua_set_meshio__pmd__RigidBody_restitution);
10759      tolua_variable(tolua_S,"friction",tolua_get_meshio__pmd__RigidBody_friction,tolua_set_meshio__pmd__RigidBody_friction);
10760      tolua_variable(tolua_S,"processType",tolua_get_meshio__pmd__RigidBody_processType,tolua_set_meshio__pmd__RigidBody_processType);
10761     tolua_endmodule(tolua_S);
10762     #ifdef __cplusplus
10763     tolua_cclass(tolua_S,"Constraint","meshio::pmd::Constraint","",tolua_collect_meshio__pmd__Constraint);
10764     #else
10765     tolua_cclass(tolua_S,"Constraint","meshio::pmd::Constraint","",NULL);
10766     #endif
10767     tolua_beginmodule(tolua_S,"Constraint");
10768      tolua_variable(tolua_S,"name",tolua_get_meshio__pmd__Constraint_name,tolua_set_meshio__pmd__Constraint_name);
10769      tolua_variable(tolua_S,"rigidA",tolua_get_meshio__pmd__Constraint_unsigned_rigidA,tolua_set_meshio__pmd__Constraint_unsigned_rigidA);
10770      tolua_variable(tolua_S,"rigidB",tolua_get_meshio__pmd__Constraint_unsigned_rigidB,tolua_set_meshio__pmd__Constraint_unsigned_rigidB);
10771      tolua_variable(tolua_S,"pos",tolua_get_meshio__pmd__Constraint_pos,tolua_set_meshio__pmd__Constraint_pos);
10772      tolua_variable(tolua_S,"rot",tolua_get_meshio__pmd__Constraint_rot,tolua_set_meshio__pmd__Constraint_rot);
10773      tolua_variable(tolua_S,"constraintPosMin",tolua_get_meshio__pmd__Constraint_constraintPosMin,tolua_set_meshio__pmd__Constraint_constraintPosMin);
10774      tolua_variable(tolua_S,"constraintPosMax",tolua_get_meshio__pmd__Constraint_constraintPosMax,tolua_set_meshio__pmd__Constraint_constraintPosMax);
10775      tolua_variable(tolua_S,"constraintRotMin",tolua_get_meshio__pmd__Constraint_constraintRotMin,tolua_set_meshio__pmd__Constraint_constraintRotMin);
10776      tolua_variable(tolua_S,"constraintRotMax",tolua_get_meshio__pmd__Constraint_constraintRotMax,tolua_set_meshio__pmd__Constraint_constraintRotMax);
10777      tolua_variable(tolua_S,"springPos",tolua_get_meshio__pmd__Constraint_springPos,tolua_set_meshio__pmd__Constraint_springPos);
10778      tolua_variable(tolua_S,"springRot",tolua_get_meshio__pmd__Constraint_springRot,tolua_set_meshio__pmd__Constraint_springRot);
10779     tolua_endmodule(tolua_S);
10780     #ifdef __cplusplus
10781     tolua_cclass(tolua_S,"IO","meshio::pmd::IO","",tolua_collect_meshio__pmd__IO);
10782     #else
10783     tolua_cclass(tolua_S,"IO","meshio::pmd::IO","",NULL);
10784     #endif
10785     tolua_beginmodule(tolua_S,"IO");
10786      tolua_variable(tolua_S,"version",tolua_get_meshio__pmd__IO_version,tolua_set_meshio__pmd__IO_version);
10787      tolua_variable(tolua_S,"name",tolua_get_meshio__pmd__IO_name,tolua_set_meshio__pmd__IO_name);
10788      tolua_variable(tolua_S,"comment",tolua_get_meshio__pmd__IO_comment,tolua_set_meshio__pmd__IO_comment);
10789      tolua_variable(tolua_S,"vertices",tolua_get_meshio__pmd__IO_vertices,tolua_set_meshio__pmd__IO_vertices);
10790      tolua_variable(tolua_S,"indices",tolua_get_meshio__pmd__IO_indices,tolua_set_meshio__pmd__IO_indices);
10791      tolua_variable(tolua_S,"materials",tolua_get_meshio__pmd__IO_materials,tolua_set_meshio__pmd__IO_materials);
10792      tolua_variable(tolua_S,"bones",tolua_get_meshio__pmd__IO_bones,tolua_set_meshio__pmd__IO_bones);
10793      tolua_variable(tolua_S,"ik_list",tolua_get_meshio__pmd__IO_ik_list,tolua_set_meshio__pmd__IO_ik_list);
10794      tolua_variable(tolua_S,"morph_list",tolua_get_meshio__pmd__IO_morph_list,tolua_set_meshio__pmd__IO_morph_list);
10795      tolua_variable(tolua_S,"face_list",tolua_get_meshio__pmd__IO_face_list,tolua_set_meshio__pmd__IO_face_list);
10796      tolua_variable(tolua_S,"bone_group_list",tolua_get_meshio__pmd__IO_bone_group_list,tolua_set_meshio__pmd__IO_bone_group_list);
10797      tolua_variable(tolua_S,"bone_display_list",tolua_get_meshio__pmd__IO_bone_display_list,tolua_set_meshio__pmd__IO_bone_display_list);
10798      tolua_variable(tolua_S,"toon_textures",tolua_get_meshio__pmd__IO_toon_textures,tolua_set_meshio__pmd__IO_toon_textures);
10799      tolua_variable(tolua_S,"rigidbodies",tolua_get_meshio__pmd__IO_rigidbodies,tolua_set_meshio__pmd__IO_rigidbodies);
10800      tolua_variable(tolua_S,"constraints",tolua_get_meshio__pmd__IO_constraints,tolua_set_meshio__pmd__IO_constraints);
10801      tolua_variable(tolua_S,"english_name",tolua_get_meshio__pmd__IO_english_name,tolua_set_meshio__pmd__IO_english_name);
10802      tolua_variable(tolua_S,"english_comment",tolua_get_meshio__pmd__IO_english_comment,tolua_set_meshio__pmd__IO_english_comment);
10803      tolua_function(tolua_S,"new",tolua_lmeshio_meshio_pmd_IO_new00);
10804      tolua_function(tolua_S,"new_local",tolua_lmeshio_meshio_pmd_IO_new00_local);
10805      tolua_function(tolua_S,".call",tolua_lmeshio_meshio_pmd_IO_new00_local);
10806      tolua_function(tolua_S,"read",tolua_lmeshio_meshio_pmd_IO_read00);
10807      tolua_function(tolua_S,"write",tolua_lmeshio_meshio_pmd_IO_write00);
10808     tolua_endmodule(tolua_S);
10809    tolua_endmodule(tolua_S);
10810    tolua_module(tolua_S,"mqo",0);
10811    tolua_beginmodule(tolua_S,"mqo");
10812     tolua_cclass(tolua_S,"Scene","meshio::mqo::Scene","",NULL);
10813     tolua_beginmodule(tolua_S,"Scene");
10814      tolua_variable(tolua_S,"pos",tolua_get_meshio__mqo__Scene_pos,tolua_set_meshio__mqo__Scene_pos);
10815      tolua_variable(tolua_S,"lookat",tolua_get_meshio__mqo__Scene_lookat,tolua_set_meshio__mqo__Scene_lookat);
10816      tolua_variable(tolua_S,"head",tolua_get_meshio__mqo__Scene_head,tolua_set_meshio__mqo__Scene_head);
10817      tolua_variable(tolua_S,"pitch",tolua_get_meshio__mqo__Scene_pitch,tolua_set_meshio__mqo__Scene_pitch);
10818      tolua_variable(tolua_S,"ortho",tolua_get_meshio__mqo__Scene_ortho,tolua_set_meshio__mqo__Scene_ortho);
10819      tolua_variable(tolua_S,"zoom2",tolua_get_meshio__mqo__Scene_zoom2,tolua_set_meshio__mqo__Scene_zoom2);
10820      tolua_variable(tolua_S,"ambient",tolua_get_meshio__mqo__Scene_ambient,tolua_set_meshio__mqo__Scene_ambient);
10821     tolua_endmodule(tolua_S);
10822     #ifdef __cplusplus
10823     tolua_cclass(tolua_S,"Material","meshio::mqo::Material","",tolua_collect_meshio__mqo__Material);
10824     #else
10825     tolua_cclass(tolua_S,"Material","meshio::mqo::Material","",NULL);
10826     #endif
10827     tolua_beginmodule(tolua_S,"Material");
10828      tolua_variable(tolua_S,"name",tolua_get_meshio__mqo__Material_name,tolua_set_meshio__mqo__Material_name);
10829      tolua_variable(tolua_S,"shader",tolua_get_meshio__mqo__Material_shader,tolua_set_meshio__mqo__Material_shader);
10830      tolua_variable(tolua_S,"color",tolua_get_meshio__mqo__Material_color,tolua_set_meshio__mqo__Material_color);
10831      tolua_variable(tolua_S,"diffuse",tolua_get_meshio__mqo__Material_diffuse,tolua_set_meshio__mqo__Material_diffuse);
10832      tolua_variable(tolua_S,"ambient",tolua_get_meshio__mqo__Material_ambient,tolua_set_meshio__mqo__Material_ambient);
10833      tolua_variable(tolua_S,"emit",tolua_get_meshio__mqo__Material_emit,tolua_set_meshio__mqo__Material_emit);
10834      tolua_variable(tolua_S,"specular",tolua_get_meshio__mqo__Material_specular,tolua_set_meshio__mqo__Material_specular);
10835      tolua_variable(tolua_S,"power",tolua_get_meshio__mqo__Material_power,tolua_set_meshio__mqo__Material_power);
10836      tolua_variable(tolua_S,"texture",tolua_get_meshio__mqo__Material_texture,tolua_set_meshio__mqo__Material_texture);
10837      tolua_variable(tolua_S,"alphamap",tolua_get_meshio__mqo__Material_alphamap,tolua_set_meshio__mqo__Material_alphamap);
10838      tolua_variable(tolua_S,"bumpmap",tolua_get_meshio__mqo__Material_bumpmap,tolua_set_meshio__mqo__Material_bumpmap);
10839      tolua_variable(tolua_S,"vcol",tolua_get_meshio__mqo__Material_vcol,tolua_set_meshio__mqo__Material_vcol);
10840     tolua_endmodule(tolua_S);
10841     #ifdef __cplusplus
10842     tolua_cclass(tolua_S,"Face","meshio::mqo::Face","",tolua_collect_meshio__mqo__Face);
10843     #else
10844     tolua_cclass(tolua_S,"Face","meshio::mqo::Face","",NULL);
10845     #endif
10846     tolua_beginmodule(tolua_S,"Face");
10847      tolua_variable(tolua_S,"index_count",tolua_get_meshio__mqo__Face_unsigned_index_count,tolua_set_meshio__mqo__Face_unsigned_index_count);
10848      tolua_array(tolua_S,"indices",tolua_get_lmeshio_meshio_mqo_Face_indices,tolua_set_lmeshio_meshio_mqo_Face_indices);
10849      tolua_variable(tolua_S,"material_index",tolua_get_meshio__mqo__Face_unsigned_material_index,tolua_set_meshio__mqo__Face_unsigned_material_index);
10850      tolua_array(tolua_S,"uv",tolua_get_lmeshio_meshio_mqo_Face_uv,tolua_set_lmeshio_meshio_mqo_Face_uv);
10851      tolua_array(tolua_S,"color",tolua_get_lmeshio_meshio_mqo_Face_color,tolua_set_lmeshio_meshio_mqo_Face_color);
10852     tolua_endmodule(tolua_S);
10853     #ifdef __cplusplus
10854     tolua_cclass(tolua_S,"Object","meshio::mqo::Object","",tolua_collect_meshio__mqo__Object);
10855     #else
10856     tolua_cclass(tolua_S,"Object","meshio::mqo::Object","",NULL);
10857     #endif
10858     tolua_beginmodule(tolua_S,"Object");
10859      tolua_variable(tolua_S,"name",tolua_get_meshio__mqo__Object_name,tolua_set_meshio__mqo__Object_name);
10860      tolua_variable(tolua_S,"depth",tolua_get_meshio__mqo__Object_depth,tolua_set_meshio__mqo__Object_depth);
10861      tolua_variable(tolua_S,"folding",tolua_get_meshio__mqo__Object_folding,tolua_set_meshio__mqo__Object_folding);
10862      tolua_variable(tolua_S,"scale",tolua_get_meshio__mqo__Object_scale,tolua_set_meshio__mqo__Object_scale);
10863      tolua_variable(tolua_S,"rotation",tolua_get_meshio__mqo__Object_rotation,tolua_set_meshio__mqo__Object_rotation);
10864      tolua_variable(tolua_S,"translation",tolua_get_meshio__mqo__Object_translation,tolua_set_meshio__mqo__Object_translation);
10865      tolua_variable(tolua_S,"visible",tolua_get_meshio__mqo__Object_visible,tolua_set_meshio__mqo__Object_visible);
10866      tolua_variable(tolua_S,"locking",tolua_get_meshio__mqo__Object_locking,tolua_set_meshio__mqo__Object_locking);
10867      tolua_variable(tolua_S,"shading",tolua_get_meshio__mqo__Object_shading,tolua_set_meshio__mqo__Object_shading);
10868      tolua_variable(tolua_S,"smoothing",tolua_get_meshio__mqo__Object_smoothing,tolua_set_meshio__mqo__Object_smoothing);
10869      tolua_variable(tolua_S,"color",tolua_get_meshio__mqo__Object_color,tolua_set_meshio__mqo__Object_color);
10870      tolua_variable(tolua_S,"color_type",tolua_get_meshio__mqo__Object_color_type,tolua_set_meshio__mqo__Object_color_type);
10871      tolua_variable(tolua_S,"mirror",tolua_get_meshio__mqo__Object_mirror,tolua_set_meshio__mqo__Object_mirror);
10872      tolua_variable(tolua_S,"vertices",tolua_get_meshio__mqo__Object_vertices,tolua_set_meshio__mqo__Object_vertices);
10873      tolua_variable(tolua_S,"faces",tolua_get_meshio__mqo__Object_faces,tolua_set_meshio__mqo__Object_faces);
10874     tolua_endmodule(tolua_S);
10875     #ifdef __cplusplus
10876     tolua_cclass(tolua_S,"IO","meshio::mqo::IO","",tolua_collect_meshio__mqo__IO);
10877     #else
10878     tolua_cclass(tolua_S,"IO","meshio::mqo::IO","",NULL);
10879     #endif
10880     tolua_beginmodule(tolua_S,"IO");
10881      tolua_variable(tolua_S,"scene",tolua_get_meshio__mqo__IO_scene,tolua_set_meshio__mqo__IO_scene);
10882      tolua_variable(tolua_S,"materials",tolua_get_meshio__mqo__IO_materials,tolua_set_meshio__mqo__IO_materials);
10883      tolua_variable(tolua_S,"objects",tolua_get_meshio__mqo__IO_objects,tolua_set_meshio__mqo__IO_objects);
10884      tolua_function(tolua_S,"new",tolua_lmeshio_meshio_mqo_IO_new00);
10885      tolua_function(tolua_S,"new_local",tolua_lmeshio_meshio_mqo_IO_new00_local);
10886      tolua_function(tolua_S,".call",tolua_lmeshio_meshio_mqo_IO_new00_local);
10887      tolua_function(tolua_S,"read",tolua_lmeshio_meshio_mqo_IO_read00);
10888      tolua_function(tolua_S,"write",tolua_lmeshio_meshio_mqo_IO_write00);
10889     tolua_endmodule(tolua_S);
10890    tolua_endmodule(tolua_S);
10891    #ifdef __cplusplus
10892    tolua_cclass(tolua_S,"Vector2","meshio::Vector2","",tolua_collect_meshio__Vector2);
10893    #else
10894    tolua_cclass(tolua_S,"Vector2","meshio::Vector2","",NULL);
10895    #endif
10896    tolua_beginmodule(tolua_S,"Vector2");
10897     tolua_variable(tolua_S,"x",tolua_get_meshio__Vector2_x,tolua_set_meshio__Vector2_x);
10898     tolua_variable(tolua_S,"y",tolua_get_meshio__Vector2_y,tolua_set_meshio__Vector2_y);
10899     tolua_function(tolua_S,"new",tolua_lmeshio_meshio_Vector2_new00);
10900     tolua_function(tolua_S,"new_local",tolua_lmeshio_meshio_Vector2_new00_local);
10901     tolua_function(tolua_S,".call",tolua_lmeshio_meshio_Vector2_new00_local);
10902    tolua_endmodule(tolua_S);
10903    #ifdef __cplusplus
10904    tolua_cclass(tolua_S,"Vector3","meshio::Vector3","",tolua_collect_meshio__Vector3);
10905    #else
10906    tolua_cclass(tolua_S,"Vector3","meshio::Vector3","",NULL);
10907    #endif
10908    tolua_beginmodule(tolua_S,"Vector3");
10909     tolua_variable(tolua_S,"x",tolua_get_meshio__Vector3_x,tolua_set_meshio__Vector3_x);
10910     tolua_variable(tolua_S,"y",tolua_get_meshio__Vector3_y,tolua_set_meshio__Vector3_y);
10911     tolua_variable(tolua_S,"z",tolua_get_meshio__Vector3_z,tolua_set_meshio__Vector3_z);
10912     tolua_function(tolua_S,"new",tolua_lmeshio_meshio_Vector3_new00);
10913     tolua_function(tolua_S,"new_local",tolua_lmeshio_meshio_Vector3_new00_local);
10914     tolua_function(tolua_S,".call",tolua_lmeshio_meshio_Vector3_new00_local);
10915     tolua_function(tolua_S,".eq",tolua_lmeshio_meshio_Vector3__eq00);
10916     tolua_function(tolua_S,".add",tolua_lmeshio_meshio_Vector3__add00);
10917     tolua_function(tolua_S,".sub",tolua_lmeshio_meshio_Vector3__sub00);
10918    tolua_endmodule(tolua_S);
10919    #ifdef __cplusplus
10920    tolua_cclass(tolua_S,"Vector4","meshio::Vector4","",tolua_collect_meshio__Vector4);
10921    #else
10922    tolua_cclass(tolua_S,"Vector4","meshio::Vector4","",NULL);
10923    #endif
10924    tolua_beginmodule(tolua_S,"Vector4");
10925     tolua_variable(tolua_S,"x",tolua_get_meshio__Vector4_x,tolua_set_meshio__Vector4_x);
10926     tolua_variable(tolua_S,"y",tolua_get_meshio__Vector4_y,tolua_set_meshio__Vector4_y);
10927     tolua_variable(tolua_S,"z",tolua_get_meshio__Vector4_z,tolua_set_meshio__Vector4_z);
10928     tolua_variable(tolua_S,"w",tolua_get_meshio__Vector4_w,tolua_set_meshio__Vector4_w);
10929     tolua_function(tolua_S,"new",tolua_lmeshio_meshio_Vector4_new00);
10930     tolua_function(tolua_S,"new_local",tolua_lmeshio_meshio_Vector4_new00_local);
10931     tolua_function(tolua_S,".call",tolua_lmeshio_meshio_Vector4_new00_local);
10932    tolua_endmodule(tolua_S);
10933    #ifdef __cplusplus
10934    tolua_cclass(tolua_S,"Quaternion","meshio::Quaternion","",tolua_collect_meshio__Quaternion);
10935    #else
10936    tolua_cclass(tolua_S,"Quaternion","meshio::Quaternion","",NULL);
10937    #endif
10938    tolua_beginmodule(tolua_S,"Quaternion");
10939     tolua_variable(tolua_S,"x",tolua_get_meshio__Quaternion_x,tolua_set_meshio__Quaternion_x);
10940     tolua_variable(tolua_S,"y",tolua_get_meshio__Quaternion_y,tolua_set_meshio__Quaternion_y);
10941     tolua_variable(tolua_S,"z",tolua_get_meshio__Quaternion_z,tolua_set_meshio__Quaternion_z);
10942     tolua_variable(tolua_S,"w",tolua_get_meshio__Quaternion_w,tolua_set_meshio__Quaternion_w);
10943     tolua_function(tolua_S,"new",tolua_lmeshio_meshio_Quaternion_new00);
10944     tolua_function(tolua_S,"new_local",tolua_lmeshio_meshio_Quaternion_new00_local);
10945     tolua_function(tolua_S,".call",tolua_lmeshio_meshio_Quaternion_new00_local);
10946     tolua_function(tolua_S,"dot",tolua_lmeshio_meshio_Quaternion_dot00);
10947    tolua_endmodule(tolua_S);
10948    #ifdef __cplusplus
10949    tolua_cclass(tolua_S,"fRGBA","meshio::fRGBA","",tolua_collect_meshio__fRGBA);
10950    #else
10951    tolua_cclass(tolua_S,"fRGBA","meshio::fRGBA","",NULL);
10952    #endif
10953    tolua_beginmodule(tolua_S,"fRGBA");
10954     tolua_variable(tolua_S,"r",tolua_get_meshio__fRGBA_r,tolua_set_meshio__fRGBA_r);
10955     tolua_variable(tolua_S,"g",tolua_get_meshio__fRGBA_g,tolua_set_meshio__fRGBA_g);
10956     tolua_variable(tolua_S,"b",tolua_get_meshio__fRGBA_b,tolua_set_meshio__fRGBA_b);
10957     tolua_variable(tolua_S,"a",tolua_get_meshio__fRGBA_a,tolua_set_meshio__fRGBA_a);
10958    tolua_endmodule(tolua_S);
10959    tolua_cclass(tolua_S,"fixed_string_20_","meshio::fixed_string<20>","",NULL);
10960    tolua_beginmodule(tolua_S,"fixed_string_20_");
10961     tolua_function(tolua_S,"str",tolua_lmeshio_meshio_fixed_string_20__str00);
10962     tolua_function(tolua_S,"assign",tolua_lmeshio_meshio_fixed_string_20__assign00);
10963    tolua_endmodule(tolua_S);
10964    tolua_cclass(tolua_S,"fixed_string_50_","meshio::fixed_string<50>","",NULL);
10965    tolua_beginmodule(tolua_S,"fixed_string_50_");
10966     tolua_function(tolua_S,"str",tolua_lmeshio_meshio_fixed_string_50__str00);
10967     tolua_function(tolua_S,"assign",tolua_lmeshio_meshio_fixed_string_50__assign00);
10968    tolua_endmodule(tolua_S);
10969    tolua_cclass(tolua_S,"fixed_string_100_","meshio::fixed_string<100>","",NULL);
10970    tolua_beginmodule(tolua_S,"fixed_string_100_");
10971     tolua_function(tolua_S,"str",tolua_lmeshio_meshio_fixed_string_100__str00);
10972     tolua_function(tolua_S,"assign",tolua_lmeshio_meshio_fixed_string_100__assign00);
10973    tolua_endmodule(tolua_S);
10974    tolua_cclass(tolua_S,"fixed_string_256_","meshio::fixed_string<256>","",NULL);
10975    tolua_beginmodule(tolua_S,"fixed_string_256_");
10976     tolua_function(tolua_S,"str",tolua_lmeshio_meshio_fixed_string_256__str00);
10977     tolua_function(tolua_S,"assign",tolua_lmeshio_meshio_fixed_string_256__assign00);
10978    tolua_endmodule(tolua_S);
10979   tolua_endmodule(tolua_S);
10980   tolua_module(tolua_S,"std",0);
10981   tolua_beginmodule(tolua_S,"std");
10982    #ifdef __cplusplus
10983    tolua_cclass(tolua_S,"vector_meshio__pmd__Bone__","std::vector<meshio::pmd::Bone*>","",tolua_collect_std__vector_meshio__pmd__Bone__);
10984    #else
10985    tolua_cclass(tolua_S,"vector_meshio__pmd__Bone__","std::vector<meshio::pmd::Bone*>","",NULL);
10986    #endif
10987    tolua_beginmodule(tolua_S,"vector_meshio__pmd__Bone__");
10988     tolua_function(tolua_S,"new",tolua_lmeshio_std_vector_meshio__pmd__Bone___new00);
10989     tolua_function(tolua_S,"new_local",tolua_lmeshio_std_vector_meshio__pmd__Bone___new00_local);
10990     tolua_function(tolua_S,".call",tolua_lmeshio_std_vector_meshio__pmd__Bone___new00_local);
10991     tolua_function(tolua_S,"size",tolua_lmeshio_std_vector_meshio__pmd__Bone___size00);
10992     tolua_function(tolua_S,"push_back",tolua_lmeshio_std_vector_meshio__pmd__Bone___push_back00);
10993     tolua_function(tolua_S,"back",tolua_lmeshio_std_vector_meshio__pmd__Bone___back00);
10994     tolua_function(tolua_S,".geti",tolua_lmeshio_std_vector_meshio__pmd__Bone____geti00);
10995     tolua_function(tolua_S,".seti",tolua_lmeshio_std_vector_meshio__pmd__Bone____seti00);
10996     luaL_getmetatable(tolua_S, "std::pair<std::vector<meshio::pmd::Bone*>::iterator, std::vector<meshio::pmd::Bone*>::iterator>");
10997     lua_pushstring(tolua_S, "__gc");
10998     lua_pushcfunction(tolua_S, tolua_lmeshio_std__vector_meshio__pmd__Bone___iterator_gc);
10999     lua_settable(tolua_S, -3);
11000     lua_pop(tolua_S, 1);
11001     tolua_function(tolua_S,"foreachi",tolua_lmeshio_std__vector_meshio__pmd__Bone___iterator);
11002    tolua_endmodule(tolua_S);
11003    #ifdef __cplusplus
11004    tolua_cclass(tolua_S,"vector_unsigned_short_","std::vector<unsigned short>","",tolua_collect_std__vector_unsigned_short_);
11005    #else
11006    tolua_cclass(tolua_S,"vector_unsigned_short_","std::vector<unsigned short>","",NULL);
11007    #endif
11008    tolua_beginmodule(tolua_S,"vector_unsigned_short_");
11009     tolua_function(tolua_S,"new",tolua_lmeshio_std_vector_unsigned_short__new00);
11010     tolua_function(tolua_S,"new_local",tolua_lmeshio_std_vector_unsigned_short__new00_local);
11011     tolua_function(tolua_S,".call",tolua_lmeshio_std_vector_unsigned_short__new00_local);
11012     tolua_function(tolua_S,"size",tolua_lmeshio_std_vector_unsigned_short__size00);
11013     tolua_function(tolua_S,"push_back",tolua_lmeshio_std_vector_unsigned_short__push_back00);
11014     tolua_function(tolua_S,"back",tolua_lmeshio_std_vector_unsigned_short__back00);
11015     tolua_function(tolua_S,".geti",tolua_lmeshio_std_vector_unsigned_short___geti00);
11016     tolua_function(tolua_S,".seti",tolua_lmeshio_std_vector_unsigned_short___seti00);
11017     luaL_getmetatable(tolua_S, "std::pair<std::vector<unsigned short>::iterator, std::vector<unsigned short>::iterator>");
11018     lua_pushstring(tolua_S, "__gc");
11019     lua_pushcfunction(tolua_S, tolua_lmeshio_std__vector_unsigned_short__iterator_gc);
11020     lua_settable(tolua_S, -3);
11021     lua_pop(tolua_S, 1);
11022     tolua_function(tolua_S,"foreachi",tolua_lmeshio_std__vector_unsigned_short__iterator);
11023    tolua_endmodule(tolua_S);
11024    #ifdef __cplusplus
11025    tolua_cclass(tolua_S,"vector_unsigned_int_","std::vector<unsigned int>","",tolua_collect_std__vector_unsigned_int_);
11026    #else
11027    tolua_cclass(tolua_S,"vector_unsigned_int_","std::vector<unsigned int>","",NULL);
11028    #endif
11029    tolua_beginmodule(tolua_S,"vector_unsigned_int_");
11030     tolua_function(tolua_S,"new",tolua_lmeshio_std_vector_unsigned_int__new00);
11031     tolua_function(tolua_S,"new_local",tolua_lmeshio_std_vector_unsigned_int__new00_local);
11032     tolua_function(tolua_S,".call",tolua_lmeshio_std_vector_unsigned_int__new00_local);
11033     tolua_function(tolua_S,"size",tolua_lmeshio_std_vector_unsigned_int__size00);
11034     tolua_function(tolua_S,"push_back",tolua_lmeshio_std_vector_unsigned_int__push_back00);
11035     tolua_function(tolua_S,"back",tolua_lmeshio_std_vector_unsigned_int__back00);
11036     tolua_function(tolua_S,".geti",tolua_lmeshio_std_vector_unsigned_int___geti00);
11037     tolua_function(tolua_S,".seti",tolua_lmeshio_std_vector_unsigned_int___seti00);
11038     luaL_getmetatable(tolua_S, "std::pair<std::vector<unsigned int>::iterator, std::vector<unsigned int>::iterator>");
11039     lua_pushstring(tolua_S, "__gc");
11040     lua_pushcfunction(tolua_S, tolua_lmeshio_std__vector_unsigned_int__iterator_gc);
11041     lua_settable(tolua_S, -3);
11042     lua_pop(tolua_S, 1);
11043     tolua_function(tolua_S,"foreachi",tolua_lmeshio_std__vector_unsigned_int__iterator);
11044    tolua_endmodule(tolua_S);
11045    #ifdef __cplusplus
11046    tolua_cclass(tolua_S,"vector_meshio__Vector3_","std::vector<meshio::Vector3>","",tolua_collect_std__vector_meshio__Vector3_);
11047    #else
11048    tolua_cclass(tolua_S,"vector_meshio__Vector3_","std::vector<meshio::Vector3>","",NULL);
11049    #endif
11050    tolua_beginmodule(tolua_S,"vector_meshio__Vector3_");
11051     tolua_function(tolua_S,"new",tolua_lmeshio_std_vector_meshio__Vector3__new00);
11052     tolua_function(tolua_S,"new_local",tolua_lmeshio_std_vector_meshio__Vector3__new00_local);
11053     tolua_function(tolua_S,".call",tolua_lmeshio_std_vector_meshio__Vector3__new00_local);
11054     tolua_function(tolua_S,"size",tolua_lmeshio_std_vector_meshio__Vector3__size00);
11055     tolua_function(tolua_S,"push_back",tolua_lmeshio_std_vector_meshio__Vector3__push_back00);
11056     tolua_function(tolua_S,"back",tolua_lmeshio_std_vector_meshio__Vector3__back00);
11057     tolua_function(tolua_S,".geti",tolua_lmeshio_std_vector_meshio__Vector3___geti00);
11058     tolua_function(tolua_S,".seti",tolua_lmeshio_std_vector_meshio__Vector3___seti00);
11059     luaL_getmetatable(tolua_S, "std::pair<std::vector<meshio::Vector3>::iterator, std::vector<meshio::Vector3>::iterator>");
11060     lua_pushstring(tolua_S, "__gc");
11061     lua_pushcfunction(tolua_S, tolua_lmeshio_std__vector_meshio__Vector3__iterator_gc);
11062     lua_settable(tolua_S, -3);
11063     lua_pop(tolua_S, 1);
11064     tolua_function(tolua_S,"foreachi",tolua_lmeshio_std__vector_meshio__Vector3__iterator);
11065    tolua_endmodule(tolua_S);
11066    #ifdef __cplusplus
11067    tolua_cclass(tolua_S,"vector_meshio__pmd__Vertex_","std::vector<meshio::pmd::Vertex>","",tolua_collect_std__vector_meshio__pmd__Vertex_);
11068    #else
11069    tolua_cclass(tolua_S,"vector_meshio__pmd__Vertex_","std::vector<meshio::pmd::Vertex>","",NULL);
11070    #endif
11071    tolua_beginmodule(tolua_S,"vector_meshio__pmd__Vertex_");
11072     tolua_function(tolua_S,"new",tolua_lmeshio_std_vector_meshio__pmd__Vertex__new00);
11073     tolua_function(tolua_S,"new_local",tolua_lmeshio_std_vector_meshio__pmd__Vertex__new00_local);
11074     tolua_function(tolua_S,".call",tolua_lmeshio_std_vector_meshio__pmd__Vertex__new00_local);
11075     tolua_function(tolua_S,"size",tolua_lmeshio_std_vector_meshio__pmd__Vertex__size00);
11076     tolua_function(tolua_S,"push_back",tolua_lmeshio_std_vector_meshio__pmd__Vertex__push_back00);
11077     tolua_function(tolua_S,"back",tolua_lmeshio_std_vector_meshio__pmd__Vertex__back00);
11078     tolua_function(tolua_S,".geti",tolua_lmeshio_std_vector_meshio__pmd__Vertex___geti00);
11079     tolua_function(tolua_S,".seti",tolua_lmeshio_std_vector_meshio__pmd__Vertex___seti00);
11080     luaL_getmetatable(tolua_S, "std::pair<std::vector<meshio::pmd::Vertex>::iterator, std::vector<meshio::pmd::Vertex>::iterator>");
11081     lua_pushstring(tolua_S, "__gc");
11082     lua_pushcfunction(tolua_S, tolua_lmeshio_std__vector_meshio__pmd__Vertex__iterator_gc);
11083     lua_settable(tolua_S, -3);
11084     lua_pop(tolua_S, 1);
11085     tolua_function(tolua_S,"foreachi",tolua_lmeshio_std__vector_meshio__pmd__Vertex__iterator);
11086    tolua_endmodule(tolua_S);
11087    #ifdef __cplusplus
11088    tolua_cclass(tolua_S,"vector_meshio__pmd__Material_","std::vector<meshio::pmd::Material>","",tolua_collect_std__vector_meshio__pmd__Material_);
11089    #else
11090    tolua_cclass(tolua_S,"vector_meshio__pmd__Material_","std::vector<meshio::pmd::Material>","",NULL);
11091    #endif
11092    tolua_beginmodule(tolua_S,"vector_meshio__pmd__Material_");
11093     tolua_function(tolua_S,"new",tolua_lmeshio_std_vector_meshio__pmd__Material__new00);
11094     tolua_function(tolua_S,"new_local",tolua_lmeshio_std_vector_meshio__pmd__Material__new00_local);
11095     tolua_function(tolua_S,".call",tolua_lmeshio_std_vector_meshio__pmd__Material__new00_local);
11096     tolua_function(tolua_S,"size",tolua_lmeshio_std_vector_meshio__pmd__Material__size00);
11097     tolua_function(tolua_S,"push_back",tolua_lmeshio_std_vector_meshio__pmd__Material__push_back00);
11098     tolua_function(tolua_S,"back",tolua_lmeshio_std_vector_meshio__pmd__Material__back00);
11099     tolua_function(tolua_S,".geti",tolua_lmeshio_std_vector_meshio__pmd__Material___geti00);
11100     tolua_function(tolua_S,".seti",tolua_lmeshio_std_vector_meshio__pmd__Material___seti00);
11101     luaL_getmetatable(tolua_S, "std::pair<std::vector<meshio::pmd::Material>::iterator, std::vector<meshio::pmd::Material>::iterator>");
11102     lua_pushstring(tolua_S, "__gc");
11103     lua_pushcfunction(tolua_S, tolua_lmeshio_std__vector_meshio__pmd__Material__iterator_gc);
11104     lua_settable(tolua_S, -3);
11105     lua_pop(tolua_S, 1);
11106     tolua_function(tolua_S,"foreachi",tolua_lmeshio_std__vector_meshio__pmd__Material__iterator);
11107    tolua_endmodule(tolua_S);
11108    #ifdef __cplusplus
11109    tolua_cclass(tolua_S,"vector_meshio__pmd__Bone_","std::vector<meshio::pmd::Bone>","",tolua_collect_std__vector_meshio__pmd__Bone_);
11110    #else
11111    tolua_cclass(tolua_S,"vector_meshio__pmd__Bone_","std::vector<meshio::pmd::Bone>","",NULL);
11112    #endif
11113    tolua_beginmodule(tolua_S,"vector_meshio__pmd__Bone_");
11114     tolua_function(tolua_S,"new",tolua_lmeshio_std_vector_meshio__pmd__Bone__new00);
11115     tolua_function(tolua_S,"new_local",tolua_lmeshio_std_vector_meshio__pmd__Bone__new00_local);
11116     tolua_function(tolua_S,".call",tolua_lmeshio_std_vector_meshio__pmd__Bone__new00_local);
11117     tolua_function(tolua_S,"size",tolua_lmeshio_std_vector_meshio__pmd__Bone__size00);
11118     tolua_function(tolua_S,"push_back",tolua_lmeshio_std_vector_meshio__pmd__Bone__push_back00);
11119     tolua_function(tolua_S,"back",tolua_lmeshio_std_vector_meshio__pmd__Bone__back00);
11120     tolua_function(tolua_S,".geti",tolua_lmeshio_std_vector_meshio__pmd__Bone___geti00);
11121     tolua_function(tolua_S,".seti",tolua_lmeshio_std_vector_meshio__pmd__Bone___seti00);
11122     luaL_getmetatable(tolua_S, "std::pair<std::vector<meshio::pmd::Bone>::iterator, std::vector<meshio::pmd::Bone>::iterator>");
11123     lua_pushstring(tolua_S, "__gc");
11124     lua_pushcfunction(tolua_S, tolua_lmeshio_std__vector_meshio__pmd__Bone__iterator_gc);
11125     lua_settable(tolua_S, -3);
11126     lua_pop(tolua_S, 1);
11127     tolua_function(tolua_S,"foreachi",tolua_lmeshio_std__vector_meshio__pmd__Bone__iterator);
11128    tolua_endmodule(tolua_S);
11129    #ifdef __cplusplus
11130    tolua_cclass(tolua_S,"vector_meshio__pmd__IK_","std::vector<meshio::pmd::IK>","",tolua_collect_std__vector_meshio__pmd__IK_);
11131    #else
11132    tolua_cclass(tolua_S,"vector_meshio__pmd__IK_","std::vector<meshio::pmd::IK>","",NULL);
11133    #endif
11134    tolua_beginmodule(tolua_S,"vector_meshio__pmd__IK_");
11135     tolua_function(tolua_S,"new",tolua_lmeshio_std_vector_meshio__pmd__IK__new00);
11136     tolua_function(tolua_S,"new_local",tolua_lmeshio_std_vector_meshio__pmd__IK__new00_local);
11137     tolua_function(tolua_S,".call",tolua_lmeshio_std_vector_meshio__pmd__IK__new00_local);
11138     tolua_function(tolua_S,"size",tolua_lmeshio_std_vector_meshio__pmd__IK__size00);
11139     tolua_function(tolua_S,"push_back",tolua_lmeshio_std_vector_meshio__pmd__IK__push_back00);
11140     tolua_function(tolua_S,"back",tolua_lmeshio_std_vector_meshio__pmd__IK__back00);
11141     tolua_function(tolua_S,".geti",tolua_lmeshio_std_vector_meshio__pmd__IK___geti00);
11142     tolua_function(tolua_S,".seti",tolua_lmeshio_std_vector_meshio__pmd__IK___seti00);
11143     luaL_getmetatable(tolua_S, "std::pair<std::vector<meshio::pmd::IK>::iterator, std::vector<meshio::pmd::IK>::iterator>");
11144     lua_pushstring(tolua_S, "__gc");
11145     lua_pushcfunction(tolua_S, tolua_lmeshio_std__vector_meshio__pmd__IK__iterator_gc);
11146     lua_settable(tolua_S, -3);
11147     lua_pop(tolua_S, 1);
11148     tolua_function(tolua_S,"foreachi",tolua_lmeshio_std__vector_meshio__pmd__IK__iterator);
11149    tolua_endmodule(tolua_S);
11150    #ifdef __cplusplus
11151    tolua_cclass(tolua_S,"vector_meshio__pmd__Morph_","std::vector<meshio::pmd::Morph>","",tolua_collect_std__vector_meshio__pmd__Morph_);
11152    #else
11153    tolua_cclass(tolua_S,"vector_meshio__pmd__Morph_","std::vector<meshio::pmd::Morph>","",NULL);
11154    #endif
11155    tolua_beginmodule(tolua_S,"vector_meshio__pmd__Morph_");
11156     tolua_function(tolua_S,"new",tolua_lmeshio_std_vector_meshio__pmd__Morph__new00);
11157     tolua_function(tolua_S,"new_local",tolua_lmeshio_std_vector_meshio__pmd__Morph__new00_local);
11158     tolua_function(tolua_S,".call",tolua_lmeshio_std_vector_meshio__pmd__Morph__new00_local);
11159     tolua_function(tolua_S,"size",tolua_lmeshio_std_vector_meshio__pmd__Morph__size00);
11160     tolua_function(tolua_S,"push_back",tolua_lmeshio_std_vector_meshio__pmd__Morph__push_back00);
11161     tolua_function(tolua_S,"back",tolua_lmeshio_std_vector_meshio__pmd__Morph__back00);
11162     tolua_function(tolua_S,".geti",tolua_lmeshio_std_vector_meshio__pmd__Morph___geti00);
11163     tolua_function(tolua_S,".seti",tolua_lmeshio_std_vector_meshio__pmd__Morph___seti00);
11164     luaL_getmetatable(tolua_S, "std::pair<std::vector<meshio::pmd::Morph>::iterator, std::vector<meshio::pmd::Morph>::iterator>");
11165     lua_pushstring(tolua_S, "__gc");
11166     lua_pushcfunction(tolua_S, tolua_lmeshio_std__vector_meshio__pmd__Morph__iterator_gc);
11167     lua_settable(tolua_S, -3);
11168     lua_pop(tolua_S, 1);
11169     tolua_function(tolua_S,"foreachi",tolua_lmeshio_std__vector_meshio__pmd__Morph__iterator);
11170    tolua_endmodule(tolua_S);
11171    #ifdef __cplusplus
11172    tolua_cclass(tolua_S,"vector_meshio__pmd__BoneGroup_","std::vector<meshio::pmd::BoneGroup>","",tolua_collect_std__vector_meshio__pmd__BoneGroup_);
11173    #else
11174    tolua_cclass(tolua_S,"vector_meshio__pmd__BoneGroup_","std::vector<meshio::pmd::BoneGroup>","",NULL);
11175    #endif
11176    tolua_beginmodule(tolua_S,"vector_meshio__pmd__BoneGroup_");
11177     tolua_function(tolua_S,"new",tolua_lmeshio_std_vector_meshio__pmd__BoneGroup__new00);
11178     tolua_function(tolua_S,"new_local",tolua_lmeshio_std_vector_meshio__pmd__BoneGroup__new00_local);
11179     tolua_function(tolua_S,".call",tolua_lmeshio_std_vector_meshio__pmd__BoneGroup__new00_local);
11180     tolua_function(tolua_S,"size",tolua_lmeshio_std_vector_meshio__pmd__BoneGroup__size00);
11181     tolua_function(tolua_S,"push_back",tolua_lmeshio_std_vector_meshio__pmd__BoneGroup__push_back00);
11182     tolua_function(tolua_S,"back",tolua_lmeshio_std_vector_meshio__pmd__BoneGroup__back00);
11183     tolua_function(tolua_S,".geti",tolua_lmeshio_std_vector_meshio__pmd__BoneGroup___geti00);
11184     tolua_function(tolua_S,".seti",tolua_lmeshio_std_vector_meshio__pmd__BoneGroup___seti00);
11185     luaL_getmetatable(tolua_S, "std::pair<std::vector<meshio::pmd::BoneGroup>::iterator, std::vector<meshio::pmd::BoneGroup>::iterator>");
11186     lua_pushstring(tolua_S, "__gc");
11187     lua_pushcfunction(tolua_S, tolua_lmeshio_std__vector_meshio__pmd__BoneGroup__iterator_gc);
11188     lua_settable(tolua_S, -3);
11189     lua_pop(tolua_S, 1);
11190     tolua_function(tolua_S,"foreachi",tolua_lmeshio_std__vector_meshio__pmd__BoneGroup__iterator);
11191    tolua_endmodule(tolua_S);
11192    #ifdef __cplusplus
11193    tolua_cclass(tolua_S,"vector_std__pair_unsigned_short_unsigned_char___","std::vector<std::pair<unsigned short,unsigned char> >","",tolua_collect_std__vector_std__pair_unsigned_short_unsigned_char___);
11194    #else
11195    tolua_cclass(tolua_S,"vector_std__pair_unsigned_short_unsigned_char___","std::vector<std::pair<unsigned short,unsigned char> >","",NULL);
11196    #endif
11197    tolua_beginmodule(tolua_S,"vector_std__pair_unsigned_short_unsigned_char___");
11198     tolua_function(tolua_S,"new",tolua_lmeshio_std_vector_std__pair_unsigned_short_unsigned_char____new00);
11199     tolua_function(tolua_S,"new_local",tolua_lmeshio_std_vector_std__pair_unsigned_short_unsigned_char____new00_local);
11200     tolua_function(tolua_S,".call",tolua_lmeshio_std_vector_std__pair_unsigned_short_unsigned_char____new00_local);
11201     tolua_function(tolua_S,"size",tolua_lmeshio_std_vector_std__pair_unsigned_short_unsigned_char____size00);
11202     tolua_function(tolua_S,"push_back",tolua_lmeshio_std_vector_std__pair_unsigned_short_unsigned_char____push_back00);
11203     tolua_function(tolua_S,"back",tolua_lmeshio_std_vector_std__pair_unsigned_short_unsigned_char____back00);
11204     tolua_function(tolua_S,".geti",tolua_lmeshio_std_vector_std__pair_unsigned_short_unsigned_char_____geti00);
11205     tolua_function(tolua_S,".seti",tolua_lmeshio_std_vector_std__pair_unsigned_short_unsigned_char_____seti00);
11206     luaL_getmetatable(tolua_S, "std::pair<std::vector<std::pair<unsigned short,unsigned char> >::iterator, std::vector<std::pair<unsigned short,unsigned char> >::iterator>");
11207     lua_pushstring(tolua_S, "__gc");
11208     lua_pushcfunction(tolua_S, tolua_lmeshio_std__vector_std__pair_unsigned_short_unsigned_char____iterator_gc);
11209     lua_settable(tolua_S, -3);
11210     lua_pop(tolua_S, 1);
11211     tolua_function(tolua_S,"foreachi",tolua_lmeshio_std__vector_std__pair_unsigned_short_unsigned_char____iterator);
11212    tolua_endmodule(tolua_S);
11213    #ifdef __cplusplus
11214    tolua_cclass(tolua_S,"vector_meshio__pmd__RigidBody_","std::vector<meshio::pmd::RigidBody>","",tolua_collect_std__vector_meshio__pmd__RigidBody_);
11215    #else
11216    tolua_cclass(tolua_S,"vector_meshio__pmd__RigidBody_","std::vector<meshio::pmd::RigidBody>","",NULL);
11217    #endif
11218    tolua_beginmodule(tolua_S,"vector_meshio__pmd__RigidBody_");
11219     tolua_function(tolua_S,"new",tolua_lmeshio_std_vector_meshio__pmd__RigidBody__new00);
11220     tolua_function(tolua_S,"new_local",tolua_lmeshio_std_vector_meshio__pmd__RigidBody__new00_local);
11221     tolua_function(tolua_S,".call",tolua_lmeshio_std_vector_meshio__pmd__RigidBody__new00_local);
11222     tolua_function(tolua_S,"size",tolua_lmeshio_std_vector_meshio__pmd__RigidBody__size00);
11223     tolua_function(tolua_S,"push_back",tolua_lmeshio_std_vector_meshio__pmd__RigidBody__push_back00);
11224     tolua_function(tolua_S,"back",tolua_lmeshio_std_vector_meshio__pmd__RigidBody__back00);
11225     tolua_function(tolua_S,".geti",tolua_lmeshio_std_vector_meshio__pmd__RigidBody___geti00);
11226     tolua_function(tolua_S,".seti",tolua_lmeshio_std_vector_meshio__pmd__RigidBody___seti00);
11227     luaL_getmetatable(tolua_S, "std::pair<std::vector<meshio::pmd::RigidBody>::iterator, std::vector<meshio::pmd::RigidBody>::iterator>");
11228     lua_pushstring(tolua_S, "__gc");
11229     lua_pushcfunction(tolua_S, tolua_lmeshio_std__vector_meshio__pmd__RigidBody__iterator_gc);
11230     lua_settable(tolua_S, -3);
11231     lua_pop(tolua_S, 1);
11232     tolua_function(tolua_S,"foreachi",tolua_lmeshio_std__vector_meshio__pmd__RigidBody__iterator);
11233    tolua_endmodule(tolua_S);
11234    #ifdef __cplusplus
11235    tolua_cclass(tolua_S,"vector_meshio__pmd__Constraint_","std::vector<meshio::pmd::Constraint>","",tolua_collect_std__vector_meshio__pmd__Constraint_);
11236    #else
11237    tolua_cclass(tolua_S,"vector_meshio__pmd__Constraint_","std::vector<meshio::pmd::Constraint>","",NULL);
11238    #endif
11239    tolua_beginmodule(tolua_S,"vector_meshio__pmd__Constraint_");
11240     tolua_function(tolua_S,"new",tolua_lmeshio_std_vector_meshio__pmd__Constraint__new00);
11241     tolua_function(tolua_S,"new_local",tolua_lmeshio_std_vector_meshio__pmd__Constraint__new00_local);
11242     tolua_function(tolua_S,".call",tolua_lmeshio_std_vector_meshio__pmd__Constraint__new00_local);
11243     tolua_function(tolua_S,"size",tolua_lmeshio_std_vector_meshio__pmd__Constraint__size00);
11244     tolua_function(tolua_S,"push_back",tolua_lmeshio_std_vector_meshio__pmd__Constraint__push_back00);
11245     tolua_function(tolua_S,"back",tolua_lmeshio_std_vector_meshio__pmd__Constraint__back00);
11246     tolua_function(tolua_S,".geti",tolua_lmeshio_std_vector_meshio__pmd__Constraint___geti00);
11247     tolua_function(tolua_S,".seti",tolua_lmeshio_std_vector_meshio__pmd__Constraint___seti00);
11248     luaL_getmetatable(tolua_S, "std::pair<std::vector<meshio::pmd::Constraint>::iterator, std::vector<meshio::pmd::Constraint>::iterator>");
11249     lua_pushstring(tolua_S, "__gc");
11250     lua_pushcfunction(tolua_S, tolua_lmeshio_std__vector_meshio__pmd__Constraint__iterator_gc);
11251     lua_settable(tolua_S, -3);
11252     lua_pop(tolua_S, 1);
11253     tolua_function(tolua_S,"foreachi",tolua_lmeshio_std__vector_meshio__pmd__Constraint__iterator);
11254    tolua_endmodule(tolua_S);
11255    #ifdef __cplusplus
11256    tolua_cclass(tolua_S,"vector_meshio__mqo__Face_","std::vector<meshio::mqo::Face>","",tolua_collect_std__vector_meshio__mqo__Face_);
11257    #else
11258    tolua_cclass(tolua_S,"vector_meshio__mqo__Face_","std::vector<meshio::mqo::Face>","",NULL);
11259    #endif
11260    tolua_beginmodule(tolua_S,"vector_meshio__mqo__Face_");
11261     tolua_function(tolua_S,"new",tolua_lmeshio_std_vector_meshio__mqo__Face__new00);
11262     tolua_function(tolua_S,"new_local",tolua_lmeshio_std_vector_meshio__mqo__Face__new00_local);
11263     tolua_function(tolua_S,".call",tolua_lmeshio_std_vector_meshio__mqo__Face__new00_local);
11264     tolua_function(tolua_S,"size",tolua_lmeshio_std_vector_meshio__mqo__Face__size00);
11265     tolua_function(tolua_S,"push_back",tolua_lmeshio_std_vector_meshio__mqo__Face__push_back00);
11266     tolua_function(tolua_S,"back",tolua_lmeshio_std_vector_meshio__mqo__Face__back00);
11267     tolua_function(tolua_S,".geti",tolua_lmeshio_std_vector_meshio__mqo__Face___geti00);
11268     tolua_function(tolua_S,".seti",tolua_lmeshio_std_vector_meshio__mqo__Face___seti00);
11269     luaL_getmetatable(tolua_S, "std::pair<std::vector<meshio::mqo::Face>::iterator, std::vector<meshio::mqo::Face>::iterator>");
11270     lua_pushstring(tolua_S, "__gc");
11271     lua_pushcfunction(tolua_S, tolua_lmeshio_std__vector_meshio__mqo__Face__iterator_gc);
11272     lua_settable(tolua_S, -3);
11273     lua_pop(tolua_S, 1);
11274     tolua_function(tolua_S,"foreachi",tolua_lmeshio_std__vector_meshio__mqo__Face__iterator);
11275    tolua_endmodule(tolua_S);
11276    #ifdef __cplusplus
11277    tolua_cclass(tolua_S,"vector_meshio__mqo__Material_","std::vector<meshio::mqo::Material>","",tolua_collect_std__vector_meshio__mqo__Material_);
11278    #else
11279    tolua_cclass(tolua_S,"vector_meshio__mqo__Material_","std::vector<meshio::mqo::Material>","",NULL);
11280    #endif
11281    tolua_beginmodule(tolua_S,"vector_meshio__mqo__Material_");
11282     tolua_function(tolua_S,"new",tolua_lmeshio_std_vector_meshio__mqo__Material__new00);
11283     tolua_function(tolua_S,"new_local",tolua_lmeshio_std_vector_meshio__mqo__Material__new00_local);
11284     tolua_function(tolua_S,".call",tolua_lmeshio_std_vector_meshio__mqo__Material__new00_local);
11285     tolua_function(tolua_S,"size",tolua_lmeshio_std_vector_meshio__mqo__Material__size00);
11286     tolua_function(tolua_S,"push_back",tolua_lmeshio_std_vector_meshio__mqo__Material__push_back00);
11287     tolua_function(tolua_S,"back",tolua_lmeshio_std_vector_meshio__mqo__Material__back00);
11288     tolua_function(tolua_S,".geti",tolua_lmeshio_std_vector_meshio__mqo__Material___geti00);
11289     tolua_function(tolua_S,".seti",tolua_lmeshio_std_vector_meshio__mqo__Material___seti00);
11290     luaL_getmetatable(tolua_S, "std::pair<std::vector<meshio::mqo::Material>::iterator, std::vector<meshio::mqo::Material>::iterator>");
11291     lua_pushstring(tolua_S, "__gc");
11292     lua_pushcfunction(tolua_S, tolua_lmeshio_std__vector_meshio__mqo__Material__iterator_gc);
11293     lua_settable(tolua_S, -3);
11294     lua_pop(tolua_S, 1);
11295     tolua_function(tolua_S,"foreachi",tolua_lmeshio_std__vector_meshio__mqo__Material__iterator);
11296    tolua_endmodule(tolua_S);
11297    #ifdef __cplusplus
11298    tolua_cclass(tolua_S,"vector_meshio__mqo__Object_","std::vector<meshio::mqo::Object>","",tolua_collect_std__vector_meshio__mqo__Object_);
11299    #else
11300    tolua_cclass(tolua_S,"vector_meshio__mqo__Object_","std::vector<meshio::mqo::Object>","",NULL);
11301    #endif
11302    tolua_beginmodule(tolua_S,"vector_meshio__mqo__Object_");
11303     tolua_function(tolua_S,"new",tolua_lmeshio_std_vector_meshio__mqo__Object__new00);
11304     tolua_function(tolua_S,"new_local",tolua_lmeshio_std_vector_meshio__mqo__Object__new00_local);
11305     tolua_function(tolua_S,".call",tolua_lmeshio_std_vector_meshio__mqo__Object__new00_local);
11306     tolua_function(tolua_S,"size",tolua_lmeshio_std_vector_meshio__mqo__Object__size00);
11307     tolua_function(tolua_S,"push_back",tolua_lmeshio_std_vector_meshio__mqo__Object__push_back00);
11308     tolua_function(tolua_S,"back",tolua_lmeshio_std_vector_meshio__mqo__Object__back00);
11309     tolua_function(tolua_S,".geti",tolua_lmeshio_std_vector_meshio__mqo__Object___geti00);
11310     tolua_function(tolua_S,".seti",tolua_lmeshio_std_vector_meshio__mqo__Object___seti00);
11311     luaL_getmetatable(tolua_S, "std::pair<std::vector<meshio::mqo::Object>::iterator, std::vector<meshio::mqo::Object>::iterator>");
11312     lua_pushstring(tolua_S, "__gc");
11313     lua_pushcfunction(tolua_S, tolua_lmeshio_std__vector_meshio__mqo__Object__iterator_gc);
11314     lua_settable(tolua_S, -3);
11315     lua_pop(tolua_S, 1);
11316     tolua_function(tolua_S,"foreachi",tolua_lmeshio_std__vector_meshio__mqo__Object__iterator);
11317    tolua_endmodule(tolua_S);
11318    #ifdef __cplusplus
11319    tolua_cclass(tolua_S,"pair_unsigned_short_unsigned_char_","std::pair<unsigned short,unsigned char>","",tolua_collect_std__pair_unsigned_short_unsigned_char_);
11320    #else
11321    tolua_cclass(tolua_S,"pair_unsigned_short_unsigned_char_","std::pair<unsigned short,unsigned char>","",NULL);
11322    #endif
11323    tolua_beginmodule(tolua_S,"pair_unsigned_short_unsigned_char_");
11324     tolua_variable(tolua_S,"first",tolua_get_std__pair_unsigned_short_unsigned_char__unsigned_first,tolua_set_std__pair_unsigned_short_unsigned_char__unsigned_first);
11325     tolua_variable(tolua_S,"second",tolua_get_std__pair_unsigned_short_unsigned_char__unsigned_second,tolua_set_std__pair_unsigned_short_unsigned_char__unsigned_second);
11326    tolua_endmodule(tolua_S);
11327   tolua_endmodule(tolua_S);
11328  tolua_endmodule(tolua_S);
11329  return 1;
11330 }
11331
11332 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
11333 #ifdef __cplusplus
11334 extern "C" {
11335 #endif
11336
11337  TOLUA_API int luaopen_lmeshio (lua_State* tolua_S) {
11338  return tolua_lmeshio_open(tolua_S);
11339 };
11340
11341 #ifdef __cplusplus
11342 }
11343 #endif
11344 #endif
11345