Esempio n. 1
0
    static void CreateFont()
    {
        InitGBK();
        string path = AssetDatabase.GetAssetPath(Selection.activeObject);

        fontName = Path.GetFileNameWithoutExtension(path);
        int errorCode = TMPro_FontPlugin.Initialize_FontEngine();

        if (errorCode == 0 || errorCode == 99)
        {
            errorCode = TMPro_FontPlugin.Load_TrueType_Font(path);
            if (errorCode == 0 || errorCode == 99)
            {
                errorCode = TMPro_FontPlugin.FT_Size_Font(fontSize);
                if (errorCode == 0 || errorCode == 99)
                {
                    EditorApplication.update += RenderUpdate;
                    textureColors             = new Color32[textureSize * textureSize];
                    charInfoList              = new List <CharacterInfo>();
                    CreateTexture(0);
                }
            }
        }
    }
Esempio n. 2
0
        public static void CreateSDFAsset(TexAsset asset, Font font, string fontPath)
        {
            // initialize
            CheckErr(TMPro_FontPlugin.Initialize_FontEngine());
            CheckErr(TMPro_FontPlugin.Load_TrueType_Font(fontPath));
            CheckErr(TMPro_FontPlugin.FT_Size_Font(72));

            _buffers = new byte[_bufferWidth * _bufferHeight];
            var charSet = new int[asset.chars.Length];

            _glyphsInfo = new FT_GlyphInfo[asset.chars.Length];
            _atlasInfo  = null;

            for (int i = 0; i < asset.chars.Length; i++)
            {
                charSet[i] = asset.chars[i].characterIndex;
            }

            float strokeSize = _styleStrokeSize;

            if (_render == RenderModes.DistanceField16)
            {
                strokeSize = _styleStrokeSize * 16;
            }
            if (_render == RenderModes.DistanceField32)
            {
                strokeSize = _styleStrokeSize * 32;
            }

            ThreadPool.QueueUserWorkItem(SomeTask =>
            {
                try
                {
                    onRendering = true;

                    CheckErr(TMPro_FontPlugin.Render_Characters(_buffers, _bufferWidth, _bufferHeight, _padding,
                                                                charSet, charSet.Length, _style, strokeSize, true, _render, _optimized ? 4 : 0,
                                                                ref _faceInfo, _glyphsInfo));

                    EditorApplication.delayCall += delegate()
                    {
                        try
                        {
                            OnFinished(Convert(asset));
                        }
                        catch (Exception ex)
                        {
                            Debug.LogException(ex);
                            Debug.LogWarningFormat("Failed to create SDF File for {0}.ttf. Consider delete and rerender again", asset.id);
                        }
                        finally
                        {
                            hasRendered = false;

                            if (onRendering)
                            {
                                //CheckErr(TMPro_FontPlugin.Destroy_FontEngine());
                                onRendering = false;
                            }

                            if (onRenderingBatch > 0)
                            {
                                isRenderingBatchFinished = true;
                            }
                        }
                    };
                    Debug.LogFormat("Font Rendering of {0}.ttf has completed.", asset.id);
                }
                catch (Exception ex)
                {
                    Debug.LogException(ex);
                    Debug.LogWarningFormat("Failed to create Render {0}.ttf. Consider rerender again", asset.id);
                }
                finally
                {
                    if (onRendering)
                    {
                        //CheckErr(TMPro_FontPlugin.Destroy_FontEngine());
                        onRendering = false;
                    }
                }
            });
        }
