public override MeshSelection Select(Camera camera, Rect rect, GameObject[] gameObjects, MeshEditorSelectionMode mode)
{
Dictionary <ProBuilderMesh, HashSet <Edge> > pickResult = PBUtility.PickEdges(camera, rect, gameObjects);
if (pickResult.Count == 0)
{
return(null);
}
MeshSelection selection = new MeshSelection();
foreach (KeyValuePair <ProBuilderMesh, HashSet <Edge> > kvp in pickResult)
{
ProBuilderMesh mesh = kvp.Key;
m_edgeSelection.FindCoincidentEdges(mesh);
IList <Edge> edges = m_edgeSelection.GetCoincidentEdges(kvp.Value);
IList <Edge> selected = edges.Where(edge => m_edgeSelection.IsSelected(mesh, edge)).ToArray();
IList <Edge> notSelected = edges.Where(edge => !m_edgeSelection.IsSelected(mesh, edge)).ToArray();
if (mode == MeshEditorSelectionMode.Substract || mode == MeshEditorSelectionMode.Difference)
{
selection.UnselectedEdges.Add(mesh, selected);
m_edgeSelection.Remove(mesh, selected);
}
if (mode == MeshEditorSelectionMode.Add || mode == MeshEditorSelectionMode.Difference)
{
selection.SelectedEdges.Add(mesh, notSelected);
m_edgeSelection.Add(mesh, notSelected);
}
}
return(selection);
}
public override void Hover(Camera camera, Vector3 pointer)
{
if (m_nextUpdate > Time.time)
{
return;
}
m_nextUpdate = Time.time + 0.3f;
if (m_vertexSelection.MeshesCount == 0)
{
return;
}
float result = PBUtility.PickVertex(camera, pointer, 20, null, m_vertexSelection.Meshes, ref m_selection);
if (result != Mathf.Infinity)
{
m_vertexSelection.Hover(m_selection.mesh, m_selection.vertex);
}
else
{
m_vertexSelection.Leave();
}
}
public override MeshSelection Select(Camera camera, Vector3 pointer, bool shift, bool ctrl, bool depthTest)
{
MeshSelection selection = null;
GameObject pickedObject = PBUtility.PickObject(camera, pointer);
float result = PBUtility.PickVertex(camera, pointer, 20, pickedObject, m_vertexSelection.Meshes, depthTest, ref m_selection);
if (result != Mathf.Infinity)
{
if (m_vertexSelection.IsSelected(m_selection.mesh, m_selection.vertex))
{
if (shift)
{
List <int> indices = m_selection.mesh.GetCoincidentVertices(new[] { m_selection.vertex });
m_vertexSelection.Remove(m_selection.mesh, indices);
selection = new MeshSelection();
selection.UnselectedIndices.Add(m_selection.mesh.gameObject, indices);
}
else
{
List <int> indices = m_selection.mesh.GetCoincidentVertices(new[] { m_selection.vertex });
selection = ReadSelection();
selection.UnselectedIndices[m_selection.mesh.gameObject] = selection.UnselectedIndices[m_selection.mesh.gameObject].Where(i => i != m_selection.vertex).ToArray();
selection.SelectedIndices.Add(m_selection.mesh.gameObject, indices);
m_vertexSelection.Clear();
m_vertexSelection.Add(m_selection.mesh, indices);
}
}
else
{
if (shift)
{
selection = new MeshSelection();
}
else
{
selection = ReadSelection();
m_vertexSelection.Clear();
}
List <int> indices = m_selection.mesh.GetCoincidentVertices(new[] { m_selection.vertex });
m_vertexSelection.Add(m_selection.mesh, indices);
selection.SelectedIndices.Add(m_selection.mesh.gameObject, indices);
}
}
else
{
if (!shift)
{
selection = ReadSelection();
if (selection.UnselectedIndices.Count == 0)
{
selection = null;
}
m_vertexSelection.Clear();
}
}
return(selection);
}
private void BuildVertexMesh(ProBuilderMesh mesh, Mesh target, IList <int> indexes)
{
if (IsGeometryShadersSupported)
{
PBUtility.BuildVertexMesh(mesh.positions, m_color, target, indexes);
}
else
{
PBUtility.BuildVertexMeshLegacy(mesh.positions, m_color, target, indexes);
}
}
public override MeshSelection Select(Camera camera, Vector3 pointer, bool shift)
{
MeshSelection selection = null;
MeshAndFace result = PBUtility.PickFace(camera, pointer);
if (result.face != null)
{
int faceIndex = result.mesh.faces.IndexOf(result.face);
if (m_faceSelection.IsSelected(faceIndex))
{
if (shift)
{
m_faceSelection.Remove(faceIndex);
selection = new MeshSelection();
selection.UnselectedFaces.Add(result.mesh, new[] { faceIndex });
}
else
{
selection = ReadSelection();
selection = null;
}
}
else
{
if (shift)
{
selection = new MeshSelection();
}
else
{
selection = ReadSelection();
m_faceSelection.Clear();
}
m_faceSelection.Add(result.mesh, faceIndex);
selection.SelectedFaces.Add(result.mesh, new[] { faceIndex });
}
}
else
{
if (!shift)
{
selection = ReadSelection();
if (selection.UnselectedFaces.Count == 0)
{
selection = null;
}
m_faceSelection.Clear();
}
}
return(selection);
}
public override MeshSelection Select(Camera camera, Rect rect, Rect uiRootRect, GameObject[] gameObjects, bool depthTest, MeshEditorSelectionMode mode)
{
Dictionary <ProBuilderMesh, HashSet <int> > pickResult = PBUtility.PickVertices(camera, rect, uiRootRect, gameObjects, depthTest);
if (pickResult.Count == 0)
{
return(null);
}
MeshSelection selection = new MeshSelection();
foreach (KeyValuePair <ProBuilderMesh, HashSet <int> > kvp in pickResult)
{
ProBuilderMesh mesh = kvp.Key;
HashSet <int> sharedIndexes = kvp.Value;
IList <SharedVertex> sharedVertices = mesh.sharedVertices;
HashSet <int> indices = new HashSet <int>();
foreach (int sharedIndex in sharedIndexes)
{
SharedVertex sharedVertex = sharedVertices[sharedIndex];
for (int j = 0; j < sharedVertex.Count; ++j)
{
if (!indices.Contains(sharedVertex[j]))
{
indices.Add(sharedVertex[j]);
}
}
}
if (mode == MeshEditorSelectionMode.Substract || mode == MeshEditorSelectionMode.Difference)
{
IList <int> selected = mesh.GetCoincidentVertices(indices).Where(index => m_vertexSelection.IsSelected(mesh, index)).ToArray();
selection.UnselectedIndices.Add(mesh.gameObject, selected);
m_vertexSelection.Remove(mesh, selected);
}
if (mode == MeshEditorSelectionMode.Add || mode == MeshEditorSelectionMode.Difference)
{
IList <int> notSelected = mesh.GetCoincidentVertices(indices).Where(index => !m_vertexSelection.IsSelected(mesh, index)).ToArray();
selection.SelectedIndices.Add(mesh.gameObject, notSelected);
m_vertexSelection.Add(mesh, notSelected);
}
}
return(selection);
}
public ApplyMaterialResult ApplyMaterial(Material material, MeshSelection selection, Camera camera, Vector3 mousePosition)
{
MeshAndFace meshAndFace = PBUtility.PickFace(camera, mousePosition);
if (meshAndFace.mesh != null && meshAndFace.face != null)
{
MeshMaterialsState oldState = new MeshMaterialsState();
MeshMaterialsState newState = new MeshMaterialsState();
int faceIndex = meshAndFace.mesh.faces.IndexOf(meshAndFace.face);
IList <int> faceIndexes;
if (selection != null && selection.SelectedFaces.TryGetValue(meshAndFace.mesh.gameObject, out faceIndexes))
{
if (faceIndexes.Contains(faceIndex))
{
return(ApplyMaterial(material, selection));
}
}
AddAllFacesToState(oldState, meshAndFace.mesh);
AddMaterialsToState(oldState, meshAndFace.mesh);
meshAndFace.mesh.SetMaterial(new[] { meshAndFace.face }, material);
meshAndFace.mesh.Refresh();
meshAndFace.mesh.ToMesh();
RemoveUnusedMaterials(meshAndFace.mesh);
meshAndFace.mesh.Refresh();
meshAndFace.mesh.ToMesh();
FaceToSubmeshIndex newFaceToIndex = new FaceToSubmeshIndex(meshAndFace.mesh, meshAndFace.mesh.faces.IndexOf(meshAndFace.face), meshAndFace.face.submeshIndex);
newState.FaceToSubmeshIndex.Add(newFaceToIndex);
AddMaterialsToState(newState, meshAndFace.mesh);
if (MaterialsApplied != null)
{
MaterialsApplied();
}
return(new ApplyMaterialResult(oldState, newState));
}
return(null);
}
public bool Click(Camera camera, Vector3 pointer)
{
if (!m_isEditing)
{
return(false);
}
SceneSelection selection = new SceneSelection();
float result = PBUtility.PickVertex(camera, pointer, 20, m_selection.Transform, m_selection.Positions, ref selection);
if (result != Mathf.Infinity)
{
if (m_selection.Positions.Count >= 3)
{
m_selection.Unselect();
m_selection.Select(selection.vertex);
return(true);
}
}
else
{
if (Stage == 0)
{
Ray ray = camera.ScreenPointToRay(pointer);
float enter;
Plane plane = new Plane(m_selection.transform.up, m_selection.transform.position);
if (plane.Raycast(ray, out enter))
{
Vector3 position = ray.GetPoint(enter);
position = m_selection.Transform.InverseTransformPoint(position);
m_selection.Add(position);
m_positions.Add(position);
}
m_target.CreateShapeFromPolygon(m_selection.Positions, 0.001f, false);
}
}
return(false);
}
public override MeshSelection Select(Camera camera, Vector3 pointer, bool shift)
{
MeshSelection selection = null;
GameObject pickedObject = PBUtility.PickObject(camera, pointer);
float result = PBUtility.PickEdge(camera, pointer, 20, pickedObject, m_edgeSelection.Meshes, ref m_selection);
if (result != Mathf.Infinity)
{
if (m_edgeSelection.IsSelected(m_selection.mesh, m_selection.edge))
{
if (shift)
{
m_edgeSelection.FindCoincidentEdges(m_selection.mesh);
IList <Edge> edges = m_edgeSelection.GetCoincidentEdges(new[] { m_selection.edge });
m_edgeSelection.Remove(m_selection.mesh, edges);
selection = new MeshSelection();
selection.UnselectedEdges.Add(m_selection.mesh, edges);
}
else
{
m_edgeSelection.FindCoincidentEdges(m_selection.mesh);
IList <Edge> edges = m_edgeSelection.GetCoincidentEdges(new[] { m_selection.edge });
selection = ReadSelection();
selection.UnselectedEdges[m_selection.mesh] = selection.UnselectedEdges[m_selection.mesh].Where(e => e != m_selection.edge).ToArray();
selection.SelectedEdges.Add(m_selection.mesh, edges);
m_edgeSelection.Clear();
m_edgeSelection.Add(m_selection.mesh, edges);
}
}
else
{
if (shift)
{
selection = new MeshSelection();
}
else
{
selection = ReadSelection();
m_edgeSelection.Clear();
}
m_edgeSelection.FindCoincidentEdges(m_selection.mesh);
IList <Edge> edges = m_edgeSelection.GetCoincidentEdges(new[] { m_selection.edge });
m_edgeSelection.Add(m_selection.mesh, edges);
selection.SelectedEdges.Add(m_selection.mesh, edges);
}
}
else
{
if (!shift)
{
selection = ReadSelection();
if (selection.UnselectedEdges.Count == 0)
{
selection = null;
}
m_edgeSelection.Clear();
}
}
return(selection);
}
public override MeshSelection Select(Camera camera, Rect rect, GameObject[] gameObjects, MeshEditorSelectionMode mode)
{
MeshSelection selection = new MeshSelection();
m_faceSelection.BeginChange();
Dictionary <ProBuilderMesh, HashSet <Face> > result = PBUtility.PickFaces(camera, rect, gameObjects);
if (mode == MeshEditorSelectionMode.Add)
{
foreach (KeyValuePair <ProBuilderMesh, HashSet <Face> > kvp in result)
{
ProBuilderMesh mesh = kvp.Key;
IList <Face> faces = mesh.faces;
IList <int> faceIndices = kvp.Value.Select(f => faces.IndexOf(f)).ToArray();
IList <int> notSelected = faceIndices.Where(f => !m_faceSelection.IsSelected(f)).ToArray();
foreach (int face in notSelected)
{
m_faceSelection.Add(mesh, face);
}
selection.SelectedFaces.Add(mesh, notSelected);
}
}
else if (mode == MeshEditorSelectionMode.Substract)
{
foreach (KeyValuePair <ProBuilderMesh, HashSet <Face> > kvp in result)
{
ProBuilderMesh mesh = kvp.Key;
IList <Face> faces = mesh.faces;
IList <int> faceIndices = kvp.Value.Select(f => faces.IndexOf(f)).ToArray();
IList <int> selected = faceIndices.Where(f => m_faceSelection.IsSelected(f)).ToArray();
foreach (int face in selected)
{
m_faceSelection.Remove(face);
}
selection.UnselectedFaces.Add(mesh, selected);
}
}
else if (mode == MeshEditorSelectionMode.Difference)
{
foreach (KeyValuePair <ProBuilderMesh, HashSet <Face> > kvp in result)
{
ProBuilderMesh mesh = kvp.Key;
IList <Face> faces = mesh.faces;
IList <int> faceIndices = kvp.Value.Select(f => faces.IndexOf(f)).ToArray();
IList <int> selected = faceIndices.Where(f => m_faceSelection.IsSelected(f)).ToArray();
IList <int> notSelected = faceIndices.Where(f => !m_faceSelection.IsSelected(f)).ToArray();
foreach (int face in selected)
{
m_faceSelection.Remove(face);
}
foreach (int face in notSelected)
{
m_faceSelection.Add(mesh, face);
}
selection.UnselectedFaces.Add(mesh, selected);
selection.SelectedFaces.Add(mesh, notSelected);
}
}
m_faceSelection.EndChange();
if (selection.SelectedFaces.Count == 0 && selection.UnselectedFaces.Count == 0)
{
selection = null;
}
return(selection);
}
public override MeshSelection Select(Camera camera, Vector3 pointer, bool shift)
{
MeshSelection selection = null;
MeshAndFace result = PBUtility.PickFace(camera, pointer);
if (result.face != null)
{
if (m_faceSelection.IsSelected(result.face))
{
if (shift)
{
m_faceSelection.Remove(result.face);
selection = new MeshSelection();
selection.UnselectedFaces.Add(result.mesh, new[] { result.face });
}
else
{
selection = ReadSelection();
//if(selection.SelectedFaces.Count > 1)
//{
// selection.UnselectedFaces[result.mesh] = selection.UnselectedFaces[result.mesh].Where(f => f != result.face).ToArray();
// selection.SelectedFaces.Add(result.mesh, new[] { result.face });
// m_faceSelection.Clear();
// m_faceSelection.Add(result.mesh, result.face);
//}
//else
{
selection = null;
}
}
}
else
{
if (shift)
{
selection = new MeshSelection();
}
else
{
selection = ReadSelection();
m_faceSelection.Clear();
}
m_faceSelection.Add(result.mesh, result.face);
selection.SelectedFaces.Add(result.mesh, new[] { result.face });
}
}
else
{
if (!shift)
{
selection = ReadSelection();
if (selection.UnselectedFaces.Count == 0)
{
selection = null;
}
m_faceSelection.Clear();
}
}
return(selection);
}
public override MeshSelection Select(Camera camera, Vector3 pointer, bool shift, bool ctrl)
{
MeshSelection selection = null;
MeshAndFace result = PBUtility.PickFace(camera, pointer);
if (result.face != null)
{
if (ctrl)
{
int submeshIndex = result.face.submeshIndex;
IList <Face> faces = result.mesh.faces;
List <int> sameMaterialFaces = new List <int>();
bool wasSelected = false;
bool wasUnselected = false;
m_faceSelection.BeginChange();
for (int i = 0; i < faces.Count; ++i)
{
Face face = faces[i];
if (face.submeshIndex == submeshIndex)
{
sameMaterialFaces.Add(i);
if (!m_faceSelection.IsSelected(result.mesh, i))
{
m_faceSelection.Add(result.mesh, i);
wasUnselected = true;
}
else
{
wasSelected = true;
}
}
}
if (wasSelected && !wasUnselected)
{
for (int i = 0; i < sameMaterialFaces.Count; ++i)
{
m_faceSelection.Remove(result.mesh, sameMaterialFaces[i]);
}
selection = new MeshSelection();
selection.UnselectedFaces.Add(result.mesh, sameMaterialFaces.ToArray());
}
else
{
selection = new MeshSelection();
selection.SelectedFaces.Add(result.mesh, sameMaterialFaces.ToArray());
}
m_faceSelection.EndChange();
}
else
{
int faceIndex = result.mesh.faces.IndexOf(result.face);
if (m_faceSelection.IsSelected(result.mesh, faceIndex))
{
if (shift)
{
m_faceSelection.Remove(result.mesh, faceIndex);
selection = new MeshSelection();
selection.UnselectedFaces.Add(result.mesh, new[] { faceIndex });
}
else
{
//selection = ReadSelection();
selection = null;
}
}
else
{
if (shift)
{
selection = new MeshSelection();
}
else
{
selection = ReadSelection();
m_faceSelection.Clear();
}
m_faceSelection.Add(result.mesh, faceIndex);
selection.SelectedFaces.Add(result.mesh, new[] { faceIndex });
}
}
}
else
{
if (!shift)
{
selection = ReadSelection();
if (selection.UnselectedFaces.Count == 0)
{
selection = null;
}
m_faceSelection.Clear();
}
}
return(selection);
}
private void BuildVertexMesh(IList <Vector3> positions, Mesh target)
{
PBUtility.BuildVertexMesh(positions, m_vertexColor, target);
}
public static Dictionary <ProBuilderMesh, HashSet <Edge> > PickEdgesInRect(
Camera cam,
Rect rect,
Rect uiRootRect,
IList <ProBuilderMesh> selectable,
PickerOptions options,
float pixelsPerPoint = 1f)
{
if (/*options.depthTest &&*/ options.rectSelectMode == RectSelectMode.Partial)
{
return(m_renderer.PickEdgesInRect(
cam,
rect,
selectable,
options.depthTest,
(int)(uiRootRect.width / pixelsPerPoint),
(int)(uiRootRect.height / pixelsPerPoint)));
}
var selected = new Dictionary <ProBuilderMesh, HashSet <Edge> >();
foreach (var pb in selectable)
{
if (!pb.selectable)
{
continue;
}
Transform trs = pb.transform;
var selectedEdges = new HashSet <Edge>();
IList <Face> faces = pb.faces;
IList <Vector3> positions = pb.positions;
for (int i = 0, fc = pb.faceCount; i < fc; i++)
{
var edges = faces[i].edges;
for (int n = 0, ec = edges.Count; n < ec; n++)
{
var edge = edges[n];
var posA = trs.TransformPoint(positions[edge.a]);
var posB = trs.TransformPoint(positions[edge.b]);
Vector3 a = ScreenToGuiPoint(uiRootRect, cam.WorldToScreenPoint(posA), pixelsPerPoint);
Vector3 b = ScreenToGuiPoint(uiRootRect, cam.WorldToScreenPoint(posB), pixelsPerPoint);
switch (options.rectSelectMode)
{
case RectSelectMode.Complete:
{
// if either of the positions are clipped by the camera we cannot possibly select both, skip it
if ((a.z < cam.nearClipPlane || b.z < cam.nearClipPlane))
{
continue;
}
if (rect.Contains(a) && rect.Contains(b))
{
if (!options.depthTest || !PBUtility.PointIsOccluded(cam, pb, (posA + posB) * .5f))
{
selectedEdges.Add(edge);
}
}
break;
}
case RectSelectMode.Partial:
{
// partial + depth test is covered earlier
if (RectIntersectsLineSegment(rect, a, b))
{
selectedEdges.Add(edge);
}
break;
}
}
}
}
selected.Add(pb, selectedEdges);
}
return(selected);
}
