Exemplo n.º 1
0
        public void Import(IAssetImportEnvironment env)
        {
            // Handle all available input. No need to filter or ask for this anymore, as
            // the preparation step already made a selection with AcceptsInput. We won't
            // get any input here that didn't match.
            foreach (AssetImportInput input in env.Input)
            {
                // Request a target Resource with a name matching the input
                ContentRef <DualityFont> targetRef = env.GetOutput <DualityFont>(input.AssetName);

                // If we successfully acquired one, proceed with the import
                if (targetRef.IsAvailable)
                {
                    DualityFont target = targetRef.Res;

                    // Retrieve import parameters
                    float               size          = env.GetOrInitParameter(targetRef, "Size", 16.0f);
                    FontStyle           style         = env.GetOrInitParameter(targetRef, "Style", FontStyle.Regular);
                    string              customCharSet = env.GetOrInitParameter(targetRef, "CustomCharSet", string.Empty);
                    List <UnicodeBlock> unicodeBlocks = env.GetOrInitParameter(targetRef, "UnicodeBlocks", new List <UnicodeBlock>(DefaultBlocks));
                    bool antialiasing = env.GetOrInitParameter(targetRef, "AntiAlias", true);
                    bool monospace    = env.GetOrInitParameter(targetRef, "Monospace", false);

                    HashSet <char> fullCharSet = new HashSet <char>();

                    if (!string.IsNullOrWhiteSpace(customCharSet))
                    {
                        string[] blocks = customCharSet.Split(',');
                        ulong    start  = 0;
                        ulong    end    = 0;

                        foreach (string block in blocks)
                        {
                            string[] limits = block.Split(new[] { '-' }, 3);
                            if (!ulong.TryParse(limits[0], NumberStyles.HexNumber, null, out start))
                            {
                                Log.Editor.WriteError("Cannot parse value " + limits[0] + "; CustomCharSet will be ignored. Please verify the value and repeat the import.");
                            }

                            if (limits.Length == 1)
                            {
                                end = start;
                            }
                            else
                            {
                                if (limits.Length == 2 && !ulong.TryParse(limits[1], NumberStyles.HexNumber, null, out end))
                                {
                                    Log.Editor.WriteError("Cannot parse value " + limits[1] + "; CustomCharSet will be ignored. Please verify the value and repeat the import.");
                                }

                                else if (limits.Length > 2)
                                {
                                    Log.Editor.WriteError("Unexpected values " + limits[2] + " in range " + block + " will be ignored. Please verify the value and repeat the import.");
                                }

                                if (start > end)
                                {
                                    Log.Editor.WriteWarning(start + " is bigger than " + end + "; block will be ignored. Please verify the value and repeat the import.");
                                }
                            }

                            for (char c = (char)start; c <= (char)end; c++)
                            {
                                if (!char.IsControl(c))
                                {
                                    fullCharSet.Add(c);
                                }
                            }
                        }
                    }

                    if (unicodeBlocks != null)
                    {
                        Type unicodeBlockType     = typeof(UnicodeBlock);
                        Type unicodeRangeAttrType = typeof(UnicodeRangeAttribute);

                        foreach (UnicodeBlock block in unicodeBlocks)
                        {
                            UnicodeRangeAttribute range = unicodeBlockType.GetMember(block.ToString())
                                                          .First()
                                                          .GetCustomAttributes(unicodeRangeAttrType, false)
                                                          .FirstOrDefault() as UnicodeRangeAttribute;

                            if (range != null)
                            {
                                for (char c = (char)range.CharStart; c <= (char)range.CharEnd; c++)
                                {
                                    if (!char.IsControl(c))
                                    {
                                        fullCharSet.Add(c);
                                    }
                                }
                            }
                        }
                    }

                    // Load the TrueType Font and render all the required glyphs
                    byte[]           trueTypeData = File.ReadAllBytes(input.Path);
                    RenderedFontData fontData     = this.RenderGlyphs(
                        trueTypeData,
                        size,
                        style,
                        new FontCharSet(new string(fullCharSet.ToArray())),
                        antialiasing,
                        monospace);

                    // Transfer our rendered Font data to the Font Resource
                    target.SetGlyphData(
                        fontData.Bitmap,
                        fontData.Atlas,
                        fontData.GlyphData,
                        fontData.Metrics);

                    // Add the requested output to signal that we've done something with it
                    env.AddOutput(targetRef, input.Path);
                }
            }
        }
