public override void SetScene(IRayEngineScene secn)
{
Tracer.TraceLine("OptixIntersectionDevice - Initializing Optix");
this.scene = (RayEngineScene)secn;
td = scene.Triangles.SelectMany(tr => new[]
{
scene.Vertices[tr.v0.VertexIndex].x,
scene.Vertices[tr.v0.VertexIndex].y,
scene.Vertices[tr.v0.VertexIndex].z,
scene.Vertices[tr.v1.VertexIndex].x,
scene.Vertices[tr.v1.VertexIndex].y,
scene.Vertices[tr.v1.VertexIndex].z,
scene.Vertices[tr.v2.VertexIndex].x,
scene.Vertices[tr.v2.VertexIndex].y,
scene.Vertices[tr.v2.VertexIndex].z,
}).ToArray();
this.triangles = scene.Triangles.Select(tr => new TriInfo
{
v0x = scene.Vertices[tr.v0.VertexIndex].x,
v1x = scene.Vertices[tr.v1.VertexIndex].x,
v2x = scene.Vertices[tr.v2.VertexIndex].x,
v0y = scene.Vertices[tr.v0.VertexIndex].y,
v1y = scene.Vertices[tr.v1.VertexIndex].y,
v2y = scene.Vertices[tr.v2.VertexIndex].y,
v0z = scene.Vertices[tr.v0.VertexIndex].z,
v1z = scene.Vertices[tr.v1.VertexIndex].z,
v2z = scene.Vertices[tr.v2.VertexIndex].z,
}).ToArray();
if (trav == null)
trav = new Traversal(Context, QueryType.ClosestHit, RayFormat.OriginDirectionMinMaxInterleaved, TriFormat.TriangleSoup, TraversalOutput.BaryCentric, InitOptions.CullBackFace);
trav.SetTriangles(td);
}
public ByTraversalStep(Traversal traversal) : base(traversal.GetSideEffectSemanticsChange())
{
Traversal = traversal;
}
public WithStrategiesStep(Traversal traversal) : base(traversal.GetSideEffectSemanticsChange())
{
Traversal = traversal;
}
public ByTraversalStep(Traversal traversal, Order order) : base(traversal.GetSideEffectSemanticsChange())
{
Traversal = traversal;
Order = order;
}
public OptionTraversalStep(object?guard, Traversal optionTraversal)
{
Guard = guard;
OptionTraversal = optionTraversal;
}
public static void Traverse(Tour tour, Traversal tm, Visitor vm, Direction d, Filter f = null)
{
WriteHeader(tm.ToString() + " - " + vm.ToString() + " - " + d.ToString());
if (f == null)
{
filter = v => true;
}
else
{
filter = f;
}
switch (vm)
{
case Visitor.Partition: tour.visit = StandardPartition; break;
case Visitor.Conjugate: tour.visit = ConjugatedPartition; break;
case Visitor.Reverse: tour.visit = ReversedPartition; break;
case Visitor.ReverseConjugate: tour.visit = ReversedConjugatedPartition; break;
default: tour.visit = PrintPartition; break;
}
switch (tm)
{
case Traversal.PreOrder:
if (d == Direction.LeftRight)
{
tour.PreorderLRTraversal();
}
else
{
tour.PreorderRLTraversal();
}
break;
case Traversal.InOrder:
if (d == Direction.LeftRight)
{
tour.InorderLRTraversal();
}
else
{
tour.InorderRLTraversal();
}
break;
case Traversal.PostOrder:
if (d == Direction.LeftRight)
{
tour.PostorderLRTraversal();
}
else
{
tour.PostorderRLTraversal();
}
break;
case Traversal.LevelOrder:
if (d == Direction.LeftRight)
{
tour.LevelorderLRTraversal();
}
else
{
tour.LevelorderRLTraversal();
}
break;
case Traversal.BranchOrder:
if (d == Direction.LeftRight)
{
tour.BranchorderLRTraversal();
}
else
{
tour.BranchorderRLTraversal();
}
break;
}
}
/// <summary>
/// Compute the algorithm starting at the first vertex.
/// </summary>
public void Compute()
{
this.Compute(Traversal.FirstEdge(this.VisitedGraph).Source);
}
public ChooseTraversalStep(Traversal ifTraversal, Traversal thenTraversal, Traversal?elseTraversal = default) : base(thenTraversal, elseTraversal)
{
IfTraversal = ifTraversal;
}
public HasTraversalStep(Key key, Traversal traversal) : base(traversal.GetSideEffectSemanticsChange())
{
Key = key;
Traversal = traversal;
}
public ToTraversalStep(Traversal traversal)
{
Traversal = traversal;
}
public FromTraversalStep(Traversal traversal)
{
Traversal = traversal;
}
public FlatMapStep(Traversal traversal)
{
Traversal = traversal;
}
public HasTraversalStep(Key key, Traversal traversal)
{
Key = key;
Traversal = traversal;
}
internal override GremlinToSqlContext GetContext()
{
GremlinToSqlContext inputContext = GetInputContext();
switch (OpType)
{
//has(key)
case HasOpType.HasProperty:
inputContext.PivotVariable.Has(inputContext, PropertyKey);
break;
//has(key, value)
case HasOpType.HasPropertyValue:
inputContext.PivotVariable.Has(inputContext, PropertyKey, Value);
break;
//has(key, predicate)
case HasOpType.HasPropertyPredicate:
inputContext.PivotVariable.Has(inputContext, PropertyKey, Predicate);
break;
//has(label, key, value)
case HasOpType.HasLabelPropertyValue:
inputContext.PivotVariable.Has(inputContext, Label, PropertyKey, Value);
break;
//has(label, key, predicate)
case HasOpType.HasLabelPropertyPredicate:
inputContext.PivotVariable.Has(inputContext, Label, PropertyKey, Predicate);
break;
case HasOpType.HasPropertyTraversal:
Traversal.GetStartOp().InheritedVariableFromParent(inputContext);
if (Traversal.GetStartOp() is GremlinParentContextOp)
{
if (Traversal.GremlinTranslationOpList.Count > 1)
{
Traversal.InsertGremlinOperator(1, new GremlinValuesOp(PropertyKey));
}
else
{
Traversal.AddGremlinOperator(new GremlinValuesOp(PropertyKey));
}
}
GremlinToSqlContext hasContext = Traversal.GetEndOp().GetContext();
inputContext.PivotVariable.Has(inputContext, PropertyKey, hasContext);
break;
//hasId(values)
case HasOpType.HasId:
inputContext.PivotVariable.HasId(inputContext, Values);
break;
//hasId(predicate)
case HasOpType.HasIdPredicate:
inputContext.PivotVariable.HasId(inputContext, Predicate);
break;
//hasKey(values)
case HasOpType.HasKey:
inputContext.PivotVariable.HasKey(inputContext, Keys);
break;
//hasKey(predicate)
case HasOpType.HasKeyPredicate:
inputContext.PivotVariable.HasKey(inputContext, Predicate);
break;
//hasLabel(values)
case HasOpType.HasLabel:
inputContext.PivotVariable.HasLabel(inputContext, Values);
break;
//hasLabel(predicate)
case HasOpType.HasLabelPredicate:
inputContext.PivotVariable.HasLabel(inputContext, Predicate);
break;
//hasValue(values)
case HasOpType.HasValue:
inputContext.PivotVariable.HasValue(inputContext, Values);
break;
//hasValue(predicate)
case HasOpType.HasValuePredicate:
inputContext.PivotVariable.HasValue(inputContext, Predicate);
break;
}
return(inputContext);
}
