public static ProgramNode Learn(Grammar grammar, Spec spec)
{
var engine = new SynthesisEngine(grammar, new SynthesisEngine.Config
{
UseThreads = false,
LogListener = new LogListener(),
});
ProgramSet consistentPrograms = engine.LearnGrammar(spec);
engine.Configuration.LogListener.SaveLogToXML("learning.log.xml");
//foreach (ProgramNode p in consistentPrograms.RealizedPrograms) {
// Console.WriteLine(p);
//}
ProgramNode bestProgram = consistentPrograms.TopK("Score").FirstOrDefault();
if (bestProgram == null)
{
WriteColored(ConsoleColor.Red, "No program :(");
return(null);
}
var score = bestProgram["Score"];
WriteColored(ConsoleColor.Cyan, $"[score = {score:F3}] {bestProgram}");
return(bestProgram);
}
/// <summary>
/// Learns all region programs that satisfy the examples (advanced feature).
/// Demonstrates access to the entire program set.
/// </summary>
private static void LearnAllRegionPrograms()
{
var session = new RegionSession();
StringRegion input = RegionSession.CreateStringRegion("Carrie Dodson 100");
session.AddConstraints(new RegionExample(input, input.Slice(14, 17))); // "Carrie Dodson 100" => "Dodson"
ProgramSet allPrograms = session.LearnAll().ProgramSet;
IEnumerable <ProgramNode> topKPrograms = allPrograms.TopK(RegionLearner.Instance.ScoreFeature, 3);
var i = 0;
StringRegion[] otherInputs =
{
input, RegionSession.CreateStringRegion("Leonard Robledo NA"),
RegionSession.CreateStringRegion("Margaret Cook 320")
};
foreach (ProgramNode programNode in topKPrograms)
{
Console.WriteLine("Program {0}:", ++i);
var program = new RegionProgram(programNode, ReferenceKind.Parent);
foreach (StringRegion str in otherInputs)
{
StringRegion r = program.Run(str);
Console.WriteLine(r == null ? "null" : r.Value);
}
}
}
private static void LearnFromNewExample()
{
Console.Out.Write("Provide a new input-output example (e.g., \"(Sumit Gulwani)\",\"Gulwani\"): ");
try {
string input = Console.ReadLine();
if (input != null)
{
var startFirstExample = input.IndexOf("\"", StringComparison.Ordinal) + 1;
var endFirstExample = input.IndexOf("\"", startFirstExample + 1, StringComparison.Ordinal) + 1;
var startSecondExample = input.IndexOf("\"", endFirstExample + 1, StringComparison.Ordinal) + 1;
var endSecondExample = input.IndexOf("\"", startSecondExample + 1, StringComparison.Ordinal) + 1;
if ((startFirstExample >= endFirstExample) || (startSecondExample >= endSecondExample))
{
throw new Exception("Invalid example format. Please try again. input and out should be between quotes");
}
var inputExample = input.Substring(startFirstExample, endFirstExample - startFirstExample - 1);
var outputExample = input.Substring(startSecondExample, endSecondExample - startSecondExample - 1);
var inputState = State.CreateForExecution(Grammar.InputSymbol, inputExample);
Examples.Add(inputState, outputExample);
}
}
catch (Exception) {
throw new Exception("Invalid example format. Please try again. input and out should be between quotes");
}
var spec = new ExampleSpec(Examples);
Console.Out.WriteLine("Learning a program for examples:");
foreach (var example in Examples)
{
Console.WriteLine("\"{0}\" -> \"{1}\"", example.Key.Bindings.First().Value, example.Value);
}
var scoreFeature = new RankingScore(Grammar);
ProgramSet topPrograms = _prose.LearnGrammarTopK(spec, scoreFeature, 4, null);
if (topPrograms.IsEmpty)
{
throw new Exception("No program was found for this specification.");
}
_topProgram = topPrograms.RealizedPrograms.First();
Console.Out.WriteLine("Top 4 learned programs:");
var counter = 1;
foreach (var program in topPrograms.RealizedPrograms)
{
if (counter > 4)
{
break;
}
Console.Out.WriteLine("==========================");
Console.Out.WriteLine("Program {0}: ", counter);
Console.Out.WriteLine(program.PrintAST(ASTSerializationFormat.HumanReadable));
counter++;
}
}
public void ProgramSetConstructor_WithSync_SteppersSynced_ZonesInit_ProgramsInit()
{
//arrange
TestHelpers.InitializeZoneScaffolder();
//create zones
var zones = new BetterList <Zone>();
FadeCandyController.Instance.Initialize();
var leftWing = ZoneScaffolder.Instance.AddFadeCandyZone(zones, "LeftWing", PixelType.FadeCandyWS2812Pixel, 6, 1);
var rightWing = ZoneScaffolder.Instance.AddFadeCandyZone(zones, "RightWing", PixelType.FadeCandyWS2811Pixel, 21, 2);
//act
var programSet = new ProgramSet("Stepper", zones.ToList(), true, null, "StepperSet");
//assert
TestHelpers.ValidateSteppersInSync(((ITestProgramSet)programSet).ZoneProgramsTest.Cast <IStepper>(), 100);
Assert.That(leftWing.Running, Is.True);
Assert.That(rightWing.Running, Is.True);
Assert.That(leftWing.ZoneProgram.State == ProgramState.Started, Is.True);
Assert.That(rightWing.ZoneProgram.State == ProgramState.Started, Is.True);
//cleanup
programSet.Dispose();
leftWing.Dispose();
rightWing.Dispose();
}
public static ProgramNode Learn(Grammar grammar, Spec spec,
Feature <double> scorer, DomainLearningLogic witnessFunctions)
{
var engine = new SynthesisEngine(grammar, new SynthesisEngine.Config
{
Strategies = new ISynthesisStrategy[]
{
new EnumerativeSynthesis(),
new DeductiveSynthesis(witnessFunctions)
},
UseThreads = false,
LogListener = new LogListener(),
});
ProgramSet consistentPrograms = engine.LearnGrammar(spec);
engine.Configuration.LogListener.SaveLogToXML("learning.log.xml");
//foreach (ProgramNode p in consistentPrograms.RealizedPrograms) {
// Console.WriteLine(p);
//}
ProgramNode bestProgram = consistentPrograms.TopK(scorer).FirstOrDefault();
if (bestProgram == null)
{
WriteColored(ConsoleColor.Red, "No program :(");
return(null);
}
var score = bestProgram.GetFeatureValue(scorer);
WriteColored(ConsoleColor.Cyan, $"[score = {score:F3}] {bestProgram}");
return(bestProgram);
}
private Optional <ProgramSet> LearnChildren(PremSpec <TInput, IEnumerable <SyntaxNode> > spec)
{
Debug.Assert(spec.Forall((i, o) => o.Any()) && spec.Identical((i, o) => o.Count()));
// First synthesize the first child.
var childSpec = spec.MapOutputs((i, o) => o.First());
var childSpace = LearnTree(childSpec);
if (childSpace.IsEmpty)
{
return(Optional <ProgramSet> .Nothing);
}
// Suppose no more children, then this is the base case.
if (!spec.Forall((i, o) => o.Rest().Any()))
{
return(ProgramSet.Join(Op(nameof(Semantics.Child)), childSpace).Some());
}
#if DEBUG
Debug.Assert(spec.Forall((i, o) => o.Rest().Any()));
#endif
// Then synthesize the rest, inductively.
var childrenSpec = spec.MapOutputs((i, o) => o.Rest());
var childrenSpace = LearnChildren(childrenSpec);
if (!childrenSpace.HasValue || childrenSpace.Value.IsEmpty)
{
return(Optional <ProgramSet> .Nothing);
}
return(ProgramSet.Join(Op(nameof(Semantics.Children)), childSpace, childrenSpace.Value).Some());
}
internal override bool PostCreateGpuPrograms( ProgramSet programSet )
{
BindAutoParameters( programSet.CpuVertexProgram, programSet.GpuVertexProgram );
BindAutoParameters( programSet.CpuFragmentProgram, programSet.GpuFragmentProgram );
return true;
}
public static string GetProgramNameMarkup(this HtmlHelper helper, ProgramSet programSet, SelectList programList)
{
var returnValue = MvcHtmlString.Create(programSet.State == ProgramState.Stopped
? helper.DropDownList("ddl" + programSet.Name + "Program", programList, new { @class = "form-control", style = "display: inline-flex; width: inherit;" }).ToString()
: programSet.Name);
return(returnValue.ToHtmlString());
}
private ProgSetTreeItem AddItem(ProgramSet progSet)
{
ProgSetTreeItem setItem = new ProgSetTreeItem(progSet);
progSets.Add(progSet.guid, setItem);
this.Children.Add(setItem);
return(setItem);
}
internal override bool PostCreateGpuPrograms(ProgramSet programSet)
{
BindAutoParameters(programSet.CpuVertexProgram, programSet.GpuVertexProgram);
BindAutoParameters(programSet.CpuFragmentProgram, programSet.GpuFragmentProgram);
return(true);
}
private static void LearnFromNewExample()
{
Console.Out.Write("Provide a new input-output example as \"input\", \"output\":\n");
try
{
string input = Console.ReadLine();
var startFirstExample = input.IndexOf("\"") + 1;
var endFirstExample = input.IndexOf("\"", startFirstExample + 1) + 1;
var startSecondExample = input.IndexOf("\"", endFirstExample + 1) + 1;
var endSecondExample = input.IndexOf("\"", startSecondExample + 1) + 1;
if ((startFirstExample >= endFirstExample) || (startSecondExample >= endSecondExample))
{
throw new Exception("Invalid example format. Please try again. input and out should be between quotes");
}
var inputExample = input.Substring(startFirstExample, endFirstExample - startFirstExample - 1);
var outputExample = input.Substring(startSecondExample, endSecondExample - startSecondExample - 1);
var inputState = State.CreateForExecution(grammar.InputSymbol, inputExample);
examples.Add(inputState, outputExample);
} catch (Exception)
{
throw new Exception("Invalid example format. Please try again. input and out should be between quotes");
}
var spec = new ExampleSpec(examples);
Console.Out.WriteLine("Learning a program for examples:");
foreach (var example in examples)
{
Console.WriteLine("\"" + example.Key.Bindings.First().Value + "\" -> \"" + example.Value + "\"");
}
var scoreFeature = new RankingScore(grammar);
ProgramSet topPrograms = prose.LearnGrammarTopK(spec, scoreFeature, 4, null);
if (topPrograms.IsEmpty)
{
throw new Exception("No program was found for this specification.");
}
topProgram = topPrograms.RealizedPrograms.First();
Console.Out.WriteLine("Top 4 learned programs:");
var counter = 1;
foreach (var program in topPrograms.RealizedPrograms)
{
if (counter > 4)
{
break;
}
Console.Out.WriteLine("==========================");
Console.Out.WriteLine("Program " + counter + ": ");
Console.Out.WriteLine(program.PrintAST(Microsoft.ProgramSynthesis.AST.ASTSerializationFormat.HumanReadable));
counter++;
}
}
/// <summary>
/// Learning a set of `ref`s, i.e. node selectors, that are consistent with the specification.
/// </summary>
/// <param name="spec">Specification of the form: input -> node to be referenced.</param>
/// <returns>Consistent programs (if exist) or emptyset.</returns>
private ProgramSet LearnRef(PremSpec <TInput, SyntaxNode> spec)
{
// A `ref` must be either a `scope` or `Select`, and both require a `scope`,
// whose `node` must be constructed by `Lift`.
// Heuristic: only lift as lowest as possible until the scope contains the expected node for every example.
// Before we really learn the selectors, we first collect all learned scopes,
// as the same scope may corresponds to multiple lifters.
var scopeSpecDict = new MultiValueDict <PremSpec <TInput, Node>, ProgramNode>();
// Option 1: lift error node.
if (spec.Forall((i, o) => !i.errNode.Equals(o)))
{
PremSpec <TInput, Node> scopeSpec;
var lifter = LearnLift(spec, errNodes, Err(), out scopeSpec);
if (lifter.HasValue)
{
scopeSpecDict.Add(scopeSpec, lifter.Value);
}
}
// Option 2: lift var node.
foreach (var p in varNodeDict)
{
var key = p.Key;
var varNodes = p.Value;
if (varNodes.Forall((i, v) => v != spec[i])) // Source node != expected node.
{
PremSpec <TInput, Node> scopeSpec;
var lifter = LearnLift(spec, varNodes, Var(key), out scopeSpec);
if (lifter.HasValue)
{
scopeSpecDict.Add(scopeSpec, lifter.Value);
}
}
}
// Finally, let's learn selectors!
var spaces = new List <ProgramSet>();
foreach (var p in scopeSpecDict)
{
var scopeSpec = p.Key;
var scopeSpace = ProgramSet.List(Symbol(nameof(Semantics.Lift)), p.Value);
#if DEBUG
Log.Tree("lifters");
Log.IncIndent();
foreach (var lft in p.Value)
{
Log.Tree("{0}", lft);
}
Log.DecIndent();
#endif
spaces.Add(LearnSelect(spec, scopeSpec, scopeSpace));
}
return(Union(spaces));
}
public void UpdateConnections(bool clear = false)
{
if (firewallPage == null)
{
return;
}
if (clear)
{
LogList.Clear();
}
Dictionary <Guid, LogItem> oldLog = new Dictionary <Guid, LogItem>();
foreach (LogItem oldItem in LogList)
{
oldLog.Add(oldItem.entry.guid, oldItem);
}
Dictionary <Guid, List <Program.LogEntry> > entries = App.client.GetConnections(firewallPage.GetCurGuids());
foreach (var entrySet in entries)
{
ProgramControl item = null;
ProgramSet prog = firewallPage.GetProgSet(entrySet.Key, null, out item);
if (prog == null)
{
continue;
}
foreach (Program.LogEntry entry in entrySet.Value)
{
//if (!TestEntry(prog, entry))
// continue;
//LogItem Item;
//if (!oldLog.TryGetValue(entry.guid, out Item))
if (!oldLog.Remove(entry.guid))
{
Program program = ProgramList.GetProgramFuzzy(prog.Programs, entry.ProgID, ProgramList.FuzzyModes.Any);
LogList.Insert(0, new LogItem(entry, program != null ? program.Description : prog.config.Name));
}
/*else
* {
* oldLog.Remove(entry.guid);
* Item.Update(entry);
* }*/
}
}
foreach (LogItem item in oldLog.Values)
{
LogList.Remove(item);
}
}
public ProgramNode[] LearnSQLTopK(DataTable inputTable, DataTable outputTable, int k)
{
var spec = SpecFromStateOutput(inputTable, outputTable);
ProgramSet consistentPrograms = LearnProgramSet(spec, new Semantics.WitnessFunctions(Grammar));
int nProgs = consistentPrograms.AllElements.ToArray().Length;
k = (nProgs < k) ? nProgs : k;
return(consistentPrograms.TopK(QueryRanker, k).ToArray());
}
internal override bool ResolveDependencies(ProgramSet programSet)
{
Program vsProgram = programSet.CpuVertexProgram;
vsProgram.AddDependency(FFPRenderState.FFPLibCommon);
vsProgram.AddDependency(FFPRenderState.FFPLibTransform);
vsProgram.AddDependency(SGXLibQuaternion);
return(true);
}
public void Create(ProgramSet _program)
{
using (var db = new osu2008Entities1())
{
var program = _program;
db.ProgramSet.Add(_program);
db.SaveChanges();
}
}
private ProgramSet LearnConjunction(IEnumerable <Feature> features, IEnumerable <TInput> inputs)
{
var spaces = new List <ProgramSet>();
foreach (var feature in features)
{
spaces.Add(ProgramSet.List(Symbol(nameof(Semantics.HasFeature)), HasFeature(feature)));
}
return(spaces.Aggregate1((s1, s2) => ProgramSet.Join(Op(nameof(Semantics.And)), s1, s2)));
}
private Optional <ProgramSet> LearnAppend(PremSpec <TInput, IEnumerable <SyntaxNode> > spec, int k)
{
Debug.Assert(spec.Forall((i, o) => o.Any()));
// Synthesize param `frontParent`.
var frontSpec = spec.MapOutputs((i, o) => o.DropLast(k));
var parents = frontSpec.MapOutputs((i, o) =>
{
var candidates = o.MapI((index, c) => c.MatchedParents(index));
return(candidates.Any() ? candidates.SetIntersect() : new HashSet <SyntaxNode>());
});
if (parents.Forall((i, ps) => ps.Any()))
{
#if DEBUG
if (parents.Any((i, ps) => ps.Count > 1))
{
Log.Debug("Possibly multiple ways for frontParentSpec");
}
#endif
var frontParentSpec = parents.MapOutputs((i, ps) => ps.First() as SyntaxNode);
#if DEBUG
Log.Tree("front parent |- {0}", frontParentSpec);
Log.IncIndent();
#endif
var frontParentSpace = LearnRef(frontParentSpec);
#if DEBUG
Log.DecIndent();
#endif
if (frontParentSpace.IsEmpty)
{
return(Optional <ProgramSet> .Nothing);
}
// Synthesize param `tail`.
var childrenSpec = spec.MapOutputs((i, o) => o.Last(k));
#if DEBUG
Log.Tree("append children |- {0}", childrenSpec);
Log.IncIndent();
#endif
var childrenSpace = LearnChildren(childrenSpec);
#if DEBUG
Log.DecIndent();
#endif
if (!childrenSpace.HasValue || childrenSpace.Value.IsEmpty)
{
return(Optional <ProgramSet> .Nothing);
}
return(ProgramSet.Join(Op(nameof(Semantics.Append)), frontParentSpace, childrenSpace.Value).Some());
}
return(Optional <ProgramSet> .Nothing);
}
public void AddCon(ProgramSet prog, Priv10Engine.FwEventArgs args)
{
this.conTab.IsEnabled = true;
tabs.SelectedItem = this.conTab;
tabItems[this.conTab].state = STab.EState.eNew;
//tabItems[this.conTab].state = tabs.SelectedItem != this.conTab ? STab.EState.eNew : STab.EState.eFilled;
if (this.ConNotify.Add(prog, args))
{
ShowWnd();
}
}
public async Task <IActionResult> Create([Bind("Id,NameProgram,TypeProgram,DurationProgram,Description,Observation")] ProgramSet programSet)
{
if (ModelState.IsValid)
{
_context.Add(programSet);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(programSet));
}
/// <summary>
/// Creates a ProgramSet with one program instance
/// </summary>
public ProgramSet CreateSingularProgramSet(string programSetName, ZoneProgram program, ISV isv, Zone zone, dynamic startingParameters = null)
{
if (!AvailableZones.Contains(zone))
{
throw new Exception("The provided zone is not available.");
}
var programSet = new ProgramSet(program, zone, isv, programSetName, startingParameters);
ProgramSets.Add(programSet);
return(programSet);
}
private static void Print(ProgramSet progs)
{
if (progs.IsEmpty)
{
Console.WriteLine("wasn't able to find any matching program");
}
else
{
foreach (var prog in progs.AllElements)
{
Console.WriteLine(String.Format("* {0}", prog.PrintAST(ASTSerializationFormat.HumanReadable)));
}
}
}
protected override bool ResolveDependencies(ProgramSet programSet)
{
Program vsProgram = programSet.CpuVertexProgram;
Program psProgram = programSet.CpuFragmentProgram;
vsProgram.AddDependency(FFPRenderState.FFPLibCommon);
vsProgram.AddDependency(FFPRenderState.FFPLibTexturing);
psProgram.AddDependency(FFPRenderState.FFPLibCommon);
psProgram.AddDependency(FFPRenderState.FFPLibTexturing);
psProgram.AddDependency(SGXLibReflectionMap);
return(true);
}
public static string GetProgramActionMarkup(ProgramSet programSet)
{
var returnValue = MvcHtmlString.Create((programSet.State == ProgramState.Stopped
? string.Format(
"<input type='button' onclick=\"zlmCommand('start', '{0}', document.getElementById('ddl{0}Program').options[document.getElementById('ddl{0}Program').selectedIndex].text)\" value='Start' class='form-control btn btn-primary inTable'/>",
programSet.Name)
: string.Format(
"<input type='button' onclick=\"zlmCommand('stop', '{0}')\" value='Stop' class='form-control btn btn-primary inTable'/>",
programSet.Name)) +
string.Format(
"<span id='{0}Loading' style='display: none; text - align: right;'><img src='/WebController/Content/loadng.gif' alt = 'Busy...' width = '30px' height = '30px'></span>",
programSet.Name));
return(returnValue.ToHtmlString());
}
internal override bool AddFunctionInvocations(ProgramSet programSet)
{
Program vsProgram = programSet.CpuVertexProgram;
Function vsMain = vsProgram.EntryPointFunction;
int internalCounter = 0;
//add functions to calculate position data in world, object and projective space
AddPositionCalculations(vsMain, ref internalCounter);
//add functions to calculate normal and normal related data in world and object space
AddNormalRelatedCalculations(vsMain, paramInNormal, paramLocalNormalWorld, ref internalCounter);
AddNormalRelatedCalculations(vsMain, paramInTangent, paramLocalTangentWorld, ref internalCounter);
AddNormalRelatedCalculations(vsMain, paramInBiNormal, paramLocalBiNormalWorld, ref internalCounter);
return(true);
}
/// <summary>
/// Creates a ProgramSet
/// </summary>
/// <param name="programSetName">Name of program set</param>
/// <param name="programName">Name of program</param>
/// <param name="sync">Whether or not to start the programs in sync</param>
/// <param name="isv">Input starting values - starting values for the inputs</param>
/// <param name="zones">Zones to run the program set on</param>
/// <param name="startingParameters">Starting parameters for creating this program set. These will be fed to the constructor(s) of the ZoneProgram(s).</param>
public ProgramSet CreateProgramSet(string programSetName, string programName, bool sync, ISV isv,
IEnumerable <Zone> zones, dynamic startingParameters = null)
{
var zonesList = zones as IList <Zone> ?? zones.ToList();
if (zonesList.Any(z => !AvailableZones.Contains(z)))
{
throw new Exception("Some of the provided zones are not available.");
}
var programSet = new ProgramSet(programName, zonesList, sync, isv.Listify(), programSetName, startingParameters);
ProgramSets.Add(programSet);
return(programSet);
}
public ProgramSetJsonModel CreateProgramSet(string programSetName, string programName, IEnumerable <string> zoneNames, bool sync = true,
ISV isv = null, dynamic startingParameters = null)
{
var model = new ProgramSetJsonModel();
ProgramSet programSet = null;
ZLMAction(
zlm =>
programSet =
zlm.CreateProgramSet(programSetName, programName, zoneNames, sync, isv, startingParameters)
);
model = programSet.ToJsonModel <ProgramSet, ProgramSetJsonModel>();
return(model);
}
internal override bool CreateCpuSubPrograms(ProgramSet programSet)
{
Program vsProgram = programSet.CpuVertexProgram;
//Resolve world view proj matrix
UniformParameter wvpMatrix =
vsProgram.ResolveAutoParameterInt(Graphics.GpuProgramParameters.AutoConstantType.WorldViewProjMatrix, 0);
if (wvpMatrix == null)
{
return(false);
}
Function vsEntry = vsProgram.EntryPointFunction;
//Resolve input position parameter
Parameter positionIn = vsEntry.ResolveInputParameter(Parameter.SemanticType.Position, 0,
Parameter.ContentType.PositionObjectSpace,
Graphics.GpuProgramParameters.GpuConstantType.Float4);
if (positionIn == null)
{
return(false);
}
//Resolve output position parameter
Parameter positionOut = vsEntry.ResolveOutputParameter(Parameter.SemanticType.Position, 0,
Parameter.ContentType.PositionProjectiveSpace,
Graphics.GpuProgramParameters.GpuConstantType.Float4);
if (positionOut == null)
{
return(false);
}
//Add dependency
vsProgram.AddDependency(FFPRenderState.FFPLibTransform);
var transformFunc = new FunctionInvocation(FFPRenderState.FFPFuncTransform, -1, 0);
transformFunc.PushOperand(wvpMatrix, Operand.OpSemantic.In);
transformFunc.PushOperand(positionIn, Operand.OpSemantic.In);
transformFunc.PushOperand(positionOut, Operand.OpSemantic.Out);
vsEntry.AddAtomInstance(transformFunc);
return(true);
}
internal override bool PreCreateGpuPrograms(ProgramSet programSet)
{
Program vsProgram = programSet.CpuVertexProgram;
Program psProgram = programSet.CpuFragmentProgram;
Function vsMain = vsProgram.EntryPointFunction;
Function psMain = psProgram.EntryPointFunction;
bool success;
success = ProgramProcessor.CompactVsOutputs(vsMain, psMain);
if (success == false)
{
return(false);
}
return(true);
}
ProgramControl AddProgramItem(ProgramSet prog)
{
ProgramControl item = new ProgramControl(prog, CatModel);
Programs.Add(prog.guid, item);
//item.Tag = process;
item.VerticalAlignment = VerticalAlignment.Top;
item.HorizontalAlignment = HorizontalAlignment.Stretch;
item.Margin = new Thickness(1, 1, 1, 1);
//item.MouseDown += new MouseButtonEventHandler(process_Click);
item.Click += new RoutedEventHandler(process_Click);
this.processGrid.Children.Add(item);
return(item);
}
private ProgramSet LearnProgramSet(Spec spec, DomainLearningLogic witnessFunctions)
{
var engine = new SynthesisEngine(Grammar, new SynthesisEngine.Config
{
Strategies = new ISynthesisStrategy[] {
new EnumerativeSynthesis(),
new DeductiveSynthesis(witnessFunctions)
},
UseThreads = false,
LogListener = new LogListener(),
});
ProgramSet consistentPrograms = engine.LearnGrammar(spec);
engine.Configuration.LogListener.SaveLogToXML("learning.log.xml");
return(consistentPrograms);
}
internal override bool PreCreateGpuPrograms( ProgramSet programSet )
{
Program vsProgram = programSet.CpuVertexProgram;
Program psProgram = programSet.CpuFragmentProgram;
Function vsMain = vsProgram.EntryPointFunction;
Function psMain = psProgram.EntryPointFunction;
bool success;
success = ProgramProcessor.CompactVsOutputs( vsMain, psMain );
if ( success == false )
{
return false;
}
return true;
}
internal override bool CreateCpuSubPrograms( ProgramSet programSet )
{
Program vsProgram = programSet.CpuVertexProgram;
//Resolve world view proj matrix
UniformParameter wvpMatrix =
vsProgram.ResolveAutoParameterInt( Graphics.GpuProgramParameters.AutoConstantType.WorldViewProjMatrix, 0 );
if ( wvpMatrix == null )
{
return false;
}
Function vsEntry = vsProgram.EntryPointFunction;
//Resolve input position parameter
Parameter positionIn = vsEntry.ResolveInputParameter( Parameter.SemanticType.Position, 0,
Parameter.ContentType.PositionObjectSpace,
Graphics.GpuProgramParameters.GpuConstantType.Float4 );
if ( positionIn == null )
{
return false;
}
//Resolve output position parameter
Parameter positionOut = vsEntry.ResolveOutputParameter( Parameter.SemanticType.Position, 0,
Parameter.ContentType.PositionProjectiveSpace,
Graphics.GpuProgramParameters.GpuConstantType.Float4 );
if ( positionOut == null )
{
return false;
}
//Add dependency
vsProgram.AddDependency( FFPRenderState.FFPLibTransform );
var transformFunc = new FunctionInvocation( FFPRenderState.FFPFuncTransform, -1, 0 );
transformFunc.PushOperand( wvpMatrix, Operand.OpSemantic.In );
transformFunc.PushOperand( positionIn, Operand.OpSemantic.In );
transformFunc.PushOperand( positionOut, Operand.OpSemantic.Out );
vsEntry.AddAtomInstance( transformFunc );
return true;
}
internal virtual bool ResolveDependencies( ProgramSet programSet )
{
return false;
}
internal override bool ResolveParameters( ProgramSet programSet )
{
Program vsProgram = programSet.CpuVertexProgram;
Function vsMain = vsProgram.EntryPointFunction;
//if needed mark this vertex program as hardware skinned
if ( doBoneCalculations )
{
vsProgram.SkeletalAnimationIncluded = true;
}
//get the parameters we need whether we are doing bone calculations or not
// Note: in order to be consistent we will always output position, normal,
// tangent and binormal in both object and world space. And output position
// in projective space to cover the responsibility of the transform stage
//input param
paramInPosition = vsMain.ResolveInputParameter( Parameter.SemanticType.Position, 0,
Parameter.ContentType.PositionObjectSpace,
Graphics.GpuProgramParameters.GpuConstantType.Float4 );
paramInNormal = vsMain.ResolveInputParameter( Parameter.SemanticType.Normal, 0,
Parameter.ContentType.NormalObjectSpace,
Graphics.GpuProgramParameters.GpuConstantType.Float3 );
paramInBiNormal = vsMain.ResolveInputParameter( Parameter.SemanticType.Binormal, 0,
Parameter.ContentType.BinormalObjectSpace,
Graphics.GpuProgramParameters.GpuConstantType.Float3 );
paramInTangent = vsMain.ResolveInputParameter( Parameter.SemanticType.Tangent, 0,
Parameter.ContentType.TangentObjectSpace,
Graphics.GpuProgramParameters.GpuConstantType.Float3 );
//local param
this.paramLocalBlendPosition = vsMain.ResolveLocalParameter( Parameter.SemanticType.Unknown, -1,
"BlendedPosition",
Graphics.GpuProgramParameters.GpuConstantType.Float3 );
paramLocalPositionWorld = vsMain.ResolveLocalParameter( Parameter.SemanticType.Position, 0,
Parameter.ContentType.PositionWorldSpace,
Graphics.GpuProgramParameters.GpuConstantType.Float4 );
paramLocalNormalWorld = vsMain.ResolveLocalParameter( Parameter.SemanticType.Normal, 0,
Parameter.ContentType.NormalWorldSpace,
Graphics.GpuProgramParameters.GpuConstantType.Float3 );
paramLocalTangentWorld = vsMain.ResolveLocalParameter( Parameter.SemanticType.Tangent, 0,
Parameter.ContentType.TangentWorldSpace,
Graphics.GpuProgramParameters.GpuConstantType.Float3 );
paramLocalBiNormalWorld = vsMain.ResolveLocalParameter( Parameter.SemanticType.Binormal, 0,
Parameter.ContentType.BinormalWorldSpace,
Graphics.GpuProgramParameters.GpuConstantType.Float3 );
//output param
paramOutPositionProj = vsMain.ResolveOutputParameter( Parameter.SemanticType.Position, 0,
Parameter.ContentType.PositionProjectiveSpace,
Graphics.GpuProgramParameters.GpuConstantType.Float4 );
//check if parameter retrieval went well
bool isValid =
( paramInPosition != null &&
paramInNormal != null &&
paramInBiNormal != null &&
paramInTangent != null &&
paramLocalPositionWorld != null &&
paramLocalNormalWorld != null &&
paramLocalTangentWorld != null &&
paramLocalBiNormalWorld != null &&
paramOutPositionProj != null );
if ( doBoneCalculations )
{
//input parameters
paramInNormal = vsMain.ResolveInputParameter( Parameter.SemanticType.Normal, 0,
Parameter.ContentType.NormalObjectSpace,
Graphics.GpuProgramParameters.GpuConstantType.Float3 );
paramInBiNormal = vsMain.ResolveInputParameter( Parameter.SemanticType.Binormal, 0,
Parameter.ContentType.BinormalObjectSpace,
Graphics.GpuProgramParameters.GpuConstantType.Float3 );
paramInTangent = vsMain.ResolveInputParameter( Parameter.SemanticType.Tangent, 0,
Parameter.ContentType.TangentObjectSpace,
Graphics.GpuProgramParameters.GpuConstantType.Float3 );
paramInIndices = vsMain.ResolveInputParameter( Parameter.SemanticType.BlendIndicies, 0,
Parameter.ContentType.Unknown,
Graphics.GpuProgramParameters.GpuConstantType.Float4 );
paramInWeights = vsMain.ResolveInputParameter( Parameter.SemanticType.BlendWeights, 0,
Parameter.ContentType.Unknown,
Graphics.GpuProgramParameters.GpuConstantType.Float4 );
//ACT_WORLD_DUALQUATERNION_ARRAY_2x4 is an array of float4s, so there are two indices for each bone
//TODO
//paramInWorldMatrices = vsProgram.ResolveAutoParameterInt(Graphics.GpuProgramParameters.AutoConstantType.WorldDualQuatenrionArray_2x4, Graphics.GpuProgramParameters.GpuConstantType.Float4, 0, boneCount * 2);
paramInInvWorldMatrix =
vsProgram.ResolveAutoParameterInt(
Graphics.GpuProgramParameters.AutoConstantType.InverseWorldMatrix, 0 );
paramInViewProjMatrix =
vsProgram.ResolveAutoParameterInt( Graphics.GpuProgramParameters.AutoConstantType.ViewProjMatrix, 0 );
this.paramTempWorldMatrix = vsMain.ResolveLocalParameter( Parameter.SemanticType.Unknown, -1, "worldMatrix",
Graphics.GpuProgramParameters.GpuConstantType.
Matrix_2X4 );
this.paramBlendDQ = vsMain.ResolveLocalParameter( Parameter.SemanticType.Unknown, -1, "blendDQ",
Graphics.GpuProgramParameters.GpuConstantType.Matrix_2X4 );
this.paramInitialDQ = vsMain.ResolveLocalParameter( Parameter.SemanticType.Unknown, -1, "initialDQ",
Graphics.GpuProgramParameters.GpuConstantType.Matrix_2X4 );
this.paramIndex1 = vsMain.ResolveLocalParameter( Parameter.SemanticType.Unknown, -1, "index1",
Graphics.GpuProgramParameters.GpuConstantType.Float1 );
this.paramIndex2 = vsMain.ResolveLocalParameter( Parameter.SemanticType.Unknown, -1, "index2",
Graphics.GpuProgramParameters.GpuConstantType.Float1 );
if ( scalingShearingSupport )
{
//TODO
//paramInScaleShearMatrices = vsProgram.ResolveAutoParameterInt(Graphics.GpuProgramParameters.AutoConstantType.WorldScaleShearMatrixArray3x4, 0, boneCount);
this.paramBlendS = vsMain.ResolveLocalParameter( Parameter.SemanticType.Unknown, -1, "blendS",
Graphics.GpuProgramParameters.GpuConstantType.Matrix_3X4 );
this.paramTempFloat3x3 = vsMain.ResolveLocalParameter( Parameter.SemanticType.Unknown, -1, "TempVal3x3",
Graphics.GpuProgramParameters.GpuConstantType.
Matrix_3X3 );
this.paramTempFloat3x4 = vsMain.ResolveLocalParameter( Parameter.SemanticType.Unknown, -1, "TempVal3x4",
Graphics.GpuProgramParameters.GpuConstantType.
Matrix_3X4 );
}
this.paramTempFloat2x4 = vsMain.ResolveLocalParameter( Parameter.SemanticType.Unknown, -1, "TempVal2x4",
Graphics.GpuProgramParameters.GpuConstantType.
Matrix_2X4 );
paramTempFloat4 = vsMain.ResolveLocalParameter( Parameter.SemanticType.Unknown, -1, "TempVal4",
Graphics.GpuProgramParameters.GpuConstantType.Float4 );
paramTempFloat3 = vsMain.ResolveLocalParameter( Parameter.SemanticType.Unknown, -1, "TempVal3",
Graphics.GpuProgramParameters.GpuConstantType.Float3 );
//check if parameter retrieval went well
isValid &=
( paramInIndices != null &&
paramInWeights != null &&
paramInWorldMatrices != null &&
paramInViewProjMatrix != null &&
paramInInvWorldMatrix != null &&
this.paramBlendDQ != null &&
this.paramInitialDQ != null &&
this.paramIndex1 != null &&
this.paramIndex2 != null &&
( !scalingShearingSupport || ( scalingShearingSupport &&
this.paramInScaleShearMatrices != null && this.paramBlendS != null &&
this.paramTempFloat3x3 != null && this.paramTempFloat3x4 != null ) ) &&
this.paramTempFloat2x4 != null &&
paramTempFloat4 != null &&
paramTempFloat3 != null );
}
else
{
paramInWorldMatrix =
vsProgram.ResolveAutoParameterInt( Graphics.GpuProgramParameters.AutoConstantType.WorldMatrix, 0 );
paramInWorldViewProjMatrix =
vsProgram.ResolveAutoParameterInt(
Graphics.GpuProgramParameters.AutoConstantType.WorldViewProjMatrix, 0 );
isValid &= paramInWorldMatrix != null && paramInWorldViewProjMatrix != null;
}
return isValid;
}
internal override bool AddFunctionInvocations( ProgramSet programSet )
{
Program vsProgram = programSet.CpuVertexProgram;
Function vsMain = vsProgram.EntryPointFunction;
int internalCounter = 0;
//add functions to calculate position data in world, object and projective space
AddPositionCalculations( vsMain, ref internalCounter );
//add functions to calculate normal and normal related data in world and object space
AddNormalRelatedCalculations( vsMain, paramInNormal, paramLocalNormalWorld, ref internalCounter );
AddNormalRelatedCalculations( vsMain, paramInTangent, paramLocalTangentWorld, ref internalCounter );
AddNormalRelatedCalculations( vsMain, paramInBiNormal, paramLocalBiNormalWorld, ref internalCounter );
return true;
}
internal virtual bool AddFunctionInvocations( ProgramSet programSet )
{
return false;
}
internal virtual bool ResolveParameters( ProgramSet programSet )
{
return false;
}
internal override bool ResolveDependencies( ProgramSet programSet )
{
Program vsProgram = programSet.CpuVertexProgram;
vsProgram.AddDependency( FFPRenderState.FFPLibCommon );
vsProgram.AddDependency( FFPRenderState.FFPLibTransform );
vsProgram.AddDependency( SGXLibQuaternion );
return true;
}
