private static void TessellateBorderedFan(TessellationType tessellationType, Vector2 center, Vector2 radius, float leftWidth, float topWidth, Color color, float posZ, MeshWriteData mesh, ref UInt16 indexOffset, ref UInt16 vertexCount, ref UInt16 indexCount, bool countOnly)
{
if (countOnly)
{
vertexCount += (UInt16)(kSubdivisions * 2);
indexCount += (UInt16)((kSubdivisions - 1) * 6);
return;
}
float innerVertexFlags, outerVertexFlags;
if (tessellationType == TessellationType.EdgeCorner)
{
innerVertexFlags = (float)VertexFlags.IsEdge;
outerVertexFlags = (float)VertexFlags.IsSolid;
}
else
{
innerVertexFlags = outerVertexFlags = (float)mesh.m_Flags;
}
var a = radius.x - leftWidth;
var b = radius.y - topWidth;
var p = new Vector2(center.x - radius.x, center.y);
var q = new Vector2(center.x - a, center.y);
mesh.SetNextVertex(new Vertex {
position = new Vector3(q.x, q.y, posZ), uv = q - p, tint = color, flags = innerVertexFlags
});
mesh.SetNextVertex(new Vertex {
position = new Vector3(p.x, p.y, posZ), uv = p - q, tint = color, flags = outerVertexFlags
});
vertexCount += 2;
for (int k = 1; k < kSubdivisions; ++k)
{
float percent = ((float)k) / (kSubdivisions - 1);
float angle = (Mathf.PI * 0.5f) * percent;
p = center + new Vector2(-Mathf.Cos(angle), -Mathf.Sin(angle)) * radius;
q = center + new Vector2(-a * Mathf.Cos(angle), -b * Mathf.Sin(angle));
mesh.SetNextVertex(new Vertex {
position = new Vector3(q.x, q.y, posZ), uv = q - p, tint = color, flags = innerVertexFlags
});
mesh.SetNextVertex(new Vertex {
position = new Vector3(p.x, p.y, posZ), uv = p - q, tint = color, flags = outerVertexFlags
});
vertexCount += 2;
int i = k * 2;
mesh.SetNextIndex((UInt16)(indexOffset + (i - 2)));
mesh.SetNextIndex((UInt16)(indexOffset + (i)));
mesh.SetNextIndex((UInt16)(indexOffset + (i - 1)));
mesh.SetNextIndex((UInt16)(indexOffset + (i - 1)));
mesh.SetNextIndex((UInt16)(indexOffset + (i)));
mesh.SetNextIndex((UInt16)(indexOffset + (i + 1)));
indexCount += 6;
}
indexOffset += (UInt16)(kSubdivisions * 2);
}
internal static void MakeText(MeshInfo meshInfo, Vector2 offset, MeshBuilder.AllocMeshData meshAlloc)
{
int num = MeshBuilder.LimitTextVertices(meshInfo.vertexCount, true);
int num2 = num / 4;
MeshWriteData meshWriteData = meshAlloc.Allocate((uint)(num2 * 4), (uint)(num2 * 6));
int i = 0;
int num3 = 0;
int num4 = 0;
while (i < num2)
{
meshWriteData.SetNextVertex(MeshBuilder.ConvertTextVertexToUIRVertex(meshInfo, num3, offset));
meshWriteData.SetNextVertex(MeshBuilder.ConvertTextVertexToUIRVertex(meshInfo, num3 + 1, offset));
meshWriteData.SetNextVertex(MeshBuilder.ConvertTextVertexToUIRVertex(meshInfo, num3 + 2, offset));
meshWriteData.SetNextVertex(MeshBuilder.ConvertTextVertexToUIRVertex(meshInfo, num3 + 3, offset));
meshWriteData.SetNextIndex((ushort)num3);
meshWriteData.SetNextIndex((ushort)(num3 + 1));
meshWriteData.SetNextIndex((ushort)(num3 + 2));
meshWriteData.SetNextIndex((ushort)(num3 + 2));
meshWriteData.SetNextIndex((ushort)(num3 + 3));
meshWriteData.SetNextIndex((ushort)num3);
i++;
num3 += 4;
num4 += 6;
}
}
private static void TessellateFilledFan(TessellationType tessellationType, Vector2 center, Vector2 radius, Color color, float posZ, MeshWriteData mesh, ref UInt16 indexOffset, ref UInt16 vertexCount, ref UInt16 indexCount, bool countOnly)
{
if (countOnly)
{
vertexCount += (UInt16)(kSubdivisions + 1);
indexCount += (UInt16)((kSubdivisions - 1) * 3);
return;
}
float innerVertexFlags, outerVertexFlags;
if (tessellationType == TessellationType.EdgeCorner)
{
innerVertexFlags = (float)VertexFlags.IsEdge;
outerVertexFlags = (float)VertexFlags.IsSolid;
}
else
{
outerVertexFlags = innerVertexFlags = (float)mesh.m_Flags;
}
var p = new Vector2(center.x - radius.x, center.y);
mesh.SetNextVertex(new Vertex()
{
position = new Vector3(center.x, center.y, posZ), uv = p, tint = color, flags = innerVertexFlags
});
mesh.SetNextVertex(new Vertex()
{
position = new Vector3(p.x, p.y, posZ), uv = center, tint = color, flags = outerVertexFlags
});
vertexCount += 2;
for (int k = 1; k < kSubdivisions; ++k)
{
float angle = (Mathf.PI * 0.5f) * ((float)k) / (kSubdivisions - 1);
p = center + new Vector2(-Mathf.Cos(angle), -Mathf.Sin(angle)) * radius;
mesh.SetNextVertex(new Vertex()
{
position = new Vector3(p.x, p.y, posZ), uv = center, tint = color, flags = outerVertexFlags
});
vertexCount++;
mesh.SetNextIndex((UInt16)(indexOffset + 0));
mesh.SetNextIndex((UInt16)(indexOffset + k + 1));
mesh.SetNextIndex((UInt16)(indexOffset + k));
indexCount += 3;
}
indexOffset += (UInt16)(kSubdivisions + 1);
}
private static void MakeVectorGraphics9SliceBackground(Vertex[] svgVertices, ushort[] svgIndices, float svgWidth, float svgHeight, Rect targetRect, Vector4 sliceLTRB, bool stretch, Color tint, int settingIndexOffset, MeshBuilder.AllocMeshData meshAlloc)
{
MeshWriteData meshWriteData = meshAlloc.alloc((uint)svgVertices.Length, (uint)svgIndices.Length, ref meshAlloc);
meshWriteData.SetAllIndices(svgIndices);
bool flag = !stretch;
if (flag)
{
throw new NotImplementedException("Support for repeating 9-slices is not done yet");
}
MeshBuilder.s_VectorGraphics9Slice.Begin();
Rect uvRegion = meshWriteData.uvRegion;
int num = svgVertices.Length;
Vector2 vector = new Vector2(1f / (svgWidth - sliceLTRB.z - sliceLTRB.x), 1f / (svgHeight - sliceLTRB.w - sliceLTRB.y));
Vector2 vector2 = new Vector2(targetRect.width - svgWidth, targetRect.height - svgHeight);
for (int i = 0; i < num; i++)
{
Vertex vertex = svgVertices[i];
Vector2 vector3;
vector3.x = Mathf.Clamp01((vertex.position.x - sliceLTRB.x) * vector.x);
vector3.y = Mathf.Clamp01((vertex.position.y - sliceLTRB.y) * vector.y);
vertex.position.x = vertex.position.x + vector3.x * vector2.x;
vertex.position.y = vertex.position.y + vector3.y * vector2.y;
vertex.uv.x = vertex.uv.x * uvRegion.width + uvRegion.xMin;
vertex.uv.y = vertex.uv.y * uvRegion.height + uvRegion.yMin;
vertex.tint *= tint;
uint num2 = (uint)(((int)vertex.opacityPageSVGSettingIndex.b << 8 | (int)vertex.opacityPageSVGSettingIndex.a) + settingIndexOffset);
vertex.opacityPageSVGSettingIndex.b = (byte)(num2 >> 8);
vertex.opacityPageSVGSettingIndex.a = (byte)num2;
meshWriteData.SetNextVertex(vertex);
}
MeshBuilder.s_VectorGraphics9Slice.End();
}
public static void SetNextVertex(this MeshWriteData md, Vector3 pos, Vector2 uv, Color32 tint)
{
#if UNITY_2021_1_OR_NEWER
Color32 ids = new Color32(0, 0, 0, 0);
Color32 flags = new Color32((byte)VertexFlags.IsGraphViewEdge, 0, 0, 0);
md.SetNextVertex(new Vertex()
{
position = pos, uv = uv, tint = tint, ids = ids, flags = flags
});
#else
Color32 flags = new Color32(0, 0, 0, (byte)VertexFlags.LastType);
md.SetNextVertex(new Vertex()
{
position = pos, uv = uv, tint = tint, idsFlags = flags
});
#endif
}
public static void SetNextVertex(this MeshWriteData md, Vector3 pos, Vector2 uv, Color32 tint)
{
Color32 flags = new Color32(0, 0, 0, (byte)VertexFlags.LastType);
md.SetNextVertex(new Vertex()
{
position = pos, uv = uv, tint = tint, idsFlags = flags
});
}
private static void MakeQuad(Rect rcPosition, Rect rcTexCoord, Color color, float posZ, MeshBuilder.AllocMeshData meshAlloc)
{
MeshWriteData meshWriteData = meshAlloc.Allocate(4u, 6u);
float x = rcPosition.x;
float xMax = rcPosition.xMax;
float yMax = rcPosition.yMax;
float y = rcPosition.y;
Rect uvRegion = meshWriteData.uvRegion;
float x2 = rcTexCoord.x * uvRegion.width + uvRegion.xMin;
float x3 = rcTexCoord.xMax * uvRegion.width + uvRegion.xMin;
float y2 = rcTexCoord.y * uvRegion.height + uvRegion.yMin;
float y3 = rcTexCoord.yMax * uvRegion.height + uvRegion.yMin;
meshWriteData.SetNextVertex(new Vertex
{
position = new Vector3(x, yMax, posZ),
tint = color,
uv = new Vector2(x2, y2)
});
meshWriteData.SetNextVertex(new Vertex
{
position = new Vector3(xMax, yMax, posZ),
tint = color,
uv = new Vector2(x3, y2)
});
meshWriteData.SetNextVertex(new Vertex
{
position = new Vector3(x, y, posZ),
tint = color,
uv = new Vector2(x2, y3)
});
meshWriteData.SetNextVertex(new Vertex
{
position = new Vector3(xMax, y, posZ),
tint = color,
uv = new Vector2(x3, y3)
});
meshWriteData.SetNextIndex(0);
meshWriteData.SetNextIndex(2);
meshWriteData.SetNextIndex(1);
meshWriteData.SetNextIndex(1);
meshWriteData.SetNextIndex(2);
meshWriteData.SetNextIndex(3);
}
void QuadA(Vector2 pos, Vector2 size, Vector2 uvSize, Vector2 uvOffset, Color color, MeshWriteData mesh, ushort vertextOffset)
{
var x0 = pos.x;
var y0 = pos.y;
var x1 = pos.x + size.x;
var y1 = pos.y + size.y;
mesh.SetNextVertex(new Vertex()
{
position = new Vector3(x0, y0, Vertex.nearZ),
tint = color,
uv = new Vector2(0, 1) * uvSize * mesh.uvRegion.size + mesh.uvRegion.position
});
mesh.SetNextVertex(new Vertex()
{
position = new Vector3(x1, y0, Vertex.nearZ),
tint = color,
uv = new Vector2(1, 1) * uvSize * mesh.uvRegion.size + mesh.uvRegion.position
});
mesh.SetNextVertex(new Vertex()
{
position = new Vector3(x0, y1, Vertex.nearZ),
tint = color,
uv = new Vector2(0, uvOffset.y) * uvSize * mesh.uvRegion.size + mesh.uvRegion.position
});
mesh.SetNextVertex(new Vertex()
{
position = new Vector3(x1, y1, Vertex.nearZ),
tint = color,
uv = new Vector2(1, uvOffset.y) * uvSize * mesh.uvRegion.size + mesh.uvRegion.position
});
for (int i = 0; i < k_Indices.Length; i++)
{
mesh.SetNextIndex((ushort)(k_Indices[i] + vertextOffset));
}
}
internal static void MakeText(NativeArray <UnityEngine.UIElements.TextVertex> uiVertices, Vector2 offset, MeshBuilder.AllocMeshData meshAlloc)
{
int num = MeshBuilder.LimitTextVertices(uiVertices.Length, true);
int num2 = num / 4;
MeshWriteData meshWriteData = meshAlloc.Allocate((uint)(num2 * 4), (uint)(num2 * 6));
int i = 0;
int num3 = 0;
while (i < num2)
{
meshWriteData.SetNextVertex(MeshBuilder.ConvertTextVertexToUIRVertex(uiVertices[num3], offset));
meshWriteData.SetNextVertex(MeshBuilder.ConvertTextVertexToUIRVertex(uiVertices[num3 + 1], offset));
meshWriteData.SetNextVertex(MeshBuilder.ConvertTextVertexToUIRVertex(uiVertices[num3 + 2], offset));
meshWriteData.SetNextVertex(MeshBuilder.ConvertTextVertexToUIRVertex(uiVertices[num3 + 3], offset));
meshWriteData.SetNextIndex((ushort)num3);
meshWriteData.SetNextIndex((ushort)(num3 + 1));
meshWriteData.SetNextIndex((ushort)(num3 + 2));
meshWriteData.SetNextIndex((ushort)(num3 + 2));
meshWriteData.SetNextIndex((ushort)(num3 + 3));
meshWriteData.SetNextIndex((ushort)num3);
i++;
num3 += 4;
}
}
private void ValidateMeshWriteData()
{
for (int i = 0; i < this.m_NextMeshWriteDataPoolItem; i++)
{
MeshWriteData meshWriteData = this.m_MeshWriteDataPool[i];
bool flag = meshWriteData.vertexCount > 0 && meshWriteData.currentVertex < meshWriteData.vertexCount;
if (flag)
{
Debug.LogError(string.Concat(new string[]
{
"Not enough vertices written in generateVisualContent callback (asked for ",
meshWriteData.vertexCount.ToString(),
" but only wrote ",
meshWriteData.currentVertex.ToString(),
")"
}));
Vertex nextVertex = meshWriteData.m_Vertices[0];
while (meshWriteData.currentVertex < meshWriteData.vertexCount)
{
meshWriteData.SetNextVertex(nextVertex);
}
}
bool flag2 = meshWriteData.indexCount > 0 && meshWriteData.currentIndex < meshWriteData.indexCount;
if (flag2)
{
Debug.LogError(string.Concat(new string[]
{
"Not enough indices written in generateVisualContent callback (asked for ",
meshWriteData.indexCount.ToString(),
" but only wrote ",
meshWriteData.currentIndex.ToString(),
")"
}));
while (meshWriteData.currentIndex < meshWriteData.indexCount)
{
meshWriteData.SetNextIndex(0);
}
}
}
}
private static void TessellateQuad(Rect rect, TessellationType tessellationType, Color color, float posZ, MeshWriteData mesh, ref UInt16 indexOffset, ref UInt16 vertexCount, ref UInt16 indexCount, bool countOnly)
{
if (rect.width < kEpsilon || rect.height < kEpsilon)
{
return;
}
if (countOnly)
{
vertexCount += 4;
indexCount += 6;
return;
}
float x0 = rect.x;
float x3 = rect.xMax;
float y0 = rect.y;
float y3 = rect.yMax;
Vector2 uv0, uv1, uv2, uv3;
float flags0, flags1, flags2, flags3;
switch (tessellationType)
{
case TessellationType.EdgeHorizontal:
// The uvs contain the displacement from the vertically opposed corner.
uv0 = new Vector2(0, y0 - y3);
uv1 = new Vector2(0, y0 - y3);
uv2 = new Vector2(0, y3 - y0);
uv3 = new Vector2(0, y3 - y0);
flags0 = flags1 = (float)VertexFlags.IsSolid;
flags2 = flags3 = (float)VertexFlags.IsEdge;
break;
case TessellationType.EdgeVertical:
// The uvs contain the displacement from the horizontally opposed corner.
uv0 = new Vector2(x0 - x3, 0);
uv1 = new Vector2(x3 - x0, 0);
uv2 = new Vector2(x0 - x3, 0);
uv3 = new Vector2(x3 - x0, 0);
flags0 = flags2 = (float)VertexFlags.IsSolid;
flags1 = flags3 = (float)VertexFlags.IsEdge;
break;
case TessellationType.EdgeCorner:
uv0 = uv1 = uv2 = uv3 = Vector2.zero;
flags0 = flags1 = flags2 = flags3 = (float)VertexFlags.IsSolid;
break;
case TessellationType.Content:
uv0 = uv1 = uv2 = uv3 = Vector2.zero; // UVs are computed later for content
flags0 = flags1 = flags2 = flags3 = (float)mesh.m_Flags;
break;
default:
throw new NotImplementedException();
}
mesh.SetNextVertex(new Vertex {
position = new Vector3(x0, y0, posZ), uv = uv0, tint = color, flags = flags0
});
mesh.SetNextVertex(new Vertex {
position = new Vector3(x3, y0, posZ), uv = uv1, tint = color, flags = flags1
});
mesh.SetNextVertex(new Vertex {
position = new Vector3(x0, y3, posZ), uv = uv2, tint = color, flags = flags2
});
mesh.SetNextVertex(new Vertex {
position = new Vector3(x3, y3, posZ), uv = uv3, tint = color, flags = flags3
});
mesh.SetNextIndex((UInt16)(indexOffset + 0));
mesh.SetNextIndex((UInt16)(indexOffset + 2));
mesh.SetNextIndex((UInt16)(indexOffset + 1));
mesh.SetNextIndex((UInt16)(indexOffset + 3));
mesh.SetNextIndex((UInt16)(indexOffset + 1));
mesh.SetNextIndex((UInt16)(indexOffset + 2));
vertexCount += 4;
indexCount += 6;
indexOffset += 4;
}
internal static void MakeVectorGraphicsStretchBackground(Vertex[] svgVertices, ushort[] svgIndices, float svgWidth, float svgHeight, Rect targetRect, Rect sourceUV, ScaleMode scaleMode, Color tint, int settingIndexOffset, MeshBuilder.AllocMeshData meshAlloc, out int finalVertexCount, out int finalIndexCount)
{
Vector2 vector = new Vector2(svgWidth * sourceUV.width, svgHeight * sourceUV.height);
Vector2 vector2 = new Vector2(sourceUV.xMin * svgWidth, sourceUV.yMin * svgHeight);
Rect rect = new Rect(vector2, vector);
bool flag = sourceUV.xMin != 0f || sourceUV.yMin != 0f || sourceUV.width != 1f || sourceUV.height != 1f;
float num = vector.x / vector.y;
float num2 = targetRect.width / targetRect.height;
Vector2 vector3;
Vector2 vector4;
switch (scaleMode)
{
case ScaleMode.StretchToFill:
vector3 = new Vector2(0f, 0f);
vector4.x = targetRect.width / vector.x;
vector4.y = targetRect.height / vector.y;
break;
case ScaleMode.ScaleAndCrop:
{
vector3 = new Vector2(0f, 0f);
bool flag2 = num2 > num;
if (flag2)
{
vector4.x = (vector4.y = targetRect.width / vector.x);
float num3 = targetRect.height / vector4.y;
float num4 = rect.height / 2f - num3 / 2f;
vector3.y -= num4 * vector4.y;
rect.y += num4;
rect.height = num3;
flag = true;
}
else
{
bool flag3 = num2 < num;
if (flag3)
{
vector4.x = (vector4.y = targetRect.height / vector.y);
float num5 = targetRect.width / vector4.x;
float num6 = rect.width / 2f - num5 / 2f;
vector3.x -= num6 * vector4.x;
rect.x += num6;
rect.width = num5;
flag = true;
}
else
{
vector4.x = (vector4.y = targetRect.width / vector.x);
}
}
break;
}
case ScaleMode.ScaleToFit:
{
bool flag4 = num2 > num;
if (flag4)
{
vector4.x = (vector4.y = targetRect.height / vector.y);
vector3.x = (targetRect.width - vector.x * vector4.x) * 0.5f;
vector3.y = 0f;
}
else
{
vector4.x = (vector4.y = targetRect.width / vector.x);
vector3.x = 0f;
vector3.y = (targetRect.height - vector.y * vector4.y) * 0.5f;
}
break;
}
default:
throw new NotImplementedException();
}
MeshBuilder.s_VectorGraphicsStretch.Begin();
vector3 -= vector2 * vector4;
int num7 = svgVertices.Length;
int num8 = svgIndices.Length;
MeshBuilder.ClipCounts clipCounts = default(MeshBuilder.ClipCounts);
Vector4 zero = Vector4.zero;
bool flag5 = flag;
if (flag5)
{
bool flag6 = rect.width <= 0f || rect.height <= 0f;
if (flag6)
{
finalVertexCount = (finalIndexCount = 0);
MeshBuilder.s_VectorGraphicsStretch.End();
return;
}
zero = new Vector4(rect.xMin, rect.yMin, rect.xMax, rect.yMax);
clipCounts = MeshBuilder.UpperBoundApproximateRectClippingResults(svgVertices, svgIndices, zero);
num7 += clipCounts.clippedTriangles * 6;
num8 += clipCounts.addedTriangles * 3;
num8 -= clipCounts.degenerateTriangles * 3;
}
MeshWriteData meshWriteData = meshAlloc.alloc((uint)num7, (uint)num8, ref meshAlloc);
bool flag7 = flag;
if (flag7)
{
MeshBuilder.RectClip(svgVertices, svgIndices, zero, meshWriteData, clipCounts, ref num7);
}
else
{
meshWriteData.SetAllIndices(svgIndices);
}
Debug.Assert(meshWriteData.currentVertex == 0);
Rect uvRegion = meshWriteData.uvRegion;
int num9 = svgVertices.Length;
for (int i = 0; i < num9; i++)
{
Vertex vertex = svgVertices[i];
vertex.position.x = vertex.position.x * vector4.x + vector3.x;
vertex.position.y = vertex.position.y * vector4.y + vector3.y;
vertex.uv.x = vertex.uv.x * uvRegion.width + uvRegion.xMin;
vertex.uv.y = vertex.uv.y * uvRegion.height + uvRegion.yMin;
vertex.tint *= tint;
uint num10 = (uint)(((int)vertex.opacityPageSVGSettingIndex.b << 8 | (int)vertex.opacityPageSVGSettingIndex.a) + settingIndexOffset);
vertex.opacityPageSVGSettingIndex.b = (byte)(num10 >> 8);
vertex.opacityPageSVGSettingIndex.a = (byte)num10;
meshWriteData.SetNextVertex(vertex);
}
for (int j = num9; j < num7; j++)
{
Vertex vertex2 = meshWriteData.m_Vertices[j];
vertex2.position.x = vertex2.position.x * vector4.x + vector3.x;
vertex2.position.y = vertex2.position.y * vector4.y + vector3.y;
vertex2.uv.x = vertex2.uv.x * uvRegion.width + uvRegion.xMin;
vertex2.uv.y = vertex2.uv.y * uvRegion.height + uvRegion.yMin;
vertex2.tint *= tint;
uint num11 = (uint)(((int)vertex2.opacityPageSVGSettingIndex.b << 8 | (int)vertex2.opacityPageSVGSettingIndex.a) + settingIndexOffset);
vertex2.opacityPageSVGSettingIndex.b = (byte)(num11 >> 8);
vertex2.opacityPageSVGSettingIndex.a = (byte)num11;
meshWriteData.SetNextVertex(vertex2);
}
finalVertexCount = meshWriteData.vertexCount;
finalIndexCount = meshWriteData.indexCount;
MeshBuilder.s_VectorGraphicsStretch.End();
}
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);
}
