コード例 #1
0
 private static void TessellateRectInternal(ref MeshGenerationContextUtils.RectangleParams rectParams, float posZ, VertexFlags vertexFlags, NativeSlice <Vertex>?vertices, NativeSlice <UInt16>?indices, ref UInt16 vertexCount, ref UInt16 indexCount, bool countOnly = false)
 {
     if (!rectParams.HasRadius(kEpsilon))
     {
         UInt16 indexOffset = 0;
         TessellateQuad(rectParams.rect, TessellationType.Content, rectParams.color, posZ, vertexFlags, vertices, indices, ref indexOffset, ref vertexCount, ref indexCount, countOnly);
     }
     else
     {
         TessellateRoundedCorners(ref rectParams, posZ, vertexFlags, vertices, indices, ref vertexCount, ref indexCount, countOnly);
     }
 }
コード例 #2
0
        internal static void MakeSolidRect(MeshGenerationContextUtils.RectangleParams rectParams, float posZ, MeshBuilder.AllocMeshData meshAlloc)
        {
            bool flag = !rectParams.HasRadius(Tessellation.kEpsilon);

            if (flag)
            {
                MeshBuilder.MakeQuad(rectParams.rect, Rect.zero, rectParams.color, posZ, meshAlloc);
            }
            else
            {
                Tessellation.TessellateRect(rectParams, posZ, meshAlloc, false);
            }
        }
コード例 #3
0
        public void DrawVisualElementBackground()
        {
            bool flag = this.currentElement.layout.width <= Mathf.Epsilon || this.currentElement.layout.height <= Mathf.Epsilon;

            if (!flag)
            {
                ComputedStyle computedStyle = this.currentElement.computedStyle;
                bool          flag2         = computedStyle.backgroundColor != Color.clear;
                if (flag2)
                {
                    MeshGenerationContextUtils.RectangleParams rectParams = new MeshGenerationContextUtils.RectangleParams
                    {
                        rect              = GUIUtility.AlignRectToDevice(this.currentElement.rect),
                        color             = computedStyle.backgroundColor.value,
                        playmodeTintColor = ((this.currentElement.panel.contextType == ContextType.Editor) ? UIElementsUtility.editorPlayModeTintColor : Color.white)
                    };
                    MeshGenerationContextUtils.GetVisualElementRadii(this.currentElement, out rectParams.topLeftRadius, out rectParams.bottomLeftRadius, out rectParams.topRightRadius, out rectParams.bottomRightRadius);
                    this.DrawRectangle(rectParams);
                }
                Background value = computedStyle.backgroundImage.value;
                bool       flag3 = value.texture != null || value.vectorImage != null;
                if (flag3)
                {
                    MeshGenerationContextUtils.RectangleParams rectParams2 = default(MeshGenerationContextUtils.RectangleParams);
                    bool flag4 = value.texture != null;
                    if (flag4)
                    {
                        rectParams2 = MeshGenerationContextUtils.RectangleParams.MakeTextured(GUIUtility.AlignRectToDevice(this.currentElement.rect), new Rect(0f, 0f, 1f, 1f), value.texture, computedStyle.unityBackgroundScaleMode.value, this.currentElement.panel.contextType);
                    }
                    else
                    {
                        bool flag5 = value.vectorImage != null;
                        if (flag5)
                        {
                            rectParams2 = MeshGenerationContextUtils.RectangleParams.MakeVectorTextured(GUIUtility.AlignRectToDevice(this.currentElement.rect), new Rect(0f, 0f, 1f, 1f), value.vectorImage, computedStyle.unityBackgroundScaleMode.value, this.currentElement.panel.contextType);
                        }
                    }
                    MeshGenerationContextUtils.GetVisualElementRadii(this.currentElement, out rectParams2.topLeftRadius, out rectParams2.bottomLeftRadius, out rectParams2.topRightRadius, out rectParams2.bottomRightRadius);
                    rectParams2.leftSlice   = computedStyle.unitySliceLeft.value;
                    rectParams2.topSlice    = computedStyle.unitySliceTop.value;
                    rectParams2.rightSlice  = computedStyle.unitySliceRight.value;
                    rectParams2.bottomSlice = computedStyle.unitySliceBottom.value;
                    bool flag6 = computedStyle.unityBackgroundImageTintColor != Color.clear;
                    if (flag6)
                    {
                        rectParams2.color = computedStyle.unityBackgroundImageTintColor.value;
                    }
                    this.DrawRectangle(rectParams2);
                }
            }
        }