Esempio n. 3
0
        // PRAGMA MARK - Public Interface
        public static void Bake(Font font, bool useAutoSizing, int fontSize, int characterPadding, TMPFontPackingModes fontPackingMode, int atlasWidth, int atlasHeight, FaceStyles fontStyle, int fontStyleMod, RenderModes fontRenderMode, string charactersToBake, string outputFilePath)
        {
            int errorCode = TMPro_FontPlugin.Initialize_FontEngine();

            if (errorCode != 0 && errorCode != 99)               // 99 means that engine was already initialized
            {
                Debug.LogWarning("Error Code: " + errorCode + "  occurred while initializing TMPro_FontPlugin.");
                return;
            }

            string fontPath = AssetDatabase.GetAssetPath(font);

            errorCode = TMPro_FontPlugin.Load_TrueType_Font(fontPath);
            if (errorCode != 0 && errorCode != 99)               // 99 means that font was already loaded
            {
                Debug.LogWarning("Error Code: " + errorCode + "  occurred while loading font: " + font + ".");
                return;
            }

            if (useAutoSizing)
            {
                fontSize = 72;
            }
            errorCode = TMPro_FontPlugin.FT_Size_Font(fontSize);
            if (errorCode != 0)
            {
                Debug.LogWarning("Error Code: " + errorCode + "  occurred while sizing font: " + font + " to size: " + fontSize + ".");
                return;
            }

            byte[] textureBuffer = new byte[atlasWidth * atlasHeight];

            int[] characterArray = charactersToBake.Select(c => (int)c).ToArray();
            int   characterCount = charactersToBake.Length;

            var fontFaceInfo  = new FT_FaceInfo();
            var fontGlyphInfo = new FT_GlyphInfo[characterCount];

            float strokeSize = fontStyleMod;

            if (fontRenderMode == RenderModes.DistanceField16)
            {
                strokeSize *= 16;
            }
            else if (fontRenderMode == RenderModes.DistanceField32)
            {
                strokeSize *= 32;
            }

            errorCode = TMPro_FontPlugin.Render_Characters(textureBuffer, atlasWidth, atlasHeight, characterPadding, characterArray, characterCount, fontStyle, strokeSize, useAutoSizing, fontRenderMode, (int)fontPackingMode, ref fontFaceInfo, fontGlyphInfo);
            if (errorCode != 0)
            {
                Debug.LogWarning("Error Code: " + errorCode + "  occurred while rendering font characters!");
                return;
            }

            string outputFilename = Path.GetFileNameWithoutExtension(outputFilePath);

            // check if font asset already exists
            TMP_FontAsset fontAsset = AssetDatabase.LoadAssetAtPath(outputFilePath, typeof(TMP_FontAsset)) as TMP_FontAsset;

            if (fontAsset == null)
            {
                fontAsset = ScriptableObject.CreateInstance <TMP_FontAsset>();                // Create new TextMeshPro Font Asset.
                AssetDatabase.CreateAsset(fontAsset, outputFilePath);
            }

            // Destroy Assets that will be replaced.
            UnityEngine.Object.DestroyImmediate(fontAsset.atlas, allowDestroyingAssets: true);

            fontAsset.fontAssetType = (fontRenderMode >= RenderModes.DistanceField16) ? TMP_FontAsset.FontAssetTypes.SDF : TMP_FontAsset.FontAssetTypes.Bitmap;

            fontAsset.AddFaceInfo(ConvertToFaceInfo(fontFaceInfo));
            fontAsset.AddGlyphInfo(ConvertToGlyphs(fontGlyphInfo));

            var fontTexture = CreateFontTexture(atlasWidth, atlasHeight, textureBuffer, fontRenderMode);

            fontTexture.name      = outputFilename + " Atlas";
            fontTexture.hideFlags = HideFlags.HideInHierarchy;

            fontAsset.atlas = fontTexture;
            AssetDatabase.AddObjectToAsset(fontTexture, fontAsset);

            // Find all Materials referencing this font atlas.
            Material[] materialReferences = TMP_EditorUtility.FindMaterialReferences(fontAsset).Where(m => m != null).ToArray();
            if (materialReferences == null || materialReferences.Length <= 0)
            {
                // Create new Material and add it as Sub-Asset
                Shader   shader       = Shader.Find("TMPro/Distance Field");
                Material fontMaterial = new Material(shader);
                fontMaterial.name = outputFilename + " Material";

                fontAsset.material     = fontMaterial;
                fontMaterial.hideFlags = HideFlags.HideInHierarchy;
                AssetDatabase.AddObjectToAsset(fontMaterial, fontAsset);

                materialReferences = new Material[] { fontMaterial };
            }

            foreach (var m in materialReferences)
            {
                m.SetTexture(ShaderUtilities.ID_MainTex, fontTexture);
                m.SetFloat(ShaderUtilities.ID_TextureWidth, fontTexture.width);
                m.SetFloat(ShaderUtilities.ID_TextureHeight, fontTexture.height);


                m.SetFloat(ShaderUtilities.ID_WeightNormal, fontAsset.normalStyle);
                m.SetFloat(ShaderUtilities.ID_WeightBold, fontAsset.boldStyle);

                m.SetFloat(ShaderUtilities.ID_GradientScale, characterPadding + 1);
            }

            AssetDatabase.SaveAssets();
            // Re-import font asset to get the new updated version.
            AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(fontAsset));
            fontAsset.ReadFontDefinition();
            AssetDatabase.Refresh();

            // NEED TO GENERATE AN EVENT TO FORCE A REDRAW OF ANY TEXTMESHPRO INSTANCES THAT MIGHT BE USING THIS FONT ASSET
            TMPro_EventManager.ON_FONT_PROPERTY_CHANGED(true, fontAsset);
        }
