Example #1
0
    public static bool processLetter <Data>(char letter, LetterDelegate <Data> callback, Data data)
    {
        if (callback == null)
        {
            throw new System.ArgumentNullException();
        }
        initLetters();

        if (!letters.ContainsKey(letter))
        {
            if (letter != defaultChar)
            {
                processLetter(defaultChar, callback, data);
            }
            return(false);
        }

        var curLetterData = letters[letter];

        for (int i = 0; i < curLetterData.ints.Length; i += 2)
        {
            int idxa = curLetterData.ints[i];
            int idxb = curLetterData.ints[i + 1];

            callback(curLetterData.getVertex(idxa), curLetterData.getVertex(idxb), data);
        }

        return(true);
    }
Example #2
0
    public static void processTextLine <Data>(string text, LetterDelegate <Data> callback, Data data)
    {
        if (string.IsNullOrEmpty(text))
        {
            return;
        }
        if (callback == null)
        {
            throw new System.ArgumentNullException();
        }

        TextProcessData <Data> payload;

        payload.callback   = callback;
        payload.charOffset = Vector2.zero;
        payload.data       = data;
        for (int i = 0; i < text.Length; i++)
        {
            char c = text[i];
            processLetter(c, (a, b, charData) =>
                          charData.callback(a + charData.charOffset, b + charData.charOffset, payload.data), payload);
            payload.charOffset.x += charSize.x;
        }
    }
Example #3
0
    public static void processText <Data>(string text, TextAnchor anchor, TextAnchor alignment, LetterDelegate <Data> callback, Data data)
    {
        if (string.IsNullOrEmpty(text))
        {
            return;
        }
        if (callback == null)
        {
            throw new System.ArgumentNullException();
        }
        Vector2 textOffset    = new Vector2(0.0f, 0.0f);
        int     numLines      = countLines(text);
        int     maxLineLength = getMaxLineLength(text);

        float maxLineWidth = charSize.x * (float)maxLineLength;

        if ((anchor == TextAnchor.UpperCenter) || (anchor == TextAnchor.UpperLeft) || (anchor == TextAnchor.UpperRight))
        {
            textOffset.y -= charSize.y;
        }
        else if ((anchor == TextAnchor.MiddleCenter) || (anchor == TextAnchor.MiddleLeft) || (anchor == TextAnchor.MiddleRight))
        {
            textOffset.y = (float)numLines * charSize.y * 0.5f - charSize.y;
        }
        else
        {
            textOffset.y = (float)numLines * charSize.y;
        }

        int charOffset = 0;

        float lineAnchorOffsetMultiplier    = getAnchorXPivot(anchor);
        float lineAlignmentOffsetMultiplier = getAnchorXPivot(alignment);

        var lineOffset = textOffset;
        TextProcessData <Data> textData;

        textData.data     = data;
        textData.callback = callback;
        do
        {
            var   curLineLength = getCurLineLength(text, charOffset);
            float lineWidth     = charSize.x * (float)curLineLength;

            lineOffset.x = textOffset.x - maxLineWidth * lineAnchorOffsetMultiplier
                           + (maxLineWidth - lineWidth) * lineAlignmentOffsetMultiplier;
            for (int i = 0; i < curLineLength; i++)
            {
                char c = text[i + charOffset];
                textData.charOffset = lineOffset;
                processLetter(c, (p1, p2, d) =>
                              d.callback(p1 + d.charOffset, p2 + d.charOffset, d.data)
                              , textData);
                lineOffset.x += charSize.x;
            }

            lineOffset.y -= charSize.y;
            charOffset   += curLineLength + 1;
        }while(charOffset < text.Length);
    }