public void MethodCalc()
{
EasyType typebuilder = new EasyType(module, "mytype");
ArgumentReference arg1 = new ArgumentReference(typeof(int));
ArgumentReference arg2 = new ArgumentReference(typeof(int));
ReturnReferenceExpression ret = new ReturnReferenceExpression(typeof(int));
EasyMethod calcMethod = typebuilder.CreateMethod("Calc", ret, arg1, arg2);
calcMethod.CodeBuilder.AddStatement(
new ReturnStatement(
new BinaryExpression(BinaryExpression.Add, arg1.ToExpression(), arg2.ToExpression())));
Type newType = typebuilder.BuildType();
Assert.IsNotNull(newType);
object instance = Activator.CreateInstance(newType);
Assert.IsNotNull(instance);
MethodInfo method = instance.GetType().GetMethod("Calc");
Assert.AreEqual(2, method.Invoke(instance, new object[] { 1, 1 }));
Assert.AreEqual(5, method.Invoke(instance, new object[] { 3, 2 }));
RunPEVerify();
}
protected virtual EasyType CreateTypeBuilder(String typeName, Type baseType, Type[] interfaces)
{
_baseType = baseType;
_typeBuilder = new EasyType(ModuleScope, typeName, baseType, interfaces, true);
return(_typeBuilder);
}
public void NewInstanceExpression()
{
EasyType typebuilder = new EasyType(module, "mytype");
FieldReference cachefield = typebuilder.CreateField("cache", typeof(ArrayList));
EasyConstructor constructor = typebuilder.CreateConstructor( );
constructor.CodeBuilder.InvokeBaseConstructor();
constructor.CodeBuilder.AddStatement(new AssignStatement(cachefield,
new NewInstanceExpression(typeof(ArrayList), new Type[0])));
constructor.CodeBuilder.AddStatement(new ReturnStatement());
ReturnReferenceExpression ret = new ReturnReferenceExpression(typeof(ArrayList));
EasyMethod getCache = typebuilder.CreateMethod("GetCache", ret);
getCache.CodeBuilder.AddStatement(new ReturnStatement(cachefield));
Type newType = typebuilder.BuildType();
Assert.IsNotNull(newType);
object instance = Activator.CreateInstance(newType, new object[0]);
Assert.IsNotNull(instance);
MethodInfo method = instance.GetType().GetMethod("GetCache");
Assert.IsNotNull(method.Invoke(instance, new object[0]));
RunPEVerify();
}
public static Vector2 Lerp(Vector2 start, Vector2 end, float ratio, EasyType easyType = EasyType.None)
{
var lerpFunction = FindLerp(easyType);
return(new Vector2(x: lerpFunction(start.x, end.x, ratio),
y: lerpFunction(start.y, end.y, ratio)));
}
private IEnumerator CRMovingDownAndUp()
{
meshCollider.enabled = false;
float movingTime = 0.5f;
float t = 0;
Vector3 startPos = transform.position;
Vector3 endPos = new Vector3(startPos.x, startPos.y - 0.75f, startPos.z);
while (t < movingTime)
{
t += Time.deltaTime;
float factor = EasyType.MatchedLerpType(LerpType.EaseOutCubic, t / movingTime);
transform.position = Vector3.Lerp(startPos, endPos, factor);
yield return(null);
}
startPos = endPos;
endPos = new Vector3(startPos.x, startPos.y + 10f, startPos.z);
t = 0;
while (t < movingTime)
{
t += Time.deltaTime;
float factor = EasyType.MatchedLerpType(LerpType.EaseOutCubic, t / movingTime);
transform.position = Vector3.Lerp(startPos, endPos, factor);
yield return(null);
}
meshCollider.enabled = true;
gameObject.SetActive(false);
}
public void EmptyMethodWithEnumTypeRefArg()
{
EasyType typebuilder = new EasyType(module, "mytype");
SByteEnum refArgInst = SByteEnum.Two;
Type refType = GetEnumRefType(ref refArgInst);
Assert.IsTrue(refType.IsByRef);
ArgumentReference refArg = new ArgumentReference(refType);
ReturnReferenceExpression ret = new ReturnReferenceExpression(typeof(int));
EasyMethod emptyMethod = typebuilder.CreateMethod("DoSomething", ret, refArg);
Type newType = typebuilder.BuildType();
Assert.IsNotNull(newType);
object instance = Activator.CreateInstance(newType);
Assert.IsNotNull(instance);
MethodInfo method = instance.GetType().GetMethod("DoSomething");
method.Invoke(instance, new object[] { refArgInst });
Assert.AreEqual(SByteEnum.Two, refArgInst, "Argument made round-trip successfully");
RunPEVerify();
}
public void CreateMoreComplexCallable()
{
EasyType typebuilder = new EasyType(module, "mytype");
ArgumentReference arg1 = new ArgumentReference(typeof(int));
ArgumentReference arg2 = new ArgumentReference(typeof(DateTime));
ArgumentReference arg3 = new ArgumentReference(typeof(object));
EasyCallable callable = typebuilder.CreateCallable(
new ReturnReferenceExpression(typeof(string)),
arg1, arg2, arg3);
FieldReference field1 = typebuilder.CreateField("field1", callable.TypeBuilder);
SimpleCallback sc = new SimpleCallback();
ArgumentReference arg = new ArgumentReference(typeof(SimpleCallback));
EasyConstructor constructor = typebuilder.CreateConstructor(arg);
constructor.CodeBuilder.InvokeBaseConstructor();
constructor.CodeBuilder.AddStatement(new AssignStatement(field1,
new NewInstanceExpression(callable,
arg.ToExpression(),
new MethodPointerExpression(arg, typeof(SimpleCallback).GetMethod("RunAs")))));
constructor.CodeBuilder.AddStatement(new ReturnStatement());
arg1 = new ArgumentReference(typeof(int));
arg2 = new ArgumentReference(typeof(DateTime));
arg3 = new ArgumentReference(typeof(object));
ReturnReferenceExpression ret1 = new ReturnReferenceExpression(typeof(string));
EasyMethod getField1 = typebuilder.CreateMethod("Exec", ret1, arg1, arg2, arg3);
getField1.CodeBuilder.AddStatement(
new ReturnStatement(
new ConvertExpression(typeof(String),
new MethodInvocationExpression(field1,
callable.Callmethod,
new ReferencesToObjectArrayExpression(arg1, arg2, arg3)))));
Type newType = typebuilder.BuildType();
RunPEVerify();
object instance = Activator.CreateInstance(newType, new object[] { sc });
MethodInfo method = instance.GetType().GetMethod("Exec");
object result = method.Invoke(instance, new object[] { 1, DateTime.Now, "" });
Assert.AreEqual("hello2", result);
}
public void CreateSimpleType()
{
EasyType typebuilder = new EasyType(module, "mytype");
Type newType = typebuilder.BuildType();
Assert.IsNotNull(newType);
object instance = Activator.CreateInstance(newType);
Assert.IsNotNull(instance);
RunPEVerify();
}
private IEnumerator CRScalingRect(RectTransform rect, Vector2 startScale, Vector2 endScale, float scalingTime)
{
rect.localScale = startScale;
float t = 0;
while (t < scalingTime)
{
t += Time.deltaTime;
float factor = EasyType.MatchedLerpType(LerpType.EaseInOutQuart, t / scalingTime);
rect.localScale = Vector2.Lerp(startScale, endScale, factor);
yield return(null);
}
}
public static LerpAny FindLerp(EasyType easyType)
{
switch (easyType)
{
case EasyType.None:
return(Mathf.Lerp);
case EasyType.InQuad:
return(LerpInQuad);
case EasyType.OutQuad:
return(LerpOutQuad);
case EasyType.InOutQuad:
return(LerpInOutQuad);
case EasyType.InQuart:
return(LerpInQuart);
case EasyType.OutQuart:
return(LerpOutQuart);
case EasyType.InOutQuart:
return(LerpInOutQuart);
case EasyType.InSine:
return(LerpInSine);
case EasyType.OutSine:
return(LerpOutSine);
case EasyType.InOutSine:
return(LerpInOutSine);
case EasyType.InBounce:
return(LerpInBounce);
case EasyType.OutBounce:
return(LerpOutBounce);
case EasyType.InOutBounce:
return(LerpInOutBounce);
default:
return(Mathf.Lerp);
}
}
public void ArrayRefs()
{
EasyType typebuilder = new EasyType(module, "mytype");
FieldReference field1 = typebuilder.CreateField("field1", typeof(object));
FieldReference field2 = typebuilder.CreateField("field2", typeof(object));
ArgumentReference arg = new ArgumentReference(typeof(object[]));
EasyConstructor constructor = typebuilder.CreateConstructor(arg);
constructor.CodeBuilder.InvokeBaseConstructor();
constructor.CodeBuilder.AddStatement(new AssignStatement(field1,
new LoadRefArrayElementExpression(0, arg)));
constructor.CodeBuilder.AddStatement(new AssignStatement(field2,
new LoadRefArrayElementExpression(1, arg)));
constructor.CodeBuilder.AddStatement(new ReturnStatement());
ReturnReferenceExpression ret1 = new ReturnReferenceExpression(typeof(object));
EasyMethod getField1 = typebuilder.CreateMethod("GetField1", ret1);
getField1.CodeBuilder.AddStatement(new ReturnStatement(field1));
ReturnReferenceExpression ret2 = new ReturnReferenceExpression(typeof(object));
EasyMethod getField2 = typebuilder.CreateMethod("GetField2", ret2);
getField2.CodeBuilder.AddStatement(new ReturnStatement(field2));
Type newType = typebuilder.BuildType();
object[] innerArgs = new object[] { "hammett", "verissimo" };
object instance = Activator.CreateInstance(newType, new object[] { innerArgs });
MethodInfo method = instance.GetType().GetMethod("GetField1");
object result = method.Invoke(instance, new object[0]);
Assert.AreEqual("hammett", result);
method = instance.GetType().GetMethod("GetField2");
result = method.Invoke(instance, new object[0]);
Assert.AreEqual("verissimo", result);
RunPEVerify();
}
private IEnumerator CRFadingImage(Image image, float startAlpha, float endAlpha, float fadingTime)
{
Color startColor = image.color;
startColor.a = startAlpha;
image.color = startColor;
Color endColor = new Color(startColor.r, startColor.g, startColor.b, endAlpha);
float t = 0;
while (t < fadingTime)
{
t += Time.deltaTime;
float factor = EasyType.MatchedLerpType(LerpType.EaseInOutQuart, t / fadingTime);
image.color = Color.Lerp(startColor, endColor, factor);
yield return(null);
}
}
private IEnumerator CRMovingRect(RectTransform rect, Vector2 startPos, Vector2 endPos, float movingTime)
{
Vector2 currentPos = new Vector2(Mathf.RoundToInt(rect.anchoredPosition.x), Mathf.RoundToInt(rect.anchoredPosition.y));
if (!currentPos.Equals(endPos))
{
rect.anchoredPosition = startPos;
float t = 0;
while (t < movingTime)
{
t += Time.deltaTime;
float factor = EasyType.MatchedLerpType(LerpType.EaseInOutQuart, t / movingTime);
rect.anchoredPosition = Vector2.Lerp(startPos, endPos, factor);
yield return(null);
}
}
}
private IEnumerator MovingLeftAndRight(float amount, float speed, LerpType lerpType)
{
float t = 0;
float time = amount / speed;
Vector3 startPos = transform.position;
Vector3 endPos;
if (Random.value <= 0.5f)
{
endPos = startPos + Vector3.left * amount;
}
else
{
endPos = startPos + Vector3.right * amount;
}
while (t < time)
{
t += Time.deltaTime;
float factor = EasyType.MatchedLerpType(lerpType, t / time);
transform.position = Vector3.Lerp(startPos, endPos, factor);
yield return(null);
}
while (true)
{
t = 0;
startPos = transform.position;
if (startPos.x > 0) //On right
{
endPos = new Vector3(-amount, startPos.y, startPos.z);
}
else //On left
{
endPos = new Vector3(amount, startPos.y, startPos.z);
}
while (t < time)
{
t += Time.deltaTime;
float factor = EasyType.MatchedLerpType(lerpType, t / time);
transform.position = Vector3.Lerp(startPos, endPos, factor);
yield return(null);
}
}
}
public void CreateSimpleTypeWithConstructor()
{
EasyType typebuilder = new EasyType(module, "mytype");
ArgumentReference arg1 = new ArgumentReference(typeof(String));
ArgumentReference arg2 = new ArgumentReference(typeof(int));
typebuilder.CreateConstructor(arg1, arg2);
Type newType = typebuilder.BuildType();
Assert.IsNotNull(newType);
object instance = Activator.CreateInstance(newType, new object[] { "message", 10 });
Assert.IsNotNull(instance);
RunPEVerify();
}
public void FieldsStoreAndLoad()
{
EasyType typebuilder = new EasyType(module, "mytype");
FieldReference field1 = typebuilder.CreateField("field1", typeof(int));
FieldReference field2 = typebuilder.CreateField("field2", typeof(string));
{
ArgumentReference arg1 = new ArgumentReference(typeof(int));
ArgumentReference arg2 = new ArgumentReference(typeof(string));
EasyConstructor constr = typebuilder.CreateConstructor(arg1, arg2);
constr.CodeBuilder.InvokeBaseConstructor();
constr.CodeBuilder.AddStatement(new AssignStatement(field1, arg1.ToExpression()));
constr.CodeBuilder.AddStatement(new AssignStatement(field2, arg2.ToExpression()));
constr.CodeBuilder.AddStatement(new ReturnStatement());
}
{
ReturnReferenceExpression ret1 = new ReturnReferenceExpression(typeof(int));
EasyMethod m1 = typebuilder.CreateMethod("GetField1", ret1);
m1.CodeBuilder.AddStatement(new ReturnStatement(field1));
ReturnReferenceExpression ret2 = new ReturnReferenceExpression(typeof(string));
EasyMethod m2 = typebuilder.CreateMethod("GetField2", ret2);
m2.CodeBuilder.AddStatement(new ReturnStatement(field2));
}
Type newType = typebuilder.BuildType();
Assert.IsNotNull(newType);
object instance = Activator.CreateInstance(newType, new object[] { 10, "hello" });
Assert.IsNotNull(instance);
MethodInfo method1 = instance.GetType().GetMethod("GetField1");
MethodInfo method2 = instance.GetType().GetMethod("GetField2");
Assert.AreEqual(10, method1.Invoke(instance, new object[0]));
Assert.AreEqual("hello", method2.Invoke(instance, new object[0]));
RunPEVerify();
}
public void EmptyMethodReturningInt()
{
EasyType typebuilder = new EasyType(module, "mytype");
EasyMethod emptyMethod = typebuilder.CreateMethod("DoSomething",
new ReturnReferenceExpression(typeof(int)));
Type newType = typebuilder.BuildType();
Assert.IsNotNull(newType);
object instance = Activator.CreateInstance(newType);
Assert.IsNotNull(instance);
MethodInfo method = instance.GetType().GetMethod("DoSomething");
Assert.AreEqual(0, method.Invoke(instance, new object[0]));
RunPEVerify();
}
public void Conditionals()
{
EasyType typebuilder = new EasyType(module, "mytype");
FieldReference cachefield = typebuilder.CreateField("cache", typeof(IDictionary));
ArgumentReference arg = new ArgumentReference(typeof(bool));
EasyConstructor constructor = typebuilder.CreateConstructor(arg);
constructor.CodeBuilder.InvokeBaseConstructor();
ConditionExpression exp = new ConditionExpression(OpCodes.Brtrue_S, arg.ToExpression());
exp.AddTrueStatement(new AssignStatement(cachefield,
new NewInstanceExpression(typeof(HybridDictionary), new Type[0])));
exp.AddFalseStatement(new AssignStatement(cachefield,
new NewInstanceExpression(typeof(Hashtable), new Type[0])));
constructor.CodeBuilder.AddStatement(new ExpressionStatement(exp));
constructor.CodeBuilder.AddStatement(new ReturnStatement());
ReturnReferenceExpression ret = new ReturnReferenceExpression(typeof(IDictionary));
EasyMethod getCache = typebuilder.CreateMethod("GetCache", ret);
getCache.CodeBuilder.AddStatement(new ReturnStatement(cachefield));
Type newType = typebuilder.BuildType();
object instance = Activator.CreateInstance(newType, new object[] { true });
MethodInfo method = instance.GetType().GetMethod("GetCache");
object dic = method.Invoke(instance, new object[0]);
Assert.IsTrue(dic is HybridDictionary);
instance = Activator.CreateInstance(newType, new object[] { false });
dic = method.Invoke(instance, new object[0]);
Assert.IsTrue(dic is Hashtable);
RunPEVerify();
}
public static float Lerp(float start, float end, float ratio, EasyType easyType = EasyType.None)
{
var lerpFunction = FindLerp(easyType);
return(lerpFunction(start, end, ratio));
}