Esempio n. 4
0
        //==============================================================================
        // 関数
        //==============================================================================
        public void Start(TMP_FontAssetUpdaterSettings settings, Action onComplete = null)
        {
            ShaderUtilities.GetShaderPropertyIDs();

            m_settings      = settings;
            m_font          = settings.SourceFontFile;
            m_fontAssetPath = AssetDatabase.GetAssetPath(settings.FontAsset);

            var fontPath = AssetDatabase.GetAssetPath(m_font);
            var fontName = Path.GetFileNameWithoutExtension(fontPath);
            var filter   = "t:TMP_FontAsset " + fontName + " SDF";

            m_assets = AssetDatabase
                       .FindAssets(filter, new [] { "Assets" })
                       .Select(c => AssetDatabase.GUIDToAssetPath(c))
                       .ToArray()
            ;

            m_characterSequence = m_settings.CustomCharacterList.text;

            if (m_font == null)
            {
                return;
            }

            GameObject.DestroyImmediate(m_fontAtlas);
            m_fontAtlas = null;

            var initResult = TMPro_FontPlugin.Initialize_FontEngine();

            if (initResult != 0 && initResult != 0xF0)
            {
                Debug.Log("Error Code: " + initResult + "  occurred while Initializing the FreeType Library.");
                return;
            }

            var loadResult = TMPro_FontPlugin.Load_TrueType_Font(fontPath);

            if (loadResult != 0 && loadResult != 0xF1)
            {
                Debug.Log("Error Code: " + loadResult + "  occurred while Loading the [" + m_font.name + "] font file. This typically results from the use of an incompatible or corrupted font file.");
                return;
            }

            var sizeResult = TMPro_FontPlugin.FT_Size_Font(SamplingPointSize);

            if (sizeResult != 0)
            {
                Debug.Log("Error Code: " + sizeResult + "  occurred while Sizing the font.");
                return;
            }

            int[] characterSet;
            var   charList = new List <int>();

            for (int i = 0; i < m_characterSequence.Length; i++)
            {
                if (charList.FindIndex(item => item == m_characterSequence[i]) == -1)
                {
                    charList.Add(m_characterSequence[i]);
                }
                else
                {
                    //Debug.Log("Character [" + characterSequence[i] + "] is a duplicate.");
                }
            }

            characterSet = charList.ToArray();

            m_characterCount = characterSet.Length;
            m_textureBuffer  = new byte[AtlasWidth * AtlasHeight];
            m_fontFaceInfo   = new FT_FaceInfo();
            m_fontGlyphInfo  = new FT_GlyphInfo[m_characterCount];

            int padding = Padding;

            var autoSizing = SamplingPointSizeMode == SamplingPointSizes.AutoSizing;
            var strokeSize = FontStyleModifier;

            if (RenderMode == RenderModes.DistanceField16)
            {
                strokeSize = FontStyleModifier * 16;
            }
            if (RenderMode == RenderModes.DistanceField32)
            {
                strokeSize = FontStyleModifier * 32;
            }

            EditorApplication.update += OnUpdate;

            ThreadPool.QueueUserWorkItem(_ =>
            {
                TMPro_FontPlugin.Render_Characters
                (
                    buffer: m_textureBuffer,
                    buffer_width: AtlasWidth,
                    buffer_height: AtlasHeight,
                    character_padding: padding,
                    asc_set: characterSet,
                    char_count: m_characterCount,
                    style: FontStyle,
                    style_mod: strokeSize,
                    autoSize: autoSizing,
                    renderMode: RenderMode,
                    method: ( int )PackingMethod,
                    fontData: ref m_fontFaceInfo,
                    Output: m_fontGlyphInfo
                );

                EditorApplication.delayCall += () =>
                {
                    OnDone();

                    if (onComplete != null)
                    {
                        onComplete();
                    }
                };
            });
        }
