private IntSet32 BuildChildVisibility()
{
var visibility = new IntSet32();
for (var i = 0; i < rows.Count; i++)
{
if (rows[i].IsVisible)
{
visibility = visibility.With(i);
}
}
return(visibility);
}
public void Update()
{
foreach (var row in rows.Where(x => x.IsVisible))
{
row.Update();
}
var newRowVisibility = BuildChildVisibility();
if (newRowVisibility != rowVisibility)
{
RebuildEto();
}
rowVisibility = newRowVisibility;
}
public void GenerateDeterminants4x3()
{
for (int r1 = 0; r1 < 4; r1++)
{
for (int r2 = r1 + 1; r2 < 4; r2++)
{
for (int c1 = 0; c1 < 4; c1++)
{
for (int c2 = c1 + 1; c2 < 4; c2++)
{
var rowSet = IntSet32.Range(0, 4).Without(r1).Without(r2);
int dr1 = rowSet.First();
int dr2 = rowSet.Last();
var colSet = IntSet32.Range(0, 4).Without(c1).Without(c2);
int dc1 = colSet.First();
int dc2 = colSet.Last();
Console.WriteLine("private float D{0}{1}{2}{3} {{ get {{ return M{4}{5} * M{6}{7} - M{4}{7} * M{6}{5}; }} }}",
r1, r2, c1, c2, dr1, dc1, dr2, dc2);
}
}
}
}
Console.WriteLine();
for (int r = 0; r < 4; r++)
{
for (int c = 0; c < 4; c++)
{
int dc = c != 3 ? 3 : 2;
var drows = IntSet32.Range(0, 4).Without(r);
var memberList = new List <string>();
foreach (int dr in drows)
{
int dr1 = System.Math.Min(r, dr);
int dr2 = System.Math.Max(r, dr);
int dc1 = System.Math.Min(c, dc);
int dc2 = System.Math.Max(c, dc);
memberList.Add(string.Format("M{0}{1} * D{2}{3}{4}{5}", dr, dc, dr1, dr2, dc1, dc2));
}
Console.WriteLine("private float D{0}{1} {{ get {{ return {2} - {3} + {4}; }} }}",
r, c, memberList[0], memberList[1], memberList[2]);
}
}
}
public void GenerateDeterminants3x3()
{
for (int r = 0; r < 4; r++)
{
for (int c = 0; c < 4; c++)
{
var rowSet = IntSet32.Range(0, 3).Without(r);
int dr1 = rowSet.First();
int dr2 = rowSet.Last();
var colSet = IntSet32.Range(0, 3).Without(c);
int dc1 = colSet.First();
int dc2 = colSet.Last();
Console.WriteLine("private float D{0}{1} {{ get {{ return M{2}{3} * M{4}{5} - M{2}{5} * M{4}{3}; }} }}",
r, c, dr1, dc1, dr2, dc2);
}
}
}
public void TestConstruction()
{
var set = IntSet32.Range(7, 15).Without(11).Without(16).With(29).With(31);
Assert.That(set.ToString(), Is.EqualTo("00000001111011110111110000000101"));
}
private void PlaceCorridors()
{
var occupiedLanes = new IntSet32[sg.NodeIds.Max() + 1];
foreach (var edge in sg.Edges)
{
laneBuilder.StartLane(edge);
var disambiguator = 0;
var commonOccupiedLanes = new IntSet32();
if (sg.Parents[edge.First] == sg.Parents[edge.Second])
{
var commonParent = sg.Parents[edge.First];
var startPoint = relPositions[edge.First] + Vector3.UnitX * halfSizes[edge.First].Width;
var endPoint = relPositions[edge.Second] - Vector3.UnitX * halfSizes[edge.Second].Width;
if (!IsMultiFloorNode(commonParent))
{
if (nodeRows[edge.Second] - nodeRows[edge.First] == 1)
{
laneBuilder.StartLaneSegment(BuildingStoryLayoutLanePartType.Immediate, true);
laneBuilder.AddRawPoint(startPoint);
laneBuilder.AddRawPoint(startPoint + Vector3.UnitX * BuildingConstants.CorridorBranchingOffset);
laneBuilder.AddRawPoint(endPoint - Vector3.UnitX * BuildingConstants.CorridorBranchingOffset);
laneBuilder.AddRawPoint(endPoint);
laneBuilder.EndLaneSegment(commonParent, true);
}
else
{
disambiguator = 1;
while (occupiedLanes[commonParent].Contains(disambiguator))
{
disambiguator++;
}
var leafChildrenOnly = !sg.Children[commonParent].SelectMany(x => sg.Children[x]).Any();
if (leafChildrenOnly)
{
laneBuilder.StartLaneSegment(BuildingStoryLayoutLanePartType.LongRange, true);
laneBuilder.AddRawPoint(startPoint);
laneBuilder.AddRawPoint(startPoint + Vector3.UnitX * BuildingConstants.CorridorBranchingOffset);
laneBuilder.AddRawPoint(new Vector3(startPoint.X + BuildingConstants.WidthMargin - BuildingConstants.CorridorBranchingOffset, startPoint.Y, 0));
laneBuilder.AddRawPoint(new Vector3(endPoint.X - BuildingConstants.WidthMargin + BuildingConstants.CorridorBranchingOffset, startPoint.Y, 0));
laneBuilder.AddRawPoint(endPoint - Vector3.UnitX * BuildingConstants.CorridorBranchingOffset);
laneBuilder.AddRawPoint(endPoint);
laneBuilder.EndLaneSegment(commonParent, true);
occupiedLanes[commonParent] = occupiedLanes[commonParent].With(disambiguator);
}
else
{
laneBuilder.StartLaneSegment(BuildingStoryLayoutLanePartType.LongRange, true);
laneBuilder.AddRawPoint(startPoint);
laneBuilder.AddRawPoint(startPoint + Vector3.UnitX * BuildingConstants.CorridorBranchingOffset);
laneBuilder.AddRawPoint(new Vector3(startPoint.X + BuildingConstants.WidthMargin - BuildingConstants.CorridorBranchingOffset, startPoint.Y, 0));
laneBuilder.AddRawPoint(new Vector3(startPoint.X + BuildingConstants.WidthMargin, startPoint.Y, 0));
laneBuilder.EndLaneSegment(commonParent, false);
laneBuilder.StartLaneSegment(BuildingStoryLayoutLanePartType.LongRange, false);
laneBuilder.AddRawPoint(new Vector3(endPoint.X - BuildingConstants.WidthMargin, startPoint.Y, 0));
laneBuilder.AddRawPoint(new Vector3(endPoint.X - BuildingConstants.WidthMargin + BuildingConstants.CorridorBranchingOffset, startPoint.Y, 0));
laneBuilder.AddRawPoint(endPoint - Vector3.UnitX * BuildingConstants.CorridorBranchingOffset);
laneBuilder.AddRawPoint(endPoint);
laneBuilder.EndLaneSegment(commonParent, true);
occupiedLanes[commonParent] = occupiedLanes[commonParent].With(disambiguator);
}
}
}
else
{
disambiguator = 1;
while (occupiedLanes[commonParent].Contains(disambiguator))
{
disambiguator++;
}
var floorDistance = nodeRows[edge.Second] - nodeRows[edge.First];
laneBuilder.StartLaneSegment(BuildingStoryLayoutLanePartType.LongRange, true);
laneBuilder.AddRawPoint(startPoint);
laneBuilder.AddRawPoint(new Vector3(halfSizes[commonParent].Width, startPoint.Y, startPoint.Z));
laneBuilder.AddRawPoint(new Vector3(halfSizes[commonParent].Width, startPoint.Y, -halfSizes[commonParent].Depth - BuildingConstants.StairsDistance * (floorDistance + 1)));
laneBuilder.AddRawPoint(new Vector3(halfSizes[commonParent].Width, endPoint.Y, -halfSizes[commonParent].Depth - BuildingConstants.StairsDistance * (floorDistance + 1)));
laneBuilder.AddRawPoint(new Vector3(halfSizes[commonParent].Width, endPoint.Y, endPoint.Z));
laneBuilder.AddRawPoint(endPoint);
laneBuilder.EndLaneSegment(commonParent, true);
}
}
else
{
var commonParent = sg.GetCommonParent(edge.First, edge.Second);
var laneContainerNodes = new List <int>();
var descendingNodes = new Stack <int>();
{
var descNode = edge.Second;
while (descNode != commonParent)
{
descendingNodes.Push(descNode);
descNode = sg.Parents[descNode];
}
}
var node = edge.First;
while (sg.Parents[node] != commonParent)
{
var parent = sg.Parents[node];
commonOccupiedLanes = commonOccupiedLanes.Union(occupiedLanes[parent]);
laneContainerNodes.Add(parent);
var nodeLoc = node;
var transitSiblings = sg.Children[parent].Where(x => relPositions[x].Z == 0f && nodeRows[nodeLoc] < nodeRows[x]);
foreach (var transitSibling in transitSiblings)
{
commonOccupiedLanes = commonOccupiedLanes.Union(occupiedLanes[transitSibling]);
laneContainerNodes.Add(transitSibling);
}
var startPoint = relPositions[node] + Vector3.UnitX * halfSizes[node].Width;
laneBuilder.StartLaneSegment(BuildingStoryLayoutLanePartType.InterNode, node == edge.First);
laneBuilder.AddRawPoint(startPoint);
laneBuilder.AddRawPoint(startPoint + Vector3.UnitX * BuildingConstants.CorridorBranchingOffset);
laneBuilder.AddRawPoint(new Vector3(startPoint.X + BuildingConstants.WidthMargin - BuildingConstants.CorridorBranchingOffset, startPoint.Y, 0));
laneBuilder.AddRawPoint(new Vector3(halfSizes[parent].Width, startPoint.Y, 0));
laneBuilder.EndLaneSegment(parent, false);
node = sg.Parents[node];
}
{
var topLevelChildFirst = node;
var topLevelChildSecond = descendingNodes.Pop();
commonOccupiedLanes = commonOccupiedLanes.Union(occupiedLanes[commonParent]);
laneContainerNodes.Add(commonParent);
var startPoint = relPositions[topLevelChildFirst] + Vector3.UnitX * halfSizes[topLevelChildFirst].Width;
var endPoint = relPositions[topLevelChildSecond] - Vector3.UnitX * halfSizes[topLevelChildSecond].Width;
if (!IsMultiFloorNode(commonParent))
{
if (nodeRows[topLevelChildSecond] - nodeRows[topLevelChildFirst] == 1)
{
laneBuilder.StartLaneSegment(BuildingStoryLayoutLanePartType.InterNode, false);
laneBuilder.AddRawPoint(startPoint);
laneBuilder.AddRawPoint(startPoint + Vector3.UnitX * BuildingConstants.CorridorBranchingOffset);
laneBuilder.AddRawPoint(endPoint - Vector3.UnitX * BuildingConstants.CorridorBranchingOffset);
laneBuilder.AddRawPoint(endPoint);
laneBuilder.EndLaneSegment(commonParent, false);
}
else
{
var transitSiblings = sg.Children[commonParent].Where(x => relPositions[x].Z == 0f && nodeRows[topLevelChildFirst] < nodeRows[x] && nodeRows[x] < nodeRows[topLevelChildSecond]);
foreach (var transitSibling in transitSiblings)
{
commonOccupiedLanes = commonOccupiedLanes.Union(occupiedLanes[transitSibling]);
laneContainerNodes.Add(transitSibling);
}
laneBuilder.StartLaneSegment(BuildingStoryLayoutLanePartType.InterNode, false);
laneBuilder.AddRawPoint(startPoint);
laneBuilder.AddRawPoint(startPoint + Vector3.UnitX * BuildingConstants.CorridorBranchingOffset);
laneBuilder.AddRawPoint(new Vector3(startPoint.X + BuildingConstants.WidthMargin - BuildingConstants.CorridorBranchingOffset, startPoint.Y, 0));
laneBuilder.AddRawPoint(new Vector3(endPoint.X - BuildingConstants.WidthMargin + BuildingConstants.CorridorBranchingOffset, startPoint.Y, 0));
laneBuilder.AddRawPoint(endPoint - Vector3.UnitX * BuildingConstants.CorridorBranchingOffset);
laneBuilder.AddRawPoint(endPoint);
laneBuilder.EndLaneSegment(commonParent, false);
}
}
else
{
var revStartPoint = new Vector3(-startPoint.X, startPoint.Y, startPoint.Z);
var revEndPoint = new Vector3(-endPoint.X, endPoint.Y, endPoint.Z);
var floorDistance = nodeRows[topLevelChildSecond] - nodeRows[topLevelChildFirst];
laneBuilder.StartLaneSegment(BuildingStoryLayoutLanePartType.Elevator, false);
if (!isReversed[topLevelChildFirst])
{
laneBuilder.AddRawPoint(startPoint);
laneBuilder.AddRawPoint(startPoint + Vector3.UnitX * BuildingConstants.ElevatorOffset);
}
else
{
laneBuilder.AddRawPoint(revStartPoint);
laneBuilder.AddRawPoint(revStartPoint - Vector3.UnitX * BuildingConstants.ElevatorOffset);
}
if (!isReversed[topLevelChildSecond])
{
if (!isReversed[topLevelChildFirst])
{
laneBuilder.AddRawPoint(revEndPoint + Vector3.UnitX * BuildingConstants.ElevatorOffset);
laneBuilder.AddRawPoint(revEndPoint);
laneBuilder.AddRawPoint(endPoint);
}
else
{
laneBuilder.AddRawPoint(endPoint - Vector3.UnitX * BuildingConstants.ElevatorOffset);
laneBuilder.AddRawPoint(endPoint);
}
}
else
{
if (!isReversed[topLevelChildFirst])
{
laneBuilder.AddRawPoint(revEndPoint + Vector3.UnitX * BuildingConstants.ElevatorOffset);
laneBuilder.AddRawPoint(revEndPoint);
}
else
{
laneBuilder.AddRawPoint(endPoint - Vector3.UnitX * BuildingConstants.ElevatorOffset);
laneBuilder.AddRawPoint(endPoint);
laneBuilder.AddRawPoint(revEndPoint);
}
}
laneBuilder.EndLaneSegment(commonParent, false);
}
}
while (descendingNodes.Any())
{
node = descendingNodes.Pop();
var parent = sg.Parents[node];
commonOccupiedLanes = commonOccupiedLanes.Union(occupiedLanes[parent]);
laneContainerNodes.Add(parent);
var nodeLoc = node;
var transitSiblings = sg.Children[parent].Where(x => relPositions[x].Z == 0f && nodeRows[x] < nodeRows[nodeLoc]);
foreach (var transitSibling in transitSiblings)
{
commonOccupiedLanes = commonOccupiedLanes.Union(occupiedLanes[transitSibling]);
laneContainerNodes.Add(transitSibling);
}
var endPoint = relPositions[node] - Vector3.UnitX * halfSizes[node].Width;
laneBuilder.StartLaneSegment(BuildingStoryLayoutLanePartType.InterNode, false);
laneBuilder.AddRawPoint(new Vector3(-halfSizes[parent].Width, endPoint.Y, 0));
laneBuilder.AddRawPoint(new Vector3(endPoint.X - BuildingConstants.WidthMargin + BuildingConstants.CorridorBranchingOffset, endPoint.Y, 0));
laneBuilder.AddRawPoint(new Vector3(endPoint.X - BuildingConstants.CorridorBranchingOffset, endPoint.Y, endPoint.Z));
laneBuilder.AddRawPoint(endPoint);
laneBuilder.EndLaneSegment(parent, node == edge.Second);
}
disambiguator = 1;
while (commonOccupiedLanes.Contains(disambiguator))
{
disambiguator++;
}
foreach (var laneContainerNode in laneContainerNodes)
{
occupiedLanes[laneContainerNode] = occupiedLanes[laneContainerNode].With(disambiguator);
}
}
laneBuilder.EndLane(disambiguator);
}
}
