656 lines
19 KiB
C++
656 lines
19 KiB
C++
/****************************************************************************
|
||
Copyright (c) 2011-2013,WebJet Business Division,CYOU
|
||
|
||
http://www.genesis-3d.com.cn
|
||
|
||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||
of this software and associated documentation files (the "Software"), to deal
|
||
in the Software without restriction, including without limitation the rights
|
||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||
copies of the Software, and to permit persons to whom the Software is
|
||
furnished to do so, subject to the following conditions:
|
||
|
||
The above copyright notice and this permission notice shall be included in
|
||
all copies or substantial portions of the Software.
|
||
|
||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||
THE SOFTWARE.
|
||
****************************************************************************/
|
||
#ifndef __SCRIPT_UTILITY_H__
|
||
#define __SCRIPT_UTILITY_H__
|
||
|
||
#include "foundation/io/stream.h"
|
||
#include "foundation/io/ioserver.h"
|
||
#include "foundation/io/memorystream.h"
|
||
#include "foundation/io/iointerface.h"
|
||
#include "foundation/io/iointerfaceprotocol.h"
|
||
|
||
#include "foundation/util/string.h"
|
||
#include "foundation/util/guid.h"
|
||
#include "foundation/util/monoapi.h"
|
||
#include "foundation/core/rtti.h"
|
||
#include "app/scriptfeature/inc/script_fwd_decl.h"
|
||
#include "app/appframework/component.h"
|
||
|
||
// - define some mono function by macro
|
||
#define mono_array_addr(array,type,index) ((type*)(void*) mono_array_addr_with_size (array, sizeof (type), index))
|
||
#define mono_array_get(array,type,index) ( *(type*)mono_array_addr ((array), type, (index)) )
|
||
#define mono_array_set(array,type,index,value) \
|
||
do { \
|
||
type *__p = (type *) mono_array_addr ((array), type, (index)); \
|
||
*__p = (value); \
|
||
} while (false)
|
||
|
||
|
||
|
||
|
||
namespace App
|
||
{
|
||
|
||
class Actor;
|
||
class ScriptComponent;
|
||
|
||
// Mono Object has private data offset when get C# object. See Mono Source Code
|
||
enum {
|
||
MonoObjectMemoryOffset = 2 * sizeof(void*),
|
||
MonoArrayMemoryOffset = 4 * sizeof(void*)
|
||
};
|
||
|
||
struct bbox_script
|
||
{
|
||
Math::float3 Min;
|
||
Math::float3 Max;
|
||
inline void operator = (const Math::bbox& rhs)
|
||
{
|
||
Min.x() = rhs.pmin.x();
|
||
Min.y() = rhs.pmin.y();
|
||
Min.z() = rhs.pmin.z();
|
||
|
||
Max.x() = rhs.pmax.x();
|
||
Max.y() = rhs.pmax.y();
|
||
Max.z() = rhs.pmax.z();
|
||
}
|
||
inline Math::bbox toBbox() const
|
||
{
|
||
return Math::bbox(Math::point(Min.x(), Min.y(), Min.z()), Math::point(Max.x(), Max.y(), Max.z()));
|
||
}
|
||
};
|
||
|
||
|
||
// - name define
|
||
static char* s_cpScriptFrameworkLibrary = "ScriptFrameworkLibrary.dll";
|
||
static char* s_cpScriptRuntimeLibraryName = "ScriptRuntimeLibrary.dll";
|
||
static char* s_cpScriptGUILibraryName = "ScriptGUILibrary.dll"; //[2012/5/15 zhongdaohuan]
|
||
static char* s_cpUserDefCSharpLibName = "UserDefCSharp.dll";
|
||
|
||
static const Util::String s_csScriptableClassName = "ScriptableClass";
|
||
static const Util::String s_csScriptRuntimeNamespace = "ScriptRuntime";
|
||
|
||
static const Util::String s_csScriptFrameworkLibraryName = s_cpScriptFrameworkLibrary;
|
||
static const Util::String s_csScriptRuntimeLibraryName = s_cpScriptRuntimeLibraryName;
|
||
static const Util::String s_csScriptGUILibraryName = s_cpScriptGUILibraryName; //[2012/5/15 zhongdaohuan]
|
||
static const Util::String s_csUserDefCSharpLibName = s_cpUserDefCSharpLibName;
|
||
static const Util::String s_csScriptBinaryAssign = "script:";
|
||
|
||
#ifdef __WIN32__
|
||
static const Util::String s_csMonoDllAssign = "script:mono-2.0.dll";
|
||
|
||
#elif defined(__ANDROID__)
|
||
static const Util::String s_csMonoDllAssign = "";
|
||
|
||
#elif defined(__OSX__)
|
||
static const Util::String s_csMonoDllAssign = "script:mono-2.0.dll";
|
||
#endif
|
||
|
||
static const Util::String s_csFloat2ClassName = "Vector2";
|
||
static const Util::String s_csFloat3ClassName = "Vector3";
|
||
static const Util::String s_csFloat4ClassName = "Vector4";
|
||
static const Util::String s_csColorFClassName = "ColorF";
|
||
static const Util::String s_csColor32ClassName = "Color32";
|
||
static const Util::String s_csImagePathClassName = "ImagePath";
|
||
static const Util::String s_csAssetPathClassName = "AssetPath";
|
||
|
||
static const Util::String s_csExceptionConverterName = "ExceptionConverter";
|
||
static const Util::String s_csExceptionToStringMethodSig = "*:ExceptionToString(Exception,string&)";
|
||
|
||
// - assemblies define
|
||
struct AssemblyNameAndPath
|
||
{
|
||
char* __pAssign;
|
||
char* __pName;
|
||
};
|
||
|
||
static const AssemblyNameAndPath s_cAssemblies[] = {
|
||
{ "script:", s_cpScriptFrameworkLibrary },
|
||
{ "script:", s_cpScriptRuntimeLibraryName },
|
||
{ "script:", s_cpScriptGUILibraryName },
|
||
{ "script:", s_cpUserDefCSharpLibName },
|
||
};
|
||
|
||
/// - entry method names and index define
|
||
enum EEntryMethodIndex
|
||
{
|
||
EEntryMethodIndex_OnLoad,
|
||
EEntryMethodIndex_OnBeginFrame,
|
||
EEntryMethodIndex_OnFrame,
|
||
EEntryMethodIndex_OnEndFrame,
|
||
EEntryMethodIndex_OnExit,
|
||
EEntryMethodIndex_OnStopped,
|
||
EEntryMethodIndex_OnResumed,
|
||
EEntryMethodIndex_OnRenderPostEffect,
|
||
EEntryMethodIndex_OnWillRenderObject,
|
||
EEntryMethodIndex_Num,
|
||
};
|
||
|
||
struct EntryMethodNameAndIndex
|
||
{
|
||
char* __pName;
|
||
uint8 __iIdx;
|
||
};
|
||
|
||
/// structure in front of a C# object
|
||
struct DataOnHead
|
||
{
|
||
void* __CppObjPtr;
|
||
};
|
||
|
||
struct InternalCallDetail
|
||
{
|
||
char* __pScriptFunName;
|
||
void* __pCppFunPtr;
|
||
};
|
||
|
||
//<2F><><EFBFBD><EFBFBD><EFBFBD>IJ<EFBFBD><C4B2><EFBFBD><EFBFBD>б<EFBFBD><D0B1>ﲻ<EFBFBD><EFB2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>κοո<CEBF><D5B8><EFBFBD><EFBFBD>ڣ<EFBFBD>Ҫ<EFBFBD><D2AA>Ȼ<EFBFBD><C8BB>mono<6E><6F><EFBFBD>Ҳ<EFBFBD><D2B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
static const EntryMethodNameAndIndex s_cEntryMethodNameAndIndex[] = {
|
||
{ "*:OnLoad()", EEntryMethodIndex_OnLoad },
|
||
{ "*:OnBeginFrame()", EEntryMethodIndex_OnBeginFrame },
|
||
{ "*:OnFrame()", EEntryMethodIndex_OnFrame },
|
||
{ "*:OnEndFrame()", EEntryMethodIndex_OnEndFrame },
|
||
{ "*:OnExit()", EEntryMethodIndex_OnExit },
|
||
{ "*:OnStopped()", EEntryMethodIndex_OnStopped },
|
||
{ "*:OnResumed()", EEntryMethodIndex_OnResumed },
|
||
{ "*:OnRenderPostEffect(CameraComponent,RenderToTexture,RenderToTexture)", EEntryMethodIndex_OnRenderPostEffect },
|
||
{ "*:OnWillRenderObject(RenderComponent)", EEntryMethodIndex_OnWillRenderObject },
|
||
};
|
||
|
||
/// let the script system work
|
||
bool StartupSciptSystem( const Util::String& monoDirPaths,
|
||
const Util::String& monoConfigsPath,
|
||
const Util::String& monoDllPath,
|
||
bool bEnableMonoDebugger );
|
||
|
||
/// close script system
|
||
bool ShutDownScriptSystem();
|
||
|
||
/// load mono dll
|
||
bool LoadMonoDll( const Util::String& monoDllPath );
|
||
|
||
/// unload mono dll
|
||
void UnloadMonoDll();
|
||
|
||
Util::String GetLastError();
|
||
|
||
/// replace '\' to '/',upper case to lower case
|
||
void Utility_RegularPath( Util::String& inout);
|
||
|
||
/// get file extension from a path
|
||
Util::String Utility_ExtractExtension( const Util::String& sPath );
|
||
|
||
/// change extension
|
||
void Utility_ChangeExtension( Util::String& sPath, const Util::String& newEx );
|
||
|
||
/// remove namespace
|
||
void Utility_RemoveNameSpace( Util::String& inout );
|
||
|
||
/// get class definition on the mono side
|
||
MonoClass* Utility_GetMonoClassByName( const Util::String& sClassName, const Util::String& sNamespace, const Util::String& sAssemblyName );
|
||
|
||
/// get runtime mono class
|
||
MonoClass* Utility_GetRuntimeMonoClass( const Util::String& sClassName );
|
||
|
||
/// create a mono string
|
||
MonoString* Utility_NewMonoString( const Util::String& string );
|
||
|
||
/// create a dummy object to initialize a class
|
||
MonoObject* Utility_GetDummyObject( void );
|
||
|
||
/// create a monoObject from given mono class
|
||
MonoObject* Utility_CreateMonoObj( MonoClass* pMonoClass );
|
||
|
||
/// convert a MonoString to Cpp string
|
||
Util::String Utility_MonoStringToCppString( MonoString* pMonoStr );
|
||
|
||
/// convert a MonoString to Cpp string
|
||
template<typename StringType>
|
||
void Utility_MonoStringToCppString( MonoString* pMonoStr, StringType& buffer);
|
||
|
||
/// convert a string to a MonoString
|
||
MonoString* Utility_CppStringToMonoString( const char* pStr );
|
||
|
||
MonoString* Utility_CppStringToMonoStringSafe( const char* pStr );
|
||
|
||
/// get component's RTTI by name
|
||
const Core::Rtti* Utility_GetComRttiByName( const Util::String& sName );
|
||
|
||
/// add component by name
|
||
Component* AddComponentByName( Actor* pActor, const Util::String& sName );
|
||
|
||
/// get component by name
|
||
Component* GetComponentByName( Actor* pActor, const Util::String& sName );
|
||
|
||
/// create a mono string array from a cpp string array
|
||
MonoArray* Utility_CppStrArrToMonoStrArr( const Util::TStringArray& cppStrArr );
|
||
|
||
MonoArray* Utility_CppByteArrToMonoByteArr( const Util::Array<ubyte>& cppStrArr );
|
||
|
||
MonoArray* Utility_CppByteArrToMonoByteArr( const char* cppByteArr,unsigned int size );
|
||
template<typename T>
|
||
MonoArray* Utility_CppArrToMonoArr( const Util::Array<T>& cppStrArr );
|
||
|
||
template<typename T>
|
||
T* Utility_CreateCppArrFromMonoArr( MonoArray* monoarray );
|
||
|
||
template<typename T>
|
||
void Utility_FreeCppArr( T* cpparray );
|
||
|
||
/// create a cpp string array from mono string array
|
||
bool Utility_MonoStrArrToCppStrArr( MonoArray* pMonoStrArr, Util::TStringArray& cppStrArr );
|
||
|
||
/// get a string from a class instance by given a field
|
||
Util::String Utility_GetFieldStringValue( MonoObject* pMonoObj, MonoClassField* pClassField );
|
||
|
||
Util::Guid Utility_MonoGuidToUtilGuid(MonoArray* guid_array);
|
||
|
||
MonoArray* Utility_UtilGuidToMonoByteArray(const Util::Guid& guid);
|
||
|
||
/// get all fields name from a script instance,it's slow
|
||
Util::TStringArray Utility_GetAllEditableFieldNames( TScriptInstancePtr& pInstance );
|
||
|
||
/// get editable field count
|
||
int Utility_GetEditableFieldCount( TScriptInstancePtr& pInstance );
|
||
|
||
/// get field by name
|
||
MonoClassField* Utility_GetEditableField( TScriptInstancePtr& pInstance, const Util::String& sName );
|
||
|
||
/// get field by index
|
||
MonoClassField* Utility_GetEditableField( TScriptInstancePtr& pInstance, IndexT iIdx );
|
||
|
||
/// get all fields of a script instance
|
||
TMonoClassFieldMap* Utility_GetFields( TScriptInstancePtr& pInstance );
|
||
|
||
/// get field type, if null pointer is given,a invalid mono type(c_iInvalidMonoType) is return
|
||
int Utility_GetFieldType( MonoClassField* pClassField );
|
||
|
||
/// set a script instance's field value
|
||
bool Utility_SetFieldValue( TScriptInstancePtr& pInstance, const Util::String& sName, int iType, void* val );
|
||
|
||
/// set a imagepath instance's field value
|
||
bool Utility_SetImagePathFieldValue( TScriptInstancePtr& pInstance, const Util::String& key, const Util::String& str, int iType);
|
||
|
||
/// get a imagepath instance's field value
|
||
Util::String Utility_GetFieldImagePathValue(MonoObject* pMonoObj, MonoClassField* pField);
|
||
|
||
/// set a imagepath instance's field value
|
||
bool Utility_SetAssetPathFieldValue( TScriptInstancePtr& pInstance, const Util::String& key, const Util::AssetPath& str, int iType);
|
||
|
||
/// get a imagepath instance's field value
|
||
Util::AssetPath Utility_GetFieldAssetPathValue(MonoObject* pMonoObj, MonoClassField* pField);
|
||
|
||
|
||
/// set a script instance's field value
|
||
bool Utility_SetFieldValue( GPtr<ScriptComponent>& com , int index, const Util::String& sName, int iType, void* val );
|
||
|
||
/// set a script instance's field value
|
||
bool Utility_SetFieldValue( GPtr<ScriptComponent>& com , const Util::String& sInstanceName, const Util::String& sName, int iType, void* val );
|
||
|
||
/// get type's class name
|
||
const char* Utility_GetTypeClassName(MonoType *type);
|
||
|
||
/// get a feild's class name
|
||
const char* Utility_GetTypeClassName(MonoClassField *type);
|
||
|
||
/// create a child domain
|
||
MonoDomain* Utility_CreateChildDomain();
|
||
|
||
/// set it as current domain
|
||
void Utility_SetChildDomain(MonoDomain* newDomain);
|
||
|
||
/// unload a child domain ,never unload the root domain
|
||
void Utility_UnloadChildDomain();
|
||
|
||
/// call script root's load foo
|
||
void Utility_ScriptRootLoad();
|
||
|
||
/// call script root's Tick foo
|
||
void Utility_ScriptRootTick();
|
||
|
||
/// call script root's Stop foo
|
||
void Utility_ScriptRootStop();
|
||
|
||
/// call script root's Resume foo
|
||
void Utility_ScriptRootResume();
|
||
|
||
/// call script root's Stop foo
|
||
void Utility_ScriptRootExit();
|
||
|
||
Math::float3 Utility_VectorToFloat3(const Math::vector& vec);
|
||
|
||
Math::vector Utility_Float3ToVector(const Math::float3& f3);
|
||
|
||
/// exception to string
|
||
Util::String Utility_ExceptionToString(MonoObject* ecx);
|
||
|
||
/// call mono method with exeception process
|
||
MonoObject* Utility_MonoRuntimeInvoke(MonoMethod* method, void* obj, void** params);
|
||
|
||
/// Create a script instance
|
||
GPtr<ScriptInstance> Utility_CreateScriptInstance(const Util::String& className,const Util::String& nameSpaceName,const Util::String& assemblyName);
|
||
|
||
#ifdef __GENESIS_EDITOR__
|
||
/// To check if this dll is a dot net's dll
|
||
bool Utility_DetectDotNetDll(const char* pathName);
|
||
#endif
|
||
|
||
// -- inline function define -------
|
||
|
||
// translate from bool to MoonBool
|
||
inline mono_bool Utility_MonoBool(bool b)
|
||
{
|
||
return b ? c_iMonoBool_True : c_iMonoBool_False;
|
||
}
|
||
|
||
// translate from MonoBool to bool
|
||
inline bool Utility_MonoBool(mono_bool b)
|
||
{
|
||
return b == c_iMonoBool_True;
|
||
}
|
||
|
||
/// extract a stucture from a MonoObject
|
||
inline DataOnHead* GetDataOnHead(MonoObject* wrapper)
|
||
{
|
||
return reinterpret_cast<DataOnHead*> (((char*)wrapper) + MonoObjectMemoryOffset);
|
||
}
|
||
|
||
//<2F><>Ҫ<EFBFBD><D2AA><EFBFBD><EFBFBD>ֵ<EFBFBD><D6B5><EFBFBD>͵<EFBFBD>MonoObject<63><74><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
template<typename T>
|
||
inline T& MonoObjectUnbox(MonoObject* obj)
|
||
{
|
||
return *((T*)(((char*) obj) + MonoObjectMemoryOffset));
|
||
}
|
||
|
||
template<typename T>
|
||
inline T* GetMonoArrayBegin(MonoArray* array)
|
||
{
|
||
return (T*) (((char*) array) + MonoArrayMemoryOffset);
|
||
}
|
||
|
||
template<typename T>
|
||
inline const T* GetMonoArrayBegin(const MonoArray* array)
|
||
{
|
||
return (T*) (((char*) array) + MonoArrayMemoryOffset);
|
||
}
|
||
|
||
template<typename T>
|
||
inline T& GetMonoArrayElement (MonoArray* array, int i)
|
||
{
|
||
return *(GetMonoArrayBegin<T>(array) + i);
|
||
}
|
||
|
||
template<typename T>
|
||
inline void SetMonoArrayElement (MonoArray* array, int i, const T& value)
|
||
{
|
||
T& elem = GetMonoArrayElement<T>(array,i);
|
||
elem = value;
|
||
}
|
||
|
||
/// bind a cpp object with a script object
|
||
inline void Utility_SetCppObjectPtr(MonoObject* wrapper, void* pCppObj )
|
||
{
|
||
GetDataOnHead(wrapper)->__CppObjPtr = pCppObj;
|
||
}
|
||
|
||
/// get cpp object pointer from a script object
|
||
inline void* Utility_GetCppObjectPtr( MonoObject* wrapper )
|
||
{
|
||
return GetDataOnHead(wrapper)->__CppObjPtr;
|
||
}
|
||
|
||
/// if a script instance has editable fields
|
||
inline bool Utility_HasEdiableFields( TScriptInstancePtr& pInstance )
|
||
{
|
||
int count = Utility_GetEditableFieldCount( pInstance );
|
||
return count>0;
|
||
}
|
||
|
||
/// get field name
|
||
inline const char* Utility_GetFieldName( MonoClassField* pField )
|
||
{
|
||
if ( NULL!=pField )
|
||
{
|
||
return mono_field_get_name( pField );
|
||
}
|
||
|
||
return NULL;
|
||
}
|
||
|
||
inline Math::float3 Utility_VectorToFloat3(const Math::vector& vec)
|
||
{
|
||
return Math::float3(vec.x(), vec.y(), vec.z());
|
||
}
|
||
|
||
inline Math::vector Utility_Float3ToVector(const Math::float3& f3)
|
||
{
|
||
return Math::vector(f3.x(), f3.y(), f3.z());
|
||
}
|
||
|
||
//------------------------------------------------------------------------
|
||
template<typename StringType>
|
||
void Utility_MonoStringToCppString( MonoString* pMonoStr, StringType& buffer)
|
||
{
|
||
char* pStr = mono_string_to_utf8( pMonoStr );
|
||
buffer = pStr;
|
||
mono_free( pStr );
|
||
}
|
||
|
||
// -- template function define -------
|
||
/// bind a mono object with a cpp object
|
||
template<typename T>
|
||
bool BindCppObjWithMonoObj( T* pCppObj, MonoObject* pMonoObj )
|
||
{
|
||
script_fatal_error( NULL!=pCppObj );
|
||
script_fatal_error( NULL!=pMonoObj );
|
||
|
||
// - this cpp obj must havn't bind before
|
||
bool bBind = pCppObj->IsBindMonoObject();
|
||
script_fatal_error( !bBind );
|
||
|
||
// - bind this two object
|
||
Utility_SetCppObjectPtr( pMonoObj, pCppObj );
|
||
pCppObj->SetMonoObject( pMonoObj );
|
||
|
||
// - add ref to this cpp object
|
||
pCppObj->AddRef();
|
||
|
||
return true;
|
||
}
|
||
|
||
/// bind a mono object with a cpp object
|
||
template<typename T>
|
||
bool ReleaseCppObjWithMonoObj( T* pCppObj, MonoObject* pMonoObj )
|
||
{
|
||
script_fatal_error( NULL!=pCppObj );
|
||
script_fatal_error( NULL!=pMonoObj );
|
||
|
||
// - unbind this two object
|
||
Utility_SetCppObjectPtr( pMonoObj, NULL );
|
||
|
||
// - release one ref of this cpp object,this foo is called in a mono's certain thread,
|
||
// - it may be called at any time after the GC.
|
||
pCppObj->Release();
|
||
|
||
return true;
|
||
}
|
||
|
||
/// create a mono object from a cpp object
|
||
template<typename T>
|
||
MonoObject* CppObjectToScriptObj( T& rCppObj )
|
||
{
|
||
MonoObject* pMonoObj = rCppObj.GetMonoObject();
|
||
if ( NULL == pMonoObj )
|
||
{
|
||
const Core::Rtti* pRtti = rCppObj.GetRtti();
|
||
n_assert( NULL != pRtti );
|
||
// - create a script object
|
||
MonoClass* pMonoClass = NULL;
|
||
|
||
while(NULL != pRtti)
|
||
{
|
||
pMonoClass = Utility_GetRuntimeMonoClass( pRtti->GetName() );
|
||
if (pMonoClass)
|
||
{
|
||
pMonoObj = Utility_CreateMonoObj( pMonoClass );
|
||
// - bind this two object
|
||
BindCppObjWithMonoObj( &rCppObj, pMonoObj );
|
||
break;
|
||
}
|
||
pRtti = pRtti->GetParent();
|
||
}
|
||
}
|
||
return pMonoObj;
|
||
}
|
||
|
||
/// create a mono object from a cpp pointer
|
||
template<typename T>
|
||
MonoObject* CppPointerToScriptObj( T* pCppObj )
|
||
{
|
||
if( NULL==pCppObj )
|
||
{
|
||
return NULL;
|
||
}
|
||
else
|
||
{
|
||
return CppObjectToScriptObj( *pCppObj );
|
||
}
|
||
}
|
||
|
||
template<typename T>
|
||
T* ScriptObjToCppPointer(MonoObject* pScriptObj)
|
||
{
|
||
if (pScriptObj)
|
||
{
|
||
return (T*)Utility_GetCppObjectPtr( pScriptObj );
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
|
||
template<typename T>
|
||
MonoArray* Utility_CppArrToMonoArr( const Util::Array<T>& cppArr )
|
||
{
|
||
if (cppArr.Size()==0)
|
||
{
|
||
return NULL;
|
||
}
|
||
MonoArray* pMonoArr = NULL;
|
||
MonoClass* pMonoClass = mono_object_get_class(CppObjectToScriptObj( *cppArr[0] ));
|
||
MonoDomain* pDomain = mono_domain_get();
|
||
size_t size = cppArr.Size();
|
||
|
||
// - create a ubyte array
|
||
pMonoArr = mono_array_new( pDomain, pMonoClass, size );
|
||
if ( NULL==pMonoArr )
|
||
{
|
||
return NULL;
|
||
}
|
||
// - convert string into mono string and add them to a mono byte array
|
||
for ( uint32 ii=0; ii<size; ii++ )
|
||
{
|
||
mono_array_set ( pMonoArr, MonoObject*, ii, CppObjectToScriptObj( *cppArr[ii] ) );
|
||
}
|
||
|
||
return pMonoArr;
|
||
}
|
||
|
||
/// - get a instance's field build in type value,for example:int float double etc
|
||
template<typename T>
|
||
inline T Utility_GetFieldBuiltInTypeValue( MonoObject* pMonoObj, MonoClassField* pField )
|
||
{
|
||
#ifdef _DEBUG
|
||
n_assert( NULL!=pMonoObj );
|
||
n_assert( NULL!=pField );
|
||
#endif
|
||
T* value = reinterpret_cast<T*> ( reinterpret_cast<char*> (pMonoObj) + mono_field_get_offset(pField) );
|
||
return *value;
|
||
}
|
||
|
||
/*
|
||
* wrapper a mono object and associate with its cpp object,act like a pointer
|
||
*/
|
||
template<typename T>
|
||
class ScriptObjWrapper
|
||
{
|
||
public:
|
||
ScriptObjWrapper( MonoObject* pMonoObj )
|
||
: m_pMonoObj( pMonoObj )
|
||
, m_pCppObj( NULL )
|
||
{
|
||
if( NULL!=m_pMonoObj )
|
||
{
|
||
void* pObj = Utility_GetCppObjectPtr( pMonoObj );
|
||
m_pCppObj = static_cast<T*>( pObj );
|
||
n_assert( NULL!=m_pCppObj );
|
||
}
|
||
}
|
||
|
||
T* GetCppObjPtr( void ) { return m_pCppObj; }
|
||
T* operator -> () const { return m_pCppObj; }
|
||
bool IsValid( void ) const { return m_pMonoObj!=NULL;}
|
||
|
||
static T* Convert( MonoObject* pMonoObj )
|
||
{
|
||
if (NULL == pMonoObj)
|
||
{
|
||
return NULL;
|
||
}
|
||
return static_cast<T*>( Utility_GetCppObjectPtr( pMonoObj ) );
|
||
}
|
||
private:
|
||
MonoObject* m_pMonoObj;
|
||
T* m_pCppObj;
|
||
};
|
||
|
||
|
||
|
||
}
|
||
|
||
template<typename T>
|
||
T* App::Utility_CreateCppArrFromMonoArr( MonoArray* monoarray )
|
||
{
|
||
if ( NULL==monoarray )
|
||
{
|
||
return false;
|
||
}
|
||
|
||
size_t size = mono_array_length( monoarray );
|
||
T* cppArray = n_new_array(T,size);
|
||
for ( uint32 ii=0; ii<size; ii++ )
|
||
{
|
||
cppArray[ii] = mono_array_get( monoarray, T, ii );
|
||
}
|
||
}
|
||
|
||
|
||
template<typename T>
|
||
void App::Utility_FreeCppArr( T* cpparray )
|
||
{
|
||
n_delete_array(cpparray);
|
||
}
|
||
|
||
#endif // - __SCRIPT_UTILITY_H__
|
||
|