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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
|
#include "UnityPrefix.h"
#include "MonoBehaviour.h"
#include "Runtime/Math/AnimationCurve.h"
#include "Runtime/Serialize/TransferFunctions/SerializeTransfer.h"
#include "Runtime/Serialize/FileCache.h"
#include "Runtime/Serialize/IterateTypeTree.h"
#include "MonoScript.h"
#include "MonoManager.h"
#include "Runtime/Mono/MonoBehaviourSerialization.h"
#include "Runtime/Scripting/ScriptingUtility.h"
#include "Runtime/Scripting/CommonScriptingClasses.h"
#include "Runtime/IMGUI/GUIStyle.h"
#if ENABLE_SCRIPTING && UNITY_WINRT && !ENABLE_SERIALIZATION_BY_CODEGENERATION
std::stack<StreamedBinaryWrite<false>*> currentTransferWrite;
std::stack<StreamedBinaryRead<false>*> currentTransferRead;
RemapPPtrTransfer* currentRemapper = NULL;
static void SerializationReader_Read(int destination, int size, bool align)
{
StreamedBinaryRead<false>* read = currentTransferRead.top();
read->ReadDirect((void*)destination, size);
if (align)
read->Align();
}
static long long SerializationReader_ReadPPtr()
{
StreamedBinaryRead<false>* transfer = currentTransferRead.top();
PPtr<Object> pptr;
transfer->Transfer (pptr, "does_not_matter", kNoTransferFlags);
return TransferPPtrToMonoObjectUnChecked(pptr.GetInstanceID(), transfer->GetFlags() & kThreadedSerialization);
}
void SerializationReader_ReadGUIStyle(int dstPtr)
{
StreamedBinaryRead<false>* transfer = currentTransferRead.top();
transfer->Transfer(*(GUIStyle*)dstPtr, "does_not_matter", kNoTransferFlags);
}
void SerializationReader_ReadRectOffset(int dstPtr)
{
StreamedBinaryRead<false>* transfer = currentTransferRead.top();
transfer->Transfer(*(RectOffset*)dstPtr, "does_not_matter", kNoTransferFlags);
}
int SerializationReader_ReadAnimationCurve()
{
StreamedBinaryRead<false>* transfer = currentTransferRead.top();
AnimationCurve* curve = new AnimationCurve();
transfer->Transfer (*curve, "does_not_matter", kNoTransferFlags);
return (int)curve;
}
static void SetupReader()
{
static BridgeInterface::ISerializationReader^ reader = nullptr;
if (reader == nullptr)
{
reader = s_WinRTBridge->CreateSerializationReader(
ref new BridgeInterface::SerializationReader_Read(SerializationReader_Read),
ref new BridgeInterface::SerializationReader_ReadPPtr(SerializationReader_ReadPPtr),
ref new BridgeInterface::SerializationReader_ReadStruct(SerializationReader_ReadGUIStyle),
ref new BridgeInterface::SerializationReader_ReadStruct(SerializationReader_ReadRectOffset),
ref new BridgeInterface::SerializationReader_ReadAnimationCurve(SerializationReader_ReadAnimationCurve));
GetWinRTMonoBehaviourSerialization()->SetNativeReader(reader);
}
}
static void SerializationWriter_Write(int source, int size, bool align)
{
StreamedBinaryWrite<false>* writer = currentTransferWrite.top();
writer->GetCachedWriter().Write((void*)source, size);
if (align)
writer->Align();
}
void SerializationWriter_WriteGUIStyle(int srcPtr)
{
currentTransferWrite.top()->Transfer(*(GUIStyle*)srcPtr, "does_not_matter", kNoTransferFlags);
}
void SerializationWriter_WriteRectOffset(int srcPtr)
{
currentTransferWrite.top()->Transfer(*(RectOffset*)srcPtr, "does_not_matter", kNoTransferFlags);
}
void SerializationWriter_WriteAnimationCurve(int srcAnimationCurvePtr)
{
AnimationCurve* curve = (AnimationCurve*)srcAnimationCurvePtr;
currentTransferWrite.top()->Transfer(*curve,"doesntmatter", kNoTransferFlags);
}
static void SerializationWriter_WritePPtr(int instanceID)
{
StreamedBinaryWrite<false>* transfer = currentTransferWrite.top();
PPtr<Object> pptr;
pptr.SetInstanceID(instanceID);
currentTransferWrite.top()->Transfer(pptr, "doesntmatter", kNoTransferFlags);
}
static void SetupWriter()
{
static BridgeInterface::ISerializationWriter^ writer = nullptr;
if (writer == nullptr)
{
writer = s_WinRTBridge->CreateSerializationWriter(
ref new BridgeInterface::SerializationWriter_Write(SerializationWriter_Write),
ref new BridgeInterface::SerializationWriter_WritePPtr(SerializationWriter_WritePPtr),
ref new BridgeInterface::SerializationWriter_WriteStruct(SerializationWriter_WriteGUIStyle),
ref new BridgeInterface::SerializationWriter_WriteStruct(SerializationWriter_WriteRectOffset),
ref new BridgeInterface::SerializationWriter_WriteAnimationCurve(SerializationWriter_WriteAnimationCurve));
GetWinRTMonoBehaviourSerialization()->SetNativeWriter(writer);
}
}
template<>
void MonoBehaviour::TransferWithInstance<StreamedBinaryWrite<false> > (StreamedBinaryWrite<false>& transfer)
{
AssertIf (GetInstance() == SCRIPTING_NULL);
currentTransferWrite.push(&transfer);
SetupWriter();
GetWinRTMonoBehaviourSerialization()->Serialize(GetInstance());
StreamedBinaryWrite<false>* remove = currentTransferWrite.top();
Assert(remove == &transfer);
currentTransferWrite.pop();
}
template<>
void MonoBehaviour::TransferWithInstance<StreamedBinaryRead<false> > (StreamedBinaryRead<false> & transfer)
{
AssertIf (GetInstance() == SCRIPTING_NULL);
currentTransferRead.push(&transfer);
SetupReader();
GetWinRTMonoBehaviourSerialization()->Deserialize(GetInstance());
StreamedBinaryRead<false>* remove = currentTransferRead.top();
Assert(remove == &transfer);
currentTransferRead.pop();
}
static long long SerializationRemapper_GetScriptingWrapper(int oldInstanceID)
{
SInt32 newInstanceID = currentRemapper->GetNewInstanceIDforOldInstanceID(oldInstanceID);
//printf_console("GNITRO called. old instanceid: %i, new instanceid: %i", oldInstanceID, newInstanceID);
return Scripting::GetScriptingWrapperForInstanceID(newInstanceID);
}
static void SetupRemapper()
{
static BridgeInterface::SerializationRemapper_GetScriptingWrapper^ remapper = nullptr;
if (remapper == nullptr)
{
remapper = ref new BridgeInterface::SerializationRemapper_GetScriptingWrapper(SerializationRemapper_GetScriptingWrapper);
GetWinRTMonoBehaviourSerialization()->SetNativeRemapper(remapper);
}
}
template<>
void MonoBehaviour::TransferWithInstance<RemapPPtrTransfer> (RemapPPtrTransfer& transfer)
{
AssertIf (GetInstance() == SCRIPTING_NULL);
currentRemapper = &transfer;
SetupRemapper();
GetWinRTMonoBehaviourSerialization()->Remap(GetInstance());
}
void MonoBehaviour::DoLivenessCheck(RemapPPtrTransfer& transfer)
{
}
#endif
|