Esempio n. 5
0
    private void GenerateFontAtlasButton()
    {
        if (!m_IsProcessing && m_SourceFontFile != null)
        {
            DestroyImmediate(m_FontAtlas);
            m_FontAtlas      = null;
            m_OutputFeedback = string.Empty;
            m_SavedFontAtlas = null;
            int errorCode;

            errorCode = TMPro_FontPlugin.Initialize_FontEngine(); // Initialize Font Engine
            if (errorCode != 0)
            {
                if (errorCode == 0xF0)
                {
                    //Debug.Log("Font Library was already initialized!");
                    errorCode = 0;
                }
                else
                {
                    Debug.Log("Error Code: " + errorCode + "  occurred while Initializing the FreeType Library.");
                }
            }

            string fontPath = AssetDatabase.GetAssetPath(m_SourceFontFile); // Get file path of TTF Font.

            if (errorCode == 0)
            {
                errorCode = TMPro_FontPlugin.Load_TrueType_Font(fontPath); // Load the selected font.

                if (errorCode != 0)
                {
                    if (errorCode == 0xF1)
                    {
                        //Debug.Log("Font was already loaded!");
                        errorCode = 0;
                    }
                    else
                    {
                        Debug.Log("Error Code: " + errorCode + "  occurred while Loading the [" + m_SourceFontFile.name + "] font file. This typically results from the use of an incompatible or corrupted font file.");
                    }
                }
            }

            if (errorCode == 0)
            {
                if (m_PointSizeSamplingMode == 0)
                {
                    m_PointSize = 72;                                   // If Auto set size to 72 pts.
                }
                errorCode = TMPro_FontPlugin.FT_Size_Font(m_PointSize); // Load the selected font and size it accordingly.
                if (errorCode != 0)
                {
                    Debug.Log("Error Code: " + errorCode + "  occurred while Sizing the font.");
                }
            }

            // Define an array containing the characters we will render.
            if (errorCode == 0)
            {
                int[] characterSet;
                if (m_CharacterSetSelectionMode == 7 || m_CharacterSetSelectionMode == 8)
                {
                    List <int> charList = new List <int>();

                    for (int i = 0; i < m_CharacterSequence.Length; i++)
                    {
                        // Check to make sure we don't include duplicates
                        if (charList.FindIndex(item => item == m_CharacterSequence[i]) == -1)
                        {
                            charList.Add(m_CharacterSequence[i]);
                        }
                        else
                        {
                            //Debug.Log("Character [" + characterSequence[i] + "] is a duplicate.");
                        }
                    }

                    characterSet = charList.ToArray();
                }
                else if (m_CharacterSetSelectionMode == 6)
                {
                    characterSet = ParseHexNumberSequence(m_CharacterSequence);
                }
                else
                {
                    characterSet = ParseNumberSequence(m_CharacterSequence);
                }

                m_CharacterCount = characterSet.Length;

                m_TextureBuffer = new byte[m_AtlasWidth * m_AtlasHeight];

                m_FontFaceInfo = new FT_FaceInfo();

                m_FontGlyphInfo = new FT_GlyphInfo[m_CharacterCount];

                int padding = m_Padding;

                bool autoSizing = m_PointSizeSamplingMode == 0;

                float strokeSize = m_FontStyleValue;
                if (m_RenderMode == RenderModes.DistanceField16)
                {
                    strokeSize = m_FontStyleValue * 16;
                }
                if (m_RenderMode == RenderModes.DistanceField32)
                {
                    strokeSize = m_FontStyleValue * 32;
                }

                m_IsProcessing          = true;
                m_IsGenerationCancelled = false;

                // Start Stop Watch
                m_StopWatch = System.Diagnostics.Stopwatch.StartNew();

                ThreadPool.QueueUserWorkItem(someTask =>
                {
                    m_IsRenderingDone = false;

                    errorCode = TMPro_FontPlugin.Render_Characters(m_TextureBuffer, m_AtlasWidth, m_AtlasHeight,
                                                                   padding, characterSet, m_CharacterCount, m_FontStyle, strokeSize, autoSizing, m_RenderMode,
                                                                   (int)m_PackingMode, ref m_FontFaceInfo, m_FontGlyphInfo);

                    ThreadRenderBackupFont(0, m_AtlasWidth);

                    m_IsRenderingDone = true;
                });
            }
        }
    }
