Rigs of Rods 2026.01
Soft-body Physics Simulation
Loading...
Searching...
No Matches
OgreAngelscriptGeneric.cpp
Go to the documentation of this file.
1/*
2 This source file is part of Rigs of Rods
3 Copyright 2005-2012 Pierre-Michel Ricordel
4 Copyright 2007-2012 Thomas Fischer
5 Copyright 2013-2024 Petr Ohlidal
6
7 For more information, see http://www.rigsofrods.org/
8
9 Rigs of Rods is free software: you can redistribute it and/or modify
10 it under the terms of the GNU General Public License version 3, as
11 published by the Free Software Foundation.
12
13 Rigs of Rods is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with Rigs of Rods. If not, see <http://www.gnu.org/licenses/>.
20*/
21
23
24#include "../../autowrapper/aswrappedcall.h"
25#include "AngelScriptBindings.h"
26#include "Application.h"
27#include "ScriptEngine.h"
28#include "ScriptUtils.h"
29#include "wrappers/OgreAngelscriptWrappers.h"
30
31#include <angelscript.h>
32
33#include <OgreRenderOperation.h>
34
35#include <Overlay/OgreOverlaySystem.h>
36#include <Overlay/OgreOverlayManager.h>
37#include <Overlay/OgreOverlay.h>
38#include <Overlay/OgreOverlayContainer.h>
39
40using namespace Ogre;
41using namespace AngelScript;
42using namespace RoR;
43using namespace OgreAngelscriptWrappers;
44
45// Generic-only helpers:
46// The autowrapper reads each argument as its exact C++ type, so C++ `size_t` params
47// can't be bound directly to 32-bit script params (`int`/`uint`) and C++ `const T&`
48// return values can't be bound to by-value script returns. These adapters convert.
49
50static float Vector3OpIndex(const Vector3& self, int i)
51{
52 return self[i];
53}
54
55static Vector3 Vector3OpAddUnary(const Vector3& self)
56{
57 return +self;
58}
59
60static float Vector2OpIndex(const Vector2& self, int i)
61{
62 return self[i];
63}
64
65static Vector2 Vector2OpAddUnary(const Vector2& self)
66{
67 return +self;
68}
69
70static float QuaternionOpIndex(const Quaternion& self, int i)
71{
72 return self[i];
73}
74
75static Radian& RadianAssignFloat(Radian& self, float f)
76{
77 return self = f;
78}
79
80static Radian RadianOpAddUnary(const Radian& self)
81{
82 return +self;
83}
84
85static Degree& DegreeAssignFloat(Degree& self, float f)
86{
87 return self = f;
88}
89
90static Degree DegreeOpAddUnary(const Degree& self)
91{
92 return +self;
93}
94
95static ColourValue PixelBoxGetColourAt(const PixelBox& self, asUINT x, asUINT y, asUINT z)
96{
97 return self.getColourAt(x, y, z);
98}
99
100static void PixelBoxSetColourAt(PixelBox& self, const ColourValue& c, asUINT x, asUINT y, asUINT z)
101{
102 self.setColourAt(c, x, y, z);
103}
104
105static ColourValue ImageGetColourAt(const Image& self, asUINT x, asUINT y, asUINT z)
106{
107 return self.getColourAt(x, y, z);
108}
109
110static void ImageSetColourAt(Image& self, const ColourValue& c, asUINT x, asUINT y, asUINT z)
111{
112 self.setColourAt(c, x, y, z);
113}
114
115static PixelBox ImageGetPixelBox(const Image& self, asUINT face, asUINT mipmap)
116{
117 return self.getPixelBox(face, mipmap);
118}
119
120static void AnimationStateCreateBlendMask(AnimationState* self, asUINT blendMaskSizeHint, float initialWeight)
121{
122 self->createBlendMask(blendMaskSizeHint, initialWeight);
123}
124
125static void AnimationStateSetBlendMaskEntry(AnimationState* self, asUINT boneHandle, float weight)
126{
127 self->setBlendMaskEntry(boneHandle, weight);
128}
129
130static float AnimationStateGetBlendMaskEntry(AnimationState* self, asUINT boneHandle)
131{
132 return self->getBlendMaskEntry(boneHandle);
133}
134
135// Generic version of `ScriptRefCastNoCount()` from ScriptUtils.h
136template<class A, class B>
137static void ScriptRefCastNoCountGeneric(asIScriptGeneric* gen)
138{
139 A* a = static_cast<A*>(gen->GetObject());
140 *static_cast<B**>(gen->GetAddressOfReturnLocation()) = ScriptRefCastNoCount<A, B>(a);
141}
142
143// forward declarations, defined below
144static void registerOgreVector3Generic(AngelScript::asIScriptEngine* engine);
145static void registerOgreVector2Generic(AngelScript::asIScriptEngine* engine);
146static void registerOgreRadianGeneric(AngelScript::asIScriptEngine* engine);
147static void registerOgreDegreeGeneric(AngelScript::asIScriptEngine* engine);
148static void registerOgreQuaternionGeneric(AngelScript::asIScriptEngine* engine);
149static void registerOgreColourValueGeneric(AngelScript::asIScriptEngine* engine);
150static void registerOgreBoxGeneric(AngelScript::asIScriptEngine* engine);
151
152static void registerOgreMovableObjectGeneric(AngelScript::asIScriptEngine* engine);
153static void registerOgreEntityGeneric(AngelScript::asIScriptEngine* engine);
154static void registerOgreSubEntityGeneric(AngelScript::asIScriptEngine* engine);
155static void registerOgreNodeGeneric(AngelScript::asIScriptEngine* engine);
156static void registerOgreSceneNodeGeneric(AngelScript::asIScriptEngine* engine);
157static void registerOgreSceneManagerGeneric(AngelScript::asIScriptEngine* engine);
158static void registerOgreRootGeneric(AngelScript::asIScriptEngine* engine);
159static void registerOgreAnimationStateGeneric(AngelScript::asIScriptEngine* engine);
160static void registerOgreAnimationStateSetGeneric(AngelScript::asIScriptEngine* engine);
161static void registerOgreTextureGeneric(AngelScript::asIScriptEngine* engine);
162static void registerOgreTextureManagerGeneric(AngelScript::asIScriptEngine* engine);
163static void registerOgreManualObjectGeneric(AngelScript::asIScriptEngine* engine);
164static void registerOgreHardwarePixelBufferGeneric(AngelScript::asIScriptEngine* engine);
165static void registerOgrePixelBoxGeneric(AngelScript::asIScriptEngine* engine);
166static void registerOgreImageGeneric(AngelScript::asIScriptEngine* engine);
167static void registerOgreMeshManagerGeneric(AngelScript::asIScriptEngine* engine);
168static void registerOgreMeshGeneric(AngelScript::asIScriptEngine* engine);
169static void registerOgreSubMeshGeneric(AngelScript::asIScriptEngine* engine);
170static void registerOgreMaterialManagerGeneric(AngelScript::asIScriptEngine* engine);
171static void registerOgreMaterialGeneric(AngelScript::asIScriptEngine* engine);
172static void registerOgreTechniqueGeneric(AngelScript::asIScriptEngine* engine);
173static void registerOgrePassGeneric(AngelScript::asIScriptEngine* engine);
174static void registerOgreTextureUnitStateGeneric(AngelScript::asIScriptEngine* engine);
175static void registerOgreTimerGeneric(AngelScript::asIScriptEngine* engine);
176static void registerOgreGpuProgramParametersGeneric(AngelScript::asIScriptEngine* engine);
177static void registerOgreLightGeneric(AngelScript::asIScriptEngine* engine);
178static void registerOgreOverlayGeneric(AngelScript::asIScriptEngine* engine);
179static void registerOgreOverlayElementGeneric(AngelScript::asIScriptEngine* engine);
180static void registerOgreOverlayManagerGeneric(AngelScript::asIScriptEngine* engine);
181
182// main registration method
183void RoR::RegisterOgreObjectsGeneric(AngelScript::asIScriptEngine* engine)
184{
185 int r;
186
187 // NOTE: data types, enums and object properties are registered in RegisterOgreObjectsCommon()
188
189 r = engine->SetDefaultNamespace("Ogre"); ROR_ASSERT(r >= 0);
190
191 // dictionary/array view types, also under namespace `Ogre`
192
193 SceneManagerInstanceDict::RegisterReadonlyScriptDictViewGeneric(engine, "SceneManagerInstanceDict", "SceneManager");
194 MovableObjectArray::RegisterReadonlyScriptArrayViewGeneric(engine, "MovableObjectArray", "MovableObject");
195 ChildNodeArray::RegisterReadonlyScriptArrayViewGeneric(engine, "ChildNodeArray", "Node");
196 AnimationStateDict::RegisterReadonlyScriptDictViewGeneric(engine, "AnimationStateDict", "AnimationState");
197 SubMeshArray::RegisterReadonlyScriptArrayViewGeneric(engine, "SubMeshArray", "SubMesh");
198 TechniqueArray::RegisterReadonlyScriptArrayViewGeneric(engine, "TechniqueArray", "Technique");
199 PassArray::RegisterReadonlyScriptArrayViewGeneric(engine, "PassArray", "Pass");
200 TextureUnitStateArray::RegisterReadonlyScriptArrayViewGeneric(engine, "TextureUnitStateArray", "TextureUnitState");
201 SubEntityArray::RegisterReadonlyScriptArrayViewGeneric(engine, "SubEntityArray", "SubEntity");
202
203 r = engine->SetDefaultNamespace(""); ROR_ASSERT(r >= 0);
204
205 // Now we register the object methods
206
207 registerOgreRadianGeneric(engine);
208 registerOgreDegreeGeneric(engine);
209 registerOgreVector3Generic(engine);
210 registerOgreVector2Generic(engine);
211 registerOgreQuaternionGeneric(engine);
212 registerOgreColourValueGeneric(engine);
213 registerOgreBoxGeneric(engine);
214
215 registerOgreNodeGeneric(engine);
216 registerOgreMovableObjectGeneric(engine);
217 registerOgreEntityGeneric(engine);
218 registerOgreSubEntityGeneric(engine);
219 registerOgreSceneNodeGeneric(engine);
220 registerOgreSceneManagerGeneric(engine);
221 registerOgreRootGeneric(engine);
222 registerOgreAnimationStateGeneric(engine);
223 registerOgreAnimationStateSetGeneric(engine);
224 registerOgreTextureGeneric(engine);
225 registerOgreTextureManagerGeneric(engine);
226 registerOgreManualObjectGeneric(engine);
227 registerOgreHardwarePixelBufferGeneric(engine);
228 registerOgrePixelBoxGeneric(engine);
229 registerOgreImageGeneric(engine);
230 registerOgreMeshGeneric(engine);
231 registerOgreSubMeshGeneric(engine);
232 registerOgreMeshManagerGeneric(engine);
233 registerOgreMaterialGeneric(engine);
234 registerOgreTechniqueGeneric(engine);
235 registerOgrePassGeneric(engine);
236 registerOgreTextureUnitStateGeneric(engine);
237 registerOgreMaterialManagerGeneric(engine);
238 registerOgreTimerGeneric(engine);
239 registerOgreGpuProgramParametersGeneric(engine);
240 registerOgreLightGeneric(engine);
241 registerOgreOverlayGeneric(engine);
242 registerOgreOverlayElementGeneric(engine);
243 registerOgreOverlayManagerGeneric(engine);
244
245 // To estabilish class hierarchy in AngelScript you need to register the reference cast operators opCast and opImplCast.
246
247 // - `SceneNode` derives from `Node`
248 r = engine->RegisterObjectMethod("Ogre::Node", "Ogre::SceneNode@ opCast()", asFUNCTION((ScriptRefCastNoCountGeneric<Ogre::Node, Ogre::SceneNode>)), asCALL_GENERIC); ROR_ASSERT(r >= 0);
249 r = engine->RegisterObjectMethod("Ogre::SceneNode", "Ogre::Node@ opImplCast()", asFUNCTION((ScriptRefCastNoCountGeneric<Ogre::SceneNode, Ogre::Node>)), asCALL_GENERIC); ROR_ASSERT(r >= 0);
250 // - `Entity` derives from `MovableObject`
251 r = engine->RegisterObjectMethod("Ogre::MovableObject", "Ogre::Entity@ opCast()", asFUNCTION((ScriptRefCastNoCountGeneric<Ogre::MovableObject, Ogre::Entity>)), asCALL_GENERIC); ROR_ASSERT(r >= 0);
252 r = engine->RegisterObjectMethod("Ogre::Entity", "Ogre::MovableObject@ opImplCast()", asFUNCTION((ScriptRefCastNoCountGeneric<Ogre::Entity, Ogre::MovableObject>)), asCALL_GENERIC); ROR_ASSERT(r >= 0);
253 // - `ManualObject` derives from `MovableObject`
254 r = engine->RegisterObjectMethod("Ogre::MovableObject", "Ogre::ManualObject@ opCast()", asFUNCTION((ScriptRefCastNoCountGeneric<Ogre::MovableObject, Ogre::ManualObject>)), asCALL_GENERIC); ROR_ASSERT(r >= 0);
255 r = engine->RegisterObjectMethod("Ogre::ManualObject", "Ogre::MovableObject@ opImplCast()", asFUNCTION((ScriptRefCastNoCountGeneric<Ogre::ManualObject, Ogre::MovableObject>)), asCALL_GENERIC); ROR_ASSERT(r >= 0);
256 // - `Light` derives from `MovableObject`
257 r = engine->RegisterObjectMethod("Ogre::MovableObject", "Ogre::Light@ opCast()", asFUNCTION((ScriptRefCastNoCountGeneric<Ogre::MovableObject, Ogre::Light>)), asCALL_GENERIC); ROR_ASSERT(r >= 0);
258 r = engine->RegisterObjectMethod("Ogre::Light", "Ogre::MovableObject@ opImplCast()", asFUNCTION((ScriptRefCastNoCountGeneric<Ogre::Light, Ogre::MovableObject>)), asCALL_GENERIC); ROR_ASSERT(r >= 0);
259
260 // Also register the const overloads so the cast works also when the handle is read only
261
262 // - `SceneNode` derives from `Node`
263 r = engine->RegisterObjectMethod("Ogre::Node", "const Ogre::SceneNode@ opCast() const", asFUNCTION((ScriptRefCastNoCountGeneric<Ogre::Node, Ogre::SceneNode>)), asCALL_GENERIC); ROR_ASSERT(r >= 0);
264 r = engine->RegisterObjectMethod("Ogre::SceneNode", "const Ogre::Node@ opImplCast() const", asFUNCTION((ScriptRefCastNoCountGeneric<Ogre::SceneNode, Ogre::Node>)), asCALL_GENERIC); ROR_ASSERT(r >= 0);
265 // - `Entity` derives from `MovableObject`
266 r = engine->RegisterObjectMethod("Ogre::MovableObject", "const Ogre::Entity@ opCast() const", asFUNCTION((ScriptRefCastNoCountGeneric<Ogre::MovableObject, Ogre::Entity>)), asCALL_GENERIC); ROR_ASSERT(r >= 0);
267 r = engine->RegisterObjectMethod("Ogre::Entity", "const Ogre::MovableObject@ opImplCast() const", asFUNCTION((ScriptRefCastNoCountGeneric<Ogre::Entity, Ogre::MovableObject>)), asCALL_GENERIC); ROR_ASSERT(r >= 0);
268 // - `ManualObject` derives from `MovableObject`
269 r = engine->RegisterObjectMethod("Ogre::MovableObject", "const Ogre::ManualObject@ opCast() const", asFUNCTION((ScriptRefCastNoCountGeneric<Ogre::MovableObject, Ogre::ManualObject>)), asCALL_GENERIC); ROR_ASSERT(r >= 0);
270 r = engine->RegisterObjectMethod("Ogre::ManualObject", "const Ogre::MovableObject@ opImplCast() const", asFUNCTION((ScriptRefCastNoCountGeneric<Ogre::ManualObject, Ogre::MovableObject>)), asCALL_GENERIC); ROR_ASSERT(r >= 0);
271 // - `Light` derives from `MovableObject`
272 r = engine->RegisterObjectMethod("Ogre::MovableObject", "const Ogre::Light@ opCast() const", asFUNCTION((ScriptRefCastNoCountGeneric<Ogre::MovableObject, Ogre::Light>)), asCALL_GENERIC); ROR_ASSERT(r >= 0);
273 r = engine->RegisterObjectMethod("Ogre::Light", "const Ogre::MovableObject@ opImplCast() const", asFUNCTION((ScriptRefCastNoCountGeneric<Ogre::Light, Ogre::MovableObject>)), asCALL_GENERIC); ROR_ASSERT(r >= 0);
274}
275
276// register Ogre::Vector3
277static void registerOgreVector3Generic(AngelScript::asIScriptEngine* engine)
278{
279 int r;
280
281 // Register the object constructors
282 r = engine->RegisterObjectBehaviour("vector3", asBEHAVE_CONSTRUCT, "void f()", WRAP_OBJ_LAST(Vector3DefaultConstructor), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
283 r = engine->RegisterObjectBehaviour("vector3", asBEHAVE_CONSTRUCT, "void f(float, float, float)", WRAP_OBJ_LAST(Vector3InitConstructor), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
284 r = engine->RegisterObjectBehaviour("vector3", asBEHAVE_CONSTRUCT, "void f(const vector3 &in)", WRAP_OBJ_LAST(Vector3CopyConstructor), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
285 r = engine->RegisterObjectBehaviour("vector3", asBEHAVE_CONSTRUCT, "void f(float)", WRAP_OBJ_LAST(Vector3InitConstructorScaler), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
286
287 // Register the object operators
288 r = engine->RegisterObjectMethod("vector3", "float opIndex(int) const", WRAP_OBJ_FIRST(Vector3OpIndex), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
289 r = engine->RegisterObjectMethod("vector3", "vector3 &f(const vector3 &in)", WRAP_MFN_PR(Vector3, operator =, (const Vector3 &), Vector3&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
290 r = engine->RegisterObjectMethod("vector3", "bool opEquals(const vector3 &in) const", WRAP_MFN_PR(Vector3, operator==,(const Vector3&) const, bool), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
291
292 r = engine->RegisterObjectMethod("vector3", "vector3 opAdd(const vector3 &in) const", WRAP_MFN_PR(Vector3, operator+,(const Vector3&) const, Vector3), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
293 r = engine->RegisterObjectMethod("vector3", "vector3 opSub(const vector3 &in) const", WRAP_MFN_PR(Vector3, operator-,(const Vector3&) const, Vector3), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
294
295 r = engine->RegisterObjectMethod("vector3", "vector3 opMul(float) const", WRAP_MFN_PR(Vector3, operator*,(const float) const, Vector3), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
296 r = engine->RegisterObjectMethod("vector3", "vector3 opMul(const vector3 &in) const", WRAP_MFN_PR(Vector3, operator*,(const Vector3&) const, Vector3), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
297 r = engine->RegisterObjectMethod("vector3", "vector3 opDiv(float) const", WRAP_MFN_PR(Vector3, operator/,(const float) const, Vector3), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
298 r = engine->RegisterObjectMethod("vector3", "vector3 opDiv(const vector3 &in) const", WRAP_MFN_PR(Vector3, operator/,(const Vector3&) const, Vector3), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
299
300 r = engine->RegisterObjectMethod("vector3", "vector3 opAdd() const", WRAP_OBJ_FIRST(Vector3OpAddUnary), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
301 r = engine->RegisterObjectMethod("vector3", "vector3 opSub() const", WRAP_MFN_PR(Vector3, operator-,() const, Vector3), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
302
303 r = engine->RegisterObjectMethod("vector3", "vector3 &opAddAssign(const vector3 &in)", WRAP_MFN_PR(Vector3,operator+=,(const Vector3 &),Vector3&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
304 r = engine->RegisterObjectMethod("vector3", "vector3 &opAddAssign(float)", WRAP_MFN_PR(Vector3,operator+=,(const float),Vector3&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
305
306 r = engine->RegisterObjectMethod("vector3", "vector3 &opSubAssign(const vector3 &in)", WRAP_MFN_PR(Vector3,operator-=,(const Vector3 &),Vector3&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
307 r = engine->RegisterObjectMethod("vector3", "vector3 &opSubAssign(float)", WRAP_MFN_PR(Vector3,operator-=,(const float),Vector3&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
308
309 r = engine->RegisterObjectMethod("vector3", "vector3 &opMulAssign(const vector3 &in)", WRAP_MFN_PR(Vector3,operator*=,(const Vector3 &),Vector3&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
310 r = engine->RegisterObjectMethod("vector3", "vector3 &opMulAssign(float)", WRAP_MFN_PR(Vector3,operator*=,(const float),Vector3&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
311
312 r = engine->RegisterObjectMethod("vector3", "vector3 &opDivAssign(const vector3 &in)", WRAP_MFN_PR(Vector3,operator/=,(const Vector3 &),Vector3&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
313 r = engine->RegisterObjectMethod("vector3", "vector3 &opDivAssign(float)", WRAP_MFN_PR(Vector3,operator/=,(const float),Vector3&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
314
315 // Register the object methods
316 r = engine->RegisterObjectMethod("vector3", "float length() const", WRAP_MFN(Vector3,length), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
317 r = engine->RegisterObjectMethod("vector3", "float squaredLength() const", WRAP_MFN(Vector3,squaredLength), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
318
319 r = engine->RegisterObjectMethod("vector3", "float distance(const vector3 &in) const", WRAP_MFN(Vector3,distance), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
320 r = engine->RegisterObjectMethod("vector3", "float squaredDistance(const vector3 &in) const", WRAP_MFN(Vector3,squaredDistance), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
321
322 r = engine->RegisterObjectMethod("vector3", "float dotProduct(const vector3 &in) const", WRAP_MFN(Vector3,dotProduct), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
323 r = engine->RegisterObjectMethod("vector3", "float absDotProduct(const vector3 &in) const", WRAP_MFN(Vector3,absDotProduct), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
324
325 r = engine->RegisterObjectMethod("vector3", "float normalise()", WRAP_MFN(Vector3,normalise), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
326 r = engine->RegisterObjectMethod("vector3", "vector3 crossProduct(const vector3 &in) const", WRAP_MFN(Vector3,crossProduct), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
327 r = engine->RegisterObjectMethod("vector3", "vector3 midPoint(const vector3 &in) const", WRAP_MFN(Vector3,midPoint), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
328 r = engine->RegisterObjectMethod("vector3", "void makeFloor(const vector3 &in)", WRAP_MFN(Vector3,makeFloor), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
329 r = engine->RegisterObjectMethod("vector3", "void makeCeil(const vector3 &in)", WRAP_MFN(Vector3,makeCeil), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
330 r = engine->RegisterObjectMethod("vector3", "vector3 perpendicular() const", WRAP_MFN(Vector3,perpendicular), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
331 r = engine->RegisterObjectMethod("vector3", "vector3 randomDeviant(const radian &in, const vector3 &in) const", WRAP_MFN(Vector3,randomDeviant), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
332 r = engine->RegisterObjectMethod("vector3", "radian angleBetween(const vector3 &in)", WRAP_MFN(Vector3,angleBetween), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
333 r = engine->RegisterObjectMethod("vector3", "quaternion getRotationTo(const vector3 &in, const vector3 &in) const", WRAP_MFN(Vector3,getRotationTo), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
334 r = engine->RegisterObjectMethod("vector3", "bool isZeroLength() const", WRAP_MFN(Vector3,isZeroLength), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
335 r = engine->RegisterObjectMethod("vector3", "vector3 normalisedCopy() const", WRAP_MFN(Vector3,normalisedCopy), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
336 r = engine->RegisterObjectMethod("vector3", "vector3 reflect(const vector3 &in) const", WRAP_MFN(Vector3,reflect), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
337
338 r = engine->RegisterObjectMethod("vector3", "bool positionEquals(const vector3 &in, float) const", WRAP_MFN(Vector3,positionEquals), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
339 r = engine->RegisterObjectMethod("vector3", "bool positionCloses(const vector3 &in, float) const", WRAP_MFN(Vector3,positionCloses), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
340 r = engine->RegisterObjectMethod("vector3", "bool directionEquals(const vector3 &in, radian &in) const", WRAP_MFN(Vector3,directionEquals), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
341
342 r = engine->RegisterObjectMethod("vector3", "bool isNaN() const", WRAP_MFN(Vector3,isNaN), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
343}
344
345// register Ogre::Vector2
346static void registerOgreVector2Generic(AngelScript::asIScriptEngine* engine)
347{
348 int r;
349
350 // Register the object constructors
351 r = engine->RegisterObjectBehaviour("vector2", asBEHAVE_CONSTRUCT, "void f()", WRAP_OBJ_LAST(Vector2DefaultConstructor), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
352 r = engine->RegisterObjectBehaviour("vector2", asBEHAVE_CONSTRUCT, "void f(float, float)", WRAP_OBJ_LAST(Vector2InitConstructor), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
353 r = engine->RegisterObjectBehaviour("vector2", asBEHAVE_CONSTRUCT, "void f(const vector2 &in)", WRAP_OBJ_LAST(Vector2CopyConstructor), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
354 r = engine->RegisterObjectBehaviour("vector2", asBEHAVE_CONSTRUCT, "void f(float)", WRAP_OBJ_LAST(Vector2InitConstructorScaler), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
355
356 // Register the object operators
357 r = engine->RegisterObjectMethod("vector2", "float opIndex(int) const", WRAP_OBJ_FIRST(Vector2OpIndex), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
358 r = engine->RegisterObjectMethod("vector2", "vector2 &f(const vector2 &in)", WRAP_MFN_PR(Vector2, operator =, (const Vector2 &), Vector2&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
359 r = engine->RegisterObjectMethod("vector2", "bool opEquals(const vector2 &in) const", WRAP_MFN_PR(Vector2, operator==,(const Vector2&) const, bool), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
360
361 r = engine->RegisterObjectMethod("vector2", "vector2 opAdd(const vector2 &in) const", WRAP_MFN_PR(Vector2, operator+,(const Vector2&) const, Vector2), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
362 r = engine->RegisterObjectMethod("vector2", "vector2 opSub(const vector2 &in) const", WRAP_MFN_PR(Vector2, operator-,(const Vector2&) const, Vector2), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
363
364 r = engine->RegisterObjectMethod("vector2", "vector2 opMul(float) const", WRAP_MFN_PR(Vector2, operator*,(const float) const, Vector2), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
365 r = engine->RegisterObjectMethod("vector2", "vector2 opMul(const vector2 &in) const", WRAP_MFN_PR(Vector2, operator*,(const Vector2&) const, Vector2), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
366 r = engine->RegisterObjectMethod("vector2", "vector2 opDiv(float) const", WRAP_MFN_PR(Vector2, operator/,(const float) const, Vector2), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
367 r = engine->RegisterObjectMethod("vector2", "vector2 opDiv(const vector2 &in) const", WRAP_MFN_PR(Vector2, operator/,(const Vector2&) const, Vector2), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
368
369 r = engine->RegisterObjectMethod("vector2", "vector2 opAdd() const", WRAP_OBJ_FIRST(Vector2OpAddUnary), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
370 r = engine->RegisterObjectMethod("vector2", "vector2 opSub() const", WRAP_MFN_PR(Vector2, operator-,() const, Vector2), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
371
372 r = engine->RegisterObjectMethod("vector2", "vector2 &opAddAssign(const vector2 &in)", WRAP_MFN_PR(Vector2,operator+=,(const Vector2 &),Vector2&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
373 r = engine->RegisterObjectMethod("vector2", "vector2 &opAddAssign(float)", WRAP_MFN_PR(Vector2,operator+=,(const float),Vector2&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
374
375 r = engine->RegisterObjectMethod("vector2", "vector2 &opSubAssign(const vector2 &in)", WRAP_MFN_PR(Vector2,operator-=,(const Vector2 &),Vector2&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
376 r = engine->RegisterObjectMethod("vector2", "vector2 &opSubAssign(float)", WRAP_MFN_PR(Vector2,operator-=,(const float),Vector2&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
377
378 r = engine->RegisterObjectMethod("vector2", "vector2 &opMulAssign(const vector2 &in)", WRAP_MFN_PR(Vector2,operator*=,(const Vector2 &),Vector2&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
379 r = engine->RegisterObjectMethod("vector2", "vector2 &opMulAssign(float)", WRAP_MFN_PR(Vector2,operator*=,(const float),Vector2&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
380
381 r = engine->RegisterObjectMethod("vector2", "vector2 &opDivAssign(const vector2 &in)", WRAP_MFN_PR(Vector2,operator/=,(const Vector2 &),Vector2&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
382 r = engine->RegisterObjectMethod("vector2", "vector2 &opDivAssign(float)", WRAP_MFN_PR(Vector2,operator/=,(const float),Vector2&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
383
384 // Register the object methods
385
386 r = engine->RegisterObjectMethod("vector2", "float length() const", WRAP_MFN(Vector2,length), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
387 r = engine->RegisterObjectMethod("vector2", "float squaredLength() const", WRAP_MFN(Vector2,squaredLength), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
388
389 r = engine->RegisterObjectMethod("vector2", "float distance(const vector2 &in) const", WRAP_MFN(Vector2,distance), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
390 r = engine->RegisterObjectMethod("vector2", "float squaredDistance(const vector2 &in) const", WRAP_MFN(Vector2,squaredDistance), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
391
392 r = engine->RegisterObjectMethod("vector2", "float dotProduct(const vector2 &in) const", WRAP_MFN(Vector2,dotProduct), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
393
394 r = engine->RegisterObjectMethod("vector2", "float normalise()", WRAP_MFN(Vector2,normalise), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
395 r = engine->RegisterObjectMethod("vector2", "float crossProduct(const vector2 &in) const", WRAP_MFN(Vector2,crossProduct), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
396 r = engine->RegisterObjectMethod("vector2", "vector2 midPoint(const vector2 &in) const", WRAP_MFN(Vector2,midPoint), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
397 r = engine->RegisterObjectMethod("vector2", "void makeFloor(const vector2 &in)", WRAP_MFN(Vector2,makeFloor), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
398 r = engine->RegisterObjectMethod("vector2", "void makeCeil(const vector2 &in)", WRAP_MFN(Vector2,makeCeil), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
399 r = engine->RegisterObjectMethod("vector2", "vector2 perpendicular() const", WRAP_MFN(Vector2,perpendicular), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
400 r = engine->RegisterObjectMethod("vector2", "vector2 randomDeviant(const radian &in, const vector2 &in) const", WRAP_MFN(Vector2,randomDeviant), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
401 r = engine->RegisterObjectMethod("vector2", "radian angleBetween(const vector2 &in)", WRAP_MFN(Vector2,angleBetween), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
402 r = engine->RegisterObjectMethod("vector2", "bool isZeroLength() const", WRAP_MFN(Vector2,isZeroLength), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
403 r = engine->RegisterObjectMethod("vector2", "vector2 normalisedCopy() const", WRAP_MFN(Vector2,normalisedCopy), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
404 r = engine->RegisterObjectMethod("vector2", "vector2 reflect(const vector2 &in) const", WRAP_MFN(Vector2,reflect), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
405
406 r = engine->RegisterObjectMethod("vector2", "bool positionEquals(const vector2 &in, float) const", WRAP_MFN(Vector2,positionEquals), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
407
408 r = engine->RegisterObjectMethod("vector2", "bool isNaN() const", WRAP_MFN(Vector2,isNaN), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
409}
410
411static void registerOgreRadianGeneric(AngelScript::asIScriptEngine* engine)
412{
413 int r;
414
415 // Register the object constructors
416 r = engine->RegisterObjectBehaviour("radian", asBEHAVE_CONSTRUCT, "void f()", WRAP_OBJ_LAST(RadianDefaultConstructor), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
417 r = engine->RegisterObjectBehaviour("radian", asBEHAVE_CONSTRUCT, "void f(float)", WRAP_OBJ_LAST(RadianInitConstructor), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
418 r = engine->RegisterObjectBehaviour("radian", asBEHAVE_CONSTRUCT, "void f(const radian &in)", WRAP_OBJ_LAST(RadianCopyConstructor), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
419
420 // Register the object operators
421 r = engine->RegisterObjectMethod("radian", "radian &opAssign(const radian &in)", WRAP_MFN_PR(Radian, operator =, (const Radian &), Radian&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
422 r = engine->RegisterObjectMethod("radian", "radian &opAssign(const float)", WRAP_OBJ_FIRST(RadianAssignFloat), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
423 r = engine->RegisterObjectMethod("radian", "radian &opAssign(const degree &in)", WRAP_MFN_PR(Radian, operator =, (const Degree &), Radian&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
424
425 r = engine->RegisterObjectMethod("radian", "radian opAdd() const", WRAP_OBJ_FIRST(RadianOpAddUnary), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
426 r = engine->RegisterObjectMethod("radian", "radian opAdd(const radian &in) const", WRAP_MFN_PR(Radian, operator+,(const Radian&) const, Radian), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
427 r = engine->RegisterObjectMethod("radian", "radian opAdd(const degree &in) const", WRAP_MFN_PR(Radian, operator+,(const Degree&) const, Radian), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
428
429 r = engine->RegisterObjectMethod("radian", "radian &opAddAssign(const radian &in)", WRAP_MFN_PR(Radian,operator+=,(const Radian &),Radian&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
430 r = engine->RegisterObjectMethod("radian", "radian &opAddAssign(const degree &in)", WRAP_MFN_PR(Radian,operator+=,(const Degree &),Radian&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
431
432 r = engine->RegisterObjectMethod("radian", "radian opSub() const", WRAP_MFN_PR(Radian, operator-,() const, Radian), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
433 r = engine->RegisterObjectMethod("radian", "radian opSub(const radian &in) const", WRAP_MFN_PR(Radian, operator-,(const Radian&) const, Radian), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
434 r = engine->RegisterObjectMethod("radian", "radian opSub(const degree &in) const", WRAP_MFN_PR(Radian, operator-,(const Degree&) const, Radian), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
435
436 r = engine->RegisterObjectMethod("radian", "radian &opSubAssign(const radian &in)", WRAP_MFN_PR(Radian,operator-=,(const Radian &),Radian&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
437 r = engine->RegisterObjectMethod("radian", "radian &opSubAssign(const degree &in)", WRAP_MFN_PR(Radian,operator-=,(const Degree &),Radian&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
438
439 r = engine->RegisterObjectMethod("radian", "radian opMul(float) const", WRAP_MFN_PR(Radian, operator*,(float) const, Radian), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
440 r = engine->RegisterObjectMethod("radian", "radian opMul(const radian &in) const", WRAP_MFN_PR(Radian, operator*,(const Radian&) const, Radian), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
441
442 r = engine->RegisterObjectMethod("radian", "radian &opMulAssign(float)", WRAP_MFN_PR(Radian,operator*=,(float),Radian&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
443
444 r = engine->RegisterObjectMethod("radian", "radian opDiv(float) const", WRAP_MFN_PR(Radian, operator/,(float) const, Radian), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
445
446 // NOTE: mirrors the native binding, which maps opDivAssign to operator*= (!)
447 r = engine->RegisterObjectMethod("radian", "radian &opDivAssign(float)", WRAP_MFN_PR(Radian,operator*=,(float),Radian&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
448
449 r = engine->RegisterObjectMethod("radian", "int opCmp(const radian &in) const", WRAP_OBJ_FIRST(RadianCmp), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
450
451 r = engine->RegisterObjectMethod("radian", "bool opEquals(const radian &in) const", WRAP_MFN_PR(Radian, operator==,(const Radian&) const, bool), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
452
453 // Register the object methods
454 r = engine->RegisterObjectMethod("radian", "float valueDegrees() const", WRAP_MFN(Radian,valueDegrees), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
455 r = engine->RegisterObjectMethod("radian", "float valueRadians() const", WRAP_MFN(Radian,valueRadians), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
456 r = engine->RegisterObjectMethod("radian", "float valueAngleUnits() const", WRAP_MFN(Radian,valueAngleUnits), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
457}
458
459static void registerOgreDegreeGeneric(AngelScript::asIScriptEngine* engine)
460{
461 int r;
462
463 // Register the object constructors
464 r = engine->RegisterObjectBehaviour("degree", asBEHAVE_CONSTRUCT, "void f()", WRAP_OBJ_LAST(DegreeDefaultConstructor), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
465 r = engine->RegisterObjectBehaviour("degree", asBEHAVE_CONSTRUCT, "void f(float)", WRAP_OBJ_LAST(DegreeInitConstructor), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
466 r = engine->RegisterObjectBehaviour("degree", asBEHAVE_CONSTRUCT, "void f(const degree &in)", WRAP_OBJ_LAST(DegreeCopyConstructor), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
467
468 // Register the object operators
469 r = engine->RegisterObjectMethod("degree", "degree &opAssign(const degree &in)", WRAP_MFN_PR(Degree, operator =, (const Degree &), Degree&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
470 r = engine->RegisterObjectMethod("degree", "degree &opAssign(float)", WRAP_OBJ_FIRST(DegreeAssignFloat), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
471 r = engine->RegisterObjectMethod("degree", "degree &opAssign(const radian &in)", WRAP_MFN_PR(Degree, operator =, (const Radian &), Degree&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
472
473 r = engine->RegisterObjectMethod("degree", "degree opAdd() const", WRAP_OBJ_FIRST(DegreeOpAddUnary), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
474 r = engine->RegisterObjectMethod("degree", "degree opAdd(const degree &in) const", WRAP_MFN_PR(Degree, operator+,(const Degree&) const, Degree), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
475 r = engine->RegisterObjectMethod("degree", "degree opAdd(const radian &in) const", WRAP_MFN_PR(Degree, operator+,(const Radian&) const, Degree), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
476
477 r = engine->RegisterObjectMethod("degree", "degree &opAddAssign(const degree &in)", WRAP_MFN_PR(Degree,operator+=,(const Degree &),Degree&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
478 r = engine->RegisterObjectMethod("degree", "degree &opAddAssign(const radian &in)", WRAP_MFN_PR(Degree,operator+=,(const Radian &),Degree&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
479
480 r = engine->RegisterObjectMethod("degree", "degree opSub() const", WRAP_MFN_PR(Degree, operator-,() const, Degree), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
481 r = engine->RegisterObjectMethod("degree", "degree opSub(const degree &in) const", WRAP_MFN_PR(Degree, operator-,(const Degree&) const, Degree), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
482 r = engine->RegisterObjectMethod("degree", "degree opSub(const radian &in) const", WRAP_MFN_PR(Degree, operator-,(const Radian&) const, Degree), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
483
484 r = engine->RegisterObjectMethod("degree", "degree &opSubAssign(const degree &in)", WRAP_MFN_PR(Degree,operator-=,(const Degree &),Degree&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
485 r = engine->RegisterObjectMethod("degree", "degree &opSubAssign(const radian &in)", WRAP_MFN_PR(Degree,operator-=,(const Radian &),Degree&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
486
487 r = engine->RegisterObjectMethod("degree", "degree opMul(float) const", WRAP_MFN_PR(Degree, operator*,(float) const, Degree), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
488 r = engine->RegisterObjectMethod("degree", "degree opMul(const degree &in) const", WRAP_MFN_PR(Degree, operator*,(const Degree&) const, Degree), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
489
490 r = engine->RegisterObjectMethod("degree", "degree &opMulAssign(float)", WRAP_MFN_PR(Degree,operator*=,(float),Degree&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
491
492 r = engine->RegisterObjectMethod("degree", "degree opDiv(float) const", WRAP_MFN_PR(Degree, operator/,(float) const, Degree), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
493
494 // NOTE: mirrors the native binding, which maps opDivAssign to operator*= (!)
495 r = engine->RegisterObjectMethod("degree", "degree &opDivAssign(float)", WRAP_MFN_PR(Degree,operator*=,(float),Degree&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
496
497 r = engine->RegisterObjectMethod("degree", "int opCmp(const degree &in) const", WRAP_OBJ_FIRST(DegreeCmp), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
498
499 r = engine->RegisterObjectMethod("degree", "bool opEquals(const degree &in) const", WRAP_MFN_PR(Degree, operator==,(const Degree&) const, bool), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
500
501 // Register the object methods
502 r = engine->RegisterObjectMethod("degree", "float valueRadians() const", WRAP_MFN(Degree,valueRadians), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
503 r = engine->RegisterObjectMethod("degree", "float valueDegrees() const", WRAP_MFN(Degree,valueDegrees), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
504 r = engine->RegisterObjectMethod("degree", "float valueAngleUnits() const", WRAP_MFN(Degree,valueAngleUnits), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
505}
506
507static void registerOgreQuaternionGeneric(AngelScript::asIScriptEngine* engine)
508{
509 int r;
510
511 // Register the object constructors
512 r = engine->RegisterObjectBehaviour("quaternion", asBEHAVE_CONSTRUCT, "void f()", WRAP_OBJ_LAST(QuaternionDefaultConstructor), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
513 r = engine->RegisterObjectBehaviour("quaternion", asBEHAVE_CONSTRUCT, "void f(const radian &in, const vector3 &in)", WRAP_OBJ_LAST(QuaternionInitConstructor1), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
514 r = engine->RegisterObjectBehaviour("quaternion", asBEHAVE_CONSTRUCT, "void f(float, float, float, float)", WRAP_OBJ_LAST(QuaternionInitConstructor2), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
515 r = engine->RegisterObjectBehaviour("quaternion", asBEHAVE_CONSTRUCT, "void f(const vector3 &in, const vector3 &in, const vector3 &in)", WRAP_OBJ_LAST(QuaternionInitConstructor3), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
516 r = engine->RegisterObjectBehaviour("quaternion", asBEHAVE_CONSTRUCT, "void f(float)", WRAP_OBJ_LAST(QuaternionInitConstructorScaler), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
517 r = engine->RegisterObjectBehaviour("quaternion", asBEHAVE_CONSTRUCT, "void f(const quaternion &in)", WRAP_OBJ_LAST(QuaternionCopyConstructor), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
518
519 // Register the object operators
520 r = engine->RegisterObjectMethod("quaternion", "float opIndex(int) const", WRAP_OBJ_FIRST(QuaternionOpIndex), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
521 r = engine->RegisterObjectMethod("quaternion", "quaternion &opAssign(const quaternion &in)", WRAP_MFN_PR(Quaternion, operator =, (const Quaternion &), Quaternion&), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
522 r = engine->RegisterObjectMethod("quaternion", "quaternion opAdd(const quaternion &in) const", WRAP_MFN_PR(Quaternion, operator+,(const Quaternion&) const, Quaternion), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
523 r = engine->RegisterObjectMethod("quaternion", "quaternion opSub(const quaternion &in) const", WRAP_MFN_PR(Quaternion, operator-,(const Quaternion&) const, Quaternion), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
524 r = engine->RegisterObjectMethod("quaternion", "quaternion opMul(const quaternion &in) const", WRAP_MFN_PR(Quaternion, operator*,(const Quaternion&) const, Quaternion), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
525 r = engine->RegisterObjectMethod("quaternion", "quaternion opMul(float) const", WRAP_MFN_PR(Quaternion, operator*,(float) const, Quaternion), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
526 r = engine->RegisterObjectMethod("quaternion", "quaternion opSub() const", WRAP_MFN_PR(Quaternion, operator-,() const, Quaternion), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
527 r = engine->RegisterObjectMethod("quaternion", "bool opEquals(const quaternion &in) const", WRAP_MFN_PR(Quaternion, operator==,(const Quaternion&) const, bool), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
528 r = engine->RegisterObjectMethod("quaternion", "vector3 opMul(const vector3 &in) const", WRAP_MFN_PR(Quaternion, operator*,(const Vector3&) const, Vector3), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
529
530 // Register the object methods
531 r = engine->RegisterObjectMethod("quaternion", "float Dot(const quaternion &in) const", WRAP_MFN(Quaternion,Dot), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
532 r = engine->RegisterObjectMethod("quaternion", "float Norm() const", WRAP_MFN(Quaternion,Norm), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
533 r = engine->RegisterObjectMethod("quaternion", "float normalise()", WRAP_MFN(Quaternion,normalise), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
534 r = engine->RegisterObjectMethod("quaternion", "quaternion Inverse() const", WRAP_MFN(Quaternion,Inverse), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
535 r = engine->RegisterObjectMethod("quaternion", "quaternion UnitInverse() const", WRAP_MFN(Quaternion,UnitInverse), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
536 r = engine->RegisterObjectMethod("quaternion", "quaternion Exp() const", WRAP_MFN(Quaternion,Exp), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
537 r = engine->RegisterObjectMethod("quaternion", "quaternion Log() const", WRAP_MFN(Quaternion,Log), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
538 r = engine->RegisterObjectMethod("quaternion", "radian getRoll(bool reprojectAxis = true) const", WRAP_MFN(Quaternion,getRoll), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
539 r = engine->RegisterObjectMethod("quaternion", "radian getPitch(bool reprojectAxis = true) const", WRAP_MFN(Quaternion,getPitch), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
540 r = engine->RegisterObjectMethod("quaternion", "radian getYaw(bool reprojectAxis = true) const", WRAP_MFN(Quaternion,getYaw), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
541 r = engine->RegisterObjectMethod("quaternion", "bool equals(const quaternion &in, const radian &in) const", WRAP_MFN(Quaternion,equals), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
542 r = engine->RegisterObjectMethod("quaternion", "bool isNaN() const", WRAP_MFN(Quaternion,isNaN), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
543
544 // Register some static methods
545 r = engine->RegisterGlobalFunction("quaternion Slerp(float, const quaternion &in, const quaternion &in, bool &in)", WRAP_FN_PR(Quaternion::Slerp,(Real fT, const Quaternion&, const Quaternion&, bool), Quaternion), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
546 r = engine->RegisterGlobalFunction("quaternion SlerpExtraSpins(float, const quaternion &in, const quaternion &in, int &in)", WRAP_FN(Quaternion::SlerpExtraSpins), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
547 r = engine->RegisterGlobalFunction("void Intermediate(const quaternion &in, const quaternion &in, const quaternion &in, const quaternion &in, const quaternion &in)", WRAP_FN(Quaternion::Intermediate), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
548 r = engine->RegisterGlobalFunction("quaternion Squad(float, const quaternion &in, const quaternion &in, const quaternion &in, const quaternion &in, bool &in)", WRAP_FN(Quaternion::Squad), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
549 r = engine->RegisterGlobalFunction("quaternion nlerp(float, const quaternion &in, const quaternion &in, bool &in)", WRAP_FN(Quaternion::nlerp), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
550}
551
552static void registerOgreColourValueGeneric(AngelScript::asIScriptEngine* engine)
553{
554 int r;
555
556 // Register the object constructors
557 r = engine->RegisterObjectBehaviour("color", asBEHAVE_CONSTRUCT, "void f()", WRAP_OBJ_LAST(ColourValueDefaultConstructor), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
558 r = engine->RegisterObjectBehaviour("color", asBEHAVE_CONSTRUCT, "void f(float r, float g, float b, float a)", WRAP_OBJ_LAST(ColourValueInitConstructor), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
559 r = engine->RegisterObjectBehaviour("color", asBEHAVE_CONSTRUCT, "void f(const color &other)", WRAP_OBJ_LAST(ColourValueCopyConstructor), asCALL_GENERIC);
560}
561
562static void registerOgreBoxGeneric(AngelScript::asIScriptEngine* engine)
563{
564 int r;
565
566 // Register the object constructors
567 r = engine->RegisterObjectBehaviour("box", asBEHAVE_CONSTRUCT, "void f()", WRAP_OBJ_LAST(BoxDefaultConstructor), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
568 r = engine->RegisterObjectBehaviour("box", asBEHAVE_CONSTRUCT, "void f(uint32 l, uint32 t, uint32 r, uint32 b)", WRAP_OBJ_LAST(BoxInitConstructor), asCALL_GENERIC); ROR_ASSERT( r >= 0 );
569 r = engine->RegisterObjectBehaviour("box", asBEHAVE_CONSTRUCT, "void f(const box &other)", WRAP_OBJ_LAST(BoxCopyConstructor), asCALL_GENERIC);
570
571 // Register other behaviors
572 r = engine->RegisterObjectBehaviour("box", asBEHAVE_DESTRUCT, "void f()", WRAP_OBJ_LAST(BoxDestructor), asCALL_GENERIC); ROR_ASSERT(r >= 0);
573 r = engine->RegisterObjectMethod("box", "box& opAssign(const box&in)", WRAP_OBJ_LAST(BoxAssignOperator), asCALL_GENERIC); ROR_ASSERT(r >= 0);
574}
575
576static void registerOgreTextureGeneric(AngelScript::asIScriptEngine* engine)
577{
578 int r;
579 r = engine->SetDefaultNamespace("Ogre"); ROR_ASSERT(r >= 0);
580
581 r = engine->RegisterObjectBehaviour("TexturePtr", asBEHAVE_CONSTRUCT, "void f()", WRAP_OBJ_LAST(TexturePtrDefaultConstructor), asCALL_GENERIC); ROR_ASSERT(r >= 0);
582 r = engine->RegisterObjectBehaviour("TexturePtr", asBEHAVE_CONSTRUCT, "void f(const TexturePtr&in)", WRAP_OBJ_LAST(TexturePtrCopyConstructor), asCALL_GENERIC); ROR_ASSERT(r >= 0);
583 r = engine->RegisterObjectBehaviour("TexturePtr", asBEHAVE_DESTRUCT, "void f()", WRAP_OBJ_LAST(TexturePtrDestructor), asCALL_GENERIC); ROR_ASSERT(r >= 0);
584 r = engine->RegisterObjectMethod("TexturePtr", "TexturePtr& opAssign(const TexturePtr&in)", WRAP_OBJ_LAST(TexturePtrAssignOperator), asCALL_GENERIC); ROR_ASSERT(r >= 0);
585 r = engine->RegisterObjectMethod("TexturePtr", "bool isNull()", WRAP_OBJ_LAST(TexturePtrIsNull), asCALL_GENERIC); ROR_ASSERT(r >= 0);
586
587 // Wrappers are inevitable, see https://www.gamedev.net/forums/topic/540419-custom-smartpointers-and-angelscript-/
588 r = engine->RegisterObjectMethod("TexturePtr", "string getName() const", WRAP_OBJ_FIRST(TexturePtrGetName), asCALL_GENERIC); ROR_ASSERT(r >= 0);
589 r = engine->RegisterObjectMethod("TexturePtr", "uint getWidth()", WRAP_OBJ_FIRST(TexturePtrGetWidth), asCALL_GENERIC); ROR_ASSERT(r >= 0);
590 r = engine->RegisterObjectMethod("TexturePtr", "uint getHeight()", WRAP_OBJ_FIRST(TexturePtrGetHeight), asCALL_GENERIC); ROR_ASSERT(r >= 0);
591 r = engine->RegisterObjectMethod("TexturePtr", "uint getNumMipmaps()", WRAP_OBJ_FIRST(TexturePtrGetNumMipmaps), asCALL_GENERIC); ROR_ASSERT(r >= 0);
592 r = engine->RegisterObjectMethod("TexturePtr", "HardwarePixelBufferPtr getBuffer(uint, uint)", WRAP_OBJ_FIRST(TexturePtrGetBuffer), asCALL_GENERIC); ROR_ASSERT(r >= 0);
593
594 r = engine->SetDefaultNamespace(""); ROR_ASSERT(r >= 0);
595}
596
597static void registerOgreTextureManagerGeneric(AngelScript::asIScriptEngine * engine)
598{
599 int r;
600 r = engine->SetDefaultNamespace("Ogre"); ROR_ASSERT(r >= 0);
601
602 // Convenience wrapper to omit optional parameters
603 r = engine->RegisterObjectMethod("TextureManager", "TexturePtr load(const string&in file, const string&in rg)", WRAP_OBJ_FIRST(TextureManagerLoad), asCALL_GENERIC); ROR_ASSERT(r >= 0);
604
605 r = engine->SetDefaultNamespace("Ogre::TextureManager"); ROR_ASSERT(r >= 0);
606 r = engine->RegisterGlobalFunction("TextureManager& getSingleton()", WRAP_FN(TextureManager::getSingleton), asCALL_GENERIC); ROR_ASSERT(r >= 0);
607
608 r = engine->SetDefaultNamespace(""); ROR_ASSERT(r >= 0);
609}
610
611template <typename T>
612static void registerOgreMovableObjectBaseGeneric(AngelScript::asIScriptEngine* engine, const char* obj)
613{
614 int r;
615 r = engine->RegisterObjectMethod(obj, "string __getUniqueName() const", WRAP_OBJ_LAST(MovableObjectGetUniqueNameMixin), asCALL_GENERIC); ROR_ASSERT(r >= 0);
616
617 r = engine->RegisterObjectMethod(obj, "const string& getName() const", WRAP_MFN(MovableObject, getName), asCALL_GENERIC); ROR_ASSERT(r >= 0);
618 r = engine->RegisterObjectMethod(obj, "const string& getMovableType() const", WRAP_MFN(MovableObject, getMovableType), asCALL_GENERIC); ROR_ASSERT(r >= 0);
619
620 r = engine->RegisterObjectMethod(obj, "Node@ getParentNode()", WRAP_MFN(MovableObject, getParentNode), asCALL_GENERIC); ROR_ASSERT(r >= 0);
621 r = engine->RegisterObjectMethod(obj, "SceneNode@ getParentSceneNode()", WRAP_MFN(MovableObject, getParentSceneNode), asCALL_GENERIC); ROR_ASSERT(r >= 0);
622 r = engine->RegisterObjectMethod(obj, "bool isParentTagPoint() const", WRAP_MFN(MovableObject, isParentTagPoint), asCALL_GENERIC); ROR_ASSERT(r >= 0);
623 r = engine->RegisterObjectMethod(obj, "bool isAttached() const", WRAP_MFN(MovableObject, isAttached), asCALL_GENERIC); ROR_ASSERT(r >= 0);
624 r = engine->RegisterObjectMethod(obj, "void detachFromParent()", WRAP_MFN(MovableObject, detachFromParent), asCALL_GENERIC); ROR_ASSERT(r >= 0);
625
626 r = engine->RegisterObjectMethod(obj, "bool isInScene() const", WRAP_MFN(MovableObject, isInScene), asCALL_GENERIC); ROR_ASSERT(r >= 0);
627 r = engine->RegisterObjectMethod(obj, "float getBoundingRadius() const", WRAP_MFN(MovableObject, getBoundingRadius), asCALL_GENERIC); ROR_ASSERT(r >= 0);
628
629 r = engine->RegisterObjectMethod(obj, "void setVisible(bool visible)", WRAP_MFN(MovableObject, setVisible), asCALL_GENERIC); ROR_ASSERT(r >= 0);
630 r = engine->RegisterObjectMethod(obj, "bool getVisible() const", WRAP_MFN(MovableObject, getVisible), asCALL_GENERIC); ROR_ASSERT(r >= 0);
631 r = engine->RegisterObjectMethod(obj, "bool isVisible() const", WRAP_MFN(MovableObject, isVisible), asCALL_GENERIC); ROR_ASSERT(r >= 0);
632
633 r = engine->RegisterObjectMethod(obj, "void setRenderingDistance(float dist)", WRAP_MFN(MovableObject, setRenderingDistance), asCALL_GENERIC); ROR_ASSERT(r >= 0);
634 r = engine->RegisterObjectMethod(obj, "float getRenderingDistance() const", WRAP_MFN(MovableObject, getRenderingDistance), asCALL_GENERIC); ROR_ASSERT(r >= 0);
635
636 r = engine->RegisterObjectMethod(obj, "void setRenderingMinPixelSize(float pixelSize)", WRAP_MFN(MovableObject, setRenderingMinPixelSize), asCALL_GENERIC); ROR_ASSERT(r >= 0);
637 r = engine->RegisterObjectMethod(obj, "float getRenderingMinPixelSize() const", WRAP_MFN(MovableObject, getRenderingMinPixelSize), asCALL_GENERIC); ROR_ASSERT(r >= 0);
638
639 r = engine->RegisterObjectMethod(obj, "void setCastShadows(bool enabled)", WRAP_MFN(MovableObject, setCastShadows), asCALL_GENERIC); ROR_ASSERT(r >= 0);
640 r = engine->RegisterObjectMethod(obj, "bool getCastShadows() const", WRAP_MFN(MovableObject, getCastShadows), asCALL_GENERIC); ROR_ASSERT(r >= 0);
641}
642
643static void registerOgreMovableObjectGeneric(AngelScript::asIScriptEngine* engine)
644{
645 int r;
646 r = engine->SetDefaultNamespace("Ogre"); ROR_ASSERT(r >= 0);
647
648 registerOgreMovableObjectBaseGeneric<MovableObject>(engine, "MovableObject");
649
650 r = engine->SetDefaultNamespace(""); ROR_ASSERT(r >= 0);
651}
652
653static void registerOgreEntityGeneric(AngelScript::asIScriptEngine* engine)
654{
655 int r;
656 r = engine->SetDefaultNamespace("Ogre"); ROR_ASSERT(r >= 0);
657
658 r = engine->RegisterObjectMethod("Entity", "void setMaterialName(const string &in name, const string &in rg = \"OgreAutodetect\")", WRAP_MFN(Entity, setMaterialName), asCALL_GENERIC); ROR_ASSERT(r >= 0);
659 r = engine->RegisterObjectMethod("Entity", "AnimationState @getAnimationState(const string &in) const", WRAP_MFN(Entity, getAnimationState), asCALL_GENERIC); ROR_ASSERT(r >= 0);
660 r = engine->RegisterObjectMethod("Entity", "AnimationStateSet @getAllAnimationStates()", WRAP_MFN(Entity, getAllAnimationStates), asCALL_GENERIC); ROR_ASSERT(r >= 0);
661 r = engine->RegisterObjectMethod("Entity", "void setDisplaySkeleton(bool)", WRAP_MFN(Entity, setDisplaySkeleton), asCALL_GENERIC); ROR_ASSERT(r >= 0);
662 r = engine->RegisterObjectMethod("Entity", "bool getDisplaySkeleton() const", WRAP_MFN(Entity, getDisplaySkeleton), asCALL_GENERIC); ROR_ASSERT(r >= 0);
663 r = engine->RegisterObjectMethod("Entity", "uint64 getNumManualLodLevels() const", WRAP_MFN(Entity, getNumManualLodLevels), asCALL_GENERIC); ROR_ASSERT(r >= 0);
664 r = engine->RegisterObjectMethod("Entity", "uint16 getCurrentLodIndex()", WRAP_MFN(Entity, getCurrentLodIndex), asCALL_GENERIC); ROR_ASSERT(r >= 0);
665 r = engine->RegisterObjectMethod("Entity", "Entity @getManualLodLevel(uint64) const", WRAP_MFN(Entity, getManualLodLevel), asCALL_GENERIC); ROR_ASSERT(r >= 0);
666 r = engine->RegisterObjectMethod("Entity", "void setMeshLodBias(float, uint16, uint16)", WRAP_MFN(Entity, setMeshLodBias), asCALL_GENERIC); ROR_ASSERT(r >= 0);
667 r = engine->RegisterObjectMethod("Entity", "void setMaterialLodBias(float, uint16, uint16)", WRAP_MFN(Entity, setMaterialLodBias), asCALL_GENERIC); ROR_ASSERT(r >= 0);
668 r = engine->RegisterObjectMethod("Entity", "SubEntityArray @getSubEntities() const", WRAP_OBJ_FIRST(EntityGetSubEntities), asCALL_GENERIC); ROR_ASSERT(r >= 0);
669 r = engine->RegisterObjectMethod("Entity", "const MeshPtr& getMesh() const", WRAP_MFN(Entity, getMesh), asCALL_GENERIC); ROR_ASSERT(r >= 0);
670
671 registerOgreMovableObjectBaseGeneric<MovableObject>(engine, "Entity");
672
673 r = engine->SetDefaultNamespace(""); ROR_ASSERT(r >= 0);
674}
675
676static void registerOgreSubEntityGeneric(AngelScript::asIScriptEngine* engine)
677{
678 int r;
679 r = engine->SetDefaultNamespace("Ogre"); ROR_ASSERT(r >= 0);
680
681 r = engine->RegisterObjectMethod("SubEntity", "const MaterialPtr& getMaterial() const", WRAP_MFN(SubEntity, getMaterial), asCALL_GENERIC); ROR_ASSERT(r >= 0);
682 r = engine->RegisterObjectMethod("SubEntity", "void setMaterial(const MaterialPtr&in)", WRAP_MFN(SubEntity, setMaterial), asCALL_GENERIC); ROR_ASSERT(r >= 0);
683 r = engine->RegisterObjectMethod("SubEntity", "SubMesh@ getSubMesh()", WRAP_MFN(SubEntity, getSubMesh), asCALL_GENERIC); ROR_ASSERT(r >= 0);
684
685 r = engine->SetDefaultNamespace(""); ROR_ASSERT(r >= 0);
686}
687
688template <typename T>
689static void registerOgreNodeBaseGeneric(AngelScript::asIScriptEngine* engine, const char* obj)
690{
691 int r;
692 r = engine->SetDefaultNamespace("Ogre"); ROR_ASSERT(r >= 0);
693
694 r = engine->RegisterObjectMethod(obj, "const vector3& getPosition() const", WRAP_MFN(T, getPosition), asCALL_GENERIC); ROR_ASSERT(r >= 0);
695 r = engine->RegisterObjectMethod(obj, "void setPosition(const vector3 &in)", WRAP_MFN_PR(Node, setPosition, (const Vector3&), void), asCALL_GENERIC); ROR_ASSERT(r >= 0);
696
697 r = engine->RegisterObjectMethod(obj, "const vector3& getScale() const", WRAP_MFN(T, getScale), asCALL_GENERIC); ROR_ASSERT(r >= 0);
698 r = engine->RegisterObjectMethod(obj, "void setScale(const vector3 &in)", WRAP_MFN_PR(Node, setScale, (const Ogre::Vector3&), void), asCALL_GENERIC); ROR_ASSERT(r >= 0);
699
700 r = engine->RegisterObjectMethod(obj, "const string& getName() const", WRAP_MFN(T, getName), asCALL_GENERIC); ROR_ASSERT(r >= 0);
701 r = engine->RegisterObjectMethod(obj, "Node@ getParent()", WRAP_MFN(T, getParent), asCALL_GENERIC); ROR_ASSERT(r >= 0);
702
703 r = engine->RegisterObjectMethod(obj, "const quaternion& getOrientation() const", WRAP_MFN(T, getOrientation), asCALL_GENERIC); ROR_ASSERT(r >= 0);
704 r = engine->RegisterObjectMethod(obj, "void setOrientation(const quaternion&in)", WRAP_OBJ_FIRST(NodeSetOrientation<T>), asCALL_GENERIC); ROR_ASSERT(r >= 0);
705
706 r = engine->RegisterObjectMethod(obj, "string __getUniqueName() const", WRAP_OBJ_LAST(NodeGetUniqueNameMixin), asCALL_GENERIC); ROR_ASSERT(r >= 0);
707
708 // Not const because we don't want all elements to be const (this isn't the case with raw pointers in C++).
709 r = engine->RegisterObjectMethod(obj, "ChildNodeArray@ getChildren()", WRAP_OBJ_LAST(NodeGetChildren), asCALL_GENERIC); ROR_ASSERT(r >= 0);
710
711 r = engine->SetDefaultNamespace(""); ROR_ASSERT(r >= 0);
712}
713
714static void registerOgreNodeGeneric(AngelScript::asIScriptEngine* engine)
715{
716 int r;
717 r = engine->SetDefaultNamespace("Ogre"); ROR_ASSERT(r >= 0);
718
719 registerOgreNodeBaseGeneric<Node>(engine, "Node");
720
721 r = engine->SetDefaultNamespace(""); ROR_ASSERT(r >= 0);
722}
723
724static void registerOgreSceneNodeGeneric(AngelScript::asIScriptEngine* engine)
725{
726 int r;
727 r = engine->SetDefaultNamespace("Ogre"); ROR_ASSERT(r >= 0);
728
729 r = engine->RegisterObjectMethod("SceneNode", "void attachObject(MovableObject@ obj)", WRAP_MFN_PR(SceneNode, attachObject, (MovableObject*), void), asCALL_GENERIC); ROR_ASSERT(r >= 0);
730 r = engine->RegisterObjectMethod("SceneNode", "MovableObject@ getAttachedObject(const string& in)", WRAP_MFN_PR(SceneNode, getAttachedObject, (const String&), MovableObject*), asCALL_GENERIC); ROR_ASSERT(r >= 0);
731 r = engine->RegisterObjectMethod("SceneNode", "MovableObject@ detachObject(uint16)", WRAP_MFN_PR(SceneNode, detachObject, (uint16), MovableObject*), asCALL_GENERIC); ROR_ASSERT(r >= 0);
732 r = engine->RegisterObjectMethod("SceneNode", "void detachObject(MovableObject@ obj)", WRAP_MFN_PR(SceneNode, detachObject, (MovableObject*), void), asCALL_GENERIC); ROR_ASSERT(r >= 0);
733 r = engine->RegisterObjectMethod("SceneNode", "MovableObject@ detachObject(const string& in)", WRAP_MFN_PR(SceneNode, detachObject, (const String&), MovableObject*), asCALL_GENERIC); ROR_ASSERT(r >= 0);
734 r = engine->RegisterObjectMethod("SceneNode", "void detachAllObjects()", WRAP_MFN(SceneNode, detachAllObjects), asCALL_GENERIC); ROR_ASSERT(r >= 0);
735 r = engine->RegisterObjectMethod("SceneNode", "bool isInSceneGraph() const", WRAP_MFN(SceneNode, isInSceneGraph), asCALL_GENERIC); ROR_ASSERT(r >= 0);
736 r = engine->RegisterObjectMethod("SceneNode", "SceneManager@ getCreator() const", WRAP_MFN(SceneNode, getCreator), asCALL_GENERIC); ROR_ASSERT(r >= 0);
737 r = engine->RegisterObjectMethod("SceneNode", "void removeAndDestroyChild(const string& in)", WRAP_MFN_PR(SceneNode, removeAndDestroyChild, (const String&), void), asCALL_GENERIC); ROR_ASSERT(r >= 0);
738 r = engine->RegisterObjectMethod("SceneNode", "void removeAndDestroyChild(uint16)", WRAP_MFN_PR(SceneNode, removeAndDestroyChild, (uint16), void), asCALL_GENERIC); ROR_ASSERT(r >= 0);
739 r = engine->RegisterObjectMethod("SceneNode", "void removeAndDestroyChild(SceneNode@)", WRAP_MFN_PR(SceneNode, removeAndDestroyChild, (SceneNode*), void), asCALL_GENERIC); ROR_ASSERT(r >= 0);
740 r = engine->RegisterObjectMethod("SceneNode", "void removeAndDestroyAllChildren()", WRAP_MFN(SceneNode, removeAndDestroyAllChildren), asCALL_GENERIC); ROR_ASSERT(r >= 0);
741 r = engine->RegisterObjectMethod("SceneNode", "void showBoundingBox(bool bShow)", WRAP_MFN(SceneNode, showBoundingBox), asCALL_GENERIC); ROR_ASSERT(r >= 0);
742 r = engine->RegisterObjectMethod("SceneNode", "void hideBoundingBox(bool bHide)", WRAP_MFN(SceneNode, hideBoundingBox), asCALL_GENERIC); ROR_ASSERT(r >= 0);
743 r = engine->RegisterObjectMethod("SceneNode", "bool getShowBoundingBox() const", WRAP_MFN(SceneNode, getShowBoundingBox), asCALL_GENERIC); ROR_ASSERT(r >= 0);
744 r = engine->RegisterObjectMethod("SceneNode", "SceneNode@ createChildSceneNode(const string& in name, const vector3& in translate = vector3(0.f, 0.f, 0.f), const quaternion& in rotate = quaternion())", WRAP_MFN_PR(SceneNode, createChildSceneNode, (const String&, const Vector3&, const Quaternion&), SceneNode*), asCALL_GENERIC); ROR_ASSERT(r >= 0);
745 r = engine->RegisterObjectMethod("SceneNode", "void setFixedYawAxis(bool useFixed, const vector3& in fixedAxis = vector3(0.f, 1.f, 0.f))", WRAP_MFN(SceneNode, setFixedYawAxis), asCALL_GENERIC); ROR_ASSERT(r >= 0);
746 r = engine->RegisterObjectMethod("SceneNode", "void yaw(const radian& in angle, TransformSpace relativeTo = Ogre::TS_LOCAL)", WRAP_MFN(SceneNode, yaw), asCALL_GENERIC); ROR_ASSERT(r >= 0);
747 r = engine->RegisterObjectMethod("SceneNode", "void setDirection(const vector3& in vec, TransformSpace relativeTo = Ogre::TS_LOCAL, const vector3& in localDirectionVector = vector3(0.f, 0.f, -1.f))", WRAP_MFN_PR(SceneNode, setDirection, (const Vector3&, Node::TransformSpace, const Vector3&), void), asCALL_GENERIC); ROR_ASSERT(r >= 0);
748 r = engine->RegisterObjectMethod("SceneNode", "SceneNode@ getParentSceneNode() const", WRAP_MFN(SceneNode, getParentSceneNode), asCALL_GENERIC); ROR_ASSERT(r >= 0);
749 // Not const because we don't want all elements to be const (this isn't the case with raw pointers in C++).
750 r = engine->RegisterObjectMethod("SceneNode", "MovableObjectArray@ getAttachedObjects()", WRAP_OBJ_LAST(SceneNodeGetAttachedObjects), asCALL_GENERIC); ROR_ASSERT(r >= 0);
751 r = engine->RegisterObjectMethod("SceneNode", "void lookAt(const vector3 &in, TransformSpace, const vector3 &in = vector3(0,0,-1))", WRAP_MFN_PR(SceneNode, lookAt, (const Vector3&, Node::TransformSpace, const Vector3&), void), asCALL_GENERIC);
752 r = engine->RegisterObjectMethod("SceneNode", "void setAutoTracking(bool, SceneNode@, const vector3 &in = vector3(0,0,-1), const vector3 &in = vector3())", WRAP_MFN_PR(SceneNode, setAutoTracking, (bool, SceneNode* const, const Vector3&, const Vector3&), void), asCALL_GENERIC);
753 r = engine->RegisterObjectMethod("SceneNode", "SceneNode@ getAutoTrackTarget()", WRAP_MFN_PR(SceneNode, getAutoTrackTarget, (), SceneNode*), asCALL_GENERIC); ROR_ASSERT(r >= 0);
754 r = engine->RegisterObjectMethod("SceneNode", "const vector3& getAutoTrackOffset()", WRAP_MFN_PR(SceneNode, getAutoTrackOffset, (), const Vector3&), asCALL_GENERIC); ROR_ASSERT(r >= 0);
755 r = engine->RegisterObjectMethod("SceneNode", "const vector3& getAutoTrackLocalDirection()", WRAP_MFN_PR(SceneNode, getAutoTrackLocalDirection, (), const Vector3&), asCALL_GENERIC); ROR_ASSERT(r >= 0);
756 r = engine->RegisterObjectMethod("SceneNode", "SceneNode@ getParentSceneNode()", WRAP_MFN_PR(SceneNode, getParentSceneNode, () const, SceneNode*), asCALL_GENERIC); ROR_ASSERT(r >= 0);
757 r = engine->RegisterObjectMethod("SceneNode", "void setVisible(bool, bool cascade = true)", WRAP_MFN_PR(SceneNode, setVisible, (bool, bool), void), asCALL_GENERIC); ROR_ASSERT(r >= 0);
758 r = engine->RegisterObjectMethod("SceneNode", "void flipVisibility(bool = true)", WRAP_MFN_PR(SceneNode, flipVisibility, (bool), void), asCALL_GENERIC); ROR_ASSERT(r >= 0);
759 r = engine->RegisterObjectMethod("SceneNode", "void setDebugDisplayEnabled(bool, bool cascade = true)", WRAP_MFN_PR(SceneNode, setDebugDisplayEnabled, (bool, bool), void), asCALL_GENERIC); ROR_ASSERT(r >= 0);
760
761 registerOgreNodeBaseGeneric<SceneNode>(engine, "SceneNode");
762
763 r = engine->SetDefaultNamespace(""); ROR_ASSERT(r >= 0);
764}
765
766static void registerOgreSceneManagerGeneric(AngelScript::asIScriptEngine* engine)
767{
768 int r;
769 r = engine->SetDefaultNamespace("Ogre"); ROR_ASSERT(r >= 0);
770
771 r = engine->RegisterObjectMethod("SceneManager", "const string& getName() const", WRAP_MFN(SceneManager, getName), asCALL_GENERIC); ROR_ASSERT(r >= 0);
772
773 r = engine->RegisterObjectMethod("SceneManager", "array<MovableObject@>@ __getMovableObjectsByType(const string&in typeName)", WRAP_OBJ_FIRST(SceneManager__getMovableObjectsByType), asCALL_GENERIC); ROR_ASSERT(r >= 0);
774
775 // Entities
776 r = engine->RegisterObjectMethod("SceneManager", "Entity@ createEntity(const string&in ent_name, const string &in mesh_name, const string &in mesh_rg = \"OgreAutodetect\")", WRAP_OBJ_FIRST(SceneManagerCreateEntity), asCALL_GENERIC); ROR_ASSERT(r >= 0);
777 r = engine->RegisterObjectMethod("SceneManager", "void destroyEntity(Entity@)", WRAP_MFN_PR(SceneManager, destroyEntity, (Entity*), void), asCALL_GENERIC); ROR_ASSERT(r >= 0);
778 r = engine->RegisterObjectMethod("SceneManager", "void destroyEntity(const string &in)", WRAP_MFN_PR(SceneManager, destroyEntity, (const Ogre::String&), void), asCALL_GENERIC); ROR_ASSERT(r >= 0);
779
780 // Scene nodes
781 r = engine->RegisterObjectMethod("SceneManager", "SceneNode@ getRootSceneNode()", WRAP_MFN(SceneManager, getRootSceneNode), asCALL_GENERIC); ROR_ASSERT(r >= 0);
782 r = engine->RegisterObjectMethod("SceneManager", "void destroySceneNode(SceneNode@)", WRAP_MFN_PR(SceneManager, destroySceneNode, (SceneNode*), void), asCALL_GENERIC); ROR_ASSERT(r >= 0);
783 r = engine->RegisterObjectMethod("SceneManager", "void destroySceneNode(const string &in)", WRAP_MFN_PR(SceneManager, destroySceneNode, (const Ogre::String&), void), asCALL_GENERIC); ROR_ASSERT(r >= 0);
784
785 // Ambient light
786 r = engine->RegisterObjectMethod("SceneManager", "const color& getAmbientLight() const", WRAP_MFN(SceneManager, getAmbientLight), asCALL_GENERIC); ROR_ASSERT(r >= 0);
787 r = engine->RegisterObjectMethod("SceneManager", "void setAmbientLight(const color &in)", WRAP_MFN_PR(SceneManager, setAmbientLight, (const ColourValue&), void), asCALL_GENERIC); ROR_ASSERT(r >= 0);
788
789 // ManualObject:
790 r = engine->RegisterObjectMethod("SceneManager", "ManualObject@ createManualObject(const string &in)", WRAP_MFN_PR(SceneManager, createManualObject, (const Ogre::String&), Ogre::ManualObject*), asCALL_GENERIC); ROR_ASSERT(r >= 0);
791 r = engine->RegisterObjectMethod("SceneManager", "ManualObject@ getManualObject(const string &in)", WRAP_MFN_PR(SceneManager, getManualObject, (const Ogre::String&) const, Ogre::ManualObject*), asCALL_GENERIC); ROR_ASSERT(r >= 0);
792 r = engine->RegisterObjectMethod("SceneManager", "void destroyManualObject(const string &in)", WRAP_MFN_PR(SceneManager, destroyManualObject, (const Ogre::String&), void), asCALL_GENERIC); ROR_ASSERT(r >= 0);
793 r = engine->RegisterObjectMethod("SceneManager", "void destroyManualObject(ManualObject@)", WRAP_MFN_PR(SceneManager, destroyManualObject, (Ogre::ManualObject*), void), asCALL_GENERIC); ROR_ASSERT(r >= 0);
794
795 r = engine->SetDefaultNamespace(""); ROR_ASSERT(r >= 0);
796}
797
798static void registerOgreRootGeneric(AngelScript::asIScriptEngine* engine)
799{
800 int r;
801 r = engine->SetDefaultNamespace("Ogre"); ROR_ASSERT(r >= 0);
802
803 r = engine->RegisterObjectMethod("Root", "SceneManagerInstanceDict@ getSceneManagers()", WRAP_OBJ_LAST(RootGetSceneManagers), asCALL_GENERIC);
804
805 r = engine->SetDefaultNamespace("Ogre::Root");
806 r = engine->RegisterGlobalFunction("Root& getSingleton()", WRAP_FN(Root::getSingleton), asCALL_GENERIC);
807
808 r = engine->SetDefaultNamespace(""); ROR_ASSERT(r >= 0);
809}
810
811static void registerOgreAnimationStateGeneric(AngelScript::asIScriptEngine* engine)
812{
813 int r;
814 r = engine->SetDefaultNamespace("Ogre"); ROR_ASSERT(r >= 0);
815
816 // Register the getters and setters
817 r = engine->RegisterObjectMethod("AnimationState", "const string& getAnimationName() const", WRAP_MFN(AnimationState, getAnimationName), asCALL_GENERIC); ROR_ASSERT(r >= 0);
818 r = engine->RegisterObjectMethod("AnimationState", "float getTimePosition() const", WRAP_MFN(AnimationState, getTimePosition), asCALL_GENERIC); ROR_ASSERT(r >= 0);
819 r = engine->RegisterObjectMethod("AnimationState", "void setTimePosition(float)", WRAP_MFN(AnimationState, setTimePosition), asCALL_GENERIC); ROR_ASSERT(r >= 0);
820 r = engine->RegisterObjectMethod("AnimationState", "float getLength() const", WRAP_MFN(AnimationState, getLength), asCALL_GENERIC); ROR_ASSERT(r >= 0);
821 r = engine->RegisterObjectMethod("AnimationState", "void setLength(float)", WRAP_MFN(AnimationState, setLength), asCALL_GENERIC); ROR_ASSERT(r >= 0);
822 r = engine->RegisterObjectMethod("AnimationState", "float getWeight() const", WRAP_MFN(AnimationState, getWeight), asCALL_GENERIC); ROR_ASSERT(r >= 0);
823 r = engine->RegisterObjectMethod("AnimationState", "void setWeight(float)", WRAP_MFN(AnimationState, setWeight), asCALL_GENERIC); ROR_ASSERT(r >= 0);
824 r = engine->RegisterObjectMethod("AnimationState", "void addTime(float)", WRAP_MFN(AnimationState, addTime), asCALL_GENERIC); ROR_ASSERT(r >= 0);
825 r = engine->RegisterObjectMethod("AnimationState", "bool hasEnded() const", WRAP_MFN(AnimationState, hasEnded), asCALL_GENERIC); ROR_ASSERT(r >= 0);
826 r = engine->RegisterObjectMethod("AnimationState", "bool getEnabled() const", WRAP_MFN(AnimationState, getEnabled), asCALL_GENERIC); ROR_ASSERT(r >= 0);
827 r = engine->RegisterObjectMethod("AnimationState", "void setEnabled(bool)", WRAP_MFN(AnimationState, setEnabled), asCALL_GENERIC); ROR_ASSERT(r >= 0);
828 r = engine->RegisterObjectMethod("AnimationState", "void setLoop(bool)", WRAP_MFN(AnimationState, setLoop), asCALL_GENERIC); ROR_ASSERT(r >= 0);
829 r = engine->RegisterObjectMethod("AnimationState", "bool getLoop() const", WRAP_MFN(AnimationState, getLoop), asCALL_GENERIC); ROR_ASSERT(r >= 0);
830 r = engine->RegisterObjectMethod("AnimationState", "AnimationStateSet@ getParent()", WRAP_MFN(AnimationState, getParent), asCALL_GENERIC); ROR_ASSERT(r >= 0);
831 r = engine->RegisterObjectMethod("AnimationState", "void createBlendMask(uint blendMaskSizeHint, float initialWeight = 1.0f)", WRAP_OBJ_FIRST(AnimationStateCreateBlendMask), asCALL_GENERIC); ROR_ASSERT(r >= 0);
832 r = engine->RegisterObjectMethod("AnimationState", "void destroyBlendMask()", WRAP_MFN(AnimationState, destroyBlendMask), asCALL_GENERIC); ROR_ASSERT(r >= 0);
833 r = engine->RegisterObjectMethod("AnimationState", "bool hasBlendMask() const", WRAP_MFN(AnimationState, hasBlendMask), asCALL_GENERIC); ROR_ASSERT(r >= 0);
834 r = engine->RegisterObjectMethod("AnimationState", "void setBlendMaskEntry(uint boneHandle, float weight)", WRAP_OBJ_FIRST(AnimationStateSetBlendMaskEntry), asCALL_GENERIC); ROR_ASSERT(r >= 0);
835 r = engine->RegisterObjectMethod("AnimationState", "float getBlendMaskEntry(uint boneHandle)", WRAP_OBJ_FIRST(AnimationStateGetBlendMaskEntry), asCALL_GENERIC); ROR_ASSERT(r >= 0);
836
837 r = engine->SetDefaultNamespace(""); ROR_ASSERT(r >= 0);
838}
839
840static void registerOgreAnimationStateSetGeneric(AngelScript::asIScriptEngine* engine)
841{
842 int r;
843 r = engine->SetDefaultNamespace("Ogre"); ROR_ASSERT(r >= 0);
844
845 r = engine->RegisterObjectMethod("AnimationStateSet", "AnimationState@ createAnimationState(const string& in, float, float, float = 1.0f, bool = false)", WRAP_MFN(AnimationStateSet, createAnimationState), asCALL_GENERIC); ROR_ASSERT(r >= 0);
846 r = engine->RegisterObjectMethod("AnimationStateSet", "AnimationState@ getAnimationState(const string& in) const", WRAP_MFN(AnimationStateSet, getAnimationState), asCALL_GENERIC); ROR_ASSERT(r >= 0);
847 r = engine->RegisterObjectMethod("AnimationStateSet", "bool hasAnimationState(const string& in) const", WRAP_MFN(AnimationStateSet, hasAnimationState), asCALL_GENERIC); ROR_ASSERT(r >= 0);
848 r = engine->RegisterObjectMethod("AnimationStateSet", "void removeAnimationState(const string& in)", WRAP_MFN(AnimationStateSet, removeAnimationState), asCALL_GENERIC); ROR_ASSERT(r >= 0);
849 r = engine->RegisterObjectMethod("AnimationStateSet", "void removeAllAnimationStates()", WRAP_MFN(AnimationStateSet, removeAllAnimationStates), asCALL_GENERIC); ROR_ASSERT(r >= 0);
850 r = engine->RegisterObjectMethod("AnimationStateSet", "AnimationStateDict@ getAnimationStates()", WRAP_OBJ_LAST(AnimationStateSetGetAnimationStates), asCALL_GENERIC); ROR_ASSERT(r >= 0);
851
852 r = engine->SetDefaultNamespace(""); ROR_ASSERT(r >= 0);
853}
854
855static void registerOgreOverlayElementGeneric(AngelScript::asIScriptEngine* engine)
856{
857 int r;
858 r = engine->SetDefaultNamespace("Ogre"); ROR_ASSERT(r >= 0);
859
860 // Register the OverlayElement class
861 // (order roughly matches OgreOverlayElement.h)
862 r = engine->RegisterObjectMethod("OverlayElement", "const string& getName() const", WRAP_MFN(Ogre::OverlayElement, getName), asCALL_GENERIC); ROR_ASSERT(r >= 0);
863 // > visibility
864 r = engine->RegisterObjectMethod("OverlayElement", "void show()", WRAP_MFN(Ogre::OverlayElement, show), asCALL_GENERIC); ROR_ASSERT(r >= 0);
865 r = engine->RegisterObjectMethod("OverlayElement", "void hide()", WRAP_MFN(Ogre::OverlayElement, hide), asCALL_GENERIC); ROR_ASSERT(r >= 0);
866 r = engine->RegisterObjectMethod("OverlayElement", "bool isVisible() const", WRAP_MFN(Ogre::OverlayElement, isVisible), asCALL_GENERIC); ROR_ASSERT(r >= 0);
867 // > positioning
868 r = engine->RegisterObjectMethod("OverlayElement", "void setPosition(float, float)", WRAP_MFN(Ogre::OverlayElement, setPosition), asCALL_GENERIC); ROR_ASSERT(r >= 0);
869 r = engine->RegisterObjectMethod("OverlayElement", "void setDimensions(float, float)", WRAP_MFN(Ogre::OverlayElement, setDimensions), asCALL_GENERIC); ROR_ASSERT(r >= 0);
870 r = engine->RegisterObjectMethod("OverlayElement", "float getLeft() const", WRAP_MFN(Ogre::OverlayElement, getLeft), asCALL_GENERIC); ROR_ASSERT(r >= 0);
871 r = engine->RegisterObjectMethod("OverlayElement", "float getTop() const", WRAP_MFN(Ogre::OverlayElement, getTop), asCALL_GENERIC); ROR_ASSERT(r >= 0);
872 r = engine->RegisterObjectMethod("OverlayElement", "float getWidth() const", WRAP_MFN(Ogre::OverlayElement, getWidth), asCALL_GENERIC); ROR_ASSERT(r >= 0);
873 r = engine->RegisterObjectMethod("OverlayElement", "float getHeight() const", WRAP_MFN(Ogre::OverlayElement, getHeight), asCALL_GENERIC); ROR_ASSERT(r >= 0);
874 r = engine->RegisterObjectMethod("OverlayElement", "void setLeft(float)", WRAP_MFN(Ogre::OverlayElement, setLeft), asCALL_GENERIC); ROR_ASSERT(r >= 0);
875 r = engine->RegisterObjectMethod("OverlayElement", "void setTop(float)", WRAP_MFN(Ogre::OverlayElement, setTop), asCALL_GENERIC); ROR_ASSERT(r >= 0);
876 r = engine->RegisterObjectMethod("OverlayElement", "void setWidth(float)", WRAP_MFN(Ogre::OverlayElement, setWidth), asCALL_GENERIC); ROR_ASSERT(r >= 0);
877 r = engine->RegisterObjectMethod("OverlayElement", "void setHeight(float)", WRAP_MFN(Ogre::OverlayElement, setHeight), asCALL_GENERIC); ROR_ASSERT(r >= 0);
878 // > material
879 r = engine->RegisterObjectMethod("OverlayElement", "const string& getMaterialName() const", WRAP_MFN(Ogre::OverlayElement, getMaterialName), asCALL_GENERIC); ROR_ASSERT(r >= 0);
880 r = engine->RegisterObjectMethod("OverlayElement", "void setMaterialName(const string&in, const string&in)", WRAP_MFN(Ogre::OverlayElement, setMaterialName), asCALL_GENERIC); ROR_ASSERT(r >= 0);
881 // > caption
882 r = engine->RegisterObjectMethod("OverlayElement", "void setCaption(const string&in)", WRAP_MFN(Ogre::OverlayElement, setCaption), asCALL_GENERIC); ROR_ASSERT(r >= 0);
883 r = engine->RegisterObjectMethod("OverlayElement", "const string& getCaption() const", WRAP_MFN(Ogre::OverlayElement, getCaption), asCALL_GENERIC); ROR_ASSERT(r >= 0);
884 // > color
885 r = engine->RegisterObjectMethod("OverlayElement", "void setColour(const color&in)", WRAP_MFN(Ogre::OverlayElement, setColour), asCALL_GENERIC); ROR_ASSERT(r >= 0);
886 r = engine->RegisterObjectMethod("OverlayElement", "const color& getColour() const", WRAP_MFN(Ogre::OverlayElement, getColour), asCALL_GENERIC); ROR_ASSERT(r >= 0);
887 // > GuiMetricsMode
888 r = engine->RegisterObjectMethod("OverlayElement", "GuiMetricsMode getMetricsMode() const", WRAP_MFN(Ogre::OverlayElement, getMetricsMode), asCALL_GENERIC); ROR_ASSERT(r >= 0);
889 r = engine->RegisterObjectMethod("OverlayElement", "void setMetricsMode(GuiMetricsMode)", WRAP_MFN(Ogre::OverlayElement, setMetricsMode), asCALL_GENERIC); ROR_ASSERT(r >= 0);
890 // > GuiHorizontalAlignment
891 r = engine->RegisterObjectMethod("OverlayElement", "GuiHorizontalAlignment getHorizontalAlignment() const", WRAP_MFN(Ogre::OverlayElement, getHorizontalAlignment), asCALL_GENERIC); ROR_ASSERT(r >= 0);
892 r = engine->RegisterObjectMethod("OverlayElement", "void setHorizontalAlignment(GuiHorizontalAlignment)", WRAP_MFN(Ogre::OverlayElement, setHorizontalAlignment), asCALL_GENERIC); ROR_ASSERT(r >= 0);
893
894 r = engine->SetDefaultNamespace(""); ROR_ASSERT(r >= 0);
895}
896
897static void registerOgreOverlayGeneric(AngelScript::asIScriptEngine* engine)
898{
899 int r;
900 r = engine->SetDefaultNamespace("Ogre"); ROR_ASSERT(r >= 0);
901
902 // Register the Overlay class
903 // (order roughly matches OgreOverlay.h)
904 r = engine->RegisterObjectMethod("Overlay", "const string& getName() const", WRAP_MFN(Ogre::Overlay, getName), asCALL_GENERIC); ROR_ASSERT(r >= 0);
905 // > z-order
906 r = engine->RegisterObjectMethod("Overlay", "void setZOrder(uint16)", WRAP_MFN(Ogre::Overlay, setZOrder), asCALL_GENERIC); ROR_ASSERT(r >= 0);
907 r = engine->RegisterObjectMethod("Overlay", "uint16 getZOrder()", WRAP_MFN(Ogre::Overlay, getZOrder), asCALL_GENERIC); ROR_ASSERT(r >= 0);
908 // > visibility
909 r = engine->RegisterObjectMethod("Overlay", "bool isVisible() const", WRAP_MFN_PR(Ogre::Overlay, isVisible, () const, bool), asCALL_GENERIC); ROR_ASSERT(r >= 0);
910 r = engine->RegisterObjectMethod("Overlay", "void show()", WRAP_MFN_PR(Ogre::Overlay, show, (), void), asCALL_GENERIC); ROR_ASSERT(r >= 0);
911 r = engine->RegisterObjectMethod("Overlay", "void hide()", WRAP_MFN_PR(Ogre::Overlay, hide, (), void), asCALL_GENERIC); ROR_ASSERT(r >= 0);
912 // > 2D elements
913 r = engine->RegisterObjectMethod("Overlay", "void add2D(OverlayElement@)", WRAP_OBJ_FIRST(OverlayAdd2D), asCALL_GENERIC); ROR_ASSERT(r >= 0);
914 r = engine->RegisterObjectMethod("Overlay", "void remove2D(OverlayElement@)", WRAP_OBJ_FIRST(OverlayRemove2D), asCALL_GENERIC); ROR_ASSERT(r >= 0);
915 // > scrolling
916 r = engine->RegisterObjectMethod("Overlay", "void setScroll(float, float)", WRAP_MFN(Ogre::Overlay, setScroll), asCALL_GENERIC); ROR_ASSERT(r >= 0);
917 r = engine->RegisterObjectMethod("Overlay", "float getScrollX() const", WRAP_MFN(Ogre::Overlay, getScrollX), asCALL_GENERIC); ROR_ASSERT(r >= 0);
918 r = engine->RegisterObjectMethod("Overlay", "float getScrollY() const", WRAP_MFN(Ogre::Overlay, getScrollY), asCALL_GENERIC); ROR_ASSERT(r >= 0);
919 r = engine->RegisterObjectMethod("Overlay", "void scroll(float, float)", WRAP_MFN(Ogre::Overlay, scroll), asCALL_GENERIC); ROR_ASSERT(r >= 0);
920 // > rotating
921 r = engine->RegisterObjectMethod("Overlay", "void setRotate(const radian&in)", WRAP_MFN(Ogre::Overlay, setRotate), asCALL_GENERIC); ROR_ASSERT(r >= 0);
922 r = engine->RegisterObjectMethod("Overlay", "const radian& getRotate() const", WRAP_MFN(Ogre::Overlay, getRotate), asCALL_GENERIC); ROR_ASSERT(r >= 0);
923 r = engine->RegisterObjectMethod("Overlay", "void rotate(const radian&in)", WRAP_MFN(Ogre::Overlay, rotate), asCALL_GENERIC); ROR_ASSERT(r >= 0);
924 // > scaling
925 r = engine->RegisterObjectMethod("Overlay", "void setScale(float, float)", WRAP_MFN(Ogre::Overlay, setScale), asCALL_GENERIC); ROR_ASSERT(r >= 0);
926 r = engine->RegisterObjectMethod("Overlay", "float getScaleX() const", WRAP_MFN(Ogre::Overlay, getScaleX), asCALL_GENERIC); ROR_ASSERT(r >= 0);
927 r = engine->RegisterObjectMethod("Overlay", "float getScaleY() const", WRAP_MFN(Ogre::Overlay, getScaleY), asCALL_GENERIC); ROR_ASSERT(r >= 0);
928 // > 2D elements
929 r = engine->RegisterObjectMethod("Overlay", "array<OverlayElement@>@ get2DElements()", WRAP_OBJ_FIRST(get2DElementsHelper), asCALL_GENERIC); ROR_ASSERT(r >= 0);
930
931 r = engine->SetDefaultNamespace(""); ROR_ASSERT(r >= 0);
932}
933
934static void registerOgreOverlayManagerGeneric(AngelScript::asIScriptEngine* engine)
935{
936 int r;
937 r = engine->SetDefaultNamespace("Ogre"); ROR_ASSERT(r >= 0);
938
939 // Register the OverlayManager class
940 // (order roughly matches OgreOverlayManager.h)
941 // > overlay management
942 r = engine->RegisterObjectMethod("OverlayManager", "Overlay@ create(const string&in)", WRAP_OBJ_FIRST(OverlayManagerCreate), asCALL_GENERIC); ROR_ASSERT(r >= 0);
943 r = engine->RegisterObjectMethod("OverlayManager", "Overlay@ getByName(const string&in)", WRAP_OBJ_FIRST(OverlayManagerGetByName), asCALL_GENERIC); ROR_ASSERT(r >= 0);
944 r = engine->RegisterObjectMethod("OverlayManager", "void destroy(const string&in)", WRAP_OBJ_FIRST(OverlayManagerDestroyByName), asCALL_GENERIC); ROR_ASSERT(r >= 0);
945 r = engine->RegisterObjectMethod("OverlayManager", "void destroy(Overlay@)", WRAP_OBJ_FIRST(OverlayManagerDestroy), asCALL_GENERIC); ROR_ASSERT(r >= 0);
946 r = engine->RegisterObjectMethod("OverlayManager", "void destroyAll()", WRAP_OBJ_FIRST(OverlayManagerDestroyAll), asCALL_GENERIC); ROR_ASSERT(r >= 0);
947 // NOTE: we have `getOverlays()` instead of `getOverlayIterator()`
948 r = engine->RegisterObjectMethod("OverlayManager", "array<Overlay@>@ getOverlays()", WRAP_OBJ_FIRST(OverlayManagerGetOverlays), asCALL_GENERIC); ROR_ASSERT(r >= 0);
949 // > viewport info
950 r = engine->RegisterObjectMethod("OverlayManager", "float getViewportHeight() const", WRAP_MFN(Ogre::OverlayManager, getViewportHeight), asCALL_GENERIC); ROR_ASSERT(r >= 0);
951 r = engine->RegisterObjectMethod("OverlayManager", "float getViewportWidth() const", WRAP_MFN(Ogre::OverlayManager, getViewportWidth), asCALL_GENERIC); ROR_ASSERT(r >= 0);
952 // > overlay element management
953 r = engine->RegisterObjectMethod("OverlayManager", "OverlayElement@ createOverlayElement(const string&in, const string&in, bool=false)", WRAP_OBJ_FIRST(OverlayManagerCreateOverlayElement), asCALL_GENERIC); ROR_ASSERT(r >= 0);
954 r = engine->RegisterObjectMethod("OverlayManager", "OverlayElement@ getOverlayElement(const string&in) const", WRAP_OBJ_FIRST(OverlayManagerGetOverlayElement), asCALL_GENERIC); ROR_ASSERT(r >= 0);
955 r = engine->RegisterObjectMethod("OverlayManager", "bool hasOverlayElement(const string&in) const", WRAP_MFN(Ogre::OverlayManager, hasOverlayElement), asCALL_GENERIC); ROR_ASSERT(r >= 0);
956 r = engine->RegisterObjectMethod("OverlayManager", "void destroyOverlayElement(const string&in, bool isTemplate=false) const", WRAP_OBJ_FIRST(OverlayManagerDestroyOverlayElementByName), asCALL_GENERIC); ROR_ASSERT(r >= 0);
957 r = engine->RegisterObjectMethod("OverlayManager", "void destroyOverlayElement(OverlayElement@, bool isTemplate=false) const", WRAP_OBJ_FIRST(OverlayManagerDestroyOverlayElement), asCALL_GENERIC); ROR_ASSERT(r >= 0);
958 r = engine->RegisterObjectMethod("OverlayManager", "void destroyAllOverlayElements(bool isTemplate=false) const", WRAP_OBJ_FIRST(OverlayManagerDestroyAllOverlayElements), asCALL_GENERIC); ROR_ASSERT(r >= 0);
959 // > template management
960 r = engine->RegisterObjectMethod("OverlayManager", "OverlayElement@ createOverlayElementFromTemplate(const string&in, const string&in, const string&in, bool=false)", WRAP_OBJ_FIRST(OverlayManagerCreateOverlayElementFromTemplate), asCALL_GENERIC); ROR_ASSERT(r >= 0);
961 r = engine->RegisterObjectMethod("OverlayManager", "OverlayElement@ cloneOverlayElementFromTemplate(const string&in, const string&in)", WRAP_OBJ_FIRST(OverlayManagerCloneOverlayElementFromTemplate), asCALL_GENERIC); ROR_ASSERT(r >= 0);
962 // NOTE: we have `getTemplates()` instead of `getTemplateIterator()`
963 r = engine->RegisterObjectMethod("OverlayManager", "array<OverlayElement@>@ getTemplates()", WRAP_OBJ_FIRST(getElementTemplatesHelper), asCALL_GENERIC); ROR_ASSERT(r >= 0);
964 r = engine->RegisterObjectMethod("OverlayManager", "bool isTemplate(const string&in)", WRAP_OBJ_FIRST(OverlayManagerIsTemplate), asCALL_GENERIC); ROR_ASSERT(r >= 0);
965
966 r = engine->SetDefaultNamespace("Ogre::OverlayManager"); ROR_ASSERT(r >= 0);
967 r = engine->RegisterGlobalFunction("OverlayManager& getSingleton()", WRAP_FN(OverlayManager::getSingleton), asCALL_GENERIC); ROR_ASSERT(r >= 0);
968
969 r = engine->SetDefaultNamespace(""); ROR_ASSERT(r >= 0);
970}
971
972static void registerOgreManualObjectGeneric(AngelScript::asIScriptEngine* engine)
973{
974 engine->SetDefaultNamespace("Ogre");
975
976 // Register the ManualObject class
977 engine->RegisterObjectMethod("ManualObject", "void begin(const string&in, RenderOperation, const string&in)", WRAP_MFN_PR(Ogre::ManualObject, begin, (const String&, Ogre::RenderOperation::OperationType, const String&), void), asCALL_GENERIC);
978 engine->RegisterObjectMethod("ManualObject", "void beginUpdate()", WRAP_MFN(Ogre::ManualObject, beginUpdate), asCALL_GENERIC);
979 engine->RegisterObjectMethod("ManualObject", "void position(const vector3&in)", WRAP_MFN_PR(Ogre::ManualObject, position, (const Ogre::Vector3&), void), asCALL_GENERIC);
980 engine->RegisterObjectMethod("ManualObject", "void normal(const vector3&in)", WRAP_MFN_PR(Ogre::ManualObject, normal, (const Ogre::Vector3&), void), asCALL_GENERIC);
981 engine->RegisterObjectMethod("ManualObject", "void textureCoord(float, float)", WRAP_MFN_PR(Ogre::ManualObject, textureCoord, (float, float), void), asCALL_GENERIC);
982 engine->RegisterObjectMethod("ManualObject", "void textureCoord(const vector2&in)", WRAP_MFN_PR(Ogre::ManualObject, textureCoord, (const Ogre::Vector2&), void), asCALL_GENERIC);
983 engine->RegisterObjectMethod("ManualObject", "void textureCoord(const vector3&in)", WRAP_MFN_PR(Ogre::ManualObject, textureCoord, (const Ogre::Vector3&), void), asCALL_GENERIC);
984 engine->RegisterObjectMethod("ManualObject", "void colour(const color&in)", WRAP_MFN_PR(Ogre::ManualObject, colour, (const Ogre::ColourValue&), void), asCALL_GENERIC);
985 engine->RegisterObjectMethod("ManualObject", "void index(uint32)", WRAP_MFN(Ogre::ManualObject, index), asCALL_GENERIC);
986 engine->RegisterObjectMethod("ManualObject", "void end()", WRAP_MFN(Ogre::ManualObject, end), asCALL_GENERIC);
987
988 engine->RegisterObjectMethod("ManualObject", "uint getCurrentVertexCount()", WRAP_MFN(Ogre::ManualObject, getCurrentVertexCount), asCALL_GENERIC);
989 engine->RegisterObjectMethod("ManualObject", "void getCurrentIndexCount()", WRAP_MFN(Ogre::ManualObject, getCurrentIndexCount), asCALL_GENERIC);
990
991 engine->RegisterObjectMethod("ManualObject", "MeshPtr convertToMesh(const string&in name, const string&in group = 'General')", WRAP_MFN(Ogre::ManualObject, convertToMesh), asCALL_GENERIC);
992
993 engine->SetDefaultNamespace("");
994}
995
996static void registerOgreHardwarePixelBufferGeneric(AngelScript::asIScriptEngine* engine)
997{
998 int r;
999 r = engine->SetDefaultNamespace("Ogre"); ROR_ASSERT(r >= 0);
1000
1001 r = engine->RegisterObjectBehaviour("HardwarePixelBufferPtr", asBEHAVE_CONSTRUCT, "void f()", WRAP_OBJ_LAST(HardwarePixelBufferPtrDefaultConstructor), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1002 r = engine->RegisterObjectBehaviour("HardwarePixelBufferPtr", asBEHAVE_CONSTRUCT, "void f(const HardwarePixelBufferPtr&in)", WRAP_OBJ_LAST(HardwarePixelBufferPtrCopyConstructor), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1003 r = engine->RegisterObjectBehaviour("HardwarePixelBufferPtr", asBEHAVE_DESTRUCT, "void f()", WRAP_OBJ_LAST(HardwarePixelBufferPtrDestructor), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1004 r = engine->RegisterObjectMethod("HardwarePixelBufferPtr", "HardwarePixelBufferPtr& opAssign(const HardwarePixelBufferPtr&in)", WRAP_OBJ_LAST(HardwarePixelBufferPtrAssignOperator), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1005
1006 r = engine->RegisterObjectMethod("HardwarePixelBufferPtr", "const PixelBox& getCurrentLock()", WRAP_OBJ_FIRST(HardwarePixelBufferPtrGetCurrentLock), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1007 r = engine->RegisterObjectMethod("HardwarePixelBufferPtr", "const PixelBox& lock(const box& lockbox, HardwareBufferLockOptions opt)", WRAP_OBJ_FIRST(HardwarePixelBufferPtrLock), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1008 r = engine->RegisterObjectMethod("HardwarePixelBufferPtr", "uint getWidth()", WRAP_OBJ_FIRST(HardwarePixelBufferPtrGetWidth), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1009 r = engine->RegisterObjectMethod("HardwarePixelBufferPtr", "uint getHeight()", WRAP_OBJ_FIRST(HardwarePixelBufferPtrGetHeight), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1010 r = engine->RegisterObjectMethod("HardwarePixelBufferPtr", "void blitFromMemory(const PixelBox& src, const box& dst)", WRAP_OBJ_FIRST(HardwarePixelBufferPtrBlitFromMemory), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1011 r = engine->RegisterObjectMethod("HardwarePixelBufferPtr", "void blitToMemory(const box& src, const PixelBox& dst)", WRAP_OBJ_FIRST(HardwarePixelBufferPtrBlitToMemory), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1012 r = engine->RegisterObjectMethod("HardwarePixelBufferPtr", "void unlock()", WRAP_OBJ_FIRST(HardwarePixelBufferPtrUnlock), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1013
1014 engine->SetDefaultNamespace("");
1015}
1016
1017static void registerOgrePixelBoxGeneric(AngelScript::asIScriptEngine* engine)
1018{
1019 int r;
1020 r = engine->SetDefaultNamespace("Ogre"); ROR_ASSERT(r >= 0);
1021
1022 r = engine->RegisterObjectBehaviour("PixelBox", asBEHAVE_CONSTRUCT, "void f()", WRAP_OBJ_LAST(PixelBoxDefaultConstructor), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1023 r = engine->RegisterObjectBehaviour("PixelBox", asBEHAVE_CONSTRUCT, "void f(const PixelBox&in)", WRAP_OBJ_LAST(PixelBoxCopyConstructor), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1024 r = engine->RegisterObjectBehaviour("PixelBox", asBEHAVE_DESTRUCT, "void f()", WRAP_OBJ_LAST(PixelBoxDestructor), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1025 r = engine->RegisterObjectMethod("PixelBox", "PixelBox& opAssign(const PixelBox&in)", WRAP_OBJ_LAST(PixelBoxAssignOperator), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1026
1027 r = engine->RegisterObjectMethod("PixelBox", "color getColourAt(uint32 x, uint32 y, uint32 z)", WRAP_OBJ_FIRST(PixelBoxGetColourAt), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1028 r = engine->RegisterObjectMethod("PixelBox", "void setColourAt(const color& c, uint32 x, uint32 y, uint32 z)", WRAP_OBJ_FIRST(PixelBoxSetColourAt), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1029
1030 // Inherited methods must have wrappers - see AngelScript doc
1031 r = engine->RegisterObjectMethod("PixelBox", "uint getWidth()", WRAP_OBJ_FIRST(PixelBoxGetWidth), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1032 r = engine->RegisterObjectMethod("PixelBox", "uint getHeight()", WRAP_OBJ_FIRST(PixelBoxGetHeight), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1033 r = engine->RegisterObjectMethod("PixelBox", "uint getDepth()", WRAP_OBJ_FIRST(PixelBoxGetDepth), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1034
1035 r = engine->SetDefaultNamespace(""); ROR_ASSERT(r >= 0);
1036}
1037
1038static void registerOgreImageGeneric(AngelScript::asIScriptEngine* engine)
1039{
1040 int r;
1041 r = engine->SetDefaultNamespace("Ogre"); ROR_ASSERT(r >= 0);
1042
1043 r = engine->RegisterObjectBehaviour("Image", asBEHAVE_CONSTRUCT, "void f()", WRAP_OBJ_LAST(ImageDefaultConstructor), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1044 r = engine->RegisterObjectBehaviour("Image", asBEHAVE_CONSTRUCT, "void f(const Image&in)", WRAP_OBJ_LAST(ImageCopyConstructor), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1045 r = engine->RegisterObjectBehaviour("Image", asBEHAVE_DESTRUCT, "void f()", WRAP_OBJ_LAST(ImageDestructor), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1046 r = engine->RegisterObjectMethod("Image", "Image& opAssign(const Image&in)", WRAP_OBJ_LAST(ImageAssignOperator), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1047
1048 r = engine->RegisterObjectMethod("Image", "color getColourAt(uint32 x, uint32 y, uint32 z)", WRAP_OBJ_FIRST(ImageGetColourAt), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1049 r = engine->RegisterObjectMethod("Image", "void setColourAt(const color& c, uint32 x, uint32 y, uint32 z)", WRAP_OBJ_FIRST(ImageSetColourAt), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1050 r = engine->RegisterObjectMethod("Image", "Image& flipAroundX()", WRAP_MFN(Ogre::Image, flipAroundX), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1051 r = engine->RegisterObjectMethod("Image", "Image& flipAroundY()", WRAP_MFN(Ogre::Image, flipAroundY), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1052 r = engine->RegisterObjectMethod("Image", "uint getNumMipmaps()", WRAP_MFN(Ogre::Image, getNumMipmaps), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1053 r = engine->RegisterObjectMethod("Image", "uint getNumFaces()", WRAP_MFN(Ogre::Image, getNumFaces), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1054 r = engine->RegisterObjectMethod("Image", "PixelBox getPixelBox(uint face, uint mipmap)", WRAP_OBJ_FIRST(ImageGetPixelBox), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1055 r = engine->RegisterObjectMethod("Image", "uint getSize()", WRAP_MFN(Ogre::Image, getSize), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1056 r = engine->RegisterObjectMethod("Image", "uint getWidth()", WRAP_MFN(Ogre::Image, getWidth), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1057 r = engine->RegisterObjectMethod("Image", "uint getHeight()", WRAP_MFN(Ogre::Image, getHeight), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1058 r = engine->RegisterObjectMethod("Image", "void resize(uint16 width, uint16 height, ImageFilter filter)", WRAP_MFN(Ogre::Image, resize), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1059
1060 r = engine->SetDefaultNamespace(""); ROR_ASSERT(r >= 0);
1061}
1062
1063static void registerOgreSubMeshGeneric(AngelScript::asIScriptEngine* engine)
1064{
1065 engine->SetDefaultNamespace("Ogre");
1066
1067 // Register the SubMesh class
1068 engine->RegisterObjectMethod("SubMesh", "const string& getMaterialName()", WRAP_MFN(Ogre::SubMesh, getMaterialName), asCALL_GENERIC);
1069 engine->RegisterObjectMethod("SubMesh", "void setMaterialName(const string&in, const string&in)", WRAP_MFN(Ogre::SubMesh, setMaterialName), asCALL_GENERIC);
1070
1071 // > Vertex buffer
1072 engine->RegisterObjectMethod("SubMesh", "array<vector3>@ __getVertexPositions()", WRAP_OBJ_FIRST(SubMesh__getVertexPositions), asCALL_GENERIC);
1073 engine->RegisterObjectMethod("SubMesh", "array<vector2>@ __getVertexTexcoords(uint index)", WRAP_OBJ_FIRST(SubMesh__getVertexTexcoords), asCALL_GENERIC);
1074
1075 // > Index buffer
1076 engine->RegisterObjectMethod("SubMesh", "array<uint16>@ __getIndexBuffer16bit()", WRAP_OBJ_FIRST(SubMesh__getIndexBuffer16bit), asCALL_GENERIC);
1077 engine->RegisterObjectMethod("SubMesh", "array<uint>@ __getIndexBuffer32bit()", WRAP_OBJ_FIRST(SubMesh__getIndexBuffer32bit), asCALL_GENERIC);
1078 engine->RegisterObjectMethod("SubMesh", "IndexType __getIndexType()", WRAP_OBJ_FIRST(SubMesh__getIndexType), asCALL_GENERIC);
1079
1080 engine->SetDefaultNamespace("");
1081}
1082
1083static void registerOgreMeshGeneric(AngelScript::asIScriptEngine* engine)
1084{
1085 int r;
1086 r = engine->SetDefaultNamespace("Ogre"); ROR_ASSERT(r >= 0);
1087
1088 r = engine->RegisterObjectBehaviour("MeshPtr", asBEHAVE_CONSTRUCT, "void f()", WRAP_OBJ_LAST(MeshPtrDefaultConstructor), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1089 r = engine->RegisterObjectBehaviour("MeshPtr", asBEHAVE_CONSTRUCT, "void f(const MeshPtr&in)", WRAP_OBJ_LAST(MeshPtrCopyConstructor), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1090 r = engine->RegisterObjectBehaviour("MeshPtr", asBEHAVE_DESTRUCT, "void f()", WRAP_OBJ_LAST(MeshPtrDestructor), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1091 r = engine->RegisterObjectMethod("MeshPtr", "MeshPtr& opAssign(const MeshPtr&in)", WRAP_OBJ_LAST(MeshPtrAssignOperator), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1092 r = engine->RegisterObjectMethod("MeshPtr", "bool isNull()", WRAP_OBJ_LAST(MeshPtrIsNull), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1093
1094 // Wrappers are inevitable, see https://www.gamedev.net/forums/topic/540419-custom-smartpointers-and-angelscript-/
1095 r = engine->RegisterObjectMethod("MeshPtr", "SubMeshArray@ getSubMeshes()", WRAP_OBJ_FIRST(MeshPtrGetSubmeshes), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1096 r = engine->RegisterObjectMethod("MeshPtr", "string getName()", WRAP_OBJ_FIRST(MeshPtrGetName), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1097 r = engine->RegisterObjectMethod("MeshPtr", "SubMesh@ createSubMesh(const string&in name)", WRAP_OBJ_FIRST(MeshPtrCreateSubMesh), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1098 r = engine->RegisterObjectMethod("MeshPtr", "void destroySubMesh(const string&in name)", WRAP_OBJ_FIRST(MeshPtrDestroySubMesh), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1099
1100 r = engine->SetDefaultNamespace(""); ROR_ASSERT(r >= 0);
1101}
1102
1103static void registerOgreMeshManagerGeneric(AngelScript::asIScriptEngine * engine)
1104{
1105 int r;
1106 r = engine->SetDefaultNamespace("Ogre"); ROR_ASSERT(r >= 0);
1107
1108 r = engine->RegisterObjectMethod("MeshManager", "MeshPtr load(const string&in file, const string&in rg)", WRAP_OBJ_FIRST(MeshManagerLoad), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1109 r = engine->RegisterObjectMethod("MeshManager", "void remove(const string&in file, const string&in rg)", WRAP_OBJ_FIRST(MeshManagerRemove), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1110
1111 r = engine->SetDefaultNamespace("Ogre::MeshManager"); ROR_ASSERT(r >= 0);
1112 r = engine->RegisterGlobalFunction("MeshManager& getSingleton()", WRAP_FN(MeshManager::getSingleton), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1113
1114 r = engine->SetDefaultNamespace(""); ROR_ASSERT(r >= 0);
1115}
1116
1117static void registerOgreMaterialManagerGeneric(AngelScript::asIScriptEngine * engine)
1118{
1119 int r;
1120 r = engine->SetDefaultNamespace("Ogre"); ROR_ASSERT(r >= 0);
1121
1122 r = engine->RegisterObjectMethod("MaterialManager", "MaterialPtr getByName(const string&in file, const string&in rg)", WRAP_OBJ_FIRST(MaterialManagerGetByName), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1123 r = engine->RegisterObjectMethod("MaterialManager", "MaterialPtr create(const string&in file, const string&in rg)", WRAP_OBJ_FIRST(MaterialManagerCreate), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1124
1125 r = engine->SetDefaultNamespace("Ogre::MaterialManager"); ROR_ASSERT(r >= 0);
1126 r = engine->RegisterGlobalFunction("MaterialManager& getSingleton()", WRAP_FN(MaterialManager::getSingleton), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1127
1128 r = engine->SetDefaultNamespace(""); ROR_ASSERT(r >= 0);
1129}
1130
1131static void registerOgreMaterialGeneric(AngelScript::asIScriptEngine* engine)
1132{
1133 int r;
1134 r = engine->SetDefaultNamespace("Ogre"); ROR_ASSERT(r >= 0);
1135
1136 r = engine->RegisterObjectBehaviour("MaterialPtr", asBEHAVE_CONSTRUCT, "void f()", WRAP_OBJ_LAST(MaterialPtrDefaultConstructor), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1137 r = engine->RegisterObjectBehaviour("MaterialPtr", asBEHAVE_CONSTRUCT, "void f(const MaterialPtr&in)", WRAP_OBJ_LAST(MaterialPtrCopyConstructor), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1138 r = engine->RegisterObjectBehaviour("MaterialPtr", asBEHAVE_DESTRUCT, "void f()", WRAP_OBJ_LAST(MaterialPtrDestructor), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1139 r = engine->RegisterObjectMethod("MaterialPtr", "MaterialPtr& opAssign(const MaterialPtr&in)", WRAP_OBJ_LAST(MaterialPtrAssignOperator), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1140 r = engine->RegisterObjectMethod("MaterialPtr", "bool isNull()", WRAP_OBJ_LAST(MaterialPtrIsNull), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1141
1142 // Wrappers are inevitable, see https://www.gamedev.net/forums/topic/540419-custom-smartpointers-and-angelscript-/
1143 r = engine->RegisterObjectMethod("MaterialPtr", "TechniqueArray@ getTechniques()", WRAP_OBJ_FIRST(MaterialPtrGetTechniques), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1144 r = engine->RegisterObjectMethod("MaterialPtr", "string getName()", WRAP_OBJ_FIRST(MaterialPtrGetName), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1145 r = engine->RegisterObjectMethod("MaterialPtr", "Technique@ createTechnique()", WRAP_OBJ_FIRST(MaterialPtrCreateTechnique), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1146 r = engine->RegisterObjectMethod("MaterialPtr", "void removeTechnique(uint16 index)", WRAP_OBJ_FIRST(MaterialPtrRemoveTechnique), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1147
1148 r = engine->SetDefaultNamespace(""); ROR_ASSERT(r >= 0);
1149}
1150
1151static void registerOgreTechniqueGeneric(AngelScript::asIScriptEngine* engine)
1152{
1153 engine->SetDefaultNamespace("Ogre");
1154
1155 engine->RegisterObjectMethod("Technique", "PassArray @getPasses()", WRAP_OBJ_FIRST(TechniqueGetPasses), asCALL_GENERIC);
1156 engine->RegisterObjectMethod("Technique", "Pass @createPass()", WRAP_MFN(Ogre::Technique, createPass), asCALL_GENERIC);
1157 engine->RegisterObjectMethod("Technique", "void removePass(uint16 index)", WRAP_MFN(Ogre::Technique, removePass), asCALL_GENERIC);
1158 engine->RegisterObjectMethod("Technique", "const string& getName() const", WRAP_MFN(Ogre::Technique, getName), asCALL_GENERIC);
1159
1160 engine->SetDefaultNamespace("");
1161}
1162
1163static void registerOgrePassGeneric(AngelScript::asIScriptEngine* engine)
1164{
1165 int r = 0;
1166 engine->SetDefaultNamespace("Ogre");
1167
1168 engine->RegisterObjectMethod("Pass", "const string& getName() const", WRAP_MFN(Ogre::Pass, getName), asCALL_GENERIC);
1169 engine->RegisterObjectMethod("Pass", "TextureUnitStateArray @getTextureUnitStates()", WRAP_OBJ_FIRST(PassGetTextureUnitStates), asCALL_GENERIC);
1170 engine->RegisterObjectMethod("Pass", "void removeTextureUnitState(uint16 index)", WRAP_MFN(Ogre::Pass, removeTextureUnitState), asCALL_GENERIC);
1171
1172 r = engine->RegisterObjectMethod("Pass", "GpuProgramParametersPtr getVertexProgramParameters()", WRAP_OBJ_FIRST(PassGetVertexProgramParameters), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1173 r = engine->RegisterObjectMethod("Pass", "GpuProgramParametersPtr getFragmentProgramParameters()", WRAP_OBJ_FIRST(PassGetFragmentProgramParameters), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1174 r = engine->RegisterObjectMethod("Pass", "GpuProgramParametersPtr getGeometryProgramParameters()", WRAP_OBJ_FIRST(PassGetGeometryProgramParameters), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1175 r = engine->RegisterObjectMethod("Pass", "GpuProgramParametersPtr getTessellationHullProgramParameters()", WRAP_OBJ_FIRST(PassGetTessellationHullProgramParameters), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1176 r = engine->RegisterObjectMethod("Pass", "GpuProgramParametersPtr getTessellationDomainProgramParameters()", WRAP_OBJ_FIRST(PassGetTessellationDomainProgramParameters), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1177 r = engine->RegisterObjectMethod("Pass", "GpuProgramParametersPtr getComputeProgramParameters()", WRAP_OBJ_FIRST(PassGetComputeProgramParameters), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1178
1179 engine->RegisterObjectMethod("Pass", "void setVertexProgramParameters(GpuProgramParametersPtr)", WRAP_MFN(Ogre::Pass, setVertexProgramParameters), asCALL_GENERIC);
1180 engine->RegisterObjectMethod("Pass", "void setFragmentProgramParameters(GpuProgramParametersPtr)", WRAP_MFN(Ogre::Pass, setFragmentProgramParameters), asCALL_GENERIC);
1181 engine->RegisterObjectMethod("Pass", "void setGeometryProgramParameters(GpuProgramParametersPtr)", WRAP_MFN(Ogre::Pass, setGeometryProgramParameters), asCALL_GENERIC);
1182 engine->RegisterObjectMethod("Pass", "void setTessellationHullProgramParameters(GpuProgramParametersPtr)", WRAP_MFN(Ogre::Pass, setTessellationHullProgramParameters), asCALL_GENERIC);
1183 engine->RegisterObjectMethod("Pass", "void setTessellationDomainProgramParameters(GpuProgramParametersPtr)", WRAP_MFN(Ogre::Pass, setTessellationDomainProgramParameters), asCALL_GENERIC);
1184 engine->RegisterObjectMethod("Pass", "void setComputeProgramParameters(GpuProgramParametersPtr)", WRAP_MFN(Ogre::Pass, setComputeProgramParameters), asCALL_GENERIC);
1185
1186 engine->SetDefaultNamespace("");
1187}
1188
1189static void registerOgreTextureUnitStateGeneric(AngelScript::asIScriptEngine* engine)
1190{
1191 engine->SetDefaultNamespace("Ogre");
1192
1193 engine->RegisterObjectMethod("TextureUnitState", "const string& getName() const", WRAP_MFN(Ogre::TextureUnitState, getName), asCALL_GENERIC);
1194 engine->RegisterObjectMethod("TextureUnitState", "void setTexture(const TexturePtr&in)", WRAP_MFN_PR(Ogre::TextureUnitState, setTexture, (const TexturePtr&), void), asCALL_GENERIC);
1195 engine->RegisterObjectMethod("TextureUnitState", "const TexturePtr& _getTexturePtr() const", WRAP_MFN_PR(Ogre::TextureUnitState, _getTexturePtr, (void) const, const TexturePtr&), asCALL_GENERIC);
1196
1197 engine->SetDefaultNamespace("");
1198}
1199
1200static void registerOgreTimerGeneric(AngelScript::asIScriptEngine* engine)
1201{
1202 int r;
1203 r = engine->SetDefaultNamespace("Ogre"); ROR_ASSERT(r >= 0);
1204
1205 r = engine->RegisterObjectBehaviour("Timer", asBEHAVE_CONSTRUCT, "void f()", WRAP_OBJ_LAST(TimerDefaultConstructor), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1206 r = engine->RegisterObjectBehaviour("Timer", asBEHAVE_CONSTRUCT, "void f(const Timer&in)", WRAP_OBJ_LAST(TimerCopyConstructor), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1207 r = engine->RegisterObjectBehaviour("Timer", asBEHAVE_DESTRUCT, "void f()", WRAP_OBJ_LAST(TimerDefaultDestructor), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1208 r = engine->RegisterObjectMethod("Timer", "Timer& opAssign(const Timer&in)", WRAP_OBJ_LAST(TimerAssignOperator), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1209
1210 r = engine->RegisterObjectMethod("Timer", "void reset()", WRAP_MFN(Timer, reset), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1211 r = engine->RegisterObjectMethod("Timer", "uint getMilliseconds()", WRAP_MFN(Timer, getMilliseconds), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1212 r = engine->RegisterObjectMethod("Timer", "uint getMicroseconds()", WRAP_MFN(Timer, getMicroseconds), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1213 r = engine->RegisterObjectMethod("Timer", "uint getMillisecondsCPU()", WRAP_MFN(Timer, getMillisecondsCPU), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1214 r = engine->RegisterObjectMethod("Timer", "uint getMicrosecondsCPU()", WRAP_MFN(Timer, getMicrosecondsCPU), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1215
1216 r = engine->SetDefaultNamespace(""); ROR_ASSERT(r >= 0);
1217}
1218
1219static void registerOgreGpuProgramParametersGeneric(AngelScript::asIScriptEngine* engine)
1220{
1221 int r;
1222
1223 r = engine->SetDefaultNamespace("Ogre"); ROR_ASSERT(r >= 0);
1224
1225 // Note: The `*SharedPtr` is a deprecated alias of `*Ptr` in OGRE 14, but it's not yet present in the version we use.
1226 r = engine->RegisterObjectBehaviour("GpuProgramParametersPtr", asBEHAVE_CONSTRUCT, "void f()", WRAP_OBJ_LAST(GpuProgramParametersPtrDefaultConstructor), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1227 r = engine->RegisterObjectBehaviour("GpuProgramParametersPtr", asBEHAVE_CONSTRUCT, "void f(const GpuProgramParametersPtr&in)", WRAP_OBJ_LAST(GpuProgramParametersPtrCopyConstructor), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1228 r = engine->RegisterObjectBehaviour("GpuProgramParametersPtr", asBEHAVE_DESTRUCT, "void f()", WRAP_OBJ_LAST(GpuProgramParametersPtrDestructor), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1229 r = engine->RegisterObjectMethod("GpuProgramParametersPtr", "GpuProgramParametersPtr& opAssign(const GpuProgramParametersPtr&in)", WRAP_OBJ_LAST(GpuProgramParametersPtrAssignOperator), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1230 r = engine->RegisterObjectMethod("GpuProgramParametersPtr", "bool isNull()", WRAP_OBJ_LAST(GpuProgramParametersPtrIsNull), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1231
1232 // Wrappers are inevitable, see https://www.gamedev.net/forums/topic/540419-custom-smartpointers-and-angelscript-/
1233
1234 // > setConstant (scalar)
1235 r = engine->RegisterObjectMethod("GpuProgramParametersPtr", "void setConstant(uint index, float val)", WRAP_OBJ_FIRST(GpuProgramParametersPtrSetConstantFloat), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1236 r = engine->RegisterObjectMethod("GpuProgramParametersPtr", "void setConstant(uint index, const vector3& val)", WRAP_OBJ_FIRST(GpuProgramParametersPtrSetConstantVector3), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1237 r = engine->RegisterObjectMethod("GpuProgramParametersPtr", "void setConstant(uint index, const vector2& val)", WRAP_OBJ_FIRST(GpuProgramParametersPtrSetConstantVector2), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1238 r = engine->RegisterObjectMethod("GpuProgramParametersPtr", "void setConstant(uint index, const color& val)", WRAP_OBJ_FIRST(GpuProgramParametersPtrSetConstantColourValue), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1239
1240 // > setConstant (vector)
1241 r = engine->RegisterObjectMethod("GpuProgramParametersPtr", "void setConstant(uint index, const array<float>@ vals)", WRAP_OBJ_FIRST(GpuProgramParametersPtrSetConstantFloatArray), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1242 r = engine->RegisterObjectMethod("GpuProgramParametersPtr", "void setConstant(uint index, const array<vector3>@ vals)", WRAP_OBJ_FIRST(GpuProgramParametersPtrSetConstantVector3Array), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1243 r = engine->RegisterObjectMethod("GpuProgramParametersPtr", "void setConstant(uint index, const array<vector2>@ vals)", WRAP_OBJ_FIRST(GpuProgramParametersPtrSetConstantVector2Array), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1244 r = engine->RegisterObjectMethod("GpuProgramParametersPtr", "void setConstant(uint index, const array<color>@ vals)", WRAP_OBJ_FIRST(GpuProgramParametersPtrSetConstantColourValueArray), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1245
1246 // > setNamedConstant (scalar)
1247 r = engine->RegisterObjectMethod("GpuProgramParametersPtr", "void setNamedConstant(const string&in name, float val)", WRAP_OBJ_FIRST(GpuProgramParametersPtrSetNamedConstantFloat), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1248 r = engine->RegisterObjectMethod("GpuProgramParametersPtr", "void setNamedConstant(const string&in name, const vector3& val)", WRAP_OBJ_FIRST(GpuProgramParametersPtrSetNamedConstantVector3), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1249 r = engine->RegisterObjectMethod("GpuProgramParametersPtr", "void setNamedConstant(const string&in name, const vector2& val)", WRAP_OBJ_FIRST(GpuProgramParametersPtrSetNamedConstantVector2), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1250 r = engine->RegisterObjectMethod("GpuProgramParametersPtr", "void setNamedConstant(const string&in name, const color& val)", WRAP_OBJ_FIRST(GpuProgramParametersPtrSetNamedConstantColourValue), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1251
1252 // > setNamedConstant (vector)
1253 r = engine->RegisterObjectMethod("GpuProgramParametersPtr", "void setNamedConstant(const string&in name, const array<float>@ vals)", WRAP_OBJ_FIRST(GpuProgramParametersPtrSetNamedConstantFloatArray), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1254 r = engine->RegisterObjectMethod("GpuProgramParametersPtr", "void setNamedConstant(const string&in name, const array<vector3>@ vals)", WRAP_OBJ_FIRST(GpuProgramParametersPtrSetNamedConstantVector3Array), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1255 r = engine->RegisterObjectMethod("GpuProgramParametersPtr", "void setNamedConstant(const string&in name, const array<vector2>@ vals)", WRAP_OBJ_FIRST(GpuProgramParametersPtrSetNamedConstantVector2Array), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1256 r = engine->RegisterObjectMethod("GpuProgramParametersPtr", "void setNamedConstant(const string&in name, const array<color>@ vals)", WRAP_OBJ_FIRST(GpuProgramParametersPtrSetNamedConstantColourValueArray), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1257
1258 r = engine->RegisterObjectMethod("GpuProgramParametersPtr", "array<string>@ __getNamedConstants()", WRAP_OBJ_FIRST(GpuProgramParametersPtr__getNamedConstants), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1259
1260 r = engine->SetDefaultNamespace(""); ROR_ASSERT(r >= 0);
1261}
1262
1263static void registerOgreLightGeneric(AngelScript::asIScriptEngine* engine)
1264{
1265 int r;
1266 r = engine->SetDefaultNamespace("Ogre"); ROR_ASSERT(r >= 0);
1267
1268 // Type control
1269 r = engine->RegisterObjectMethod("Light", "void setType(LightTypes type)", WRAP_MFN(Ogre::Light, setType), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1270 r = engine->RegisterObjectMethod("Light", "LightTypes getType() const", WRAP_MFN(Ogre::Light, getType), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1271
1272 // Color
1273 r = engine->RegisterObjectMethod("Light", "void setDiffuseColour(float r, float g, float b)", WRAP_MFN_PR(Ogre::Light, setDiffuseColour, (float, float, float), void), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1274 r = engine->RegisterObjectMethod("Light", "void setDiffuseColour(const color&in)", WRAP_MFN_PR(Ogre::Light, setDiffuseColour, (const Ogre::ColourValue&), void), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1275 r = engine->RegisterObjectMethod("Light", "const color& getDiffuseColour() const", WRAP_MFN(Ogre::Light, getDiffuseColour), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1276
1277 r = engine->RegisterObjectMethod("Light", "void setSpecularColour(float r, float g, float b)", WRAP_MFN_PR(Ogre::Light, setSpecularColour, (float, float, float), void), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1278 r = engine->RegisterObjectMethod("Light", "void setSpecularColour(const color&in)", WRAP_MFN_PR(Ogre::Light, setSpecularColour, (const Ogre::ColourValue&), void), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1279 r = engine->RegisterObjectMethod("Light", "const color& getSpecularColour() const", WRAP_MFN(Ogre::Light, getSpecularColour), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1280
1281 // Attenuation
1282 r = engine->RegisterObjectMethod("Light", "void setAttenuation(float range, float constant, float linear, float quadratic)", WRAP_MFN(Ogre::Light, setAttenuation), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1283 r = engine->RegisterObjectMethod("Light", "float getAttenuationRange() const", WRAP_MFN(Ogre::Light, getAttenuationRange), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1284 r = engine->RegisterObjectMethod("Light", "float getAttenuationConstant() const", WRAP_MFN(Ogre::Light, getAttenuationConstant), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1285 r = engine->RegisterObjectMethod("Light", "float getAttenuationLinear() const", WRAP_MFN(Ogre::Light, getAttenuationLinear), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1286 r = engine->RegisterObjectMethod("Light", "float getAttenuationQuadric() const", WRAP_MFN(Ogre::Light, getAttenuationQuadric), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1287
1288 // Position & Direction
1289 r = engine->RegisterObjectMethod("Light", "void setPosition(float x, float y, float z)", WRAP_MFN_PR(Ogre::Light, setPosition, (float, float, float), void), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1290 r = engine->RegisterObjectMethod("Light", "void setPosition(const vector3&in)", WRAP_MFN_PR(Ogre::Light, setPosition, (const Ogre::Vector3&), void), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1291 r = engine->RegisterObjectMethod("Light", "const vector3& getPosition() const", WRAP_MFN(Ogre::Light, getPosition), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1292
1293 r = engine->RegisterObjectMethod("Light", "void setDirection(float x, float y, float z)", WRAP_MFN_PR(Ogre::Light, setDirection, (float, float, float), void), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1294 r = engine->RegisterObjectMethod("Light", "void setDirection(const vector3&in)", WRAP_MFN_PR(Ogre::Light, setDirection, (const Ogre::Vector3&), void), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1295 r = engine->RegisterObjectMethod("Light", "const vector3& getDirection() const", WRAP_MFN(Ogre::Light, getDirection), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1296
1297 // Spotlight parameters
1298 r = engine->RegisterObjectMethod("Light", "void setSpotlightRange(const radian&in innerAngle, const radian&in outerAngle, float falloff = 1.0f)", WRAP_MFN(Ogre::Light, setSpotlightRange), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1299 r = engine->RegisterObjectMethod("Light", "const radian& getSpotlightInnerAngle() const", WRAP_MFN(Ogre::Light, getSpotlightInnerAngle), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1300 r = engine->RegisterObjectMethod("Light", "const radian& getSpotlightOuterAngle() const", WRAP_MFN(Ogre::Light, getSpotlightOuterAngle), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1301 r = engine->RegisterObjectMethod("Light", "float getSpotlightFalloff() const", WRAP_MFN(Ogre::Light, getSpotlightFalloff), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1302
1303 // Power scale
1304 r = engine->RegisterObjectMethod("Light", "void setPowerScale(float power)", WRAP_MFN(Ogre::Light, setPowerScale), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1305 r = engine->RegisterObjectMethod("Light", "float getPowerScale() const", WRAP_MFN(Ogre::Light, getPowerScale), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1306
1307 // Derived direction (useful for attached lights)
1308 r = engine->RegisterObjectMethod("Light", "const vector3& getDerivedPosition() const", WRAP_MFN(Ogre::Light, getDerivedPosition), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1309 r = engine->RegisterObjectMethod("Light", "const vector3& getDerivedDirection() const", WRAP_MFN(Ogre::Light, getDerivedDirection), asCALL_GENERIC); ROR_ASSERT(r >= 0);
1310
1311 // Inherit MovableObject methods
1312 registerOgreMovableObjectBaseGeneric<Ogre::Light>(engine, "Light");
1313
1314 r = engine->SetDefaultNamespace(""); ROR_ASSERT(r >= 0);
1315}
normalise
float normalise()
getRoll
radian getRoll(bool reprojectAxis=true) const
isNaN
bool isNaN() const
Exp
quaternion Exp() const
getYaw
radian getYaw(bool reprojectAxis=true) const
equals
bool equals(const quaternion &in, const radian &in) const
Dot
float Dot(const quaternion &in) const
Log
quaternion Log() const
Norm
float Norm() const
Inverse
quaternion Inverse() const
getPitch
radian getPitch(bool reprojectAxis=true) const
UnitInverse
quaternion UnitInverse() const
Application.h
Central state/object manager and communications hub.
ROR_ASSERT
#define ROR_ASSERT(_EXPR)
Definition Application.h:40
Vector2OpIndex
static float Vector2OpIndex(const Vector2 &self, int i)
Definition OgreAngelscriptGeneric.cpp:60
registerOgreColourValueGeneric
static void registerOgreColourValueGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:552
registerOgreMovableObjectBaseGeneric
static void registerOgreMovableObjectBaseGeneric(AngelScript::asIScriptEngine *engine, const char *obj)
Definition OgreAngelscriptGeneric.cpp:612
registerOgreLightGeneric
static void registerOgreLightGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:1263
registerOgreRootGeneric
static void registerOgreRootGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:798
registerOgreHardwarePixelBufferGeneric
static void registerOgreHardwarePixelBufferGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:996
registerOgreRadianGeneric
static void registerOgreRadianGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:411
registerOgreVector2Generic
static void registerOgreVector2Generic(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:346
registerOgreSceneManagerGeneric
static void registerOgreSceneManagerGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:766
registerOgreSubMeshGeneric
static void registerOgreSubMeshGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:1063
registerOgreMeshGeneric
static void registerOgreMeshGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:1083
PixelBoxSetColourAt
static void PixelBoxSetColourAt(PixelBox &self, const ColourValue &c, asUINT x, asUINT y, asUINT z)
Definition OgreAngelscriptGeneric.cpp:100
registerOgreSubEntityGeneric
static void registerOgreSubEntityGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:676
Vector3OpIndex
static float Vector3OpIndex(const Vector3 &self, int i)
Definition OgreAngelscriptGeneric.cpp:50
registerOgreOverlayManagerGeneric
static void registerOgreOverlayManagerGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:934
registerOgreEntityGeneric
static void registerOgreEntityGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:653
registerOgrePassGeneric
static void registerOgrePassGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:1163
registerOgreTextureGeneric
static void registerOgreTextureGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:576
registerOgreMovableObjectGeneric
static void registerOgreMovableObjectGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:643
DegreeAssignFloat
static Degree & DegreeAssignFloat(Degree &self, float f)
Definition OgreAngelscriptGeneric.cpp:85
registerOgreVector3Generic
static void registerOgreVector3Generic(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:277
registerOgreDegreeGeneric
static void registerOgreDegreeGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:459
Vector2OpAddUnary
static Vector2 Vector2OpAddUnary(const Vector2 &self)
Definition OgreAngelscriptGeneric.cpp:65
registerOgreSceneNodeGeneric
static void registerOgreSceneNodeGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:724
registerOgreQuaternionGeneric
static void registerOgreQuaternionGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:507
registerOgreGpuProgramParametersGeneric
static void registerOgreGpuProgramParametersGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:1219
AnimationStateSetBlendMaskEntry
static void AnimationStateSetBlendMaskEntry(AnimationState *self, asUINT boneHandle, float weight)
Definition OgreAngelscriptGeneric.cpp:125
PixelBoxGetColourAt
static ColourValue PixelBoxGetColourAt(const PixelBox &self, asUINT x, asUINT y, asUINT z)
Definition OgreAngelscriptGeneric.cpp:95
Vector3OpAddUnary
static Vector3 Vector3OpAddUnary(const Vector3 &self)
Definition OgreAngelscriptGeneric.cpp:55
ImageSetColourAt
static void ImageSetColourAt(Image &self, const ColourValue &c, asUINT x, asUINT y, asUINT z)
Definition OgreAngelscriptGeneric.cpp:110
registerOgreMaterialGeneric
static void registerOgreMaterialGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:1131
registerOgreManualObjectGeneric
static void registerOgreManualObjectGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:972
registerOgreTextureUnitStateGeneric
static void registerOgreTextureUnitStateGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:1189
ImageGetPixelBox
static PixelBox ImageGetPixelBox(const Image &self, asUINT face, asUINT mipmap)
Definition OgreAngelscriptGeneric.cpp:115
ImageGetColourAt
static ColourValue ImageGetColourAt(const Image &self, asUINT x, asUINT y, asUINT z)
Definition OgreAngelscriptGeneric.cpp:105
registerOgreTimerGeneric
static void registerOgreTimerGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:1200
ScriptRefCastNoCountGeneric
static void ScriptRefCastNoCountGeneric(asIScriptGeneric *gen)
Definition OgreAngelscriptGeneric.cpp:137
RadianAssignFloat
static Radian & RadianAssignFloat(Radian &self, float f)
Definition OgreAngelscriptGeneric.cpp:75
DegreeOpAddUnary
static Degree DegreeOpAddUnary(const Degree &self)
Definition OgreAngelscriptGeneric.cpp:90
registerOgreMaterialManagerGeneric
static void registerOgreMaterialManagerGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:1117
registerOgreOverlayElementGeneric
static void registerOgreOverlayElementGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:855
registerOgreMeshManagerGeneric
static void registerOgreMeshManagerGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:1103
registerOgreImageGeneric
static void registerOgreImageGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:1038
AnimationStateCreateBlendMask
static void AnimationStateCreateBlendMask(AnimationState *self, asUINT blendMaskSizeHint, float initialWeight)
Definition OgreAngelscriptGeneric.cpp:120
registerOgreAnimationStateSetGeneric
static void registerOgreAnimationStateSetGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:840
AnimationStateGetBlendMaskEntry
static float AnimationStateGetBlendMaskEntry(AnimationState *self, asUINT boneHandle)
Definition OgreAngelscriptGeneric.cpp:130
registerOgreBoxGeneric
static void registerOgreBoxGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:562
registerOgreOverlayGeneric
static void registerOgreOverlayGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:897
RadianOpAddUnary
static Radian RadianOpAddUnary(const Radian &self)
Definition OgreAngelscriptGeneric.cpp:80
registerOgreAnimationStateGeneric
static void registerOgreAnimationStateGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:811
registerOgreTechniqueGeneric
static void registerOgreTechniqueGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:1151
QuaternionOpIndex
static float QuaternionOpIndex(const Quaternion &self, int i)
Definition OgreAngelscriptGeneric.cpp:70
registerOgreNodeGeneric
static void registerOgreNodeGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:714
registerOgreNodeBaseGeneric
static void registerOgreNodeBaseGeneric(AngelScript::asIScriptEngine *engine, const char *obj)
Definition OgreAngelscriptGeneric.cpp:689
registerOgrePixelBoxGeneric
static void registerOgrePixelBoxGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:1017
registerOgreTextureManagerGeneric
static void registerOgreTextureManagerGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:597
OgreAngelscriptWrappers.h
Helper/wrapper functions shared by native (OgreAngelscript.cpp) and generic (OgreAngelscriptGeneric....
WRAP_MFN
#define WRAP_MFN(ClassType, name)
Definition aswrappedcall.h:1566
WRAP_OBJ_FIRST
#define WRAP_OBJ_FIRST(name)
Definition aswrappedcall.h:1568
WRAP_MFN_PR
#define WRAP_MFN_PR(ClassType, name, Parameters, ReturnType)
Definition aswrappedcall.h:1577
WRAP_FN_PR
#define WRAP_FN_PR(name, Parameters, ReturnType)
Definition aswrappedcall.h:1571
WRAP_FN
#define WRAP_FN(name)
Definition aswrappedcall.h:1565
WRAP_OBJ_LAST
#define WRAP_OBJ_LAST(name)
Definition aswrappedcall.h:1569
RoR::CReadonlyScriptArrayView::RegisterReadonlyScriptArrayViewGeneric
static void RegisterReadonlyScriptArrayViewGeneric(AngelScript::asIScriptEngine *engine, const char *decl, const char *value_decl)
Definition ScriptUtils.h:282
RoR::CReadonlyScriptDictView::RegisterReadonlyScriptDictViewGeneric
static void RegisterReadonlyScriptDictViewGeneric(AngelScript::asIScriptEngine *engine, const char *decl, const char *value_decl)
Definition ScriptUtils.h:222
RoR::RegisterOgreObjectsGeneric
void RegisterOgreObjectsGeneric(AngelScript::asIScriptEngine *engine)
Definition OgreAngelscriptGeneric.cpp:183
OgreAngelscriptWrappers::GpuProgramParametersPtrCopyConstructor
static void GpuProgramParametersPtrCopyConstructor(const GpuProgramParametersPtr &other, GpuProgramParametersPtr *self)
Definition OgreAngelscriptWrappers.h:812
OgreAngelscriptWrappers::MaterialPtrGetTechniques
static TechniqueArray * MaterialPtrGetTechniques(const MaterialPtr &self)
Definition OgreAngelscriptWrappers.h:664
OgreAngelscriptWrappers::TexturePtrGetWidth
static Ogre::uint32 TexturePtrGetWidth(TexturePtr const &self)
Definition OgreAngelscriptWrappers.h:249
OgreAngelscriptWrappers::OverlayManagerCloneOverlayElementFromTemplate
static Ogre::OverlayElement * OverlayManagerCloneOverlayElementFromTemplate(Ogre::OverlayManager *self, const std::string &templateName, const std::string &instanceName)
Definition OgreAngelscriptWrappers.h:1125
OgreAngelscriptWrappers::GpuProgramParametersPtrSetConstantFloat
static void GpuProgramParametersPtrSetConstantFloat(GpuProgramParametersPtr const &self, asUINT index, float val)
Definition OgreAngelscriptWrappers.h:835
OgreAngelscriptWrappers::AnimationStateSetGetAnimationStates
static AnimationStateDict * AnimationStateSetGetAnimationStates(AnimationStateSet *self)
Definition OgreAngelscriptWrappers.h:656
OgreAngelscriptWrappers::MeshPtrDefaultConstructor
static void MeshPtrDefaultConstructor(MeshPtr *self)
Definition OgreAngelscriptWrappers.h:409
OgreAngelscriptWrappers::GpuProgramParametersPtrSetConstantColourValueArray
static void GpuProgramParametersPtrSetConstantColourValueArray(GpuProgramParametersPtr const &self, asUINT index, CScriptArray *vals)
Definition OgreAngelscriptWrappers.h:881
OgreAngelscriptWrappers::MaterialPtrCreateTechnique
static Ogre::Technique * MaterialPtrCreateTechnique(MaterialPtr const &self)
Definition OgreAngelscriptWrappers.h:700
OgreAngelscriptWrappers::MaterialPtrAssignOperator
static void MaterialPtrAssignOperator(const MaterialPtr &other, MaterialPtr *self)
Definition OgreAngelscriptWrappers.h:684
OgreAngelscriptWrappers::GpuProgramParametersPtrSetConstantVector2Array
static void GpuProgramParametersPtrSetConstantVector2Array(GpuProgramParametersPtr const &self, asUINT index, CScriptArray *vals)
Definition OgreAngelscriptWrappers.h:874
OgreAngelscriptWrappers::PixelBoxGetWidth
static asUINT PixelBoxGetWidth(const Ogre::PixelBox &self)
Definition OgreAngelscriptWrappers.h:365
OgreAngelscriptWrappers::MaterialPtrDestructor
static void MaterialPtrDestructor(MaterialPtr *self)
Definition OgreAngelscriptWrappers.h:679
OgreAngelscriptWrappers::GpuProgramParametersPtrSetNamedConstantVector3
static void GpuProgramParametersPtrSetNamedConstantVector3(GpuProgramParametersPtr const &self, const std::string &name, const Ogre::Vector3 &val)
Definition OgreAngelscriptWrappers.h:895
OgreAngelscriptWrappers::PassGetComputeProgramParameters
static Ogre::GpuProgramParametersPtr PassGetComputeProgramParameters(Ogre::Pass *self)
Definition OgreAngelscriptWrappers.h:771
OgreAngelscriptWrappers::ImageCopyConstructor
static void ImageCopyConstructor(const Image &other, Image *self)
Definition OgreAngelscriptWrappers.h:386
OgreAngelscriptWrappers::TexturePtrGetBuffer
static HardwarePixelBufferSharedPtr TexturePtrGetBuffer(TexturePtr const &self, asUINT face, asUINT mipmap)
Definition OgreAngelscriptWrappers.h:264
OgreAngelscriptWrappers::SubMesh__getVertexTexcoords
static AngelScript::CScriptArray * SubMesh__getVertexTexcoords(SubMesh *self, asUINT index)
Definition OgreAngelscriptWrappers.h:499
OgreAngelscriptWrappers::OverlayManagerIsTemplate
static bool OverlayManagerIsTemplate(Ogre::OverlayManager *self, const std::string &name)
Definition OgreAngelscriptWrappers.h:1131
OgreAngelscriptWrappers::MeshPtrAssignOperator
static void MeshPtrAssignOperator(const MeshPtr &other, MeshPtr *self)
Definition OgreAngelscriptWrappers.h:424
OgreAngelscriptWrappers::ImageDefaultConstructor
static void ImageDefaultConstructor(Image *self)
Definition OgreAngelscriptWrappers.h:381
OgreAngelscriptWrappers::MeshPtrCopyConstructor
static void MeshPtrCopyConstructor(const MeshPtr &other, MeshPtr *self)
Definition OgreAngelscriptWrappers.h:414
OgreAngelscriptWrappers::MeshPtrIsNull
static bool MeshPtrIsNull(MeshPtr *self)
Definition OgreAngelscriptWrappers.h:429
OgreAngelscriptWrappers::NodeGetChildren
static ChildNodeArray * NodeGetChildren(Ogre::Node *self)
Definition OgreAngelscriptWrappers.h:613
OgreAngelscriptWrappers::BoxDestructor
static void BoxDestructor(Box *self)
Definition OgreAngelscriptWrappers.h:207
OgreAngelscriptWrappers::Vector2DefaultConstructor
static void Vector2DefaultConstructor(Vector2 *self)
Definition OgreAngelscriptWrappers.h:71
OgreAngelscriptWrappers::PassGetGeometryProgramParameters
static Ogre::GpuProgramParametersPtr PassGetGeometryProgramParameters(Ogre::Pass *self)
Definition OgreAngelscriptWrappers.h:753
OgreAngelscriptWrappers::HardwarePixelBufferPtrGetWidth
static asUINT HardwarePixelBufferPtrGetWidth(HardwarePixelBufferSharedPtr const &self)
Definition OgreAngelscriptWrappers.h:313
OgreAngelscriptWrappers::EntityGetSubEntities
static SubEntityArray * EntityGetSubEntities(Entity *self)
Definition OgreAngelscriptWrappers.h:780
OgreAngelscriptWrappers::HardwarePixelBufferPtrBlitFromMemory
static void HardwarePixelBufferPtrBlitFromMemory(HardwarePixelBufferSharedPtr const &self, const PixelBox &src, const Box &dstBox)
Definition OgreAngelscriptWrappers.h:325
OgreAngelscriptWrappers::PixelBoxCopyConstructor
static void PixelBoxCopyConstructor(const PixelBox &other, PixelBox *self)
Definition OgreAngelscriptWrappers.h:349
OgreAngelscriptWrappers::OverlayAdd2D
static void OverlayAdd2D(Ogre::Overlay *self, Ogre::OverlayElement *elem)
Definition OgreAngelscriptWrappers.h:1007
OgreAngelscriptWrappers::SubMesh__getIndexBuffer16bit
static CScriptArray * SubMesh__getIndexBuffer16bit(Ogre::SubMesh *self)
Definition OgreAngelscriptWrappers.h:596
OgreAngelscriptWrappers::PassGetTessellationDomainProgramParameters
static Ogre::GpuProgramParametersPtr PassGetTessellationDomainProgramParameters(Ogre::Pass *self)
Definition OgreAngelscriptWrappers.h:765
OgreAngelscriptWrappers::BoxCopyConstructor
static void BoxCopyConstructor(const Box &other, Box *self)
Definition OgreAngelscriptWrappers.h:202
OgreAngelscriptWrappers::RadianInitConstructor
static void RadianInitConstructor(float r, Radian *self)
Definition OgreAngelscriptWrappers.h:103
OgreAngelscriptWrappers::ImageDestructor
static void ImageDestructor(PixelBox *self)
Definition OgreAngelscriptWrappers.h:391
OgreAngelscriptWrappers::TexturePtrGetHeight
static Ogre::uint32 TexturePtrGetHeight(TexturePtr const &self)
Definition OgreAngelscriptWrappers.h:254
OgreAngelscriptWrappers::MovableObjectGetUniqueNameMixin
static std::string MovableObjectGetUniqueNameMixin(Ogre::MovableObject *self)
Definition OgreAngelscriptWrappers.h:639
OgreAngelscriptWrappers::OverlayManagerCreateOverlayElementFromTemplate
static Ogre::OverlayElement * OverlayManagerCreateOverlayElementFromTemplate(Ogre::OverlayManager *self, const std::string &templateName, const std::string &typeName, const std::string &instanceName, bool isTemplate)
Definition OgreAngelscriptWrappers.h:1119
OgreAngelscriptWrappers::HardwarePixelBufferPtrLock
static const PixelBox & HardwarePixelBufferPtrLock(HardwarePixelBufferSharedPtr const &self, const Box &lockbox, HardwareBuffer::LockOptions opt)
Definition OgreAngelscriptWrappers.h:307
OgreAngelscriptWrappers::TimerDefaultConstructor
static void TimerDefaultConstructor(Timer *self)
Definition OgreAngelscriptWrappers.h:786
OgreAngelscriptWrappers::PixelBoxDestructor
static void PixelBoxDestructor(PixelBox *self)
Definition OgreAngelscriptWrappers.h:354
OgreAngelscriptWrappers::SceneNodeGetAttachedObjects
static MovableObjectArray * SceneNodeGetAttachedObjects(SceneNode *self)
Definition OgreAngelscriptWrappers.h:633
OgreAngelscriptWrappers::TechniqueGetPasses
static PassArray * TechniqueGetPasses(Technique *self)
Definition OgreAngelscriptWrappers.h:728
OgreAngelscriptWrappers::TexturePtrAssignOperator
static void TexturePtrAssignOperator(const TexturePtr &other, TexturePtr *self)
Definition OgreAngelscriptWrappers.h:233
OgreAngelscriptWrappers::MaterialPtrDefaultConstructor
static void MaterialPtrDefaultConstructor(MaterialPtr *self)
Definition OgreAngelscriptWrappers.h:669
OgreAngelscriptWrappers::MeshPtrDestructor
static void MeshPtrDestructor(MeshPtr *self)
Definition OgreAngelscriptWrappers.h:419
OgreAngelscriptWrappers::MaterialManagerCreate
static MaterialPtr MaterialManagerCreate(MaterialManager &mgr, std::string const &file, std::string const &rg)
Definition OgreAngelscriptWrappers.h:719
OgreAngelscriptWrappers::GpuProgramParametersPtrSetNamedConstantColourValueArray
static void GpuProgramParametersPtrSetNamedConstantColourValueArray(GpuProgramParametersPtr const &self, const std::string &name, CScriptArray *vals)
Definition OgreAngelscriptWrappers.h:935
OgreAngelscriptWrappers::GpuProgramParametersPtrSetNamedConstantVector2Array
static void GpuProgramParametersPtrSetNamedConstantVector2Array(GpuProgramParametersPtr const &self, const std::string &name, CScriptArray *vals)
Definition OgreAngelscriptWrappers.h:928
OgreAngelscriptWrappers::RadianCmp
static int RadianCmp(const Radian &a, const Radian &b)
Definition OgreAngelscriptWrappers.h:108
OgreAngelscriptWrappers::DegreeDefaultConstructor
static void DegreeDefaultConstructor(Degree *self)
Definition OgreAngelscriptWrappers.h:119
OgreAngelscriptWrappers::GpuProgramParametersPtrSetConstantVector3
static void GpuProgramParametersPtrSetConstantVector3(GpuProgramParametersPtr const &self, asUINT index, const Ogre::Vector3 &val)
Definition OgreAngelscriptWrappers.h:841
OgreAngelscriptWrappers::GpuProgramParametersPtrDestructor
static void GpuProgramParametersPtrDestructor(GpuProgramParametersPtr *self)
Definition OgreAngelscriptWrappers.h:817
OgreAngelscriptWrappers::TexturePtrGetName
static Ogre::String TexturePtrGetName(TexturePtr const &self)
Definition OgreAngelscriptWrappers.h:244
OgreAngelscriptWrappers::SceneManager__getMovableObjectsByType
static AngelScript::CScriptArray * SceneManager__getMovableObjectsByType(SceneManager *self, const std::string &typeName)
Definition OgreAngelscriptWrappers.h:958
OgreAngelscriptWrappers::MaterialPtrGetName
static Ogre::String MaterialPtrGetName(MaterialPtr const &self)
Definition OgreAngelscriptWrappers.h:695
OgreAngelscriptWrappers::GpuProgramParametersPtrSetConstantVector2
static void GpuProgramParametersPtrSetConstantVector2(GpuProgramParametersPtr const &self, asUINT index, const Ogre::Vector2 &val)
Definition OgreAngelscriptWrappers.h:847
OgreAngelscriptWrappers::Vector3InitConstructorScaler
static void Vector3InitConstructorScaler(float s, Vector3 *self)
Definition OgreAngelscriptWrappers.h:65
OgreAngelscriptWrappers::Vector2CopyConstructor
static void Vector2CopyConstructor(const Vector2 &other, Vector2 *self)
Definition OgreAngelscriptWrappers.h:76
OgreAngelscriptWrappers::MeshManagerRemove
static void MeshManagerRemove(MeshManager &mgr, std::string const &file, std::string const &rg)
Definition OgreAngelscriptWrappers.h:457
OgreAngelscriptWrappers::Vector3CopyConstructor
static void Vector3CopyConstructor(const Vector3 &other, Vector3 *self)
Definition OgreAngelscriptWrappers.h:55
OgreAngelscriptWrappers::OverlayManagerDestroy
static void OverlayManagerDestroy(Ogre::OverlayManager *self, Ogre::Overlay *ov)
Definition OgreAngelscriptWrappers.h:1069
OgreAngelscriptWrappers::GpuProgramParametersPtrSetNamedConstantColourValue
static void GpuProgramParametersPtrSetNamedConstantColourValue(GpuProgramParametersPtr const &self, const std::string &name, const Ogre::ColourValue &val)
Definition OgreAngelscriptWrappers.h:907
OgreAngelscriptWrappers::PixelBoxDefaultConstructor
static void PixelBoxDefaultConstructor(PixelBox *self)
Definition OgreAngelscriptWrappers.h:344
OgreAngelscriptWrappers::ColourValueDefaultConstructor
static void ColourValueDefaultConstructor(ColourValue *self)
Definition OgreAngelscriptWrappers.h:176
OgreAngelscriptWrappers::RadianCopyConstructor
static void RadianCopyConstructor(const Radian &other, Radian *self)
Definition OgreAngelscriptWrappers.h:98
OgreAngelscriptWrappers::GpuProgramParametersPtrSetConstantVector3Array
static void GpuProgramParametersPtrSetConstantVector3Array(GpuProgramParametersPtr const &self, asUINT index, CScriptArray *vals)
Definition OgreAngelscriptWrappers.h:867
OgreAngelscriptWrappers::ColourValueCopyConstructor
static void ColourValueCopyConstructor(const ColourValue &other, ColourValue *self)
Definition OgreAngelscriptWrappers.h:186
OgreAngelscriptWrappers::TexturePtrDefaultConstructor
static void TexturePtrDefaultConstructor(TexturePtr *self)
Definition OgreAngelscriptWrappers.h:218
OgreAngelscriptWrappers::RootGetSceneManagers
static SceneManagerInstanceDict * RootGetSceneManagers(Root *self)
Definition OgreAngelscriptWrappers.h:648
OgreAngelscriptWrappers::Vector2InitConstructorScaler
static void Vector2InitConstructorScaler(float s, Vector2 *self)
Definition OgreAngelscriptWrappers.h:86
OgreAngelscriptWrappers::PassGetFragmentProgramParameters
static Ogre::GpuProgramParametersPtr PassGetFragmentProgramParameters(Ogre::Pass *self)
Definition OgreAngelscriptWrappers.h:747
OgreAngelscriptWrappers::OverlayManagerGetOverlays
static CScriptArray * OverlayManagerGetOverlays(Ogre::OverlayManager *self)
Definition OgreAngelscriptWrappers.h:1082
OgreAngelscriptWrappers::QuaternionInitConstructor1
static void QuaternionInitConstructor1(const Radian &rfAngle, const Vector3 &rkAxis, Quaternion *self)
Definition OgreAngelscriptWrappers.h:155
OgreAngelscriptWrappers::SubMesh__getIndexBuffer32bit
static CScriptArray * SubMesh__getIndexBuffer32bit(Ogre::SubMesh *self)
Definition OgreAngelscriptWrappers.h:603
OgreAngelscriptWrappers::GpuProgramParametersPtrSetNamedConstantFloat
static void GpuProgramParametersPtrSetNamedConstantFloat(GpuProgramParametersPtr const &self, const std::string &name, float val)
Definition OgreAngelscriptWrappers.h:889
OgreAngelscriptWrappers::PassGetTextureUnitStates
static TextureUnitStateArray * PassGetTextureUnitStates(Pass *self)
Definition OgreAngelscriptWrappers.h:736
OgreAngelscriptWrappers::HardwarePixelBufferPtrGetHeight
static asUINT HardwarePixelBufferPtrGetHeight(HardwarePixelBufferSharedPtr const &self)
Definition OgreAngelscriptWrappers.h:319
OgreAngelscriptWrappers::ImageAssignOperator
static void ImageAssignOperator(const PixelBox &other, PixelBox *self)
Definition OgreAngelscriptWrappers.h:396
OgreAngelscriptWrappers::SceneManagerCreateEntity
static Ogre::Entity * SceneManagerCreateEntity(Ogre::SceneManager *self, const std::string &entityName, const std::string &meshName, const std::string &meshRG)
Definition OgreAngelscriptWrappers.h:1000
OgreAngelscriptWrappers::QuaternionDefaultConstructor
static void QuaternionDefaultConstructor(Quaternion *self)
Definition OgreAngelscriptWrappers.h:145
OgreAngelscriptWrappers::NodeGetUniqueNameMixin
static std::string NodeGetUniqueNameMixin(Ogre::Node *self)
Definition OgreAngelscriptWrappers.h:618
OgreAngelscriptWrappers::GpuProgramParametersPtrIsNull
static bool GpuProgramParametersPtrIsNull(GpuProgramParametersPtr *self)
Definition OgreAngelscriptWrappers.h:827
OgreAngelscriptWrappers::GpuProgramParametersPtrSetConstantColourValue
static void GpuProgramParametersPtrSetConstantColourValue(GpuProgramParametersPtr const &self, asUINT index, const Ogre::ColourValue &val)
Definition OgreAngelscriptWrappers.h:853
OgreAngelscriptWrappers::HardwarePixelBufferPtrCopyConstructor
static void HardwarePixelBufferPtrCopyConstructor(const HardwarePixelBufferSharedPtr &other, HardwarePixelBufferSharedPtr *self)
Definition OgreAngelscriptWrappers.h:284
OgreAngelscriptWrappers::OverlayManagerDestroyAllOverlayElements
static void OverlayManagerDestroyAllOverlayElements(Ogre::OverlayManager *self, bool isTemplate)
Definition OgreAngelscriptWrappers.h:1113
OgreAngelscriptWrappers::BoxAssignOperator
static void BoxAssignOperator(const Box &other, Box *self)
Definition OgreAngelscriptWrappers.h:212
OgreAngelscriptWrappers::TimerAssignOperator
static void TimerAssignOperator(const Timer &other, Timer *self)
Definition OgreAngelscriptWrappers.h:801
OgreAngelscriptWrappers::MaterialPtrIsNull
static bool MaterialPtrIsNull(MaterialPtr *self)
Definition OgreAngelscriptWrappers.h:689
OgreAngelscriptWrappers::TexturePtrIsNull
static bool TexturePtrIsNull(TexturePtr *self)
Definition OgreAngelscriptWrappers.h:238
OgreAngelscriptWrappers::TexturePtrGetNumMipmaps
static Ogre::uint32 TexturePtrGetNumMipmaps(TexturePtr const &self)
Definition OgreAngelscriptWrappers.h:259
OgreAngelscriptWrappers::TextureManagerLoad
static TexturePtr TextureManagerLoad(TextureManager &mgr, std::string const &file, std::string const &rg)
Definition OgreAngelscriptWrappers.h:271
OgreAngelscriptWrappers::HardwarePixelBufferPtrUnlock
static void HardwarePixelBufferPtrUnlock(HardwarePixelBufferSharedPtr const &self)
Definition OgreAngelscriptWrappers.h:337
OgreAngelscriptWrappers::TimerDefaultDestructor
static void TimerDefaultDestructor(Timer *self)
Definition OgreAngelscriptWrappers.h:791
OgreAngelscriptWrappers::OverlayManagerDestroyAll
static void OverlayManagerDestroyAll(Ogre::OverlayManager *self)
Definition OgreAngelscriptWrappers.h:1075
OgreAngelscriptWrappers::QuaternionInitConstructor3
static void QuaternionInitConstructor3(const Vector3 &xaxis, const Vector3 &yaxis, const Vector3 &zaxis, Quaternion *self)
Definition OgreAngelscriptWrappers.h:165
OgreAngelscriptWrappers::BoxInitConstructor
static void BoxInitConstructor(asUINT l, asUINT t, asUINT r, asUINT b, Box *self)
Definition OgreAngelscriptWrappers.h:197
OgreAngelscriptWrappers::PixelBoxAssignOperator
static void PixelBoxAssignOperator(const PixelBox &other, PixelBox *self)
Definition OgreAngelscriptWrappers.h:359
OgreAngelscriptWrappers::OverlayManagerDestroyOverlayElementByName
static void OverlayManagerDestroyOverlayElementByName(Ogre::OverlayManager *self, const std::string &name, bool isTemplate)
Definition OgreAngelscriptWrappers.h:1101
OgreAngelscriptWrappers::GpuProgramParametersPtrSetNamedConstantFloatArray
static void GpuProgramParametersPtrSetNamedConstantFloatArray(GpuProgramParametersPtr const &self, const std::string &name, CScriptArray *vals)
Definition OgreAngelscriptWrappers.h:914
OgreAngelscriptWrappers::getElementTemplatesHelper
static AngelScript::CScriptArray * getElementTemplatesHelper(Ogre::OverlayManager *self)
Definition OgreAngelscriptWrappers.h:1036
OgreAngelscriptWrappers::PassGetTessellationHullProgramParameters
static Ogre::GpuProgramParametersPtr PassGetTessellationHullProgramParameters(Ogre::Pass *self)
Definition OgreAngelscriptWrappers.h:759
OgreAngelscriptWrappers::DegreeInitConstructor
static void DegreeInitConstructor(float r, Degree *self)
Definition OgreAngelscriptWrappers.h:129
OgreAngelscriptWrappers::MeshPtrCreateSubMesh
static Ogre::SubMesh * MeshPtrCreateSubMesh(MeshPtr const &self, const Ogre::String &name)
Definition OgreAngelscriptWrappers.h:440
OgreAngelscriptWrappers::TimerCopyConstructor
static void TimerCopyConstructor(const Timer &other, Timer *self)
Definition OgreAngelscriptWrappers.h:796
OgreAngelscriptWrappers::Vector3InitConstructor
static void Vector3InitConstructor(float x, float y, float z, Vector3 *self)
Definition OgreAngelscriptWrappers.h:60
OgreAngelscriptWrappers::RadianDefaultConstructor
static void RadianDefaultConstructor(Radian *self)
Definition OgreAngelscriptWrappers.h:93
OgreAngelscriptWrappers::MeshPtrGetSubmeshes
static SubMeshArray * MeshPtrGetSubmeshes(const MeshPtr &self)
Definition OgreAngelscriptWrappers.h:404
OgreAngelscriptWrappers::SubMesh__getIndexType
static Ogre::HardwareIndexBuffer::IndexType SubMesh__getIndexType(SubMesh *self)
Definition OgreAngelscriptWrappers.h:536
OgreAngelscriptWrappers::PixelBoxGetDepth
static asUINT PixelBoxGetDepth(const Ogre::PixelBox &self)
Definition OgreAngelscriptWrappers.h:375
OgreAngelscriptWrappers::MaterialPtrRemoveTechnique
static void MaterialPtrRemoveTechnique(MaterialPtr const &self, uint16_t index)
Definition OgreAngelscriptWrappers.h:706
OgreAngelscriptWrappers::Vector2InitConstructor
static void Vector2InitConstructor(float x, float y, Vector2 *self)
Definition OgreAngelscriptWrappers.h:81
OgreAngelscriptWrappers::HardwarePixelBufferPtrDestructor
static void HardwarePixelBufferPtrDestructor(HardwarePixelBufferSharedPtr *self)
Definition OgreAngelscriptWrappers.h:289
OgreAngelscriptWrappers::HardwarePixelBufferPtrBlitToMemory
static void HardwarePixelBufferPtrBlitToMemory(HardwarePixelBufferSharedPtr const &self, const Box &srcBox, const PixelBox &dst)
Definition OgreAngelscriptWrappers.h:331
OgreAngelscriptWrappers::Vector3DefaultConstructor
static void Vector3DefaultConstructor(Vector3 *self)
Definition OgreAngelscriptWrappers.h:50
OgreAngelscriptWrappers::ColourValueInitConstructor
static void ColourValueInitConstructor(float r, float g, float b, float a, ColourValue *self)
Definition OgreAngelscriptWrappers.h:181
OgreAngelscriptWrappers::GpuProgramParametersPtrSetConstantFloatArray
static void GpuProgramParametersPtrSetConstantFloatArray(GpuProgramParametersPtr const &self, asUINT index, CScriptArray *vals)
Definition OgreAngelscriptWrappers.h:860
OgreAngelscriptWrappers::HardwarePixelBufferPtrAssignOperator
static void HardwarePixelBufferPtrAssignOperator(const HardwarePixelBufferSharedPtr &other, HardwarePixelBufferSharedPtr *self)
Definition OgreAngelscriptWrappers.h:294
OgreAngelscriptWrappers::QuaternionInitConstructor2
static void QuaternionInitConstructor2(float w, float x, float y, float z, Quaternion *self)
Definition OgreAngelscriptWrappers.h:160
OgreAngelscriptWrappers::GpuProgramParametersPtrSetNamedConstantVector3Array
static void GpuProgramParametersPtrSetNamedConstantVector3Array(GpuProgramParametersPtr const &self, const std::string &name, CScriptArray *vals)
Definition OgreAngelscriptWrappers.h:921
OgreAngelscriptWrappers::MaterialManagerGetByName
static MaterialPtr MaterialManagerGetByName(MaterialManager &mgr, std::string const &file, std::string const &rg)
Definition OgreAngelscriptWrappers.h:713
OgreAngelscriptWrappers::BoxDefaultConstructor
static void BoxDefaultConstructor(Box *self)
Definition OgreAngelscriptWrappers.h:192
OgreAngelscriptWrappers::OverlayManagerGetOverlayElement
static Ogre::OverlayElement * OverlayManagerGetOverlayElement(Ogre::OverlayManager *self, const std::string &name)
Definition OgreAngelscriptWrappers.h:1095
OgreAngelscriptWrappers::PixelBoxGetHeight
static asUINT PixelBoxGetHeight(const Ogre::PixelBox &self)
Definition OgreAngelscriptWrappers.h:370
OgreAngelscriptWrappers::SubMesh__getVertexPositions
static AngelScript::CScriptArray * SubMesh__getVertexPositions(SubMesh *self)
Definition OgreAngelscriptWrappers.h:464
OgreAngelscriptWrappers::MeshPtrGetName
static Ogre::String MeshPtrGetName(MeshPtr const &self)
Definition OgreAngelscriptWrappers.h:435
OgreAngelscriptWrappers::HardwarePixelBufferPtrDefaultConstructor
static void HardwarePixelBufferPtrDefaultConstructor(HardwarePixelBufferSharedPtr *self)
Definition OgreAngelscriptWrappers.h:279
OgreAngelscriptWrappers::MaterialPtrCopyConstructor
static void MaterialPtrCopyConstructor(const MaterialPtr &other, MaterialPtr *self)
Definition OgreAngelscriptWrappers.h:674
OgreAngelscriptWrappers::PassGetVertexProgramParameters
static Ogre::GpuProgramParametersPtr PassGetVertexProgramParameters(Ogre::Pass *self)
Definition OgreAngelscriptWrappers.h:741
OgreAngelscriptWrappers::OverlayManagerCreateOverlayElement
static Ogre::OverlayElement * OverlayManagerCreateOverlayElement(Ogre::OverlayManager *self, const std::string &type, const std::string &name, bool isTemplate)
Definition OgreAngelscriptWrappers.h:1089
OgreAngelscriptWrappers::MeshManagerLoad
static MeshPtr MeshManagerLoad(MeshManager &mgr, std::string const &file, std::string const &rg)
Definition OgreAngelscriptWrappers.h:451
OgreAngelscriptWrappers::OverlayManagerDestroyOverlayElement
static void OverlayManagerDestroyOverlayElement(Ogre::OverlayManager *self, Ogre::OverlayElement *oe, bool isTemplate)
Definition OgreAngelscriptWrappers.h:1107
OgreAngelscriptWrappers::GpuProgramParametersPtrDefaultConstructor
static void GpuProgramParametersPtrDefaultConstructor(GpuProgramParametersPtr *self)
Definition OgreAngelscriptWrappers.h:807
OgreAngelscriptWrappers::OverlayManagerCreate
static Ogre::Overlay * OverlayManagerCreate(Ogre::OverlayManager *self, const std::string &name)
Definition OgreAngelscriptWrappers.h:1051
OgreAngelscriptWrappers::TexturePtrDestructor
static void TexturePtrDestructor(TexturePtr *self)
Definition OgreAngelscriptWrappers.h:228
OgreAngelscriptWrappers::QuaternionCopyConstructor
static void QuaternionCopyConstructor(const Quaternion &other, Quaternion *self)
Definition OgreAngelscriptWrappers.h:150
OgreAngelscriptWrappers::MeshPtrDestroySubMesh
static void MeshPtrDestroySubMesh(MeshPtr const &self, const Ogre::String &name)
Definition OgreAngelscriptWrappers.h:445
OgreAngelscriptWrappers::OverlayManagerDestroyByName
static void OverlayManagerDestroyByName(Ogre::OverlayManager *self, const std::string &name)
Definition OgreAngelscriptWrappers.h:1063
OgreAngelscriptWrappers::OverlayManagerGetByName
static Ogre::Overlay * OverlayManagerGetByName(Ogre::OverlayManager *self, const std::string &name)
Definition OgreAngelscriptWrappers.h:1057
OgreAngelscriptWrappers::HardwarePixelBufferPtrGetCurrentLock
static const PixelBox & HardwarePixelBufferPtrGetCurrentLock(HardwarePixelBufferSharedPtr const &self)
Definition OgreAngelscriptWrappers.h:301
OgreAngelscriptWrappers::DegreeCmp
static int DegreeCmp(const Degree &a, const Degree &b)
Definition OgreAngelscriptWrappers.h:134
OgreAngelscriptWrappers::GpuProgramParametersPtr__getNamedConstants
static CScriptArray * GpuProgramParametersPtr__getNamedConstants(GpuProgramParametersPtr const &self)
Definition OgreAngelscriptWrappers.h:942
OgreAngelscriptWrappers::DegreeCopyConstructor
static void DegreeCopyConstructor(const Degree &other, Degree *self)
Definition OgreAngelscriptWrappers.h:124
OgreAngelscriptWrappers::TexturePtrCopyConstructor
static void TexturePtrCopyConstructor(const TexturePtr &other, TexturePtr *self)
Definition OgreAngelscriptWrappers.h:223
OgreAngelscriptWrappers::get2DElementsHelper
static AngelScript::CScriptArray * get2DElementsHelper(Ogre::Overlay *self)
Definition OgreAngelscriptWrappers.h:1019
OgreAngelscriptWrappers::QuaternionInitConstructorScaler
static void QuaternionInitConstructorScaler(float s, Quaternion *self)
Definition OgreAngelscriptWrappers.h:170
OgreAngelscriptWrappers::GpuProgramParametersPtrSetNamedConstantVector2
static void GpuProgramParametersPtrSetNamedConstantVector2(GpuProgramParametersPtr const &self, const std::string &name, const Ogre::Vector2 &val)
Definition OgreAngelscriptWrappers.h:901
OgreAngelscriptWrappers::GpuProgramParametersPtrAssignOperator
static void GpuProgramParametersPtrAssignOperator(const GpuProgramParametersPtr &other, GpuProgramParametersPtr *self)
Definition OgreAngelscriptWrappers.h:822
OgreAngelscriptWrappers::OverlayRemove2D
static void OverlayRemove2D(Ogre::Overlay *self, Ogre::OverlayElement *elem)
Definition OgreAngelscriptWrappers.h:1013
Generated on Sun Oct 18 2026 08:40:11 for Rigs of Rods by doxygen 1.9.8