// Called when the mouse exits hovering an editable object.
internal override void OnBrushExit(EditableObject target)
{
base.OnBrushExit(target);
if (!m_EditableObjectsData.ContainsKey(target))
{
return;
}
var data = m_EditableObjectsData[target];
if (data.SplatCache != null)
{
data.SplatCache.Apply(target.editMesh);
target.ApplyMeshAttributes();
target.graphicsMesh.UploadMeshData(false);
}
if (m_MainCacheTarget != null && data.CacheTarget.Equals(m_MainCacheTarget))
{
m_MainCacheTarget = null;
}
m_EditableObjectsData.Remove(target);
}
void OnGUI()
{
Event e = Event.current;
GUILayout.Space(8);
DoContextMenu();
DrawToolbar();
CheckForEscapeKey(e);
// Call current mode GUI
if (mode != null)
{
m_Scroll = EditorGUILayout.BeginScrollView(m_Scroll);
DrawBrushSettings();
m_BrushMirrorEditor.OnGUI();
if (tool != BrushTool.None)
{
DrawActiveToolmodeSettings();
}
EditorGUILayout.Space();
if (EditorGUI.EndChangeCheck())
{
mode.OnBrushSettingsChanged(brushTarget, brushSettings);
}
EditorGUILayout.EndScrollView();
}
#if POLYBRUSH_DEBUG
GUILayout.Label("DEBUG", EditorStyles.boldLabel);
GUILayout.Label("target: " + (Util.IsValid(brushTarget) ? brushTarget.editableObject.gameObjectAttached.name : "null"));
GUILayout.Label("vertex: " + (Util.IsValid(brushTarget) ? brushTarget.editableObject.vertexCount : 0));
GUILayout.Label("applying: " + m_ApplyingBrush);
GUILayout.Label("lockBrushToFirst: " + s_LockBrushToFirst);
GUILayout.Label("lastHoveredGameObject: " + m_LastHoveredGameObject);
GUILayout.Space(6);
foreach (var kvp in m_Hovering)
{
BrushTarget t = kvp.Value;
EditableObject dbg_editable = t.editableObject;
GUILayout.Label("Vertex Streams: " + dbg_editable.usingVertexStreams);
GUILayout.Label("Original: " + (dbg_editable.originalMesh == null ? "null" : dbg_editable.originalMesh.name));
GUILayout.Label("Active: " + (dbg_editable.editMesh == null ? "null" : dbg_editable.editMesh.name));
GUILayout.Label("Graphics: " + (dbg_editable.graphicsMesh == null ? "null" : dbg_editable.graphicsMesh.name));
}
#endif
if (m_WantsRepaint)
{
m_WantsRepaint = false;
Repaint();
}
}
// Called when the mouse begins hovering an editable object.
internal override void OnBrushEnter(EditableObject target, BrushSettings settings)
{
base.OnBrushEnter(target, settings);
if (target.editMesh == null)
{
return;
}
bool refresh = (m_MainCacheTarget != null && !m_MainCacheTarget.Equals(target)) || m_MainCacheTarget == null;
if (m_MainCacheTarget != null && m_MainCacheTarget.Equals(target))
{
var targetMaterials = target.gameObjectAttached.GetMaterials();
refresh = !targetMaterials.SequenceEqual(m_MainCacheMaterials);
}
if (refresh)
{
SetActiveObject(target);
RebuildMaterialCaches();
PolybrushEditor.instance.Repaint();
}
if (m_LikelySupportsTextureBlending && (brushColor == null || !brushColor.MatchesAttributes(meshAttributes)))
{
brushColor = new SplatWeight(SplatWeight.GetChannelMap(meshAttributes));
SetBrushColorWithAttributeIndex(selectedAttributeIndex);
}
RebuildColorTargets(target, brushColor, settings.strength);
}
// Called when the mouse begins hovering an editable object.
internal override void OnBrushEnter(EditableObject target, BrushSettings settings)
{
base.OnBrushEnter(target, settings);
if (target.graphicsMesh == null)
{
return;
}
EditableObjectData data;
if (!m_EditableObjectsData.TryGetValue(target, out data))
{
data = new EditableObjectData();
m_EditableObjectsData.Add(target, data);
}
RebuildCaches(target, settings);
data.TriangleLookup = PolyMeshUtility.GetAdjacentTriangles(target.editMesh);
MeshRenderer mr = target.gameObjectAttached.GetComponent <MeshRenderer>();
if (mr != null && mr.sharedMaterials != null)
{
data.LikelySupportsVertexColors = mr.sharedMaterials.Any(x =>
x != null && x.shader != null && PolyShaderUtil.SupportsVertexColors(x.shader));
}
else
{
data.LikelySupportsVertexColors = false;
}
}
// Called when the mouse begins hovering an editable object.
internal override void OnBrushEnter(EditableObject target, BrushSettings settings)
{
base.OnBrushEnter(target, settings);
if (target.editMesh == null)
{
return;
}
bool refresh = (m_CacheTarget != null && !m_CacheTarget.Equals(target)) || m_CacheTarget == null;
if (m_CacheTarget != null && m_CacheTarget.Equals(target.gameObjectAttached))
{
var targetMaterials = target.gameObjectAttached.GetMaterials();
refresh = !AreListsEqual(targetMaterials, m_CacheMaterials);
}
if (refresh)
{
m_CacheTarget = target;
m_CacheMaterials = target.gameObjectAttached.GetMaterials();
m_MeshAttributesContainer = null;
currentMeshACIndex = 0;
ArrayUtility.Clear(ref m_AvailableMaterialsAsString);
m_LikelySupportsTextureBlending = CheckForTextureBlendSupport(target.gameObjectAttached);
RebuildCaches(target.editMesh);
}
if (m_LikelySupportsTextureBlending && (brushColor == null || !brushColor.MatchesAttributes(meshAttributes)))
{
brushColor = new SplatWeight(SplatWeight.GetChannelMap(meshAttributes));
SetBrushColorWithAttributeIndex(selectedAttributeIndex);
}
RebuildColorTargets(brushColor, settings.strength);
}
protected override void CreateTempComponent(EditableObject target)
{
if (target == null)
{
return;
}
RefreshVertexSculptSupport(target);
if (!m_LikelyToSupportVertexSculpt)
{
return;
}
OverlayRenderer ren = target.gameObjectAttached.AddComponent <OverlayRenderer>();
ren.SetMesh(target.editMesh);
ren.fullColor = s_FullStrengthColor;
ren.gradient = s_BrushGradientColor;
ren.vertexBillboardSize = s_VertexBillboardSize;
EditableObjectData data;
if (!m_EditableObjectsData.TryGetValue(target, out data))
{
data = new EditableObjectData();
m_EditableObjectsData.Add(target, data);
}
data.TempComponent = ren;
}
internal override void OnBrushEnter(EditableObject target, BrushSettings settings)
{
base.OnBrushEnter(target, settings);
nonManifoldIndices = PolyMeshUtility.GetNonManifoldIndices(target.editMesh);
RefreshVertexSculptSupport(target);
}
void RebuildColorTargets(EditableObject target, SplatWeight blend, float strength)
{
if (target == null)
{
return;
}
var data = m_EditableObjectsData[target];
if (blend == null || data.SplatCache == null || data.SplatTarget == null)
{
return;
}
m_MinWeights = data.SplatTarget.GetMinWeights();
data.SplatTarget.LerpWeights(data.SplatCache, blend, strength);
// get index of texture that is being painted
var attrib = meshAttributes[selectedAttributeIndex];
var baseTexture = attrib.isBaseTexture? attrib : GetBaseTexture();
var baseTexIndex = baseTexture != null ? (int)baseTexture.index : -1;
data.SplatErase.LerpWeightOnSingleChannel(data.SplatCache, m_MinWeights, strength, attrib.channel, (int)attrib.index, baseTexIndex);
}
/// <summary>
/// Called when the mouse exits hovering an editable object.
/// </summary>
/// <param name="target">Previously hovered object</param>
internal virtual void OnBrushExit(EditableObject target)
{
if (target.renderer != null)
{
PolyEditorUtility.SetSelectionRenderState(target.renderer, PolyEditorUtility.GetSelectionRenderState());
}
DestroyTempComponent();
}
// Called when the mouse exits hovering an editable object.
internal override void OnBrushExit(EditableObject target)
{
base.OnBrushExit(target);
if (m_EditableObjectsData.ContainsKey(target))
{
m_EditableObjectsData.Remove(target);
}
}
// Called when the mouse exits hovering an editable object.
internal override void OnBrushExit(EditableObject target)
{
base.OnBrushExit(target);
if (m_EditableObjectsData.ContainsKey(target))
{
DestroyImmediate(m_EditableObjectsData[target].TempComponent);
m_EditableObjectsData.Remove(target);
}
}
/// <summary>
/// Called when the mouse begins hovering an editable object.
/// </summary>
/// <param name="target">Object being hovered</param>
/// <param name="settings">Current brush settings</param>
internal virtual void OnBrushEnter(EditableObject target, BrushSettings settings)
{
if (s_HideWireframe.value && target.renderer != null)
{
// disable wirefame
PolyEditorUtility.SetSelectionRenderState(target.renderer, PolyEditorUtility.GetSelectionRenderState() & SelectionRenderState.Outline);
}
CreateTempComponent(target);
}
/// <summary>
/// Create the temporary component
/// </summary>
/// <param name="target">The object to attach the temporary component on</param>
protected virtual void CreateTempComponent(EditableObject target)
{
if (!Util.IsValid(target))
{
return;
}
tempComponent = target.gameObjectAttached.AddComponent <ZoomOverride>();
tempComponent.hideFlags = HideFlags.HideAndDontSave;
tempComponent.SetWeights(null, 0f);
}
// Called when the mouse exits hovering an editable object.
internal override void OnBrushExit(EditableObject target)
{
base.OnBrushExit(target);
if (target.editMesh != null)
{
target.editMesh.colors = m_MeshVertexColors.OriginalColors;
target.ApplyMeshAttributes(MeshChannel.Color);
}
m_LikelySupportsVertexColors = true;
}
/// <summary>
/// Explicit constructor.
/// </summary>
/// <param name="editableObject"></param>
/// <param name="hits"></param>
internal BrushTarget(EditableObject editableObject, List <PolyRaycastHit> hits)
{
this.raycastHits = hits;
this._editableObject = editableObject;
if (this.editableObject != null)
{
this._weights = new float[this._editableObject.editMesh.vertexCount];
}
else
{
this._weights = new float[0];
}
}
// Called when the mouse exits hovering an editable object.
internal override void OnBrushExit(EditableObject target)
{
base.OnBrushExit(target);
if (splat_cache != null)
{
splat_cache.Apply(target.editMesh);
target.ApplyMeshAttributes();
target.graphicsMesh.UploadMeshData(false);
}
//likelySupportsTextureBlending = true;
}
// Called when the mouse begins hovering an editable object.
internal override void OnBrushEnter(EditableObject target, BrushSettings settings)
{
base.OnBrushEnter(target, settings);
EditableObjectData data;
if (!m_EditableObjectsData.TryGetValue(target, out data))
{
data = new EditableObjectData();
m_EditableObjectsData.Add(target, data);
}
data.LastBrushApplication = 0f;
}
internal override void OnBrushEnter(EditableObject target, BrushSettings settings)
{
base.OnBrushEnter(target, settings);
if (!likelyToSupportVertexSculpt)
{
return;
}
vertices = target.editMesh.vertices;
neighborLookup = PolyMeshUtility.GetAdjacentVertices(target.editMesh);
commonVertices = PolyMeshUtility.GetCommonVertices(target.editMesh);
commonVertexCount = commonVertices.Count;
}
internal override void OnBrushEnter(EditableObject target, BrushSettings settings)
{
base.OnBrushEnter(target, settings);
if (!likelyToSupportVertexSculpt)
{
return;
}
vertices = target.editMesh.vertices;
normalLookup = PolyMeshUtility.GetSmoothNormalLookup(target.editMesh);
commonVertices = PolyMeshUtility.GetCommonVertices(target.editMesh);
commonVertexCount = commonVertices.Length;
}
// Called when the mouse exits hovering an editable object.
internal override void OnBrushExit(EditableObject target)
{
base.OnBrushExit(target);
var data = m_EditableObjectsData[target];
if (target.editMesh != null)
{
target.editMesh.colors = data.MeshVertexColors.OriginalColors;
target.ApplyMeshAttributes(MeshChannel.Color);
}
data.LikelySupportsVertexColors = true;
m_EditableObjectsData.Remove(target);
}
/// <summary>
/// Get a EditableObject matching the GameObject go or create a new one.
/// </summary>
/// <param name="go">Gameobject to edit</param>
/// <returns></returns>
BrushTarget GetOrCreateBrushTarget(GameObject go)
{
BrushTarget target = null;
if (!m_Hovering.TryGetValue(go, out target))
{
target = new BrushTarget(EditableObject.Create(go));
m_Hovering.Add(go, target);
}
else if (!target.IsValid())
{
m_Hovering[go] = new BrushTarget(EditableObject.Create(go));
}
return(target);
}
void SetActiveObject(EditableObject activeObject)
{
m_MainCacheTarget = activeObject;
EditableObjectData data;
if (!m_EditableObjectsData.TryGetValue(activeObject, out data))
{
data = new EditableObjectData();
m_EditableObjectsData.Add(activeObject, data);
}
data.CacheTarget = activeObject;
data.CacheMaterials = activeObject.gameObjectAttached.GetMaterials();
RebuildCaches(data);
}
internal override void OnBrushEnter(EditableObject target, BrushSettings settings)
{
base.OnBrushEnter(target, settings);
EditableObjectData data;
if (!m_EditableObjectsData.TryGetValue(target, out data))
{
data = new EditableObjectData();
m_EditableObjectsData.Add(target, data);
}
data.NonManifoldIndices = PolyMeshUtility.GetNonManifoldIndices(target.editMesh);
RefreshVertexSculptSupport(target);
}
/// <summary>
/// Will ensure that the check is not done everytime (inspired from BrushModeTexture script)
/// </summary>
/// <param name="target"></param>
void RefreshVertexSculptSupport(EditableObject target)
{
bool refresh = (cache_target != null && !cache_target.Equals(target.gameObjectAttached)) || cache_target == null;
if (cache_target != null && cache_target.Equals(target.gameObjectAttached))
{
refresh = cache_materials != target.gameObjectAttached.GetMaterials();
}
if (refresh)
{
cache_target = target;
cache_materials = target.gameObjectAttached.GetMaterials();
likelyToSupportVertexSculpt = CheckForVertexScluptSupport(target.gameObjectAttached);
}
}
protected override void CreateTempComponent(EditableObject target)
{
RefreshVertexSculptSupport(target);
if (!likelyToSupportVertexSculpt)
{
return;
}
OverlayRenderer ren = target.gameObjectAttached.AddComponent <OverlayRenderer>();
ren.SetMesh(target.editMesh);
ren.fullColor = s_FullStrengthColor;
ren.gradient = s_BrushGradientColor;
ren.vertexBillboardSize = s_VertexBillboardSize;
tempComponent = ren;
}
void RebuildCaches(EditableObject target, BrushSettings settings)
{
PolyMesh m = target.editMesh;
int vertexCount = m.vertexCount;
Color32[] newBaseColors = null;
if (m.colors != null && m.colors.Length == vertexCount)
{
newBaseColors = Util.Duplicate(m.colors);
}
else
{
newBaseColors = Util.Fill <Color32>(x => { return(Color.white); }, vertexCount);
}
m_MeshVertexColors.Build(newBaseColors);
m_MeshVertexColors.RebuildColorTargets(m_BrushColor, settings.strength, mask);
}
/// <summary>
/// Will ensure that the check is not done everytime (inspired from BrushModeTexture script)
/// </summary>
/// <param name="target"></param>
void RefreshVertexSculptSupport(EditableObject target)
{
EditableObjectData data;
if (m_EditableObjectsData.TryGetValue(target, out data))
{
bool refresh = (data.CacheTarget != null && !data.CacheTarget.Equals(target.gameObjectAttached)) || data.CacheTarget == null;
if (data.CacheTarget != null && data.CacheTarget.Equals(target.gameObjectAttached))
{
refresh = data.CacheMaterials != target.gameObjectAttached.GetMaterials();
}
if (refresh)
{
data.CacheTarget = target;
data.CacheMaterials = target.gameObjectAttached.GetMaterials();
m_LikelyToSupportVertexSculpt = CheckForVertexScluptSupport(target.gameObjectAttached);
}
}
}
internal override void OnBrushEnter(EditableObject target, BrushSettings settings)
{
base.OnBrushEnter(target, settings);
if (!m_LikelyToSupportVertexSculpt)
{
return;
}
EditableObjectData data;
if (!m_EditableObjectsData.TryGetValue(target, out data))
{
data = new EditableObjectData();
m_EditableObjectsData.Add(target, data);
}
data.Vertices = target.editMesh.vertices;
data.NormalLookup = PolyMeshUtility.GetSmoothNormalLookup(target.editMesh);
data.CommonVertices = PolyMeshUtility.GetCommonVertices(target.editMesh);
data.CommonVertexCount = data.CommonVertices.Length;
}
static HierarchyChanged()
{
EditorApplication.hierarchyChanged += () =>
{
foreach (var gameObject in Selection.gameObjects)
{
var mesh = Util.GetMesh(gameObject);
var id = EditableObject.GetMeshId(mesh);
// if the mesh is an instance managed by polybrush check that it's not a duplicate.
if (id != -1)
{
if (id != gameObject.GetInstanceID() && EditorUtility.InstanceIDToObject(id) != null)
{
mesh = PolyMeshUtility.DeepCopy(mesh);
mesh.name = EditableObject.k_MeshInstancePrefix + gameObject.GetInstanceID();
var mf = gameObject.GetComponent <MeshFilter>();
var sf = gameObject.GetComponent <SkinnedMeshRenderer>();
var polyMesh = gameObject.GetComponent <PolybrushMesh>();
if (polyMesh != null)
{
polyMesh.SetMesh(mesh);
PrefabUtility.RecordPrefabInstancePropertyModifications(polyMesh);
}
else if (mf != null)
{
mf.sharedMesh = mesh;
}
else if (sf != null)
{
sf.sharedMesh = mesh;
}
}
}
}
};
}
// Called when the mouse exits hovering an editable object.
internal override void OnBrushExit(EditableObject target)
{
base.OnBrushExit(target);
}
