private void PaintSubTreeChildren(Event e, VisualElement root, Matrix4x4 offset, VisualElement.ClippingOptions clippingOption, Rect textureClip) { int count = root.shadow.childCount; for (int i = 0; i < count; i++) { VisualElement child = root.shadow[i]; PaintSubTree(e, child, offset, clippingOption, textureClip); if (count != root.shadow.childCount) { throw new NotImplementedException("Visual tree is read-only during repaint"); } } }
private void PaintSubTree(Event e, VisualElement root, Matrix4x4 offset, VisualElement.ClippingOptions clippingOption, Rect currentGlobalClip) { if (root == null || root.panel != this) { return; } if (root.visible == false || root.style.opacity.GetSpecifiedValueOrDefault(1.0f) < Mathf.Epsilon) { return; } // update clip if (root.clippingOptions != VisualElement.ClippingOptions.NoClipping) { var worldBound = ComputeAAAlignedBound(root.rect, offset * root.worldTransform); // are we and our children clipped? if (!worldBound.Overlaps(currentGlobalClip)) { return; } float x1 = Mathf.Max(worldBound.x, currentGlobalClip.x); float x2 = Mathf.Min(worldBound.xMax, currentGlobalClip.xMax); float y1 = Mathf.Max(worldBound.y, currentGlobalClip.y); float y2 = Mathf.Min(worldBound.yMax, currentGlobalClip.yMax); // new global clip and hierarchical clip space option. currentGlobalClip = new Rect(x1, y1, x2 - x1, y2 - y1); clippingOption = root.clippingOptions; } else { //since our children are not clipped, there is no early out. } // Check for the rotated space - clipping issue. if (!whinedOnceAboutRotatedClipSpaceThisFrame && clippingOption == VisualElement.ClippingOptions.ClipContents && DoesMatrixHaveUnsupportedRotation(root.worldTransform)) { Debug.LogError("Panel.PaintSubTree - Rotated clip-spaces are only supported by the VisualElement.ClippingOptions.ClipAndCacheContents mode. First offending Panel:'" + root.name + "'."); whinedOnceAboutRotatedClipSpaceThisFrame = true; } if (ShouldUsePixelCache(root)) { // now actually paint the texture to previous group IStylePainter painter = stylePainter; // validate cache texture size first var worldBound = root.worldBound; Rect alignedRect; int textureWidth, textureHeight; painter.currentWorldClip = currentGlobalClip; painter.currentTransform = offset * root.worldTransform; using (new GUIClip.ParentClipScope(painter.currentTransform, currentGlobalClip)) { alignedRect = GUIUtility.AlignRectToDevice(root.rect, out textureWidth, out textureHeight); } // Prevent the texture size from going empty, which may occur if the element has a sub-pixel size textureWidth = Math.Max(textureWidth, 1); textureHeight = Math.Max(textureHeight, 1); var cache = root.renderData.pixelCache; if (cache != null && (cache.width != textureWidth || cache.height != textureHeight) && (!keepPixelCacheOnWorldBoundChange || root.IsDirty(ChangeType.Repaint))) { Object.DestroyImmediate(cache); cache = root.renderData.pixelCache = null; } // if the child node world transforms are not up to date due to changes below the pixel cache this is fine. if (root.IsDirty(ChangeType.Repaint) || root.renderData.pixelCache == null || !root.renderData.pixelCache.IsCreated()) { // Recreate as needed if (cache == null) { root.renderData.pixelCache = cache = new RenderTexture( textureWidth, textureHeight, 32, // depth RenderTextureFormat.ARGB32, RenderTextureReadWrite.sRGB); } bool hasRoundedBorderRects = (root.style.borderTopLeftRadius > 0 || root.style.borderTopRightRadius > 0 || root.style.borderBottomLeftRadius > 0 || root.style.borderBottomRightRadius > 0); RenderTexture temporaryTexture = null; var old = RenderTexture.active; try { // We first render to a temp texture, then blit the result into the result pixelCache again to mask the rounder corners if (hasRoundedBorderRects) { temporaryTexture = cache = RenderTexture.GetTemporary(textureWidth, textureHeight, 32, RenderTextureFormat.ARGB32, RenderTextureReadWrite.sRGB); } // render the texture again to clip the round rect borders RenderTexture.active = cache; GL.Clear(true, true, new Color(0, 0, 0, 0)); // Calculate the offset required to translate the origin of the rect to the upper left corner // of the pixel cache. We need to round because the rect will be rounded when rendered. Rect worldAlignedRect = root.LocalToWorld(alignedRect); var childrenOffset = Matrix4x4.Translate(new Vector3(-worldAlignedRect.x, -worldAlignedRect.y, 0)); Matrix4x4 offsetWorldTransform = childrenOffset * root.worldTransform; // reset clipping var textureClip = new Rect(0, 0, worldAlignedRect.width, worldAlignedRect.height); painter.currentTransform = offsetWorldTransform; // Metal ignores the sRGBWrite flag and will always do linear to gamma conversions // when writing to an sRGB buffer. In this situation, we disable the manual sRGB // conversion since it will be done automatically when writing to the framebuffer. bool manualTex2SRGBEnabled = (SystemInfo.graphicsDeviceType != GraphicsDeviceType.Metal); using (new GUIUtility.ManualTex2SRGBScope(manualTex2SRGBEnabled)) using (new GUIClip.ParentClipScope(painter.currentTransform, textureClip)) { // Paint self painter.currentWorldClip = textureClip; stylePainter.opacity = root.style.opacity.GetSpecifiedValueOrDefault(1.0f); root.DoRepaint(painter); stylePainter.opacity = 1.0f; root.ClearDirty(ChangeType.Repaint); PaintSubTreeChildren(e, root, childrenOffset, clippingOption, textureClip); } if (hasRoundedBorderRects) { RenderTexture.active = root.renderData.pixelCache; // Fix up transform for subtree to match texture upper left. painter.currentTransform = Matrix4x4.identity; using (new GUIUtility.ManualTex2SRGBScope(manualTex2SRGBEnabled)) using (new GUIClip.ParentClipScope(painter.currentTransform, textureClip)) { GL.Clear(true, true, new Color(0, 0, 0, 0)); var textureParams = painter.GetDefaultTextureParameters(root); textureParams.texture = cache; textureParams.scaleMode = ScaleMode.StretchToFill; textureParams.rect = textureClip; textureParams.border.SetWidth(0.0f); // The rect of the temporary texture implicitly carries the scale factor of the // transform. Since we are blitting with an identity matrix, we need to scale the // radius manually. // We assume uniform positive scaling without rotations. Vector4 toScale = new Vector4(1, 0, 0, 0); Vector4 scaled = offsetWorldTransform * toScale; float radiusScale = scaled.x; textureParams.border.SetRadius( textureParams.border.topLeftRadius * radiusScale, textureParams.border.topRightRadius * radiusScale, textureParams.border.bottomRightRadius * radiusScale, textureParams.border.bottomLeftRadius * radiusScale); // No border is drawn but the rounded corners are clipped properly. // Use premultiply alpha to avoid blending again. textureParams.usePremultiplyAlpha = true; painter.DrawTexture(textureParams); } // Redraw the border (border was already drawn in first root.DoRepaint call). painter.currentTransform = offsetWorldTransform; using (new GUIUtility.ManualTex2SRGBScope(manualTex2SRGBEnabled)) using (new GUIClip.ParentClipScope(painter.currentTransform, textureClip)) { painter.DrawBorder(root); } } } finally { cache = null; if (temporaryTexture != null) { RenderTexture.ReleaseTemporary(temporaryTexture); } RenderTexture.active = old; } } // now actually paint the texture to previous group painter.currentWorldClip = currentGlobalClip; painter.currentTransform = offset * root.worldTransform; using (new GUIClip.ParentClipScope(painter.currentTransform, currentGlobalClip)) { var painterParams = new TextureStylePainterParameters { rect = GUIUtility.AlignRectToDevice(root.rect), uv = new Rect(0, 0, 1, 1), texture = root.renderData.pixelCache, color = Color.white, scaleMode = ScaleMode.StretchToFill, usePremultiplyAlpha = true }; painter.DrawTexture(painterParams); } } else { stylePainter.currentTransform = offset * root.worldTransform; using (new GUIClip.ParentClipScope(stylePainter.currentTransform, currentGlobalClip)) { stylePainter.currentWorldClip = currentGlobalClip; stylePainter.mousePosition = root.worldTransform.inverse.MultiplyPoint3x4(e.mousePosition); stylePainter.opacity = root.style.opacity.GetSpecifiedValueOrDefault(1.0f); root.DoRepaint(stylePainter); stylePainter.opacity = 1.0f; root.ClearDirty(ChangeType.Repaint); PaintSubTreeChildren(e, root, offset, clippingOption, currentGlobalClip); } } }