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; }