1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
#ifndef AS3UTILITY_H
#define AS3UTILITY_H
#if !defined(SCRIPTINGUTILITY_H)
#error "Don't include AS3Utility.h, include ScriptingUtility.h instead"
#endif
typedef UInt32 AS3Handle;
struct UTF16String;
#include "Runtime/Scripting/Backend/ScriptingTypes.h"
#include "Runtime/Graphics/Transform.h"
#include "Runtime/Scripting/Backend/ScriptingBackendApi.h"
#include "Scripting.h"
using namespace std;
#define htons(A) (A)
#define htonl(A) (A)
#define ntohs htons
#define ntohl htohl
#define SCRIPTINGAPI_THREAD_CHECK(NAME)
#define SCRIPTINGAPI_CONSTRUCTOR_CHECK(NAME)
#define SCRIPTINGAPI_DEFINE_REF_ARG(t, n) t n
#define SCRIPTINGAPI_FIX_REF_ARG(t, n)
extern "C" void Ext_FileContainer_MakeFilesAvailable();
extern "C" int Ext_FileContainer_GetFileLength(const char* filename);
extern "C" char* Ext_Flash_GetNameFromClass(ScriptingType* handle);
extern "C" void Ext_Stack_Store(void* ptr);
extern "C" void Ext_Flash_LogCallstack();
extern "C" void Ext_Flash_ThrowError(const char*) __attribute__((noreturn));
extern "C" int Ext_MarshallTo(ScriptingObjectPtr obj, void* dest);
extern "C" int Ext_UnmarshallFrom(ScriptingObjectPtr obj, void* src);
//extern "C" void Ext_SetNativePtr(ScriptingObjectPtr obj, void* ptr);
//extern "C" void* Ext_GetNativePtr(ScriptingObjectPtr obj);
//ScriptingArray* MonoFindObjectsOfType (ScriptingType* reflectionTypeObject, int mode);
namespace Unity { class GameObject; class Component; }
using namespace Unity;
extern "C" const char* Ext_FileContainer_ReadStringFromFile(const char* filename);
//Used by MonoBehaviourSerialization
extern "C" void Ext_SerializeMonoBehaviour(ScriptingObjectPtr behaviour);
extern "C" UInt8* Ext_DeserializeMonoBehaviour(ScriptingObjectPtr behaviour);
extern "C" void Ext_RemapPPtrs(ScriptingObjectPtr behaviour);
extern "C" ScriptingObjectPtr Ext_Scripting_InstantiateScriptingWrapperForClassWithName(const char* name);
extern "C" bool Ext_FileContainer_IsFileCreatedAt(const char* filename);
extern "C" void Ext_WriteTextAndToolTipIntoUTF16Strings(ScriptingObject* obj, UTF16String* text, UTF16String* tooltip);
extern "C" bool Ext_Trace(const char* msg);
extern "C" ScriptingObjectPtr Ext_GetNewMonoBehaviour(const char* name);
//External interface / openurl / application.
extern "C" void Ext_OpenURL(const char* url);
extern "C" ScriptingString* Ext_ExternalCall(const char* function, ScriptingObjectPtr args);
extern "C" ScriptingObjectPtr Ext_Flash_getProperty(ScriptingObjectPtr object, const char* property);
template<class T>
ScriptingObjectPtr Flash_CreateScriptingObjectFromNativeStruct(ScriptingClass* klass, T& thestruct);
template<class T> inline
ScriptingObjectPtr CreateScriptingObjectFromNativeStruct(ScriptingClass* klass, T& thestruct)
{
//printf_console("creating instance of klass: %d",klass);
ScriptingObjectPtr obj = scripting_object_new(klass);
//printf_console("populating it with native data stored at %d",&thestruct);
Ext_UnmarshallFrom(obj, &thestruct);
return obj;
}
inline void RaiseIfNull(ScriptingObjectPtr o) {}
inline int GetScriptingArraySize(ScriptingArray* a)
{
if(a == NULL)
return 0;
//POD arrays are encoded by the as3 glue as a memoryblob: one int describing the size, following the actual bytes.
return *(int*)(a);
}
extern "C" int Ext_MarshallTo(ScriptingObjectPtr obj, void* dest);
extern "C" int Ext_UnmarshallFrom(ScriptingObjectPtr obj, void* src);
template<class T> inline
void MarshallManagedStructIntoNative(ScriptingObjectPtr so, T* dest)
{
Ext_MarshallTo(so,(void*)dest);
}
template<class T> inline
void MarshallNativeStructIntoManaged(T& src, ScriptingObjectPtr dest)
{
Ext_UnmarshallFrom(dest,(void*)&src);
}
template<class T>
inline T* ScriptingObjectToObject(ScriptingObjectPtr so)
{
//todo: create the optimized path where we directly grab the cachedptr
PPtr<T> p;
p.SetInstanceID(Scripting::GetInstanceIDFromScriptingWrapper(so));
return p;
}
ScriptingObjectPtr ScriptingInstantiateObjectFromClassName(const char* name);
inline
char* ScriptingStringToAllocatedChars(const ICallString& str)
{
return strdup(str.utf8stream);
}
inline void ScriptingStringToAllocatedChars_Free(const char* str)
{
free((void*)str);
}
template<class T>
inline ScriptingObjectPtr ScriptingGetObjectReference(PPtr<T> object)
{
return Scripting::ScriptingWrapperFor(object);
}
template<class T>
inline ScriptingObjectPtr ScriptingGetObjectReference(T* object)
{
return Scripting::ScriptingWrapperFor(object);
}
#define CreateScriptingParams(VariableName, ParamCount) ScriptingParams VariableName[ParamCount];
// Don't use if Value is ScriptingObjectPtr!!!
#define SetScriptingParam(VariableName, Index, Value) VariableName[Index] = &Value;
#define GetSafeString(ClassName, Getter) Getter
#endif
|