コード例 #4
0
        private static void TessellateRoundedCorners(ref MeshGenerationContextUtils.RectangleParams rectParams, float posZ, MeshWriteData mesh, ref UInt16 vertexCount, ref UInt16 indexCount, bool countOnly)
        {
            // To tessellate the 4 corners, the rect is divided in 4 quadrants and every quadrant is computed as if they were the top-left corner.
            // The quadrants are then mirrored and the triangles winding flipped as necessary.
            UInt16 indexOffset = 0;
            UInt16 startVc = 0, startIc = 0;
            var    halfSize    = new Vector2(rectParams.rect.width * 0.5f, rectParams.rect.height * 0.5f);
            var    quarterRect = new Rect(rectParams.rect.x, rectParams.rect.y, halfSize.x, halfSize.y);

            // Top-left
            TessellateRoundedCorner(quarterRect, rectParams.color, posZ, rectParams.topLeftRadius, mesh, ref indexOffset, ref vertexCount, ref indexCount, countOnly);

            // Top-right
            startVc = vertexCount;
            startIc = indexCount;
            TessellateRoundedCorner(quarterRect, rectParams.color, posZ, rectParams.topRightRadius, mesh, ref indexOffset, ref vertexCount, ref indexCount, countOnly);
            if (!countOnly)
            {
                MirrorVertices(quarterRect, mesh.m_Vertices, startVc, vertexCount - startVc, true);
                FlipWinding(mesh.m_Indices, startIc, indexCount - startIc);
            }

            // Bottom-right
            startVc = vertexCount;
            startIc = indexCount;
            TessellateRoundedCorner(quarterRect, rectParams.color, posZ, rectParams.bottomRightRadius, mesh, ref indexOffset, ref vertexCount, ref indexCount, countOnly);
            if (!countOnly)
            {
                MirrorVertices(quarterRect, mesh.m_Vertices, startVc, vertexCount - startVc, true);
                MirrorVertices(quarterRect, mesh.m_Vertices, startVc, vertexCount - startVc, false);
            }

            // Bottom-left
            startVc = vertexCount;
            startIc = indexCount;
            TessellateRoundedCorner(quarterRect, rectParams.color, posZ, rectParams.bottomLeftRadius, mesh, ref indexOffset, ref vertexCount, ref indexCount, countOnly);
            if (!countOnly)
            {
                MirrorVertices(quarterRect, mesh.m_Vertices, startVc, vertexCount - startVc, false);
                FlipWinding(mesh.m_Indices, startIc, indexCount - startIc);
            }
        }
コード例 #5
0
        internal static void MakeVectorGraphics(MeshGenerationContextUtils.RectangleParams rectParams, int settingIndexOffset, AllocMeshData meshAlloc, out int finalVertexCount, out int finalIndexCount)
        {
            var vi = rectParams.vectorImage;

            Debug.Assert(vi != null);

            finalVertexCount = 0;
            finalIndexCount  = 0;

            if (rectParams.leftSlice <= Mathf.Epsilon &&
                rectParams.topSlice <= Mathf.Epsilon &&
                rectParams.rightSlice <= Mathf.Epsilon &&
                rectParams.bottomSlice <= Mathf.Epsilon)
            {
                MeshBuilder.MakeVectorGraphicsStretchBackground(vi.vertices, vi.indices, vi.size.x, vi.size.y, rectParams.rect, rectParams.uv, rectParams.scaleMode, rectParams.color, settingIndexOffset, meshAlloc, out finalVertexCount, out finalIndexCount);
            }
            else
            {
                var sliceLTRB = new Vector4(rectParams.leftSlice, rectParams.topSlice, rectParams.rightSlice, rectParams.bottomSlice);
                MeshBuilder.MakeVectorGraphics9SliceBackground(vi.vertices, vi.indices, vi.size.x, vi.size.y, rectParams.rect, sliceLTRB, true, rectParams.color, settingIndexOffset, meshAlloc);
            }
        }
