// 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;
}
}
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;
}
// 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;
}
/// <summary>
/// Draw gizmos taking into account handling of normal by raiser lower brush mode.
/// </summary>
/// <param name="target">Current target Object</param>
/// <param name="settings">Current brush settings</param>
internal override void DrawGizmos(BrushTarget target, BrushSettings settings)
{
if (!m_EditableObjectsData.ContainsKey(target.editableObject))
{
return;
}
EditableObjectData data = m_EditableObjectsData[target.editableObject];
UpdateBrushGizmosColor();
int rayCount = target.raycastHits.Count;
List <Vector3> brushNormalOnBeginApply = BrushNormalsOnBeginApply(target.editableObject);
for (int ri = 0; ri < rayCount; ri++)
{
PolyRaycastHit hit = target.raycastHits[ri];
Vector3 normal = hit.normal;
switch (s_RaiseLowerDirection.value)
{
case PolyDirection.BrushNormal:
case PolyDirection.VertexNormal:
{
if (s_UseFirstNormalVector && brushNormalOnBeginApply.Count > ri)
{
normal = brushNormalOnBeginApply[ri];
}
}
break;
case PolyDirection.Up:
case PolyDirection.Right:
case PolyDirection.Forward:
{
normal = DirectionUtil.ToVector3(s_RaiseLowerDirection);
}
break;
}
;
normal = settings.isUserHoldingControl ? normal * -1f : normal;
PolyHandles.DrawBrush(hit.position,
normal,
settings,
target.localToWorldMatrix,
innerColor,
outerColor);
}
}
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);
}
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;
}
void RebuildCaches(EditableObjectData data)
{
PolyMesh mesh = data.CacheTarget.editMesh;
data.VertexCount = mesh.vertexCount;
data.TriangleLookup = PolyMeshUtility.GetAdjacentTriangles(mesh);
if (meshAttributes == null)
{
// clear caches
data.SplatCache = null;
data.SplatCurrent = null;
data.SplatTarget = null;
data.SplatErase = null;
return;
}
data.SplatCache = new SplatSet(mesh, meshAttributes);
SetupBaseTextures(data.SplatCache);
data.SplatCurrent = new SplatSet(data.SplatCache);
data.SplatTarget = new SplatSet(data.VertexCount, meshAttributes);
data.SplatErase = new SplatSet(data.VertexCount, meshAttributes);
}
/// <summary>
/// Draw gizmos taking into account handling of normal by raiser lower brush mode.
/// </summary>
/// <param name="target">Current target Object</param>
/// <param name="settings">Current brush settings</param>
internal override void DrawGizmos(BrushTarget target, BrushSettings settings)
{
if (!m_EditableObjectsData.ContainsKey(target.editableObject))
{
return;
}
EditableObjectData data = m_EditableObjectsData[target.editableObject];
UpdateBrushGizmosColor();
int rayCount = target.raycastHits.Count;
List <Vector3> brushNormalOnBeginApply = BrushNormalsOnBeginApply(target.editableObject);
for (int ri = 0; ri < rayCount; ri++)
{
PolyRaycastHit hit = target.raycastHits[ri];
Vector3 normal = hit.normal;
switch (s_RaiseLowerDirection.value)
{
case PolyDirection.BrushNormal:
{
if (s_UseFirstNormalVector && brushNormalOnBeginApply.Count > ri)
{
normal = brushNormalOnBeginApply[ri];
}
}
break;
case PolyDirection.Up:
case PolyDirection.Right:
case PolyDirection.Forward:
{
normal = DirectionUtil.ToVector3(s_RaiseLowerDirection);
}
break;
case PolyDirection.VertexNormal:
{
//For vertex normal mode we take the vertex with the highest weight to compute the normal
//if non has enough we take the hit normal.
float highestWeight = .0001f;
int highestIndex = -1;
for (int i = 0; i < data.CommonVertexCount; i++)
{
int index = data.CommonVertices[i][0];
if (hit.weights[index] < .0001f || (s_IgnoreOpenEdges && ContainsIndexInNonManifoldIndices(target.editableObject, index)))
{
continue;
}
if (hit.weights[index] > highestWeight)
{
highestIndex = index;
}
}
if (highestIndex != -1)
{
normal = data.NormalLookup[highestIndex];
}
}
break;
}
;
normal = settings.isUserHoldingControl ? normal * -1f : normal;
PolyHandles.DrawBrush(hit.position, normal, settings, target.localToWorldMatrix, innerColor, outerColor);
}
}
internal override void OnBrushApply(BrushTarget target, BrushSettings settings)
{
if (!m_LikelyToSupportVertexSculpt)
{
return;
}
if (!m_EditableObjectsData.ContainsKey(target.editableObject))
{
return;
}
int rayCount = target.raycastHits.Count;
if (rayCount < 1)
{
return;
}
Vector3 n = s_RaiseLowerDirection.value.ToVector3();
float scale = 1f / (Vector3.Scale(target.transform.lossyScale, n).magnitude);
float sign = settings.isUserHoldingControl ? -1f : 1f;//Event.current != null ? (Event.current.control ? -1f : 1f) : 1f;
float maxMoveDistance = settings.strength * k_StrengthModifier * sign * s_RaiseLowerStrength;
int vertexCount = target.editableObject.vertexCount;
PolyMesh mesh = target.editableObject.editMesh;
EditableObjectData data = m_EditableObjectsData[target.editableObject];
List <Vector3> brushNormalOnBeginApply = BrushNormalsOnBeginApply(target.editableObject);
// rayCount could be different from brushNormalOnBeginApply.Count with some shapes (example: sphere).
for (int ri = 0; ri < rayCount && ri < brushNormalOnBeginApply.Count; ri++)
{
PolyRaycastHit hit = target.raycastHits[ri];
if (hit.weights == null || hit.weights.Length < vertexCount)
{
continue;
}
if (s_RaiseLowerDirection == PolyDirection.BrushNormal)
{
if (s_UseFirstNormalVector)
{
n = brushNormalOnBeginApply[ri];
}
else
{
n = hit.normal;
}
scale = 1f / (Vector3.Scale(target.transform.lossyScale, n).magnitude);
}
for (int i = 0; i < data.CommonVertexCount; i++)
{
int index = data.CommonVertices[i][0];
if (hit.weights[index] < .0001f || (s_IgnoreOpenEdges && ContainsIndexInNonManifoldIndices(target.editableObject, index)))
{
continue;
}
if (s_RaiseLowerDirection == PolyDirection.VertexNormal)
{
n = data.NormalLookup[index];
scale = 1f / (Vector3.Scale(target.transform.lossyScale, n).magnitude);
}
Vector3 pos = data.Vertices[index] + n * (hit.weights[index] * maxMoveDistance * scale);
int[] indices = data.CommonVertices[i];
for (int it = 0; it < indices.Length; it++)
{
data.Vertices[indices[it]] = pos;
}
}
}
mesh.vertices = data.Vertices;
target.editableObject.modifiedChannels |= MeshChannel.Position;
// different than setting weights on temp component,
// which is what BrushModeMesh.OnBrushApply does.
if (tempComponent != null)
{
tempComponent.OnVerticesMoved(mesh);
}
base.OnBrushApply(target, settings);
}
