public static void OnRightSelected()
{
selection = "Right";
SideSelector.SetSide(selection);
testStart = true;
input.gameObject.SetActive(false);
}
internal BidirectionalTraverserIterator(Resource resource, MonoDirectionalTraversalDescription start, MonoDirectionalTraversalDescription end, SideSelectorPolicy sideSelector, Org.Neo4j.Graphdb.traversal.BranchCollisionPolicy collisionPolicy, PathEvaluator collisionEvaluator, int maxDepth, IEnumerable <Node> startNodes, IEnumerable <Node> endNodes) : base(resource)
{
this._sides[Direction.OUTGOING] = new Side(start);
this._sides[Direction.INCOMING] = new Side(end);
this._uniqueness = MakeSureStartAndEndHasSameUniqueness(start, end);
// A little chicken-and-egg problem. This happens when constructing the start/end
// selectors and they initially call evaluate() and isUniqueFirst, where the selector is used.
// Solved this way for now, to have it return the start side to begin with.
this._selector = FixedSide(Direction.OUTGOING);
BranchSelector startSelector = start.BranchOrdering.create(new AsOneStartBranch(this, startNodes, start.InitialState, start.UniquenessConflict), start.Expander);
this._selector = FixedSide(Direction.INCOMING);
BranchSelector endSelector = end.BranchOrdering.create(new AsOneStartBranch(this, endNodes, end.InitialState, start.UniquenessConflict), end.Expander);
this._selector = sideSelector.Create(startSelector, endSelector, maxDepth);
this._collisionDetector = collisionPolicy.Create(collisionEvaluator, _uniqueness.checkFull);
}
protected void ProcessFrame()
{
if (XDevice == null || !Scanning)
{
return;
}
Processing++;
try
{
if (DepthCacheUsed >= DepthAveragingCacheSize)
{
if (FrameID % FusionSpacing == 0)
{
XDevice.SetRenderTarget(Vector2TargetA);
XDevice.Clear(Color.Black);
XDevice.SetRenderTarget(Vector2TargetB);
XDevice.Clear(Color.Black);
int mainIndex = (DepthIndex + DepthMainItem) % DepthAveragingCacheSize;
mainRotation = DepthCache[mainIndex].Rotation;
byte[] deltaData;
float deltaRotation;
bool tick = false;
for (int i = 0; i < DepthAveragingCacheSize; i++)
{
deltaData = DepthCache[i].Data;
deltaRotation = DepthCache[i].Rotation - mainRotation;
if (deltaRotation > MathHelper.Pi)
{
deltaRotation -= MathHelper.TwoPi;
}
if (deltaRotation < -MathHelper.Pi)
{
deltaRotation += MathHelper.TwoPi;
}
for (int j = 0; j < 16; j++)
{
XDevice.Textures[j] = null;
}
TRawDepth.SetData <byte>(deltaData);
//Anti-distort
XDevice.SetRenderTarget(SingleTargetA);
XDevice.Clear(Color.Black);
XDevice.RasterizerState = RasterizerState.CullNone;
XDevice.BlendState = BlendState.Opaque;
XDevice.DepthStencilState = DepthStencilState.None;
DepthSampler.SetValue(TRawDepth);
DepthCorrectionSampler.SetValue(TDepthCorrection);
XEffect.CurrentTechnique = DepthAntiDistortTechnique; //<----
XEffect.CurrentTechnique.Passes[0].Apply();
MiniPlane.Draw();
if (ViewMode == Views.AntiDistort)
{
Visualize(SingleTargetA, DepthVisualizationTechnique, MainViewport);
}
//Reprojection + transform
SetReprojection(deltaRotation);
TriangleRemoveLimit.SetValue(Context.TriangleRemoveLimit);
XDevice.SetRenderTarget(SingleTargetB);
XDevice.Clear(Color.Black);
XDevice.BlendState = BlendState.Opaque;
XDevice.RasterizerState = RasterizerState.CullCounterClockwise;
XDevice.DepthStencilState = DepthStencilState.Default;
DepthSampler.SetValue(SingleTargetA);
XEffect.CurrentTechnique = PerspectiveReprojectionTechnique; //<----
XEffect.CurrentTechnique.Passes[0].Apply();
MaxiPlane.Draw();
if (ViewMode == Views.Sum)
{
Visualize(SingleTargetB, DepthVisualizationTechnique, MainViewport);
}
//Sum
XDevice.SetRenderTarget(tick ? Vector2TargetA : Vector2TargetB);
XDevice.Clear(Color.Black);
XDevice.RasterizerState = RasterizerState.CullNone;
XDevice.BlendState = BlendState.Opaque;
XDevice.DepthStencilState = DepthStencilState.None;
DepthSamplerA.SetValue(SingleTargetB);
DepthSamplerB.SetValue(tick ? Vector2TargetB : Vector2TargetA);
XEffect.CurrentTechnique = SumTechnique; //<----
XEffect.CurrentTechnique.Passes[0].Apply();
MiniPlane.Draw();
tick = !tick;
}
//Fusion + transform
SetFusionReprojection(0f, mainRotation);
XDevice.SetRenderTarget(SingleTargetTick ? SingleTargetA : SingleTargetB);
DepthSampler.SetValue(tick ? Vector2TargetB : Vector2TargetA);
XEffect.CurrentTechnique = AvgTechnique; //<----
XEffect.CurrentTechnique.Passes[0].Apply();
MiniPlane.Draw();
if (ViewMode == Views.Avg)
{
Visualize(SingleTargetTick ? SingleTargetA : SingleTargetB, SignedDepthVisualizationTechnique, MainViewport);
}
//Gauss
for (int i = 0; i < 0; i++)
{
XDevice.SetRenderTarget(SingleTargetTick ? SingleTargetB : SingleTargetA);
DepthSampler.SetValue(SingleTargetTick ? SingleTargetA : SingleTargetB);
XEffect.CurrentTechnique = VGaussTechnique;
XEffect.CurrentTechnique.Passes[0].Apply();
MiniPlane.Draw();
SingleTargetTick = !SingleTargetTick;
XDevice.SetRenderTarget(SingleTargetTick ? SingleTargetB : SingleTargetA);
DepthSampler.SetValue(SingleTargetTick ? SingleTargetA : SingleTargetB);
XEffect.CurrentTechnique = HGaussTechnique;
XEffect.CurrentTechnique.Passes[0].Apply();
MiniPlane.Draw();
SingleTargetTick = !SingleTargetTick;
}
if (ViewMode == Views.Gauss)
{
Visualize(SingleTargetTick ? SingleTargetA : SingleTargetB, SignedDepthVisualizationTechnique, MainViewport);
}
for (int leg = 0; leg < 2; leg++)
{
SideSelector.SetValue(leg == 0 ? 1f : -1f);
ProcessLeg(leg, leg == VisualizedLeg || VisualizedLeg == 2, VisualizedLeg == 2 ? Viewports[leg] : MainViewport, leg == VisualizedLeg || (VisualizedLeg == 2 && leg == 1), VisualizedLeg != 2 || (VisualizedLeg == 2 && leg == 0));
}
}
FrameID++;
}
if (StopPending)
{
StopARE.Set();
StopPending = false;
}
}
catch
{
if (System.Diagnostics.Debugger.IsAttached)
{
System.Diagnostics.Debugger.Break();
}
}
Processing--;
}