コード例 #6
0
        internal static void MakeVectorGraphics(MeshGenerationContextUtils.RectangleParams rectParams, int settingIndexOffset, AllocMeshData meshAlloc, out int finalVertexCount, out int finalIndexCount)
        {
            var vi = rectParams.vectorImage;

            Debug.Assert(vi != null);

            finalVertexCount = 0;
            finalIndexCount  = 0;

            // Convert the VectorImage's serializable vertices to Vertex instances
            int vertexCount = vi.vertices.Length;
            var vertices    = new Vertex[vertexCount];

            for (int i = 0; i < vertexCount; ++i)
            {
                var v = vi.vertices[i];
                vertices[i] = new Vertex()
                {
                    position = v.position,
                    tint     = v.tint,
                    uv       = v.uv,
                    opacityPageSVGSettingIndex = new Color32(0, 0, (byte)(v.settingIndex >> 8), (byte)v.settingIndex)
                };
            }

            if (rectParams.leftSlice <= Mathf.Epsilon &&
                rectParams.topSlice <= Mathf.Epsilon &&
                rectParams.rightSlice <= Mathf.Epsilon &&
                rectParams.bottomSlice <= Mathf.Epsilon)
            {
                MeshBuilder.MakeVectorGraphicsStretchBackground(vertices, vi.indices, vi.size.x, vi.size.y, rectParams.rect, rectParams.uv, rectParams.scaleMode, rectParams.color, settingIndexOffset, meshAlloc, out finalVertexCount, out finalIndexCount);
            }
            else
            {
                var sliceLTRB = new Vector4(rectParams.leftSlice, rectParams.topSlice, rectParams.rightSlice, rectParams.bottomSlice);
                MeshBuilder.MakeVectorGraphics9SliceBackground(vertices, vi.indices, vi.size.x, vi.size.y, rectParams.rect, sliceLTRB, true, rectParams.color, settingIndexOffset, meshAlloc);
            }
        }
コード例 #7
0
 private static void CountRectTriangles(ref MeshGenerationContextUtils.RectangleParams rectParams, ref UInt16 vertexCount, ref UInt16 indexCount)
 {
     // To count the required triangles, we call the tessellation method with a "countOnly=true" flag, which skips
     // tessellation and only update the vertex and index counts.
     TessellateRectInternal(ref rectParams, 0, null, ref vertexCount, ref indexCount, true);
 }
