private bool DrawBoxSelection()
{
if (viewModel.PreviousModelFactory == null)
{
return(false);
}
NPVoxModel previousTransformedModel = viewModel.PreviousModelFactory.GetProduct();
NPVoxToUnity npVoxToUnity = new NPVoxToUnity(previousTransformedModel, viewModel.Animation.MeshFactory.VoxelSize);
List <NPVoxBox> boxes = viewModel.GetNonEditableBoxes();
if (boxes != null)
{
foreach (NPVoxBox b in boxes)
{
NPVoxHandles.DrawBoxSelection(npVoxToUnity, b, false);
}
}
if (!viewModel.IsAreaSelectionActive())
{
return(false);
}
NPVoxBox box = viewModel.GetAffectedBox();
if (Event.current.shift)
{
// affected area picker
NPVoxCoord someCoord = box.RoundedCenter;
NPVoxCoord someNewCoord = NPVoxHandles.VoxelPicker(new NPVoxToUnity(previousTransformedModel, viewModel.Animation.MeshFactory.VoxelSize), someCoord, 0, ((NPVoxAnimationEditorSession)target).previewFilter.transform);
if (!someCoord.Equals(someNewCoord))
{
viewModel.ChangeAffectedBox(new NPVoxBox(someNewCoord, someNewCoord));
}
}
else
{
// affected area box
NPVoxBox newBox = NPVoxHandles.DrawBoxSelection(npVoxToUnity, box);
if (!newBox.Equals(box))
{
viewModel.ChangeAffectedBox(newBox);
}
}
return(true);
}
private bool DrawBoneSelection()
{
if (viewModel.PreviousModelFactory == null)
{
return(false);
}
NPVoxBoneModel previewModel = viewModel.EditorModelFactory.GetProduct() as NPVoxBoneModel;
if (previewModel == null)
{
return(false);
}
if (!viewModel.IsBoneSelectionActive())
{
return(false);
}
NPVoxToUnity npVoxToUnity = new NPVoxToUnity(previewModel, viewModel.Animation.MeshFactory.VoxelSize);
// affected area picker
if (Event.current.isMouse && Event.current.type == EventType.MouseDown && Event.current.button == 0)
{
// NPVoxCoord someCoord = NPVoxCoord.INVALID;
float mouseScale = NPVoxHandles.GetMouseScale(SceneView.currentDrawingSceneView.camera);
Camera cam = SceneView.currentDrawingSceneView.camera;
Ray r = SceneView.currentDrawingSceneView.camera.ScreenPointToRay(
new Vector3(Event.current.mousePosition.x * mouseScale, -Event.current.mousePosition.y * mouseScale + Camera.current.pixelHeight)
);
NPVoxRayCastHit raycastHit = npVoxToUnity.Raycast(r, ((NPVoxAnimationEditorSession)target).previewFilter.transform, 20);
if (raycastHit.IsHit)
{
uint boneMask = previewModel.GetBoneMask(raycastHit.Coord);
if (boneMask != 0)
{
if (Event.current.control || Event.current.command)
{
viewModel.ToggleBoneMask(boneMask, Event.current.shift);
}
else
{
viewModel.SetBoneMask(boneMask, Event.current.shift);
}
}
}
}
return(true);
}
public static Bounds DrawBoundsSelection(Bounds previous, Vector3 cellOffset, float cellSize)
{
NPVoxToUnity npVoxToUnity = new NPVoxToUnity(null, Vector3.one * cellSize, cellOffset - Vector3.one * 0.5f * cellSize);
NPVoxBox previousBox = new NPVoxBox(
npVoxToUnity.ToVoxCoord(previous.min + Vector3.one * cellSize / 2),
npVoxToUnity.ToVoxCoord(previous.max - Vector3.one * cellSize / 2)
);
NPVoxBox newBox = NPVoxHandles.DrawBoxSelection(npVoxToUnity, previousBox, true);
if (!previousBox.Equals(newBox))
{
Bounds bounds = new Bounds(Vector3.zero, Vector3.zero);
bounds.SetMinMax(
npVoxToUnity.ToUnityPosition(newBox.LeftDownBack) - Vector3.one * cellSize / 2,
npVoxToUnity.ToUnityPosition(newBox.RightUpForward) + Vector3.one * cellSize / 2
);
return(bounds);
}
else
{
return(previous);
}
}
public System.Func <NPVoxISceneEditable, bool> DrawSceneTool(NPVoxToUnity npVoxToUnity, Transform transform, int tool)
{
if (Input == null)
{
return(null);
}
NPVoxModel model = ((NPVoxIModelFactory)Input).GetProduct() as NPVoxModel;
if (!model)
{
return(null);
}
// Start Coord 1
if (tool == 0)
{
NPVoxCoord someNewCoord = NPVoxHandles.VoxelPicker(npVoxToUnity, startCoord1, 0, transform);
if (!startCoord1.Equals(someNewCoord))
{
return((NPVoxISceneEditable t) =>
{
(t as NPVoxTrailAttacher).startCoord1 = someNewCoord;
return true;
});
}
}
// Start Coord 2
if (tool == 1)
{
NPVoxCoord someNewCoord = NPVoxHandles.VoxelPicker(npVoxToUnity, startCoord2, 0, transform);
if (!startCoord2.Equals(someNewCoord))
{
return((NPVoxISceneEditable t) =>
{
(t as NPVoxTrailAttacher).startCoord2 = someNewCoord;
return true;
});
}
}
// Direction 1
if (tool == 2)
{
Quaternion newQuaternion = Handles.RotationHandle(rotation1, npVoxToUnity.ToUnityPosition(startCoord1));
if (!newQuaternion.Equals(rotation1))
{
return((NPVoxISceneEditable t) =>
{
(t as NPVoxTrailAttacher).rotation1 = newQuaternion;
return true;
});
}
}
// Direction 2
if (tool == 3)
{
Quaternion newQuaternion = Handles.RotationHandle(rotation2, npVoxToUnity.ToUnityPosition(startCoord2));
if (!newQuaternion.Equals(rotation2))
{
return((NPVoxISceneEditable t) =>
{
(t as NPVoxTrailAttacher).rotation2 = newQuaternion;
return true;
});
}
}
return(null);
}
private void MouseInput()
{
int controlID = GUIUtility.GetControlID(FocusType.Passive);
EventType eventType = Event.current.GetTypeForControl(controlID);
Event e = Event.current;
float mouseScale = NPVoxHandles.GetMouseScale(SceneView.currentDrawingSceneView.camera);
Ray r = Camera.current.ScreenPointToRay(new Vector3(Event.current.mousePosition.x * mouseScale, -Event.current.mousePosition.y * mouseScale + Camera.current.pixelHeight));
bool bShiftHeld = e.shift;
bool bAltHeld = e.alt;
bool bCtrlHeld = e.control;
if (Event.current.mousePosition.y < TOOLBAR_HEIGHT)
{
// allow to click the buttons always
return;
}
// if (viewModel.CurrentTool == GNBlockMapEditorVM.Tool.ERASE)
if (inputController.IsErasingActive())
{
Handles.color = new Color(128, 0, 0, 0.25f);
Handles.CubeCap(controlID, viewModel.CurrentCell, Quaternion.identity, viewModel.CellSize);
}
if (inputController.IsPrefabNavigationActive())
{
Handles.color = new Color(128, 128, 0, 0.05f);
Handles.CubeCap(controlID, viewModel.CurrentCell, Quaternion.identity, viewModel.CellSize);
}
if (inputController.IsPickingActive())
{
Handles.color = new Color(128, 128, 0, 0.25f);
Handles.CubeCap(controlID, viewModel.CurrentCell, Quaternion.identity, viewModel.CellSize);
}
if (inputController.IsRotationActive())
{
Handles.color = new Color(0, 128, 0, 0.05f);
Handles.CubeCap(controlID, viewModel.CurrentCell, Quaternion.identity, viewModel.CellSize);
}
switch (eventType)
{
case EventType.Layout:
if (inputController.TakeEvents())
{
HandleUtility.AddControl(
controlID,
HandleUtility.DistanceToCircle(r.origin, 10f)
);
}
break;
case EventType.MouseDown:
if (HandleUtility.nearestControl == controlID && e.button == 0)
{
GUIUtility.hotControl = controlID;
if (inputController.MouseDown(e))
{
e.Use();
SceneView.RepaintAll();
}
}
break;
case EventType.MouseUp:
if (GUIUtility.hotControl == controlID)
{
GUI.changed = true;
GUIUtility.hotControl = 0;
e.Use();
}
break;
case EventType.MouseDrag:
if (GUIUtility.hotControl == controlID)
{
if (inputController.MouseDrag(RayCast(r)))
{
e.Use();
SceneView.RepaintAll();
}
}
break;
case EventType.ScrollWheel:
if (inputController.WheelScrolled(e.delta, bShiftHeld, bAltHeld, bCtrlHeld))
{
e.Use();
if (inputController.MouseMoved(RayCast(r)))
{
}
SceneView.RepaintAll();
}
break;
case EventType.MouseMove:
if (inputController.MouseMoved(RayCast(r)))
{
e.Use();
SceneView.RepaintAll();
}
break;
}
}
public void OnSceneGUI()
{
if (!m_bActive)
{
return;
}
if (viewModel.CurrentTool == GNBlockMapEditorVM.Tool.BOX)
{
if (viewModel.SelectBox(GNHandles.DrawBoundsSelection(viewModel.SelectedBox, viewModel.CellOffset, viewModel.CellSize)))
{
// SceneView.RepaintAll();
}
}
else
{
MouseInput();
}
KeyboardInput();
KeyboardShortcuts();
GUILayout.BeginArea(new Rect(0, 0, 880, 100));
EditorGUILayout.BeginVertical();
{
EditorGUILayout.BeginHorizontal();
{
DrawToolbar();
DrawCameraToolbar();
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
{
DrawPaintMode();
EditorGUILayout.BeginVertical();
DrawShowLayerMode();
if (viewModel.CurrentTool == GNBlockMapEditorVM.Tool.BOX)
{
DrawBoxTools();
}
EditorGUILayout.EndVertical();
}
EditorGUILayout.EndHorizontal();
}
EditorGUILayout.EndVertical();
GUILayout.EndArea();
if (inputController.IsPickingActive())
{
GUILayout.BeginArea(new Rect(10, 100, 400, 100));
GUILayout.Label("Tile Info: " + viewModel.GetTileInfo(), EditorStyles.whiteLargeLabel);
GUILayout.EndArea();
}
if (Event.current.type == EventType.Layout)
{
screenScale = NPVoxHandles.GetScreenScale();
}
GUILayout.BeginArea(new Rect(10, Screen.height * screenScale - 70, 400, 100));
EditorGUILayout.BeginHorizontal();
GUILayout.Label("CellSize: " + viewModel.CellSize, EditorStyles.whiteLargeLabel);
GUILayout.Label("CellOffset: " + viewModel.CellOffset, EditorStyles.whiteLargeLabel);
GUILayout.Label("Cell: " + viewModel.CurrentCell, EditorStyles.whiteLargeLabel);
// GUILayout.Label("Brush: " + viewModel.CurrentPrefabPath, EditorStyles.whiteLargeLabel);
EditorGUILayout.EndHorizontal();
GUILayout.EndArea();
GUILayout.BeginArea(new Rect(Screen.width * screenScale - 350, Screen.height * screenScale - 240, 300, 200));
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
GUILayout.BeginVertical();
GUILayout.FlexibleSpace();
GUILayout.Label(inputController.GetCurrentToolInfo(), EditorStyles.whiteLargeLabel);
GUILayout.EndVertical();
GUILayout.EndHorizontal();
GUILayout.EndArea();
Selection.activeGameObject = ((MonoBehaviour)target).gameObject;
DrawZIndicator(screenScale);
}
public static NPVoxBox DrawBoxSelection(NPVoxToUnity npVoxToUnity, NPVoxBox box, bool editable = true)
{
Vector3 leftDownBack = npVoxToUnity.ToUnityPosition(box.LeftDownBack) - npVoxToUnity.VoxeSize * 0.5f;
Vector3 rightUpForward = npVoxToUnity.ToUnityPosition(box.RightUpForward) + npVoxToUnity.VoxeSize * 0.5f;
Vector3 rightDownBack = new Vector3(rightUpForward.x, leftDownBack.y, leftDownBack.z);
Vector3 leftUpBack = new Vector3(leftDownBack.x, rightUpForward.y, leftDownBack.z);
Vector3 rightUpBack = new Vector3(rightUpForward.x, rightUpForward.y, leftDownBack.z);
Vector3 leftDownForward = new Vector3(leftDownBack.x, leftDownBack.y, rightUpForward.z);
Vector3 rightDownForward = new Vector3(rightUpForward.x, leftDownBack.y, rightUpForward.z);
Vector3 leftUpForward = new Vector3(leftDownBack.x, rightUpForward.y, rightUpForward.z);
Handles.DrawDottedLine(leftDownBack, rightDownBack, 1f);
Handles.DrawDottedLine(leftDownBack, leftUpBack, 1f);
Handles.DrawDottedLine(leftUpBack, rightUpBack, 1f);
Handles.DrawDottedLine(rightDownBack, rightUpBack, 1f);
Handles.DrawDottedLine(leftDownForward, rightDownForward, 1f);
Handles.DrawDottedLine(leftDownForward, leftUpForward, 1f);
Handles.DrawDottedLine(leftUpForward, rightUpForward, 1f);
Handles.DrawDottedLine(rightDownForward, rightUpForward, 1f);
Handles.DrawDottedLine(leftDownBack, leftDownForward, 1f);
Handles.DrawDottedLine(rightDownBack, rightDownForward, 1f);
Handles.DrawDottedLine(leftUpBack, leftUpForward, 1f);
Handles.DrawDottedLine(rightUpBack, rightUpForward, 1f);
if (!editable)
{
return(box);
}
NPVoxBox newBox = new NPVoxBox(box.LeftDownBack, box.RightUpForward);
if (SceneView.currentDrawingSceneView.camera.orthographic)
{
NPVoxCoord oldCoord;
NPVoxCoord newCoord;
oldCoord = box.LeftDownBack;
newCoord = NPVoxHandles.DrawVoxelHandle(leftDownBack, oldCoord, npVoxToUnity);
if (!newCoord.Equals(oldCoord))
{
newBox.LeftDownBack = newCoord;
}
oldCoord = box.RightDownBack;
newCoord = NPVoxHandles.DrawVoxelHandle(rightDownBack, oldCoord, npVoxToUnity);
if (!newCoord.Equals(oldCoord))
{
newBox.RightDownBack = newCoord;
}
oldCoord = box.LeftUpBack;
newCoord = NPVoxHandles.DrawVoxelHandle(leftUpBack, oldCoord, npVoxToUnity);
if (!newCoord.Equals(oldCoord))
{
newBox.LeftUpBack = newCoord;
}
oldCoord = box.RightUpBack;
newCoord = NPVoxHandles.DrawVoxelHandle(rightUpBack, oldCoord, npVoxToUnity);
if (!newCoord.Equals(oldCoord))
{
newBox.RightUpBack = newCoord;
}
oldCoord = box.LeftDownForward;
newCoord = NPVoxHandles.DrawVoxelHandle(leftDownForward, oldCoord, npVoxToUnity);
if (!newCoord.Equals(oldCoord))
{
newBox.LeftDownForward = newCoord;
}
oldCoord = box.RightDownForward;
newCoord = NPVoxHandles.DrawVoxelHandle(rightDownForward, oldCoord, npVoxToUnity);
if (!newCoord.Equals(oldCoord))
{
newBox.RightDownForward = newCoord;
}
oldCoord = box.LeftUpForward;
newCoord = NPVoxHandles.DrawVoxelHandle(leftUpForward, oldCoord, npVoxToUnity);
if (!newCoord.Equals(oldCoord))
{
newBox.LeftUpForward = newCoord;
}
oldCoord = box.RightUpForward;
newCoord = NPVoxHandles.DrawVoxelHandle(rightUpForward, oldCoord, npVoxToUnity);
if (!newCoord.Equals(oldCoord))
{
newBox.RightUpForward = newCoord;
}
// center mover
oldCoord = box.LeftDownBack;
newCoord = NPVoxHandles.DrawVoxelHandle(npVoxToUnity.ToUnityPosition(box.SaveCenter), oldCoord, npVoxToUnity);
if (!newCoord.Equals(oldCoord))
{
newBox.SaveCenter += NPVoxCoordUtil.ToVector(newCoord - oldCoord);
}
}
else
{
sbyte oldPos;
sbyte newPos;
Vector3 handlePos;
handlePos = new Vector3(leftDownBack.x + (rightUpForward.x - leftDownBack.x) / 2, leftDownBack.y + (rightUpForward.y - leftDownBack.y) / 2, leftDownBack.z);
oldPos = box.Back;
newPos = NPVoxHandles.DrawAxisHandle(handlePos, oldPos, npVoxToUnity, Vector3.forward);
if (oldPos != newPos)
{
newBox.Back = newPos;
}
handlePos = new Vector3(leftDownBack.x + (rightUpForward.x - leftDownBack.x) / 2, leftDownBack.y + (rightUpForward.y - leftDownBack.y) / 2, rightUpForward.z);
oldPos = box.Forward;
newPos = NPVoxHandles.DrawAxisHandle(handlePos, oldPos, npVoxToUnity, Vector3.forward);
if (oldPos != newPos)
{
newBox.Forward = newPos;
}
handlePos = new Vector3(leftDownBack.x + (rightUpForward.x - leftDownBack.x) / 2, leftDownBack.y, leftDownBack.z + (rightUpForward.z - leftDownBack.z) / 2);
oldPos = box.Down;
newPos = NPVoxHandles.DrawAxisHandle(handlePos, oldPos, npVoxToUnity, Vector3.up);
if (oldPos != newPos)
{
newBox.Down = newPos;
}
handlePos = new Vector3(leftDownBack.x + (rightUpForward.x - leftDownBack.x) / 2, rightUpForward.y, leftDownBack.z + (rightUpForward.z - leftDownBack.z) / 2);
oldPos = box.Up;
newPos = NPVoxHandles.DrawAxisHandle(handlePos, oldPos, npVoxToUnity, Vector3.up);
if (oldPos != newPos)
{
newBox.Up = newPos;
}
handlePos = new Vector3(leftDownBack.x, leftDownBack.y + (rightUpForward.y - leftDownBack.y) / 2, leftDownBack.z + (rightUpForward.z - leftDownBack.z) / 2);
oldPos = box.Left;
newPos = NPVoxHandles.DrawAxisHandle(handlePos, oldPos, npVoxToUnity, Vector3.right);
if (oldPos != newPos)
{
newBox.Left = newPos;
}
handlePos = new Vector3(rightUpForward.x, leftDownBack.y + (rightUpForward.y - leftDownBack.y) / 2, leftDownBack.z + (rightUpForward.z - leftDownBack.z) / 2);
oldPos = box.Right;
newPos = NPVoxHandles.DrawAxisHandle(handlePos, oldPos, npVoxToUnity, Vector3.right);
if (oldPos != newPos)
{
newBox.Right = newPos;
}
}
return(newBox);
}
