void CallOnPaintSceneGUI()
{
bool hasSelection = GridSelection.active && GridSelection.target == brushTarget;
if (!hasSelection && GridPaintingState.activeGrid != this)
{
return;
}
RectInt rect = new RectInt(mouseGridPosition, new Vector2Int(1, 1));
if (m_MarqueeStart.HasValue)
{
rect = GridEditorUtility.GetMarqueeRect(mouseGridPosition, m_MarqueeStart.Value);
}
else if (hasSelection)
{
rect = new RectInt(GridSelection.position.xMin, GridSelection.position.yMin, GridSelection.position.size.x, GridSelection.position.size.y);
}
var layoutGrid = tilemap != null ? tilemap as GridLayout : grid as GridLayout;
BoundsInt brushBounds = new BoundsInt(new Vector3Int(rect.x, rect.y, zPosition), new Vector3Int(rect.width, rect.height, 1));
if (GridPaintingState.activeBrushEditor != null)
{
GridPaintingState.activeBrushEditor.OnPaintSceneGUI(layoutGrid, brushTarget, brushBounds
, EditModeToBrushTool(EditMode.editMode), m_MarqueeStart.HasValue || executing);
}
else // Fallback when user hasn't defined custom editor
{
GridBrushEditorBase.OnPaintSceneGUIInternal(layoutGrid, brushTarget, brushBounds
, EditModeToBrushTool(EditMode.editMode), m_MarqueeStart.HasValue || executing);
}
}
void OnEnable()
{
//Hide Unity's Handles
LastTool = Tools.current;
Tools.current = Tool.None;
//Hide WireFrame
gridObject = (Grid)target;
EditorUtility.SetSelectedWireframeHidden(gridObject.gameObject.GetComponent <Renderer>(), true);
if (!EditorApplication.isPlaying)
{
if (gridObject.GetComponent <MeshFilter>().sharedMesh == null)
{
gridObject.X = 0;
gridObject.Z = 0;
GridEditorUtility.NewGrid(target);
GridEditorUtility.UpdateGridMesh(target);
}
GridEditorUtility.vertices = gridObject.GetComponent <MeshFilter>().sharedMesh.vertices;
}
//Editor Serialized Properties
grid = new SerializedObject(target);
X = grid.FindProperty("X");
Z = grid.FindProperty("Z");
snap = grid.FindProperty("snap");
}
internal static void OnPaintSceneGUIInternal(GridLayout gridLayout, GameObject brushTarget, BoundsInt position, GridBrushBase.Tool tool, bool executing)
{
if (Event.current.type == EventType.Repaint)
{
Color color = Color.white;
if (tool == GridBrushBase.Tool.Pick && executing)
{
color = Color.cyan;
}
if (tool == GridBrushBase.Tool.Paint && executing)
{
color = Color.yellow;
}
if (tool == GridBrushBase.Tool.Select || tool == GridBrushBase.Tool.Move)
{
if (executing)
{
color = GridBrushEditorBase.Styles.executingColor;
}
else if (GridSelection.active)
{
color = GridBrushEditorBase.Styles.activeColor;
}
}
GridEditorUtility.DrawGridMarquee(gridLayout, position, color);
}
}
private void CallOnPaintSceneGUI()
{
bool flag = GridSelection.active && GridSelection.target == this.brushTarget;
if (flag || !(GridPaintingState.activeGrid != this))
{
RectInt marqueeRect = new RectInt(base.mouseGridPosition, new Vector2Int(1, 1));
if (this.m_MarqueeStart.HasValue)
{
marqueeRect = GridEditorUtility.GetMarqueeRect(base.mouseGridPosition, this.m_MarqueeStart.Value);
}
else if (flag)
{
marqueeRect = new RectInt(GridSelection.position.xMin, GridSelection.position.yMin, GridSelection.position.size.x, GridSelection.position.size.y);
}
GridLayout gridLayout = (!(this.tilemap != null)) ? this.grid : this.tilemap;
if (GridPaintingState.activeBrushEditor != null)
{
GridPaintingState.activeBrushEditor.OnPaintSceneGUI(gridLayout, this.brushTarget, new BoundsInt(new Vector3Int(marqueeRect.x, marqueeRect.y, 0), new Vector3Int(marqueeRect.width, marqueeRect.height, 1)), PaintableGrid.EditModeToBrushTool(EditMode.editMode), this.m_MarqueeStart.HasValue || base.executing);
}
else
{
GridBrushEditorBase.OnPaintSceneGUIInternal(gridLayout, this.brushTarget, new BoundsInt(new Vector3Int(marqueeRect.x, marqueeRect.y, 0), new Vector3Int(marqueeRect.width, marqueeRect.height, 1)), PaintableGrid.EditModeToBrushTool(EditMode.editMode), this.m_MarqueeStart.HasValue || base.executing);
}
}
}
public static RectInt GetBounds(GameObject palette)
{
RectInt result;
if (palette == null)
{
result = default(RectInt);
}
else
{
Vector2Int p = new Vector2Int(2147483647, 2147483647);
Vector2Int p2 = new Vector2Int(-2147483648, -2147483648);
Tilemap[] componentsInChildren = palette.GetComponentsInChildren <Tilemap>();
for (int i = 0; i < componentsInChildren.Length; i++)
{
Tilemap tilemap = componentsInChildren[i];
Vector3Int editorPreviewOrigin = tilemap.editorPreviewOrigin;
Vector3Int vector3Int = editorPreviewOrigin + tilemap.editorPreviewSize;
Vector2Int vector2Int = new Vector2Int(Mathf.Min(editorPreviewOrigin.x, vector3Int.x), Mathf.Min(editorPreviewOrigin.y, vector3Int.y));
Vector2Int vector2Int2 = new Vector2Int(Mathf.Max(editorPreviewOrigin.x, vector3Int.x), Mathf.Max(editorPreviewOrigin.y, vector3Int.y));
p = new Vector2Int(Mathf.Min(p.x, vector2Int.x), Mathf.Min(p.y, vector2Int.y));
p2 = new Vector2Int(Mathf.Max(p2.x, vector2Int2.x), Mathf.Max(p2.y, vector2Int2.y));
}
result = GridEditorUtility.GetMarqueeRect(p, p2);
}
return(result);
}
void UpdateDragBox()
{
int ID = GUIUtility.GetControlID(hash, FocusType.Passive);
switch (Event.current.GetTypeForControl(ID))
{
case EventType.Layout:
HandleUtility.AddDefaultControl(ID);
break;
case EventType.MouseDown:
if (Event.current.button == 0 && HandleUtility.nearestControl == ID)
{
GridEditorUtility.MousePos0 = Camera.current.ScreenToViewportPoint(Event.current.mousePosition);
GridEditorUtility.MousePos0.y = 1f - GridEditorUtility.MousePos0.y;
GridEditorUtility.IsMouseDown = true;
GUIUtility.hotControl = ID;
Event.current.Use();
EditorGUIUtility.SetWantsMouseJumping(1);
}
break;
case EventType.MouseDrag:
if (Event.current.button == 0)
{
GUI.changed = true;
Event.current.Use();
}
break;
case EventType.MouseUp:
if (Event.current.button == 0)
{
GridEditorUtility.MousePosF = Camera.current.ScreenToViewportPoint(Event.current.mousePosition);
GridEditorUtility.MousePosF.y = 1f - GridEditorUtility.MousePosF.y;
GridEditorUtility.DragSelecting(target);
GridEditorUtility.IsMouseDown = false;
if (GUIUtility.hotControl == ID)
{
GUIUtility.hotControl = 0;
Event.current.Use();
EditorGUIUtility.SetWantsMouseJumping(0);
}
}
break;
case EventType.Repaint:
if (GridEditorUtility.IsMouseDown)
{
DrawDragBox();
}
break;
}
}
public void GetMarqueeBounds_SamePoint()
{
var point = new Vector3Int(5, -4, 6);
var marquee = GridEditorUtility.GetMarqueeBounds(point, point);
Assert.AreEqual(new BoundsInt(5, -4, 6, 1, 1, 1), marquee);
}
public void GetMarqueeRect_SamePoint()
{
var point = new Vector2Int(5, -4);
var marquee = GridEditorUtility.GetMarqueeRect(point, point);
Assert.AreEqual(new RectInt(5, -4, 1, 1), marquee);
}
void ChangeEditionType(int EditionType, Object target)
{
Grid grid = (Grid)target;
GUIUtility.hotControl = 0;
GridEditorUtility.DeselectAll();
grid.EditionType = EditionType;
}
private void RenderGrid()
{
if (this.m_GridMesh == null && this.grid.cellLayout == GridLayout.CellLayout.Rectangle)
{
this.m_GridMesh = GridEditorUtility.GenerateCachedGridMesh(this.grid, GridPaintPaletteClipboard.k_GridColor, 1f / this.LocalToScreenRatio(), this.paddedBoundsInt, MeshTopology.Quads);
}
GridEditorUtility.DrawGridGizmo(this.grid, this.grid.transform, GridPaintPaletteClipboard.k_GridColor, ref this.m_GridMesh, ref this.m_GridMaterial);
}
private void HandleBrushPicking()
{
Event evt = Event.current;
if (evt.type == EventType.MouseDown && IsPickingEvent(evt) && !isHotControl)
{
m_ModeBeforePicking = EditMode.SceneViewEditMode.GridPainting;
if (inEditMode && EditMode.editMode != EditMode.SceneViewEditMode.GridPicking)
{
m_ModeBeforePicking = EditMode.editMode;
EditMode.ChangeEditMode(EditMode.SceneViewEditMode.GridPicking, GridPaintingState.instance);
}
m_MarqueeStart = mouseGridPosition;
m_MarqueeType = MarqueeType.Pick;
s_LastActivePaintableGrid = this;
Event.current.Use();
GUI.changed = true;
GUIUtility.hotControl = m_PermanentControlID;
OnBrushPickStarted();
}
if (evt.type == EventType.MouseDrag && isHotControl && m_MarqueeStart.HasValue && m_MarqueeType == MarqueeType.Pick && IsPickingEvent(evt))
{
RectInt rect = GridEditorUtility.GetMarqueeRect(m_MarqueeStart.Value, mouseGridPosition);
OnBrushPickDragged(new BoundsInt(new Vector3Int(rect.xMin, rect.yMin, 0), new Vector3Int(rect.size.x, rect.size.y, 1)));
Event.current.Use();
GUI.changed = true;
}
if (evt.rawType == EventType.MouseUp && isHotControl && m_MarqueeStart.HasValue && m_MarqueeType == MarqueeType.Pick && IsPickingEvent(evt))
{
// Check if event only occurred in the PaintableGrid window as evt.type will filter for this
if (evt.type == EventType.MouseUp && m_MarqueeType == MarqueeType.Pick)
{
RectInt rect = GridEditorUtility.GetMarqueeRect(m_MarqueeStart.Value, mouseGridPosition);
Vector2Int pivot = GetMarqueePivot(m_MarqueeStart.Value, mouseGridPosition);
PickBrush(new BoundsInt(new Vector3Int(rect.xMin, rect.yMin, 0), new Vector3Int(rect.size.x, rect.size.y, 1)), new Vector3Int(pivot.x, pivot.y, 0));
if (inEditMode && EditMode.editMode != m_ModeBeforePicking)
{
EditMode.ChangeEditMode(m_ModeBeforePicking, GridPaintingState.instance);
}
GridPaletteBrushes.ActiveGridBrushAssetChanged();
s_LastActivePaintableGrid = this;
Event.current.Use();
GUI.changed = true;
}
else
// Event occurred outside of PaintableGrid window, cancel the pick event
{
OnBrushPickCancelled();
}
m_MarqueeType = MarqueeType.None;
m_MarqueeStart = null;
GUIUtility.hotControl = 0;
InspectorWindow.RepaintAllInspectors();
}
}
public void GetMarqueeBounds_AlternatePoints()
{
var xPoint = new Vector3Int(5, -4, 5);
var yPoint = new Vector3Int(-4, 5, -4);
var marquee = GridEditorUtility.GetMarqueeBounds(xPoint, yPoint);
Assert.AreEqual(new BoundsInt(-4, -4, -4, 10, 10, 10), marquee);
}
private static void DrawGrid(GridLayout gridLayout)
{
if (SceneViewGridManager.sceneViewGridComponentGizmo.Color != SceneViewGridManager.s_LastGridProxyColor)
{
SceneViewGridManager.FlushCachedGridProxy();
SceneViewGridManager.s_LastGridProxyColor = SceneViewGridManager.sceneViewGridComponentGizmo.Color;
}
GridEditorUtility.DrawGridGizmo(gridLayout, gridLayout.transform, SceneViewGridManager.s_LastGridProxyColor, ref SceneViewGridManager.s_GridProxyMesh, ref SceneViewGridManager.s_GridProxyMaterial);
}
public void GetPointsOnLine_DiagonalLine_PointCountCorrect()
{
var startPoint = Vector2Int.zero;
var endPoint = new Vector2Int(5, 5);
var count = GridEditorUtility.GetPointsOnLine(startPoint, endPoint).Count();
Assert.AreEqual(endPoint.y - startPoint.x + 1, count);
}
public void GetMarqueeBounds_MinMaxPoints()
{
var minPoint = Vector3Int.one * -4;
var maxPoint = Vector3Int.one * 4;
var marquee = GridEditorUtility.GetMarqueeBounds(minPoint, maxPoint);
Assert.AreEqual(new BoundsInt(-4, -4, -4, 9, 9, 9), marquee);
}
private static void DrawGrid(GridLayout gridLayout)
{
if (sceneViewGridComponentGizmo.Color != s_LastGridProxyColor)
{
FlushCachedGridProxy();
s_LastGridProxyColor = sceneViewGridComponentGizmo.Color;
}
GridEditorUtility.DrawGridGizmo(gridLayout, gridLayout.transform, s_LastGridProxyColor, ref s_GridProxyMesh, ref s_GridProxyMaterial);
}
public void GetMarqueeRect_MinMaxPoints()
{
var minPoint = Vector2Int.one * -4;
var maxPoint = Vector2Int.one * 4;
var marquee = GridEditorUtility.GetMarqueeRect(minPoint, maxPoint);
Assert.AreEqual(new RectInt(-4, -4, 9, 9), marquee);
}
public void ClampToGrid_PointInGridIsSame()
{
var point = new Vector3Int(1, 2, 3);
var gridOrigin = Vector2Int.zero;
var gridSize = Vector2Int.one * 4;
var clampedPoint = GridEditorUtility.ClampToGrid(point, gridOrigin, gridSize);
Assert.AreEqual(point, clampedPoint);
}
private void RenderDragAndDropPreview()
{
if (this.activeDragAndDrop && this.m_HoverData != null && this.m_HoverData.Count != 0)
{
RectInt minMaxRect = TileDragAndDrop.GetMinMaxRect(this.m_HoverData.Keys.ToList <Vector2Int>());
minMaxRect.position += base.mouseGridPosition;
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
GridEditorUtility.DrawGridMarquee(this.grid, new BoundsInt(new Vector3Int(minMaxRect.xMin, minMaxRect.yMin, 0), new Vector3Int(minMaxRect.width, minMaxRect.height, 1)), Color.white);
}
}
public void ClampToGrid_NegativePointOutsideGridIsClamped()
{
var point = new Vector3Int(-1, 2, 3);
var gridOrigin = Vector2Int.zero;
var gridSize = Vector2Int.one * 4;
var clampedPoint = GridEditorUtility.ClampToGrid(point, gridOrigin, gridSize);
Assert.AreEqual(new Vector3Int(0, 2, 3), clampedPoint);
}
private void RenderGrid()
{
// MeshTopology.Lines doesn't give nice pixel perfect grid so we have to have separate codepath with MeshTopology.Quads specially for palette window here
if (m_GridMesh == null && grid.cellLayout == Grid.CellLayout.Rectangle)
{
m_GridMesh = GridEditorUtility.GenerateCachedGridMesh(grid, k_GridColor, 1f / LocalToScreenRatio(), paddedBoundsInt, MeshTopology.Quads);
}
GridEditorUtility.DrawGridGizmo(grid, grid.transform, k_GridColor, ref m_GridMesh, ref m_GridMaterial);
}
private static void DrawGrid(GridLayout gridLayout)
{
int gridHash = GenerateHash(gridLayout, sceneViewGridComponentGizmo.Color);
if (s_LastGridProxyHash != gridHash)
{
FlushCachedGridProxy();
s_LastGridProxyHash = gridHash;
}
GridEditorUtility.DrawGridGizmo(gridLayout, gridLayout.transform, sceneViewGridComponentGizmo.Color, ref s_GridProxyMesh, ref s_GridProxyMaterial);
}
protected void DrawSelectionGizmo(RectInt rect)
{
if (Event.current.type == EventType.Repaint && GUI.enabled)
{
Color color = Color.white;
if (base.isPicking)
{
color = Color.cyan;
}
GridEditorUtility.DrawGridMarquee(this.grid, new BoundsInt(new Vector3Int(rect.xMin, rect.yMin, 0), new Vector3Int(rect.width, rect.height, 1)), color);
}
}
public static RectInt GetMinMaxRect(List <Vector2Int> positions)
{
if (positions == null || positions.Count == 0)
{
return(new RectInt());
}
return(GridEditorUtility.GetMarqueeRect(
new Vector2Int(positions.Min(p1 => p1.x), positions.Min(p1 => p1.y)),
new Vector2Int(positions.Max(p1 => p1.x), positions.Max(p1 => p1.y))
));
}
private void RenderDragAndDropPreview()
{
if (!activeDragAndDrop || m_HoverData == null || m_HoverData.Count == 0)
{
return;
}
RectInt rect = TileDragAndDrop.GetMinMaxRect(m_HoverData.Keys.ToList());
rect.position += mouseGridPosition;
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
GridEditorUtility.DrawGridMarquee(grid, new BoundsInt(new Vector3Int(rect.xMin, rect.yMin, 0), new Vector3Int(rect.width, rect.height, 1)), Color.white);
}
public static RectInt GetMinMaxRect(List <Vector2Int> positions)
{
RectInt result;
if (positions == null || positions.Count == 0)
{
result = default(RectInt);
}
else
{
result = GridEditorUtility.GetMarqueeRect(new Vector2Int(positions.Min((Vector2Int p1) => p1.x), positions.Min((Vector2Int p1) => p1.y)), new Vector2Int(positions.Max((Vector2Int p1) => p1.x), positions.Max((Vector2Int p1) => p1.y)));
}
return(result);
}
private void HandleBrushPicking()
{
Event current = Event.current;
if (current.type == EventType.MouseDown && this.IsPickingEvent(current) && !this.isHotControl)
{
this.m_ModeBeforePicking = EditMode.SceneViewEditMode.GridPainting;
if (this.inEditMode && EditMode.editMode != EditMode.SceneViewEditMode.GridPicking)
{
this.m_ModeBeforePicking = EditMode.editMode;
EditMode.ChangeEditMode(EditMode.SceneViewEditMode.GridPicking, ScriptableSingleton <GridPaintingState> .instance);
}
this.m_MarqueeStart = new Vector2Int?(this.mouseGridPosition);
this.m_MarqueeType = PaintableGrid.MarqueeType.Pick;
PaintableGrid.s_LastActivePaintableGrid = this;
Event.current.Use();
GUI.changed = true;
GUIUtility.hotControl = this.m_PermanentControlID;
this.OnBrushPickStarted();
}
if (current.type == EventType.MouseDrag && this.isHotControl && this.m_MarqueeStart.HasValue && this.m_MarqueeType == PaintableGrid.MarqueeType.Pick && this.IsPickingEvent(current))
{
RectInt marqueeRect = GridEditorUtility.GetMarqueeRect(this.m_MarqueeStart.Value, this.mouseGridPosition);
this.OnBrushPickDragged(new BoundsInt(new Vector3Int(marqueeRect.xMin, marqueeRect.yMin, 0), new Vector3Int(marqueeRect.size.x, marqueeRect.size.y, 1)));
Event.current.Use();
GUI.changed = true;
}
if (current.type == EventType.MouseUp && this.m_MarqueeStart.HasValue && this.m_MarqueeType == PaintableGrid.MarqueeType.Pick && this.IsPickingEvent(current))
{
RectInt marqueeRect2 = GridEditorUtility.GetMarqueeRect(this.m_MarqueeStart.Value, this.mouseGridPosition);
if (this.isHotControl)
{
Vector2Int marqueePivot = this.GetMarqueePivot(this.m_MarqueeStart.Value, this.mouseGridPosition);
this.PickBrush(new BoundsInt(new Vector3Int(marqueeRect2.xMin, marqueeRect2.yMin, 0), new Vector3Int(marqueeRect2.size.x, marqueeRect2.size.y, 1)), new Vector3Int(marqueePivot.x, marqueePivot.y, 0));
if (this.inEditMode && EditMode.editMode != this.m_ModeBeforePicking)
{
EditMode.ChangeEditMode(this.m_ModeBeforePicking, ScriptableSingleton <GridPaintingState> .instance);
}
GridPaletteBrushes.ActiveGridBrushAssetChanged();
PaintableGrid.s_LastActivePaintableGrid = this;
InspectorWindow.RepaintAllInspectors();
Event.current.Use();
GUI.changed = true;
GUIUtility.hotControl = 0;
}
this.m_MarqueeType = PaintableGrid.MarqueeType.None;
this.m_MarqueeStart = null;
}
}
protected override Vector2Int ScreenToGrid(Vector2 screenPosition)
{
if (tilemap != null)
{
var transform = tilemap.transform;
Vector3 forward = tilemap.orientationMatrix.MultiplyVector(transform.forward) * -1f;
Plane plane = new Plane(forward, transform.position);
Vector3Int cell = LocalToGrid(tilemap, GridEditorUtility.ScreenToLocal(transform, screenPosition, plane));
return(new Vector2Int(cell.x, cell.y));
}
if (grid)
{
Vector3Int cell = LocalToGrid(grid, GridEditorUtility.ScreenToLocal(gridTransform, screenPosition, GetGridPlane(grid)));
return(new Vector2Int(cell.x, cell.y));
}
return(Vector2Int.zero);
}
private void HandleBoxTool()
{
Event evt = Event.current;
if (evt.type == EventType.MouseDown && evt.button == 0 && !evt.alt && EditMode.editMode == EditMode.SceneViewEditMode.GridBox)
{
m_MarqueeStart = mouseGridPosition;
m_MarqueeType = MarqueeType.Box;
Event.current.Use();
GUI.changed = true;
executing = true;
GUIUtility.hotControl = m_PermanentControlID;
}
if (evt.type == EventType.MouseDrag && evt.button == 0 && EditMode.editMode == EditMode.SceneViewEditMode.GridBox)
{
if (isHotControl && m_MarqueeStart.HasValue)
{
Event.current.Use();
executing = true;
GUI.changed = true;
}
}
if (evt.type == EventType.MouseUp && evt.button == 0 && EditMode.editMode == EditMode.SceneViewEditMode.GridBox)
{
if (isHotControl && m_MarqueeStart.HasValue)
{
RegisterUndo();
RectInt rect = GridEditorUtility.GetMarqueeRect(m_MarqueeStart.Value, mouseGridPosition);
if (evt.shift)
{
BoxErase(new BoundsInt(rect.x, rect.y, 0, rect.size.x, rect.size.y, 1));
}
else
{
BoxFill(new BoundsInt(rect.x, rect.y, 0, rect.size.x, rect.size.y, 1));
}
Event.current.Use();
executing = false;
GUI.changed = true;
GUIUtility.hotControl = 0;
}
m_MarqueeStart = null;
m_MarqueeType = MarqueeType.None;
}
}
private void HandleBoxTool()
{
Event current = Event.current;
if (current.type == EventType.MouseDown && current.button == 0 && !current.alt && EditMode.editMode == EditMode.SceneViewEditMode.GridBox)
{
this.m_MarqueeStart = new Vector2Int?(this.mouseGridPosition);
this.m_MarqueeType = PaintableGrid.MarqueeType.Box;
Event.current.Use();
GUI.changed = true;
this.executing = true;
GUIUtility.hotControl = this.m_PermanentControlID;
}
if (current.type == EventType.MouseDrag && current.button == 0 && EditMode.editMode == EditMode.SceneViewEditMode.GridBox)
{
if (this.isHotControl && this.m_MarqueeStart.HasValue)
{
Event.current.Use();
this.executing = true;
GUI.changed = true;
}
}
if (current.type == EventType.MouseUp && current.button == 0 && EditMode.editMode == EditMode.SceneViewEditMode.GridBox)
{
if (this.isHotControl && this.m_MarqueeStart.HasValue)
{
this.RegisterUndo();
RectInt marqueeRect = GridEditorUtility.GetMarqueeRect(this.m_MarqueeStart.Value, this.mouseGridPosition);
if (current.shift)
{
this.BoxErase(new BoundsInt(marqueeRect.x, marqueeRect.y, 0, marqueeRect.size.x, marqueeRect.size.y, 1));
}
else
{
this.BoxFill(new BoundsInt(marqueeRect.x, marqueeRect.y, 0, marqueeRect.size.x, marqueeRect.size.y, 1));
}
Event.current.Use();
this.executing = false;
GUI.changed = true;
GUIUtility.hotControl = 0;
}
this.m_MarqueeStart = null;
this.m_MarqueeType = PaintableGrid.MarqueeType.None;
}
}
