public void SetParameter(ModuleBinding module, ParameterBinding param, object value)
{
var binding = new Binding();
binding.Module = module;
binding.Parameter = param;
SetParameter(binding, value);
}
/// <inheritdoc />
protected override AmbientNamespaceDefinition?GetNamespaceDefinition()
{
var members = new List <NamespaceFunctionDefinition>();
foreach (NameResolutionSemantics semantics in Enum.GetValues(typeof(NameResolutionSemantics)))
{
var memberName = ToCamelCase(semantics.ToString());
members.Add(Function(memberName, ModuleBinding.CreateEnum(Symbol(memberName), (int)semantics)));
}
return(new AmbientNamespaceDefinition(
typeof(NameResolutionSemantics).Name,
members.ToArray()));
}
/// <inheritdoc />
protected override AmbientNamespaceDefinition?GetNamespaceDefinition()
{
var members = new List <NamespaceFunctionDefinition>();
foreach (SealSourceDirectoryOption kind in Enum.GetValues(typeof(SealSourceDirectoryOption)))
{
var memberName = ToCamelCase(kind.ToString());
members.Add(Function(memberName, ModuleBinding.CreateEnum(Symbol(memberName), (int)kind)));
}
return(new AmbientNamespaceDefinition(
"Transformer." + typeof(SealSourceDirectoryOption).Name,
members.ToArray()));
}
private List <NamespaceFunctionDefinition> GetGlobalFunctionDefinitions()
{
var globRecursivelyBinding = ModuleBinding.CreateFun(Symbol(Constants.Names.GlobRFunction), GlobRecursively, GlobSignature, StringTable);
return(new List <NamespaceFunctionDefinition>
{
Function(Constants.Names.GlobFunction, this.Glob, GlobSignature),
Function(Constants.Names.GlobRFunction, globRecursivelyBinding),
Function(Constants.Names.GlobRecursivelyFunction, globRecursivelyBinding),
Function(Constants.Names.GlobFoldersFunction, this.GlobFolders, GlobFoldersSignature),
Function("addIf", AddIf, AddIfSignature),
Function("addIfLazy", AddIfLazy, AddIfLazySignature),
Function("sign", Sign, SignSignature),
});
}
/// <inheritdoc />
protected override AmbientNamespaceDefinition?GetNamespaceDefinition()
{
var members = new List <NamespaceFunctionDefinition>();
Type containerIsolationLevelType = typeof(ContainerIsolationLevel);
foreach (string isolationLevelName in Enum.GetNames(containerIsolationLevelType))
{
var value = Enum.Parse(containerIsolationLevelType, isolationLevelName);
var memberName = ToCamelCase(isolationLevelName);
members.Add(Function(memberName, ModuleBinding.CreateEnum(Symbol(memberName), (int)value)));
}
return(new AmbientNamespaceDefinition(
typeof(ContainerIsolationLevel).Name,
members.ToArray()));
}
/// <inheritdoc />
protected override AmbientNamespaceDefinition?GetNamespaceDefinition()
{
var members = new List <NamespaceFunctionDefinition>();
foreach (ArtifactKind kind in Enum.GetValues(typeof(ArtifactKind)))
{
// Undefined is an artificial value.
if (kind != ArtifactKind.Undefined)
{
var memberName = ToCamelCase(kind.ToString());
members.Add(Function(memberName, ModuleBinding.CreateEnum(Symbol(memberName), (int)kind)));
}
}
return(new AmbientNamespaceDefinition(
typeof(ArtifactKind).Name,
members.ToArray()));
}
public void Bind(ModuleBinding module)
{
Module = module;
KnobOctave.SetBinding(module, ParameterBinding.Octave);
KnobSemi.SetBinding(module, ParameterBinding.Semi);
KnobCent.SetBinding(module, ParameterBinding.Cent);
KnobWavePosition.SetBinding(module, ParameterBinding.WavePosition);
var coll = Extensions.GetLogicalChildCollection<Knob>(this);
foreach (var knob in coll)
knob.ValueChanged += ValueChanged;
foreach (var knob in coll)
{
knob.Value = knob.Value;
ValueChanged(knob, null);
}
}
public void Bind(ModuleBinding module)
{
KnobA.SetBinding(module, ParameterBinding.Attack);
KnobH.SetBinding(module, ParameterBinding.Hold);
KnobD.SetBinding(module, ParameterBinding.Decay);
KnobS.SetBinding(module, ParameterBinding.Sustain);
KnobR.SetBinding(module, ParameterBinding.Release);
var coll = Extensions.GetLogicalChildCollection<Knob>(this);
foreach (var knob in coll)
knob.ValueChanged += ValueChanged;
foreach (var knob in coll)
{
knob.Value = knob.Value;
ValueChanged(knob, null);
}
}
public void Bind(ModuleBinding module)
{
KnobCutoff.SetBinding(module, ParameterBinding.Cutoff);
KnobResonance.SetBinding(module, ParameterBinding.Resonance);
KnobX.SetBinding(module, ParameterBinding.X);
KnobA.SetBinding(module, ParameterBinding.A);
KnobB.SetBinding(module, ParameterBinding.B);
KnobC.SetBinding(module, ParameterBinding.C);
KnobD.SetBinding(module, ParameterBinding.D);
var coll = Extensions.GetLogicalChildCollection<Knob>(this);
foreach (var knob in coll)
knob.ValueChanged += ValueChanged;
foreach (var knob in coll)
{
knob.Value = knob.Value;
ValueChanged(knob, null);
}
}
/// <nodoc />
public NamespaceFunctionDefinition(string name, ModuleBinding functionDefinition)
{
Name = name;
FunctionDefinition = functionDefinition;
}
private static bool UpgradeScripts(UdonSharpProgramAsset[] programAssets)
{
if (programAssets.Length == 0)
{
return(false);
}
if (programAssets.All(e => e.ScriptVersion >= UdonSharpProgramVersion.CurrentVersion))
{
return(false);
}
CompilationContext compilationContext = new CompilationContext(new UdonSharpCompileOptions());
ModuleBinding[] bindings = compilationContext.LoadSyntaxTreesAndCreateModules(CompilationContext.GetAllFilteredSourcePaths(false), UdonSharpUtils.GetProjectDefines(false));
CSharpCompilation compilation = CSharpCompilation.Create(
$"UdonSharpRoslynUpgradeAssembly{_assemblyCounter++}",
bindings.Select(e => e.tree),
CompilationContext.GetMetadataReferences(),
new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
bool scriptUpgraded = false;
bool versionUpgraded = false;
foreach (var programAsset in programAssets)
{
string assetPath = AssetDatabase.GetAssetPath(programAsset.sourceCsScript);
ModuleBinding binding = bindings.FirstOrDefault(e => e.filePath == assetPath);
if (binding == null)
{
continue;
}
if (programAsset.ScriptVersion < UdonSharpProgramVersion.V1SerializationUpdate)
{
SyntaxTree bindingTree = binding.tree;
SemanticModel bindingModel = compilation.GetSemanticModel(bindingTree);
SerializationUpdateSyntaxRewriter rewriter = new SerializationUpdateSyntaxRewriter(bindingModel);
SyntaxNode newRoot = rewriter.Visit(bindingTree.GetRoot());
if (rewriter.Modified)
{
try
{
File.WriteAllText(binding.filePath, newRoot.ToFullString(), Encoding.UTF8);
scriptUpgraded = true;
UdonSharpUtils.Log($"Upgraded field serialization attributes on U# script '{binding.filePath}'", programAsset.sourceCsScript);
}
catch (Exception e)
{
UdonSharpUtils.LogError($"Could not upgrade U# script, exception: {e}");
}
}
// We expect this to come through a second time after scripts have been updated and change the version on the asset.
else
{
programAsset.ScriptVersion = UdonSharpProgramVersion.V1SerializationUpdate;
EditorUtility.SetDirty(programAsset);
versionUpgraded = true;
}
}
}
if (scriptUpgraded)
{
AssetDatabase.Refresh();
return(true);
}
if (versionUpgraded)
{
UdonSharpCompilerV1.CompileSync(new UdonSharpCompileOptions());
}
return(false);
}
/// <summary>
/// Perform recursive module initialization.
/// </summary>
/// <param name="root"></param>
static void InitRecursive ( ModuleBinding root, string prefix )
{
var children = GetModuleBindings( root.Module );
foreach ( var child in children ) {
if (child.InitOrder==InitOrder.Before) {
InitRecursive( child, prefix + root.NiceName + "/" );
}
}
Log.Message( "---- Init : {0} ----", prefix + root.NiceName );
root.Module.Initialize();
disposeList.Add( root );
foreach ( var child in children ) {
if (child.InitOrder==InitOrder.After) {
InitRecursive( child, prefix + root.NiceName + "/" );
}
}
}
public void SetWave(double[] wave, ModuleBinding module, int waveIndex)
{
foreach (var voice in Manager.Voices)
{
IOscillator osc = null;
if (module == ModuleBinding.Osc1)
osc = voice.Osc1;
else if (module == ModuleBinding.Osc2)
osc = voice.Osc2;
//else if (module == ModuleBinding.Osc3)
// osc = voice.Osc3;
//else if (module == ModuleBinding.Osc4)
// osc = voice.Osc4;
if (osc == null || !(osc is WavetableOsc))
continue;
WavetableOsc wo = osc as WavetableOsc;
wo.SetWave(wave, waveIndex);
}
}
private static Dictionary <string, MondFunction> BindImpl(Type type)
{
ModuleBinding binding;
lock (Cache)
{
if (Cache.TryGetValue(type, out binding))
{
return(binding.Functions);
}
}
var moduleAttrib = type.Attribute <MondModuleAttribute>();
if (moduleAttrib == null)
{
throw new MondBindingException(BindingError.TypeMissingAttribute, "MondModule");
}
var moduleName = moduleAttrib.Name ?? type.Name;
var result = new Dictionary <string, MondFunction>();
var methods = type.GetMethods(BindingFlags.Public | BindingFlags.Static);
foreach (var method in MondFunctionBinder.BindStatic(moduleName, methods))
{
var name = method.Item1;
if (result.ContainsKey(name))
{
throw new MondBindingException(BindingError.DuplicateDefinition, name);
}
result[name] = method.Item2;
}
var properties = type.GetProperties(BindingFlags.Public | BindingFlags.Static);
foreach (var property in properties.PropertyMethods())
{
var name = property.Item1;
if (result.ContainsKey(name))
{
throw new MondBindingException(BindingError.DuplicateDefinition, name);
}
var propertyArray = new[] { property.Item2 };
var propertyBinding = MondFunctionBinder.BindStatic(moduleName, propertyArray, MondFunctionBinder.MethodType.Property, name)
.FirstOrDefault();
if (propertyBinding != null)
{
result[name] = propertyBinding.Item2;
}
}
binding = new ModuleBinding(result);
lock (Cache)
Cache[type] = binding;
return(result);
}
public static void SetBinding(this System.Windows.Controls.Control control, ModuleBinding module, ParameterBinding parameter)
{
var map = new Binding();
map.Module = module;
map.Parameter = parameter;
ParameterBindings[control] = map;
}
public ObjectInfo GetObjectInfo(object context, object obj)
{
obj = obj is EvaluationResult evalResult
? evalResult.Value
: obj;
if (obj == null || IsInvalid(obj))
{
return(s_nullObj);
}
if (obj.GetType().IsArray)
{
return(ArrayObjInfo(((IEnumerable)obj).Cast <object>().ToArray()));
}
var customResult = m_customRenderer?.Invoke(this, context, obj);
if (customResult != null)
{
return(customResult);
}
return(obj switch
{
ScopeLocals scope => new ObjectInfo(LocalsScopeName, null, Lazy.Create(() => GetLocalsForStackEntry(scope.EvalState, scope.FrameIndex))),
ScopePipGraph scope => PipGraphInfo(scope.Graph).WithPreview(PipGraphScopeName),
ScopeAllModules scope => ArrayObjInfo(scope.EvaluatedModules.ToArray()).WithPreview(EvaluatedModulesScopeName),
IModuleAndContext mc => GetObjectInfo(mc.Tree.RootContext, mc.Module),
ObjectInfo objInf => objInf,
IPipGraph graph => PipGraphInfo(graph),
Pip pip => GenericObjectInfo(pip, $"<{pip.PipType}>").Build(),
PipProvenance prov => ProvenanceInfo(prov),
EnvironmentVariable envVar => EnvironmentVariableInfo(envVar),
PipFragment pipFrag => PipFragmentInfo(context, pipFrag),
Thunk thunk => thunk.Value != null?GetObjectInfo(context, thunk.Value) : new ObjectInfo("<not evaluated>"),
FunctionLikeExpression lambda => LambdaInfo(lambda),
Closure cls => LambdaInfo(cls.Function),
SymbolAtom sym => new ObjectInfo(sym.ToString(StringTable)),
StringId id => new ObjectInfo(id.ToString(StringTable)),
PipId id => new ObjectInfo($"{id.Value}"),
UndefinedLiteral _ => new ObjectInfo("undefined", UndefinedLiteral.Instance),
UndefinedValue _ => new ObjectInfo("undefined", UndefinedValue.Instance),
AbsolutePath path => new ObjectInfo($"p`{path.ToString(PathTable)}`", path),
RelativePath path => new ObjectInfo($"r`{path.ToString(StringTable)}`", path),
PathAtom atom => new ObjectInfo($"a`{atom.ToString(StringTable)}`", atom),
FileArtifact file => new ObjectInfo($"f`{file.Path.ToString(PathTable)}`", file),
DirectoryArtifact dir => new ObjectInfo($"d`{dir.Path.ToString(PathTable)}`", dir),
int num => new ObjectInfo($"{num}"),
uint num => new ObjectInfo($"{num}"),
short num => new ObjectInfo($"{num}", (int)num),
long num => new ObjectInfo($"{num}"),
char ch => new ObjectInfo($"'{ch}'", ch.ToString()),
string str => new ObjectInfo($"\"{str}\"", str),
Enum e => new ObjectInfo($"{e.GetType().Name}.{e}", e),
NumberLiteral numLit => new ObjectInfo(numLit.UnboxedValue.ToString(), numLit),
Func <object> func => FuncObjInfo(func),
ArraySegment <object> arrSeg => ArrayObjInfo(arrSeg),
IEnumerable enu => new ObjectInfoBuilder().Preview("IEnumerable").Prop("Result", Lazy.Create <object>(() => enu.Cast <object>().ToArray())).Build(),
ArrayLiteral arrLit => ArrayObjInfo(arrLit.Values.Select(v => v.Value).ToArray()).WithOriginal(arrLit),
ModuleBinding binding => GetObjectInfo(context, binding.Body),
ErrorValue error => ErrorValueInfo(),
object o => GenericObjectInfo(o).Build(),
_ => s_nullObj
});
/// <summary>
/// Factory method that creates instance of the <see cref="NamespaceFunctionDefinition" />.
/// </summary>
protected static NamespaceFunctionDefinition Function(string name, ModuleBinding body)
{
return(new NamespaceFunctionDefinition(name, body));
}
/// <summary>
/// Factory method that creates instance of the <see cref="NamespaceFunctionDefinition" />.
/// </summary>
protected NamespaceFunctionDefinition EnumMember(string name, int value)
{
return(new NamespaceFunctionDefinition(name, ModuleBinding.CreateEnum(Symbol(name), value)));
}
