public EmitStoreField(FieldInfo field, IEmitterType targetObject, IEmitterType value)
{
_field = field;
_targetObject = targetObject;
_value = value;
ObjectType = _field.FieldType;
}
public CodeGenerator EmitCall(MethodInfo method, IEmitterType invocationObject, params IEmitterType[] arguments)
{
ParameterInfo[] actualArguments = method.GetParameters();
if (arguments.IsNull())
{
arguments = new IEmitterType[0];
}
if (arguments.Length != actualArguments.Length)
{
throw new ArgumentException();
}
if (invocationObject.IsNotNull())
{
invocationObject.Emit(this);
}
for (var i = 0; i < arguments.Length; i++)
{
arguments[i].Emit(this);
CastType(arguments[i].ObjectType, actualArguments[i].ParameterType);
}
EmitCall(method);
return(this);
}
internal void Initialize()
{
if (info.Attachments.Count > 0)
{
for (int i = 0; i < info.Attachments.Count; i++)
{
object obj = AssemblyManager.CreateInstance(info.Attachments[i]);
if (obj != null)
{
attachments.Add(obj as IAttachment);
updateAttachments.Add(obj as IUpdate);
}
}
}
if (info.CycleType != null)
{
object obj = AssemblyManager.CreateInstance(info.CycleType);
if (obj != null)
{
updateAttachments.Add(obj as IUpdate);
spawnCycle = obj as Cycle;
spawnCycle.OnSpawn += new OnSpawnEvent(GenerateParticles);
spawnCycle.OnComplete += new OnSpawnCompleteEvent(SpawningComplete);
}
}
if (info.EmitterType != null)
{
object obj = AssemblyManager.CreateInstance(info.EmitterType);
if (obj != null)
{
if (obj is IUpdate)
{
updateAttachments.Add(obj as IUpdate);
}
emitter = obj as IEmitterType;
}
}
if (info.ParticleRenderType != null)
{
object obj = AssemblyManager.CreateInstance(info.ParticleRenderType);
if (obj != null)
{
if (obj is IUpdate)
{
updateAttachments.Add(obj as IUpdate);
}
particleType = obj as IParticleType;
}
}
}
public EmitterCallMethod(MethodInfo method, IEmitterType invocationObject, params IEmitterType[] arguments)
{
_method = method;
_invocationObject = invocationObject;
_arguments = arguments;
ObjectType = _method.ReturnType;
}
public EmitStoreProperty(PropertyInfo property, IEmitterType targetObject, IEmitterType value)
{
MethodInfo method = property.GetSetMethod();
_callMethod = EmitMethod.Call(method, targetObject, value);
ObjectType = _callMethod.ObjectType;
}
public CodeGenerator EmitCall(MethodInfo method, IEmitterType invocationObject, params IEmitterType[] arguments)
{
ParameterInfo[] actualArguments = method.GetParameters();
if (arguments.IsNull())
{
arguments = new IEmitterType[0];
}
if (arguments.Length != actualArguments.Length)
{
throw new ArgumentException();
}
if (invocationObject.IsNotNull())
{
invocationObject.Emit(this);
}
for (var i = 0; i < arguments.Length; i++)
{
arguments[i].Emit(this);
CastType(arguments[i].ObjectType, actualArguments[i].ParameterType);
}
EmitCall(method);
return this;
}
private IEmitter Build(TypePair parentTypePair, MappingMemberPath memberPath)
{
if (memberPath.OneLevelTarget)
{
var sourceObject = EmitArgument.Load(memberPath.TypePair.Source, 1);
var targetObject = EmitArgument.Load(memberPath.TypePair.Target, 2);
var sourceMember = LoadMember(memberPath.Source, sourceObject, memberPath.Source.Count);
var targetMember = LoadMember(memberPath.Target, targetObject, memberPath.Target.Count);
IEmitterType convertedMember = ConvertMember(parentTypePair, memberPath.Tail, sourceMember, targetMember);
IEmitter result = StoreTargetObjectMember(memberPath.Tail, targetObject, convertedMember);
return(result);
}
else
{
var targetObject = EmitArgument.Load(memberPath.Head.TypePair.Target, 2);
var targetMember = LoadMember(memberPath.Target, targetObject, memberPath.Target.Count - 1);
var sourceObject = EmitArgument.Load(memberPath.Head.TypePair.Source, 1);
var sourceMember = LoadMember(memberPath.Source, sourceObject, memberPath.Source.Count);
IEmitterType convertedMember = ConvertMember(parentTypePair, memberPath.Tail, sourceMember, targetMember);
IEmitter result = StoreTargetObjectMember(memberPath.Tail, targetMember, convertedMember);
return(result);
}
}
public EmitStoreField(FieldInfo field, IEmitterType targetObject, IEmitterType value)
{
_field = field;
_targetObject = targetObject;
_value = value;
ObjectType = _field.FieldType;
}
public EmitterCallMethod(MethodInfo method, IEmitterType invocationObject, params IEmitterType[] arguments)
{
_method = method;
_invocationObject = invocationObject;
_arguments = arguments;
ObjectType = _method.ReturnType;
}
public Emitter(Texture2D texture, EmitterParticleState particleState, IEmitterType emitterType, int nbParticleEmittedPerUpdate, int maxParticles)
: base(texture)
{
_emitterParticleState = particleState;
_emitterType = emitterType;
_nbParticleEmittedPerUpdate = nbParticleEmittedPerUpdate;
_maxNbParticle = maxParticles;
}
public Emitter(Texture2D texture, Vector2 position, EmitterParticleState particleState, IEmitterType emitterType, int nbParticleEmittedPerUpdate, int maxParticles)
{
_emitterParticleState = particleState;
_emitterType = emitterType;
_texture = texture;
_nbParticleEmittedPerUpdate = nbParticleEmittedPerUpdate;
_maxNbParticle = maxParticles;
Position = position;
}
private static IEmitterType StoreTargetObjectMember(MappingMember member, IEmitterType targetObject, IEmitterType convertedMember)
{
IEmitterType result = null;
member.Target
.ToOption()
.Match(x => x.IsField(), x => result = StoreFiled((FieldInfo)x, targetObject, convertedMember))
.Match(x => x.IsProperty(), x => result = StoreProperty((PropertyInfo)x, targetObject, convertedMember));
return result;
}
private static void EmitCreateTargetInstance(Type targetType, TypeBuilder typeBuilder)
{
MethodBuilder methodBuilder = typeBuilder.DefineMethod(CreateTargetInstanceMethod, OverrideProtected, targetType, Type.EmptyTypes);
var codeGenerator = new CodeGenerator(methodBuilder.GetILGenerator());
IEmitterType result = targetType.IsValueType ? EmitValueType(targetType, codeGenerator) : EmitRefType(targetType);
EmitReturn.Return(result, targetType).Emit(codeGenerator);
}
private IEmitterType LoadMember(MemberInfo member, IEmitterType sourceObject)
{
IEmitterType result = null;
member.ToOption()
.Match(x => x.IsField(), x => result = LoadField(sourceObject, (FieldInfo)x))
.Match(x => x.IsProperty(), x => result = LoadProperty(sourceObject, (PropertyInfo)x));
return(result);
}
public IEmitterType EmitMapMethod(IEmitterType sourceMemeber, IEmitterType targetMember)
{
Type mapperType = typeof(Mapper);
MethodInfo mapMethod = mapperType.GetMethod(Mapper.MapMethodName, BindingFlags.Instance | BindingFlags.Public);
FieldInfo mappersField = mapperType.GetField(Mapper.MappersFieldName, BindingFlags.Instance | BindingFlags.NonPublic);
IEmitterType mappers = EmitField.Load(EmitThis.Load(mapperType), mappersField);
IEmitterType mapper = EmitArray.Load(mappers, Id);
IEmitterType result = EmitMethod.Call(mapMethod, mapper, sourceMemeber, targetMember);
return result;
}
private static IEmitterType StoreTargetObjectMember(MappingMember member, IEmitterType targetObject, IEmitterType convertedMember)
{
IEmitterType result = null;
member.Target
.ToOption()
.Match(x => x.IsField(), x => result = StoreFiled((FieldInfo)x, targetObject, convertedMember))
.Match(x => x.IsProperty(), x => result = StoreProperty((PropertyInfo)x, targetObject, convertedMember));
return(result);
}
public IEmitterType EmitMapMethod(IEmitterType sourceMemeber, IEmitterType targetMember)
{
Type mapperType = typeof(Mapper);
MethodInfo mapMethod = mapperType.GetMethod(Mapper.MapMethodName, BindingFlags.Instance | BindingFlags.Public);
FieldInfo mappersField = mapperType.GetField(Mapper.MappersFieldName, BindingFlags.Instance | BindingFlags.NonPublic);
IEmitterType mappers = EmitField.Load(EmitThis.Load(mapperType), mappersField);
IEmitterType mapper = EmitArray.Load(mappers, Id);
IEmitterType result = EmitMethod.Call(mapMethod, mapper, sourceMemeber, targetMember);
return(result);
}
public IEmitterType EmitMapMethod(IEmitterType sourceMember, IEmitterType targetMember)
{
var mapperType = typeof(Mapper);
var mapMethod = mapperType.GetMethod(Mapper.MAP_METHOD_NAME, BindingFlags.Instance | BindingFlags.Public);
var mappersField = mapperType.GetField(Mapper.MAPPERS_FIELD_NAME, BindingFlags.Instance | BindingFlags.NonPublic);
var mappers = EmitField.Load(EmitThis.Load(mapperType), mappersField);
var mapper = EmitArray.Load(mappers, Id);
var result = EmitMethod.Call(mapMethod, mapper, sourceMember, targetMember);
return(result);
}
private IEmitterType ConvertMember(MappingMember member, IEmitterType sourceMemeber, IEmitterType targetMember)
{
if (member.TypePair.IsDeepCloneable)
{
return sourceMemeber;
}
MapperCacheItem mapperCacheItem = CreateMapperCacheItem(member.TypePair);
IEmitterType result = mapperCacheItem.EmitMapMethod(sourceMemeber, targetMember);
return result;
}
private IEmitterType ConvertMember(TypePair parentTypePair, MappingMember member, IEmitterType sourceMemeber, IEmitterType targetMember)
{
if (member.TypePair.IsDeepCloneable && _config.GetBindingConfig(parentTypePair).HasNoValue)
{
return sourceMemeber;
}
MapperCacheItem mapperCacheItem = CreateMapperCacheItem(parentTypePair, member);
IEmitterType result = mapperCacheItem.EmitMapMethod(sourceMemeber, targetMember);
return result;
}
private IEmitterType ConvertMember(MappingMember member, IEmitterType sourceMemeber, IEmitterType targetMember)
{
if (member.TypePair.IsDeepCloneable)
{
return(sourceMemeber);
}
MapperCacheItem mapperCacheItem = CreateMapperCacheItem(member.TypePair);
IEmitterType result = mapperCacheItem.EmitMapMethod(sourceMemeber, targetMember);
return(result);
}
private void EmitConvertItem(TypeBuilder typeBuilder, TypePair typePair, string methodName = ConvertItemMethod)
{
MapperCacheItem mapperCacheItem = CreateMapperCacheItem(typePair);
MethodBuilder methodBuilder = typeBuilder.DefineMethod(methodName, OverrideProtected, typeof(object), new[] { typeof(object) });
IEmitterType sourceMemeber = EmitArgument.Load(typeof(object), 1);
IEmitterType targetMember = EmitNull.Load();
IEmitterType callMapMethod = mapperCacheItem.EmitMapMethod(sourceMemeber, targetMember);
EmitReturn.Return(callMapMethod).Emit(new CodeGenerator(methodBuilder.GetILGenerator()));
}
private IEmitter Build(MappingMember member)
{
IEmitterType sourceObject = EmitArgument.Load(member.TypePair.Source, 1);
IEmitterType targetObject = EmitArgument.Load(member.TypePair.Target, 2);
IEmitterType sourceMember = LoadMember(member.Source, sourceObject);
IEmitterType targetMember = LoadMember(member.Target, targetObject);
IEmitterType convertedMember = ConvertMember(member, sourceMember, targetMember);
IEmitter result = StoreTargetObjectMember(member, targetObject, convertedMember);
return(result);
}
private IEmitterType ConvertMember(TypePair parentTypePair, MappingMember member, IEmitterType sourceMemeber, IEmitterType targetMember)
{
// if (member.TypePair.IsDeepCloneable && _config.GetBindingConfig(parentTypePair).HasNoValue)
if (member.TypePair.IsDeepCloneable)
{
return(sourceMemeber);
}
MapperCacheItem mapperCacheItem = CreateMapperCacheItem(parentTypePair, member);
IEmitterType result = mapperCacheItem.EmitMapMethod(sourceMemeber, targetMember);
return(result);
}
private IEmitterType LoadMember(List <MemberInfo> members, IEmitterType sourceObject, int loadLevel)
{
IEmitterType dummySource = sourceObject;
if (members.Count == 1)
{
return(LoadMember(members[0], dummySource));
}
for (int i = 0; i < loadLevel; i++)
{
dummySource = LoadMember(members[i], dummySource);
}
return(dummySource);
}
private void EmitEnumerableToTarget(Type parentType, TypeBuilder typeBuilder, TypePair typePair,
string methodName, string templateMethodName)
{
MethodBuilder methodBuilder = typeBuilder.DefineMethod(methodName, OverrideProtected, typePair.Target, new[] { typeof(IEnumerable) });
Type sourceItemType = typePair.Source.GetCollectionItemType();
Type targetItemType = typePair.Target.GetCollectionItemType();
EmitConvertItem(typeBuilder, new TypePair(sourceItemType, targetItemType));
MethodInfo methodTemplate = parentType.GetGenericMethod(templateMethodName, targetItemType);
IEmitterType returnValue = EmitMethod.Call(methodTemplate, EmitThis.Load(parentType), EmitArgument.Load(typeof(IEnumerable), 1));
EmitReturn.Return(returnValue).Emit(new CodeGenerator(methodBuilder.GetILGenerator()));
}
private void EmitDictionaryToTarget(Type parentType, TypeBuilder typeBuilder, TypePair typePair,
string methodName, string templateMethodName)
{
MethodBuilder methodBuilder = typeBuilder.DefineMethod(methodName, OverrideProtected, typePair.Target, new[] { typeof(IEnumerable) });
KeyValuePair <Type, Type> sourceTypes = typePair.Source.GetDictionaryItemTypes();
KeyValuePair <Type, Type> targetTypes = typePair.Target.GetDictionaryItemTypes();
EmitConvertItem(typeBuilder, new TypePair(sourceTypes.Key, targetTypes.Key), ConvertItemKeyMethod);
EmitConvertItem(typeBuilder, new TypePair(sourceTypes.Value, targetTypes.Value));
var arguments = new[] { sourceTypes.Key, sourceTypes.Value, targetTypes.Key, targetTypes.Value };
MethodInfo methodTemplate = parentType.GetGenericMethod(templateMethodName, arguments);
IEmitterType returnValue = EmitMethod.Call(methodTemplate, EmitThis.Load(parentType), EmitArgument.Load(typeof(IEnumerable), 1));
EmitReturn.Return(returnValue).Emit(new CodeGenerator(methodBuilder.GetILGenerator()));
}
private void EmitEnumerableToTarget(
Type parentType,
TypeBuilder typeBuilder,
TypePair typePair,
TypePair collectionItemTypePair,
string methodName,
string templateMethodName)
{
MethodBuilder methodBuilder = typeBuilder.DefineMethod(methodName, OVERRIDE_PROTECTED, typePair.Target, new[] { typeof(IEnumerable) });
EmitConvertItem(typeBuilder, collectionItemTypePair);
MethodInfo methodTemplate = parentType.GetGenericMethod(templateMethodName, collectionItemTypePair.Target);
IEmitterType returnValue = EmitMethod.Call(methodTemplate, EmitThis.Load(parentType), EmitArgument.Load(typeof(IEnumerable), 1));
EmitReturn.Return(returnValue).Emit(new CodeGenerator(methodBuilder.GetILGenerator()));
}
/// <summary>
/// Creates a new Factory.
/// </summary>
/// <param name="id">The unique identifaction name to give the Factory.</param>
public Factory(string id, ParameterCollection spawnType,
ParameterCollection spawnObject, ParameterCollection cycleInfo)
{
this.id = id;
spawnObj = spawnObject;
object emit = AssemblyManager.CreateInstance(spawnType);
if (emit != null)
{
emitter = emit as IEmitterType;
}
object cyc = AssemblyManager.CreateInstance(cycleInfo);
if (cyc != null)
{
cycle = cyc as Cycle;
cycle.OnSpawn += new OnSpawnEvent(Spawn);
}
}
public static IEmitterType Load(IEmitterType source, PropertyInfo property)
{
return new EmitLoadProperty(source, property);
}
public static IEmitterType Box(IEmitterType value)
{
return(new EmitBox(value));
}
private static IEmitterType StoreFiled(FieldInfo field, IEmitterType targetObject, IEmitterType value)
{
return EmitField.Store(field, targetObject, value);
}
public EmitStoreProperty(PropertyInfo property, IEmitterType targetObject, IEmitterType value)
{
MethodInfo method = property.GetSetMethod();
_callMethod = EmitMethod.Call(method, targetObject, value);
ObjectType = _callMethod.ObjectType;
}
private static IEmitterType StoreProperty(PropertyInfo property, IEmitterType targetObject, IEmitterType value)
{
return(EmitProperty.Store(property, targetObject, value));
}
public static IEmitterType Box(IEmitterType value)
{
return new EmitBox(value);
}
private IEmitterType LoadProperty(IEmitterType source, PropertyInfo property)
{
return EmitProperty.Load(source, property);
}
private IEmitterType LoadProperty(IEmitterType source, PropertyInfo property)
{
return(EmitProperty.Load(source, property));
}
private EmitBox(IEmitterType value)
{
_value = value;
ObjectType = value.ObjectType;
}
public static IEmitterType Return(IEmitterType returnValue, Type returnType = null)
{
return new EmitReturn(returnValue, returnType);
}
private IEmitterType LoadField(IEmitterType source, FieldInfo field)
{
return EmitField.Load(source, field);
}
private IEmitterType LoadMember(MemberInfo member, IEmitterType sourceObject)
{
IEmitterType result = null;
member.ToOption()
.Match(x => x.IsField(), x => result = LoadField(sourceObject, (FieldInfo)x))
.Match(x => x.IsProperty(), x => result = LoadProperty(sourceObject, (PropertyInfo)x));
return result;
}
public static IEmitterType Load(IEmitterType array, int index)
{
return new EmitLoadArray(array, index);
}
public EmitLoadArray(IEmitterType array, int index)
{
_array = array;
_index = index;
ObjectType = array.ObjectType.GetElementType();
}
public static IEmitterType Call(MethodInfo method, IEmitterType invocationObject, params IEmitterType[] arguments)
{
return new EmitterCallMethod(method, invocationObject, arguments);
}
public static IEmitterType Store(FieldInfo field, IEmitterType targetObject, IEmitterType value)
{
return new EmitStoreField(field, targetObject, value);
}
public static IEmitterType Load(IEmitterType source, FieldInfo field)
{
var result = new EmitLoadField(source, field);
return result;
}
private IEmitterType LoadField(IEmitterType source, FieldInfo field)
{
return(EmitField.Load(source, field));
}
public EmitLoadProperty(IEmitterType source, PropertyInfo property)
{
_source = source;
_property = property;
ObjectType = property.PropertyType;
}
private EmitBox(IEmitterType value)
{
_value = value;
ObjectType = value.ObjectType;
}
private EmitReturn(IEmitterType returnValue, Type returnType)
{
ObjectType = returnType ?? returnValue.ObjectType;
_returnValue = returnValue;
}
private static IEmitterType StoreFiled(FieldInfo field, IEmitterType targetObject, IEmitterType value)
{
return(EmitField.Store(field, targetObject, value));
}
public static IEmitterType Load(IEmitterType source, PropertyInfo property)
{
return(new EmitLoadProperty(source, property));
}
public static IEmitterType Store(PropertyInfo property, IEmitterType targetObject, IEmitterType value)
{
return new EmitStoreProperty(property, targetObject, value);
}
public EmitLoadProperty(IEmitterType source, PropertyInfo property)
{
_source = source;
_property = property;
ObjectType = property.PropertyType;
}
public EmitLoadField(IEmitterType source, FieldInfo field)
{
_source = source;
_field = field;
ObjectType = field.FieldType;
}
private static IEmitterType StoreProperty(PropertyInfo property, IEmitterType targetObject, IEmitterType value)
{
return EmitProperty.Store(property, targetObject, value);
}
