diff options
Diffstat (limited to 'Runtime/Mono/MonoBehaviourSerialization_flash.cpp')
| -rw-r--r-- | Runtime/Mono/MonoBehaviourSerialization_flash.cpp | 239 |
1 files changed, 239 insertions, 0 deletions
diff --git a/Runtime/Mono/MonoBehaviourSerialization_flash.cpp b/Runtime/Mono/MonoBehaviourSerialization_flash.cpp new file mode 100644 index 0000000..55910b9 --- /dev/null +++ b/Runtime/Mono/MonoBehaviourSerialization_flash.cpp @@ -0,0 +1,239 @@ +#include "UnityPrefix.h" + +#include "MonoBehaviour.h" +#include "Runtime/Math/AnimationCurve.h" +#include "Runtime/Math/Gradient.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" +#include <stack> + +#if UNITY_FLASH + +#define FLASH_SERIALIZATION_STRING_BUFFERSIZE 4*1024 + +static StreamedBinaryRead<false>* currentTransferRead; +static CachedReader* currentCachedReader; +static std::stack< StreamedBinaryRead<false>* > currentTranferReadStack; +static StreamedBinaryWrite<false>* currentTransferWrite; +static RemapPPtrTransfer* currentRemapPPTRTransfer; + +static unsigned char temporaryStringBuffer[FLASH_SERIALIZATION_STRING_BUFFERSIZE]; + +//since there is so much code involved in reading a PPtr<T> from a serializedstream, and getting the ScriptingObject +//belonging to that, we do not do that deserialization in as3, but in c instead. as3 will call this function +//when it wants to deserialize something that enherits from UnityEngine.Object +extern "C" ScriptingObjectPtr ReadPPtrAndReturnScriptingWrapper() +{ + PPtr<Object> pptr; + currentTransferRead->Transfer (pptr, "does_not_matter", kNoTransferFlags); + return TransferPPtrToMonoObjectUnChecked(pptr.GetInstanceID(), currentTransferRead->GetFlags() & kThreadedSerialization); +} + +extern "C" GradientNEW* ReadGradientAndReturnPtr() +{ + GradientNEW* gradient = new GradientNEW(); + currentTransferRead->Transfer (*gradient, "does_not_matter", kNoTransferFlags); + return gradient; +} + +extern "C" AnimationCurve* ReadAnimationCurveAndReturnPtr() +{ + AnimationCurve* curve = new AnimationCurve(); + currentTransferRead->Transfer(*curve, "does_not_matter", kNoTransferFlags); + return curve; +} + +extern "C" int GetCurrentSerializationStreamPosition() +{ + return (int)currentCachedReader->GetAbsoluteMemoryPosition(); +} + +extern "C" void WriteGradient(GradientNEW* gradient) +{ + currentTransferWrite->Transfer(*gradient, "doesntmatter", kNoTransferFlags); +} + +extern "C" void WriteAnimationCurve(AnimationCurve* curve) +{ + currentTransferWrite->Transfer(*curve, "doesntmatter", kNoTransferFlags); +} + +extern "C" void WritePPtrWithInstanceID(int instanceid) +{ + PPtr<Object> pptr; + pptr.SetInstanceID(instanceid); + currentTransferWrite->Transfer(pptr, "doesntmatter", kNoTransferFlags); +} + +extern "C" ScriptingObjectPtr GetNewInstanceToReplaceOldInstance(int oldInstanceID) +{ + SInt32 newInstanceID = currentRemapPPTRTransfer->GetNewInstanceIDforOldInstanceID(oldInstanceID); + return Scripting::GetScriptingWrapperForInstanceID(newInstanceID); +} + +template<> +void MonoBehaviour::TransferWithInstance<StreamedBinaryWrite<false> > (StreamedBinaryWrite<false>& transfer) +{ + AssertIf (GetInstance() == NULL); + currentTransferWrite = &transfer; + Ext_SerializeMonoBehaviour(GetInstance()); +} + +template<> +void MonoBehaviour::TransferWithInstance<StreamedBinaryRead<false> > (StreamedBinaryRead<false> & transfer) +{ + AssertIf (GetInstance() == NULL); + + currentTranferReadStack.push(&transfer); + + currentTransferRead = currentTranferReadStack.top(); + if(currentTransferRead != NULL){ + currentCachedReader = ¤tTransferRead->GetCachedReader(); + } + + Ext_DeserializeMonoBehaviour(GetInstance()); + + Assert(currentTransferRead == &transfer); + currentTranferReadStack.pop(); + + if(!currentTranferReadStack.empty()){ + currentTransferRead = currentTranferReadStack.top(); + currentCachedReader = ¤tTransferRead->GetCachedReader(); + } +} + +template<> +void MonoBehaviour::TransferWithInstance<RemapPPtrTransfer> (RemapPPtrTransfer& transfer) +{ + AssertIf (GetInstance() == NULL); + currentRemapPPTRTransfer = &transfer; + Ext_RemapPPtrs(GetInstance()); +} + +extern "C" unsigned char NativeExt_MonoBehaviourSerialization_ReadByte() +{ + unsigned char retVal = 0; + currentCachedReader->Read(&retVal,1); + return retVal; +} + +extern "C" unsigned char NativeExt_MonoBehaviourSerialization_WriteByte(unsigned char value) +{ + currentTransferWrite->GetCachedWriter().Write(value); +} + +extern "C" char NativeExt_MonoBehaviourSerialization_ReadBool() +{ + return NativeExt_MonoBehaviourSerialization_ReadByte(); +} + +extern "C" char NativeExt_MonoBehaviourSerialization_WriteBool(bool value) +{ + currentTransferWrite->GetCachedWriter().Write((char)(value ? 1 : 0)); +} + +extern "C" int NativeExt_MonoBehaviourSerialization_ReadInt() +{ + int retVal = 0; + currentCachedReader->Read(&retVal,4); + return retVal; +} + +extern "C" char NativeExt_MonoBehaviourSerialization_WriteInt(int value) +{ + currentTransferWrite->GetCachedWriter().Write(value); +} + +extern "C" float NativeExt_MonoBehaviourSerialization_ReadFloat() +{ + float retVal = 0; + currentCachedReader->Read(&retVal,4); + return retVal; +} + +extern "C" char NativeExt_MonoBehaviourSerialization_WriteFloat(float value) +{ + currentTransferWrite->GetCachedWriter().Write(value); +} + +extern "C" double NativeExt_MonoBehaviourSerialization_ReadDouble() +{ + double retVal = 0; + currentCachedReader->Read(&retVal,8); + return retVal; +} + +extern "C" char NativeExt_MonoBehaviourSerialization_WriteDouble(double value) +{ + currentTransferWrite->GetCachedWriter().Write(value); +} + +extern "C" void NativeExt_MonoBehaviourSerialization_ReadString() +{ + int length = 0; + currentCachedReader->Read(&length, 4);//Length of the string + void* tempBuffer; + bool usesLocalBuffer; + usesLocalBuffer = !(length < FLASH_SERIALIZATION_STRING_BUFFERSIZE); + if(usesLocalBuffer) + tempBuffer = malloc(length); + else + tempBuffer = temporaryStringBuffer; + + + currentCachedReader->Read(tempBuffer,length); + + __asm __volatile__("var bpos:int = heap.position;"); + __asm __volatile__("heap.position = %0;"::"r"(tempBuffer)); + __asm __volatile__("string_g0 = heap.readUTFBytes(%0);"::"r"(length)); + __asm __volatile__("heap.position = bpos;"); + + if(usesLocalBuffer) + free(tempBuffer); + + currentCachedReader->Align4Read(); +} + +extern "C" void NativeExt_MonoBehaviourSerialization_WriteString(char* value, int size) +{ + UnityStr tmpStr(value, size); + currentTransferWrite->Transfer(tmpStr, "does_not_matter", kNoTransferFlags); +} + +extern "C" void NativeExt_MonoBehaviourSerialization_ReadGUIStyle(GUIStyle* style) +{ + currentTransferRead->Transfer(*style,"does_not_matter",kNoTransferFlags); +} + +extern "C" void NativeExt_MonoBehaviourSerialization_WriteGUIStyle(GUIStyle* style) +{ + currentTransferWrite->Transfer(*style,"does_not_matter",kNoTransferFlags); +} + +extern "C" void NativeExt_MonoBehaviourSerialization_ReadRectOffset(RectOffset* offset) +{ + currentTransferRead->Transfer(*offset,"does_not_matter",kNoTransferFlags); +} + +extern "C" void NativeExt_MonoBehaviourSerialization_WriteRectOffset(RectOffset* offset) +{ + currentTransferWrite->Transfer(*offset,"does_not_matter",kNoTransferFlags); +} + +extern "C" void NativeExt_MonoBehaviourSerialization_WriteAlign() +{ + currentTransferWrite->GetCachedWriter().Align4Write(); +} + +extern "C" void NativeExt_MonoBehaviourSerialization_ReadAlign() +{ + currentCachedReader->Align4Read(); +} +#endif |