OSDN -- Open-Source-Software-Entwicklung und Downloads
Übersetzungsstatus von Deutsch translation status for de
  • R/O
  • HTTP
  • SSH
  • HTTPS
Fork

meshio: Commit

3D model(pmd, mqo...) IO library using C++.


Commit MetaInfo

Revision82eccb9e28d2c908fcdb60b07c3428db21b7a28b (tree)
Zeit2011-05-01 11:12:54
Autorousttrue <ousttrue@gmai...>
Commiterousttrue

Log Message

add luabinding

Ändern Zusammenfassung

Diff

--- /dev/null
+++ b/lua/lmeshio.pkg
@@ -0,0 +1,390 @@
1+$#include "pmd.h"
2+$#include "vmd.h"
3+$#include "mqo.h"
4+$#include "la.h"
5+$#include "color.h"
6+
7+$using namespace meshio;
8+
9+namespace meshio {
10+
11+ namespace pmd {
12+
13+ struct Vertex
14+ {
15+ //! 座標
16+ Vector3 pos;
17+ //! 法線ベクトル
18+ Vector3 normal;
19+ //! テクスチャUV
20+ Vector2 uv;
21+ //! ブレンディングボーン1
22+ unsigned short bone0;
23+ //! ブレンディングボーン2
24+ unsigned short bone1;
25+ //! ウェイト[0 - 100]
26+ unsigned char weight0;
27+ //! 非エッジ
28+ unsigned char edge_flag;
29+ };
30+
31+ struct Material
32+ {
33+ //! Diffuse
34+ fRGBA diffuse;
35+ //! Shinness
36+ float shinness;
37+ //! Specular
38+ fRGB specular;
39+ //! Ambient
40+ fRGB ambient;
41+ //! トゥーンテクスチャ
42+ unsigned char toon_index;
43+ //! 輪郭/影
44+ unsigned char flag;
45+ //! 面頂点数
46+ unsigned int vertex_count;
47+ //! テクスチャ
48+ fixed_string<20> texture;
49+ };
50+
51+ //! ボーンの種類
52+ enum BONE_TYPE
53+ {
54+ // 回転
55+ BONE_ROTATE=0,
56+ // 回転と移動
57+ BONE_ROTATE_MOVE,
58+ // IK
59+ BONE_IK,
60+ // 不明
61+ BONE_UNKNOWN,
62+ // IK影響下
63+ BONE_IK_INFLUENCED,
64+ // 回転影響下
65+ BONE_ROTATE_INFLUENCED,
66+ // IK接続先
67+ BONE_IK_CONNECT,
68+ // 非表示
69+ BONE_INVISIBLE,
70+ // 捻り
71+ BONE_TWIST,
72+ // 回転連動
73+ BONE_REVOLVE,
74+ };
75+
76+ struct Bone
77+ {
78+ //! 名前
79+ fixed_string<20> name;
80+ //! 親ボーン
81+ unsigned short parent_index;
82+ //! 子ボーン
83+ unsigned short tail_index;
84+ //! ボーン種類
85+ BONE_TYPE type;
86+ //! 影響IKボーン
87+ unsigned short ik_index;
88+ // ボーン座標
89+ Vector3 pos;
90+ //! 英語名
91+ fixed_string<20> english_name;
92+ //! ボーン階層構築用
93+ Bone* parent;
94+ Vector3 tail;
95+ std::vector<Bone*> children;
96+ unsigned short index;
97+
98+ Bone();
99+ };
100+
101+ struct IK
102+ {
103+ //! IK(IKターゲット)
104+ unsigned short index;
105+ //! Target(エフェクター)
106+ unsigned short target;
107+ //! エフェクタに連動するボーン数
108+ unsigned char length;
109+ //! IK値1。CCD-IK試行回数
110+ unsigned short iterations;
111+ //! IK値2。CCD-IK試行一回辺りの影響度
112+ float weight;
113+ //! エフェクタに連動するボーン(基本的に親ボーンに遡る)
114+ std::vector<unsigned short> children;
115+ };
116+
117+ //! 表情の種類
118+ enum MORPH_TYPE
119+ {
120+ //! ベース表情
121+ MORPH_BASE=0,
122+ //! まゆ
123+ MORPH_MAYU,
124+ //! 目
125+ MORPH_ME,
126+ //! リップ
127+ MORPH_LIP,
128+ //! その他
129+ MORPH_OTHER,
130+ };
131+ struct Morph
132+ {
133+ //! 表情名
134+ fixed_string<20> name;
135+ //! 使用する頂点数
136+ unsigned int vertex_count;
137+ //! 分類
138+ unsigned char type;
139+ //! 頂点Index
140+ std::vector<unsigned int> indices;
141+ //! 移動量
142+ std::vector<Vector3> pos_list;
143+ //! 英語名
144+ fixed_string<20> english_name;
145+ };
146+
147+ struct BoneGroup
148+ {
149+ fixed_string<50> name;
150+ fixed_string<50> english_name;
151+ };
152+
153+ //! 形状
154+ enum SHAPE_TYPE
155+ {
156+ //! 球
157+ SHAPE_SPHERE=0,
158+ //! 箱
159+ SHAPE_BOX,
160+ //! カプセル
161+ SHAPE_CAPSULE,
162+ };
163+
164+ //! 剛体タイプ
165+ enum PROCESS_TYPE
166+ {
167+ //! ボーンと同じ動き
168+ RIGIDBODY_KINEMATICS=0,
169+ //! 物理演算
170+ RIGIDBODY_PHYSICS,
171+ //! 物理演算結果をボーンに反映する
172+ RIGIDBODY_PHYSICS_WITH_BONE,
173+ };
174+
175+ struct RigidBody
176+ {
177+ //! 剛体名
178+ fixed_string<20> name;
179+ //! 関連ボーン(ボーン追従とボーン位置合わせで必要)
180+ unsigned short boneIndex;
181+ //! グループ
182+ unsigned char group;
183+ //! 非衝突グループ
184+ unsigned short target;
185+ //! 形状
186+ SHAPE_TYPE shapeType;
187+ //! サイズ
188+ float w;
189+ float h;
190+ float d;
191+ //! 姿勢
192+ Vector3 position;
193+ Vector3 rotation;
194+ //! 質量
195+ float weight;
196+ //! 物理演算パラメータ(bullet)
197+ float linearDamping;
198+ float angularDamping;
199+ float restitution;
200+ float friction;
201+ //! 剛体タイプ
202+ PROCESS_TYPE processType;
203+ };
204+
205+ //! Joint(物理演算でのJointとConstraintは同じ意味)
206+ struct Constraint
207+ {
208+ //! Joint名
209+ fixed_string<20> name;
210+ //! 接続剛体A
211+ unsigned int rigidA;
212+ //! 接続剛体B
213+ unsigned int rigidB;
214+ //! 位置
215+ Vector3 pos;
216+ //! 回転
217+ Vector3 rot;
218+ //! 移動制限
219+ Vector3 constraintPosMin;
220+ Vector3 constraintPosMax;
221+ //! 回転制限
222+ Vector3 constraintRotMin;
223+ Vector3 constraintRotMax;
224+ //! ばね
225+ Vector3 springPos;
226+ Vector3 springRot;
227+ };
228+
229+ // IO
230+ struct IO
231+ {
232+ float version;
233+ fixed_string<20> name;
234+ fixed_string<256> comment;
235+ std::vector<Vertex> vertices;
236+ std::vector<unsigned short> indices;
237+ std::vector<Material> materials;
238+ std::vector<Bone> bones;
239+ std::vector<IK> ik_list;
240+ std::vector<Morph> morph_list;
241+ std::vector<unsigned short> face_list;
242+ std::vector<BoneGroup> bone_group_list;
243+ std::vector<std::pair<unsigned short, unsigned char> > bone_display_list;
244+ std::array<fixed_string<100>, 10> toon_textures;
245+ std::vector<RigidBody> rigidbodies;
246+ std::vector<Constraint> constraints;
247+
248+ fixed_string<20> english_name;
249+ fixed_string<256> english_comment;
250+
251+ IO();
252+ bool read(const char *path);
253+ bool write(const char *path);
254+ };
255+
256+ typedef std::vector<Vertex> VertexVector;
257+
258+ } // namespace pmd
259+
260+
261+
262+ namespace mqo {
263+
264+ struct Scene
265+ {
266+ Vector3 pos;
267+ Vector3 lookat;
268+ float head;
269+ float pitch;
270+ int ortho;
271+ float zoom2;
272+ Vector3 ambient;
273+ };
274+
275+ struct Material
276+ {
277+ std::string name;
278+ int shader;
279+ fRGBA color;
280+ float diffuse;
281+ float ambient;
282+ float emit;
283+ float specular;
284+ float power;
285+ std::string texture;
286+ std::string alphamap;
287+ std::string bumpmap;
288+ int vcol;
289+ };
290+
291+ struct Face
292+ {
293+ unsigned int index_count;
294+ unsigned int indices[4];
295+ unsigned int material_index;
296+ Vector2 uv[4];
297+ fRGBA color[4];
298+ };
299+
300+ struct Object
301+ {
302+ std::string name;
303+ int depth;
304+ int folding;
305+ Vector3 scale;
306+ Vector3 rotation;
307+ Vector3 translation;
308+ int visible;
309+ int locking;
310+ int shading;
311+ float smoothing;
312+ Vector3 color;
313+ int color_type;
314+ int mirror;
315+
316+ std::vector<Vector3> vertices;
317+ std::vector<Face> faces;
318+ };
319+
320+ struct IO
321+ {
322+ Scene scene;
323+ std::vector<Material> materials;
324+ std::vector<Object> objects;
325+
326+ IO();
327+ bool read(const char *path);
328+ bool write(const char *path);
329+ };
330+
331+ }
332+
333+ struct Vector2
334+ {
335+ float x;
336+ float y;
337+
338+ Vector2(float _x, float _y);
339+ };
340+
341+ struct Vector3
342+ {
343+ float x;
344+ float y;
345+ float z;
346+
347+ Vector3(float _x, float _y, float _z);
348+ bool operator==(const Vector3 &rhs)const;
349+ Vector3 operator+(const Vector3 &rhs);
350+ Vector3 operator-(const Vector3 &rhs);
351+ };
352+
353+ struct Vector4
354+ {
355+ float x;
356+ float y;
357+ float z;
358+ float w;
359+
360+ Vector4(float _x, float _y, float _z, float _w);
361+ };
362+
363+ struct Quaternion
364+ {
365+ float x;
366+ float y;
367+ float z;
368+ float w;
369+
370+ Quaternion(float _x, float _y, float _z, float _w);
371+ float dot(const Quaternion &rhs);
372+ };
373+
374+ struct fRGBA
375+ {
376+ float r;
377+ float g;
378+ float b;
379+ float a;
380+ };
381+
382+ class fixed_string
383+ {
384+ TOLUA_TEMPLATE_BIND(T, 20, 50, 100, 256);
385+ std::string str() const;
386+ void assign(const std::string &src);
387+ };
388+
389+}
390+
--- /dev/null
+++ b/lua/lmeshio_bind.cpp
@@ -0,0 +1,11345 @@
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+
--- /dev/null
+++ b/lua/lmeshio_bind.h
@@ -0,0 +1,8 @@
1+/*
2+** Lua binding: lmeshio
3+** Generated automatically by tolua++-1.0.93(lua) on Sun May 01 00:10:16 2011.
4+*/
5+
6+/* Exported function */
7+TOLUA_API int tolua_lmeshio_open(lua_State* tolua_S);
8+
--- /dev/null
+++ b/lua/lmeshio_static.make
@@ -0,0 +1,140 @@
1+# GNU Make project makefile autogenerated by Premake
2+ifndef config
3+ config=debug
4+endif
5+
6+ifndef verbose
7+ SILENT = @
8+endif
9+
10+ifndef CC
11+ CC = gcc
12+endif
13+
14+ifndef CXX
15+ CXX = g++
16+endif
17+
18+ifndef AR
19+ AR = ar
20+endif
21+
22+ifeq ($(config),debug)
23+ OBJDIR = obj/Debug
24+ TARGETDIR = ../debug
25+ TARGET = $(TARGETDIR)/liblmeshio_static.a
26+ DEFINES += -DDEBUG
27+ INCLUDES += -I../src
28+ CPPFLAGS += -MMD -MP $(DEFINES) $(INCLUDES)
29+ CFLAGS += $(CPPFLAGS) $(ARCH) -g -std=c++0x
30+ CXXFLAGS += $(CFLAGS)
31+ LDFLAGS += -L../debug
32+ LIBS += -ltolua++ -llua -lmeshio
33+ RESFLAGS += $(DEFINES) $(INCLUDES)
34+ LDDEPS +=
35+ LINKCMD = $(AR) -rcs $(TARGET) $(OBJECTS)
36+ define PREBUILDCMDS
37+ @echo Running pre-build commands
38+ make -f tolua.make
39+ endef
40+ define PRELINKCMDS
41+ endef
42+ define POSTBUILDCMDS
43+ endef
44+endif
45+
46+ifeq ($(config),release)
47+ OBJDIR = obj/Release
48+ TARGETDIR = ../release
49+ TARGET = $(TARGETDIR)/liblmeshio_static.a
50+ DEFINES += -DNDEBUG
51+ INCLUDES += -I../src
52+ CPPFLAGS += -MMD -MP $(DEFINES) $(INCLUDES)
53+ CFLAGS += $(CPPFLAGS) $(ARCH) -O2 -std=c++0x
54+ CXXFLAGS += $(CFLAGS)
55+ LDFLAGS += -s -L../release
56+ LIBS += -ltolua++ -llua -lmeshio
57+ RESFLAGS += $(DEFINES) $(INCLUDES)
58+ LDDEPS +=
59+ LINKCMD = $(AR) -rcs $(TARGET) $(OBJECTS)
60+ define PREBUILDCMDS
61+ @echo Running pre-build commands
62+ make -f tolua.make
63+ endef
64+ define PRELINKCMDS
65+ endef
66+ define POSTBUILDCMDS
67+ endef
68+endif
69+
70+OBJECTS := \
71+ $(OBJDIR)/lmeshio_bind.o \
72+ $(OBJDIR)/lmeshio.o \
73+
74+RESOURCES := \
75+
76+SHELLTYPE := msdos
77+ifeq (,$(ComSpec)$(COMSPEC))
78+ SHELLTYPE := posix
79+endif
80+ifeq (/bin,$(findstring /bin,$(SHELL)))
81+ SHELLTYPE := posix
82+endif
83+
84+.PHONY: clean prebuild prelink
85+
86+all: $(TARGETDIR) $(OBJDIR) prebuild prelink $(TARGET)
87+ @:
88+
89+$(TARGET): $(GCH) $(OBJECTS) $(LDDEPS) $(RESOURCES)
90+ @echo Linking lmeshio_static
91+ $(SILENT) $(LINKCMD)
92+ $(POSTBUILDCMDS)
93+
94+$(TARGETDIR):
95+ @echo Creating $(TARGETDIR)
96+ifeq (posix,$(SHELLTYPE))
97+ $(SILENT) mkdir -p $(TARGETDIR)
98+else
99+ $(SILENT) mkdir $(subst /,\\,$(TARGETDIR))
100+endif
101+
102+$(OBJDIR):
103+ @echo Creating $(OBJDIR)
104+ifeq (posix,$(SHELLTYPE))
105+ $(SILENT) mkdir -p $(OBJDIR)
106+else
107+ $(SILENT) mkdir $(subst /,\\,$(OBJDIR))
108+endif
109+
110+clean:
111+ @echo Cleaning lmeshio_static
112+ifeq (posix,$(SHELLTYPE))
113+ $(SILENT) rm -f $(TARGET)
114+ $(SILENT) rm -rf $(OBJDIR)
115+else
116+ $(SILENT) if exist $(subst /,\\,$(TARGET)) del $(subst /,\\,$(TARGET))
117+ $(SILENT) if exist $(subst /,\\,$(OBJDIR)) rmdir /s /q $(subst /,\\,$(OBJDIR))
118+endif
119+
120+prebuild:
121+ $(PREBUILDCMDS)
122+
123+prelink:
124+ $(PRELINKCMDS)
125+
126+ifneq (,$(PCH))
127+$(GCH): $(PCH)
128+ @echo $(notdir $<)
129+ -$(SILENT) cp $< $(OBJDIR)
130+ $(SILENT) $(CXX) $(CXXFLAGS) -o "$@" -c "$<"
131+endif
132+
133+$(OBJDIR)/lmeshio_bind.o: lmeshio_bind.cpp
134+ @echo $(notdir $<)
135+ $(SILENT) $(CXX) $(CXXFLAGS) -o "$@" -c "$<"
136+$(OBJDIR)/lmeshio.o: lmeshio.cpp
137+ @echo $(notdir $<)
138+ $(SILENT) $(CXX) $(CXXFLAGS) -o "$@" -c "$<"
139+
140+-include $(OBJECTS:%.o=%.d)
--- /dev/null
+++ b/lua/premake4.lua
@@ -0,0 +1,67 @@
1+newoption {
2+ --[[ usage: premake4 --static gmake ]]--
3+ trigger = "static",
4+ description = "build static library"
5+}
6+
7+solution "lmeshio"
8+
9+configurations { "Debug", "Release" }
10+
11+if _OPTIONS["static"] then
12+ kind "StaticLib"
13+ libdirs {
14+ }
15+ links {
16+ "tolua++", "lua",
17+ "meshio",
18+ }
19+ project "lmeshio_static"
20+else
21+ kind "SharedLib"
22+ defines {
23+ --"TOLUA_API='__declspec(dllexport)'",
24+ }
25+ libdirs {
26+ "/x86_64-w64-mingw32/local/bin",
27+ }
28+ links {
29+ "tolua++", "lua51",
30+ "meshio",
31+ }
32+ project "lmeshio"
33+end
34+
35+language "C++"
36+files {
37+ "lmeshio_bind.cpp",
38+}
39+prebuildcommands {
40+ "make -f tolua.make",
41+}
42+buildoptions {
43+ "-std=c++0x",
44+}
45+defines {
46+}
47+includedirs {
48+ "../src",
49+}
50+linkoptions {
51+}
52+
53+configuration "Debug"
54+do
55+ defines { "DEBUG" }
56+ flags { "Symbols" }
57+ targetdir "../debug"
58+ libdirs { "../debug" }
59+end
60+configuration "Release"
61+do
62+ defines { "NDEBUG" }
63+ flags { "Optimize" }
64+ targetdir "../release"
65+ libdirs { "../release" }
66+end
67+
--- /dev/null
+++ b/lua/tolua.make
@@ -0,0 +1,11 @@
1+TOLUA=$(USERPROFILE)/work/retolua/retolua
2+#TOLUA=tolua++
3+
4+all: lmeshio_bind.cpp
5+
6+lmeshio_bind.cpp: lmeshio.pkg
7+ $(TOLUA) -n lmeshio -o $@ -H lmeshio_bind.h $<
8+
9+clean:
10+ rm -f lmeshio_bind.cpp lmeshio_bind.h
11+
Show on old repository browser