public EmitFieldBuilder DefineField(string name, EmitType type, EmitVisibility visibility = EmitVisibility.Public,
bool isStatic = false, bool isReadonly = false, bool isVolatile = false)
{
var field = new EmitFieldBuilder(this, name, type, visibility, isStatic, isReadonly);
memberBuilders.Add(new EmitFieldReference(() => field));
return field;
}
/// <summary>
/// Creates a new particleEmitter
/// </summary>
/// <param name="repeat">Should the emitter stay active and keep emitting particles after the max amount of particles have been emitted</param>
/// <param name="maxParticles">Max amount of particles</param>
/// <param name="emitLocation">The location to emit from</param>
/// <param name="direction">The velocity of the particles</param>
/// <param name="particleSpeed">The speed of the particles</param>
/// <param name="maxAngle">The angle based on the velocity the particles can be emitted from</param>
/// <param name="particleLifeTime">Lifetime of particles in seconds</param>
/// <param name="particleScale">Size of particles </param>
/// <param name="particleShape">Particle shape</param>
/// <param name="startColor">Starting particle color</param>
/// <param name="autoStart">Should the emitter start immediatly</param>
/// <param name="emitType">The type of the emitter</param>
/// <param name="endColor">The color of the particle at the end</param>
public ParticleEmitter(bool autoStart, bool repeat, int maxParticles, Vector2 emitLocation, Vector2 direction,
float particleSpeed, float maxAngle, float particleLifeTime, float particleScale, ParticleShape particleShape,
EmitType emitType, Color startColor, Color endColor)
{
this.repeat = repeat;
this.maxParticles = maxParticles;
this.Position = emitLocation;
this.ParticleDirection = direction;
this.particleSpeed = particleSpeed;
this.maxAngle = maxAngle;
this.particleLifeTime = particleLifeTime;
this.particleScale = particleScale;
this.particleShape = particleShape;
this.emitType = emitType;
this.startColor = startColor;
this.endColor = endColor;
this.Paused = !autoStart;
random = new Random();
if (repeat == false)
{
emitterLifeTime = particleLifeTime;
}
particleTexture = ParticleSystem.Instance.GetTexture(particleShape);
ParticleSystem.Instance.AddEmitter(this);
}
public EmitArrayInitializerExpression(EmitType type, EmitArrayInitializer initializer)
{
Type = type;
Initializer = initializer;
if (Initializer.Length == 0)
{
throw new EmitVerifyException("An array initiaizler expression must have at least one element.");
}
Rank = 0;
var lengths = new Queue <int>();
lengths.Enqueue(Initializer.Length);
var current = Initializer[0];
while (current != null)
{
Rank++;
if (current is EmitArrayInitializer)
{
lengths.Enqueue(current.Length);
current = current[0];
}
else
{
current = null;
}
}
Lengths = lengths.ToArray();
}
public EmitArrayInitializerExpression(EmitType type, EmitArrayInitializer initializer)
{
Type = type;
Initializer = initializer;
if (Initializer.Length == 0)
throw new EmitVerifyException("An array initiaizler expression must have at least one element.");
Rank = 0;
var lengths = new Queue<int>();
lengths.Enqueue(Initializer.Length);
var current = Initializer[0];
while (current != null)
{
Rank++;
if (current is EmitArrayInitializer)
{
lengths.Enqueue(current.Length);
current = current[0];
}
else
{
current = null;
}
}
Lengths = lengths.ToArray();
}
/// <summary>
/// Init the specified type, amt, rangeminx, rangemaxx, rangeminy, rangemaxy and emit.
/// </summary>
/// <param name="type">Type.</param>
/// <param name="amt">Amount.</param>
/// <param name="rangeminx">Minimum Range of X value.</param>
/// <param name="rangemaxx">Maximum Range of X value.</param>
/// <param name="rangeminy">Minimum Range of Y value.</param>
/// <param name="rangemaxy">Minimum Range of Y value.</param>
/// <param name="emit">Type of Emission.</param>
public void Init(ItemType[] type, int[] amt, float rangeminx, float rangemaxx, float rangeminy, float rangemaxy,
EmitType emit = EmitType.Impulse)
{
if(type.Length != amt.Length)
{
Debug.LogError("Total number of types and total number of amounts are different");
return;
}
for(int i = 0; i < type.Length; ++i)
{
map.Add(type[i], amt[i]);
}
m_rangeMinX = rangeminx;
m_rangeMaxX = rangemaxx;
m_rangeMinY = rangeminy;
m_rangeMaxY = rangemaxy;
List<ItemType> keys = new List<ItemType>(map.Keys);
m_type = emit;
foreach(ItemType tp in keys)
{
if(m_type == EmitType.Impulse)
ImpulseFire(tp, map[tp]);
else
StartCoroutine(CreateItemsWithInterval(tp, map[tp]));
}
}
public EmitMethodBuilder DefineMethod(string name, EmitType returnType, EmitVisibility visibility = EmitVisibility.Public,
bool isAbstract = false, bool isSealed = false, bool isVirtual = false, bool isOverride = false,
bool isExtern = false, bool isStatic = false)
{
var method = new EmitMethodBuilder(this, name, returnType, visibility, isStatic, isSealed, isVirtual, isAbstract);
memberBuilders.Add(new EmitMethodReference(() => method));
return method;
}
public static EmitObjectCreationExpression New(this EmitType type)
{
if (!type.IsValueType)
{
var constructor = type.Members.OfType <EmitConstructor>().Single(x => x.Parameters.Count == 0);
return(constructor.New());
}
return(new EmitObjectCreationExpression(type));
}
public EmitTypeBuilder(EmitAssembly assembly, string ns, string name, EmitTypeKind kind, EmitType declaringType,
EmitVisibility visibility, EmitTypeReference baseType, Func<EmitType, IReadOnlyList<EmitTypeReference>> implementedInterfacesFactory,
bool isAbstract, bool isSealed
)
: base(assembly, ns, name, kind, declaringType,
result => ((EmitTypeBuilder)result).memberBuilders = new List<EmitMemberReference>(),
visibility, baseType, implementedInterfacesFactory, isAbstract, isSealed)
{
}
public EmitArrayType(EmitAssembly assembly, string ns, string name, EmitTypeKind kind, EmitType declaringType,
Func<EmitType, IReadOnlyList<EmitMemberReference>> membersFactory, EmitTypeReference baseType,
EmitType elementType, int rank
)
: base(assembly, ns, name, kind, declaringType, membersFactory, elementType.Visibility, baseType, _ => new List<EmitTypeReference>(), true, true)
{
ElementType = elementType;
Rank = rank;
}
/// <summary>
/// Copy the source object.
/// </summary>
/// <param name="src">Specifies the source data.</param>
public override void Copy(OptionalParameter src)
{
base.Copy(src);
if (src is EmitConstraint)
{
EmitConstraint p = (EmitConstraint)src;
m_emitType = p.emit_type;
m_fEmitOverlap = p.emit_overlap;
}
}
public void InvokeInstanceMethod()
{
var x = 5;
var y = +x;
EmitType type = typeof(InstanceMethodClass);
var method = CreateMethod(block => block.Return(type.New().Call((EmitMethod)type.Members.Single(o => o.Name == "Mirror"), "foo")));
var result = (string)method.Invoke(null, null);
Assert.AreEqual("foo", result);
}
public override void Compile(EmitCompilerContext context, EmitIl il)
{
Expression.Compile(context, il);
var expressionType = Expression.GetExpressionType();
EmitType voidType = typeof(void);
if (expressionType.IsValueType && !context.Method.ReturnType.IsValueType && !Equals(expressionType, voidType))
{
il.Emit(EmitOpCodes.Box, Expression.GetExpressionType());
}
// else if (!Expression.GetType(context.TypeSystem).IsValueType && !context.Method.ReturnType.IsValueType)
// {
//
// }
il.Emit(EmitOpCodes.Ret);
}
/// <summary>
/// Set default values
/// </summary>
protected override void DefaultValues()
{
base.DefaultValues();
////this.ShapeType = ShapeType.Point;
this.LayerId = DefaultLayers.Additive;
this.emitType = EmitType.Rate;
this.emitDuration = 0;
this.emitAutomatically = true;
this.EmitRate = 100;
this.MaxParticles = 1000;
this.InitColor = Color.White;
this.InitLife = 1;
this.InitSpeed = 1;
this.InitSize = 0.1f;
this.ForcesCategory = ColliderCategory2D.Cat1;
this.Space = SpaceEnum.World;
this.LifeFactor = 1;
this.TimeFactor = 1;
}
public override void Compile(EmitCompilerContext context, EmitIl il)
{
var item = il.DeclareLocal(Item.Type);
Item.SetData(context, item);
EmitType genericEnumerableType = typeof(IEnumerable <>);
var enumerableType = genericEnumerableType.MakeGenericType(Item.Type);
var getEnumeratorMethod = enumerableType.Members.OfType <EmitMethod>().Single(x => x.Name == nameof(IEnumerable <object> .GetEnumerator));
EmitType genericEnumeratorType = typeof(IEnumerator <>);
var enumeratorType = genericEnumeratorType.MakeGenericType(Item.Type);
var moveNextMethod = enumerableType.Members.OfType <EmitMethod>().Single(x => x.Name == nameof(IEnumerator <object> .MoveNext));
var getCurrentMethod = enumerableType.Members.OfType <EmitProperty>().Single(x => x.Name == nameof(IEnumerator <object> .Current)).GetMethod;
var enumerator = il.DeclareLocal(enumeratorType);
Collection.Compile(context, il);
il.Emit(EmitOpCodes.Callvirt, getEnumeratorMethod);
il.Emit(EmitOpCodes.Stloc, enumerator);
var topOfLoop = il.DefineLabel();
var end = il.DefineLabel();
il.MarkLabel(topOfLoop);
il.Emit(EmitOpCodes.Ldloc, enumerator);
il.Emit(EmitOpCodes.Callvirt, moveNextMethod);
il.Emit(EmitOpCodes.Brfalse, end);
il.Emit(EmitOpCodes.Ldloc, enumerator);
il.Emit(EmitOpCodes.Callvirt, getCurrentMethod);
il.Emit(EmitOpCodes.Stloc, item);
Statement.Compile(context, il);
il.Emit(EmitOpCodes.Br, topOfLoop);
il.MarkLabel(end);
il.Emit(EmitOpCodes.Nop);
}
public MemberInfo VisitType(EmitType type, TypeBuilder parent)
{
var typeAttributes = ReflectionTypeAttributes.ToTypeAttributes(type.Kind, type.Visibility, type.DeclaringType != null, type.IsAbstract, type.IsSealed);
var interfaces = type.ImplementedInterfaces.Select(x => (Type)x).ToArray();
TypeBuilder typeBuilder;
if (parent == null)
{
typeBuilder = moduleBuilder.DefineType(type.Name, typeAttributes, type.BaseType, interfaces);
}
else
{
typeBuilder = parent.DefineNestedType(type.Name, typeAttributes, type.BaseType, interfaces);
}
foreach (var member in type.Members)
{
member.Accept(this, typeBuilder);
}
return(typeBuilder);
}
public EmitCastExpression(EmitExpression operand, EmitType type)
{
Operand = operand;
Type = type;
}
public EmitArrayInitializerExpression(EmitType type, params IEmitArrayElement[] elements)
: this(type, new EmitArrayInitializer(elements))
{
}
public EmitObjectCreationExpression(EmitType valueType)
{
Type = valueType;
}
public static EmitCastExpression Cast(this EmitExpression operand, EmitType type)
{
return new EmitCastExpression(operand, type);
}
public static EmitVariableDeclarationStatement Declare(EmitType type)
{
return new EmitVariableDeclarationStatement(new EmitVariable(type));
}
public EmitCastExpression(EmitExpression operand, EmitType type)
{
Operand = operand;
Type = type;
}
public EmitLocal DeclareLocal(EmitType type)
{
var local = new EmitLocal(type);
locals.Add(local);
return local;
}
private static Func<EmitType, IReadOnlyList<EmitTypeReference>> DeriveImplementedInterfaces(EmitType genericTypeDefinition)
{
return result => new List<EmitTypeReference>(genericTypeDefinition.ImplementedInterfaces.Select(x => new EmitTypeReference(() => x)));
}
public EmitObjectCreationExpression(EmitType valueType)
{
Type = valueType;
}
public EmitArrayCreationExpression(EmitType type, params EmitExpression[] lengths)
{
Type = type;
Lengths = lengths;
}
public static EmitCastExpression Cast(this EmitExpression operand, EmitType type)
{
return(new EmitCastExpression(operand, type));
}
public static EmitArrayCreationExpression NewArray(this EmitType elementType, params EmitExpression[] length)
{
return(new EmitArrayCreationExpression(elementType, length));
}
public EmitArrayCreationExpression(EmitType type, params EmitExpression[] lengths)
{
Type = type;
Lengths = lengths;
}
public EmitFieldBuilder(EmitType declaringType, string name, EmitType fieldType, EmitVisibility visibility, bool isStatic, bool isReadOnly)
: base(declaringType, name, fieldType, visibility, isStatic, isReadOnly)
{
}
public override void Compile(EmitCompilerContext context, EmitIl il)
{
Operand.Compile(context, il);
var operandType = Operand.GetExpressionType();
EmitType typeInt = typeof(int);
EmitType typeUint = typeof(uint);
EmitType typeShort = typeof(short);
EmitType typeUshort = typeof(ushort);
EmitType typeByte = typeof(byte);
EmitType typeSbyte = typeof(sbyte);
EmitType typeLong = typeof(long);
EmitType typeUlong = typeof(ulong);
EmitType typeDouble = typeof(double);
EmitType typeFloat = typeof(float);
EmitType typeDecimal = typeof(decimal);
EmitType typeBool = typeof(bool);
var typeIs32Bit = Equals(Type, typeByte) || Equals(Type, typeShort) || Equals(Type, typeInt) || Equals(Type, typeSbyte) || Equals(Type, typeUshort) || Equals(Type, typeUint);
var operandIs32Bit = Equals(operandType, typeByte) || Equals(operandType, typeShort) || Equals(operandType, typeInt) || Equals(operandType, typeSbyte) || Equals(operandType, typeUshort) || Equals(operandType, typeUint);
var typeIsFloatingPoint = Equals(Type, typeFloat) || Equals(Type, typeDouble);
var operandIsFloatingPoint = Equals(operandType, typeFloat) || Equals(operandType, typeDouble);
if (operandIs32Bit || operandIsFloatingPoint || Equals(operandType, typeLong))
{
if (Equals(Type, operandType))
{
return;
}
if (Equals(Type, typeFloat))
{
il.Emit(EmitOpCodes.Conv_R4);
return;
}
if (Equals(Type, typeDouble))
{
il.Emit(EmitOpCodes.Conv_R8);
return;
}
if (Equals(Type, typeByte))
{
il.Emit(EmitOpCodes.Conv_U1);
return;
}
if (Equals(Type, typeSbyte))
{
il.Emit(EmitOpCodes.Conv_I1);
return;
}
if (Equals(Type, typeShort))
{
il.Emit(EmitOpCodes.Conv_I2);
return;
}
if (Equals(Type, typeUshort))
{
il.Emit(EmitOpCodes.Conv_U2);
return;
}
if (Equals(Type, typeInt))
{
il.Emit(EmitOpCodes.Conv_I4);
return;
}
if (Equals(Type, typeUint))
{
il.Emit(EmitOpCodes.Conv_U4);
return;
}
if (Equals(Type, typeLong))
{
il.Emit(EmitOpCodes.Conv_I8);
return;
}
if (Equals(Type, typeUlong))
{
il.Emit(EmitOpCodes.Conv_U8);
return;
}
}
// All else fails, then:
il.Emit(EmitOpCodes.Castclass, Type);
}
public EmitLocal(EmitType type)
{
Type = type;
}
public EmitArrayInitializerExpression(EmitType type, params IEmitArrayElement[] elements) : this(type, new EmitArrayInitializer(elements))
{
}
/// <summary>
/// Copy the source object.
/// </summary>
/// <param name="src">Specifies the source data.</param>
public void Copy(EmitConstraint src)
{
m_emitType = src.emit_type;
m_fEmitOverlap = src.emit_overlap;
}
public EmitFieldBuilder(EmitType declaringType, string name, EmitType fieldType, EmitVisibility visibility, bool isStatic, bool isReadOnly) : base(declaringType, name, fieldType, visibility, isStatic, isReadOnly)
{
}
public EmitVariable(EmitType type)
{
Type = type;
}
public EmitInstruction Emit(IEmitOpCodeType opCode, EmitType type)
{
var instruction = new EmitInstruction(opCode, type);
AddInstruction(instruction);
return instruction;
}
public static EmitVariableDeclarationStatement Declare(EmitType type)
{
return(new EmitVariableDeclarationStatement(new EmitVariable(type)));
}
public static EmitVariableDeclarationStatement Declare(this EmitBlockStatement block, EmitType type)
{
var result = Declare(type);
block.Statements.Add(result);
return result;
}
public static EmitVariableDeclarationStatement Declare(this EmitBlockStatement block, EmitType type)
{
var result = Declare(type);
block.Statements.Add(result);
return(result);
}
public void Emit()
{
_returnValue = RootTable.CreateInternalValue(GetTypeSymbol(SpecialType.System_UInt32), "returnJump");
CurrentNode = EmitType.RoslynSymbol.DeclaringSyntaxReferences.First().GetSyntax();
DefaultExecutionOrder executionOrder = EmitType.GetAttribute <DefaultExecutionOrder>();
if (executionOrder != null)
{
if (executionOrder.order < (int.MinValue + 1000000))
{
throw new CompilerException($"Execution orders below int.MinValue + 1000000 are reserved for internal use in U#");
}
Module.ExecutionOrder = executionOrder.order;
}
TypeSymbol udonSharpBehaviourType = GetTypeSymbol(typeof(UdonSharpBehaviour));
Stack <TypeSymbol> emitTypeBases = new Stack <TypeSymbol>();
TypeSymbol currentEmitType = EmitType;
while (currentEmitType.BaseType != null)
{
emitTypeBases.Push(currentEmitType);
currentEmitType = currentEmitType.BaseType;
if (currentEmitType == udonSharpBehaviourType)
{
break;
}
}
if (currentEmitType != udonSharpBehaviourType)
{
throw new NotSupportedException("U# behaviour must inherit from UdonSharpBehaviour",
currentEmitType.RoslynSymbol.DeclaringSyntaxReferences.First().GetSyntax().GetLocation());
}
List <MethodSymbol> rootMethods = new List <MethodSymbol>();
List <FieldSymbol> userFields = new List <FieldSymbol>();
HashSet <FieldSymbol> visitedFields = new HashSet <FieldSymbol>();
// Visits each base class and searches for the most derived version of a method if it is overriden
// The intention with this is to ensure a consistent ordering between all inheritors of a base class
// This means that we can know that all inheritors of a class have the same method names and parameter symbol allocations
// which allows people to call virtual methods on UdonSharpBehaviours and have Udon just make it work
while (emitTypeBases.Count > 0)
{
TypeSymbol currentBase = emitTypeBases.Pop();
// Make sure fields get emitted
foreach (FieldSymbol field in currentBase.GetMembers <FieldSymbol>(this))
{
if (field.IsConst)
{
continue;
}
if (!visitedFields.Contains(field))
{
userFields.Add(field);
visitedFields.Add(field);
}
GetUserValue(field);
}
foreach (MethodSymbol methodSymbol in currentBase.GetMembers <MethodSymbol>(this))
{
if (methodSymbol.RoslynSymbol.IsImplicitlyDeclared ||
methodSymbol.RoslynSymbol.IsStatic)
{
continue;
}
if (methodSymbol.HasOverrides)
{
MethodSymbol derivedMethod = GetMostDerivedMethod(methodSymbol);
if (derivedMethod.RoslynSymbol.IsAbstract)
{
continue;
}
if (!rootMethods.Contains(derivedMethod))
{
rootMethods.Add(derivedMethod);
}
}
else if (!rootMethods.Contains(methodSymbol))
{
if (methodSymbol.RoslynSymbol.IsAbstract)
{
continue;
}
rootMethods.Add(methodSymbol);
}
}
}
DeclaredFields = userFields.ToImmutableArray();
InitConstFields();
HashSet <MethodSymbol> emittedSet = new HashSet <MethodSymbol>();
HashSet <MethodSymbol> setToEmit = new HashSet <MethodSymbol>();
// Do not roll this into the while loop, the order must be maintained for the root symbols so calls across behaviours work consistently
foreach (MethodSymbol methodSymbol in rootMethods)
{
using (new MethodEmitScope(methodSymbol, this))
{
methodSymbol.Emit(this);
}
emittedSet.Add(methodSymbol);
setToEmit.UnionWith(methodSymbol.DirectDependencies.OfType <MethodSymbol>());
}
while (setToEmit.Count > 0)
{
HashSet <MethodSymbol> newEmitSet = new HashSet <MethodSymbol>();
foreach (var methodSymbol in setToEmit)
{
if (emittedSet.Contains(methodSymbol))
{
continue;
}
if (methodSymbol.RoslynSymbol != null)
{
if (methodSymbol.RoslynSymbol.IsAbstract || methodSymbol.IsUntypedGenericMethod)
{
continue;
}
}
if (!methodSymbol.IsStatic && methodSymbol.ContainingType.IsUdonSharpBehaviour) // Prevent other behaviour type's methods from leaking into this type from calls across behaviours
{
TypeSymbol topType = EmitType;
bool foundType = false;
while (topType != udonSharpBehaviourType)
{
if (methodSymbol.ContainingType == topType)
{
foundType = true;
break;
}
topType = topType.BaseType;
}
if (!foundType)
{
continue;
}
}
using (new MethodEmitScope(methodSymbol, this))
{
methodSymbol.Emit(this);
}
emittedSet.Add(methodSymbol);
newEmitSet.UnionWith(methodSymbol.DirectDependencies.OfType <MethodSymbol>());
}
setToEmit = newEmitSet;
}
if (_recursiveStackVal != null)
{
_recursiveStackVal.DefaultValue = new object[_maxRecursiveStackPush];
}
DebugInfo.FinalizeAssemblyInfo();
}
public EmitMethodBuilder(EmitType declaringType, string name, EmitType returnType, EmitVisibility visibility, bool isStatic, bool isSealed, bool isVirtual, bool isAbstract)
: base(declaringType, name, returnType,
result => ((EmitMethodBuilder)result).parameters = new List<EmitParameter>(),
visibility, isStatic, isSealed, isVirtual, isAbstract)
{
}
public EmitVariable(EmitType type)
{
Type = type;
}
public static EmitArrayInitializerExpression NewArrayFrom(this EmitType elementType, Array elements)
{
return(new EmitArrayInitializerExpression(elementType, elements));
}
public EmitGenericType(EmitAssembly assembly, string ns, string name, EmitType declaringType, Func<EmitType, IReadOnlyList<EmitMemberReference>> membersFactory, EmitTypeReference baseType, EmitType genericTypeDefinition, IReadOnlyList<EmitType> typeArguments)
: base(assembly, ns, name, genericTypeDefinition.Kind, declaringType, membersFactory, genericTypeDefinition.Visibility, baseType, DeriveImplementedInterfaces(genericTypeDefinition), genericTypeDefinition.IsAbstract, genericTypeDefinition.IsSealed)
{
GenericTypeDefinition = genericTypeDefinition;
TypeArguments = typeArguments;
}
public EmitConstructorBuilder(EmitType declaringType, EmitVisibility visibility, bool isStatic)
: base(declaringType, result => ((EmitConstructorBuilder)result).parameters = new List<EmitParameter>(),
visibility, isStatic)
{
}
public EmitLocal(EmitType type)
{
Type = type;
}
public EmitParameter DefineParameter(EmitType parameterType, string name = null)
{
var parameter = new EmitParameter(name, parameterType);
parameters.Add(parameter);
return parameter;
}