Esempio n. 6
0
        public static void CreateSDFAsset(TexFont font, string fontPath)
        {
            // Simple checks...
            if (!font.Font_Asset)
            {
                return;
            }
            // Expensive check, somewhat useless

            /*var objs = AssetDatabase.FindAssets("t:TMP_FontAsset");
             * foreach (var obj in objs)
             * {
             *  var asset = AssetDatabase.LoadAssetAtPath<TMP_FontAsset>(AssetDatabase.GUIDToAssetPath(obj));
             *  if (asset.name == font.name)
             *  {
             *      font.SDF_Asset = asset;
             *      return;
             *  }
             * }*/

            //TMPro_FontPlugin.LinkDebugLog();

            var error = 0;

            error = TMPro_FontPlugin.Initialize_FontEngine();
            if (error != 0 && error != 99)
            {
                throw new Exception("ERROR: " + error.ToString());
            }
            error = TMPro_FontPlugin.Load_TrueType_Font(fontPath);
            if (error != 0 && error != 99)
            {
                throw new Exception("ERROR: " + error.ToString());
            }
            error = TMPro_FontPlugin.FT_Size_Font(72);
            if (error != 0 && error != 99)
            {
                throw new Exception("ERROR: " + error.ToString());
            }

            _buffers = new byte[_bufferWidth * _bufferHeight];
            var charSet = new int[font.chars.Length];

            _glyphsInfo = new FT_GlyphInfo[font.chars.Length];
            _atlasInfo  = null;

            for (int i = 0; i < font.chars.Length; i++)
            {
                charSet[i] = font.chars[i].characterIndex;
            }
            float strokeSize = _styleStrokeSize;

            if (_render == RenderModes.DistanceField16)
            {
                strokeSize = _styleStrokeSize * 16;
            }
            if (_render == RenderModes.DistanceField32)
            {
                strokeSize = _styleStrokeSize * 32;
            }

            EditorApplication.update += OnUpdate;

            _renderedFont = font;
            ThreadPool.QueueUserWorkItem(SomeTask =>
            {
                onRendering = true;

                error = TMPro_FontPlugin.Render_Characters(_buffers, _bufferWidth, _bufferHeight, _padding,
                                                           charSet, charSet.Length, _style, strokeSize, true, _render, _optimized ? 4 : 0,
                                                           ref _faceInfo, _glyphsInfo);

                if (error != 0 && error != 99)
                {
                    onRendering = false;
                    throw new Exception("ERROR: " + error.ToString());
                }
                // Can't call OnFinished here because this isn't a Main thread
                hasRendered = true;

                Debug.LogFormat("Font Rendering of {0}.ttf is completed.", font.id);
            });
        }