public bool DragUpdated()
{
try
{
DisableVisualObjects();
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
var intersection = SceneQueryUtility.FindMeshIntersection(Event.current.mousePosition);
var normal = intersection.plane.normal;
hoverPosition = intersection.worldIntersection;
hoverParent = SelectionUtility.FindParentToAssignTo(intersection);
hoverBrushSurface = intersection.brush != null ? new SelectedBrushSurface(intersection.brush, intersection.surfaceIndex) : null;
hoverRotation = SelectionUtility.FindDragOrientation(normal, sourceSurfaceAlignment, destinationSurfaceAlignment);
haveNoParent = (hoverParent == null);
hoverSiblingIndex = int.MaxValue;
RealtimeCSG.CSGGrid.SetForcedGrid(intersection.plane);
var toggleSnapping = (Event.current.modifiers & EventModifiers.Control) == EventModifiers.Control;
var doSnapping = RealtimeCSG.CSGSettings.SnapToGrid ^ toggleSnapping;
if (doSnapping)
{
var localPoints = new Vector3[8];
var localPlane = intersection.plane;
for (var i = 0; i < localPoints.Length; i++)
{
localPoints[i] = GeometryUtility.ProjectPointOnPlane(localPlane, (hoverRotation * projectedBounds[i]) + hoverPosition);
}
hoverPosition += RealtimeCSG.CSGGrid.SnapDeltaToGrid(MathConstants.zeroVector3, localPoints);
}
hoverPosition = GeometryUtility.ProjectPointOnPlane(intersection.plane, hoverPosition) + (normal * 0.01f);
EnableVisualObjects();
return(true);
}
finally
{
if (!UpdateLoop.IsActive())
{
UpdateLoop.ResetUpdateRoutine();
}
}
}
public bool DragUpdated()
{
InternalCSGModelManager.skipCheckForChanges = true;
try
{
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
var intersection = SceneQueryUtility.FindMeshIntersection(Event.current.mousePosition, ignoreBrushes, ignoreTransforms);
var normal = intersection.worldPlane.normal;
hoverPosition = intersection.worldIntersection;
hoverParent = SelectionUtility.FindParentToAssignTo(intersection);
hoverBrushSurface = intersection.brush ? new SelectedBrushSurface(intersection.brush, intersection.surfaceIndex) : null;
hoverRotation = SelectionUtility.FindDragOrientation(normal, sourceSurfaceAlignment, destinationSurfaceAlignment);
haveNoParent = !hoverParent;
hoverSiblingIndex = int.MaxValue;
RealtimeCSG.CSGGrid.SetForcedGrid(intersection.worldPlane);
// Since we're snapping points to grid and do not have a relative distance, relative snapping makes no sense
var doGridSnapping = RealtimeCSG.CSGSettings.ActiveSnappingMode != SnapMode.None;
if (doGridSnapping)
{
var localPoints = new Vector3[8];
var localPlane = intersection.worldPlane;
for (var i = 0; i < localPoints.Length; i++)
{
localPoints[i] = GeometryUtility.ProjectPointOnPlane(localPlane, (hoverRotation * projectedBounds[i]) + hoverPosition);
}
hoverPosition += RealtimeCSG.CSGGrid.SnapDeltaToGrid(MathConstants.zeroVector3, localPoints);
}
hoverPosition = GeometryUtility.ProjectPointOnPlane(intersection.worldPlane, hoverPosition); // + (normal * 0.01f);
EnableVisualObjects();
return(true);
}
finally
{
if (!UpdateLoop.IsActive())
{
UpdateLoop.ResetUpdateRoutine();
}
}
}
public bool ValidateDropPoint(SceneView sceneView)
{
var camera = sceneView.camera;
GameObject foundObject;
if (!SceneQueryUtility.FindClickWorldIntersection(camera, Event.current.mousePosition, out foundObject))
{
return(false);
}
if (!foundObject.GetComponent <CSGBrush>())
{
return(false);
}
return(true);
}
void RunOnce()
{
if (EditorApplication.isPlaying)
{
// when you start playing the game in the editor, it'll call
// RunOnce before playing the game, but not after.
// so we need to wait until the game has stopped, after which we'll
// run first update again.
EditorApplication.update -= OnWaitUntillStoppedPlaying;
EditorApplication.update += OnWaitUntillStoppedPlaying;
return;
}
SceneView.onSceneGUIDelegate -= OnScene;
SceneView.onSceneGUIDelegate += OnScene;
Undo.undoRedoPerformed -= UndoRedoPerformed;
Undo.undoRedoPerformed += UndoRedoPerformed;
InternalCSGModelManager.UpdateHierarchy();
var scene = SceneManager.GetActiveScene();
var allGeneratedMeshes = SceneQueryUtility.GetAllComponentsInScene <GeneratedMeshes>(scene);
for (int i = 0; i < allGeneratedMeshes.Count; i++)
{
if (allGeneratedMeshes[i].owner != true)
{
UnityEngine.Object.DestroyImmediate(allGeneratedMeshes[i].gameObject);
}
}
// we use a co-routine for updates because EditorApplication.update
// works at a ridiculous rate and the co-routine is only fired in the
// editor when something has happened.
ResetUpdateRoutine();
}
public bool ValidateDropPoint(SceneView sceneView)
{
if (!sceneView)
{
return(false);
}
hoverOverObject = null;
var camera = sceneView.camera;
GameObject foundObject;
if (!SceneQueryUtility.FindClickWorldIntersection(camera, Event.current.mousePosition, out foundObject, out hoverOverMeshRenderer, out hoverMaterialIndex, ignoreDeepClick: true))
{
return(false);
}
if (foundObject.GetComponent <CSGBrush>())
{
return(true);
}
hoverOverObject = foundObject;
return(true);
}
public static void DoSelectionClick()
{
GameObject gameobject;
SceneQueryUtility.FindClickWorldIntersection(Event.current.mousePosition, out gameobject);
gameobject = SceneQueryUtility.GetGroupGameObjectIfObjectIsPartOfGroup(gameobject);
var selectedObjectsOnClick = new List <int>(Selection.instanceIDs);
bool addedSelection = false;
if (EditorGUI.actionKey)
{
if (gameobject != null)
{
var instanceID = gameobject.GetInstanceID();
if (selectedObjectsOnClick.Contains(instanceID))
{
selectedObjectsOnClick.Remove(instanceID);
}
else
{
selectedObjectsOnClick.Add(instanceID);
addedSelection = true;
}
if (selectedObjectsOnClick.Count == 0)
{
Selection.activeTransform = null;
}
else
{
Selection.instanceIDs = selectedObjectsOnClick.ToArray();
}
}
}
else
if (Event.current.shift)
{
if (gameobject != null)
{
var instanceID = gameobject.GetInstanceID();
selectedObjectsOnClick.Add(instanceID);
Selection.instanceIDs = selectedObjectsOnClick.ToArray();
addedSelection = true;
}
}
else
if (Event.current.alt)
{
if (gameobject != null)
{
var instanceID = gameobject.GetInstanceID();
selectedObjectsOnClick.Remove(instanceID);
Selection.instanceIDs = selectedObjectsOnClick.ToArray();
return;
}
}
else
{
Selection.activeGameObject = gameobject;
addedSelection = true;
}
if (!addedSelection)
{
foreach (var item in Selection.GetFiltered(typeof(CSGBrush), SelectionMode.Deep))
{
var brush = item as CSGBrush;
var brush_cache = InternalCSGModelManager.GetBrushCache(brush);
if (brush_cache == null ||
brush_cache.childData == null ||
!brush_cache.childData.Model ||
!brush_cache.childData.Model.isActiveAndEnabled)
{
continue;
}
SelectionUtility.LastUsedModel = brush_cache.childData.Model;
break;
}
}
else
if (gameobject != null)
{
var brush = gameobject.GetComponent <CSGBrush>();
if (brush != null)
{
var brush_cache = InternalCSGModelManager.GetBrushCache(brush);
if (brush_cache == null ||
brush_cache.childData == null ||
!brush_cache.childData.Model ||
!brush_cache.childData.Model.isActiveAndEnabled)
{
return;
}
SelectionUtility.LastUsedModel = brush_cache.childData.Model;
}
}
}
protected override void HandleCreateShapeEvents(SceneView sceneView, Rect sceneRect)
{
bool pointOnEdge = false;
bool havePlane = false;
bool vertexOnGeometry = false;
CSGBrush vertexOnBrush = null;
CSGPlane hoverBuildPlane = buildPlane;
var camera = sceneView.camera;
var assume2DView = CSGSettings.Assume2DView(camera);
if (camera != null &&
camera.pixelRect.Contains(Event.current.mousePosition))
{
if (!hoverDefaultPlane.HasValue ||
settings.vertices.Length == 0)
{
bool forceGrid = RealtimeCSG.CSGGrid.ForceGrid;
RealtimeCSG.CSGGrid.ForceGrid = false;
hoverDefaultPlane = RealtimeCSG.CSGGrid.CurrentGridPlane;
RealtimeCSG.CSGGrid.ForceGrid = forceGrid;
firstSnappedEdges = null;
firstSnappedBrush = null;
firstSnappedPlanes = null;
base.geometryModel = null;
}
if (editMode == EditMode.CreatePlane)
{
LegacyBrushIntersection intersection;
if (!assume2DView && !havePlane &&
EditorWindow.mouseOverWindow == sceneView &&
SceneQueryUtility.FindWorldIntersection(camera, Event.current.mousePosition, out intersection))
{
worldPosition = intersection.worldIntersection;
hoverBuildPlane = intersection.worldPlane;
vertexOnBrush = intersection.brush;
vertexOnGeometry = true;
} else
{
hoverBuildPlane = hoverDefaultPlane.Value;
vertexOnBrush = null;
var mouseRay = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition);
worldPosition = hoverBuildPlane.RayIntersection(mouseRay);
vertexOnGeometry = false;
}
ResetVisuals();
if (snapFunction != null)
{
CSGBrush snappedOnBrush;
worldPosition = snapFunction(camera, worldPosition, hoverBuildPlane, ref visualSnappedEdges, out snappedOnBrush, generatedBrushes, ignoreAllBrushes: true);
if (snappedOnBrush != null)
{
pointOnEdge = (visualSnappedEdges != null &&
visualSnappedEdges.Count > 0);
vertexOnBrush = snappedOnBrush;
vertexOnGeometry = true;
}
}
if (settings.vertices.Length == 1)
{
if (hoverBuildPlane.normal != MathConstants.zeroVector3)
{
editMode = EditMode.CreateShape;
havePlane = true;
}
}
} else
{
var mouseRay = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition);
worldPosition = hoverBuildPlane.RayIntersection(mouseRay);
ResetVisuals();
if (snapFunction != null)
{
CSGBrush snappedOnBrush;
worldPosition = snapFunction(camera, worldPosition, hoverBuildPlane, ref visualSnappedEdges, out snappedOnBrush, generatedBrushes, ignoreAllBrushes: true);
if (snappedOnBrush != null)
{
pointOnEdge = (visualSnappedEdges != null &&
visualSnappedEdges.Count > 0);
vertexOnBrush = snappedOnBrush;
}
}
}
if (geometryModel == null && vertexOnBrush != null)
{
if (vertexOnBrush.ChildData != null && vertexOnBrush.ChildData.Model)
geometryModel = vertexOnBrush.ChildData.Model;
}
if (worldPosition != prevWorldPosition)
{
prevWorldPosition = worldPosition;
if (settings.vertices.Length > 0)
{
if (hadSphere || (settings.vertices[0] - worldPosition).sqrMagnitude > MathConstants.EqualityEpsilon)
{
hadSphere = true;
UpdateBaseShape(true);
}
}
if (Event.current.type != EventType.Repaint)
CSG_EditorGUIUtility.RepaintAll();
}
visualSnappedGrid = RealtimeCSG.CSGGrid.FindAllGridEdgesThatTouchPoint(camera, worldPosition);
visualSnappedBrush = vertexOnBrush;
}
RealtimeCSG.CSGGrid.SetForcedGrid(camera, hoverBuildPlane);
if (!SceneDragToolManager.IsDraggingObjectInScene &&
Event.current.type == EventType.Repaint)
{
PaintSnapVisualisation();
PaintCircle(sceneView, base.shapeId);
}
var type = Event.current.GetTypeForControl(base.shapeId);
switch (type)
{
case EventType.Layout:
{
return;
}
case EventType.ValidateCommand:
case EventType.KeyDown:
{
if (GUIUtility.hotControl == base.shapeId)
{
if (Keys.PerformActionKey.IsKeyPressed() ||
Keys.DeleteSelectionKey.IsKeyPressed() ||
Keys.CancelActionKey.IsKeyPressed())
{
Event.current.Use();
}
}
return;
}
case EventType.KeyUp:
{
if (GUIUtility.hotControl == base.shapeId)
{
if (Keys.CylinderBuilderMode.IsKeyPressed() ||
Keys.PerformActionKey.IsKeyPressed())
{
HotKeyReleased();
Event.current.Use();
return;
}
if (Keys.DeleteSelectionKey.IsKeyPressed() ||
Keys.CancelActionKey.IsKeyPressed())
{
Cancel();
Event.current.Use();
return;
}
}
return;
}
case EventType.MouseDown:
{
if (!sceneRect.Contains(Event.current.mousePosition))
break;
if (Tools.viewTool != ViewTool.None && Tools.viewTool != ViewTool.Pan)
return;
if ((GUIUtility.hotControl != 0 && GUIUtility.hotControl != shapeEditId && GUIUtility.hotControl != base.shapeId) ||
Event.current.button != 0)
return;
Event.current.Use();
if (settings.vertices.Length == 0)
{
if ((GUIUtility.hotControl == 0 ||
GUIUtility.hotControl == base.shapeEditId) && base.shapeId != -1)
{
base.CalculateWorldSpaceTangents(camera);
GUIUtility.hotControl = base.shapeId;
GUIUtility.keyboardControl = base.shapeId;
EditorGUIUtility.editingTextField = false;
}
}
if (GUIUtility.hotControl == base.shapeId && settings.vertices.Length < 2)
{
if (!float.IsNaN(worldPosition.x) && !float.IsInfinity(worldPosition.x) &&
!float.IsNaN(worldPosition.y) && !float.IsInfinity(worldPosition.y) &&
!float.IsNaN(worldPosition.z) && !float.IsInfinity(worldPosition.z))
{
if (hoverBuildPlane.normal.sqrMagnitude != 0)
buildPlane = hoverBuildPlane;
CalculateWorldSpaceTangents(camera);
if (settings.vertices.Length == 0)
{
if (pointOnEdge)
{
firstSnappedEdges = visualSnappedEdges.ToArray();
firstSnappedBrush = visualSnappedBrush;
firstSnappedPlanes = null;
} else
{
firstSnappedBrush = null;
firstSnappedEdges = null;
firstSnappedPlanes = null;
}
planeOnGeometry = vertexOnGeometry;
} else
{
if (firstSnappedEdges != null)
{
if (firstSnappedPlanes == null)
CreateSnappedPlanes();
bool outside = true;
for (int i = 0; i < firstSnappedPlanes.Length; i++)
{
if (firstSnappedPlanes[i].Distance(worldPosition) <= MathConstants.DistanceEpsilon)
{
outside = false;
break;
}
}
planeOnGeometry = !outside;
}
if (vertexOnGeometry)
{
var plane = hoverDefaultPlane.Value;
var distance = plane.Distance(worldPosition);
plane.d += distance;
hoverDefaultPlane = plane;
for (int i = 0; i < settings.vertices.Length; i++)
{
if (!settings.onGeometryVertices[i])
{
settings.vertices[i] = GeometryUtility.ProjectPointOnPlane(plane, settings.vertices[i]);
settings.onGeometryVertices[i] = true;
}
}
}
}
ArrayUtility.Add(ref settings.onGeometryVertices, vertexOnGeometry);
settings.AddPoint(worldPosition);
CSG_EditorGUIUtility.RepaintAll();
if (settings.vertices.Length == 2)
{
HotKeyReleased();
}
}
}
return;
}
case EventType.MouseDrag:
{
if (Tools.viewTool != ViewTool.None && Tools.viewTool != ViewTool.Pan)
break;
if (GUIUtility.hotControl == base.shapeId && Event.current.button == 0)
{
Event.current.Use();
}
return;
}
case EventType.MouseUp:
{
if (GUIUtility.hotControl != base.shapeId)
return;
if (Tools.viewTool != ViewTool.None && Tools.viewTool != ViewTool.Pan)
return;
if (Event.current.button == 0)
{
Event.current.Use();
ResetVisuals();
if (settings.vertices.Length == 2)
{
GUIUtility.hotControl = 0;
GUIUtility.keyboardControl = 0;
EditorGUIUtility.editingTextField = false;
editMode = EditMode.CreateShape;
HotKeyReleased();
}
}
return;
}
}
}
public bool DragUpdated(SceneView sceneView)
{
var camera = sceneView.camera;
LegacyBrushIntersection intersection;
int highlight_surface = -1;
CSGBrush highlight_brush = null;
if (!SceneQueryUtility.FindWorldIntersection(camera, Event.current.mousePosition, out intersection))
{
highlight_brush = null;
highlight_surface = -1;
}
else
{
highlight_brush = intersection.brush;
highlight_surface = intersection.surfaceIndex;
}
bool modified = true;
if (hoverBrushSurfaces != null)
{
for (int i = 0; i < hoverBrushSurfaces.Length; i++)
{
if (hoverBrushSurfaces[i].brush == highlight_brush &&
hoverBrushSurfaces[i].surfaceIndex == highlight_surface)
{
modified = false;
break;
}
}
}
bool needUpdate = false;
if (modified)
{
hoverOnSelectedSurfaces = false;
if (hoverBrushSurfaces != null)
{
needUpdate = true;
RestoreMaterials(hoverBrushSurfaces);
}
hoverBrushSurfaces = HoverOnBrush(new CSGBrush[1] {
highlight_brush
}, highlight_surface);
if (hoverBrushSurfaces != null)
{
hoverBrushSurfaces = GetCombinedBrushes(hoverBrushSurfaces);
needUpdate = true;
using (new UndoGroup(hoverBrushSurfaces, "Modified materials"))
{
RememberMaterials(hoverBrushSurfaces);
ApplyMaterial(hoverBrushSurfaces);
}
}
}
else
{
bool prevSelectAllSurfaces = selectAllSurfaces;
selectAllSurfaces = Event.current.shift;
if (prevSelectAllSurfaces != selectAllSurfaces)
{
if (hoverBrushSurfaces != null)
{
needUpdate = true;
using (new UndoGroup(hoverBrushSurfaces, "Modified materials"))
{
ApplyMaterial(hoverBrushSurfaces);
}
}
}
}
if (needUpdate)
{
InternalCSGModelManager.UpdateMeshes();
MeshInstanceManager.UpdateHelperSurfaceVisibility();
}
return(needUpdate);
}
protected override void HandleCreateShapeEvents(Rect sceneRect)
{
if (settings.vertices.Length < 2)
{
if (editMode == EditMode.ExtrudeShape ||
editMode == EditMode.EditShape)
{
editMode = EditMode.CreatePlane;
}
}
bool pointOnEdge = false;
bool havePlane = false;
bool vertexOnGeometry = false;
CSGBrush vertexOnBrush = null;
CSGPlane hoverBuildPlane = buildPlane;
var sceneView = SceneView.currentDrawingSceneView; //(SceneView.currentDrawingSceneView != null) ? SceneView.currentDrawingSceneView : SceneView.lastActiveSceneView;
var camera = (sceneView == null) ? null : sceneView.camera;
if (camera != null &&
camera.pixelRect.Contains(Event.current.mousePosition))
{
if (!hoverDefaultPlane.HasValue ||
settings.vertices.Length == 0)
{
bool forceGrid = RealtimeCSG.CSGGrid.ForceGrid;
RealtimeCSG.CSGGrid.ForceGrid = false;
hoverDefaultPlane = RealtimeCSG.CSGGrid.CurrentGridPlane;
RealtimeCSG.CSGGrid.ForceGrid = forceGrid;
firstSnappedEdges = null;
firstSnappedBrush = null;
firstSnappedPlanes = null;
base.geometryModel = null;
}
if (editMode == EditMode.CreatePlane)
{
BrushIntersection intersection;
if (!IgnoreDepthForRayCasts(sceneView) && !havePlane &&
SceneQueryUtility.FindWorldIntersection(Event.current.mousePosition, out intersection))
{
worldPosition = intersection.worldIntersection;
if (intersection.surfaceInverted)
{
hoverBuildPlane = intersection.plane.Negated();
}
else
{
hoverBuildPlane = intersection.plane;
}
vertexOnBrush = intersection.brush;
vertexOnGeometry = true;
}
else
{
hoverBuildPlane = hoverDefaultPlane.Value;
vertexOnBrush = null;
var mouseRay = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition);
worldPosition = hoverBuildPlane.Intersection(mouseRay);
vertexOnGeometry = false;
}
ResetVisuals();
if (snapFunction != null)
{
CSGBrush snappedOnBrush;
worldPosition = snapFunction(worldPosition, hoverBuildPlane, ref visualSnappedEdges, out snappedOnBrush, generatedBrushes);
if (snappedOnBrush != null)
{
pointOnEdge = (visualSnappedEdges != null &&
visualSnappedEdges.Count > 0);
vertexOnBrush = snappedOnBrush;
vertexOnGeometry = true;
}
}
if (settings.vertices.Length == 1)
{
if (hoverBuildPlane.normal != MathConstants.zeroVector3)
{
editMode = EditMode.CreateShape;
havePlane = true;
}
}
else
if (settings.vertices.Length == 2)
{
onLastPoint = true;
}
}
else
{
var mouseRay = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition);
worldPosition = hoverBuildPlane.Intersection(mouseRay);
ResetVisuals();
if (snapFunction != null)
{
CSGBrush snappedOnBrush;
worldPosition = snapFunction(worldPosition, hoverBuildPlane, ref visualSnappedEdges, out snappedOnBrush, generatedBrushes);
if (snappedOnBrush != null)
{
pointOnEdge = (visualSnappedEdges != null &&
visualSnappedEdges.Count > 0);
vertexOnBrush = snappedOnBrush;
}
}
}
if (geometryModel == null && vertexOnBrush != null)
{
var brush_cache = InternalCSGModelManager.GetBrushCache(vertexOnBrush);
if (brush_cache != null && brush_cache.childData != null && brush_cache.childData.Model)
{
geometryModel = brush_cache.childData.Model;
}
}
if (worldPosition != prevWorldPosition)
{
prevWorldPosition = worldPosition;
if (Event.current.type != EventType.Repaint)
{
SceneView.RepaintAll();
}
}
visualSnappedGrid = RealtimeCSG.CSGGrid.FindAllGridEdgesThatTouchPoint(worldPosition);
visualSnappedBrush = vertexOnBrush;
}
RealtimeCSG.CSGGrid.SetForcedGrid(hoverBuildPlane);
if (!SceneDragToolManager.IsDraggingObjectInScene &&
Event.current.type == EventType.Repaint)
{
PaintSnapVisualisation();
PaintShape(base.shapeId);
}
var type = Event.current.GetTypeForControl(base.shapeId);
switch (type)
{
case EventType.Layout:
{
return;
}
case EventType.ValidateCommand:
case EventType.KeyDown:
{
if (GUIUtility.hotControl == base.shapeId)
{
if (Keys.PerformActionKey.IsKeyPressed() ||
Keys.DeleteSelectionKey.IsKeyPressed() ||
Keys.CancelActionKey.IsKeyPressed())
{
Event.current.Use();
}
}
return;
}
case EventType.KeyUp:
{
if (GUIUtility.hotControl == base.shapeId)
{
if (Keys.BoxBuilderMode.IsKeyPressed() ||
Keys.PerformActionKey.IsKeyPressed())
{
HotKeyReleased();
Event.current.Use();
return;
}
if (Keys.DeleteSelectionKey.IsKeyPressed() ||
Keys.CancelActionKey.IsKeyPressed())
{
Cancel();
Event.current.Use();
return;
}
}
return;
}
case EventType.MouseDown:
{
if (!sceneRect.Contains(Event.current.mousePosition))
{
break;
}
if (Tools.viewTool != ViewTool.None && Tools.viewTool != ViewTool.Pan)
{
return;
}
if ((GUIUtility.hotControl != 0 && GUIUtility.hotControl != shapeEditId && GUIUtility.hotControl != base.shapeId) ||
Event.current.button != 0)
{
return;
}
Event.current.Use();
if (settings.vertices.Length == 0)
{
if ((GUIUtility.hotControl == 0 ||
GUIUtility.hotControl == base.shapeEditId) && base.shapeId != -1)
{
base.CalculateWorldSpaceTangents();
GUIUtility.hotControl = base.shapeId;
GUIUtility.keyboardControl = base.shapeId;
EditorGUIUtility.editingTextField = false;
}
}
if (GUIUtility.hotControl == base.shapeId && settings.vertices.Length < 2)
{
if (!float.IsNaN(worldPosition.x) && !float.IsInfinity(worldPosition.x) &&
!float.IsNaN(worldPosition.y) && !float.IsInfinity(worldPosition.y) &&
!float.IsNaN(worldPosition.z) && !float.IsInfinity(worldPosition.z))
{
if (hoverBuildPlane.normal.sqrMagnitude != 0)
{
buildPlane = hoverBuildPlane;
}
CalculateWorldSpaceTangents();
if (settings.vertices.Length == 0)
{
if (pointOnEdge)
{
firstSnappedEdges = visualSnappedEdges.ToArray();
firstSnappedBrush = visualSnappedBrush;
firstSnappedPlanes = null;
}
else
{
firstSnappedBrush = null;
firstSnappedEdges = null;
firstSnappedPlanes = null;
}
geometryPlane = buildPlane;
planeOnGeometry = vertexOnGeometry;
}
else
{
if (firstSnappedEdges != null)
{
if (firstSnappedPlanes == null)
{
CreateSnappedPlanes();
}
bool outside = true;
for (int i = 0; i < firstSnappedPlanes.Length; i++)
{
if (firstSnappedPlanes[i].Distance(worldPosition) <= MathConstants.DistanceEpsilon)
{
outside = false;
break;
}
}
planeOnGeometry = !outside;
}
if (vertexOnGeometry)
{
var plane = hoverDefaultPlane.Value;
var distance = plane.Distance(worldPosition);
if (float.IsInfinity(distance) || float.IsNaN(distance))
{
distance = 1.0f;
}
plane.d += distance;
hoverDefaultPlane = plane;
for (int i = 0; i < settings.vertices.Length; i++)
{
if (!settings.onGeometryVertices[i])
{
settings.vertices[i] = GeometryUtility.ProjectPointOnPlane(plane, settings.vertices[i]);
settings.onGeometryVertices[i] = true;
}
}
}
}
ArrayUtility.Add(ref settings.onGeometryVertices, vertexOnGeometry);
settings.AddPoint(worldPosition);
SceneView.RepaintAll();
if (settings.vertices.Length == 2)
{
HotKeyReleased();
}
}
}
return;
}
case EventType.MouseDrag:
{
if (Tools.viewTool != ViewTool.None && Tools.viewTool != ViewTool.Pan)
{
break;
}
if (GUIUtility.hotControl == base.shapeId && Event.current.button == 0)
{
Event.current.Use();
}
return;
}
case EventType.MouseUp:
{
if (GUIUtility.hotControl != base.shapeId)
{
return;
}
if (Tools.viewTool != ViewTool.None && Tools.viewTool != ViewTool.Pan)
{
return;
}
if (Event.current.button == 0)
{
Event.current.Use();
ResetVisuals();
if (onLastPoint)
{
GUIUtility.hotControl = 0;
GUIUtility.keyboardControl = 0;
EditorGUIUtility.editingTextField = false;
editMode = EditMode.CreateShape;
HotKeyReleased();
}
}
return;
}
}
return;
}
protected override void HandleCreateShapeEvents(Rect sceneRect)
{
bool pointOnEdge = false;
bool havePlane = false;
bool vertexOnGeometry = false;
CSGBrush vertexOnBrush = null;
CSGPlane hoverBuildPlane = buildPlane;
var sceneView = SceneView.currentDrawingSceneView; //(SceneView.currentDrawingSceneView != null) ? SceneView.currentDrawingSceneView : SceneView.lastActiveSceneView;
var camera = sceneView.camera;
if (camera != null &&
camera.pixelRect.Contains(Event.current.mousePosition))
{
if (!hoverDefaultPlane.HasValue ||
settings.vertices.Length == 0)
{
bool forceGrid = RealtimeCSG.CSGGrid.ForceGrid;
RealtimeCSG.CSGGrid.ForceGrid = false;
hoverDefaultPlane = RealtimeCSG.CSGGrid.CurrentGridPlane;
RealtimeCSG.CSGGrid.ForceGrid = forceGrid;
firstSnappedEdges = null;
firstSnappedBrush = null;
firstSnappedPlanes = null;
base.geometryModel = null;
}
if (editMode == EditMode.CreatePlane)
{
LegacyBrushIntersection intersection;
if (!IgnoreDepthForRayCasts(sceneView) && !havePlane &&
SceneQueryUtility.FindWorldIntersection(Event.current.mousePosition, out intersection))
{
worldPosition = intersection.worldIntersection;
hoverBuildPlane = intersection.worldPlane;
vertexOnBrush = intersection.brush;
vertexOnGeometry = true;
}
else
{
hoverBuildPlane = hoverDefaultPlane.Value;
vertexOnBrush = null;
var mouseRay = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition);
worldPosition = hoverBuildPlane.RayIntersection(mouseRay);
vertexOnGeometry = false;
}
ResetVisuals();
if (snapFunction != null)
{
CSGBrush snappedOnBrush;
worldPosition = snapFunction(worldPosition, hoverBuildPlane, ref visualSnappedEdges, out snappedOnBrush, generatedBrushes, ignoreAllBrushes: true);
if (snappedOnBrush != null)
{
pointOnEdge = (visualSnappedEdges != null &&
visualSnappedEdges.Count > 0);
vertexOnBrush = snappedOnBrush;
vertexOnGeometry = true;
}
}
if (settings.vertices.Length == 1)
{
if (hoverBuildPlane.normal != MathConstants.zeroVector3)
{
editMode = EditMode.CreateShape;
havePlane = true;
}
}
}
else
{
var mouseRay = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition);
if (settings.vertices.Length == 2)
{
var startPoint = settings.vertices[1];
var forward = camera.transform.forward;
if (Vector3.Dot(forward, gridBinormal) < Vector3.Dot(forward, gridTangent))
{
hoverBuildPlane = new CSGPlane(gridBinormal, startPoint);
}
else
{
hoverBuildPlane = new CSGPlane(gridTangent, startPoint);
}
worldPosition = hoverBuildPlane.RayIntersection(mouseRay);
// the third point is always straight up from the second point
//worldPosition = startPoint + (Vector3.Dot(worldPosition - startPoint, gridNormal) * gridNormal);
RealtimeCSG.CSGGrid.SetForcedGrid(hoverBuildPlane);
ResetVisuals();
if (raySnapFunction != null)
{
Ray ray = new Ray(startPoint, gridNormal);
CSGBrush snappedOnBrush;
worldPosition = raySnapFunction(worldPosition, ray, ref visualSnappedEdges, out snappedOnBrush);
if (snappedOnBrush != null)
{
pointOnEdge = (visualSnappedEdges != null &&
visualSnappedEdges.Count > 0);
vertexOnBrush = snappedOnBrush;
}
}
worldPosition = GeometryUtility.ProjectPointOnInfiniteLine(worldPosition, startPoint, gridNormal);
}
else
{
worldPosition = hoverBuildPlane.RayIntersection(mouseRay);
RealtimeCSG.CSGGrid.SetForcedGrid(hoverBuildPlane);
ResetVisuals();
if (snapFunction != null)
{
CSGBrush snappedOnBrush;
worldPosition = snapFunction(worldPosition, hoverBuildPlane, ref visualSnappedEdges, out snappedOnBrush, generatedBrushes, ignoreAllBrushes: true);
if (snappedOnBrush != null)
{
pointOnEdge = (visualSnappedEdges != null &&
visualSnappedEdges.Count > 0);
vertexOnBrush = snappedOnBrush;
}
}
}
}
if (geometryModel == null && vertexOnBrush != null)
{
if (vertexOnBrush.ChildData != null && vertexOnBrush.ChildData.Model)
{
geometryModel = vertexOnBrush.ChildData.Model;
}
}
if (worldPosition != prevWorldPosition)
{
prevWorldPosition = worldPosition;
if (settings.vertices.Length > 0)
{
if ((settings.vertices[0] - worldPosition).sqrMagnitude > MathConstants.EqualityEpsilon)
{
UpdateSizes();
UpdateBaseShape(true);
}
}
if (Event.current.type != EventType.Repaint)
{
CSG_EditorGUIUtility.UpdateSceneViews();
}
}
visualSnappedGrid = RealtimeCSG.CSGGrid.FindAllGridEdgesThatTouchPoint(worldPosition);
visualSnappedBrush = vertexOnBrush;
}
RealtimeCSG.CSGGrid.SetForcedGrid(hoverBuildPlane);
if (!SceneDragToolManager.IsDraggingObjectInScene &&
Event.current.type == EventType.Repaint)
{
PaintSnapVisualisation();
PaintShape(base.shapeId);
}
var type = Event.current.GetTypeForControl(base.shapeId);
switch (type)
{
case EventType.Layout:
{
return;
}
case EventType.ValidateCommand:
case EventType.KeyDown:
{
if (GUIUtility.hotControl == base.shapeId)
{
if (Keys.PerformActionKey.IsKeyPressed() ||
Keys.DeleteSelectionKey.IsKeyPressed() ||
Keys.CancelActionKey.IsKeyPressed())
{
Event.current.Use();
}
}
return;
}
case EventType.KeyUp:
{
if (GUIUtility.hotControl == base.shapeId)
{
if (Keys.CylinderBuilderMode.IsKeyPressed() ||
Keys.PerformActionKey.IsKeyPressed())
{
HotKeyReleased();
Event.current.Use();
return;
}
if (Keys.DeleteSelectionKey.IsKeyPressed() ||
Keys.CancelActionKey.IsKeyPressed())
{
Cancel();
Event.current.Use();
return;
}
}
return;
}
case EventType.MouseDown:
{
if (!sceneRect.Contains(Event.current.mousePosition))
{
break;
}
if (Tools.viewTool != ViewTool.None && Tools.viewTool != ViewTool.Pan)
{
return;
}
if ((GUIUtility.hotControl != 0 && GUIUtility.hotControl != shapeEditId && GUIUtility.hotControl != base.shapeId) ||
Event.current.button != 0)
{
return;
}
Event.current.Use();
if (settings.vertices.Length == 0)
{
if ((GUIUtility.hotControl == 0 ||
GUIUtility.hotControl == base.shapeEditId) && base.shapeId != -1)
{
base.CalculateWorldSpaceTangents();
GUIUtility.hotControl = base.shapeId;
GUIUtility.keyboardControl = base.shapeId;
EditorGUIUtility.editingTextField = false;
}
}
if (GUIUtility.hotControl == base.shapeId &&
settings.vertices.Length < kMaxPoints)
{
if (!float.IsNaN(worldPosition.x) && !float.IsInfinity(worldPosition.x) &&
!float.IsNaN(worldPosition.y) && !float.IsInfinity(worldPosition.y) &&
!float.IsNaN(worldPosition.z) && !float.IsInfinity(worldPosition.z))
{
if (settings.vertices.Length < 2 &&
hoverBuildPlane.normal.sqrMagnitude != 0)
{
buildPlane = hoverBuildPlane;
}
CalculateWorldSpaceTangents();
if (settings.vertices.Length == 0)
{
if (pointOnEdge)
{
firstSnappedEdges = visualSnappedEdges.ToArray();
firstSnappedBrush = visualSnappedBrush;
firstSnappedPlanes = null;
}
else
{
firstSnappedBrush = null;
firstSnappedEdges = null;
firstSnappedPlanes = null;
}
planeOnGeometry = vertexOnGeometry;
}
else
{
if (firstSnappedEdges != null)
{
if (firstSnappedPlanes == null)
{
CreateSnappedPlanes();
}
bool outside = true;
for (int i = 0; i < firstSnappedPlanes.Length; i++)
{
if (firstSnappedPlanes[i].Distance(worldPosition) <= MathConstants.DistanceEpsilon)
{
outside = false;
break;
}
}
planeOnGeometry = !outside;
}
if (vertexOnGeometry)
{
var plane = hoverDefaultPlane.Value;
var distance = plane.Distance(worldPosition);
plane.d += distance;
hoverDefaultPlane = plane;
for (int i = 0; i < settings.vertices.Length; i++)
{
if (!settings.onGeometryVertices[i])
{
settings.SetPoint(i, GeometryUtility.ProjectPointOnPlane(plane, settings.vertices[i]));
settings.onGeometryVertices[i] = true;
}
}
}
}
ArrayUtility.Add(ref settings.onGeometryVertices, vertexOnGeometry);
settings.AddPoint(worldPosition);
UpdateSizes();
CSG_EditorGUIUtility.UpdateSceneViews();
if (settings.vertices.Length == kMaxPoints)
{
HotKeyReleased();
}
}
}
return;
}
case EventType.MouseDrag:
{
if (Tools.viewTool != ViewTool.None && Tools.viewTool != ViewTool.Pan)
{
break;
}
if (GUIUtility.hotControl == base.shapeId && Event.current.button == 0)
{
Event.current.Use();
}
return;
}
case EventType.MouseUp:
{
if (GUIUtility.hotControl != base.shapeId)
{
return;
}
if (Tools.viewTool != ViewTool.None && Tools.viewTool != ViewTool.Pan)
{
return;
}
if (Event.current.button == 0)
{
Event.current.Use();
ResetVisuals();
if (settings.vertices.Length == kMaxPoints)
{
GUIUtility.hotControl = 0;
GUIUtility.keyboardControl = 0;
EditorGUIUtility.editingTextField = false;
editMode = EditMode.CreateShape;
HotKeyReleased();
}
}
return;
}
}
}
// Update rectangle selection using reflection
// This is hacky & dangerous
// LOOK AWAY NOW!
internal static void Update(SceneView sceneView)
{
InitReflectedData();
if (!reflectionSucceeded)
{
prevStartGUIPoint = new Vector2(float.PositiveInfinity, float.PositiveInfinity);
prevMouseGUIPoint = prevStartGUIPoint;
prevStartScreenPoint = MathConstants.zeroVector2;
prevMouseScreenPoint = MathConstants.zeroVector2;
rectFoundGameObjects.Clear();
return;
}
var s_RectSelectionID_instance = (int)s_RectSelectionID_field.GetValue(null);
// check if we're rect-selecting
if (GUIUtility.hotControl == s_RectSelectionID_instance)
{
var typeForControl = Event.current.GetTypeForControl(s_RectSelectionID_instance);
if (typeForControl == EventType.Used ||
Event.current.commandName == "ModifierKeysChanged")
{
// m_RectSelection field of SceneView
var m_RectSelection_instance = m_RectSelection_field.GetValue(sceneView);
// m_RectSelecting field of RectSelection instance
var m_RectSelecting_instance = (bool)m_RectSelecting_field.GetValue(m_RectSelection_instance);
if (m_RectSelecting_instance)
{
// m_SelectStartPoint of RectSelection instance
var m_SelectStartPoint_instance = (Vector2)m_SelectStartPoint_field.GetValue(m_RectSelection_instance);
// m_SelectMousePoint of RectSelection instance
var m_SelectMousePoint_instance = (Vector2)m_SelectMousePoint_field.GetValue(m_RectSelection_instance);
// determine if our frustum changed since the last time
bool modified = false;
bool needUpdate = false;
if (prevStartGUIPoint != m_SelectStartPoint_instance)
{
prevStartGUIPoint = m_SelectStartPoint_instance;
prevStartScreenPoint = Event.current.mousePosition;
needUpdate = true;
}
if (prevMouseGUIPoint != m_SelectMousePoint_instance)
{
prevMouseGUIPoint = m_SelectMousePoint_instance;
prevMouseScreenPoint = Event.current.mousePosition;
needUpdate = true;
}
if (needUpdate)
{
var rect = CameraUtility.PointsToRect(prevStartScreenPoint, prevMouseScreenPoint);
if (rect.width > 3 && rect.height > 3)
{
var frustum = CameraUtility.GetCameraSubFrustumGUI(sceneView.camera, rect);
// Find all the brushes (and it's gameObjects) that are in the frustum
if (SceneQueryUtility.GetItemsInFrustum(frustum.Planes,
rectFoundGameObjects))
{
modified = true;
}
else
{
if (rectFoundGameObjects != null &&
rectFoundGameObjects.Count > 0)
{
rectFoundGameObjects.Clear();
modified = true;
}
}
}
}
GameObject[] currentSelection = null;
var m_LastSelection_instance = (Dictionary <GameObject, bool>)m_LastSelection_field.GetValue(m_RectSelection_instance);
var m_SelectionStart_instance = (UnityEngine.Object[])m_SelectionStart_field.GetValue(m_RectSelection_instance);
if (modified &&
rectFoundGameObjects != null &&
rectFoundGameObjects.Count > 0)
{
if (EditModeManager.ActiveTool == null)
{
if (EditModeManager.EditMode != ToolEditMode.Place ||
EditModeManager.EditMode != ToolEditMode.Edit)
{
EditModeManager.EditMode = ToolEditMode.Place;
}
}
foreach (var obj in rectFoundGameObjects)
{
// if it hasn't already been added, add the obj
if (!m_LastSelection_instance.ContainsKey(obj))
{
m_LastSelection_instance.Add(obj, false);
}
// Remove models that we may have selected when we should be selecting it's brushes
var models = obj.GetComponentsInParent <CSGModel>(includeInactive: true);
var model = models.Length == 0 ? null : models[0];
if (model != null)
{
var modelObj = model.gameObject;
if (model != null &&
modelObj != obj &&
m_LastSelection_instance.ContainsKey(modelObj) &&
!ArrayUtility.Contains(m_SelectionStart_instance, modelObj))
{
m_LastSelection_instance.Remove(modelObj);
modified = true;
}
}
}
currentSelection = m_LastSelection_instance.Keys.ToArray();
m_CurrentSelection_field.SetValue(m_RectSelection_instance, currentSelection);
}
for (int j = m_SelectionStart_instance.Length - 1; j >= 0; j--)
{
var obj = m_SelectionStart_instance[j] as GameObject;
if (obj == null)
{
continue;
}
if (obj.GetComponent <GeneratedMeshInstance>() != null)
{
ArrayUtility.RemoveAt(ref m_SelectionStart_instance, j);
m_LastSelection_instance.Remove(obj);
m_SelectionStart_field.SetValue(m_RectSelection_instance, m_SelectionStart_instance);
modified = true;
}
}
if ((Event.current.commandName == "ModifierKeysChanged" || modified))
{
if (currentSelection == null || modified)
{
currentSelection = m_LastSelection_instance.Keys.ToArray();
}
var foundObjects = currentSelection;
for (int j = foundObjects.Length - 1; j >= 0; j--)
{
var obj = foundObjects[j];
if (obj == null || obj.GetComponent <GeneratedMeshInstance>() != null)
{
ArrayUtility.RemoveAt(ref foundObjects, j);
m_LastSelection_instance.Remove(obj);
m_SelectionStart_field.SetValue(m_RectSelection_instance, m_SelectionStart_instance);
}
}
var selectionTypeNormal = SelectionType_Normal;
if (Event.current.shift)
{
selectionTypeNormal = SelectionType_Additive;
}
else
if (EditorGUI.actionKey)
{
selectionTypeNormal = SelectionType_Subtractive;
}
// calling static method UpdateSelection of RectSelection
UpdateSelection_method.Invoke(null,
new object[] {
m_SelectionStart_instance,
foundObjects,
selectionTypeNormal,
m_RectSelecting_instance
});
}
}
}
}
if (GUIUtility.hotControl != s_RectSelectionID_instance)
{
prevStartGUIPoint = MathConstants.zeroVector2;
prevMouseGUIPoint = MathConstants.zeroVector2;
rectFoundGameObjects.Clear();
}
var eventType = Event.current.GetTypeForControl(s_RectSelectionID_instance);
var hotControl = GUIUtility.hotControl;
if (hotControl == s_RectSelectionID_instance &&
EditModeManager.ActiveTool.IgnoreUnityRect)
{
hotControl = 0;
GUIUtility.hotControl = 0;
}
switch (eventType)
{
case EventType.MouseDown:
{
rectClickDown = (Event.current.button == 0 && hotControl == s_RectSelectionID_instance);
clickMousePosition = Event.current.mousePosition;
mouseDragged = false;
break;
}
case EventType.MouseUp:
{
rectClickDown = false;
break;
}
case EventType.MouseMove:
{
rectClickDown = false;
break;
}
case EventType.Used:
{
if (clickMousePosition != Event.current.mousePosition)
{
mouseDragged = true;
}
if (!mouseDragged && rectClickDown &&
Event.current.button == 0)
{
// m_RectSelection field of SceneView
var m_RectSelection_instance = m_RectSelection_field.GetValue(sceneView);
var m_RectSelecting_instance = (bool)m_RectSelecting_field.GetValue(m_RectSelection_instance);
if (!m_RectSelecting_instance)
{
// make sure GeneratedMeshes are not part of our selection
if (Selection.gameObjects != null)
{
var selectedObjects = Selection.objects;
var foundObjects = new List <UnityEngine.Object>();
foreach (var obj in selectedObjects)
{
var component = obj as Component;
var gameObject = obj as GameObject;
var transform = obj as Transform;
if (!(component && component.GetComponent <GeneratedMeshes>()) &&
!(gameObject && gameObject.GetComponent <GeneratedMeshes>()) &&
!(transform && transform.GetComponent <Transform>()))
{
foundObjects.Add(obj);
}
}
if (foundObjects.Count != selectedObjects.Length)
{
Selection.objects = foundObjects.ToArray();
}
}
SelectionUtility.DoSelectionClick(sceneView);
Event.current.Use();
}
}
rectClickDown = false;
break;
}
case EventType.ValidateCommand:
{
if (Event.current.commandName == "SelectAll")
{
Event.current.Use();
break;
}
if (Keys.HandleSceneValidate(EditModeManager.CurrentTool, true))
{
Event.current.Use();
HandleUtility.Repaint();
}
break;
}
case EventType.ExecuteCommand:
{
if (Event.current.commandName == "SelectAll")
{
var transforms = new List <UnityEngine.Object>();
for (int sceneIndex = 0; sceneIndex < SceneManager.sceneCount; sceneIndex++)
{
var scene = SceneManager.GetSceneAt(sceneIndex);
foreach (var gameObject in scene.GetRootGameObjects())
{
foreach (var transform in gameObject.GetComponentsInChildren <Transform>())
{
if ((transform.hideFlags & (HideFlags.NotEditable | HideFlags.HideInHierarchy)) == (HideFlags.NotEditable | HideFlags.HideInHierarchy))
{
continue;
}
transforms.Add(transform.gameObject);
}
}
}
Selection.objects = transforms.ToArray();
Event.current.Use();
break;
}
break;
}
case EventType.KeyDown:
{
if (Keys.HandleSceneKeyDown(EditModeManager.CurrentTool, true))
{
Event.current.Use();
HandleUtility.Repaint();
}
break;
}
case EventType.KeyUp:
{
if (Keys.HandleSceneKeyUp(EditModeManager.CurrentTool, true))
{
Event.current.Use();
HandleUtility.Repaint();
}
break;
}
}
}
public static Vector3 SnapToWorld(Camera camera, CSGPlane snapPlane, Vector3 unsnappedPosition, Vector3 snappedPosition, ref List <Vector3> snappingEdges, out CSGBrush snappedOnBrush, CSGBrush[] ignoreBrushes = null)
{
snappedOnBrush = null;
test_points[0] = unsnappedPosition;
test_points[1] = snappedPosition;
worldIntersections.Clear();
for (int i = 0; i < test_points.Length; i++)
{
var test_point2D = CameraUtility.WorldToGUIPoint(test_points[i]);
LegacyBrushIntersection intersection;
if (SceneQueryUtility.FindWorldIntersection(camera, test_point2D, out intersection))
{
if (intersection.brush &&
intersection.brush.ControlMesh != null)
{
intersection.worldIntersection = GeometryUtility.ProjectPointOnPlane(snapPlane, intersection.worldIntersection);
worldIntersections.Add(intersection);
}
}
}
var old_difference = snappedPosition - unsnappedPosition;
var old_difference_magnitude = old_difference.magnitude * 1.5f;
Vector3 newSnappedPoint = snappedPosition;
CSGPlane?snappingPlane = snapPlane;
for (int i = 0; i < worldIntersections.Count; i++)
{
if (ignoreBrushes != null &&
ArrayUtility.Contains(ignoreBrushes, worldIntersections[i].brush))
{
continue;
}
List <Vector3> outEdgePoints;
Vector3 outPosition;
if (GridUtility.SnapToVertices(worldIntersections[i].brush,
snappingPlane, unsnappedPosition,
out outEdgePoints,
out outPosition))
{
var new_difference = outPosition - unsnappedPosition;
var new_difference_magnitude = new_difference.magnitude;
if (new_difference_magnitude <= old_difference_magnitude + MathConstants.EqualityEpsilon)
{
old_difference_magnitude = new_difference_magnitude;
newSnappedPoint = outPosition;
snappingEdges = outEdgePoints;
snappedOnBrush = worldIntersections[i].brush;
}
}
if (GridUtility.SnapToEdge(camera,
worldIntersections[i].brush, snappingPlane ?? worldIntersections[i].worldPlane,
worldIntersections[i].worldIntersection,
out outEdgePoints,
out outPosition))
{
var new_difference = outPosition - unsnappedPosition;
var new_difference_magnitude = new_difference.magnitude * 1.1f;
if (new_difference_magnitude <= old_difference_magnitude + MathConstants.EqualityEpsilon)
{
old_difference_magnitude = new_difference_magnitude;
newSnappedPoint = outPosition;
snappingEdges = outEdgePoints;
snappedOnBrush = worldIntersections[i].brush;
}
}
}
//snappingEdges = FindAllEdgesThatTouchPoint(snappedOnBrush, newSnappedPoint);
return(newSnappedPoint);
}
// static Rect? currentMarqueRect = null;
// Update rectangle selection using reflection
// This is hacky, dangerous & the only way to do this ..
static void UpdateRectSelection(SceneView sceneView, int s_RectSelectionID_instance)
{
if (!reflectionSucceeded)
{
// currentMarqueRect = null;
prevStartGUIPoint = new Vector2(float.PositiveInfinity, float.PositiveInfinity);
prevMouseGUIPoint = prevStartGUIPoint;
prevStartScreenPoint = MathConstants.zeroVector2;
prevMouseScreenPoint = MathConstants.zeroVector2;
rectFoundGameObjects.Clear();
return;
}
// check if we're rect-selecting
if (GUIUtility.hotControl == s_RectSelectionID_instance)
{
var typeForControl = Event.current.GetTypeForControl(s_RectSelectionID_instance);
if (typeForControl == EventType.Used ||
Event.current.commandName == "ModifierKeysChanged")
{
// m_RectSelection field of SceneView
var m_RectSelection_instance = m_RectSelection_field.GetValue(sceneView);
// m_RectSelecting field of RectSelection instance
var m_RectSelecting_instance = (bool)m_RectSelecting_field.GetValue(m_RectSelection_instance);
if (m_RectSelecting_instance)
{
// m_SelectStartPoint of RectSelection instance
var m_SelectStartPoint_instance = (Vector2)m_SelectStartPoint_field.GetValue(m_RectSelection_instance);
// m_SelectMousePoint of RectSelection instance
var m_SelectMousePoint_instance = (Vector2)m_SelectMousePoint_field.GetValue(m_RectSelection_instance);
// determine if our frustum changed since the last time
bool modified = false;
bool needUpdate = false;
if (prevStartGUIPoint != m_SelectStartPoint_instance)
{
prevStartGUIPoint = m_SelectStartPoint_instance;
prevStartScreenPoint = Event.current.mousePosition;
needUpdate = true;
}
if (prevMouseGUIPoint != m_SelectMousePoint_instance)
{
prevMouseGUIPoint = m_SelectMousePoint_instance;
prevMouseScreenPoint = Event.current.mousePosition;
needUpdate = true;
}
if (needUpdate)
{
//var rect = CameraUtility.PointsToRect(prevStartGUIPoint, prevMouseGUIPoint);
//var frustum = CameraUtility.GetCameraSubFrustumGUI(Camera.current, rect);
var rect = CameraUtility.PointsToRect(prevStartScreenPoint, prevMouseScreenPoint);
if (rect.width > 3 && rect.height > 3)
{
var frustum = CameraUtility.GetCameraSubFrustumGUI(Camera.current, rect);
// currentMarqueRect = rect;
// Find all the brushes (and it's gameObjects) that are in the frustum
if (SceneQueryUtility.GetItemsInFrustum(frustum.Planes,
rectFoundGameObjects))
{
modified = true;
}
else
{
if (rectFoundGameObjects != null &&
rectFoundGameObjects.Count > 0)
{
rectFoundGameObjects.Clear();
modified = true;
}
}
}
}
GameObject[] currentSelection = null;
var m_LastSelection_instance = (Dictionary <GameObject, bool>)m_LastSelection_field.GetValue(m_RectSelection_instance);
var m_SelectionStart_instance = (UnityEngine.Object[])m_SelectionStart_field.GetValue(m_RectSelection_instance);
if (modified &&
rectFoundGameObjects != null &&
rectFoundGameObjects.Count > 0)
{
if (CSGBrushEditorManager.ActiveTool == null)
{
if (CSGBrushEditorManager.EditMode != ToolEditMode.Object ||
CSGBrushEditorManager.EditMode != ToolEditMode.Mesh)
{
CSGBrushEditorManager.EditMode = ToolEditMode.Object;
}
}
foreach (var obj in rectFoundGameObjects)
{
// if it hasn't already been added, add the obj
if (!m_LastSelection_instance.ContainsKey(obj))
{
m_LastSelection_instance.Add(obj, false);
}
// Remove models that we may have selected when we should be selecting it's brushes
var model = obj.GetComponentInParent <CSGModel>();
if (model != null)
{
var modelObj = model.gameObject;
if (model != null &&
modelObj != obj &&
m_LastSelection_instance.ContainsKey(modelObj) &&
!ArrayUtility.Contains(m_SelectionStart_instance, modelObj))
{
m_LastSelection_instance.Remove(modelObj);
modified = true;
}
}
}
currentSelection = m_LastSelection_instance.Keys.ToArray();
m_CurrentSelection_field.SetValue(m_RectSelection_instance, currentSelection);
}
for (int j = m_SelectionStart_instance.Length - 1; j >= 0; j--)
{
var obj = m_SelectionStart_instance[j] as GameObject;
if (obj == null)
{
continue;
}
if (obj.GetComponent <GeneratedMeshInstance>() != null)
{
ArrayUtility.RemoveAt(ref m_SelectionStart_instance, j);
m_LastSelection_instance.Remove(obj);
m_SelectionStart_field.SetValue(m_RectSelection_instance, m_SelectionStart_instance);
modified = true;
}
}
if ( //(rectFoundGameObjects != null && rectFoundGameObjects.Length > 0) &&
(Event.current.commandName == "ModifierKeysChanged" || modified))
{
if (currentSelection == null || modified)
{
currentSelection = m_LastSelection_instance.Keys.ToArray();
}
var foundObjects = currentSelection;
for (int j = foundObjects.Length - 1; j >= 0; j--)
{
var obj = foundObjects[j];
if (obj == null || obj.GetComponent <GeneratedMeshInstance>() != null)
{
ArrayUtility.RemoveAt(ref foundObjects, j);
m_LastSelection_instance.Remove(obj);
m_SelectionStart_field.SetValue(m_RectSelection_instance, m_SelectionStart_instance);
}
}
var selectionTypeNormal = SelectionType_Normal;
if (Event.current.shift)
{
selectionTypeNormal = SelectionType_Additive;
}
else
if (EditorGUI.actionKey)
{
selectionTypeNormal = SelectionType_Subtractive;
}
// calling static method UpdateSelection of RectSelection
UpdateSelection_method.Invoke(null,
new object[] {
m_SelectionStart_instance,
foundObjects,
selectionTypeNormal,
m_RectSelecting_instance
});
}
}
}
}
if (GUIUtility.hotControl != s_RectSelectionID_instance)
{
prevStartGUIPoint = MathConstants.zeroVector2;
prevMouseGUIPoint = MathConstants.zeroVector2;
rectFoundGameObjects.Clear();
// currentMarqueRect = null;
}
}
static void InitializeDefaultCSGModel(Scene currentScene, CSGSceneState sceneState, bool createIfNoExists = true)
{
bool inPrefabMode = false;
Transform prefabRootTransform = null;
#if UNITY_2018_3_OR_NEWER
var currentPrefabStage = UnityEditor.Experimental.SceneManagement.PrefabStageUtility.GetCurrentPrefabStage();
if (currentPrefabStage != null)
{
var prefabRoot = currentPrefabStage.prefabContentsRoot;
prefabRootTransform = prefabRoot.transform;
inPrefabMode = (prefabRoot.scene == currentScene);
}
#endif
var defaultModelName = inPrefabMode ? DefaultPrefabModelName : DefaultModelName;
// make sure we have a default CSG model
sceneState.DefaultModelObject = SceneQueryUtility.GetUniqueHiddenGameObjectInSceneWithName(currentScene, defaultModelName);
if (createIfNoExists)
{
if (!sceneState.DefaultModelObject)
{
sceneState.DefaultModelObject = new GameObject(defaultModelName);
sceneState.DefaultModel = CreateCSGModel(sceneState.DefaultModelObject);
}
else
{
sceneState.DefaultModel = sceneState.DefaultModelObject.GetComponent <CSGModel>();
if (!sceneState.DefaultModel)
{
sceneState.DefaultModel = CreateCSGModel(sceneState.DefaultModelObject);
}
}
// make sure it's transformation has sensible values
var transform = sceneState.DefaultModel.transform;
if (inPrefabMode)
{
transform.SetParent(prefabRootTransform, false);
}
else
{
transform.parent = null;
}
transform.localPosition = MathConstants.zeroVector3;
transform.localScale = MathConstants.oneVector3;
transform.localRotation = Quaternion.identity;
var defaultFlags = //StaticEditorFlags.LightmapStatic |
StaticEditorFlags.BatchingStatic |
StaticEditorFlags.NavigationStatic |
StaticEditorFlags.OccludeeStatic |
StaticEditorFlags.OffMeshLinkGeneration |
StaticEditorFlags.ReflectionProbeStatic;
GameObjectUtility.SetStaticEditorFlags(sceneState.DefaultModel.gameObject, defaultFlags);
RegisterModel(sceneState.DefaultModel);
}
// do not give default CSG model any extra abilities other than rendering
// since an invisible object doesn't work well with navmesh/colliders etc.
// force the users to use a CSG-model, but gracefully let it still be
// visible for objects outside of it.
if (inPrefabMode)
{
sceneState.DefaultModelObject.hideFlags = MeshInstanceManager.ComponentHideFlags | HideFlags.DontSave;
}
else
{
sceneState.DefaultModelObject.hideFlags = MeshInstanceManager.ComponentHideFlags;
}
}
public static void DoSelectionClick(SceneView sceneView, bool ignoreInvisibleSurfaces = true)
{
var camera = sceneView.camera;
GameObject gameobject;
SceneQueryUtility.FindClickWorldIntersection(camera, Event.current.mousePosition, out gameobject, ignoreInvisibleSurfaces);
gameobject = SceneQueryUtility.FindSelectionBase(gameobject);
var selectedObjectsOnClick = new List <int>(Selection.instanceIDs);
bool addedSelection = false;
if (EditorGUI.actionKey)
{
if (gameobject != null)
{
var instanceID = gameobject.GetInstanceID();
if (selectedObjectsOnClick.Contains(instanceID))
{
selectedObjectsOnClick.Remove(instanceID);
}
else
{
selectedObjectsOnClick.Add(instanceID);
addedSelection = true;
}
if (selectedObjectsOnClick.Count == 0)
{
Selection.activeTransform = null;
}
else
{
Selection.instanceIDs = selectedObjectsOnClick.ToArray();
}
}
}
else
if (Event.current.shift)
{
if (gameobject != null)
{
var instanceID = gameobject.GetInstanceID();
selectedObjectsOnClick.Add(instanceID);
Selection.instanceIDs = selectedObjectsOnClick.ToArray();
addedSelection = true;
}
}
else
if (Event.current.alt)
{
if (gameobject != null)
{
var instanceID = gameobject.GetInstanceID();
selectedObjectsOnClick.Remove(instanceID);
Selection.instanceIDs = selectedObjectsOnClick.ToArray();
return;
}
}
else
{
Selection.activeGameObject = gameobject;
addedSelection = true;
}
if (!addedSelection)
{
foreach (var item in Selection.GetFiltered(typeof(CSGBrush), SelectionMode.Deep))
{
var brush = item as CSGBrush;
if (brush.ChildData == null ||
!ModelTraits.IsModelEditable(brush.ChildData.Model))
{
continue;
}
SelectionUtility.LastUsedModel = brush.ChildData.Model;
break;
}
}
else
if (gameobject != null)
{
var brush = gameobject.GetComponent <CSGBrush>();
if (brush != null)
{
if (brush.ChildData == null ||
!ModelTraits.IsModelEditable(brush.ChildData.Model))
{
return;
}
SelectionUtility.LastUsedModel = brush.ChildData.Model;
}
}
}
public static Vector3 SnapToWorld(CSGPlane snapPlane, Vector3 unsnappedPosition, Vector3 snappedPosition, ref List <Vector3> snappingEdges, out CSGBrush snappedOnBrush, CSGBrush[] ignoreBrushes = null)
{
snappedOnBrush = null;
var intersections = new BrushIntersection[0];
var test_points = new Vector3[] { unsnappedPosition, snappedPosition };
BrushIntersection intersection;
for (int i = 0; i < test_points.Length; i++)
{
var test_point2D = HandleUtility.WorldToGUIPoint(test_points[i]);
if (SceneQueryUtility.FindWorldIntersection(test_point2D, out intersection, MathConstants.GrowBrushFactor))
{
if (intersection.brush &&
intersection.brush.ControlMesh != null)
{
intersection.worldIntersection = GeometryUtility.ProjectPointOnPlane(snapPlane, intersection.worldIntersection);
ArrayUtility.Add(ref intersections, intersection);
}
}
}
var old_difference = snappedPosition - unsnappedPosition;
var old_difference_magnitude = old_difference.magnitude * 1.5f;
Vector3 newSnappedPoint = snappedPosition;
CSGPlane?snappingPlane = snapPlane;
for (int i = 0; i < intersections.Length; i++)
{
if (ignoreBrushes != null &&
ArrayUtility.Contains(ignoreBrushes, intersections[i].brush))
{
continue;
}
List <Vector3> outEdgePoints;
Vector3 outPosition;
if (GridUtility.SnapToVertices(intersections[i].brush,
snappingPlane, unsnappedPosition,
out outEdgePoints,
out outPosition))
{
var new_difference = outPosition - unsnappedPosition;
var new_difference_magnitude = new_difference.magnitude;
if (new_difference_magnitude <= old_difference_magnitude + MathConstants.EqualityEpsilon)
{
old_difference_magnitude = new_difference_magnitude;
newSnappedPoint = outPosition;
snappingEdges = outEdgePoints;
snappedOnBrush = intersections[i].brush;
}
}
if (GridUtility.SnapToEdge(intersections[i].brush, snappingPlane ?? intersections[i].plane,
intersections[i].worldIntersection,
out outEdgePoints,
out outPosition))
{
var new_difference = outPosition - unsnappedPosition;
var new_difference_magnitude = new_difference.magnitude * 1.1f;
if (new_difference_magnitude <= old_difference_magnitude + MathConstants.EqualityEpsilon)
{
old_difference_magnitude = new_difference_magnitude;
newSnappedPoint = outPosition;
snappingEdges = outEdgePoints;
snappedOnBrush = intersections[i].brush;
}
}
}
//snappingEdges = FindAllEdgesThatTouchPoint(snappedOnBrush, newSnappedPoint);
return(newSnappedPoint);
}
