Esempio n. 1
0
int FontConverter::exec() {
    /* Font converter dependencies */
    PluginManager::Manager<Trade::AbstractImageConverter> imageConverterManager(Utility::Directory::join(args.value("plugin-dir"), "imageconverters/"));

    /* Load font */
    PluginManager::Manager<Text::AbstractFont> fontManager(Utility::Directory::join(args.value("plugin-dir"), "fonts/"));
    if(!(fontManager.load(args.value("font")) & PluginManager::LoadState::Loaded))
        std::exit(1);
    std::unique_ptr<Text::AbstractFont> font = fontManager.instance(args.value("font"));

    /* Load font converter */
    PluginManager::Manager<Text::AbstractFontConverter> converterManager(Utility::Directory::join(args.value("plugin-dir"), "fontconverters/"));
    if(!(converterManager.load(args.value("converter")) & PluginManager::LoadState::Loaded))
        std::exit(1);
    std::unique_ptr<Text::AbstractFontConverter> converter = converterManager.instance(args.value("converter"));

    /* Open font */
    if(!font->openFile(args.value("input"), args.value<Float>("font-size"))) {
        Error() << "Cannot open font" << args.value("input");
        std::exit(1);
    }

    /* Create distance field glyph cache if radius is specified */
    std::unique_ptr<Text::GlyphCache> cache;
    if(!args.value<Vector2i>("output-size").isZero()) {
        Debug() << "Populating distance field glyph cache...";

        cache.reset(new Text::DistanceFieldGlyphCache(
            args.value<Vector2i>("atlas-size"),
            args.value<Vector2i>("output-size"),
            args.value<Int>("radius")));

    /* Otherwise use normal cache */
    } else {
        Debug() << "Zero-size distance field output specified, populating normal glyph cache...";

        cache.reset(new Text::GlyphCache(args.value<Vector2i>("atlas-size")));
    }

    /* Fill the cache */
    font->fillGlyphCache(*cache, args.value("characters"));

    Debug() << "Converting font...";

    /* Convert the font */
    if(!converter->exportFontToFile(*font, *cache, args.value("output"), args.value("characters"))) {
        Error() << "Cannot export font to" << args.value("output");
        std::exit(1);
    }

    Debug() << "Done.";

    return 0;
}
Esempio n. 2
0
int DistanceFieldConverter::exec() {
    /* Load plugins */
    PluginManager::Manager<Trade::AbstractImporter> importerManager(MAGNUM_IMPORTER_PLUGIN_DIR);
    if(!(importerManager.load(args.value("importer")) & PluginManager::LoadState::Loaded)) {
        Error() << "Cannot load importer plugin" << args.value("importer") << "from" << MAGNUM_IMPORTER_PLUGIN_DIR;
        return 1;
    }
    PluginManager::Manager<Trade::AbstractImageConverter> converterManager(MAGNUM_IMAGECONVERTER_PLUGIN_DIR);
    if(!(converterManager.load(args.value("converter")) & PluginManager::LoadState::Loaded)) {
        Error() << "Cannot load converter plugin" << args.value("converter") << "from" << MAGNUM_IMAGECONVERTER_PLUGIN_DIR;
        return 1;
    }

    /* Instance plugins */
    std::unique_ptr<Trade::AbstractImporter> importer = importerManager.instance(args.value("importer"));
    CORRADE_INTERNAL_ASSERT(importer);
    std::unique_ptr<Trade::AbstractImageConverter> converter = converterManager.instance(args.value("converter"));
    CORRADE_INTERNAL_ASSERT(converter);

    /* Open input file */
    std::optional<Trade::ImageData2D> image;
    if(!importer->openFile(args.value("input")) || !(image = importer->image2D(0))) {
        Error() << "Cannot open file" << args.value("input");
        return 1;
    }

    if(image->format() != ColorFormat::Red) {
        Error() << "Unsupported image format" << image->format();
        return 1;
    }

    /* Input texture */
    Texture2D input;
    input.setMinificationFilter(Sampler::Filter::Linear)
        .setMagnificationFilter(Sampler::Filter::Linear)
        .setWrapping(Sampler::Wrapping::ClampToEdge)
        .setImage(0, TextureFormat::R8, *image);

    /* Output texture */
    Texture2D output;
    output.setStorage(1, TextureFormat::R8, args.value<Vector2i>("output-size"));

    CORRADE_INTERNAL_ASSERT(Renderer::error() == Renderer::Error::NoError);

    /* Do it */
    Debug() << "Converting image of size" << image->size() << "to distance field...";
    TextureTools::distanceField(input, output, {{}, args.value<Vector2i>("output-size")}, args.value<Int>("radius"), image->size());

    /* Save image */
    Image2D result(ColorFormat::Red, ColorType::UnsignedByte);
    output.image(0, result);
    if(!converter->exportToFile(result, args.value("output"))) {
        Error() << "Cannot save file" << args.value("output");
        return 1;
    }

    return 0;
}
Esempio n. 3
0
int DistanceFieldConverter::exec() {
    /* Load importer plugin */
    PluginManager::Manager<Trade::AbstractImporter> importerManager(Utility::Directory::join(args.value("plugin-dir"), "importers/"));
    if(!(importerManager.load(args.value("importer")) & PluginManager::LoadState::Loaded))
        return 1;
    std::unique_ptr<Trade::AbstractImporter> importer = importerManager.instance(args.value("importer"));

    /* Load converter plugin */
    PluginManager::Manager<Trade::AbstractImageConverter> converterManager(Utility::Directory::join(args.value("plugin-dir"), "imageconverters/"));
    if(!(converterManager.load(args.value("converter")) & PluginManager::LoadState::Loaded))
        return 1;
    std::unique_ptr<Trade::AbstractImageConverter> converter = converterManager.instance(args.value("converter"));

    /* Open input file */
    std::optional<Trade::ImageData2D> image;
    if(!importer->openFile(args.value("input")) || !(image = importer->image2D(0))) {
        Error() << "Cannot open file" << args.value("input");
        return 1;
    }

    /* Decide about internal format */
    TextureFormat internalFormat;
    if(image->format() == PixelFormat::Red) internalFormat = TextureFormat::R8;
    else if(image->format() == PixelFormat::RGB) internalFormat = TextureFormat::RGB8;
    else if(image->format() == PixelFormat::RGBA) internalFormat = TextureFormat::RGBA8;
    else {
        Error() << "Unsupported image format" << image->format();
        return 1;
    }

    /* Input texture */
    Texture2D input;
    input.setMinificationFilter(Sampler::Filter::Linear)
        .setMagnificationFilter(Sampler::Filter::Linear)
        .setWrapping(Sampler::Wrapping::ClampToEdge)
        .setStorage(1, internalFormat, image->size())
        .setSubImage(0, {}, *image);

    /* Output texture */
    Texture2D output;
    output.setStorage(1, TextureFormat::R8, args.value<Vector2i>("output-size"));

    CORRADE_INTERNAL_ASSERT(Renderer::error() == Renderer::Error::NoError);

    /* Do it */
    Debug() << "Converting image of size" << image->size() << "to distance field...";
    TextureTools::distanceField(input, output, {{}, args.value<Vector2i>("output-size")}, args.value<Int>("radius"), image->size());

    /* Save image */
    Image2D result(PixelFormat::Red, PixelType::UnsignedByte);
    output.image(0, result);
    if(!converter->exportToFile(result, args.value("output"))) {
        Error() << "Cannot save file" << args.value("output");
        return 1;
    }

    return 0;
}