private static IntPtr _classMethodHandler(int contextId, int classId, string methodName, IntPtr arguments, int size)
{
if (_exportsClassMethods.ContainsKey(classId) && _exportsClassMethods[classId].ContainsKey(methodName))
{
LuaContext context = LuaContext.getContext(contextId);
//存在该方法, 进行调用
MethodInfo m = _exportsClassMethods [classId][methodName];
ArrayList argsArr = parseMethodParameters(context, m, arguments, size);
object ret = m.Invoke(null, argsArr != null ? argsArr.ToArray() : null);
LuaValue retValue = new LuaValue(ret);
LuaObjectEncoder encoder = new LuaObjectEncoder(context);
encoder.writeObject(retValue);
byte[] bytes = encoder.bytes;
IntPtr retPtr;
retPtr = Marshal.AllocHGlobal(bytes.Length);
Marshal.Copy(bytes, 0, retPtr, bytes.Length);
return(retPtr);
}
return(IntPtr.Zero);
}
/// <summary>
/// 调用Lua方法
/// </summary>
/// <returns>返回值</returns>
/// <param name="methodName">方法名</param>
/// <param name="arguments">调用参数列表</param>
public LuaValue callMethod(string methodName, List <LuaValue> arguments)
{
IntPtr argsPtr = IntPtr.Zero;
IntPtr resultPtr = IntPtr.Zero;
if (arguments != null)
{
LuaObjectEncoder encoder = new LuaObjectEncoder();
encoder.writeInt32(arguments.Count);
foreach (LuaValue value in arguments)
{
encoder.writeObject(value);
}
byte[] bytes = encoder.bytes;
argsPtr = Marshal.AllocHGlobal(bytes.Length);
Marshal.Copy(bytes, 0, argsPtr, bytes.Length);
}
int size = NativeUtils.callMethod(_nativeObjectId, methodName, argsPtr, out resultPtr);
if (argsPtr != IntPtr.Zero)
{
Marshal.FreeHGlobal(argsPtr);
}
if (size > 0)
{
return(LuaObjectDecoder.DecodeObject(resultPtr, size) as LuaValue);
}
return(new LuaValue());
}
/// <summary>
/// 序列化对象
/// </summary>
/// <param name="encoder">对象编码器.</param>
public override void serialization(LuaObjectEncoder encoder)
{
base.serialization(encoder);
encoder.writeInt32(_context.objectId);
encoder.writeString(luaObjectId);
}
/// <summary>
/// 序列化对象
/// </summary>
/// <param name="encoder">对象编码器.</param>
public override void serialization(LuaObjectEncoder encoder)
{
base.serialization(encoder);
encoder.writeInt64(_objRef.referenceId);
encoder.writeString(luaObjectId != null ? luaObjectId : "");
}
/// <summary>
/// 设置对象
/// </summary>
/// <param name="keyPath">键名路径.</param>
/// <param name="value">值.</param>
public void setObject(String keyPath, object value)
{
if (_context != null && _tableId > 0 && type == LuaValueType.Map)
{
LuaValue objectValue = new LuaValue(value);
IntPtr resultPtr = IntPtr.Zero;
IntPtr valuePtr = IntPtr.Zero;
LuaObjectEncoder encoder = new LuaObjectEncoder(_context);
encoder.writeObject(objectValue);
byte[] bytes = encoder.bytes;
valuePtr = Marshal.AllocHGlobal(bytes.Length);
Marshal.Copy(bytes, 0, valuePtr, bytes.Length);
int bufferLen = NativeUtils.tableSetObject(_tableId, keyPath, valuePtr, resultPtr);
if (bufferLen > 0)
{
LuaValue resultValue = LuaObjectDecoder.DecodeObject(resultPtr, bufferLen, _context) as LuaValue;
_value = resultValue._value;
}
if (valuePtr != IntPtr.Zero)
{
Marshal.FreeHGlobal(valuePtr);
}
}
}
private static IntPtr luaModuleMethodRoute(int nativeModuleId, string methodName, IntPtr arguments, int size)
{
if (_exportsModuleMethods.ContainsKey(nativeModuleId))
{
Dictionary <string, MethodInfo> exportMethods = _exportsModuleMethods [nativeModuleId];
if (exportMethods.ContainsKey(methodName))
{
//存在该方法, 进行调用
MethodInfo m = exportMethods [methodName];
ArrayList argsArr = parseMethodParameters(m, arguments, size);
object ret = m.Invoke(null, argsArr != null ? argsArr.ToArray() : null);
LuaValue retValue = new LuaValue(ret);
LuaObjectEncoder encoder = new LuaObjectEncoder();
encoder.writeObject(retValue);
byte[] bytes = encoder.bytes;
IntPtr retPtr;
retPtr = Marshal.AllocHGlobal(bytes.Length);
Marshal.Copy(bytes, 0, retPtr, bytes.Length);
return(retPtr);
}
}
return(IntPtr.Zero);
}
private static IntPtr _instanceMethodHandler(int contextId, int classId, Int64 instancePtr, string methodName, IntPtr argumentsBuffer, int bufferSize)
{
if (instancePtr != 0 &&
_exportsInstanceMethods.ContainsKey(classId) &&
_exportsInstanceMethods[classId].ContainsKey(methodName))
{
LuaContext context = LuaContext.getContext(contextId);
LuaObjectReference objRef = LuaObjectReference.findObject(instancePtr);
object instance = objRef.target;
MethodInfo m = _exportsInstanceMethods[classId][methodName];
if (instance != null && m != null)
{
ArrayList argsArr = parseMethodParameters(context, m, argumentsBuffer, bufferSize);
object ret = m.Invoke(instance, argsArr != null ? argsArr.ToArray() : null);
LuaValue retValue = new LuaValue(ret);
LuaObjectEncoder encoder = new LuaObjectEncoder(context);
encoder.writeObject(retValue);
byte[] bytes = encoder.bytes;
IntPtr retPtr;
retPtr = Marshal.AllocHGlobal(bytes.Length);
Marshal.Copy(bytes, 0, retPtr, bytes.Length);
return(retPtr);
}
}
return(IntPtr.Zero);
}
private static IntPtr _fieldGetter(int contextId, int classId, Int64 instancePtr, string fieldName)
{
IntPtr retValuePtr = IntPtr.Zero;
if (instancePtr != 0 &&
_exportsFields.ContainsKey(classId) &&
_exportsFields[classId].ContainsKey(fieldName))
{
LuaContext context = LuaContext.getContext(contextId);
LuaObjectReference objRef = LuaObjectReference.findObject(instancePtr);
object instance = objRef.target;
PropertyInfo propertyInfo = _exportsFields[classId][fieldName];
if (instance != null && propertyInfo != null && propertyInfo.CanRead)
{
object retValue = propertyInfo.GetValue(instance, null);
LuaValue value = new LuaValue(retValue);
LuaObjectEncoder encoder = new LuaObjectEncoder(context);
encoder.writeObject(value);
byte[] bytes = encoder.bytes;
retValuePtr = Marshal.AllocHGlobal(bytes.Length);
Marshal.Copy(bytes, 0, retValuePtr, bytes.Length);
}
}
return(retValuePtr);
}
/// <summary>
/// 序列化对象
/// </summary>
/// <param name="encoder">对象编码器.</param>
public override void serialization(LuaObjectEncoder encoder)
{
base.serialization(encoder);
IntPtr ptr = Marshal.GetIUnknownForObject(obj);
encoder.writeInt64(ptr.ToInt64());
encoder.writeString(luaObjectId != null ? luaObjectId : "");
}
/// <summary>
/// 序列化对象
/// </summary>
/// <param name="encoder">对象编码器.</param>
public override void serialization(LuaObjectEncoder encoder)
{
base.serialization(encoder);
encoder.writeInt32(_returnValues.Count);
foreach (LuaValue value in _returnValues)
{
encoder.writeObject(value);
}
}
/// <summary>
/// 调用方法
/// </summary>
/// <param name="arguments">参数列表</param>
/// <param name="scriptController">脚本控制器</param>
public LuaValue invoke(List <LuaValue> arguments, LuaScriptController scriptController)
{
int scriptControllerId = 0;
if (scriptController != null)
{
scriptControllerId = scriptController.objectId;
}
IntPtr funcPtr = IntPtr.Zero;
IntPtr argsPtr = IntPtr.Zero;
IntPtr resultPtr = IntPtr.Zero;
LuaObjectEncoder funcEncoder = new LuaObjectEncoder(_context);
funcEncoder.writeObject(this);
byte[] bytes = funcEncoder.bytes;
funcPtr = Marshal.AllocHGlobal(bytes.Length);
Marshal.Copy(bytes, 0, funcPtr, bytes.Length);
if (arguments != null)
{
LuaObjectEncoder argEncoder = new LuaObjectEncoder(_context);
argEncoder.writeInt32(arguments.Count);
foreach (LuaValue value in arguments)
{
argEncoder.writeObject(value);
}
bytes = argEncoder.bytes;
argsPtr = Marshal.AllocHGlobal(bytes.Length);
Marshal.Copy(bytes, 0, argsPtr, bytes.Length);
}
int size = NativeUtils.invokeLuaFunction(_context.objectId, funcPtr, argsPtr, scriptControllerId, out resultPtr);
if (argsPtr != IntPtr.Zero)
{
Marshal.FreeHGlobal(argsPtr);
}
if (funcPtr != IntPtr.Zero)
{
Marshal.FreeHGlobal(funcPtr);
}
if (size > 0)
{
return(LuaObjectDecoder.DecodeObject(resultPtr, size, _context) as LuaValue);
}
return(new LuaValue());
}
/// <summary>
/// 序列化对象
/// </summary>
/// <param name="encoder">对象编码器.</param>
public override void serialization(LuaObjectEncoder encoder)
{
base.serialization(encoder);
encoder.writeInt64(_objRef.referenceId);
encoder.writeString(luaObjectId);
//写入自定义数据
encoder.writeInt32(1);
encoder.writeString("NativeClass");
encoder.writeString(this.obj.GetType().FullName);
}
/// <summary>
/// 注册模块
/// </summary>
/// <param name="context">Lua上下文.</param>
/// <param name="moduleName">模块名称.</param>
/// <param name="t">类型.</param>
protected static void _register(LuaContext context, string moduleName, Type t)
{
//初始化模块导出信息
Dictionary <string, MethodInfo> exportMethods = new Dictionary <string, MethodInfo> ();
List <string> exportMethodNames = new List <string> ();
MethodInfo[] methods = t.GetMethods();
foreach (MethodInfo m in methods)
{
if (m.IsStatic && m.IsPublic)
{
//静态和公开的方法会导出到Lua
exportMethodNames.Add(m.Name);
exportMethods.Add(m.Name, m);
}
}
IntPtr exportMethodNamesPtr = IntPtr.Zero;
if (exportMethodNames.Count > 0)
{
LuaObjectEncoder encoder = new LuaObjectEncoder();
encoder.writeInt32(exportMethodNames.Count);
foreach (string name in exportMethodNames)
{
encoder.writeString(name);
}
byte[] bytes = encoder.bytes;
exportMethodNamesPtr = Marshal.AllocHGlobal(bytes.Length);
Marshal.Copy(bytes, 0, exportMethodNamesPtr, bytes.Length);
}
if (_moduleMethodHandleDelegate == null)
{
_moduleMethodHandleDelegate = new LuaModuleMethodHandleDelegate(luaModuleMethodRoute);
}
IntPtr fp = Marshal.GetFunctionPointerForDelegate(_moduleMethodHandleDelegate);
//注册模块
int moduleId = NativeUtils.registerModule(context.objectId, moduleName, exportMethodNamesPtr, fp);
//关联注册模块的注册方法
_exportsModuleMethods.Add(moduleId, exportMethods);
if (exportMethodNamesPtr != IntPtr.Zero)
{
Marshal.FreeHGlobal(exportMethodNamesPtr);
}
}
/// <summary>
/// 序列化对象
/// </summary>
/// <param name="encoder">对象编码器.</param>
public override void serialization(LuaObjectEncoder encoder)
{
base.serialization(encoder);
encoder.writeInt64(_objRef.referenceId);
encoder.writeString(luaObjectId);
//写入本地类型标识
int nativeTypeId = encoder.context.exportsTypemanager.getNativeTypeId(_objRef.target.GetType());
encoder.writeInt32(nativeTypeId);
//写入自定义数据
encoder.writeInt32(1);
encoder.writeString("NativeClass");
encoder.writeString(this.obj.GetType().FullName);
}
/// <summary>
/// 执行线程
/// </summary>
/// <param name="handler">线程处理器.</param>
/// <param name="arguments">参数列表.</param>
/// <param name="scriptController">脚本控制器.</param>
public void runThread(LuaFunction handler, List <LuaValue> arguments, LuaScriptController scriptController)
{
int scriptControllerId = 0;
if (scriptController != null)
{
scriptControllerId = scriptController.objectId;
}
IntPtr funcPtr = IntPtr.Zero;
IntPtr argsPtr = IntPtr.Zero;
LuaObjectEncoder funcEncoder = new LuaObjectEncoder(this);
funcEncoder.writeObject(handler);
byte[] bytes = funcEncoder.bytes;
funcPtr = Marshal.AllocHGlobal(bytes.Length);
Marshal.Copy(bytes, 0, funcPtr, bytes.Length);
if (arguments != null)
{
LuaObjectEncoder argEncoder = new LuaObjectEncoder(this);
argEncoder.writeInt32(arguments.Count);
foreach (LuaValue value in arguments)
{
argEncoder.writeObject(value);
}
bytes = argEncoder.bytes;
argsPtr = Marshal.AllocHGlobal(bytes.Length);
Marshal.Copy(bytes, 0, argsPtr, bytes.Length);
}
NativeUtils.runThread(this.objectId, funcPtr, argsPtr, scriptControllerId);
if (argsPtr != IntPtr.Zero)
{
Marshal.FreeHGlobal(argsPtr);
}
if (funcPtr != IntPtr.Zero)
{
Marshal.FreeHGlobal(funcPtr);
}
}
/// <summary>
/// 释放Lua层的变量引用，使其内存管理权交回Lua。
/// 注：判断value能否被释放取决于value所保存的真实对象，所以只要保证保存对象一致，即使value为不同对象并不影响实际效果。
/// 即：LuaValue *val1 = new LuaValue(obj1);与LuaValue *val2 = new LuaValue(obj1);传入方法中效果相同。
/// </summary>
/// <param name="value">value 对应Lua层变量的原生对象Value，如果value为非Lua回传对象则调用此方法无任何效果。.</param>
public void releaseValue(LuaValue value)
{
if (value != null)
{
IntPtr valuePtr = IntPtr.Zero;
LuaObjectEncoder encoder = new LuaObjectEncoder(this);
encoder.writeObject(value);
byte[] bytes = encoder.bytes;
valuePtr = Marshal.AllocHGlobal(bytes.Length);
Marshal.Copy(bytes, 0, valuePtr, bytes.Length);
NativeUtils.releaseValue(_nativeObjectId, valuePtr);
if (valuePtr != IntPtr.Zero)
{
Marshal.FreeHGlobal(valuePtr);
}
}
}
/// <summary>
/// 设置全局变量
/// </summary>
/// <param name="name">变量名称.</param>
/// <param name="value">变量值.</param>
public void setGlobal(string name, LuaValue value)
{
IntPtr valuePtr = IntPtr.Zero;
if (value != null)
{
LuaObjectEncoder encoder = new LuaObjectEncoder(this);
encoder.writeObject(value);
byte[] bytes = encoder.bytes;
valuePtr = Marshal.AllocHGlobal(bytes.Length);
Marshal.Copy(bytes, 0, valuePtr, bytes.Length);
}
NativeUtils.setGlobal(_nativeObjectId, name, valuePtr);
if (valuePtr != IntPtr.Zero)
{
Marshal.FreeHGlobal(valuePtr);
}
}
/// <summary>
/// Lua方法处理器
/// </summary>
/// <returns>返回值</returns>
/// <param name="methodName">方法名称</param>
/// <param name="arguments">参数列表</param>
private IntPtr luaMethodHandler(string methodName, IntPtr args, int size)
{
if (_methodHandlers.ContainsKey(methodName))
{
//反序列化参数列表
LuaObjectDecoder decoder = new LuaObjectDecoder(args, size);
int argSize = decoder.readInt32();
List <LuaValue> argumentsList = new List <LuaValue> ();
for (int i = 0; i < argSize; i++)
{
LuaValue value = decoder.readObject() as LuaValue;
argumentsList.Add(value);
}
LuaMethodHandler handler = _methodHandlers [methodName];
LuaValue retValue = handler(argumentsList);
if (retValue == null)
{
retValue = new LuaValue();
}
LuaObjectEncoder encoder = new LuaObjectEncoder();
encoder.writeObject(retValue);
byte[] bytes = encoder.bytes;
IntPtr retPtr;
retPtr = Marshal.AllocHGlobal(bytes.Length);
Marshal.Copy(bytes, 0, retPtr, bytes.Length);
return(retPtr);
}
return(IntPtr.Zero);
}
/// <summary>
/// 序列化对象
/// </summary>
/// <param name="encoder">对象编码器.</param>
public override void serialization(LuaObjectEncoder encoder)
{
base.serialization(encoder);
if (_context != null)
{
encoder.writeInt32(_context.objectId);
}
else
{
encoder.writeInt32(0);
}
encoder.writeString(_tableId);
encoder.writeInt16((Int16)type);
switch (type)
{
case LuaValueType.Number:
{
encoder.writeDouble(toNumber());
break;
}
case LuaValueType.Integer:
{
encoder.writeInt32(toInteger());
break;
}
case LuaValueType.String:
{
encoder.writeString(toString());
break;
}
case LuaValueType.Data:
{
encoder.writeBytes(toData());
break;
}
case LuaValueType.Array:
{
List <LuaValue> list = toArray();
encoder.writeInt32(list.Count);
foreach (LuaValue value in list)
{
encoder.writeObject(value);
}
break;
}
case LuaValueType.Map:
{
Dictionary <string, LuaValue> map = toMap();
encoder.writeInt32(map.Count);
foreach (KeyValuePair <string, LuaValue> kv in map)
{
encoder.writeString(kv.Key);
encoder.writeObject(kv.Value);
}
break;
}
case LuaValueType.Object:
{
encoder.writeObject(_value);
break;
}
case LuaValueType.Boolean:
{
encoder.writeByte(Convert.ToByte(toBoolean()));
break;
}
case LuaValueType.Function:
{
encoder.writeObject(toFunction());
break;
}
case LuaValueType.Ptr:
{
encoder.writeObject(toPointer());
break;
}
case LuaValueType.Tuple:
{
encoder.writeObject(toTuple());
break;
}
default:
break;
}
}
/// <summary>
/// 序列化对象
/// </summary>
/// <param name="encoder">对象编码器.</param>
public override void serialization(LuaObjectEncoder encoder)
{
base.serialization(encoder);
encoder.writeInt64(_objReference.referenceId);
}
// /// <summary>
// /// 获取原生类名称
// /// </summary>
// /// <value>类名称.</value>
// public virtual string nativeClassName
// {
// get
// {
// return "Object";
// }
// }
/// <summary>
/// 序列化对象
/// </summary>
/// <param name="encoder">对象编码器.</param>
public virtual void serialization(LuaObjectEncoder encoder)
{
encoder.writeByte((byte)'L');
encoder.writeString(this.GetType().Name);
encoder.writeByte((byte)';');
}
/// <summary>
/// 导出类型
/// </summary>
/// <param name="type">类型.</param>
/// <param name="context">上下文对象.</param>
public void exportType(Type t, LuaContext context)
{
LuaExportTypeAnnotation typeAnnotation = Attribute.GetCustomAttribute(t, typeof(LuaExportTypeAnnotation), false) as LuaExportTypeAnnotation;
LuaExportTypeAnnotation baseTypeAnnotation = Attribute.GetCustomAttribute(t.BaseType, typeof(LuaExportTypeAnnotation), false) as LuaExportTypeAnnotation;
//获取导出的类/实例方法
Dictionary <string, MethodInfo> exportClassMethods = new Dictionary <string, MethodInfo> ();
List <string> exportClassMethodNames = new List <string> ();
Dictionary <string, MethodInfo> exportInstanceMethods = new Dictionary <string, MethodInfo> ();
List <string> exportInstanceMethodNames = new List <string> ();
MethodInfo[] methods = t.GetMethods();
foreach (MethodInfo m in methods)
{
if (m.IsPublic || (m.IsStatic && m.IsPublic))
{
StringBuilder methodSignature = new StringBuilder();
foreach (ParameterInfo paramInfo in m.GetParameters())
{
Type paramType = paramInfo.ParameterType;
if (baseTypesMapping.ContainsKey(paramType))
{
methodSignature.Append(baseTypesMapping [paramType]);
}
else
{
methodSignature.Append("@");
}
}
string methodName = string.Format("{0}_{1}", m.Name, methodSignature.ToString());
if (m.IsStatic && m.IsPublic)
{
if (typeAnnotation != null &&
typeAnnotation.excludeExportClassMethodNames != null &&
Array.IndexOf(typeAnnotation.excludeExportClassMethodNames, m.Name) >= 0)
{
//为过滤方法
continue;
}
//静态和公开的方法会导出到Lua
exportClassMethodNames.Add(methodName);
exportClassMethods.Add(methodName, m);
}
else if (m.IsPublic)
{
if (typeAnnotation != null &&
typeAnnotation.excludeExportInstanceMethodNames != null &&
Array.IndexOf(typeAnnotation.excludeExportInstanceMethodNames, m.Name) >= 0)
{
//为过滤方法
continue;
}
//实例方法
exportInstanceMethodNames.Add(methodName);
exportInstanceMethods.Add(methodName, m);
}
}
}
//获取导出的字段
Dictionary <string, PropertyInfo> exportFields = new Dictionary <string, PropertyInfo> ();
List <string> exportPropertyNames = new List <string> ();
PropertyInfo[] propertys = t.GetProperties(BindingFlags.Instance | BindingFlags.Public);
foreach (PropertyInfo p in propertys)
{
if (typeAnnotation != null &&
typeAnnotation.excludeExportPropertyNames != null &&
Array.IndexOf(typeAnnotation.excludeExportPropertyNames, p.Name) >= 0)
{
//在过滤列表中
continue;
}
StringBuilder actStringBuilder = new StringBuilder();
if (p.CanRead)
{
actStringBuilder.Append("r");
}
if (p.CanWrite)
{
actStringBuilder.Append("w");
}
exportPropertyNames.Add(string.Format("{0}_{1}", p.Name, actStringBuilder.ToString()));
exportFields.Add(p.Name, p);
}
//创建导出的字段数据
IntPtr exportPropertyNamesPtr = IntPtr.Zero;
if (exportPropertyNames.Count > 0)
{
LuaObjectEncoder fieldEncoder = new LuaObjectEncoder(context);
fieldEncoder.writeInt32(exportPropertyNames.Count);
foreach (string name in exportPropertyNames)
{
fieldEncoder.writeString(name);
}
byte[] fieldNameBytes = fieldEncoder.bytes;
exportPropertyNamesPtr = Marshal.AllocHGlobal(fieldNameBytes.Length);
Marshal.Copy(fieldNameBytes, 0, exportPropertyNamesPtr, fieldNameBytes.Length);
}
//创建导出的实例方法数据
IntPtr exportInstanceMethodNamesPtr = IntPtr.Zero;
if (exportInstanceMethodNames.Count > 0)
{
LuaObjectEncoder instanceMethodEncoder = new LuaObjectEncoder(context);
instanceMethodEncoder.writeInt32(exportInstanceMethodNames.Count);
foreach (string name in exportInstanceMethodNames)
{
instanceMethodEncoder.writeString(name);
}
byte[] instMethodNameBytes = instanceMethodEncoder.bytes;
exportInstanceMethodNamesPtr = Marshal.AllocHGlobal(instMethodNameBytes.Length);
Marshal.Copy(instMethodNameBytes, 0, exportInstanceMethodNamesPtr, instMethodNameBytes.Length);
}
//创建导出类方法数据
IntPtr exportClassMethodNamesPtr = IntPtr.Zero;
if (exportClassMethodNames.Count > 0)
{
LuaObjectEncoder classMethodEncoder = new LuaObjectEncoder(context);
classMethodEncoder.writeInt32(exportClassMethodNames.Count);
foreach (string name in exportClassMethodNames)
{
classMethodEncoder.writeString(name);
}
byte[] classMethodNameBytes = classMethodEncoder.bytes;
exportClassMethodNamesPtr = Marshal.AllocHGlobal(classMethodNameBytes.Length);
Marshal.Copy(classMethodNameBytes, 0, exportClassMethodNamesPtr, classMethodNameBytes.Length);
}
//创建实例方法
if (_createInstanceDelegate == null)
{
_createInstanceDelegate = new LuaInstanceCreateHandleDelegate(_createInstance);
}
//销毁实例方法
if (_destroyInstanceDelegate == null)
{
_destroyInstanceDelegate = new LuaInstanceDestroyHandleDelegate(_destroyInstance);
}
//类描述
if (_instanceDescriptionDelegate == null)
{
_instanceDescriptionDelegate = new LuaInstanceDescriptionHandleDelegate(_instanceDescription);
}
//字段获取器
if (_fieldGetterDelegate == null)
{
_fieldGetterDelegate = new LuaInstanceFieldGetterHandleDelegate(_fieldGetter);
}
//字段设置器
if (_fieldSetterDelegate == null)
{
_fieldSetterDelegate = new LuaInstanceFieldSetterHandleDelegate(_fieldSetter);
}
//实例方法处理器
if (_instanceMethodHandlerDelegate == null)
{
_instanceMethodHandlerDelegate = new LuaInstanceMethodHandleDelegate(_instanceMethodHandler);
}
//类方法处理器
if (_classMethodHandleDelegate == null)
{
_classMethodHandleDelegate = new LuaModuleMethodHandleDelegate(_classMethodHandler);
}
string typeName = t.Name;
if (typeAnnotation != null && typeAnnotation.typeName != null)
{
typeName = typeAnnotation.typeName;
}
string baseTypeName = t.BaseType.Name;
if (baseTypeAnnotation != null && baseTypeAnnotation.typeName != null)
{
baseTypeName = baseTypeAnnotation.typeName;
}
int typeId = NativeUtils.registerType(
context.objectId,
typeName,
baseTypeName,
exportPropertyNamesPtr,
exportInstanceMethodNamesPtr,
exportClassMethodNamesPtr,
Marshal.GetFunctionPointerForDelegate(_createInstanceDelegate),
Marshal.GetFunctionPointerForDelegate(_destroyInstanceDelegate),
Marshal.GetFunctionPointerForDelegate(_instanceDescriptionDelegate),
Marshal.GetFunctionPointerForDelegate(_fieldGetterDelegate),
Marshal.GetFunctionPointerForDelegate(_fieldSetterDelegate),
Marshal.GetFunctionPointerForDelegate(_instanceMethodHandlerDelegate),
Marshal.GetFunctionPointerForDelegate(_classMethodHandleDelegate));
//关联注册模块的注册方法
_exportsClass[typeId] = t;
_exportsClassIdMapping [t] = typeId;
_exportsClassMethods[typeId] = exportClassMethods;
_exportsInstanceMethods[typeId] = exportInstanceMethods;
_exportsFields[typeId] = exportFields;
if (exportPropertyNamesPtr != IntPtr.Zero)
{
Marshal.FreeHGlobal(exportPropertyNamesPtr);
}
if (exportInstanceMethodNamesPtr != IntPtr.Zero)
{
Marshal.FreeHGlobal(exportInstanceMethodNamesPtr);
}
if (exportClassMethodNamesPtr != IntPtr.Zero)
{
Marshal.FreeHGlobal(exportClassMethodNamesPtr);
}
}
/// <summary>
/// 序列化对象
/// </summary>
/// <param name="encoder">对象编码器.</param>
public virtual void serialization(LuaObjectEncoder encoder)
{
encoder.writeInt32(_nativeObjectId);
}
