public IEnumerator ApplyPositionalModifierAsync(Vector3 worldPosition, VPaintObjectPositionalModifier modifier, float time)
{
Mesh m = GetMeshInstance();
Vector3[] vertices = myVertices;
Color[] colors = myColors;
if (colors == null)
{
colors = m.colors;
}
var len = vertices.Length;
Color[] target = new Color[len];
for (int i = 0; i < len; i++)
{
Vector3 v = transform.TransformPoint(vertices[i]);
float distance = Vector3.Distance(v, worldPosition);
target[i] = modifier(colors[i], distance);
}
var routine = VPaintUtility.LerpColors(this, colors, target, time);
while (routine.MoveNext())
{
yield return(null);
}
}
public IEnumerator BlendTo(VPaintGroup target, float time)
{
var myBaseLayer = paintLayer;
var targetBaseLayer = target.paintLayer;
List <IEnumerator> routines = new List <IEnumerator>();
foreach (var obj in GetVPaintObjects())
{
if (!target.colorers.Contains(obj))
{
continue;
}
int colorLength = obj.GetMeshInstance().colors.Length;
var baseData = myBaseLayer.Get(obj);
Color[] baseColors = null;
if (baseData == null)
{
baseColors = new Color[colorLength];
}
else
{
baseColors = baseData.colors;
}
var targetData = targetBaseLayer.Get(obj);
Color[] targetColors = null;
if (targetData == null)
{
targetColors = new Color[colorLength];
}
else
{
targetColors = targetData.colors;
}
routines.Add(VPaintUtility.LerpColors(obj, baseColors, targetColors, time));
}
while (true)
{
bool b = true;
foreach (var r in routines)
{
if (r.MoveNext())
{
b = false;
}
}
if (b)
{
break;
}
yield return(null);
}
}
public void BlendDirectional(bool preview)
{
if (!preview)
{
VPaint.Instance.PushUndo("Blend Objects");
}
Bounds bounds = new Bounds(Settings.position, Settings.size);
var validTargets = new List <VPaintObject>();
foreach (var vc in blendTargets)
{
if (Settings.useBounds)
{
if (!bounds.Intersects(vc.GetBounds()))
{
continue;
}
}
if (!vc.editorCollider)
{
VPaint.Instance.GetCollider(vc);
}
validTargets.Add(vc);
}
var layers = GetLayers(preview);
var asyncOperation = VPaintUtility.BlendDirectionalAsync(
layers, GetBlendObjects(), validTargets.ToArray(),
Settings.direction, Settings.directionalDistance, Settings.intensity, Settings.directionalPower,
Settings.offset, Settings.useBounds ? bounds : (Bounds?)null
);
while (asyncOperation.MoveNext())
{
if (EditorUtility.DisplayCancelableProgressBar("Applying Directional Blending", asyncOperation.Current.message, asyncOperation.Current.progress))
{
EditorUtility.ClearProgressBar();
return;
}
}
EditorUtility.ClearProgressBar();
if (preview)
{
VPaint.Instance.LoadLayers(new List <VPaintLayer>(layers));
}
else
{
VPaint.Instance.ReloadLayers();
}
}
void PaintObject(VPaintObject vc, VPaintLayer layer, VPaintVertexData data)
{
if (vc.colorsBuilder == null)
{
vc.colorsBuilder = new Color[data.colors.Length];
}
if (vc.transparencyBuilder == null)
{
vc.transparencyBuilder = new float[data.colors.Length];
}
VPaintUtility.MergeColors(
vc.colorsBuilder, vc.transparencyBuilder,
data.colors, data.transparency,
layer.blendMode, layer.opacity,
layer.maskR, layer.maskG, layer.maskB, layer.maskA
);
}
VPaintLayer CalculateAmbientOcclusion(VPaintObject[] objects, float radius, float intensity, int sampleCount, Color darkColor, Color lightColor, Bounds?bounds = null)
{
foreach (var obj in objects)
{
VPaint.Instance.GetCollider(obj);
}
var async = VPaintUtility.CalculateAmbientOcclusionAsync(objects, radius, intensity, sampleCount, darkColor, lightColor, bounds);
while (async.MoveNext())
{
var c = async.Current;
if (EditorUtility.DisplayCancelableProgressBar("Sampling AO", c.message, c.progress))
{
EditorUtility.ClearProgressBar();
return(null);
}
}
EditorUtility.ClearProgressBar();
return(async.Current.result);
}
