private void OnMeshSelected(ManualUVSelection uvSelection)
{
PBMesh mesh = uvSelection.Mesh;
PBEdge[] meshEdges = mesh.Edges;
Dictionary <int, List <int> > faceToEdge = new Dictionary <int, List <int> >();
Tuple <int, int>[] edges = new Tuple <int, int> [meshEdges.Length];
for (int i = 0; i < meshEdges.Length; ++i)
{
PBEdge edge = meshEdges[i];
edges[i] = new Tuple <int, int>(edge.A, edge.B);
List <int> edgeIndices;
if (!faceToEdge.TryGetValue(edge.FaceIndex, out edgeIndices))
{
edgeIndices = new List <int>();
faceToEdge.Add(edge.FaceIndex, edgeIndices);
}
edgeIndices.Add(i);
}
ManualUVRenderer uvRenderer = m_meshToRenderer[mesh];
uvRenderer.UV = mesh.Textures;
uvRenderer.IsSelected = new bool[uvRenderer.UV.Length];
uvRenderer.Edges = edges;
uvRenderer.FaceToEdges = faceToEdge;
uvRenderer.Faces = mesh.Faces.Select(f => f.Indexes).ToArray();
uvRenderer.Refresh(false, false);
}
private void OnDestroy()
{
if (m_editor != null && m_editor.Object != null)
{
m_editor.Object.Started -= OnObjectStarted;
m_editor.Selection.SelectionChanged -= OnSelectionChanged;
foreach (ExposeToEditor obj in m_editor.Object.Get(false))
{
PBMesh pbMesh = obj.GetComponent <PBMesh>();
if (pbMesh != null)
{
WireframeMesh[] wireframeMesh = pbMesh.GetComponentsInChildren <WireframeMesh>(true);
for (int i = 0; i < wireframeMesh.Length; ++i)
{
WireframeMesh wireframe = wireframeMesh[i];
if (!wireframe.IsIndividual)
{
Destroy(wireframe.gameObject);
break;
}
}
}
}
}
if (m_window != null)
{
ResetCullingMask(m_window);
}
}
public void Undo()
{
foreach (var kvp in m_gameObjectToMesh)
{
GameObject go = kvp.Key;
if (go == null)
{
continue;
}
Mesh mesh = kvp.Value;
MeshFilter filter = go.GetComponent <MeshFilter>();
if (filter)
{
filter.sharedMesh = mesh;
}
PBMesh pbMesh = go.GetComponent <PBMesh>();
if (pbMesh)
{
pbMesh.DestroyImmediate();
}
}
RaiseOnSelectionChanged();
}
private void Awake()
{
m_editor = IOC.Resolve <IRTE>();
if (m_editor != null)
{
m_editor.Selection.SelectionChanged += OnSelectionChanged;
}
PBMesh pbMesh = GetComponent <PBMesh>();
if (pbMesh == null)
{
Destroy(this);
}
else
{
m_renderer = GetComponent <Renderer>();
if (m_renderer != null)
{
m_wasEnabled = m_renderer.enabled;
m_renderer.enabled = false;
}
CreateWireframeMesh(pbMesh);
}
}
private object OnNewPolyShape(object arg)
{
GameObject go;
ExposeToEditor exposeToEditor;
CreateNewShape(PBShapeType.Cube, out go, out exposeToEditor);
go.name = "Poly Shape";
IRuntimeEditor rte = IOC.Resolve <IRuntimeEditor>();
RuntimeWindow scene = rte.GetWindow(RuntimeWindowType.Scene);
Vector3 position;
Quaternion rotation;
GetPositionAndRotation(scene, out position, out rotation);
go.transform.position = position;
go.transform.rotation = rotation;
PBMesh pbMesh = go.GetComponent <PBMesh>();
pbMesh.Clear();
PBPolyShape polyShape = go.AddComponent <PBPolyShape>();
polyShape.IsEditing = true;
Editor.Undo.BeginRecord();
Editor.Selection.activeGameObject = go;
m_proBuilderTool.Mode = ProBuilderToolMode.PolyShape;
Editor.Undo.RegisterCreatedObjects(new[] { exposeToEditor });
Editor.Undo.EndRecord();
return(go);
}
private void OnDestroy()
{
if (m_editor != null && m_editor.Object != null)
{
m_editor.Object.Started -= OnObjectStarted;
foreach (ExposeToEditor obj in m_editor.Object.Get(false))
{
PBMesh pbMesh = obj.GetComponent <PBMesh>();
if (pbMesh != null)
{
WireframeMesh wireframeMesh = pbMesh.GetComponentInChildren <WireframeMesh>(true);
if (wireframeMesh != null)
{
Destroy(wireframeMesh.gameObject);
}
}
}
}
if (m_window != null)
{
ResetCullingMask(m_window);
}
}
private void OnCreatePolyshape()
{
GameObject go;
ExposeToEditor exposeToEditor;
CreateShape(PBShapeType.Cube, out go, out exposeToEditor);
exposeToEditor.SetName("Poly Shape");
IRTE rte = IOC.Resolve <IRTE>();
RuntimeWindow scene = rte.GetWindow(RuntimeWindowType.Scene);
Vector3 position;
Quaternion rotation;
GetPositionAndRotation(scene, out position, out rotation);
go.transform.position = position;
go.transform.rotation = rotation;
PBMesh pbMesh = go.GetComponent <PBMesh>();
pbMesh.Clear();
PBPolyShape polyShape = go.AddComponent <PBPolyShape>();
polyShape.IsEditing = true;
rte.Selection.activeGameObject = go;
IProBuilderTool tool = IOC.Resolve <IProBuilderTool>();
tool.Mode = ProBuilderToolMode.PolyShape;
}
private void Awake()
{
m_color = new Color(Random.value, Random.value, Random.value);
m_filter = GetComponent <MeshFilter>();
if (!m_filter)
{
m_filter = gameObject.AddComponent <MeshFilter>();
}
if (!m_filter.sharedMesh)
{
m_filter.sharedMesh = new Mesh();
}
MeshRenderer renderer = GetComponent <MeshRenderer>();
if (renderer == null)
{
renderer = gameObject.AddComponent <MeshRenderer>();
}
renderer.sharedMaterial = PBBuiltinMaterials.LinesMaterial;
renderer.sharedMaterial.SetColor("_Color", Color.white);
renderer.sharedMaterial.SetInt("_HandleZTest", (int)CompareFunction.LessEqual);
renderer.sharedMaterial.SetFloat("_Scale", 0.5f);
m_pbMesh = GetComponentInParent <PBMesh>();
m_pbMesh.Selected += OnPBMeshSelected;
m_pbMesh.Changed += OnPBMeshChanged;
m_pbMesh.Unselected += OnPBMeshUnselected;
m_pbMesh.BuildEdgeMesh(m_filter.sharedMesh, m_color, false);
}
protected override void ReadFromImpl(object obj)
{
base.ReadFromImpl(obj);
PBMesh uo = (PBMesh)obj;
Positions = Assign(uo.Positions, v_ => (PersistentVector3 <TID>)v_);
Textures = Assign(uo.Textures, v_ => (PersistentVector2 <TID>)v_);
}
public void SelectVertices(Func <Vector2, float> canSelect, bool selectClosest, bool clearSelection)
{
m_editor.Undo.BeginRecord();
for (int index = 0; index < m_selection.Count; ++index)
{
ManualUVSelection selection = m_selection[index];
ManualUVSelection oldSelection = new ManualUVSelection(selection);
if (clearSelection)
{
selection.Clear();
}
PBMesh mesh = selection.Mesh;
Vector2[] uvs = mesh.Textures;
float minDistance = float.PositiveInfinity;
int closestIndex = -1;
for (int i = 0; i < uvs.Length; ++i)
{
float distance = canSelect(uvs[i]);
if (selectClosest)
{
if (distance < minDistance)
{
closestIndex = i;
minDistance = distance;
}
}
else
{
if (distance <= 0)
{
if (!selection.Vertices.Contains(i))
{
selection.Vertices.Add(i);
}
}
}
}
if (closestIndex >= 0)
{
if (!selection.Vertices.Contains(closestIndex))
{
selection.Vertices.Add(closestIndex);
}
}
RecordSelection(index, oldSelection, new ManualUVSelection(selection));
if (SelectionChanged != null)
{
SelectionChanged(selection);
}
}
m_editor.Undo.EndRecord();
}
protected virtual void TryCreateWireframe(ExposeToEditor obj)
{
PBMesh pbMesh = obj.GetComponent <PBMesh>();
if (pbMesh != null && !pbMesh.GetComponentsInChildren <WireframeMesh>().Any(w => !w.IsIndividual))
{
CreateWireframeMesh(pbMesh);
}
}
private void OnObjectStarted(ExposeToEditor obj)
{
PBMesh pbMesh = obj.GetComponent <PBMesh>();
if (pbMesh != null)
{
CreateWireframeMesh(pbMesh);
}
}
protected override object WriteToImpl(object obj)
{
obj = base.WriteToImpl(obj);
PBMesh uo = (PBMesh)obj;
uo.Positions = Assign(Positions, v_ => (Vector3)v_);
uo.Textures = Assign(Textures, v_ => (Vector2)v_);
return(uo);
}
private void CreateWireframeMesh(PBMesh pbMesh)
{
GameObject wireframe = new GameObject("IndividualWireframe");
wireframe.transform.SetParent(pbMesh.transform, false);
wireframe.hideFlags = HideFlags.DontSave;
m_wireframeMesh = wireframe.AddComponent <WireframeMesh>();
m_wireframeMesh.IsIndividual = true;
}
private void CreateWireframeMesh(PBMesh pbMesh)
{
GameObject wireframe = new GameObject("Wireframe");
wireframe.transform.SetParent(pbMesh.transform, false);
wireframe.AddComponent <RTSLIgnore>();
wireframe.layer = m_editor.CameraLayerSettings.ExtraLayer2;
wireframe.AddComponent <WireframeMesh>();
}
private void CreateWireframeMesh(PBMesh pbMesh)
{
GameObject wireframe = new GameObject("Wireframe");
wireframe.transform.SetParent(pbMesh.transform, false);
wireframe.hideFlags = HideFlags.DontSave;
wireframe.layer = m_editor.CameraLayerSettings.ExtraLayer;
wireframe.AddComponent <WireframeMesh>();
}
private void RefreshUVRenderers()
{
foreach (KeyValuePair <PBMesh, ManualUVRenderer> kvp in m_meshToRenderer)
{
PBMesh mesh = kvp.Key;
ManualUVRenderer renderer = kvp.Value;
renderer.UV = mesh.Textures;
renderer.Refresh(true, false);
}
}
public PBMesh ProBuilderize(GameObject gameObject, bool hierarchy, Vector2 uvScale)
{
bool wasActive = false;
if (uvScale != Vector2.one)
{
wasActive = gameObject.activeSelf;
gameObject.SetActive(false);
}
if (hierarchy)
{
MeshFilter[] meshFilters = gameObject.GetComponentsInChildren <MeshFilter>(true);
for (int i = 0; i < meshFilters.Length; ++i)
{
if (meshFilters[i].GetComponent <PBMesh>() == null)
{
ExposeToEditor exposeToEditor = meshFilters[i].GetComponent <ExposeToEditor>();
if (exposeToEditor != null)
{
exposeToEditor.AddComponent(typeof(PBMesh));
PBMesh pbMesh = exposeToEditor.GetComponent <PBMesh>();
PBMesh.Init(pbMesh, uvScale);
}
}
}
if (uvScale != Vector2.one)
{
gameObject.SetActive(wasActive);
}
return(gameObject.GetComponent <PBMesh>());
}
else
{
PBMesh mesh = gameObject.GetComponent <PBMesh>();
if (mesh != null)
{
if (uvScale != Vector2.one)
{
gameObject.SetActive(wasActive);
}
return(mesh);
}
mesh = gameObject.AddComponent <PBMesh>();
PBMesh.Init(mesh, uvScale);
if (uvScale != Vector2.one)
{
gameObject.SetActive(wasActive);
}
return(mesh);
}
}
private void OnCenterPivot()
{
foreach (GameObject go in Editor.Selection.gameObjects)
{
PBMesh mesh = go.GetComponent <PBMesh>();
if (mesh != null)
{
mesh.CenterPivot();
}
}
}
private object OnNewPolyShape(object arg)
{
GameObject go = (GameObject)OnNewShape(PBShapeType.Cube);
go.name = "Poly Shape";
PBMesh pbMesh = go.GetComponent <PBMesh>();
pbMesh.Clear();
PBPolyShape polyShape = go.AddComponent <PBPolyShape>();
polyShape.AddVertex(Vector3.zero);
return(go);
}
public void Subdivide()
{
if (m_rte.Selection.activeGameObject != null)
{
foreach (GameObject go in m_rte.Selection.gameObjects)
{
PBMesh pbMesh = go.GetComponent <PBMesh>();
if (pbMesh != null)
{
pbMesh.Subdivide();
}
}
}
}
protected virtual void CreateWireframeMesh(PBMesh pbMesh)
{
GameObject wireframe = new GameObject("Wireframe");
wireframe.transform.SetParent(pbMesh.transform, false);
wireframe.gameObject.hideFlags = HideFlags.DontSave | HideFlags.HideInHierarchy;
wireframe.layer = m_editor.CameraLayerSettings.ExtraLayer;
WireframeMesh wireframeMesh = wireframe.AddComponent <WireframeMesh>();
if (IsSelected(pbMesh.gameObject))
{
wireframeMesh.IsSelected = true;
}
}
private void Awake()
{
m_window = GetComponent <RuntimeWindow>();
m_editor = IOC.Resolve <IRTE>();
m_editor.Object.Started += OnObjectStarted;
foreach (ExposeToEditor obj in m_editor.Object.Get(false))
{
PBMesh pbMesh = obj.GetComponent <PBMesh>();
if (pbMesh != null)
{
CreateWireframeMesh(pbMesh);
}
}
}
private void OnClear(object sender, EventArgs e)
{
SmoothGroupEditor editor = (SmoothGroupEditor)sender;
PBMesh pbMesh = editor.Data.PBMesh;
IMeshEditor meshEditor = m_proBuilderTool.GetEditor();
MeshEditorState oldState = meshEditor.GetState(false);
PBSmoothing.ClearGroup(pbMesh, meshEditor.GetSelection());
m_smoothGroups[pbMesh].Rebuild(pbMesh);
m_proBuilderTool.TryUpdatePivotTransform();
MeshEditorState newState = meshEditor.GetState(false);
m_proBuilderTool.RecordState(oldState, newState, true);
}
protected virtual void TryDestroyWireframe(ExposeToEditor obj)
{
PBMesh pbMesh = obj.GetComponent <PBMesh>();
if (pbMesh != null)
{
WireframeMesh[] wireframeMesh = pbMesh.GetComponentsInChildren <WireframeMesh>(true);
for (int i = 0; i < wireframeMesh.Length; ++i)
{
WireframeMesh wireframe = wireframeMesh[i];
if (!wireframe.IsIndividual)
{
Destroy(wireframe.gameObject);
break;
}
}
}
}
private object OnProBuilderize(object arg)
{
GameObject[] gameObjects = Editor.Selection.gameObjects;
if (gameObjects == null)
{
return(null);
}
for (int i = 0; i < gameObjects.Length; ++i)
{
MeshFilter[] filters = gameObjects[i].GetComponentsInChildren <MeshFilter>();
for (int j = 0; j < filters.Length; ++j)
{
PBMesh.ProBuilderize(filters[j].gameObject);
}
}
return(null);
}
private object OnProBuilderize(object arg)
{
GameObject[] gameObjects = Editor.Selection.gameObjects;
if (gameObjects == null)
{
return(null);
}
Transform[] transforms = gameObjects.Select(g => g.transform).ToArray();
gameObjects = gameObjects.Where(g => !transforms.Any(t => IsDescendant(t, g.transform))).ToArray();
for (int i = 0; i < gameObjects.Length; ++i)
{
Vector3 scale = gameObjects[i].transform.localScale;
float minScale = Mathf.Min(scale.x, scale.y, scale.z);
PBMesh.ProBuilderize(gameObjects[i], true, new Vector2(minScale, minScale));
}
return(null);
}
private void Awake()
{
m_window = GetComponent <RuntimeWindow>();
m_editor = IOC.Resolve <IRTE>();
m_editor.Object.Started += OnObjectStarted;
m_editor.Selection.SelectionChanged += OnSelectionChanged;
m_sceneComponent = m_window.IOCContainer.Resolve <IRuntimeSceneComponent>();
foreach (ExposeToEditor obj in m_editor.Object.Get(false))
{
PBMesh pbMesh = obj.GetComponent <PBMesh>();
if (pbMesh != null)
{
CreateWireframeMesh(pbMesh);
}
}
}
private void Move(Vector2 delta)
{
for (int i = 0; i < m_selection.Count; ++i)
{
ManualUVSelection selection = m_selection[i];
PBMesh mesh = selection.Mesh;
Vector2[] textures = mesh.Textures;
foreach (int index in m_indexes[i])
{
textures[index] = m_initialUVs[i][index] + delta;
}
mesh.Textures = textures;
mesh.RefreshUV();
}
if (UVChanged != null)
{
UVChanged();
}
}
private void Awake()
{
PBMesh pbMesh = GetComponent <PBMesh>();
if (pbMesh == null)
{
Destroy(this);
}
else
{
m_renderer = GetComponent <Renderer>();
if (m_renderer != null)
{
m_wasEnabled = m_renderer.enabled;
m_renderer.enabled = false;
}
CreateWireframeMesh(pbMesh);
}
}
