public unsafe static UIRStylePainter.ClosingInfo PaintElement(RenderChain renderChain, VisualElement ve, ref ChainBuilderStats stats)
{
var device = renderChain.device;
var isClippingWithStencil = ve.renderChainData.clipMethod == ClipMethod.Stencil;
var isClippingWithScissors = ve.renderChainData.clipMethod == ClipMethod.Scissor;
var isGroup = (ve.renderHints & RenderHints.GroupTransform) != 0; // Groups need to push view and scissors
if ((UIRUtility.IsElementSelfHidden(ve) && !isClippingWithStencil && !isClippingWithScissors && !isGroup) || ve.renderChainData.isHierarchyHidden)
{
if (ve.renderChainData.data != null)
{
device.Free(ve.renderChainData.data);
ve.renderChainData.data = null;
}
if (ve.renderChainData.firstCommand != null)
{
ResetCommands(renderChain, ve);
}
renderChain.ResetTextures(ve);
return(new UIRStylePainter.ClosingInfo());
}
// Retain our command insertion points if possible, to avoid paying the cost of finding them again
RenderChainCommand oldCmdPrev = ve.renderChainData.firstCommand?.prev;
RenderChainCommand oldCmdNext = ve.renderChainData.lastCommand?.next;
RenderChainCommand oldClosingCmdPrev, oldClosingCmdNext;
bool commandsAndClosingCommandsWereConsecutive = (ve.renderChainData.firstClosingCommand != null) && (oldCmdNext == ve.renderChainData.firstClosingCommand);
if (commandsAndClosingCommandsWereConsecutive)
{
oldCmdNext = ve.renderChainData.lastClosingCommand.next;
oldClosingCmdPrev = oldClosingCmdNext = null;
}
else
{
oldClosingCmdPrev = ve.renderChainData.firstClosingCommand?.prev;
oldClosingCmdNext = ve.renderChainData.lastClosingCommand?.next;
}
Debug.Assert(oldCmdPrev?.owner != ve);
Debug.Assert(oldCmdNext?.owner != ve);
Debug.Assert(oldClosingCmdPrev?.owner != ve);
Debug.Assert(oldClosingCmdNext?.owner != ve);
ResetCommands(renderChain, ve);
renderChain.ResetTextures(ve);
k_GenerateEntries.Begin();
var painter = renderChain.painter;
painter.Begin(ve);
if (ve.visible)
{
painter.DrawVisualElementBackground();
painter.DrawVisualElementBorder();
painter.ApplyVisualElementClipping();
InvokeGenerateVisualContent(ve, painter.meshGenerationContext);
}
else
{
// Even though the element hidden, we still have to push the stencil shape or setup the scissors in case any children are visible.
if (isClippingWithScissors || isClippingWithStencil)
{
painter.ApplyVisualElementClipping();
}
}
k_GenerateEntries.End();
MeshHandle data = ve.renderChainData.data;
if (painter.totalVertices > device.maxVerticesPerPage)
{
Debug.LogError($"A {nameof(VisualElement)} must not allocate more than {device.maxVerticesPerPage } vertices.");
if (data != null)
{
device.Free(data);
data = null;
}
renderChain.ResetTextures(ve);
// Restart without drawing anything.
painter.Reset();
painter.Begin(ve);
}
// Convert entries to commands.
var entries = painter.entries;
if (entries.Count > 0)
{
NativeSlice <Vertex> verts = new NativeSlice <Vertex>();
NativeSlice <UInt16> indices = new NativeSlice <UInt16>();
UInt16 indexOffset = 0;
if (painter.totalVertices > 0)
{
UpdateOrAllocate(ref data, painter.totalVertices, painter.totalIndices, device, out verts, out indices, out indexOffset, ref stats);
}
int vertsFilled = 0, indicesFilled = 0;
RenderChainCommand cmdPrev = oldCmdPrev, cmdNext = oldCmdNext;
if (oldCmdPrev == null && oldCmdNext == null)
{
FindCommandInsertionPoint(ve, out cmdPrev, out cmdNext);
}
// Vertex data, lazily computed
bool vertexDataComputed = false;
Matrix4x4 transform = Matrix4x4.identity;
Color32 xformClipPages = new Color32(0, 0, 0, 0);
Color32 ids = new Color32(0, 0, 0, 0);
Color32 addFlags = new Color32(0, 0, 0, 0);
Color32 opacityPage = new Color32(0, 0, 0, 0);
Color32 textCoreSettingsPage = new Color32(0, 0, 0, 0);
k_ConvertEntriesToCommandsMarker.Begin();
int firstDisplacementUV = -1, lastDisplacementUVPlus1 = -1;
foreach (var entry in painter.entries)
{
if (entry.vertices.Length > 0 && entry.indices.Length > 0)
{
if (!vertexDataComputed)
{
vertexDataComputed = true;
GetVerticesTransformInfo(ve, out transform);
ve.renderChainData.verticesSpace = transform; // This is the space for the generated vertices below
}
Color32 transformData = renderChain.shaderInfoAllocator.TransformAllocToVertexData(ve.renderChainData.transformID);
Color32 opacityData = renderChain.shaderInfoAllocator.OpacityAllocToVertexData(ve.renderChainData.opacityID);
Color32 textCoreSettingsData = renderChain.shaderInfoAllocator.TextCoreSettingsToVertexData(ve.renderChainData.textCoreSettingsID);
xformClipPages.r = transformData.r;
xformClipPages.g = transformData.g;
ids.r = transformData.b;
opacityPage.r = opacityData.r;
opacityPage.g = opacityData.g;
ids.b = opacityData.b;
if (entry.isTextEntry)
{
// It's important to avoid writing these values when the vertices aren't for text,
// as these settings are shared with the vector graphics gradients.
// The same applies to the CopyTransformVertsPos* methods below.
textCoreSettingsPage.r = textCoreSettingsData.r;
textCoreSettingsPage.g = textCoreSettingsData.g;
ids.a = textCoreSettingsData.b;
}
Color32 clipRectData = renderChain.shaderInfoAllocator.ClipRectAllocToVertexData(entry.clipRectID);
xformClipPages.b = clipRectData.r;
xformClipPages.a = clipRectData.g;
ids.g = clipRectData.b;
addFlags.r = (byte)entry.addFlags;
float textureId = entry.texture.ConvertToGpu();
// Copy vertices, transforming them as necessary
var targetVerticesSlice = verts.Slice(vertsFilled, entry.vertices.Length);
if (entry.uvIsDisplacement)
{
if (firstDisplacementUV < 0)
{
firstDisplacementUV = vertsFilled;
lastDisplacementUVPlus1 = vertsFilled + entry.vertices.Length;
}
else if (lastDisplacementUVPlus1 == vertsFilled)
{
lastDisplacementUVPlus1 += entry.vertices.Length;
}
else
{
ve.renderChainData.disableNudging = true; // Disjoint displacement UV entries, we can't keep track of them, so disable nudging optimization altogether
}
}
int entryIndexCount = entry.indices.Length;
int entryIndexOffset = vertsFilled + indexOffset;
var targetIndicesSlice = indices.Slice(indicesFilled, entryIndexCount);
bool shapeWindingIsClockwise = UIRUtility.ShapeWindingIsClockwise(entry.maskDepth, entry.stencilRef);
bool transformFlipsWinding = ve.renderChainData.worldFlipsWinding;
var job = new ConvertMeshJobData
{
vertSrc = (IntPtr)entry.vertices.GetUnsafePtr(),
vertDst = (IntPtr)targetVerticesSlice.GetUnsafePtr(),
vertCount = targetVerticesSlice.Length,
transform = transform,
transformUVs = entry.uvIsDisplacement ? 1 : 0,
xformClipPages = xformClipPages,
ids = ids,
addFlags = addFlags,
opacityPage = opacityPage,
textCoreSettingsPage = textCoreSettingsPage,
isText = entry.isTextEntry ? 1 : 0,
textureId = textureId,
indexSrc = (IntPtr)entry.indices.GetUnsafePtr(),
indexDst = (IntPtr)targetIndicesSlice.GetUnsafePtr(),
indexCount = targetIndicesSlice.Length,
indexOffset = entryIndexOffset,
flipIndices = shapeWindingIsClockwise == transformFlipsWinding ? 1 : 0
};
renderChain.jobManager.Add(ref job);
if (entry.isClipRegisterEntry)
{
painter.LandClipRegisterMesh(targetVerticesSlice, targetIndicesSlice, entryIndexOffset);
}
var cmd = InjectMeshDrawCommand(renderChain, ve, ref cmdPrev, ref cmdNext, data, entryIndexCount, indicesFilled, entry.material, entry.texture, entry.stencilRef);
if (entry.isTextEntry)
{
// Set font atlas texture gradient scale
cmd.state.sdfScale = entry.fontTexSDFScale;
}
vertsFilled += entry.vertices.Length;
indicesFilled += entryIndexCount;
}
else if (entry.customCommand != null)
{
InjectCommandInBetween(renderChain, entry.customCommand, ref cmdPrev, ref cmdNext);
}
else
{
Debug.Assert(false); // Unable to determine what kind of command to generate here
}
}
if (!ve.renderChainData.disableNudging && (firstDisplacementUV >= 0))
{
ve.renderChainData.displacementUVStart = firstDisplacementUV;
ve.renderChainData.displacementUVEnd = lastDisplacementUVPlus1;
}
k_ConvertEntriesToCommandsMarker.End();
}
else if (data != null)
{
device.Free(data);
data = null;
}
ve.renderChainData.data = data;
if (painter.closingInfo.clipperRegisterIndices.Length == 0 && ve.renderChainData.closingData != null)
{
// No more closing data needed, so free it now
device.Free(ve.renderChainData.closingData);
ve.renderChainData.closingData = null;
}
if (painter.closingInfo.needsClosing)
{
k_GenerateClosingCommandsMarker.Begin();
RenderChainCommand cmdPrev = oldClosingCmdPrev, cmdNext = oldClosingCmdNext;
if (commandsAndClosingCommandsWereConsecutive)
{
cmdPrev = ve.renderChainData.lastCommand;
cmdNext = cmdPrev.next;
}
else if (cmdPrev == null && cmdNext == null)
{
FindClosingCommandInsertionPoint(ve, out cmdPrev, out cmdNext);
}
if (painter.closingInfo.PopDefaultMaterial)
{
var cmd = renderChain.AllocCommand();
cmd.type = CommandType.PopDefaultMaterial;
cmd.closing = true;
cmd.owner = ve;
InjectClosingCommandInBetween(renderChain, cmd, ref cmdPrev, ref cmdNext);
}
if (painter.closingInfo.blitAndPopRenderTexture)
{
{
var cmd = renderChain.AllocCommand();
cmd.type = CommandType.BlitToPreviousRT;
cmd.closing = true;
cmd.owner = ve;
cmd.state.material = GetBlitMaterial(ve.subRenderTargetMode);
Debug.Assert(cmd.state.material != null);
InjectClosingCommandInBetween(renderChain, cmd, ref cmdPrev, ref cmdNext);
}
{
var cmd = renderChain.AllocCommand();
cmd.type = CommandType.PopRenderTexture;
cmd.closing = true;
cmd.owner = ve;
InjectClosingCommandInBetween(renderChain, cmd, ref cmdPrev, ref cmdNext);
}
}
if (painter.closingInfo.clipperRegisterIndices.Length > 0)
{
var cmd = InjectClosingMeshDrawCommand(renderChain, ve, ref cmdPrev, ref cmdNext, null, 0, 0, null, TextureId.invalid, painter.closingInfo.maskStencilRef);
painter.LandClipUnregisterMeshDrawCommand(cmd); // Placeholder command that will be filled actually later
}
if (painter.closingInfo.popViewMatrix)
{
var cmd = renderChain.AllocCommand();
cmd.type = CommandType.PopView;
cmd.closing = true;
cmd.owner = ve;
InjectClosingCommandInBetween(renderChain, cmd, ref cmdPrev, ref cmdNext);
}
if (painter.closingInfo.popScissorClip)
{
var cmd = renderChain.AllocCommand();
cmd.type = CommandType.PopScissor;
cmd.closing = true;
cmd.owner = ve;
InjectClosingCommandInBetween(renderChain, cmd, ref cmdPrev, ref cmdNext);
}
k_GenerateClosingCommandsMarker.End();
}
// When we have a closing mesh, we must have an opening mesh. At least we assumed where we decide
// whether we must nudge or not: we only test whether the opening mesh is non-null.
Debug.Assert(ve.renderChainData.closingData == null || ve.renderChainData.data != null);
var closingInfo = painter.closingInfo;
painter.Reset();
return(closingInfo);
}
internal void ExecuteNonDrawMesh(DrawParams drawParams, float pixelsPerPoint, ref Exception immediateException)
{
switch (type)
{
case CommandType.ImmediateCull:
{
RectInt worldRect = RectPointsToPixelsAndFlipYAxis(owner.worldBound, pixelsPerPoint);
if (!worldRect.Overlaps(Utility.GetActiveViewport()))
{
break;
}
// Element isn't culled, follow through the normal immediate callback procedure
goto case CommandType.Immediate;
}
case CommandType.Immediate:
{
if (immediateException != null)
{
break;
}
s_ImmediateOverheadMarker.Begin();
Matrix4x4 oldProjection = Utility.GetUnityProjectionMatrix();
Camera oldCamera = Camera.current;
RenderTexture oldRT = RenderTexture.active;
bool hasScissor = drawParams.scissor.Count > 1; // We always expect the "unbound" scissor rectangle to exists
if (hasScissor)
{
Utility.DisableScissor(); // Disable scissor since most IMGUI code assume it's inactive
}
using (new GUIClip.ParentClipScope(owner.worldTransform, owner.worldClip))
{
s_ImmediateOverheadMarker.End();
try
{
callback();
}
catch (Exception e)
{
immediateException = e;
}
s_ImmediateOverheadMarker.Begin();
}
Camera.SetupCurrent(oldCamera);
RenderTexture.active = oldRT;
GL.modelview = drawParams.view.Peek().transform;
GL.LoadProjectionMatrix(oldProjection);
if (hasScissor)
{
Utility.SetScissorRect(RectPointsToPixelsAndFlipYAxis(drawParams.scissor.Peek(), pixelsPerPoint));
}
s_ImmediateOverheadMarker.End();
break;
}
case CommandType.PushView:
var parent = owner.hierarchy.parent;
Vector4 clipRect;
if (parent != null)
{
clipRect = RectToClipSpace(parent.worldClip);
}
else
{
clipRect = UIRUtility.ToVector4(DrawParams.k_FullNormalizedRect);
}
var vt = new ViewTransform()
{
transform = owner.worldTransform, clipRect = clipRect
};
drawParams.view.Push(vt);
GL.modelview = vt.transform;
break;
case CommandType.PopView:
drawParams.view.Pop();
GL.modelview = drawParams.view.Peek().transform;
break;
case CommandType.PushScissor:
Rect elemRect = CombineScissorRects(owner.worldClip, drawParams.scissor.Peek());
drawParams.scissor.Push(elemRect);
Utility.SetScissorRect(RectPointsToPixelsAndFlipYAxis(elemRect, pixelsPerPoint));
break;
case CommandType.PopScissor:
drawParams.scissor.Pop();
Rect prevRect = drawParams.scissor.Peek();
if (prevRect.x == DrawParams.k_UnlimitedRect.x)
{
Utility.DisableScissor();
}
else
{
Utility.SetScissorRect(RectPointsToPixelsAndFlipYAxis(prevRect, pixelsPerPoint));
}
break;
case CommandType.PushRenderTexture:
{
RectInt viewport = Utility.GetActiveViewport();
RenderTexture rt = RenderTexture.GetTemporary(viewport.width, viewport.height, 24, RenderTextureFormat.ARGBHalf);
RenderTexture.active = rt;
GL.Clear(true, true, new Color(0, 0, 0, 0), UIRUtility.k_ClearZ);
drawParams.renderTexture.Add(RenderTexture.active);
break;
}
case CommandType.PopRenderTexture:
{
int index = drawParams.renderTexture.Count - 1;
Debug.Assert(index > 0); //Check that we have something to pop, We should never pop the last(original)one
// Only supported use case for now is to do a blit befor the pop.
// This should set the active RenderTexture to index-1 and we should not have this warning.
Debug.Assert(drawParams.renderTexture[index - 1] == RenderTexture.active, "Content of previous render texture was probably not blitted");
var rt = drawParams.renderTexture[index];
if (rt != null)
{
RenderTexture.ReleaseTemporary(rt);
}
drawParams.renderTexture.RemoveAt(index);
}
break;
case CommandType.BlitToPreviousRT:
{
// Currently the command only blit to the previous RT, but this could be expanded if we use
// indexCount and indexOffset to point to specific indices in the renderTextureBuffer.
// The main difficulty is to memorize the current renderTexture depth to get the indices in the RenderChain
// as we can edit the stack in the middle and that would requires rewriting previous/ subsequent commands
//Also, there is currently no way to have a permanently assigned rt to be used as cache.
var source = drawParams.renderTexture[drawParams.renderTexture.Count - 1];
var destination = drawParams.renderTexture[drawParams.renderTexture.Count - 2];
// Note: Graphics.Blit set the arctive RT => RT is not restored and it is expected to be chaged before PopRenderTexture
//TODO check blit code for other side effect
Debug.Assert(source == RenderTexture.active, "Unexpected render target change: Current renderTarget is not the one on the top of the stack");
//The following lines are equivalent to
//Graphics.Blit(source, destination, state.material);
//except the vertex are at the specified depth
Blit(source, destination, UIRUtility.k_MeshPosZ);
}
break;
//Logic of both command is entirely in UIRenderDevice as it need access to the local variable defaultMat
case CommandType.PushDefaultMaterial:
break;
case CommandType.PopDefaultMaterial:
break;
}
}
static Row[] BuildRowArray(int maxRowHeight, int rowHeightBias)
{
int n = UIRUtility.GetNextPow2Exp(maxRowHeight - rowHeightBias) + 1;
return(new Row[n]);
}
