protected override void Update()
{
base.Update();
if (changeReader == null)
{
changeReader = new P3dReader();
changeReader.OnComplete += HandleCompleteChange;
}
if (changeReader.Requested == false && registeredPaintableTexture != null && registeredPaintableTexture.Activated == true)
{
if (P3dReader.NeedsUpdating(changeReader, changePixels, registeredPaintableTexture.Current, downsampleSteps) == true || changeDirty == true)
{
changeDirty = false;
var desc = registeredPaintableTexture.Current.descriptor; desc.useMipMap = false;
var renderTexture = P3dHelper.GetRenderTexture(desc);
P3dCommandReplace.Blit(renderTexture, texture, color);
// Request new change
changeReader.Request(renderTexture, DownsampleSteps, Async);
P3dHelper.ReleaseRenderTexture(renderTexture);
}
}
changeReader.UpdateRequest();
}
/// <summary>This method will resize the current texture state with the specified width and height.
/// NOTE: This component must be activated.</summary>
public bool Resize(int width, int height, bool copyContents = true)
{
if (activated == true)
{
if (current.width != width || current.height != height)
{
var descriptor = current.descriptor;
descriptor.width = width;
descriptor.height = height;
var newCurrent = P3dHelper.GetRenderTexture(descriptor, current);
if (copyContents == true)
{
P3dCommandReplace.Blit(newCurrent, current, Color.white);
if (newCurrent.useMipMap == true)
{
newCurrent.GenerateMips();
}
}
P3dHelper.ReleaseRenderTexture(current);
current = newCurrent;
return(true);
}
}
return(false);
}
/// <summary>This method will clear the current texture state with the specified texture and color.
/// NOTE: This component must be activated, and this method will not resize the current texture.</summary>
public void Clear(Texture texture, Color tint)
{
if (activated == true)
{
P3dCommandReplace.Blit(current, texture, tint);
}
}
private void RebuildFromCommands()
{
P3dCommandReplace.Blit(current, texture, color);
var localToWorldMatrix = transform.localToWorldMatrix;
for (var i = 0; i <= stateIndex; i++)
{
var paintableState = paintableStates[i];
var commandCount = paintableState.Commands.Count;
for (var j = 0; j < commandCount; j++)
{
var worldCommand = paintableState.Commands[j].SpawnCopy();
worldCommand.Transform(localToWorldMatrix, localToWorldMatrix);
paintCommands.Add(worldCommand);
//AddCommand(worldCommand);
}
}
ExecuteCommands(false);
NotifyOnModified(false);
}
public void Request(RenderTexture texture, int downsample, bool async)
{
if (texture == null)
{
Debug.LogError("Texture null."); return;
}
if (requested == true)
{
Debug.LogError("Already requested."); return;
}
if (buffer != null)
{
Debug.LogError("Buffer exists."); return;
}
originalSize.x = downsampledSize.x = texture.width;
originalSize.y = downsampledSize.y = texture.height;
for (var i = 0; i < downsample; i++)
{
if (downsampledSize.x > 2)
{
downsampledSize.x /= 2;
}
if (downsampledSize.y > 2)
{
downsampledSize.y /= 2;
}
}
downsampleSteps = downsample;
downsampleBoost = (originalSize.x / downsampledSize.x) * (originalSize.y / downsampledSize.y);
var desc = texture.descriptor;
desc.useMipMap = false;
desc.width = downsampledSize.x;
desc.height = downsampledSize.y;
buffer = P3dHelper.GetRenderTexture(desc);
P3dCommandReplace.Blit(buffer, texture, Color.white);
#if ASYNC_READBACK_SUPPORTED
if (async == true)
{
request = AsyncGPUReadback.Request(buffer, 0, TextureFormat.RGBA32);
requested = true;
UpdateRequest();
}
else
#endif
{
CompleteDirectly();
}
}
public static void Blit(ref RenderTexture main, ref RenderTexture swap, P3dBlendMode blendMode, Texture texture, Color color, float opacity, float minimum)
{
Instance.SetMaterial(blendMode, texture, color, opacity, minimum);
Instance.Apply();
if (Instance.Double == true)
{
P3dCommandReplace.Blit(swap, main, Color.white);
Instance.Material.SetTexture(P3dShader._Buffer, swap);
Instance.Material.SetVector(P3dShader._BufferSize, new Vector2(swap.width, swap.height));
}
P3dHelper.Blit(main, Instance.Material);
}
public void Resize()
{
foreach (var slot in Slots)
{
if (slot.Texture != null)
{
if (slot.Texture.width != Width || slot.Texture.height != Height)
{
var desc = slot.Texture.descriptor; desc.width = Width; desc.height = Height;
var resizedTexture = P3dHelper.GetRenderTexture(desc, slot.Texture);
P3dCommandReplace.Blit(resizedTexture, slot.Texture, Color.white);
P3dHelper.ReleaseRenderTexture(slot.Texture);
slot.Texture = resizedTexture;
}
}
}
}
private void WriteThumbnailTex(RenderTexture texture, P3dPaintMaterial.Slot paintSlot, P3dShaderTemplate.Write write)
{
if (paintSlot != null)
{
P3dCommandReplace.Blit(texture, paintSlot.Texture, paintSlot.Color);
}
else
{
var group = P3dGroupData.GetGroupData(write.SourceGroup);
if (group != null)
{
P3dCommandReplace.Blit(texture, group.DefaultTexture, group.DefaultColor);
}
else
{
P3dCommandReplace.Blit(texture, default(Texture), default(Color));
}
}
}
public void Activate()
{
if (activated == false)
{
UpdateMaterial();
if (material != null)
{
var finalWidth = width;
var finalHeight = height;
var finalTexture = material.GetTexture(slot.Name);
CachedPaintable.ScaleSize(ref finalWidth, ref finalHeight);
if (texture != null)
{
finalTexture = texture;
}
if (string.IsNullOrEmpty(shaderKeyword) == false)
{
material.EnableKeyword(shaderKeyword);
}
var desc = new RenderTextureDescriptor(width, height, format, 0);
desc.autoGenerateMips = false;
if (mipMaps == MipType.ForceOn)
{
desc.useMipMap = true;
}
else if (mipMaps == MipType.Auto && P3dHelper.HasMipMaps(finalTexture) == true)
{
desc.useMipMap = true;
}
current = P3dHelper.GetRenderTexture(desc);
current.wrapMode = TextureWrapMode.Repeat;
P3dCommandReplace.Blit(current, finalTexture, color);
if (current.useMipMap == true)
{
current.GenerateMips();
}
material.SetTexture(slot.Name, current);
activated = true;
if (string.IsNullOrEmpty(saveName) == false)
{
Load();
}
NotifyOnModified(false);
}
}
}
public void UpdateMergedLayers(Layer currentLayer)
{
foreach (var mat in Mats)
{
foreach (var mergedLayer in mat.MergedLayers.Values)
{
mergedLayer.Dirty = true;
if (mergedLayer.Layer != currentLayer)
{
mergedLayer.Clear();
mergedLayer.Layer = currentLayer;
}
}
if (mat.Template != null)
{
foreach (var slot in mat.Template.Slots)
{
mat.UpdateMergedLayers(slot.WriteR.SourceGroup);
mat.UpdateMergedLayers(slot.WriteG.SourceGroup);
mat.UpdateMergedLayers(slot.WriteB.SourceGroup);
mat.UpdateMergedLayers(slot.WriteA.SourceGroup);
}
}
foreach (var pair in mat.MergedLayers)
{
var group = pair.Key;
var mergedLayer = pair.Value;
if (mergedLayer.Dirty == true)
{
mergedLayer.Clear();
}
else
{
var currentLayerIndex = Layers.IndexOf(currentLayer);
if (mergedLayer.Under == null)
{
mergedLayer.Under = P3dHelper.GetRenderTexture(mat.Desc);
var groupData = P3dGroupData.GetGroupData(group);
if (groupData != null)
{
P3dCommandReplace.Blit(mergedLayer.Under, groupData.DefaultTexture, groupData.DefaultColor);
}
else
{
P3dCommandReplace.Blit(mergedLayer.Under, default(Texture), default(Color));
}
for (var i = 0; i < currentLayerIndex; i++)
{
TryBlendInto(ref mergedLayer.Under, Layers[i], mat.Id, group);
}
}
// Last layer?
if (currentLayerIndex == Layers.Count - 1)
{
if (mergedLayer.Above != null)
{
mergedLayer.Above = P3dHelper.ReleaseRenderTexture(mergedLayer.Above);
}
}
else
{
if (mergedLayer.Above == null)
{
mergedLayer.Above = P3dHelper.GetRenderTexture(mat.Desc);
P3dCommandReplace.Blit(mergedLayer.Above, default(Texture), default(Color));
for (var i = currentLayerIndex + 1; i < Layers.Count; i++)
{
TryBlendInto(ref mergedLayer.Above, Layers[i], mat.Id, group);
}
}
}
if (mergedLayer.Final == null)
{
mergedLayer.Final = P3dHelper.GetRenderTexture(mat.Desc);
}
P3dCommandReplace.Blit(mergedLayer.Final, mergedLayer.Under, Color.white);
TryBlendInto(ref mergedLayer.Final, currentLayer, mat.Id, group);
if (mergedLayer.Above != null)
{
mergedLayer.Final = P3dCommandFill.Blit(mergedLayer.Final, P3dBlendMode.AlphaBlend, mergedLayer.Above, Color.white, 1.0f, 0.0f);
}
}
}
}
}
