public int Raise(ObjectPlacementPath path, int currentPathHeight)
{
currentPathHeight += path.Settings.ManualConstructionSettings.HeightAdjustmentSettings.ManualHeightAdjustmentSettings.RaiseAmount;
ObjectPlacementBoxStackSegmentActions.SetHeightForSegments(path.GetAllSegments(), currentPathHeight);
return(currentPathHeight);
}
private void RenderPathUnderManualConstructionWhenNotUsingTileConnections(ObjectPlacementPath path)
{
List <ObjectPlacementBoxStackSegment> allPathSegments = path.GetAllSegments();
ObjectPlacementPathManualConstructionRenderSettings renderSettings = path.RenderSettings.ManualConstructionRenderSettings;
Vector3 boxYOffsetvector = path.Settings.ManualConstructionSettings.OffsetAlongGrowDirection * path.ExtensionPlane.normal;
foreach (ObjectPlacementBoxStackSegment segment in allPathSegments)
{
for (int stackIndex = 0; stackIndex < segment.NumberOfStacks; ++stackIndex)
{
ObjectPlacementBoxStack stack = segment.GetStackByIndex(stackIndex);
if (stack.IsOverlappedByAnotherStack)
{
continue;
}
for (int boxIndex = 0; boxIndex < stack.NumberOfBoxes; ++boxIndex)
{
ObjectPlacementBox placementBox = stack.GetBoxByIndex(boxIndex);
if (placementBox.IsHidden)
{
continue;
}
OrientedBox orientedBox = placementBox.OrientedBox;
orientedBox.Center += boxYOffsetvector;
GizmosEx.RenderOrientedBoxEdges(orientedBox, renderSettings.BoxBorderLineColor);
}
}
}
}
public void RenderGizmos(ObjectPlacementPath path)
{
if (path.IsUnderManualConstruction)
{
RenderPathUnderManualConstruction(path);
}
}
private void RenderPathUnderManualConstruction(ObjectPlacementPath path)
{
ObjectPlacementPathTileConnectionSettings tileConnectionSettings = path.Settings.TileConnectionSettings;
if (tileConnectionSettings.UseTileConnections)
{
RenderPathUnderManualConstructionWhenUsingTileConnections(path, tileConnectionSettings);
}
else
{
RenderPathUnderManualConstructionWhenNotUsingTileConnections(path);
}
}
private void RenderPathUnderManualConstructionWhenUsingTileConnections(ObjectPlacementPath path, ObjectPlacementPathTileConnectionSettings tileConnectionSettings)
{
List <ObjectPlacementPathTileConnectionGridCell> tileConnectionGridCells = path.TileConnectionGridCells;
ObjectPlacementPathManualConstructionRenderSettings renderSettings = path.RenderSettings.ManualConstructionRenderSettings;
var tileConnectionYOffsetVectorCalculator = new ObjectPlacementPathTileConnectionYOffsetVectorCalculator();
// Loop through all tile connection grid cells. Each cell will give us access to all the information
// that we need to perform the rendering operation.
foreach (ObjectPlacementPathTileConnectionGridCell tileConnectionGridCell in tileConnectionGridCells)
{
// Use the cell to access the tile connection stack. If the stack is overlapped by another stack
// or if no boxes exist in the stack, we can move on to the next cell.
ObjectPlacementBoxStack tileConnectionStack = tileConnectionGridCell.TileConnectionStack;
if (tileConnectionStack.IsOverlappedByAnotherStack || tileConnectionStack.NumberOfBoxes == 0)
{
continue;
}
// Calculate the Y offset vector which applies to all tiles in the current stack and then render each
// box which resides inside the stack.
Vector3 tileConnectionYOffsetVector = tileConnectionYOffsetVectorCalculator.Calculate(tileConnectionSettings.GetSettingsForTileConnectionType(tileConnectionGridCell.TileConnectionType), path);
for (int boxIndex = 0; boxIndex < tileConnectionStack.NumberOfBoxes; ++boxIndex)
{
// If the box is hidden, we can move on to the next box
ObjectPlacementBox placementBox = tileConnectionStack.GetBoxByIndex(boxIndex);
if (placementBox.IsHidden)
{
continue;
}
// Retrieve the box and apply the Y offset vector. The render the box.
OrientedBox orientedBox = placementBox.OrientedBox;
orientedBox.Center += tileConnectionYOffsetVector;
GizmosEx.RenderOrientedBoxEdges(orientedBox, renderSettings.BoxBorderLineColor);
}
// We have to take tile connection extrusion into account, so we will need to retrieve the extrusion
// boxes and render those too.
List <OrientedBox> extrusionOrientedBoxes = ObjectPlacementPathTileConnectionExtrusion.GetTileConnectionExtrusionOrientedBoxes(tileConnectionGridCell);
foreach (OrientedBox extrusionBox in extrusionOrientedBoxes)
{
GizmosEx.RenderOrientedBoxEdges(extrusionBox, renderSettings.BoxBorderLineColor);
}
}
}
public static void PerformRegistrationForObjectPlacementPath(ObjectPlacementPath objectPlacementPath)
{
if (objectPlacementPath != null)
{
MessageListenerDatabase listenerDatabase = MessageListenerDatabase.Instance;
listenerDatabase.UnregisterListener(objectPlacementPath);
listenerDatabase.RegisterListenerForMessage(MessageType.ObjectPlacementPathExcludeCornersWasChanged, objectPlacementPath);
listenerDatabase.RegisterListenerForMessage(MessageType.ObjectPlacementPathBorderSettingsWereChanged, objectPlacementPath);
listenerDatabase.RegisterListenerForMessage(MessageType.ObjectPlacementPathPaddingSettingsWereChanged, objectPlacementPath);
listenerDatabase.RegisterListenerForMessage(MessageType.ObjectPlacementPathRotateObjectsToFollowPathWasChanged, objectPlacementPath);
listenerDatabase.RegisterListenerForMessage(MessageType.ObjectPlacementPathHeightAdjustmentModeWasChanged, objectPlacementPath);
listenerDatabase.RegisterListenerForMessage(MessageType.ObjectPlacementPathAutomaticRandomHeightAdjustmentSettingsWereChanged, objectPlacementPath);
listenerDatabase.RegisterListenerForMessage(MessageType.ObjectPlacementPathAutomaticPatternHeightAdjustmentSettingsWereChanged, objectPlacementPath);
listenerDatabase.RegisterListenerForMessage(MessageType.ObjectPlacementPathHeightPatternWasRemovedFromDatabase, objectPlacementPath);
listenerDatabase.RegisterListenerForMessage(MessageType.NewObjectPlacementPathHeightPatternWasActivated, objectPlacementPath);
listenerDatabase.RegisterListenerForMessage(MessageType.UndoRedoWasPerformed, objectPlacementPath);
}
}
public List <ObjectPlacementPathTileConnectionGridCell> Detect(ObjectPlacementPath path, float tileXZSize)
{
_tileXZSize = tileXZSize;
List <ObjectPlacementBoxStackSegment> allPathSegments = path.GetAllSegments();
if (allPathSegments.Count == 0)
{
return(new List <ObjectPlacementPathTileConnectionGridCell>());
}
// Create the grid cell instances which are occupied by tiles
Vector3 gridOrigin = path.ExtensionPlane.ProjectPoint(allPathSegments[0].GetStackByIndex(0).BasePosition);
var tileConnectionGrid = new ObjectPlacementPathTileConnectionGrid(_tileXZSize, gridOrigin, path);
foreach (ObjectPlacementBoxStackSegment segment in allPathSegments)
{
for (int stackIndex = 0; stackIndex < segment.NumberOfStacks; ++stackIndex)
{
ObjectPlacementBoxStack stack = segment.GetStackByIndex(stackIndex);
if (stack.IsOverlappedByAnotherStack)
{
continue;
}
var tileConnectionGridCell = new ObjectPlacementPathTileConnectionGridCell(tileConnectionGrid.CalculateCellIndicesFromPosition(stack.BasePosition), tileConnectionGrid);
tileConnectionGridCell.TileConnectionSegment = segment;
tileConnectionGridCell.TileConnectionStack = stack;
tileConnectionGridCell.TileConnectionPath = path;
if (!tileConnectionGrid.IsCellOccupied(tileConnectionGridCell.CellIndices))
{
tileConnectionGrid.AddCell(tileConnectionGridCell);
}
}
}
tileConnectionGrid.EstablishCellNeighbours();
tileConnectionGrid.DetectTileConnectionTypesForAllOccupiedCells();
return(tileConnectionGrid.OccupiedTileConnectionCells);
}
public void SetData(ObjectPlacementPathManualConstructionSessionData sessionData)
{
if (!_isActive)
{
_path = sessionData.Path;
_pathSegments = sessionData.PathSegments;
_pathExtensionPlane = sessionData.PathExtensionPlane;
_tileConnectionGridCells = sessionData.TileConnectionGridCells;
_startObject = sessionData.StartObject;
_startObjectHierarchyWorldOrientedBox = _startObject.GetHierarchyWorldOrientedBox();
_pathSettings = _path.Settings;
_tileConnectionSettings = _pathSettings.TileConnectionSettings;
_manualConstructionSettings = _pathSettings.ManualConstructionSettings;
_heightAdjustmentSettings = _manualConstructionSettings.HeightAdjustmentSettings;
_paddingSettings = _manualConstructionSettings.PaddingSettings;
_borderSettings = _manualConstructionSettings.BorderSettings;
_pathNoTileConnectionsObjectPlacementDataCalculator.Path = _path;
_pathWithTileConnectionsObjectPlacementDataCalculator.Path = _path;
}
}
public Quaternion Calculate(ObjectPlacementPathTileConnectionGridCell tileConnectionGridCell)
{
ObjectPlacementPath path = tileConnectionGridCell.TileConnectionPath;
ObjectPlacementPathTileConnectionSettings tileConnectionSettings = path.Settings.TileConnectionSettings;
Plane extensionPlane = path.ExtensionPlane;
ObjectPlacementBoxStackSegment tileConnectionSegment = tileConnectionGridCell.TileConnectionSegment;
ObjectPlacementBoxStack tileConnectionStack = tileConnectionGridCell.TileConnectionStack;
bool usingSprites = tileConnectionSettings.UsesSprites();
float yAxisRotationInDegrees = ObjectPlacementPathTileConnectionYAxisRotations.GetAngleInDegrees(tileConnectionSettings.GetSettingsForTileConnectionType(tileConnectionGridCell.TileConnectionType).YAxisRotation);
Quaternion yAxisRotation = Quaternion.AngleAxis(yAxisRotationInDegrees, extensionPlane.normal);
Quaternion defaultRotation = Quaternion.LookRotation(path.ExtensionPlaneLookAxis, extensionPlane.normal);
if (usingSprites)
{
defaultRotation = Quaternion.LookRotation(extensionPlane.normal, path.ExtensionPlaneLookAxis);
}
ObjectPlacementPathTileConnectionType tileConnectionType = tileConnectionGridCell.TileConnectionType;
if (tileConnectionType == ObjectPlacementPathTileConnectionType.Autofill)
{
return(yAxisRotation * defaultRotation);
}
else
if (tileConnectionType == ObjectPlacementPathTileConnectionType.Begin)
{
if (tileConnectionGridCell.NumberOfNeighbours == 0)
{
return(yAxisRotation * defaultRotation);
}
else
{
ObjectPlacementBoxStack neighbour = tileConnectionGridCell.GetFirstNeighbour().TileConnectionStack;
Vector3 toNeighbour = tileConnectionStack.GetNormalizedBasePositionConnectionVectorTo(neighbour);
if (usingSprites)
{
return(yAxisRotation * Quaternion.LookRotation(extensionPlane.normal, toNeighbour));
}
return(yAxisRotation * Quaternion.LookRotation(toNeighbour, extensionPlane.normal));
}
}
else if (tileConnectionType == ObjectPlacementPathTileConnectionType.End)
{
ObjectPlacementBoxStack neighbour = tileConnectionGridCell.GetFirstNeighbour().TileConnectionStack;
Vector3 toEndTile = neighbour.GetNormalizedBasePositionConnectionVectorTo(tileConnectionStack);
if (usingSprites)
{
return(yAxisRotation * Quaternion.LookRotation(extensionPlane.normal, toEndTile));
}
return(yAxisRotation * Quaternion.LookRotation(toEndTile, extensionPlane.normal));
}
else
if (tileConnectionType == ObjectPlacementPathTileConnectionType.Cross)
{
return(yAxisRotation * defaultRotation);
}
else
if (tileConnectionType == ObjectPlacementPathTileConnectionType.TJunction)
{
ObjectPlacementBoxStack baseOfTJunction = null;
if (tileConnectionGridCell.RightNeighbour != null && tileConnectionGridCell.LeftNeighbour != null)
{
baseOfTJunction = tileConnectionGridCell.ForwardNeighbour != null ? tileConnectionGridCell.ForwardNeighbour.TileConnectionStack : tileConnectionGridCell.BackNeighbour.TileConnectionStack;
}
else
{
baseOfTJunction = tileConnectionGridCell.RightNeighbour != null ? tileConnectionGridCell.RightNeighbour.TileConnectionStack : tileConnectionGridCell.LeftNeighbour.TileConnectionStack;
}
Vector3 toTJunction = baseOfTJunction.GetNormalizedBasePositionConnectionVectorTo(tileConnectionStack);
if (usingSprites)
{
return(yAxisRotation * Quaternion.LookRotation(extensionPlane.normal, toTJunction));
}
return(yAxisRotation * Quaternion.LookRotation(toTJunction, extensionPlane.normal));
}
else
if (tileConnectionType == ObjectPlacementPathTileConnectionType.Forward)
{
if (tileConnectionSegment.NumberOfStacks == 1)
{
if (tileConnectionGridCell.HasForwardAndBackNeightbours())
{
ObjectPlacementBoxStack forwardNeighbour = tileConnectionGridCell.ForwardNeighbour.TileConnectionStack;
ObjectPlacementBoxStack backNeighbour = tileConnectionGridCell.BackNeighbour.TileConnectionStack;
Vector3 toForwardNeighbour = backNeighbour.GetNormalizedBasePositionConnectionVectorTo(forwardNeighbour);
if (usingSprites)
{
return(yAxisRotation * Quaternion.LookRotation(extensionPlane.normal, toForwardNeighbour));
}
return(yAxisRotation * Quaternion.LookRotation(toForwardNeighbour, extensionPlane.normal));
}
else
{
ObjectPlacementBoxStack leftNeighbour = tileConnectionGridCell.LeftNeighbour.TileConnectionStack;
ObjectPlacementBoxStack rightNeighbour = tileConnectionGridCell.RightNeighbour.TileConnectionStack;
Vector3 toRightNeighbour = leftNeighbour.GetNormalizedBasePositionConnectionVectorTo(rightNeighbour);
if (usingSprites)
{
return(yAxisRotation * Quaternion.LookRotation(extensionPlane.normal, toRightNeighbour));
}
return(yAxisRotation * Quaternion.LookRotation(toRightNeighbour, extensionPlane.normal));
}
}
else
{
if (usingSprites)
{
return(yAxisRotation * Quaternion.LookRotation(extensionPlane.normal, tileConnectionSegment.ExtensionDirection));
}
return(yAxisRotation * Quaternion.LookRotation(tileConnectionSegment.ExtensionDirection, extensionPlane.normal));
}
}
else
{
ObjectPlacementBoxStack firstNeighbour, secondNeighbour;
if (tileConnectionGridCell.RightNeighbour != null)
{
firstNeighbour = tileConnectionGridCell.RightNeighbour.TileConnectionStack;
secondNeighbour = tileConnectionGridCell.ForwardNeighbour != null ? tileConnectionGridCell.ForwardNeighbour.TileConnectionStack : tileConnectionGridCell.BackNeighbour.TileConnectionStack;
}
else
if (tileConnectionGridCell.LeftNeighbour != null)
{
firstNeighbour = tileConnectionGridCell.LeftNeighbour.TileConnectionStack;
secondNeighbour = tileConnectionGridCell.ForwardNeighbour != null ? tileConnectionGridCell.ForwardNeighbour.TileConnectionStack : tileConnectionGridCell.BackNeighbour.TileConnectionStack;
}
else
if (tileConnectionGridCell.ForwardNeighbour != null)
{
firstNeighbour = tileConnectionGridCell.ForwardNeighbour.TileConnectionStack;
secondNeighbour = tileConnectionGridCell.RightNeighbour != null ? tileConnectionGridCell.RightNeighbour.TileConnectionStack : tileConnectionGridCell.LeftNeighbour.TileConnectionStack;
}
else
{
firstNeighbour = tileConnectionGridCell.BackNeighbour.TileConnectionStack;
secondNeighbour = tileConnectionGridCell.RightNeighbour != null ? tileConnectionGridCell.RightNeighbour.TileConnectionStack : tileConnectionGridCell.LeftNeighbour.TileConnectionStack;
}
Vector3 tileLook, tileRight;
tileLook = firstNeighbour.GetNormalizedBasePositionConnectionVectorTo(tileConnectionStack);
tileRight = tileConnectionStack.GetNormalizedBasePositionConnectionVectorTo(secondNeighbour);
Vector3 tileUp = Vector3.Cross(tileLook, tileRight);
if (Vector3.Dot(tileUp, extensionPlane.normal) < 0.0f)
{
tileLook = -tileRight;
}
if (usingSprites)
{
return(yAxisRotation * Quaternion.LookRotation(extensionPlane.normal, tileLook));
}
return(yAxisRotation * Quaternion.LookRotation(tileLook, extensionPlane.normal));
}
}
public Vector3 Calculate(ObjectPlacementPathTileConnectionTypeSettings tileConnectionTypeSettings, ObjectPlacementPath path)
{
return(path.ExtensionPlane.normal * (tileConnectionTypeSettings.YOffset + path.Settings.ManualConstructionSettings.OffsetAlongGrowDirection));
}
public ObjectPlacementPathTileConnectionGrid(float cellXZSize, Vector3 gridOrigin, ObjectPlacementPath path)
{
_cellXZSize = cellXZSize;
_origin = gridOrigin;
_path = path;
}
public Vector3 CalculateWorldScale(float tileConnectionXZSize, Vector3 tileConnectionPrefabBoxSize, Transform tileConnectionPrefabTransform, ObjectPlacementPath path)
{
if (path.Settings.TileConnectionSettings.UsesSprites())
{
float xScale = tileConnectionXZSize / tileConnectionPrefabBoxSize.x;
float yScale = tileConnectionXZSize / tileConnectionPrefabBoxSize.y;
return(new Vector3(tileConnectionPrefabTransform.lossyScale.x * xScale, tileConnectionPrefabTransform.lossyScale.y * yScale, 1.0f));
}
else
{
float xScale = tileConnectionXZSize / tileConnectionPrefabBoxSize.x;
float zScale = tileConnectionXZSize / tileConnectionPrefabBoxSize.z;
return(new Vector3(tileConnectionPrefabTransform.lossyScale.x * xScale, tileConnectionPrefabTransform.lossyScale.y, tileConnectionPrefabTransform.lossyScale.z * zScale));
}
}
