• R/O
  • HTTP
  • SSH
  • HTTPS

meshio: Commit

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


Commit MetaInfo

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

Log Message

add luabinding

Change Summary

Incremental Difference

--- /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> */