コード例 #8
0
        internal static void MakeSlicedQuad(ref MeshGenerationContextUtils.RectangleParams rectParams, float posZ, AllocMeshData meshAlloc)
        {
            var mesh = meshAlloc.Allocate(16, 9 * 6);

            float pixelsPerPoint = 1;
            var   texture2D      = rectParams.texture as Texture2D;

            if (texture2D != null)
            {
                pixelsPerPoint = texture2D.pixelsPerPoint;
            }

            float texWidth    = rectParams.texture.width;
            float texHeight   = rectParams.texture.height;
            float uConversion = pixelsPerPoint / texWidth;
            float vConversion = pixelsPerPoint / texHeight;

            float leftSlice   = Mathf.Max(0.0f, rectParams.leftSlice);
            float rightSlice  = Mathf.Max(0.0f, rectParams.rightSlice);
            float bottomSlice = Mathf.Max(0.0f, rectParams.bottomSlice);
            float topSlice    = Mathf.Max(0.0f, rectParams.topSlice);

            // Clamp UVs in the [0,1] range
            float uvLeftSlice   = Mathf.Clamp(leftSlice * uConversion, 0.0f, 1.0f);
            float uvRightSlice  = Mathf.Clamp(rightSlice * uConversion, 0.0f, 1.0f);
            float uvBottomSlice = Mathf.Clamp(bottomSlice * vConversion, 0.0f, 1.0f);
            float uvTopslice    = Mathf.Clamp(topSlice * vConversion, 0.0f, 1.0f);

            k_TexCoordSlicesX[0] = rectParams.uv.min.x;
            k_TexCoordSlicesX[1] = rectParams.uv.min.x + uvLeftSlice;
            k_TexCoordSlicesX[2] = rectParams.uv.max.x - uvRightSlice;
            k_TexCoordSlicesX[3] = rectParams.uv.max.x;

            k_TexCoordSlicesY[0] = rectParams.uv.max.y;
            k_TexCoordSlicesY[1] = rectParams.uv.max.y - uvBottomSlice;
            k_TexCoordSlicesY[2] = rectParams.uv.min.y + uvTopslice;
            k_TexCoordSlicesY[3] = rectParams.uv.min.y;

            var uvRegion = mesh.uvRegion;

            for (int i = 0; i < 4; i++)
            {
                k_TexCoordSlicesX[i] = k_TexCoordSlicesX[i] * uvRegion.width + uvRegion.xMin;
                k_TexCoordSlicesY[i] = (rectParams.uv.min.y + rectParams.uv.max.y - k_TexCoordSlicesY[i]) * uvRegion.height + uvRegion.yMin;
            }

            // Prevent overlapping slices
            float sliceWidth = (leftSlice + rightSlice);

            if (sliceWidth > rectParams.rect.width)
            {
                float rescale = rectParams.rect.width / sliceWidth;
                leftSlice  *= rescale;
                rightSlice *= rescale;
            }

            float sliceHeight = (bottomSlice + topSlice);

            if (sliceHeight > rectParams.rect.height)
            {
                float rescale = rectParams.rect.height / sliceHeight;
                bottomSlice *= rescale;
                topSlice    *= rescale;
            }

            k_PositionSlicesX[0] = rectParams.rect.x;
            k_PositionSlicesX[1] = rectParams.rect.x + leftSlice;
            k_PositionSlicesX[2] = rectParams.rect.xMax - rightSlice;
            k_PositionSlicesX[3] = rectParams.rect.xMax;

            k_PositionSlicesY[0] = rectParams.rect.yMax;
            k_PositionSlicesY[1] = rectParams.rect.yMax - bottomSlice;
            k_PositionSlicesY[2] = rectParams.rect.y + topSlice;
            k_PositionSlicesY[3] = rectParams.rect.y;

            for (int i = 0; i < 16; ++i)
            {
                int x = i % 4;
                int y = i / 4;
                mesh.SetNextVertex(new Vertex()
                {
                    position = new Vector3(k_PositionSlicesX[x], k_PositionSlicesY[y], posZ),
                    uv       = new Vector2(k_TexCoordSlicesX[x], k_TexCoordSlicesY[y]),
                    tint     = rectParams.color
                });
            }
            mesh.SetAllIndices(slicedQuadIndices);
        }
コード例 #9
0
 public void DrawRectangle(MeshGenerationContextUtils.RectangleParams rectParams)
 {
 }
