okseby/polygone
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Initial Commit

Browse source
This commit is contained in:
Sebastian Cabrera 2021-08-02 05:44:37 -04:00
parent 53eb92e9af
commit 270ab7d11f
15341 changed files with 700234 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

400
Library/PackageCache/com.unity.textmeshpro@3.0.4/Scripts/Runtime/TMP_TextProcessingStack.cs Normal file
View file

@ -0,0 +1,400 @@
using System;
using System.Diagnostics;
using UnityEngine;
namespace TMPro
{
/// <summary>
/// Structure used to track basic XML tags which are binary (on / off)
/// </summary>
public struct TMP_FontStyleStack
{
public byte bold;
public byte italic;
public byte underline;
public byte strikethrough;
public byte highlight;
public byte superscript;
public byte subscript;
public byte uppercase;
public byte lowercase;
public byte smallcaps;
/// <summary>
/// Clear the basic XML tag stack.
/// </summary>
public void Clear()
{
bold = 0;
italic = 0;
underline = 0;
strikethrough = 0;
highlight = 0;
superscript = 0;
subscript = 0;
uppercase = 0;
lowercase = 0;
smallcaps = 0;
}
public byte Add(FontStyles style)
{
switch (style)
{
case FontStyles.Bold:
bold++;
return bold;
case FontStyles.Italic:
italic++;
return italic;
case FontStyles.Underline:
underline++;
return underline;
case FontStyles.UpperCase:
uppercase++;
return uppercase;
case FontStyles.LowerCase:
lowercase++;
return lowercase;
case FontStyles.Strikethrough:
strikethrough++;
return strikethrough;
case FontStyles.Superscript:
superscript++;
return superscript;
case FontStyles.Subscript:
subscript++;
return subscript;
case FontStyles.Highlight:
highlight++;
return highlight;
}
return 0;
}
public byte Remove(FontStyles style)
{
switch (style)
{
case FontStyles.Bold:
if (bold > 1)
bold--;
else
bold = 0;
return bold;
case FontStyles.Italic:
if (italic > 1)
italic--;
else
italic = 0;
return italic;
case FontStyles.Underline:
if (underline > 1)
underline--;
else
underline = 0;
return underline;
case FontStyles.UpperCase:
if (uppercase > 1)
uppercase--;
else
uppercase = 0;
return uppercase;
case FontStyles.LowerCase:
if (lowercase > 1)
lowercase--;
else
lowercase = 0;
return lowercase;
case FontStyles.Strikethrough:
if (strikethrough > 1)
strikethrough--;
else
strikethrough = 0;
return strikethrough;
case FontStyles.Highlight:
if (highlight > 1)
highlight--;
else
highlight = 0;
return highlight;
case FontStyles.Superscript:
if (superscript > 1)
superscript--;
else
superscript = 0;
return superscript;
case FontStyles.Subscript:
if (subscript > 1)
subscript--;
else
subscript = 0;
return subscript;
}
return 0;
}
}
/// <summary>
/// Structure used to track XML tags of various types.
/// </summary>
/// <typeparam name="T"></typeparam>
[DebuggerDisplay("Item count = {m_Count}")]
public struct TMP_TextProcessingStack<T>
{
public T[] itemStack;
public int index;
T m_DefaultItem;
int m_Capacity;
int m_RolloverSize;
int m_Count;
const int k_DefaultCapacity = 4;
/// <summary>
/// Constructor to create a new item stack.
/// </summary>
/// <param name="stack"></param>
public TMP_TextProcessingStack(T[] stack)
{
itemStack = stack;
m_Capacity = stack.Length;
index = 0;
m_RolloverSize = 0;
m_DefaultItem = default(T);
m_Count = 0;
}
/// <summary>
/// Constructor for a new item stack with the given capacity.
/// </summary>
/// <param name="capacity"></param>
public TMP_TextProcessingStack(int capacity)
{
itemStack = new T[capacity];
m_Capacity = capacity;
index = 0;
m_RolloverSize = 0;
m_DefaultItem = default(T);
m_Count = 0;
}
public TMP_TextProcessingStack(int capacity, int rolloverSize)
{
itemStack = new T[capacity];
m_Capacity = capacity;
index = 0;
m_RolloverSize = rolloverSize;
m_DefaultItem = default(T);
m_Count = 0;
}
/// <summary>
///
/// </summary>
public int Count
{
get { return m_Count; }
}
/// <summary>
/// Returns the current item on the stack.
/// </summary>
public T current
{
get
{
if (index > 0)
return itemStack[index - 1];
return itemStack[0];
}
}
/// <summary>
///
/// </summary>
public int rolloverSize
{
get { return m_RolloverSize; }
set
{
m_RolloverSize = value;
//if (m_Capacity < m_RolloverSize)
// Array.Resize(ref itemStack, m_RolloverSize);
}
}
/// <summary>
/// Set stack elements to default item.
/// </summary>
/// <param name="stack">The stack of elements.</param>
/// <param name="item"></param>
internal static void SetDefault(TMP_TextProcessingStack<T>[] stack, T item)
{
for (int i = 0; i < stack.Length; i++)
stack[i].SetDefault(item);
}
/// <summary>
/// Function to clear and reset stack to first item.
/// </summary>
public void Clear()
{
index = 0;
m_Count = 0;
}
/// <summary>
/// Function to set the first item on the stack and reset index.
/// </summary>
/// <param name="item"></param>
public void SetDefault(T item)
{
if (itemStack == null)
{
m_Capacity = k_DefaultCapacity;
itemStack = new T[m_Capacity];
m_DefaultItem = default(T);
}
itemStack[0] = item;
index = 1;
}
/// <summary>
/// Function to add a new item to the stack.
/// </summary>
/// <param name="item"></param>
public void Add(T item)
{
if (index < itemStack.Length)
{
itemStack[index] = item;
index += 1;
}
}
/// <summary>
/// Function to retrieve an item from the stack.
/// </summary>
/// <returns></returns>
public T Remove()
{
index -= 1;
if (index <= 0)
{
index = 1;
return itemStack[0];
}
return itemStack[index - 1];
}
public void Push(T item)
{
if (index == m_Capacity)
{
m_Capacity *= 2;
if (m_Capacity == 0)
m_Capacity = k_DefaultCapacity;
Array.Resize(ref itemStack, m_Capacity);
}
itemStack[index] = item;
if (m_RolloverSize == 0)
{
index += 1;
m_Count += 1;
}
else
{
index = (index + 1) % m_RolloverSize;
m_Count = m_Count < m_RolloverSize ? m_Count + 1 : m_RolloverSize;
}
}
public T Pop()
{
if (index == 0 && m_RolloverSize == 0)
return default(T);
if (m_RolloverSize == 0)
index -= 1;
else
{
index = (index - 1) % m_RolloverSize;
index = index < 0 ? index + m_RolloverSize : index;
}
T item = itemStack[index];
itemStack[index] = m_DefaultItem;
m_Count = m_Count > 0 ? m_Count - 1 : 0;
return item;
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public T Peek()
{
if (index == 0)
return m_DefaultItem;
return itemStack[index - 1];
}
/// <summary>
/// Function to retrieve the current item from the stack.
/// </summary>
/// <returns>itemStack <T></returns>
public T CurrentItem()
{
if (index > 0)
return itemStack[index - 1];
return itemStack[0];
}
/// <summary>
/// Function to retrieve the previous item without affecting the stack.
/// </summary>
/// <returns></returns>
public T PreviousItem()
{
if (index > 1)
return itemStack[index - 2];
return itemStack[0];
}
}
}