1
+ /* ----------------------------------------------------------------------------
2
+ ** GENERATED SOURCE FILE
3
+ ** Do not modify the contents of this file.
4
+ **
5
+ ** Ursine3D Meta Generator v{ {version} }
6
+ ** --------------------------------------------------------------------------*/
1
7
{ {#usingPrecompiledHeader} }#include "{ {precompiledHeader} }"
2
8
{ {/usingPrecompiledHeader} }
3
- #include "{ {ouputHeaderFile} }"
4
9
5
- #if !defined(URSINE_REFLECTION_INCLUDED)
10
+ #include "{ {moduleFileHeader} }"
11
+ #include "{ {moduleFileSourceHeader} }"
6
12
7
- #include <Utilities /MacroUtils.h >
8
-
9
- URSINE_ERROR( "<UrsineReflection .h > must be included in the input header file." )
10
-
11
- #endif
13
+ #include <ReflectionDatabase .h >
12
14
13
15
namespace m = ursine::meta;
14
16
15
- m::ReflectionDatabase::Initializer { {targetName} }Initializer([] {
16
- auto &db = m::ReflectionDatabase::Instance( );
17
-
17
+ void meta_generated::AllocateModuleFile{ {targetName} }{ {moduleFileName} }(m::ReflectionDatabase &db)
18
+ {
18
19
///////////////////////////////////////////////////////////////////////////
19
- // Class Allocations
20
+ // Class Allocation
20
21
///////////////////////////////////////////////////////////////////////////
21
22
{{#class} }
22
23
{
@@ -45,7 +46,7 @@ m::ReflectionDatabase::Initializer {{targetName}}Initializer([] {
45
46
}
46
47
{ {/class} }
47
48
///////////////////////////////////////////////////////////////////////////
48
- // Enum Allocations
49
+ // Enum Allocation
49
50
///////////////////////////////////////////////////////////////////////////
50
51
{ {#enum} }
51
52
{
@@ -73,6 +74,10 @@ m::ReflectionDatabase::Initializer {{targetName}}Initializer([] {
73
74
{ {/constPtrTypeEnabled} }
74
75
}
75
76
{ {/enum} }
77
+ }
78
+
79
+ void meta_generated::DefineModuleFile{ {targetName} }{ {moduleFileName} }(m::ReflectionDatabase &db)
80
+ {
76
81
///////////////////////////////////////////////////////////////////////////
77
82
// Global Definitions
78
83
///////////////////////////////////////////////////////////////////////////
@@ -99,15 +104,6 @@ m::ReflectionDatabase::Initializer {{targetName}}Initializer([] {
99
104
{ {#globalFunction} }
100
105
db.AddGlobalFunction( "{ {& qualifiedName} }",
101
106
static_cast<{ {& qualifiedSignature} }>( { {& qualifiedName} } ),
102
- [](m::ArgumentList &args)
103
- { {{#isVoidReturnType} }
104
- { {> invocationBody} };
105
-
106
- return m::Variant { } ;{ {/isVoidReturnType} }{ {^isVoidReturnType} }
107
- return m::Variant {
108
- {{> invocationBody} }
109
- };{ {/isVoidReturnType} }
110
- },
111
107
{
112
108
{{> metaDataInitializerList} }
113
109
}
@@ -129,7 +125,8 @@ m::ReflectionDatabase::Initializer {{targetName}}Initializer([] {
129
125
};
130
126
131
127
type.SetEnum<{ {& qualifiedName} }>( "{ {& displayName} }", {
132
- {{#member} } { " {{key}}" , {{value} } }{ {^isLast} },{ {/isLast} }
128
+ {{#member} }
129
+ { " {{key}}" , {{value} } }{ {^isLast} },{ {/isLast} }
133
130
{ {/member} }
134
131
} );
135
132
@@ -158,71 +155,44 @@ m::ReflectionDatabase::Initializer {{targetName}}Initializer([] {
158
155
type.LoadBaseClasses( db, typeID, {
159
156
{{#baseClass} }typeof( { {& name} } ){ {^isLast} },{ {/isLast} } { {/baseClass} }
160
157
} );
158
+ { {#arrayTypeEnabled} }
159
+ // Array Constructor
160
+ type.SetArrayConstructor<{ {& qualifiedName} }>( );{ {/arrayTypeEnabled} }
161
161
162
162
// Constructors
163
- { {#constructor} }
163
+ { {#constructor} }{ {#enableNonDynamic } }
164
164
type.AddConstructor<{ {& templateParameters} }>(
165
- [](m::ArgumentList &args)
166
- {
167
- return m::Variant {
168
- {{> invocationBody} }
169
- };
170
- },
171
165
{
172
166
{{> metaDataInitializerList} }
173
- },
174
- false
167
+ }
175
168
);
176
- { {/constructor} }
169
+ { {/enableNonDynamic } } { {/ constructor} }
177
170
// Dynamic Constructors
178
171
{ {#dynamicConstructor} }
179
- type.AddConstructor<{ {& templateParameters} }>(
180
- [](m::ArgumentList &args)
181
- {
182
- return m::Variant {
183
- {{> dynamicInvocationBody} }
184
- };
185
- },
172
+ type.AddConstructor<{ {& dynamicTemplateParameters} }>(
186
173
{
187
174
{{> metaDataInitializerList} }
188
- },
189
- true
175
+ }
190
176
);
191
177
{ {/dynamicConstructor} }
192
178
// Fields
193
179
{ {#field} }
194
- type.AddField<{ {parentQualifiedName} }, { {type} }>( "{ {& displayName} }",
195
- { {#isGetterAccessible} }[](const m::Variant &obj)
196
- {
197
- auto &instance = obj.GetValue< {{parentQualifiedName} }>( );
198
-
199
- return m::Variant { {{> getterBody} } };
200
- },{ {/isGetterAccessible} }{ {^isGetterAccessible} }
201
- nullptr,{ {/isGetterAccessible} }{ {#isSetterAccessible} }
202
- [](m::Variant &obj, const m::Variant &value)
203
- {
204
- auto &instance = obj.GetValue< {{parentQualifiedName} }>( );
205
-
206
- { {> setterBody} }
207
- },{ {/isSetterAccessible} }{ {^isSetterAccessible} }
208
- nullptr,{ {/isSetterAccessible} }
180
+ type.AddField<{ {& parentQualifiedName} }, { {& type} }>( "{ {& displayName} }",
181
+ { {#isGetterAccessible} }{ {> getterBody} },{ {/isGetterAccessible} }{ {^isGetterAccessible} }
182
+ ((m::FieldGetter<{ {& parentQualifiedName} }, { {& type} }, true>::Signature))nullptr,{ {/isGetterAccessible} }{ {#isSetterAccessible} }
183
+ { {> setterBody} },{ {/isSetterAccessible} }{ {^isSetterAccessible} }
184
+ (m::FieldSetter<{ {& parentQualifiedName} }, { {& type} }, true>::Signature)nullptr,{ {/isSetterAccessible} }
209
185
{
210
186
{{> metaDataInitializerList} }
211
187
}
212
188
);
213
189
{ {/field} }
214
190
// Static Fields
215
191
{ {#staticField} }
216
- type.AddStaticField<{ {& parentQualifiedName} }, { {type} }>( "{ {& displayName} }",
217
- { {#isGetterAccessible} }[](void)
218
- {
219
- return m::Variant { {{> getterBody} } };
220
- },{ {/isGetterAccessible} }{ {^isGetterAccessible} }
192
+ type.AddStaticField<{ {& parentQualifiedName} }, { {& type} }>( "{ {& displayName} }",
193
+ { {#isGetterAccessible} }{ {> getterBody} },{ {/isGetterAccessible} }{ {^isGetterAccessible} }
221
194
nullptr,{ {/isGetterAccessible} }{ {#isSetterAccessible} }
222
- [](const m::Argument &value)
223
- {
224
- {{> setterBody} }
225
- },{ {/isSetterAccessible} }{ {^isSetterAccessible} }
195
+ { {> setterBody} },{ {/isSetterAccessible} }{ {^isSetterAccessible} }
226
196
nullptr,{ {/isSetterAccessible} }
227
197
{
228
198
{{> metaDataInitializerList} }
@@ -233,17 +203,6 @@ m::ReflectionDatabase::Initializer {{targetName}}Initializer([] {
233
203
{ {#method} }
234
204
type.AddMethod( "{ {name} }",
235
205
static_cast<{ {& qualifiedSignature} }>( & { {parentQualifiedName} }::{ {name} } ),
236
- [](m::Variant &obj, m::ArgumentList &args)
237
- {
238
- auto &instance = obj.GetValue< {{parentQualifiedName} }>( );
239
- { {#isVoidReturnType} }
240
- instance.{ {> invocationBody} };
241
-
242
- return m::Variant { } ;{ {/isVoidReturnType} }{ {^isVoidReturnType} }
243
- return m::Variant {
244
- instance.{{> invocationBody} }
245
- };{ {/isVoidReturnType} }
246
- },
247
206
{
248
207
{{> metaDataInitializerList} }
249
208
}
@@ -253,15 +212,6 @@ m::ReflectionDatabase::Initializer {{targetName}}Initializer([] {
253
212
{ {#staticMethod} }
254
213
type.AddStaticMethod<{ {parentQualifiedName} }>( "{ {name} }",
255
214
static_cast<{ {& qualifiedSignature} }>( { {parentQualifiedName} }::{ {& qualifiedName} } ),
256
- [](m::ArgumentList &args)
257
- { {{#isVoidReturnType} }
258
- { {parentQualifiedName} }::{ {> invocationBody} };
259
-
260
- return m::Variant { } ;{ {/isVoidReturnType} }{ {^isVoidReturnType} }
261
- return m::Variant {
262
- {{parentQualifiedName} }::{ {> invocationBody} }
263
- };{ {/isVoidReturnType} }
264
- },
265
215
{
266
216
{{> metaDataInitializerList} }
267
217
}
@@ -270,4 +220,4 @@ m::ReflectionDatabase::Initializer {{targetName}}Initializer([] {
270
220
m::TypeInfo<{ {& qualifiedName} }>::Defined = true;
271
221
}
272
222
}{ {/class} }
273
- });
223
+ }
0 commit comments