public void Undo()
{
if (CanUndo == true)
{
// If we're undoing for the first time, store the current state so we can redo back to it
if (stateIndex == states.Count)
{
AddState();
}
var state = states[--stateIndex];
P3dHelper.Blit(current, state);
}
}
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 static RenderTexture Blit(ref RenderTexture renderTexture, P3dBlendMode blendMode, Texture texture, Color color, float opacity)
{
Command.Instance.SetMaterial(blendMode, texture, color, opacity);
Command.Instance.Apply();
var swap = P3dHelper.GetRenderTexture(renderTexture.descriptor);
Command.Instance.Material.SetTexture(P3dShader._Buffer, renderTexture);
P3dHelper.Blit(swap, Command.Instance.Material);
P3dHelper.ReleaseRenderTexture(renderTexture);
renderTexture = swap;
return(swap);
}
private static bool Blit(Material cachedMaterial, ref RenderTexture renderTexture)
{
if (cachedSwap == true)
{
var swap = P3dHelper.GetRenderTexture(renderTexture.width, renderTexture.height, renderTexture.depth, renderTexture.format);
cachedMaterial.SetTexture(P3dShader._Buffer, renderTexture);
P3dHelper.Blit(swap, cachedMaterial);
P3dHelper.ReleaseRenderTexture(renderTexture);
renderTexture = swap;
return(true);
}
P3dHelper.Blit(renderTexture, cachedMaterial);
return(false);
}
public RenderTexture PreparePaint()
{
if (Locked == true)
{
var renderer = Parent.Root.GetComponent <Renderer>();
var materials = renderer.sharedMaterials;
var material = materials[MaterialIndex];
var colorSpace = Colors;
if (colorSpace == RenderTextureReadWrite.Default)
{
var importer = P3dHelper.GetAssetImporter <TextureImporter>(OldTexture);
if (importer != null)
{
colorSpace = importer.sRGBTexture == true ? RenderTextureReadWrite.sRGB : RenderTextureReadWrite.Linear;
}
}
if (NewTexture == null)
{
NewTexture = P3dHelper.GetRenderTexture(OldTexture.width, OldTexture.height, 0, RenderTextureFormat.ARGB32, colorSpace);
P3dHelper.Blit(NewTexture, OldTexture);
}
if (NewTexture.width != OldTexture.width || NewTexture.height != OldTexture.height)
{
NewTexture = P3dHelper.GetRenderTexture(OldTexture.width, OldTexture.height, 0, RenderTextureFormat.ARGB32, colorSpace);
P3dHelper.Blit(NewTexture, OldTexture);
}
material.SetTexture(SlotName, NewTexture);
return(NewTexture);
}
return(null);
}
public void Paint(P3dCommand command, List <P3dWindowPaintable> paintables)
{
var commandMaterial = command.Material;
//if (bounds.Intersects(lastBounds) == true)
{
for (var i = PaintableTextures.Count - 1; i >= 0; i--)
{
var paintableTexture = PaintableTextures[i];
var renderTexture = paintableTexture.PreparePaint(); // Prepare the paint regardless, to sync undo states
if (P3dHelper.IndexInMask(paintableTexture.Group, command.Groups) == true)
{
var oldActive = RenderTexture.active;
var swap = default(RenderTexture);
RenderTexture.active = renderTexture;
if (true) // TODO
{
swap = P3dHelper.GetRenderTexture(renderTexture.width, renderTexture.height, renderTexture.depth, renderTexture.format);
P3dHelper.Blit(swap, renderTexture);
commandMaterial.SetTexture(P3dShader._Buffer, swap);
}
command.Apply();
if (command.RequireMesh == true)
{
for (var j = paintables.Count - 1; j >= 0; j--)
{
var otherP = paintables[j];
for (var k = otherP.PaintableTextures.Count - 1; k >= 0; k--)
{
var otherT = otherP.PaintableTextures[k];
if (otherT.OldTexture == paintableTexture.OldTexture)
{
switch (otherT.Channel)
{
case P3dChannel.UV: commandMaterial.SetVector(P3dShader._Channel, new Vector4(1.0f, 0.0f, 0.0f, 0.0f)); break;
case P3dChannel.UV2: commandMaterial.SetVector(P3dShader._Channel, new Vector4(0.0f, 1.0f, 0.0f, 0.0f)); break;
case P3dChannel.UV3: commandMaterial.SetVector(P3dShader._Channel, new Vector4(0.0f, 0.0f, 1.0f, 0.0f)); break;
case P3dChannel.UV4: commandMaterial.SetVector(P3dShader._Channel, new Vector4(0.0f, 0.0f, 0.0f, 1.0f)); break;
}
commandMaterial.SetPass(0);
Graphics.DrawMeshNow(otherP.lastMesh, otherP.lastMatrix, otherT.MaterialIndex);
}
}
}
}
else
{
Graphics.Blit(default(Texture), renderTexture, commandMaterial);
}
RenderTexture.active = oldActive;
if (swap != null)
{
P3dHelper.ReleaseRenderTexture(swap);
}
}
}
}
}
/// <summary>This allows you to manually execute all commands in the paint stack.
/// This is useful if you need to modify the state of your object before the end of the frame.</summary>
public void ExecuteCommands(bool sendNotifications)
{
if (activated == true)
{
var commandCount = commands.Count;
var swap = default(RenderTexture);
var swapSet = false;
// Revert snapshot
if (previewSet == true)
{
P3dHelper.ReleaseRenderTexture(preview); previewSet = false;
}
if (commandCount > 0)
{
var oldActive = RenderTexture.active;
var preparedMesh = default(Mesh);
var preparedMatrix = default(Matrix4x4);
RenderTexture.active = current;
for (var i = 0; i < commandCount; i++)
{
var command = commands[i];
var commandMaterial = command.Material;
if (command.Preview != previewSet)
{
// Skip sending notifications for the first command, because if this is a preview and the previous frame ended with a preview then this would otherwise get triggered
if (sendNotifications == true && i > 0)
{
NotifyOnModified(previewSet);
}
if (previewSet == true)
{
P3dHelper.ReleaseRenderTexture(preview); previewSet = false;
RenderTexture.active = current;
}
else
{
preview = P3dHelper.GetRenderTexture(current.width, current.height, current.depth, current.format); previewSet = true;
P3dHelper.Blit(preview, current);
RenderTexture.active = preview;
}
}
if (command.Swap == true)
{
if (swapSet == false)
{
swap = P3dHelper.GetRenderTexture(current.width, current.height, current.depth, current.format); swapSet = true;
}
RenderTexture.active = swap;
if (previewSet == true)
{
swap = preview;
preview = RenderTexture.active;
}
else
{
swap = current;
current = RenderTexture.active;
}
command.Material.SetTexture(P3dShader._Buffer, swap);
}
command.Apply();
if (command.RequireMesh == true)
{
command.Model.GetPrepared(ref preparedMesh, ref preparedMatrix);
switch (channel)
{
case P3dChannel.UV: commandMaterial.SetVector(P3dShader._Channel, new Vector4(1.0f, 0.0f, 0.0f, 0.0f)); break;
case P3dChannel.UV2: commandMaterial.SetVector(P3dShader._Channel, new Vector4(0.0f, 1.0f, 0.0f, 0.0f)); break;
case P3dChannel.UV3: commandMaterial.SetVector(P3dShader._Channel, new Vector4(0.0f, 0.0f, 1.0f, 0.0f)); break;
case P3dChannel.UV4: commandMaterial.SetVector(P3dShader._Channel, new Vector4(0.0f, 0.0f, 0.0f, 1.0f)); break;
}
commandMaterial.SetPass(0);
Graphics.DrawMeshNow(preparedMesh, preparedMatrix, slot.Index);
}
else
{
if (previewSet == true)
{
Graphics.Blit(default(Texture), preview, commandMaterial);
}
else
{
Graphics.Blit(default(Texture), current, commandMaterial);
}
}
command.Pool();
}
RenderTexture.active = oldActive;
commands.Clear();
}
if (swapSet == true)
{
P3dHelper.ReleaseRenderTexture(swap); swapSet = false;
}
if (sendNotifications == true && commandCount > 0)
{
NotifyOnModified(previewSet);
}
if (materialSet == false)
{
UpdateMaterial();
}
if (previewSet == true)
{
material.SetTexture(slot.Name, preview);
}
else
{
material.SetTexture(slot.Name, current);
}
}
}
public void Paint(P3dGroup group, P3dCommand command)
{
var commandMaterial = command.Material;
//if (bounds.Intersects(lastBounds) == true)
{
for (var i = PaintableTextures.Count - 1; i >= 0; i--)
{
var paintableTexture = PaintableTextures[i];
var renderTexture = paintableTexture.PreparePaint(); // Prepare the paint regardless, to sync undo states
if (paintableTexture.Group == group)
{
var oldActive = RenderTexture.active;
var swap = default(RenderTexture);
RenderTexture.active = renderTexture;
if (command.RequireSwap == true)
{
swap = P3dHelper.GetRenderTexture(renderTexture.width, renderTexture.height, renderTexture.depth, renderTexture.format);
P3dHelper.Blit(swap, renderTexture);
commandMaterial.SetTexture(P3dShader._Buffer, swap);
}
command.Apply();
if (command.RequireMesh == true)
{
switch (paintableTexture.Channel)
{
case P3dChannel.UV: commandMaterial.SetVector(P3dShader._Channel, new Vector4(1.0f, 0.0f, 0.0f, 0.0f)); break;
case P3dChannel.UV2: commandMaterial.SetVector(P3dShader._Channel, new Vector4(0.0f, 1.0f, 0.0f, 0.0f)); break;
case P3dChannel.UV3: commandMaterial.SetVector(P3dShader._Channel, new Vector4(0.0f, 0.0f, 1.0f, 0.0f)); break;
case P3dChannel.UV4: commandMaterial.SetVector(P3dShader._Channel, new Vector4(0.0f, 0.0f, 0.0f, 1.0f)); break;
}
commandMaterial.SetPass(0);
Graphics.DrawMeshNow(lastMesh, lastMatrix, paintableTexture.MaterialIndex);
}
else
{
Graphics.Blit(default(Texture), renderTexture, commandMaterial);
}
RenderTexture.active = oldActive;
if (swap != null)
{
P3dHelper.ReleaseRenderTexture(swap);
}
}
}
}
}
public void ExecuteCommands(P3dPaintable paintable)
{
if (activated == true)
{
var commandCount = commands.Count;
var swap = default(RenderTexture);
var swapSet = false;
// Revert snapshot
if (previewSet == true)
{
P3dHelper.ReleaseRenderTexture(preview); previewSet = false;
}
if (commandCount > 0)
{
var oldActive = RenderTexture.active;
var prepared = false;
var preparedMesh = default(Mesh);
var preparedMatrix = default(Matrix4x4);
RenderTexture.active = current;
for (var i = 0; i < commandCount; i++)
{
var command = commands[i];
var commandMaterial = command.Material;
if (command.Preview != previewSet)
{
NotifyOnModified(previewSet);
if (previewSet == true)
{
P3dHelper.ReleaseRenderTexture(preview); previewSet = false;
RenderTexture.active = current;
}
else
{
preview = P3dHelper.GetRenderTexture(current.width, current.height, current.depth, current.format); previewSet = true;
P3dHelper.Blit(preview, current);
RenderTexture.active = preview;
}
}
if (command.RequireSwap == true)
{
if (swapSet == false)
{
swap = P3dHelper.GetRenderTexture(current.width, current.height, current.depth, current.format); swapSet = true;
}
RenderTexture.active = swap;
if (previewSet == true)
{
swap = preview;
preview = RenderTexture.active;
}
else
{
swap = current;
current = RenderTexture.active;
}
command.Material.SetTexture(P3dShader._Buffer, swap);
}
command.Apply();
if (command.RequireMesh == true)
{
if (prepared == false)
{
prepared = true;
paintable.GetPrepared(ref preparedMesh, ref preparedMatrix);
}
switch (channel)
{
case P3dChannel.UV: commandMaterial.SetVector(P3dShader._Channel, new Vector4(1.0f, 0.0f, 0.0f, 0.0f)); break;
case P3dChannel.UV2: commandMaterial.SetVector(P3dShader._Channel, new Vector4(0.0f, 1.0f, 0.0f, 0.0f)); break;
case P3dChannel.UV3: commandMaterial.SetVector(P3dShader._Channel, new Vector4(0.0f, 0.0f, 1.0f, 0.0f)); break;
case P3dChannel.UV4: commandMaterial.SetVector(P3dShader._Channel, new Vector4(0.0f, 0.0f, 0.0f, 1.0f)); break;
}
commandMaterial.SetPass(0);
Graphics.DrawMeshNow(preparedMesh, preparedMatrix, slot.Index);
}
else
{
Graphics.Blit(default(Texture), current, commandMaterial);
}
command.Pool();
}
RenderTexture.active = oldActive;
commands.Clear();
}
if (swapSet == true)
{
P3dHelper.ReleaseRenderTexture(swap); swapSet = false;
}
if (commandCount > 0)
{
NotifyOnModified(previewSet);
}
if (materialSet == false)
{
UpdateMaterial();
}
if (previewSet == true)
{
material.SetTexture(slot.Name, preview);
}
else
{
material.SetTexture(slot.Name, current);
}
}
}