コード例 #10
0
        internal static void MakeSlicedQuad(ref MeshGenerationContextUtils.RectangleParams rectParams, float posZ, MeshBuilder.AllocMeshData meshAlloc)
        {
            MeshWriteData meshWriteData = meshAlloc.Allocate(16u, 54u);
            float         num           = 1f;
            Texture2D     texture2D     = rectParams.texture as Texture2D;
            bool          flag          = texture2D != null;

            if (flag)
            {
                num = texture2D.pixelsPerPoint;
            }
            float num2  = (float)rectParams.texture.width;
            float num3  = (float)rectParams.texture.height;
            float num4  = num / num2;
            float num5  = num / num3;
            float num6  = Mathf.Max(0f, (float)rectParams.leftSlice);
            float num7  = Mathf.Max(0f, (float)rectParams.rightSlice);
            float num8  = Mathf.Max(0f, (float)rectParams.bottomSlice);
            float num9  = Mathf.Max(0f, (float)rectParams.topSlice);
            float num10 = Mathf.Clamp(num6 * num4, 0f, 1f);
            float num11 = Mathf.Clamp(num7 * num4, 0f, 1f);
            float num12 = Mathf.Clamp(num8 * num5, 0f, 1f);
            float num13 = Mathf.Clamp(num9 * num5, 0f, 1f);

            MeshBuilder.k_TexCoordSlicesX[0] = rectParams.uv.min.x;
            MeshBuilder.k_TexCoordSlicesX[1] = rectParams.uv.min.x + num10;
            MeshBuilder.k_TexCoordSlicesX[2] = rectParams.uv.max.x - num11;
            MeshBuilder.k_TexCoordSlicesX[3] = rectParams.uv.max.x;
            MeshBuilder.k_TexCoordSlicesY[0] = rectParams.uv.max.y;
            MeshBuilder.k_TexCoordSlicesY[1] = rectParams.uv.max.y - num12;
            MeshBuilder.k_TexCoordSlicesY[2] = rectParams.uv.min.y + num13;
            MeshBuilder.k_TexCoordSlicesY[3] = rectParams.uv.min.y;
            Rect uvRegion = meshWriteData.uvRegion;

            for (int i = 0; i < 4; i++)
            {
                MeshBuilder.k_TexCoordSlicesX[i] = MeshBuilder.k_TexCoordSlicesX[i] * uvRegion.width + uvRegion.xMin;
                MeshBuilder.k_TexCoordSlicesY[i] = (rectParams.uv.min.y + rectParams.uv.max.y - MeshBuilder.k_TexCoordSlicesY[i]) * uvRegion.height + uvRegion.yMin;
            }
            float num14 = num6 + num7;
            bool  flag2 = num14 > rectParams.rect.width;

            if (flag2)
            {
                float num15 = rectParams.rect.width / num14;
                num6 *= num15;
                num7 *= num15;
            }
            float num16 = num8 + num9;
            bool  flag3 = num16 > rectParams.rect.height;

            if (flag3)
            {
                float num17 = rectParams.rect.height / num16;
                num8 *= num17;
                num9 *= num17;
            }
            MeshBuilder.k_PositionSlicesX[0] = rectParams.rect.x;
            MeshBuilder.k_PositionSlicesX[1] = rectParams.rect.x + num6;
            MeshBuilder.k_PositionSlicesX[2] = rectParams.rect.xMax - num7;
            MeshBuilder.k_PositionSlicesX[3] = rectParams.rect.xMax;
            MeshBuilder.k_PositionSlicesY[0] = rectParams.rect.yMax;
            MeshBuilder.k_PositionSlicesY[1] = rectParams.rect.yMax - num8;
            MeshBuilder.k_PositionSlicesY[2] = rectParams.rect.y + num9;
            MeshBuilder.k_PositionSlicesY[3] = rectParams.rect.y;
            for (int j = 0; j < 16; j++)
            {
                int num18 = j % 4;
                int num19 = j / 4;
                meshWriteData.SetNextVertex(new Vertex
                {
                    position = new Vector3(MeshBuilder.k_PositionSlicesX[num18], MeshBuilder.k_PositionSlicesY[num19], posZ),
                    uv       = new Vector2(MeshBuilder.k_TexCoordSlicesX[num18], MeshBuilder.k_TexCoordSlicesY[num19]),
                    tint     = rectParams.color
                });
            }
            meshWriteData.SetAllIndices(MeshBuilder.slicedQuadIndices);
        }