Exemplo n.º 2
0
        protected override void ImportResource(ContentRef <DualityFont> resourceRef, AssetImportInput input, IAssetImportEnvironment env)
        {
            DualityFont resource = resourceRef.Res;
            // Retrieve import parameters
            float               size          = env.GetOrInitParameter(resourceRef, "Size", 16.0f);
            FontStyle           style         = env.GetOrInitParameter(resourceRef, "Style", FontStyle.Regular);
            string              customCharSet = env.GetOrInitParameter(resourceRef, "CustomCharSet", string.Empty);
            List <UnicodeBlock> unicodeBlocks = env.GetOrInitParameter(resourceRef, "UnicodeBlocks", new List <UnicodeBlock>(DefaultBlocks));
            bool antialiasing = env.GetOrInitParameter(resourceRef, "AntiAlias", true);
            bool monospace    = env.GetOrInitParameter(resourceRef, "Monospace", false);

            HashSet <char> fullCharSet = new HashSet <char>();

            if (!string.IsNullOrWhiteSpace(customCharSet))
            {
                string[] blocks = customCharSet.Split(',');
                ulong    start  = 0;
                ulong    end    = 0;

                foreach (string block in blocks)
                {
                    string[] limits = block.Split(new[] { '-' }, 3);
                    if (!ulong.TryParse(limits[0], NumberStyles.HexNumber, null, out start))
                    {
                        Log.Editor.WriteError("Cannot parse value " + limits[0] + "; CustomCharSet will be ignored. Please verify the value and repeat the import.");
                    }

                    if (limits.Length == 1)
                    {
                        end = start;
                    }
                    else
                    {
                        if (limits.Length == 2 && !ulong.TryParse(limits[1], NumberStyles.HexNumber, null, out end))
                        {
                            Log.Editor.WriteError("Cannot parse value " + limits[1] + "; CustomCharSet will be ignored. Please verify the value and repeat the import.");
                        }

                        else if (limits.Length > 2)
                        {
                            Log.Editor.WriteError("Unexpected values " + limits[2] + " in range " + block + " will be ignored. Please verify the value and repeat the import.");
                        }

                        if (start > end)
                        {
                            Log.Editor.WriteWarning(start + " is bigger than " + end + "; block will be ignored. Please verify the value and repeat the import.");
                        }
                    }

                    for (char c = (char)start; c <= (char)end; c++)
                    {
                        if (!char.IsControl(c))
                        {
                            fullCharSet.Add(c);
                        }
                    }
                }
            }

            if (unicodeBlocks != null)
            {
                Type unicodeBlockType     = typeof(UnicodeBlock);
                Type unicodeRangeAttrType = typeof(UnicodeRangeAttribute);

                foreach (UnicodeBlock block in unicodeBlocks)
                {
                    UnicodeRangeAttribute range = unicodeBlockType.GetMember(block.ToString())
                                                  .First()
                                                  .GetCustomAttributes(unicodeRangeAttrType, false)
                                                  .FirstOrDefault() as UnicodeRangeAttribute;

                    if (range != null)
                    {
                        for (char c = (char)range.CharStart; c <= (char)range.CharEnd; c++)
                        {
                            if (!char.IsControl(c))
                            {
                                fullCharSet.Add(c);
                            }
                        }
                    }
                }
            }

            // Load the TrueType Font and render all the required glyphs
            byte[]           trueTypeData = File.ReadAllBytes(input.Path);
            RenderedFontData fontData     = this.RenderGlyphs(
                trueTypeData,
                size,
                style,
                new FontCharSet(new string(fullCharSet.ToArray())),
                antialiasing,
                monospace);

            // Transfer our rendered Font data to the Font Resource
            resource.SetGlyphData(
                fontData.Bitmap,
                fontData.Atlas,
                fontData.GlyphData,
                fontData.Metrics);
        }