public static bool IsPartOfDefaultModel(UnityEngine.Object[] targetObjects)
{
if (targetObjects == null)
{
return(false);
}
for (int i = 0; i < targetObjects.Length; i++)
{
ChiselNode node = targetObjects[i] as ChiselNode;
if (Equals(node, null))
{
var gameObject = targetObjects[i] as GameObject;
if (gameObject)
{
node = gameObject.GetComponent <ChiselNode>();
}
}
if (node)
{
if (ChiselGeneratedComponentManager.IsDefaultModel(node.hierarchyItem.Model))
{
return(true);
}
}
}
return(false);
}
public PlaneIntersection(CSGTreeBrushIntersection brushIntersection, ChiselNode node, ChiselModel model)
{
this.point = brushIntersection.surfaceIntersection.worldIntersection;
this.plane = brushIntersection.surfaceIntersection.worldPlane;
this.node = node;
this.model = model;
}
static void RenderHierarchyItem(int instanceID, ChiselNode node, Rect selectionRect)
{
var model = node as ChiselModel;
if (!ReferenceEquals(model, null))
{
if (model == ChiselModelManager.ActiveModel)
{
const float kIconSize = 16;
const float kOffsetToText = 0.0f;
//const float kOffsetToText = 24.0f; // this used to be a random '24' in another version of unity?
var rect = selectionRect;
rect.xMin += kIconSize + kOffsetToText;
var content = EditorGUIUtility.TrTempContent(node.name + " (active)");
// TODO: figure out correct color depending on selection and proSkin
GUI.Label(rect, content);
rect.xMin += 0.5f;
GUI.Label(rect, content);
}
}
var icon = ChiselNodeDetailsManager.GetHierarchyIcon(node);
if (icon != null)
{
RenderIcon(selectionRect, icon);
}
}
static void RenderHierarchyItem(int instanceID, ChiselNode node, Rect selectionRect)
{
if (!ChiselSceneGUIStyle.isInitialized)
{
return;
}
var model = node as ChiselModel;
if (!ReferenceEquals(model, null))
{
if (model == ChiselModelManager.ActiveModel)
{
var content = EditorGUIUtility.TrTempContent(node.name + " (active)");
bool selected = GUIView.HasFocus && Selection.Contains(instanceID);
GUI.Label(selectionRect, content, selected ? ChiselSceneGUIStyle.inspectorSelectedLabel : ChiselSceneGUIStyle.inspectorLabel);
}
}
var icon = ChiselNodeDetailsManager.GetHierarchyIcon(node);
if (icon != null)
{
RenderIcon(selectionRect, icon);
}
}
public static GUIContent GetHierarchyIcon(ChiselNode node)
{
if (nodeDetailsLookup.TryGetValue(node.GetType(), out IChiselNodeDetails nodeDetails))
{
return(nodeDetails.GetHierarchyIconForGenericNode(node));
}
return(generatorDefaultDetails.GetHierarchyIconForGenericNode(node));
}
public static IChiselNodeDetails GetNodeDetails(ChiselNode node)
{
if (nodeDetailsLookup.TryGetValue(node.GetType(), out IChiselNodeDetails nodeDetails))
{
return(nodeDetails);
}
return(generatorDefaultDetails);
}
public static bool HasValidState(ChiselNode node)
{
if (nodeDetailsLookup.TryGetValue(node.GetType(), out IChiselNodeDetails nodeDetails))
{
return(nodeDetails.HasValidState(node));
}
return(generatorDefaultDetails.HasValidState(node));
}
static Vector3 FindSelectionCenter(ChiselNode selectedNode)
{
var bounds = selectedNode.CalculateBounds();
var min = bounds.min;
var max = bounds.max;
var center = (min + max) * 0.5f;
return(center);
}
public static Vector3 FindSelectionWorldSpaceCenter(ChiselNode selectedNode)
{
var hierarchyItem = selectedNode.hierarchyItem;
var bounds = hierarchyItem.Bounds; // Note: bounds in tree space, not world space
var modelTransform = hierarchyItem.Model.hierarchyItem.LocalToWorldMatrix;
var center = modelTransform.MultiplyPoint((bounds.min + bounds.max) * 0.5f);
return(center);
}
internal static void OnHierarchyWindowItemGUI(int instanceID, ChiselNode node, Rect selectionRect)
{
// TODO: implement material drag & drop support on hierarchy items
if (Event.current.type == EventType.Repaint)
{
RenderHierarchyItem(instanceID, node, selectionRect);
}
}
static bool GetAllSurfaces(ChiselNode chiselNode, CSGTreeNode node, CSGTreeBrush?findBrush, List <SurfaceReference> surfaces)
{
switch (node.Type)
{
case CSGNodeType.Brush: return(GetAllSurfaces(chiselNode, (CSGTreeBrush)node, findBrush, surfaces));
case CSGNodeType.Branch: return(GetAllSurfaces(chiselNode, (CSGTreeBranch)node, findBrush, surfaces));
}
return(false);
}
public static GUIContent GetHierarchyIcon(ChiselNode node, out bool hasValidState)
{
if (nodeDetailsLookup.TryGetValue(node.GetType(), out IChiselNodeDetails nodeDetails))
{
hasValidState = nodeDetails.HasValidState(node);
return(nodeDetails.GetHierarchyIconForGenericNode(node));
}
hasValidState = generatorDefaultDetails.HasValidState(node);
return(generatorDefaultDetails.GetHierarchyIconForGenericNode(node));
}
public static GUIContent GetHierarchyIcon(ChiselNode node)
{
IChiselNodeDetails someInterface;
if (nodeDetailsLookup.TryGetValue(node.GetType(), out someInterface))
{
return(someInterface.GetHierarchyIconForGenericNode(node));
}
return(null);
}
public static IChiselNodeDetails GetNodeDetails(ChiselNode node)
{
IChiselNodeDetails someInterface;
if (nodeDetailsLookup.TryGetValue(node.GetType(), out someInterface))
{
return(someInterface);
}
return(null);
}
public GUIContent GetHierarchyIconForGenericNode(ChiselNode node)
{
var generator = node as ChiselGeneratorComponent;
if (generator == null)
{
return(GUIContent.none);
}
return(GetHierarchyIcon(generator.Operation, node.NodeTypeName));
}
public static void DeselectAll(ChiselNode node, int index)
{
if (!Selection.nodeSelectionLookup.TryGetValue(node, out ChiselNodeSelection nodeSelection))
{
return;
}
Undo.RecordObject(Selection, "Deselect node");
Debug.Assert(nodeSelection.node == node);
nodeSelection.Deselect(index);
}
public bool HasValidState(ChiselNode node)
{
var generator = node as ChiselGeneratorComponent;
if (generator == null)
{
return(false);
}
return(node.HasValidState());
}
static bool FindSurfaceReference(ChiselNode chiselNode, CSGTreeBranch branch, CSGTreeBrush findBrush, int surfaceID, out SurfaceReference surfaceReference)
{
surfaceReference = null;
for (int i = 0; i < branch.Count; i++)
{
if (FindSurfaceReference(chiselNode, branch[i], findBrush, surfaceID, out surfaceReference))
{
return(true);
}
}
return(false);
}
static bool FindSurfaceReference(ChiselNode chiselNode, CSGTreeNode node, CSGTreeBrush findBrush, int surfaceID, out SurfaceReference surfaceReference)
{
surfaceReference = null;
switch (node.Type)
{
case CSGNodeType.Branch: return(FindSurfaceReference(chiselNode, (CSGTreeBranch)node, findBrush, surfaceID, out surfaceReference));
case CSGNodeType.Brush: return(FindSurfaceReference(chiselNode, (CSGTreeBrush)node, findBrush, surfaceID, out surfaceReference));
default: return(false);
}
}
static void RenderHierarchyItem(int instanceID, ChiselNode node, Rect selectionRect)
{
if (!ChiselSceneGUIStyle.isInitialized)
{
return;
}
var model = node as ChiselModel;
if (!ReferenceEquals(model, null))
{
if (model == ChiselModelManager.ActiveModel)
{
var content = EditorGUIUtility.TrTempContent(node.name + " (active)");
bool selected = GUIView.HasFocus && Selection.Contains(instanceID);
GUI.Label(selectionRect, content, selected ? ChiselSceneGUIStyle.inspectorSelectedLabel : ChiselSceneGUIStyle.inspectorLabel);
}
}
var active = node.isActiveAndEnabled;
if (active)
{
var icon = ChiselNodeDetailsManager.GetHierarchyIcon(node, out bool hasValidState);
if (icon != null)
{
RenderIcon(selectionRect, icon);
}
if (!hasValidState)
{
var warningIcon = sWarningContent;
if (warningIcon != null)
{
RenderIcon(selectionRect, warningIcon);
}
}
}
else
{
var icon = ChiselNodeDetailsManager.GetHierarchyIcon(node);
if (icon != null)
{
var prevColor = GUI.color;
var newColor = prevColor;
newColor.a *= 0.25f;
GUI.color = newColor;
RenderIcon(selectionRect, icon);
GUI.color = prevColor;
}
}
}
static bool FindSurfaceReference(ChiselNode chiselNode, CSGTreeBrush brush, CSGTreeBrush findBrush, int surfaceID, out SurfaceReference surfaceReference)
{
surfaceReference = null;
if (findBrush != brush)
{
return(false);
}
var brushMeshBlob = BrushMeshManager.GetBrushMeshBlob(findBrush.BrushMesh.BrushMeshID);
if (!brushMeshBlob.IsCreated)
{
return(true);
}
ref var brushMesh = ref brushMeshBlob.Value;
static bool GetAllSurfaces(ChiselNode chiselNode, CSGTreeBranch branch, CSGTreeBrush?findBrush, List <SurfaceReference> surfaces)
{
if (!branch.Valid)
{
return(false);
}
for (int i = 0; i < branch.Count; i++)
{
var child = branch[i];
if (GetAllSurfaces(chiselNode, child, findBrush, surfaces))
{
return(true);
}
}
return(false);
}
public ChiselNodeSelection this[ChiselNode node]
{
get
{
if (!nodeSelectionLookup.TryGetValue(node, out ChiselNodeSelection nodeSelection))
{
Undo.RecordObject(Selection, "Select node");
nodeSelection = new ChiselNodeSelection {
node = node
};
nodeSelectionLookup[node] = nodeSelection;
return(nodeSelection);
}
Debug.Assert(nodeSelection.node == node);
return(nodeSelection);
}
}
static bool GetAllSurfaces(ChiselNode chiselNode, CSGTreeBrush brush, CSGTreeBrush?findBrush, List <SurfaceReference> surfaces)
{
if (!brush.Valid)
{
return(false);
}
if (findBrush.HasValue && findBrush.Value != brush)
{
return(true);
}
var brushMeshBlob = BrushMeshManager.GetBrushMeshBlob(brush.BrushMesh.BrushMeshID);
if (!brushMeshBlob.IsCreated)
{
return(true);
}
ref var brushMesh = ref brushMeshBlob.Value;
public static GUIContent GetHierarchyIcon(ChiselNode node, out bool hasValidState)
{
hierarchyMessageHandler.Clear();
node.GetWarningMessages(hierarchyMessageHandler);
string nodeMessage;
if (hierarchyMessageHandler.Length != 0)
{
hasValidState = false;
nodeMessage = hierarchyMessageHandler.ToString();
}
else
{
hasValidState = true;
nodeMessage = string.Empty;
}
var hierarchyIcon = GetHierarchyIcon(node);
hierarchyIcon.tooltip = nodeMessage;
return(hierarchyIcon);
}
public GUIContent GetHierarchyIconForGenericNode(ChiselNode node)
{
var generator = node as ChiselGeneratorComponent;
if (generator == null)
{
return(GUIContent.none);
}
// TODO: when something is wrong with the node, we should show an indicator here
switch (generator.Operation)
{
default:
case CSGOperationType.Additive: return(ChiselEditorResources.GetIconContent(kAdditiveIconName, $"Additive {node.NodeTypeName}")[0]);
case CSGOperationType.Subtractive: return(ChiselEditorResources.GetIconContent(kSubtractiveIconName, $"Subtractive {node.NodeTypeName}")[0]);
case CSGOperationType.Intersecting: return(ChiselEditorResources.GetIconContent(kIntersectingIconName, $"Intersecting {node.NodeTypeName}")[0]);
}
}
internal static GameObject PickNodeOrGameObject(Camera camera, Vector2 pickposition, int layers, ref GameObject[] ignore, ref GameObject[] filter, out ChiselModel model, out ChiselNode node, out CSGTreeBrushIntersection intersection)
{
TryNextSelection:
intersection = new CSGTreeBrushIntersection {
surfaceID = -1, brushUserID = -1
};
model = null;
node = null;
Material sharedMaterial;
var gameObject = PickModel(camera, pickposition, layers, ref ignore, ref filter, out model, out sharedMaterial);
if (object.Equals(gameObject, null))
{
return(null);
}
if (model)
{
int filterLayerParameter0 = (sharedMaterial) ? sharedMaterial.GetInstanceID() : 0;
{
var worldRay = camera.ScreenPointToRay(pickposition);
var worldRayStart = worldRay.origin;
var worldRayVector = (worldRay.direction * (camera.farClipPlane - camera.nearClipPlane));
var worldRayEnd = worldRayStart + worldRayVector;
CSGTreeBrushIntersection tempIntersection;
if (ChiselSceneQuery.FindFirstWorldIntersection(model, worldRayStart, worldRayEnd, filterLayerParameter0, layers, ignore, filter, out tempIntersection))
{
var clickedBrush = tempIntersection.brush;
node = CSGNodeHierarchyManager.FindCSGNodeByInstanceID(clickedBrush.UserID);
if (node)
{
if (ignore != null &&
ignore.Contains(node.gameObject))
{
node = null;
return(null);
}
intersection = tempIntersection;
return(node.gameObject);
}
else
{
node = null;
}
}
}
if (ignore == null)
{
return(null);
}
ArrayUtility.Add(ref ignore, gameObject);
goto TryNextSelection;
}
if (object.Equals(gameObject, null))
{
return(null);
}
if (ignore != null &&
ignore.Contains(gameObject))
{
return(null);
}
return(gameObject);
}
public SelectedNode(ChiselNode node, Transform transform)
{
this.node = node; this.transform = transform;
}
bool IChiselNodeDetails.HasValidState(ChiselNode node)
{
return(HasValidState((T)node));
}
GUIContent IChiselNodeDetails.GetHierarchyIconForGenericNode(ChiselNode node)
{
return(GetHierarchyIcon((T)node));
}
