LayoutEngine::LayoutEngine(const LEFontInstance *fontInstance,
le_int32 scriptCode,
le_int32 languageCode,
le_int32 typoFlags,
LEErrorCode &success)
: fHbFont(NULL), fHbBuffer(NULL), fTypoFlags(typoFlags)
{
if (LE_FAILURE(success)) {
return;
}
fHbBuffer = hb_buffer_create ();
if (fHbBuffer == hb_buffer_get_empty ()) {
success = LE_MEMORY_ALLOCATION_ERROR;
return;
}
hb_buffer_set_unicode_funcs (fHbBuffer, hb_icu_get_unicode_funcs ());
hb_buffer_set_script (fHbBuffer, hb_icu_script_to_script ((UScriptCode) scriptCode));
/* TODO set language */
hb_face_t *face = hb_face_create_for_tables (icu_le_hb_reference_table, (void *) fontInstance, NULL);
fHbFont = hb_font_create (face);
hb_face_destroy (face);
if (fHbFont == hb_font_get_empty ()) {
success = LE_MEMORY_ALLOCATION_ERROR;
return;
}
hb_font_set_funcs (fHbFont, icu_le_hb_get_font_funcs (), (void *) fontInstance, NULL);
hb_font_set_scale (fHbFont,
+from_float (fontInstance->getXPixelsPerEm () * fontInstance->getScaleFactorX ()),
-from_float (fontInstance->getYPixelsPerEm () * fontInstance->getScaleFactorY ()));
hb_font_set_ppem (fHbFont,
fontInstance->getXPixelsPerEm (),
fontInstance->getYPixelsPerEm ());
}
void CTextRenderer::UpdateTextCache_HarfBuzz(array<CHarfbuzzGlyph>* pGlyphChain, const UChar* pTextUTF16, int Start, int Length, bool IsRTL, int FontId)
{
//Use harfbuzz to shape the text (arabic, tamil, ...)
hb_buffer_t* m_pHBBuffer = hb_buffer_create();
hb_buffer_set_unicode_funcs(m_pHBBuffer, hb_icu_get_unicode_funcs());
hb_buffer_set_direction(m_pHBBuffer, (IsRTL ? HB_DIRECTION_RTL : HB_DIRECTION_LTR));
hb_buffer_set_script(m_pHBBuffer, HB_SCRIPT_ARABIC);
hb_buffer_set_language(m_pHBBuffer, hb_language_from_string("ar", 2));
hb_buffer_add_utf16(m_pHBBuffer, pTextUTF16, Length, Start, Length);
hb_shape(m_Fonts[FontId]->m_pHBFont, m_pHBBuffer, 0, 0);
unsigned int GlyphCount;
hb_glyph_info_t* GlyphInfo = hb_buffer_get_glyph_infos(m_pHBBuffer, &GlyphCount);
hb_glyph_position_t* GlyphPos = hb_buffer_get_glyph_positions(m_pHBBuffer, &GlyphCount);
for(int i=0; i<GlyphCount; i++)
{
CHarfbuzzGlyph Glyph;
Glyph.m_GlyphId = CGlyphId(FontId, GlyphInfo[i].codepoint);
Glyph.m_CharPos = GlyphInfo[i].cluster;
pGlyphChain->add(Glyph);
}
hb_buffer_destroy(m_pHBBuffer);
}
inline bool HarfBuzzShaper::shapeRange(hb_buffer_t* harfBuzzBuffer,
unsigned startIndex,
unsigned numCharacters,
const SimpleFontData* currentFont,
PassRefPtr<UnicodeRangeSet> currentFontRangeSet,
UScriptCode currentRunScript,
hb_language_t language)
{
const FontPlatformData* platformData = &(currentFont->platformData());
HarfBuzzFace* face = platformData->harfBuzzFace();
if (!face) {
DLOG(ERROR) << "Could not create HarfBuzzFace from FontPlatformData.";
return false;
}
hb_buffer_set_language(harfBuzzBuffer, language);
hb_buffer_set_script(harfBuzzBuffer, ICUScriptToHBScript(currentRunScript));
hb_buffer_set_direction(harfBuzzBuffer, TextDirectionToHBDirection(m_textRun.direction(),
m_font->getFontDescription().orientation(), currentFont));
hb_font_t* hbFont = face->getScaledFont(currentFontRangeSet);
hb_shape(hbFont, harfBuzzBuffer, m_features.isEmpty() ? 0 : m_features.data(), m_features.size());
return true;
}
bool HarfBuzzShaper::shapeHarfBuzzRuns(bool shouldSetDirection)
{
HarfBuzzScopedPtr<hb_buffer_t> harfBuzzBuffer(hb_buffer_create(), hb_buffer_destroy);
hb_buffer_set_unicode_funcs(harfBuzzBuffer.get(), hb_icu_get_unicode_funcs());
for (unsigned i = 0; i < m_harfBuzzRuns.size(); ++i) {
unsigned runIndex = m_run.rtl() ? m_harfBuzzRuns.size() - i - 1 : i;
HarfBuzzRun* currentRun = m_harfBuzzRuns[runIndex].get();
const SimpleFontData* currentFontData = currentRun->fontData();
if (currentFontData->isSVGFont())
return false;
hb_buffer_set_script(harfBuzzBuffer.get(), currentRun->script());
if (shouldSetDirection)
hb_buffer_set_direction(harfBuzzBuffer.get(), currentRun->rtl() ? HB_DIRECTION_RTL : HB_DIRECTION_LTR);
else
// Leaving direction to HarfBuzz to guess is *really* bad, but will do for now.
hb_buffer_guess_segment_properties(harfBuzzBuffer.get());
// Add a space as pre-context to the buffer. This prevents showing dotted-circle
// for combining marks at the beginning of runs.
static const uint16_t preContext = ' ';
hb_buffer_add_utf16(harfBuzzBuffer.get(), &preContext, 1, 1, 0);
if (m_font->isSmallCaps() && u_islower(m_normalizedBuffer[currentRun->startIndex()])) {
String upperText = String(m_normalizedBuffer.get() + currentRun->startIndex(), currentRun->numCharacters());
upperText.makeUpper();
currentFontData = m_font->glyphDataForCharacter(upperText[0], false, SmallCapsVariant).fontData;
hb_buffer_add_utf16(harfBuzzBuffer.get(), upperText.characters(), currentRun->numCharacters(), 0, currentRun->numCharacters());
} else
hb_buffer_add_utf16(harfBuzzBuffer.get(), m_normalizedBuffer.get() + currentRun->startIndex(), currentRun->numCharacters(), 0, currentRun->numCharacters());
FontPlatformData* platformData = const_cast<FontPlatformData*>(¤tFontData->platformData());
HarfBuzzFace* face = platformData->harfBuzzFace();
if (!face)
return false;
if (m_font->fontDescription().orientation() == Vertical)
face->setScriptForVerticalGlyphSubstitution(harfBuzzBuffer.get());
HarfBuzzScopedPtr<hb_font_t> harfBuzzFont(face->createFont(), hb_font_destroy);
hb_shape(harfBuzzFont.get(), harfBuzzBuffer.get(), m_features.isEmpty() ? 0 : m_features.data(), m_features.size());
currentRun->applyShapeResult(harfBuzzBuffer.get());
setGlyphPositionsForHarfBuzzRun(currentRun, harfBuzzBuffer.get());
hb_buffer_reset(harfBuzzBuffer.get());
}
return true;
}
TextLayout::TextLayout (int direction, const char *script, const char *language) {
if (strlen (script) != 4) return;
mFont = 0;
mHBFont = 0;
mDirection = (hb_direction_t)direction;
mLanguage = (long)hb_language_from_string (language, strlen (language));
mScript = hb_script_from_string (script, -1);
mBuffer = hb_buffer_create ();
hb_buffer_set_direction ((hb_buffer_t*)mBuffer, (hb_direction_t)mDirection);
hb_buffer_set_script ((hb_buffer_t*)mBuffer, (hb_script_t)mScript);
hb_buffer_set_language ((hb_buffer_t*)mBuffer, (hb_language_t)mLanguage);
}
std::unique_ptr<AbstractLayouter> HarfBuzzFont::doLayout(const GlyphCache& cache, const Float size, const std::string& text) {
/* Prepare HarfBuzz buffer */
hb_buffer_t* const buffer = hb_buffer_create();
hb_buffer_set_direction(buffer, HB_DIRECTION_LTR);
hb_buffer_set_script(buffer, HB_SCRIPT_LATIN);
hb_buffer_set_language(buffer, hb_language_from_string("en", 2));
/* Layout the text */
hb_buffer_add_utf8(buffer, text.data(), text.size(), 0, -1);
hb_shape(hbFont, buffer, nullptr, 0);
UnsignedInt glyphCount;
hb_glyph_info_t* const glyphInfo = hb_buffer_get_glyph_infos(buffer, &glyphCount);
hb_glyph_position_t* const glyphPositions = hb_buffer_get_glyph_positions(buffer, &glyphCount);
return std::unique_ptr<AbstractLayouter>(new HarfBuzzLayouter(cache, this->size(), size, buffer, glyphInfo, glyphPositions, glyphCount));
}
static bool
_raqm_shape (raqm_t *rq)
{
for (raqm_run_t *run = rq->runs; run != NULL; run = run->next)
{
run->buffer = hb_buffer_create ();
hb_buffer_add_utf32 (run->buffer, rq->text, rq->text_len,
run->pos, run->len);
hb_buffer_set_script (run->buffer, run->script);
hb_buffer_set_language (run->buffer, hb_language_get_default ());
hb_buffer_set_direction (run->buffer, run->direction);
hb_shape_full (rq->font, run->buffer, rq->features, rq->features_len,
NULL);
}
return true;
}
ilG_gui_textlayout *ilG_gui_textlayout_new(ilG_context *ctx, const char *lang, enum ilG_gui_textdir direction, const char *script, il_base *font, const ilA_file *tc, double pt, il_string *source)
{
il_return_null_on_fail(ctx && lang && script && font && source);
struct text_globalctx *gctx = il_base_get(&ctx->base, "il.graphics.gui.text.ctx", NULL, NULL);
if (!gctx) {
gctx = calloc(1, sizeof(struct text_globalctx));
il_return_null_on_fail(!FT_Init_FreeType(&gctx->library));
il_base_set(&ctx->base, "il.graphics.gui.text.ctx", gctx, sizeof(struct text_globalctx), IL_VOID);
}
ilG_gui_textlayout *l = il_new(&ilG_gui_textlayout_type);
l->context = ctx;
l->lang = strdup(lang);
l->script = strdup(script);
l->font = il_ref(font);
l->direction = direction;
l->pt = pt;
l->source = il_string_ref(source);
size_t size;
void *data = ilA_contents(tc, font, &size);
if (!data) {
il_error("Could not open font");
return NULL;
}
il_return_null_on_fail(!FT_New_Memory_Face(gctx->library, data, size, 0, &l->ft_face));
il_return_null_on_fail(!FT_Set_Char_Size(l->ft_face, 0, pt * 64, 0, 0));
l->hb_ft_font = hb_ft_font_create(l->ft_face, NULL);
l->buf = hb_buffer_create();
hb_buffer_set_unicode_funcs(l->buf, hb_icu_get_unicode_funcs());
if (direction == ILG_GUI_DEFAULTDIR) { // TODO: find out how to determine this based on script
direction = ILG_GUI_LTR;
}
hb_buffer_set_direction(l->buf, direction + 3); // Hacky solution
hb_buffer_set_script(l->buf, hb_script_from_string(script, -1));
hb_buffer_set_language(l->buf, hb_language_from_string(lang, -1));
hb_buffer_add_utf8(l->buf, source->data, source->length, 0, source->length);
hb_shape(l->hb_ft_font, l->buf, NULL, 0);
l->glyph_info = hb_buffer_get_glyph_infos(l->buf, &l->glyph_count);
l->glyph_pos = hb_buffer_get_glyph_positions(l->buf, &l->glyph_count);
return l;
}
// ------------------------------------------------------------------- init ---
void init( void )
{
size_t i, j;
int ptSize = 50*64;
int device_hdpi = 72;
int device_vdpi = 72;
atlas = texture_atlas_new( 512, 512, 3 );
/* Init freetype */
FT_Library ft_library;
assert(!FT_Init_FreeType(&ft_library));
/* Load our fonts */
FT_Face ft_face[NUM_EXAMPLES];
assert(!FT_New_Face( ft_library, fonts[ENGLISH], 0, &ft_face[ENGLISH]) );
assert(!FT_Set_Char_Size( ft_face[ENGLISH], 0, ptSize, device_hdpi, device_vdpi ) );
// ftfdump( ft_face[ENGLISH] ); // wonderful world of encodings ...
force_ucs2_charmap( ft_face[ENGLISH] ); // which we ignore.
assert( !FT_New_Face(ft_library, fonts[ARABIC], 0, &ft_face[ARABIC]) );
assert( !FT_Set_Char_Size(ft_face[ARABIC], 0, ptSize, device_hdpi, device_vdpi ) );
// ftfdump( ft_face[ARABIC] );
force_ucs2_charmap( ft_face[ARABIC] );
assert(!FT_New_Face( ft_library, fonts[CHINESE], 0, &ft_face[CHINESE]) );
assert(!FT_Set_Char_Size( ft_face[CHINESE], 0, ptSize, device_hdpi, device_vdpi ) );
// ftfdump( ft_face[CHINESE] );
force_ucs2_charmap( ft_face[CHINESE] );
/* Get our harfbuzz font structs */
hb_font_t *hb_ft_font[NUM_EXAMPLES];
hb_ft_font[ENGLISH] = hb_ft_font_create( ft_face[ENGLISH], NULL );
hb_ft_font[ARABIC] = hb_ft_font_create( ft_face[ARABIC] , NULL );
hb_ft_font[CHINESE] = hb_ft_font_create( ft_face[CHINESE], NULL );
/* Create a buffer for harfbuzz to use */
hb_buffer_t *buf = hb_buffer_create();
for (i=0; i < NUM_EXAMPLES; ++i)
{
hb_buffer_set_direction( buf, text_directions[i] ); /* or LTR */
hb_buffer_set_script( buf, scripts[i] ); /* see hb-unicode.h */
hb_buffer_set_language( buf,
hb_language_from_string(languages[i], strlen(languages[i])) );
/* Layout the text */
hb_buffer_add_utf8( buf, texts[i], strlen(texts[i]), 0, strlen(texts[i]) );
hb_shape( hb_ft_font[i], buf, NULL, 0 );
unsigned int glyph_count;
hb_glyph_info_t *glyph_info = hb_buffer_get_glyph_infos(buf, &glyph_count);
hb_glyph_position_t *glyph_pos = hb_buffer_get_glyph_positions(buf, &glyph_count);
FT_GlyphSlot slot;
FT_Bitmap ft_bitmap;
float size = 24;
size_t hres = 64;
FT_Error error;
FT_Int32 flags = 0;
flags |= FT_LOAD_RENDER;
flags |= FT_LOAD_TARGET_LCD;
FT_Library_SetLcdFilter( ft_library, FT_LCD_FILTER_LIGHT );
FT_Matrix matrix = { (int)((1.0/hres) * 0x10000L),
(int)((0.0) * 0x10000L),
(int)((0.0) * 0x10000L),
(int)((1.0) * 0x10000L) };
/* Set char size */
error = FT_Set_Char_Size( ft_face[i], (int)(ptSize), 0, 72*hres, 72 );
if( error )
{
//fprintf( stderr, "FT_Error (line %d, code 0x%02x) : %s\n",
// __LINE__, FT_Errors[error].code, FT_Errors[error].message );
FT_Done_Face( ft_face[i] );
break;
}
/* Set transform matrix */
FT_Set_Transform( ft_face[i], &matrix, NULL );
for (j = 0; j < glyph_count; ++j)
{
/* Load glyph */
error = FT_Load_Glyph( ft_face[i], glyph_info[j].codepoint, flags );
if( error )
{
//fprintf( stderr, "FT_Error (line %d, code 0x%02x) : %s\n",
// __LINE__, FT_Errors[error].code, FT_Errors[error].message );
FT_Done_Face( ft_face[i] );
break;
}
slot = ft_face[i]->glyph;
ft_bitmap = slot->bitmap;
int ft_bitmap_width = slot->bitmap.width;
int ft_bitmap_rows = slot->bitmap.rows;
int ft_bitmap_pitch = slot->bitmap.pitch;
int ft_glyph_top = slot->bitmap_top;
int ft_glyph_left = slot->bitmap_left;
int w = ft_bitmap_width/3; // 3 because of LCD/RGB encoding
int h = ft_bitmap_rows;
ivec4 region = texture_atlas_get_region( atlas, w+1, h+1 );
if ( region.x < 0 )
{
fprintf( stderr, "Texture atlas is full (line %d)\n", __LINE__ );
continue;
}
int x = region.x, y = region.y;
texture_atlas_set_region( atlas, region.x, region.y,
w, h, ft_bitmap.buffer, ft_bitmap.pitch );
printf("%d: %dx%d %f %f\n",
glyph_info[j].codepoint,
ft_bitmap_width,
ft_bitmap_rows,
glyph_pos[j].x_advance/64.,
glyph_pos[j].y_advance/64.);
}
/* clean up the buffer, but don't kill it just yet */
hb_buffer_reset(buf);
}
/* Cleanup */
hb_buffer_destroy( buf );
for( i=0; i < NUM_EXAMPLES; ++i )
hb_font_destroy( hb_ft_font[i] );
FT_Done_FreeType( ft_library );
glClearColor(1,1,1,1);
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glGenTextures( 1, &atlas->id );
glBindTexture( GL_TEXTURE_2D, atlas->id );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, atlas->width, atlas->height,
0, GL_RGB, GL_UNSIGNED_BYTE, atlas->data );
typedef struct { float x,y,z, u,v, r,g,b,a, shift, gamma; } vertex_t;
vertex_t vertices[4] = {
{ 0, 0,0, 0,1, 0,0,0,1, 0, 1},
{ 0,512,0, 0,0, 0,0,0,1, 0, 1},
{512,512,0, 1,0, 0,0,0,1, 0, 1},
{512, 0,0, 1,1, 0,0,0,1, 0, 1} };
GLuint indices[6] = { 0, 1, 2, 0,2,3 };
buffer = vertex_buffer_new( "vertex:3f,"
"tex_coord:2f,"
"color:4f,"
"ashift:1f,"
"agamma:1f" );
vertex_buffer_push_back( buffer, vertices, 4, indices, 6 );
shader = shader_load("shaders/text.vert",
"shaders/text.frag");
mat4_set_identity( &projection );
mat4_set_identity( &model );
mat4_set_identity( &view );
}
static void shape_text(text_line & line,
text_itemizer & itemizer,
std::map<unsigned,double> & width_map,
face_manager_freetype & font_manager,
double scale_factor)
{
unsigned start = line.first_char();
unsigned end = line.last_char();
std::size_t length = end - start;
if (!length) return;
std::list<text_item> const& list = itemizer.itemize(start, end);
line.reserve(length);
auto hb_buffer_deleter = [](hb_buffer_t * buffer) { hb_buffer_destroy(buffer);};
const std::unique_ptr<hb_buffer_t, decltype(hb_buffer_deleter)> buffer(hb_buffer_create(),hb_buffer_deleter);
hb_buffer_pre_allocate(buffer.get(), safe_cast<int>(length));
mapnik::value_unicode_string const& text = itemizer.text();
for (auto const& text_item : list)
{
face_set_ptr face_set = font_manager.get_face_set(text_item.format_->face_name, text_item.format_->fontset);
double size = text_item.format_->text_size * scale_factor;
face_set->set_unscaled_character_sizes();
std::size_t num_faces = face_set->size();
std::size_t pos = 0;
font_feature_settings const& ff_settings = text_item.format_->ff_settings;
int ff_count = safe_cast<int>(ff_settings.count());
for (auto const& face : *face_set)
{
++pos;
hb_buffer_clear_contents(buffer.get());
hb_buffer_add_utf16(buffer.get(), uchar_to_utf16(text.getBuffer()), text.length(), text_item.start, static_cast<int>(text_item.end - text_item.start));
hb_buffer_set_direction(buffer.get(), (text_item.dir == UBIDI_RTL)?HB_DIRECTION_RTL:HB_DIRECTION_LTR);
hb_buffer_set_script(buffer.get(), _icu_script_to_script(text_item.script));
hb_font_t *font(hb_ft_font_create(face->get_face(), nullptr));
// https://github.com/mapnik/test-data-visual/pull/25
#if HB_VERSION_MAJOR > 0
#if HB_VERSION_ATLEAST(1, 0 , 5)
hb_ft_font_set_load_flags(font,FT_LOAD_DEFAULT | FT_LOAD_NO_HINTING);
#endif
#endif
hb_shape(font, buffer.get(), ff_settings.get_features(), ff_count);
hb_font_destroy(font);
unsigned num_glyphs = hb_buffer_get_length(buffer.get());
hb_glyph_info_t *glyphs = hb_buffer_get_glyph_infos(buffer.get(), nullptr);
hb_glyph_position_t *positions = hb_buffer_get_glyph_positions(buffer.get(), nullptr);
bool font_has_all_glyphs = true;
// Check if all glyphs are valid.
for (unsigned i=0; i<num_glyphs; ++i)
{
if (!glyphs[i].codepoint)
{
font_has_all_glyphs = false;
break;
}
}
if (!font_has_all_glyphs && (pos < num_faces))
{
//Try next font in fontset
continue;
}
double max_glyph_height = 0;
for (unsigned i=0; i<num_glyphs; ++i)
{
auto const& gpos = positions[i];
auto const& glyph = glyphs[i];
unsigned char_index = glyph.cluster;
glyph_info g(glyph.codepoint,char_index,text_item.format_);
if (face->glyph_dimensions(g))
{
g.face = face;
g.scale_multiplier = size / face->get_face()->units_per_EM;
//Overwrite default advance with better value provided by HarfBuzz
g.unscaled_advance = gpos.x_advance;
g.offset.set(gpos.x_offset * g.scale_multiplier, gpos.y_offset * g.scale_multiplier);
double tmp_height = g.height();
if (tmp_height > max_glyph_height) max_glyph_height = tmp_height;
width_map[char_index] += g.advance();
line.add_glyph(std::move(g), scale_factor);
}
}
line.update_max_char_height(max_glyph_height);
break; //When we reach this point the current font had all glyphs.
}
}
}
static int ShapeParagraphHarfBuzz( filter_t *p_filter,
paragraph_t **p_old_paragraph )
{
paragraph_t *p_paragraph = *p_old_paragraph;
paragraph_t *p_new_paragraph = 0;
filter_sys_t *p_sys = p_filter->p_sys;
int i_total_glyphs = 0;
int i_ret = VLC_EGENERIC;
if( p_paragraph->i_size <= 0 || p_paragraph->i_runs_count <= 0 )
{
msg_Err( p_filter, "ShapeParagraphHarfBuzz() invalid parameters. "
"Paragraph size: %d. Runs count %d",
p_paragraph->i_size, p_paragraph->i_runs_count );
return VLC_EGENERIC;
}
for( int i = 0; i < p_paragraph->i_runs_count; ++i )
{
run_desc_t *p_run = p_paragraph->p_runs + i;
text_style_t *p_style = p_run->p_style;
/*
* When using HarfBuzz, this is where font faces are loaded.
* In the other two paths (shaping with FriBidi or no
* shaping at all), faces are loaded in LoadGlyphs()
*/
FT_Face p_face = 0;
if( !p_run->p_face )
{
p_face = LoadFace( p_filter, p_style );
if( !p_face )
{
p_face = p_sys->p_face;
p_style = &p_sys->style;
p_run->p_style = p_style;
}
p_run->p_face = p_face;
}
else
p_face = p_run->p_face;
p_run->p_hb_font = hb_ft_font_create( p_face, 0 );
if( !p_run->p_hb_font )
{
msg_Err( p_filter,
"ShapeParagraphHarfBuzz(): hb_ft_font_create() error" );
goto error;
}
p_run->p_buffer = hb_buffer_create();
if( !p_run->p_buffer )
{
msg_Err( p_filter,
"ShapeParagraphHarfBuzz(): hb_buffer_create() error" );
goto error;
}
hb_buffer_set_direction( p_run->p_buffer, p_run->direction );
hb_buffer_set_script( p_run->p_buffer, p_run->script );
#ifdef __OS2__
hb_buffer_add_utf16( p_run->p_buffer,
p_paragraph->p_code_points + p_run->i_start_offset,
p_run->i_end_offset - p_run->i_start_offset, 0,
p_run->i_end_offset - p_run->i_start_offset );
#else
hb_buffer_add_utf32( p_run->p_buffer,
p_paragraph->p_code_points + p_run->i_start_offset,
p_run->i_end_offset - p_run->i_start_offset, 0,
p_run->i_end_offset - p_run->i_start_offset );
#endif
hb_shape( p_run->p_hb_font, p_run->p_buffer, 0, 0 );
p_run->p_glyph_infos =
hb_buffer_get_glyph_infos( p_run->p_buffer, &p_run->i_glyph_count );
p_run->p_glyph_positions =
hb_buffer_get_glyph_positions( p_run->p_buffer, &p_run->i_glyph_count );
if( p_run->i_glyph_count <= 0 )
{
msg_Err( p_filter,
"ShapeParagraphHarfBuzz() invalid glyph count in shaped run" );
goto error;
}
i_total_glyphs += p_run->i_glyph_count;
}
p_new_paragraph = NewParagraph( p_filter, i_total_glyphs, 0, 0, 0,
p_paragraph->i_runs_size );
if( !p_new_paragraph )
{
i_ret = VLC_ENOMEM;
goto error;
}
p_new_paragraph->paragraph_type = p_paragraph->paragraph_type;
int i_index = 0;
for( int i = 0; i < p_paragraph->i_runs_count; ++i )
{
run_desc_t *p_run = p_paragraph->p_runs + i;
hb_glyph_info_t *p_infos = p_run->p_glyph_infos;
hb_glyph_position_t *p_positions = p_run->p_glyph_positions;
for( unsigned int j = 0; j < p_run->i_glyph_count; ++j )
{
/*
* HarfBuzz reverses the order of glyphs in RTL runs. We reverse
* it again here to keep the glyphs in their logical order.
* For line breaking of paragraphs to work correctly, visual
* reordering should be done after line breaking has taken
* place.
*/
int i_run_index = p_run->direction == HB_DIRECTION_LTR ?
j : p_run->i_glyph_count - 1 - j;
int i_source_index =
p_infos[ i_run_index ].cluster + p_run->i_start_offset;
p_new_paragraph->p_code_points[ i_index ] = 0;
p_new_paragraph->pi_glyph_indices[ i_index ] =
p_infos[ i_run_index ].codepoint;
p_new_paragraph->p_scripts[ i_index ] =
p_paragraph->p_scripts[ i_source_index ];
p_new_paragraph->p_types[ i_index ] =
p_paragraph->p_types[ i_source_index ];
p_new_paragraph->p_levels[ i_index ] =
p_paragraph->p_levels[ i_source_index ];
p_new_paragraph->pp_styles[ i_index ] =
p_paragraph->pp_styles[ i_source_index ];
p_new_paragraph->pi_karaoke_bar[ i_index ] =
p_paragraph->pi_karaoke_bar[ i_source_index ];
p_new_paragraph->p_glyph_bitmaps[ i_index ].i_x_offset =
p_positions[ i_run_index ].x_offset;
p_new_paragraph->p_glyph_bitmaps[ i_index ].i_y_offset =
p_positions[ i_run_index ].y_offset;
p_new_paragraph->p_glyph_bitmaps[ i_index ].i_x_advance =
p_positions[ i_run_index ].x_advance;
p_new_paragraph->p_glyph_bitmaps[ i_index ].i_y_advance =
p_positions[ i_run_index ].y_advance;
++i_index;
}
if( AddRun( p_filter, p_new_paragraph, i_index - p_run->i_glyph_count,
i_index, p_run->p_face ) )
goto error;
}
for( int i = 0; i < p_paragraph->i_runs_count; ++i )
{
hb_font_destroy( p_paragraph->p_runs[ i ].p_hb_font );
hb_buffer_destroy( p_paragraph->p_runs[ i ].p_buffer );
}
FreeParagraph( *p_old_paragraph );
*p_old_paragraph = p_new_paragraph;
return VLC_SUCCESS;
error:
for( int i = 0; i < p_paragraph->i_runs_count; ++i )
{
if( p_paragraph->p_runs[ i ].p_hb_font )
hb_font_destroy( p_paragraph->p_runs[ i ].p_hb_font );
if( p_paragraph->p_runs[ i ].p_buffer )
hb_buffer_destroy( p_paragraph->p_runs[ i ].p_buffer );
}
if( p_new_paragraph )
FreeParagraph( p_new_paragraph );
return i_ret;
}
JNIEXPORT jboolean JNICALL Java_sun_font_SunLayoutEngine_shape
(JNIEnv *env, jclass cls,
jobject font2D,
jobject fontStrike,
jfloat ptSize,
jfloatArray matrix,
jlong pFace,
jlong pNativeFont,
jboolean aat,
jcharArray text,
jobject gvdata,
jint script,
jint offset,
jint limit,
jint baseIndex,
jobject startPt,
jint flags,
jint slot) {
hb_buffer_t *buffer;
hb_face_t* hbface;
hb_font_t* hbfont;
jchar *chars;
jsize len;
int glyphCount;
hb_glyph_info_t *glyphInfo;
hb_glyph_position_t *glyphPos;
hb_direction_t direction = HB_DIRECTION_LTR;
hb_feature_t *features = NULL;
int featureCount = 0;
char* kern = (flags & TYPO_KERN) ? "kern" : "-kern";
char* liga = (flags & TYPO_LIGA) ? "liga" : "-liga";
jboolean ret;
unsigned int buflen;
JDKFontInfo *jdkFontInfo =
createJDKFontInfo(env, font2D, fontStrike, ptSize,
pNativeFont, matrix, aat);
if (!jdkFontInfo) {
return JNI_FALSE;
}
jdkFontInfo->env = env; // this is valid only for the life of this JNI call.
jdkFontInfo->font2D = font2D;
jdkFontInfo->fontStrike = fontStrike;
hbface = (hb_face_t*) jlong_to_ptr(pFace);
hbfont = hb_jdk_font_create(hbface, jdkFontInfo, NULL);
buffer = hb_buffer_create();
hb_buffer_set_script(buffer, getHBScriptCode(script));
hb_buffer_set_language(buffer,
hb_ot_tag_to_language(HB_OT_TAG_DEFAULT_LANGUAGE));
if ((flags & TYPO_RTL) != 0) {
direction = HB_DIRECTION_RTL;
}
hb_buffer_set_direction(buffer, direction);
hb_buffer_set_cluster_level(buffer,
HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS);
chars = (*env)->GetCharArrayElements(env, text, NULL);
if ((*env)->ExceptionCheck(env)) {
hb_buffer_destroy(buffer);
hb_font_destroy(hbfont);
free((void*)jdkFontInfo);
return JNI_FALSE;
}
len = (*env)->GetArrayLength(env, text);
hb_buffer_add_utf16(buffer, chars, len, offset, limit-offset);
features = calloc(2, sizeof(hb_feature_t));
if (features) {
hb_feature_from_string(kern, -1, &features[featureCount++]);
hb_feature_from_string(liga, -1, &features[featureCount++]);
}
hb_shape_full(hbfont, buffer, features, featureCount, 0);
glyphCount = hb_buffer_get_length(buffer);
glyphInfo = hb_buffer_get_glyph_infos(buffer, 0);
glyphPos = hb_buffer_get_glyph_positions(buffer, &buflen);
ret = storeGVData(env, gvdata, slot, baseIndex, offset, startPt,
limit - offset, glyphCount, glyphInfo, glyphPos,
jdkFontInfo->devScale);
hb_buffer_destroy (buffer);
hb_font_destroy(hbfont);
free((void*)jdkFontInfo);
if (features != NULL) free(features);
(*env)->ReleaseCharArrayElements(env, text, chars, JNI_ABORT);
return ret;
}
void Java_org_iisc_mile_indictext_android_EditIndicText_drawIndicText(
JNIEnv* env, jobject thiz, jstring unicodeText, jint xStart,
jint yBaseLine, jint charHeight, jobject lock) {
FT_Library ft_library;
FT_Face ft_face;
hb_font_t *font;
hb_buffer_t *buffer;
int glyph_count;
hb_glyph_info_t *glyph_info;
hb_glyph_position_t *glyph_pos;
hb_bool_t fail;
FT_UInt glyph_index;
FT_GlyphSlot slot;
FT_Error error;
char* fontFilePath;
jboolean iscopy;
const jchar *text;
int num_chars, i;
int pen_x;
int glyphPosX, glyphPosY;
fontFilePath =
"/sdcard/Android/data/org.iisc.mile.indictext.android/Lohit-Kannada.ttf";
text = (*env)->GetStringChars(env, unicodeText, &iscopy);
num_chars = (*env)->GetStringLength(env, unicodeText);
error = FT_Init_FreeType(&ft_library); /* initialize library */
if (error) {
__android_log_print(6, "drawIndicText",
"Error initializing FreeType library\n");
return;
}
__android_log_print(2, "drawIndicText",
"Successfully initialized FreeType library\n");
error = FT_New_Face(ft_library, fontFilePath, 0, &ft_face); /* create face object */
if (error == FT_Err_Unknown_File_Format) {
__android_log_print(6, "drawIndicText",
"The font file could be opened and read, but it appears that its font format is unsupported");
return;
} else if (error) {
__android_log_print(6, "drawIndicText",
"The font file could not be opened or read, or it might be broken");
return;
}
__android_log_print(2, "drawIndicText",
"Successfully created font-face object\n");
font = hb_ft_font_create(ft_face, NULL);
error = FT_Set_Pixel_Sizes(ft_face, 0, charHeight); /* set character size */
/* error handling omitted */
__android_log_print(2, "drawIndicText",
"Successfully set character size to %d\n", charHeight);
__android_log_print(2, "drawIndicText", "Text being rendered = %s\n", text);
slot = ft_face->glyph;
pen_x = xStart;
/* Create a buffer for harfbuzz to use */
buffer = hb_buffer_create();
//hb_buffer_set_unicode_funcs(buffer, hb_icu_get_unicode_funcs());
//alternatively you can use hb_buffer_set_unicode_funcs(buffer, hb_glib_get_unicode_funcs());
//hb_buffer_set_direction(buffer, HB_DIRECTION_LTR); /* or LTR */
hb_buffer_set_script(buffer, HB_SCRIPT_KANNADA); /* see hb-unicode.h */
//hb_buffer_set_language(buffer, hb_language_from_string("ka"));
/* Layout the text */
hb_buffer_add_utf16(buffer, text, num_chars, 0, num_chars);
__android_log_print(2, "drawIndicText", "Before HarfBuzz shape()\n");
hb_shape(font, buffer, NULL, 0);
__android_log_print(2, "drawIndicText", "After HarfBuzz shape()\n");
glyph_count = hb_buffer_get_length(buffer);
glyph_info = hb_buffer_get_glyph_infos(buffer, 0);
glyph_pos = hb_buffer_get_glyph_positions(buffer, 0);
for (i = 0; i < glyph_count; i++) {
glyph_index = glyph_info[i].codepoint;
__android_log_print(2, "drawIndicText", "Glyph%d = %x", i, glyph_index);
error = FT_Load_Glyph(ft_face, glyph_index, FT_LOAD_DEFAULT);
if (error) {
continue; /* ignore errors */
}
/* convert to an anti-aliased bitmap */
error = FT_Render_Glyph(ft_face->glyph, FT_RENDER_MODE_NORMAL);
if (error) {
continue;
}
/* now, draw to our target surface (convert position) */
draw_bitmap(&slot->bitmap, pen_x + slot->bitmap_left,
yBaseLine - slot->bitmap_top, env, thiz, lock);
//glyphPosX = pen_x + glyph_pos[i].x_offset;
//glyphPosY = yBaseLine - glyph_pos[i].y_offset;
//draw_bitmap(&slot->bitmap, glyphPosX, glyphPosY, env, thiz, lock);
/* increment pen position */
pen_x += slot->advance.x >> 6;
//pen_x += glyph_pos[i].x_advance / 64;
__android_log_print(2, "drawIndicText",
"\tx_offset = %d\ty_offset = %d\tx_advance = %d\ty_advance = %d\n",
glyph_pos[i].x_offset / 64, glyph_pos[i].y_offset / 64,
glyph_pos[i].x_advance / 64, glyph_pos[i].y_advance / 64);
__android_log_print(2, "drawIndicText",
"\tbitmap_left = %d\tbitmap_top = %d\tadvance.x = %d\tadvance.y = %d\n",
slot->bitmap_left, slot->bitmap_top, slot->advance.x >> 6,
slot->advance.y >> 6);
}
hb_buffer_destroy(buffer);
(*env)->ReleaseStringChars(env, unicodeText, text);
hb_font_destroy(font);
FT_Done_Face(ft_face);
FT_Done_FreeType(ft_library);
return;
}
static void
text_to_glyphs (cairo_t *cr,
const gchar *text,
cairo_glyph_t **glyphs,
int *num_glyphs)
{
PangoAttribute *fallback_attr;
PangoAttrList *attr_list;
PangoContext *context;
PangoDirection base_dir;
GList *items;
GList *visual_items;
FT_Face ft_face;
hb_font_t *hb_font;
gdouble x = 0, y = 0;
gint i;
gdouble x_scale, y_scale;
*num_glyphs = 0;
*glyphs = NULL;
base_dir = pango_find_base_dir (text, -1);
cairo_scaled_font_t *cr_font = cairo_get_scaled_font (cr);
ft_face = cairo_ft_scaled_font_lock_face (cr_font);
hb_font = hb_ft_font_create (ft_face, NULL);
cairo_surface_t *target = cairo_get_target (cr);
cairo_surface_get_device_scale (target, &x_scale, &y_scale);
/* We abuse pango itemazation to split text into script and direction
* runs, since we use our fonts directly no through pango, we don't
* bother changing the default font, but we disable font fallback as
* pango will split runs at font change */
context = pango_cairo_create_context (cr);
attr_list = pango_attr_list_new ();
fallback_attr = pango_attr_fallback_new (FALSE);
pango_attr_list_insert (attr_list, fallback_attr);
items = pango_itemize_with_base_dir (context, base_dir,
text, 0, strlen (text),
attr_list, NULL);
g_object_unref (context);
pango_attr_list_unref (attr_list);
/* reorder the items in the visual order */
visual_items = pango_reorder_items (items);
while (visual_items) {
PangoItem *item;
PangoAnalysis analysis;
hb_buffer_t *hb_buffer;
hb_glyph_info_t *hb_glyphs;
hb_glyph_position_t *hb_positions;
gint n;
item = visual_items->data;
analysis = item->analysis;
hb_buffer = hb_buffer_create ();
hb_buffer_add_utf8 (hb_buffer, text, -1, item->offset, item->length);
hb_buffer_set_script (hb_buffer, hb_glib_script_to_script (analysis.script));
hb_buffer_set_language (hb_buffer, hb_language_from_string (pango_language_to_string (analysis.language), -1));
hb_buffer_set_direction (hb_buffer, analysis.level % 2 ? HB_DIRECTION_RTL : HB_DIRECTION_LTR);
hb_shape (hb_font, hb_buffer, NULL, 0);
n = hb_buffer_get_length (hb_buffer);
hb_glyphs = hb_buffer_get_glyph_infos (hb_buffer, NULL);
hb_positions = hb_buffer_get_glyph_positions (hb_buffer, NULL);
*glyphs = g_renew (cairo_glyph_t, *glyphs, *num_glyphs + n);
for (i = 0; i < n; i++) {
(*glyphs)[*num_glyphs + i].index = hb_glyphs[i].codepoint;
(*glyphs)[*num_glyphs + i].x = x + (hb_positions[i].x_offset / (64. * x_scale));
(*glyphs)[*num_glyphs + i].y = y - (hb_positions[i].y_offset / (64. * y_scale));
x += (hb_positions[i].x_advance / (64. * x_scale));
y -= (hb_positions[i].y_advance / (64. * y_scale));
}
*num_glyphs += n;
hb_buffer_destroy (hb_buffer);
visual_items = visual_items->next;
}
g_list_free_full (visual_items, (GDestroyNotify) pango_item_free);
g_list_free_full (items, (GDestroyNotify) pango_item_free);
hb_font_destroy (hb_font);
cairo_ft_scaled_font_unlock_face (cr_font);
}
FT_Error
af_get_char_index( AF_StyleMetrics metrics,
FT_ULong charcode,
FT_ULong *codepoint,
FT_Long *y_offset )
{
AF_StyleClass style_class;
const hb_feature_t* feature;
FT_ULong in_idx, out_idx;
if ( !metrics )
return FT_THROW( Invalid_Argument );
in_idx = FT_Get_Char_Index( metrics->globals->face, charcode );
style_class = metrics->style_class;
feature = features[style_class->coverage];
if ( feature )
{
FT_Int upem = (FT_Int)metrics->globals->face->units_per_EM;
hb_font_t* font = metrics->globals->hb_font;
hb_buffer_t* buf = hb_buffer_create();
uint32_t c = (uint32_t)charcode;
hb_glyph_info_t* ginfo;
hb_glyph_position_t* gpos;
unsigned int gcount;
/* we shape at a size of units per EM; this means font units */
hb_font_set_scale( font, upem, upem );
/* XXX: is this sufficient for a single character of any script? */
hb_buffer_set_direction( buf, HB_DIRECTION_LTR );
hb_buffer_set_script( buf, scripts[style_class->script] );
/* we add one character to `buf' ... */
hb_buffer_add_utf32( buf, &c, 1, 0, 1 );
/* ... and apply one feature */
hb_shape( font, buf, feature, 1 );
ginfo = hb_buffer_get_glyph_infos( buf, &gcount );
gpos = hb_buffer_get_glyph_positions( buf, &gcount );
out_idx = ginfo[0].codepoint;
/* getting the same index indicates no substitution, */
/* which means that the glyph isn't available in the feature */
if ( in_idx == out_idx )
{
*codepoint = 0;
*y_offset = 0;
}
else
{
*codepoint = out_idx;
*y_offset = gpos[0].y_offset;
}
hb_buffer_destroy( buf );
#ifdef FT_DEBUG_LEVEL_TRACE
if ( gcount > 1 )
FT_TRACE1(( "af_get_char_index:"
" input character mapped to multiple glyphs\n" ));
#endif
}
else
{
*codepoint = in_idx;
*y_offset = 0;
}
return FT_Err_Ok;
}
void HarfBuzzFace::setScriptForVerticalGlyphSubstitution(hb_buffer_t* buffer)
{
if (m_scriptForVerticalText == HB_SCRIPT_INVALID)
m_scriptForVerticalText = findScriptForVerticalGlyphSubstitution(m_face);
hb_buffer_set_script(buffer, m_scriptForVerticalText);
}
bool sui_layout_init(sui_layout *layout, sui_font *font, const sui_layout_format *fmt,
const char *text, size_t length, char **error)
{
static const int text_dir_table[] = {
HB_DIRECTION_LTR,
HB_DIRECTION_RTL,
HB_DIRECTION_TTB,
HB_DIRECTION_BTT
};
memset(layout, 0, sizeof(sui_layout));
layout->fmt = *fmt;
layout->font = font;
FT_Error fterr;
if ((fterr = FT_Set_Pixel_Sizes(font->face, 0, fmt->size))) {
*error = sui_aprintf("FT_Set_Char_Size: %i\n", fterr);
return false;
}
layout->buffer = hb_buffer_create();
hb_buffer_set_unicode_funcs(layout->buffer, hb_icu_get_unicode_funcs());
hb_buffer_set_direction(layout->buffer, text_dir_table[fmt->dir]);
hb_script_t script = hb_script_from_string(fmt->script, -1);
if (script == HB_SCRIPT_INVALID || script == HB_SCRIPT_UNKNOWN) {
*error = sui_aprintf("Invalid script: %s\n", fmt->script);
return false;
}
hb_buffer_set_script(layout->buffer, script);
hb_language_t lang = hb_language_from_string(fmt->lang, -1);
if (lang == HB_LANGUAGE_INVALID) {
*error = sui_aprintf("Invalid language: %s\n", fmt->lang);
return false;
}
hb_buffer_set_language(layout->buffer, lang);
hb_buffer_add_utf8(layout->buffer, text, length, 0, length);
hb_shape(font->hb_font, layout->buffer, NULL, 0);
layout->infos = hb_buffer_get_glyph_infos(layout->buffer, &layout->count);
layout->positions = hb_buffer_get_glyph_positions(layout->buffer, &layout->count);
int pen_x = 0, pen_y = 0;
int lx = 0, ly = 0, hx = 0, hy = 0;
for (unsigned i = 0; i < layout->count; i++) {
uint32_t codepoint = layout->infos[i].codepoint;
if ((fterr = FT_Load_Glyph(font->face, codepoint, FT_LOAD_DEFAULT))) {
*error = sui_aprintf("FT_Load_Glyph: %i\n", fterr);
return false;
}
if (pen_x < lx) {
lx = pen_x;
}
if (pen_y < ly) {
ly = pen_y;
}
int w = font->face->glyph->metrics.width, h = font->face->glyph->metrics.height;
if (pen_x + w > hx) {
hx = pen_x + w;
}
if (pen_y + h > hy) {
hy = pen_y + h;
}
pen_x += layout->positions[i].x_advance;
pen_y += layout->positions[i].y_advance;
}
layout->origin = sui_mkpoint(-lx, -ly);
layout->size = sui_mkpoint(hx-lx, hy-ly);
return true;
}
int shape (lua_State *L) {
size_t font_l;
const char * text = luaL_checkstring(L, 1);
const char * font_s = luaL_checklstring(L, 2, &font_l);
unsigned int font_index = luaL_checknumber(L, 3);
const char * script = luaL_checkstring(L, 4);
const char * direction_s = luaL_checkstring(L, 5);
const char * lang = luaL_checkstring(L, 6);
double point_size = luaL_checknumber(L, 7);
const char * featurestring = luaL_checkstring(L, 8);
hb_segment_properties_t segment_props;
hb_shape_plan_t *shape_plan;
hb_direction_t direction;
hb_feature_t* features;
int nFeatures = 0;
unsigned int glyph_count = 0;
hb_font_t *hbFont;
hb_buffer_t *buf;
hb_glyph_info_t *glyph_info;
hb_glyph_position_t *glyph_pos;
unsigned int j;
features = scan_feature_string(featurestring, &nFeatures);
if (!strcasecmp(direction_s,"RTL"))
direction = HB_DIRECTION_RTL;
else if (!strcasecmp(direction_s,"TTB"))
direction = HB_DIRECTION_TTB;
else
direction = HB_DIRECTION_LTR;
hb_blob_t* blob = hb_blob_create (font_s, font_l, HB_MEMORY_MODE_WRITABLE, (void*)font_s, NULL);
hb_face_t* hbFace = hb_face_create (blob, font_index);
hbFont = hb_font_create (hbFace);
unsigned int upem = hb_face_get_upem(hbFace);
hb_font_set_scale(hbFont, upem, upem);
/* Harfbuzz's support for OT fonts is great, but
there's currently no support for CFF fonts, so
downgrade to Freetype for those. */
if (strncmp(font_s, "OTTO", 4) == 0) {
hb_ft_font_set_funcs(hbFont);
} else {
hb_ot_font_set_funcs(hbFont);
}
buf = hb_buffer_create();
hb_buffer_add_utf8(buf, text, strlen(text), 0, strlen(text));
hb_buffer_set_script(buf, hb_tag_from_string(script, strlen(script)));
hb_buffer_set_direction(buf, direction);
hb_buffer_set_language(buf, hb_language_from_string(lang,strlen(lang)));
hb_buffer_guess_segment_properties(buf);
hb_buffer_get_segment_properties(buf, &segment_props);
shape_plan = hb_shape_plan_create_cached(hbFace, &segment_props, features, nFeatures, NULL);
int res = hb_shape_plan_execute(shape_plan, hbFont, buf, features, nFeatures);
if (direction == HB_DIRECTION_RTL) {
hb_buffer_reverse(buf); /* URGH */
}
glyph_info = hb_buffer_get_glyph_infos(buf, &glyph_count);
glyph_pos = hb_buffer_get_glyph_positions(buf, &glyph_count);
lua_checkstack(L, glyph_count);
for (j = 0; j < glyph_count; ++j) {
char namebuf[255];
hb_glyph_extents_t extents = {0,0,0,0};
hb_font_get_glyph_extents(hbFont, glyph_info[j].codepoint, &extents);
lua_newtable(L);
lua_pushstring(L, "name");
hb_font_get_glyph_name( hbFont, glyph_info[j].codepoint, namebuf, 255 );
lua_pushstring(L, namebuf);
lua_settable(L, -3);
/* We don't apply x-offset and y-offsets for TTB, which
is arguably a bug. We should. The reason we don't is that
Harfbuzz assumes that you want to shift the character from a
top-center baseline to a bottom-left baseline, and gives you
offsets which do that. We don't want to do that so we ignore the
offsets. I'm told there is a way of configuring HB's idea of the
baseline, and we should use that and take out this condition. */
if (direction != HB_DIRECTION_TTB) {
if (glyph_pos[j].x_offset) {
lua_pushstring(L, "x_offset");
lua_pushnumber(L, glyph_pos[j].x_offset * point_size / upem);
lua_settable(L, -3);
}
if (glyph_pos[j].y_offset) {
lua_pushstring(L, "y_offset");
lua_pushnumber(L, glyph_pos[j].y_offset * point_size / upem);
lua_settable(L, -3);
}
}
lua_pushstring(L, "codepoint");
lua_pushinteger(L, glyph_info[j].codepoint);
lua_settable(L, -3);
lua_pushstring(L, "index");
lua_pushinteger(L, glyph_info[j].cluster);
lua_settable(L, -3);
double height = extents.y_bearing * point_size / upem;
double tHeight = extents.height * point_size / upem;
double width = glyph_pos[j].x_advance * point_size / upem;
/* The PDF model expects us to make positioning adjustments
after a glyph is painted. For this we need to know the natural
glyph advance. libtexpdf will use this to compute the adjustment. */
double glyphAdvance = hb_font_get_glyph_h_advance(hbFont, glyph_info[j].codepoint) * point_size / upem;
if (direction == HB_DIRECTION_TTB) {
height = -glyph_pos[j].y_advance * point_size / upem;
tHeight = -height; /* Set depth to 0 - depth has no meaning for TTB */
width = glyphAdvance;
glyphAdvance = height;
}
lua_pushstring(L, "glyphAdvance");
lua_pushnumber(L, glyphAdvance);
lua_settable(L, -3);
lua_pushstring(L, "width");
lua_pushnumber(L, width);
lua_settable(L, -3);
lua_pushstring(L, "height");
lua_pushnumber(L, height);
lua_settable(L, -3);
lua_pushstring(L, "depth");
lua_pushnumber(L, -tHeight - height);
lua_settable(L, -3);
}
/* Cleanup */
hb_buffer_destroy(buf);
hb_font_destroy(hbFont);
hb_shape_plan_destroy(shape_plan);
free(features);
return glyph_count;
}
int main () {
int ptSize = 50*64;
int device_hdpi = 72;
int device_vdpi = 72;
/* Init freetype */
FT_Library ft_library;
assert(!FT_Init_FreeType(&ft_library));
/* Load our fonts */
FT_Face ft_face[NUM_EXAMPLES];
assert(!FT_New_Face(ft_library, "fonts/DejaVuSerif.ttf", 0, &ft_face[ENGLISH]));
assert(!FT_Set_Char_Size(ft_face[ENGLISH], 0, ptSize, device_hdpi, device_vdpi ));
ftfdump(ft_face[ENGLISH]); // wonderful world of encodings ...
force_ucs2_charmap(ft_face[ENGLISH]); // which we ignore.
assert(!FT_New_Face(ft_library, "fonts/amiri-0.104/amiri-regular.ttf", 0, &ft_face[ARABIC]));
assert(!FT_Set_Char_Size(ft_face[ARABIC], 0, ptSize, device_hdpi, device_vdpi ));
ftfdump(ft_face[ARABIC]);
force_ucs2_charmap(ft_face[ARABIC]);
assert(!FT_New_Face(ft_library, "fonts/fireflysung-1.3.0/fireflysung.ttf", 0, &ft_face[CHINESE]));
assert(!FT_Set_Char_Size(ft_face[CHINESE], 0, ptSize, device_hdpi, device_vdpi ));
ftfdump(ft_face[CHINESE]);
force_ucs2_charmap(ft_face[CHINESE]);
/* Get our harfbuzz font structs */
hb_font_t *hb_ft_font[NUM_EXAMPLES];
hb_ft_font[ENGLISH] = hb_ft_font_create(ft_face[ENGLISH], NULL);
hb_ft_font[ARABIC] = hb_ft_font_create(ft_face[ARABIC] , NULL);
hb_ft_font[CHINESE] = hb_ft_font_create(ft_face[CHINESE], NULL);
/** Setup our SDL window **/
int width = 800;
int height = 600;
int videoFlags = SDL_SWSURFACE | SDL_RESIZABLE | SDL_DOUBLEBUF;
int bpp = 32;
/* Initialize our SDL window */
if(SDL_Init(SDL_INIT_VIDEO) < 0) {
fprintf(stderr, "Failed to initialize SDL");
return -1;
}
SDL_WM_SetCaption("\"Simple\" SDL+FreeType+HarfBuzz Example", "\"Simple\" SDL+FreeType+HarfBuzz Example");
SDL_Surface *screen;
screen = SDL_SetVideoMode(width, height, bpp, videoFlags);
/* Enable key repeat, just makes it so we don't have to worry about fancy
* scanboard keyboard input and such */
SDL_EnableKeyRepeat(300, 130);
SDL_EnableUNICODE(1);
/* Create an SDL image surface we can draw to */
SDL_Surface *sdl_surface = SDL_CreateRGBSurface (0, width, height, 32, 0,0,0,0);
/* Create a buffer for harfbuzz to use */
hb_buffer_t *buf = hb_buffer_create();
/* Our main event/draw loop */
int done = 0;
int resized = 1;
while (!done) {
/* Clear our surface */
SDL_FillRect( sdl_surface, NULL, 0 );
SDL_LockSurface(sdl_surface);
for (int i=0; i < NUM_EXAMPLES; ++i) {
hb_buffer_set_direction(buf, text_directions[i]); /* or LTR */
hb_buffer_set_script(buf, scripts[i]); /* see hb-unicode.h */
hb_buffer_set_language(buf, hb_language_from_string(languages[i], strlen(languages[i])));
/* Layout the text */
hb_buffer_add_utf8(buf, texts[i], strlen(texts[i]), 0, strlen(texts[i]));
hb_shape(hb_ft_font[i], buf, NULL, 0);
unsigned int glyph_count;
hb_glyph_info_t *glyph_info = hb_buffer_get_glyph_infos(buf, &glyph_count);
hb_glyph_position_t *glyph_pos = hb_buffer_get_glyph_positions(buf, &glyph_count);
/* set up rendering via spanners */
spanner_baton_t stuffbaton;
FT_Raster_Params ftr_params;
ftr_params.target = 0;
ftr_params.flags = FT_RASTER_FLAG_DIRECT | FT_RASTER_FLAG_AA;
ftr_params.user = &stuffbaton;
ftr_params.black_spans = 0;
ftr_params.bit_set = 0;
ftr_params.bit_test = 0;
/* Calculate string bounding box in pixels */
ftr_params.gray_spans = spanner_sizer;
/* See http://www.freetype.org/freetype2/docs/glyphs/glyphs-3.html */
int max_x = INT_MIN; // largest coordinate a pixel has been set at, or the pen was advanced to.
int min_x = INT_MAX; // smallest coordinate a pixel has been set at, or the pen was advanced to.
int max_y = INT_MIN; // this is max topside bearing along the string.
int min_y = INT_MAX; // this is max value of (height - topbearing) along the string.
/* Naturally, the above comments swap their meaning between horizontal and vertical scripts,
since the pen changes the axis it is advanced along.
However, their differences still make up the bounding box for the string.
Also note that all this is in FT coordinate system where y axis points upwards.
*/
int sizer_x = 0;
int sizer_y = 0; /* in FT coordinate system. */
FT_Error fterr;
for (unsigned j = 0; j < glyph_count; ++j) {
if ((fterr = FT_Load_Glyph(ft_face[i], glyph_info[j].codepoint, 0))) {
printf("load %08x failed fterr=%d.\n", glyph_info[j].codepoint, fterr);
} else {
if (ft_face[i]->glyph->format != FT_GLYPH_FORMAT_OUTLINE) {
printf("glyph->format = %4s\n", (char *)&ft_face[i]->glyph->format);
} else {
int gx = sizer_x + (glyph_pos[j].x_offset/64);
int gy = sizer_y + (glyph_pos[j].y_offset/64); // note how the sign differs from the rendering pass
stuffbaton.min_span_x = INT_MAX;
stuffbaton.max_span_x = INT_MIN;
stuffbaton.min_y = INT_MAX;
stuffbaton.max_y = INT_MIN;
if ((fterr = FT_Outline_Render(ft_library, &ft_face[i]->glyph->outline, &ftr_params)))
printf("FT_Outline_Render() failed err=%d\n", fterr);
if (stuffbaton.min_span_x != INT_MAX) {
/* Update values if the spanner was actually called. */
if (min_x > stuffbaton.min_span_x + gx)
min_x = stuffbaton.min_span_x + gx;
if (max_x < stuffbaton.max_span_x + gx)
max_x = stuffbaton.max_span_x + gx;
if (min_y > stuffbaton.min_y + gy)
min_y = stuffbaton.min_y + gy;
if (max_y < stuffbaton.max_y + gy)
max_y = stuffbaton.max_y + gy;
} else {
/* The spanner wasn't called at all - an empty glyph, like space. */
if (min_x > gx) min_x = gx;
if (max_x < gx) max_x = gx;
if (min_y > gy) min_y = gy;
if (max_y < gy) max_y = gy;
}
}
}
sizer_x += glyph_pos[j].x_advance/64;
sizer_y += glyph_pos[j].y_advance/64; // note how the sign differs from the rendering pass
}
/* Still have to take into account last glyph's advance. Or not? */
if (min_x > sizer_x) min_x = sizer_x;
if (max_x < sizer_x) max_x = sizer_x;
if (min_y > sizer_y) min_y = sizer_y;
if (max_y < sizer_y) max_y = sizer_y;
/* The bounding box */
int bbox_w = max_x - min_x;
int bbox_h = max_y - min_y;
/* Two offsets below position the bounding box with respect to the 'origin',
which is sort of origin of string's first glyph.
baseline_offset - offset perpendecular to the baseline to the topmost (horizontal),
or leftmost (vertical) pixel drawn.
baseline_shift - offset along the baseline, from the first drawn glyph's origin
to the leftmost (horizontal), or topmost (vertical) pixel drawn.
Thus those offsets allow positioning the bounding box to fit the rendered string,
as they are in fact offsets from the point given to the renderer, to the top left
corner of the bounding box.
NB: baseline is defined as y==0 for horizontal and x==0 for vertical scripts.
(0,0) here is where the first glyph's origin ended up after shaping, not taking
into account glyph_pos[0].xy_offset (yeah, my head hurts too).
*/
int baseline_offset;
int baseline_shift;
if (HB_DIRECTION_IS_HORIZONTAL(hb_buffer_get_direction(buf))) {
baseline_offset = max_y;
baseline_shift = min_x;
}
if (HB_DIRECTION_IS_VERTICAL(hb_buffer_get_direction(buf))) {
baseline_offset = min_x;
baseline_shift = max_y;
}
if (resized)
printf("ex %d string min_x=%d max_x=%d min_y=%d max_y=%d bbox %dx%d boffs %d,%d\n",
i, min_x, max_x, min_y, max_y, bbox_w, bbox_h, baseline_offset, baseline_shift);
/* The pen/baseline start coordinates in window coordinate system
- with those text placement in the window is controlled.
- note that for RTL scripts pen still goes LTR */
int x = 0, y = 50 + i * 75;
if (i == ENGLISH) { x = 20; } /* left justify */
if (i == ARABIC) { x = width - bbox_w - 20; } /* right justify */
if (i == CHINESE) { x = width/2 - bbox_w/2; } /* center, and for TTB script h_advance is half-width. */
/* Draw baseline and the bounding box */
/* The below is complicated since we simultaneously
convert to the window coordinate system. */
int left, right, top, bottom;
if (HB_DIRECTION_IS_HORIZONTAL(hb_buffer_get_direction(buf))) {
/* bounding box in window coordinates without offsets */
left = x;
right = x + bbox_w;
top = y - bbox_h;
bottom = y;
/* apply offsets */
left += baseline_shift;
right += baseline_shift;
top -= baseline_offset - bbox_h;
bottom -= baseline_offset - bbox_h;
/* draw the baseline */
hline(sdl_surface, x, x + bbox_w, y, 0x0000ff00);
}
if (HB_DIRECTION_IS_VERTICAL(hb_buffer_get_direction(buf))) {
left = x;
right = x + bbox_w;
top = y;
bottom = y + bbox_h;
left += baseline_offset;
right += baseline_offset;
top -= baseline_shift;
bottom -= baseline_shift;
vline(sdl_surface, y, y + bbox_h, x, 0x0000ff00);
}
if (resized)
printf("ex %d origin %d,%d bbox l=%d r=%d t=%d b=%d\n",
i, x, y, left, right, top, bottom);
/* +1/-1 are for the bbox borders be the next pixel outside the bbox itself */
hline(sdl_surface, left - 1, right + 1, top - 1, 0x00ff0000);
hline(sdl_surface, left - 1, right + 1, bottom + 1, 0x00ff0000);
vline(sdl_surface, top - 1, bottom + 1, left - 1, 0x00ff0000);
vline(sdl_surface, top - 1, bottom + 1, right + 1, 0x00ff0000);
/* set rendering spanner */
ftr_params.gray_spans = spanner;
/* initialize rendering part of the baton */
stuffbaton.pixels = NULL;
stuffbaton.first_pixel = sdl_surface->pixels;
stuffbaton.last_pixel = (uint32_t *) (((uint8_t *) sdl_surface->pixels) + sdl_surface->pitch*sdl_surface->h);
stuffbaton.pitch = sdl_surface->pitch;
stuffbaton.rshift = sdl_surface->format->Rshift;
stuffbaton.gshift = sdl_surface->format->Gshift;
stuffbaton.bshift = sdl_surface->format->Bshift;
/* render */
for (unsigned j=0; j < glyph_count; ++j) {
if ((fterr = FT_Load_Glyph(ft_face[i], glyph_info[j].codepoint, 0))) {
printf("load %08x failed fterr=%d.\n", glyph_info[j].codepoint, fterr);
} else {
if (ft_face[i]->glyph->format != FT_GLYPH_FORMAT_OUTLINE) {
printf("glyph->format = %4s\n", (char *)&ft_face[i]->glyph->format);
} else {
int gx = x + (glyph_pos[j].x_offset/64);
int gy = y - (glyph_pos[j].y_offset/64);
stuffbaton.pixels = (uint32_t *)(((uint8_t *) sdl_surface->pixels) + gy * sdl_surface->pitch) + gx;
if ((fterr = FT_Outline_Render(ft_library, &ft_face[i]->glyph->outline, &ftr_params)))
printf("FT_Outline_Render() failed err=%d\n", fterr);
}
}
x += glyph_pos[j].x_advance/64;
y -= glyph_pos[j].y_advance/64;
}
/* clean up the buffer, but don't kill it just yet */
hb_buffer_clear_contents(buf);
}
SDL_UnlockSurface(sdl_surface);
/* Blit our new image to our visible screen */
SDL_BlitSurface(sdl_surface, NULL, screen, NULL);
SDL_Flip(screen);
/* Handle SDL events */
SDL_Event event;
resized = resized ? !resized : resized;
while(SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_KEYDOWN:
if (event.key.keysym.sym == SDLK_ESCAPE) {
done = 1;
}
break;
case SDL_QUIT:
done = 1;
break;
case SDL_VIDEORESIZE:
resized = 1;
width = event.resize.w;
height = event.resize.h;
screen = SDL_SetVideoMode(event.resize.w, event.resize.h, bpp, videoFlags);
if (!screen) {
fprintf(stderr, "Could not get a surface after resize: %s\n", SDL_GetError( ));
exit(-1);
}
/* Recreate an SDL image surface we can draw to. */
SDL_FreeSurface(sdl_surface);
sdl_surface = SDL_CreateRGBSurface(0, width, height, 32, 0, 0 ,0, 0);
break;
}
}
SDL_Delay(150);
}
/* Cleanup */
hb_buffer_destroy(buf);
for (int i=0; i < NUM_EXAMPLES; ++i)
hb_font_destroy(hb_ft_font[i]);
FT_Done_FreeType(ft_library);
SDL_FreeSurface(sdl_surface);
SDL_Quit();
return 0;
}
void drawIndicText(JNIEnv *env, jobject thiz, jstring unicodeText, jint xStart,
jint yBaseLine, jint charHeight, jobject lock, jstring fontPath, jint language) {
FT_Library ft_library;
FT_Face ft_face;
hb_font_t *font;
hb_buffer_t *buffer;
int glyph_count;
hb_glyph_info_t *glyph_info;
hb_glyph_position_t *glyph_pos;
hb_bool_t fail;
FT_UInt glyph_index;
FT_GlyphSlot slot;
FT_Error error;
jboolean iscopy;
const jchar *text;
int num_chars, i;
int pen_x;
int glyphPosX, glyphPosY;
const char *fontFilePath = (*env)->GetStringUTFChars(env, fontPath, NULL);
text = (*env)->GetStringChars(env, unicodeText, &iscopy);
num_chars = (*env)->GetStringLength(env, unicodeText);
/* initialize library */
error = FT_Init_FreeType(&ft_library);
if (error) {
__android_log_print(6, "drawIndicText",
"Error initializing FreeType library\n");
return;
}
// __android_log_print(2, "drawIndicText",
// "Successfully initialized FreeType library\n");
error = FT_New_Face(ft_library, fontFilePath, 0, &ft_face); /* create face object */
if (error == FT_Err_Unknown_File_Format) {
__android_log_print(6, "drawIndicText",
"The font file could be opened and read, but it appears that its font format is unsupported %s ",
fontFilePath);
return;
} else if (error) {
__android_log_print(6, "drawIndicText",
"The font file could not be opened or read, or it might be broken");
return;
}
// __android_log_print(2, "drawIndicText",
// "Successfully created font-face object\n");
font = hb_ft_font_create(ft_face, NULL);
error = FT_Set_Pixel_Sizes(ft_face, 0, charHeight); /* set character size */
slot = ft_face->glyph;
pen_x = xStart;
/* Create a buffer for harfbuzz to use */
buffer = hb_buffer_create();
hb_buffer_set_script(buffer, scripts[language]);
/* Layout the text */
hb_buffer_add_utf16(buffer, text, num_chars, 0, num_chars);
// __android_log_print(2, "drawIndicText", "Before HarfBuzz shape()\n");
hb_shape(font, buffer, NULL, 0);
// __android_log_print(2, "drawIndicText", "After HarfBuzz shape()\n");
glyph_count = hb_buffer_get_length(buffer);
glyph_info = hb_buffer_get_glyph_infos(buffer, 0);
glyph_pos = hb_buffer_get_glyph_positions(buffer, 0);
for (i = 0; i < glyph_count; i++) {
glyph_index = glyph_info[i].codepoint;
// __android_log_print(2, "drawIndicText", "Glyph%d = %x", i, glyph_index);
error = FT_Load_Glyph(ft_face, glyph_index, FT_LOAD_DEFAULT);
if (error) {
/* ignore errors */
continue;
}
/* convert to an anti-aliased bitmap */
error = FT_Render_Glyph(ft_face->glyph, FT_RENDER_MODE_NORMAL);
if (error) {
continue;
}
/* now, draw to our target surface (convert position) */
draw_bitmap(&slot->bitmap, pen_x + slot->bitmap_left,
yBaseLine - slot->bitmap_top, env, thiz, lock);
/* increment pen position */
pen_x += slot->advance.x >> 6;
}
hb_buffer_destroy(buffer);
(*env)->ReleaseStringChars(env, unicodeText, text);
(*env)->ReleaseStringUTFChars(env, fontPath, fontFilePath);
hb_font_destroy(font);
FT_Done_Face(ft_face);
FT_Done_FreeType(ft_library);
return;
}
// ------------------------------------------------------------------- main ---
int main( int argc, char **argv )
{
size_t i, j;
int ptSize = 50*64;
int device_hdpi = 72;
int device_vdpi = 72;
glutInit( &argc, argv );
glutInitWindowSize( 512, 512 );
glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH );
glutCreateWindow( argv[0] );
glutReshapeFunc( reshape );
glutDisplayFunc( display );
glutKeyboardFunc( keyboard );
#ifndef __APPLE__
glewExperimental = GL_TRUE;
GLenum err = glewInit();
if (GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
fprintf( stderr, "Error: %s\n", glewGetErrorString(err) );
exit( EXIT_FAILURE );
}
fprintf( stderr, "Using GLEW %s\n", glewGetString(GLEW_VERSION) );
#endif
texture_atlas_t * atlas = texture_atlas_new( 512, 512, 3 );
/* Init freetype */
FT_Library ft_library;
assert(!FT_Init_FreeType(&ft_library));
/* Load our fonts */
FT_Face ft_face[NUM_EXAMPLES];
assert(!FT_New_Face( ft_library, fonts[ENGLISH], 0, &ft_face[ENGLISH]) );
assert(!FT_Set_Char_Size( ft_face[ENGLISH], 0, ptSize, device_hdpi, device_vdpi ) );
// ftfdump( ft_face[ENGLISH] ); // wonderful world of encodings ...
force_ucs2_charmap( ft_face[ENGLISH] ); // which we ignore.
assert( !FT_New_Face(ft_library, fonts[ARABIC], 0, &ft_face[ARABIC]) );
assert( !FT_Set_Char_Size(ft_face[ARABIC], 0, ptSize, device_hdpi, device_vdpi ) );
// ftfdump( ft_face[ARABIC] );
force_ucs2_charmap( ft_face[ARABIC] );
assert(!FT_New_Face( ft_library, fonts[CHINESE], 0, &ft_face[CHINESE]) );
assert(!FT_Set_Char_Size( ft_face[CHINESE], 0, ptSize, device_hdpi, device_vdpi ) );
// ftfdump( ft_face[CHINESE] );
force_ucs2_charmap( ft_face[CHINESE] );
/* Get our harfbuzz font structs */
hb_font_t *hb_ft_font[NUM_EXAMPLES];
hb_ft_font[ENGLISH] = hb_ft_font_create( ft_face[ENGLISH], NULL );
hb_ft_font[ARABIC] = hb_ft_font_create( ft_face[ARABIC] , NULL );
hb_ft_font[CHINESE] = hb_ft_font_create( ft_face[CHINESE], NULL );
/* Create a buffer for harfbuzz to use */
hb_buffer_t *buf = hb_buffer_create();
for (i=0; i < NUM_EXAMPLES; ++i)
{
hb_buffer_set_direction( buf, text_directions[i] ); /* or LTR */
hb_buffer_set_script( buf, scripts[i] ); /* see hb-unicode.h */
hb_buffer_set_language( buf,
hb_language_from_string(languages[i], strlen(languages[i])) );
/* Layout the text */
hb_buffer_add_utf8( buf, texts[i], strlen(texts[i]), 0, strlen(texts[i]) );
hb_shape( hb_ft_font[i], buf, NULL, 0 );
unsigned int glyph_count;
hb_glyph_info_t *glyph_info = hb_buffer_get_glyph_infos(buf, &glyph_count);
hb_glyph_position_t *glyph_pos = hb_buffer_get_glyph_positions(buf, &glyph_count);
FT_GlyphSlot slot;
FT_Bitmap ft_bitmap;
float size = 24;
size_t hres = 64;
FT_Error error;
FT_Int32 flags = 0;
flags |= FT_LOAD_RENDER;
flags |= FT_LOAD_TARGET_LCD;
FT_Library_SetLcdFilter( ft_library, FT_LCD_FILTER_LIGHT );
FT_Matrix matrix = { (int)((1.0/hres) * 0x10000L),
(int)((0.0) * 0x10000L),
(int)((0.0) * 0x10000L),
(int)((1.0) * 0x10000L) };
/* Set char size */
error = FT_Set_Char_Size( ft_face[i], (int)(ptSize), 0, 72*hres, 72 );
if( error )
{
//fprintf( stderr, "FT_Error (line %d, code 0x%02x) : %s\n",
// __LINE__, FT_Errors[error].code, FT_Errors[error].message );
FT_Done_Face( ft_face[i] );
break;
}
/* Set transform matrix */
FT_Set_Transform( ft_face[i], &matrix, NULL );
for (j = 0; j < glyph_count; ++j)
{
/* Load glyph */
error = FT_Load_Glyph( ft_face[i], glyph_info[j].codepoint, flags );
if( error )
{
//fprintf( stderr, "FT_Error (line %d, code 0x%02x) : %s\n",
// __LINE__, FT_Errors[error].code, FT_Errors[error].message );
FT_Done_Face( ft_face[i] );
break;
}
slot = ft_face[i]->glyph;
ft_bitmap = slot->bitmap;
int ft_bitmap_width = slot->bitmap.width;
int ft_bitmap_rows = slot->bitmap.rows;
int ft_bitmap_pitch = slot->bitmap.pitch;
int ft_glyph_top = slot->bitmap_top;
int ft_glyph_left = slot->bitmap_left;
int w = ft_bitmap_width/3; // 3 because of LCD/RGB encoding
int h = ft_bitmap_rows;
ivec4 region = texture_atlas_get_region( atlas, w+1, h+1 );
if ( region.x < 0 )
{
fprintf( stderr, "Texture atlas is full (line %d)\n", __LINE__ );
continue;
}
int x = region.x, y = region.y;
texture_atlas_set_region( atlas, region.x, region.y,
w, h, ft_bitmap.buffer, ft_bitmap.pitch );
printf("%d: %dx%d %f %f\n",
glyph_info[j].codepoint,
ft_bitmap_width,
ft_bitmap_rows,
glyph_pos[j].x_advance/64.,
glyph_pos[j].y_advance/64.);
}
/* clean up the buffer, but don't kill it just yet */
hb_buffer_reset(buf);
}
/* Cleanup */
hb_buffer_destroy( buf );
for( i=0; i < NUM_EXAMPLES; ++i )
hb_font_destroy( hb_ft_font[i] );
FT_Done_FreeType( ft_library );
glClearColor(1,1,1,1);
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glEnable( GL_TEXTURE_2D );
glBindTexture( GL_TEXTURE_2D, atlas->id );
texture_atlas_upload( atlas );
typedef struct { float x,y,z, u,v, r,g,b,a, shift, gamma; } vertex_t;
vertex_t vertices[4] = {
{ 0, 0,0, 0,1, 0,0,0,1, 0, 1},
{ 0,512,0, 0,0, 0,0,0,1, 0, 1},
{512,512,0, 1,0, 0,0,0,1, 0, 1},
{512, 0,0, 1,1, 0,0,0,1, 0, 1} };
GLuint indices[6] = { 0, 1, 2, 0,2,3 };
buffer = vertex_buffer_new( "vertex:3f,"
"tex_coord:2f,"
"color:4f,"
"ashift:1f,"
"agamma:1f" );
vertex_buffer_push_back( buffer, vertices, 4, indices, 6 );
shader = shader_load("shaders/text.vert", "shaders/text.frag");
mat4_set_identity( &projection );
mat4_set_identity( &model );
mat4_set_identity( &view );
glutMainLoop( );
return 0;
}
bool HarfBuzzShaper::setupHarfBuzzRun()
{
m_startIndexOfCurrentRun += m_numCharactersOfCurrentRun;
// Iterate through the text to take the largest range that stays within
// a single font.
int endOfRunIndex = m_normalizedBufferLength - m_startIndexOfCurrentRun;
SurrogatePairAwareTextIterator iterator(m_normalizedBuffer.get() + m_startIndexOfCurrentRun, 0, endOfRunIndex, endOfRunIndex);
UChar32 character;
unsigned clusterLength = 0;
if (!iterator.consume(character, clusterLength))
return false;
m_currentFontData = m_font->glyphDataForCharacter(character, false).fontData;
UErrorCode errorCode = U_ZERO_ERROR;
UScriptCode currentScript = uscript_getScript(character, &errorCode);
if (U_FAILURE(errorCode))
return false;
if (currentScript == USCRIPT_INHERITED)
currentScript = USCRIPT_COMMON;
for (iterator.advance(clusterLength); iterator.consume(character, clusterLength); iterator.advance(clusterLength)) {
const SimpleFontData* nextFontData = m_font->glyphDataForCharacter(character, false).fontData;
if (nextFontData != m_currentFontData)
break;
UScriptCode nextScript = uscript_getScript(character, &errorCode);
if (U_FAILURE(errorCode))
return false;
if (currentScript == nextScript || nextScript == USCRIPT_INHERITED || nextScript == USCRIPT_COMMON)
continue;
if (currentScript == USCRIPT_COMMON)
currentScript = nextScript;
else
break;
}
m_numCharactersOfCurrentRun = iterator.currentCharacter();
if (!m_harfbuzzBuffer) {
m_harfbuzzBuffer = hb_buffer_create();
hb_buffer_set_unicode_funcs(m_harfbuzzBuffer, hb_icu_get_unicode_funcs());
} else
hb_buffer_reset(m_harfbuzzBuffer);
hb_buffer_set_script(m_harfbuzzBuffer, hb_icu_script_to_script(currentScript));
// WebKit always sets direction to LTR during width calculation.
// We only set direction when direction is explicitly set to RTL so that
// preventng wrong width calculation.
if (m_run.rtl())
hb_buffer_set_direction(m_harfbuzzBuffer, HB_DIRECTION_RTL);
// Determine whether this run needs to be converted to small caps.
// nextScriptRun() will always send us a run of the same case, because a
// case change while in small-caps mode always results in different
// FontData, so we only need to check the first character's case.
if (m_font->isSmallCaps() && u_islower(m_normalizedBuffer[m_startIndexOfCurrentRun])) {
String upperText = String(m_normalizedBuffer.get() + m_startIndexOfCurrentRun, m_numCharactersOfCurrentRun);
upperText.makeUpper();
m_currentFontData = m_font->glyphDataForCharacter(upperText[0], false, SmallCapsVariant).fontData;
hb_buffer_add_utf16(m_harfbuzzBuffer, upperText.characters(), m_numCharactersOfCurrentRun, 0, m_numCharactersOfCurrentRun);
} else
hb_buffer_add_utf16(m_harfbuzzBuffer, m_normalizedBuffer.get() + m_startIndexOfCurrentRun, m_numCharactersOfCurrentRun, 0, m_numCharactersOfCurrentRun);
return true;
}
void TextLayout::Position (Font *font, size_t size, const char *text, Bytes *bytes) {
if (mFont != font) {
mFont = font;
hb_font_destroy ((hb_font_t*)mHBFont);
mHBFont = hb_ft_font_create ((FT_Face)font->face, NULL);
}
font->SetSize (size);
// reset buffer
hb_buffer_reset ((hb_buffer_t*)mBuffer);
hb_buffer_set_direction ((hb_buffer_t*)mBuffer, (hb_direction_t)mDirection);
hb_buffer_set_script ((hb_buffer_t*)mBuffer, (hb_script_t)mScript);
hb_buffer_set_language ((hb_buffer_t*)mBuffer, (hb_language_t)mLanguage);
// layout the text
hb_buffer_add_utf8 ((hb_buffer_t*)mBuffer, text, strlen (text), 0, -1);
hb_shape ((hb_font_t*)mHBFont, (hb_buffer_t*)mBuffer, NULL, 0);
uint32_t glyph_count;
hb_glyph_info_t *glyph_info = hb_buffer_get_glyph_infos ((hb_buffer_t*)mBuffer, &glyph_count);
hb_glyph_position_t *glyph_pos = hb_buffer_get_glyph_positions ((hb_buffer_t*)mBuffer, &glyph_count);
//float hres = 100;
int posIndex = 0;
int glyphSize = sizeof (GlyphPosition);
uint32_t dataSize = 4 + (glyph_count * glyphSize);
if (bytes->Length () < dataSize) {
bytes->Resize (dataSize);
}
unsigned char* bytesPosition = bytes->Data ();
*(bytesPosition) = glyph_count;
bytesPosition += 4;
hb_glyph_position_t pos;
GlyphPosition *data;
for (int i = 0; i < glyph_count; i++) {
pos = glyph_pos[i];
data = (GlyphPosition*)(bytesPosition);
data->index = glyph_info[i].codepoint;
data->advanceX = (float)(pos.x_advance / (float)(64));
data->advanceY = (float)(pos.y_advance / (float)64);
data->offsetX = (float)(pos.x_offset / (float)(64));
data->offsetY = (float)(pos.y_offset / (float)64);
bytesPosition += glyphSize;
}
}
int
layoutChars(XeTeXLayoutEngine engine, uint16_t chars[], int32_t offset, int32_t count, int32_t max,
bool rightToLeft)
{
bool res;
hb_script_t script = HB_SCRIPT_INVALID;
hb_direction_t direction = HB_DIRECTION_LTR;
hb_segment_properties_t segment_props;
hb_shape_plan_t *shape_plan;
hb_font_t* hbFont = engine->font->getHbFont();
hb_face_t* hbFace = hb_font_get_face(hbFont);
if (engine->font->getLayoutDirVertical())
direction = HB_DIRECTION_TTB;
else if (rightToLeft)
direction = HB_DIRECTION_RTL;
script = hb_ot_tag_to_script (engine->script);
if (hbUnicodeFuncs == NULL)
hbUnicodeFuncs = _get_unicode_funcs();
hb_buffer_reset(engine->hbBuffer);
hb_buffer_set_unicode_funcs(engine->hbBuffer, hbUnicodeFuncs);
hb_buffer_add_utf16(engine->hbBuffer, chars, max, offset, count);
hb_buffer_set_direction(engine->hbBuffer, direction);
hb_buffer_set_script(engine->hbBuffer, script);
hb_buffer_set_language(engine->hbBuffer, engine->language);
hb_buffer_guess_segment_properties(engine->hbBuffer);
hb_buffer_get_segment_properties(engine->hbBuffer, &segment_props);
if (engine->ShaperList == NULL) {
// HarfBuzz gives graphite2 shaper a priority, so that for hybrid
// Graphite/OpenType fonts, Graphite will be used. However, pre-0.9999
// XeTeX preferred OpenType over Graphite, so we are doing the same
// here for sake of backward compatibility.
engine->ShaperList = (char**) xcalloc(4, sizeof(char*));
engine->ShaperList[0] = (char*) "ot";
engine->ShaperList[1] = (char*) "graphite2";
engine->ShaperList[2] = (char*) "fallback";
engine->ShaperList[3] = NULL;
}
shape_plan = hb_shape_plan_create_cached(hbFace, &segment_props, engine->features, engine->nFeatures, engine->ShaperList);
res = hb_shape_plan_execute(shape_plan, hbFont, engine->hbBuffer, engine->features, engine->nFeatures);
if (res) {
engine->shaper = strdup(hb_shape_plan_get_shaper(shape_plan));
hb_buffer_set_content_type(engine->hbBuffer, HB_BUFFER_CONTENT_TYPE_GLYPHS);
} else {
// all selected shapers failed, retrying with default
// we don't use _cached here as the cached plain will always fail.
hb_shape_plan_destroy(shape_plan);
shape_plan = hb_shape_plan_create(hbFace, &segment_props, engine->features, engine->nFeatures, NULL);
res = hb_shape_plan_execute(shape_plan, hbFont, engine->hbBuffer, engine->features, engine->nFeatures);
if (res) {
engine->shaper = strdup(hb_shape_plan_get_shaper(shape_plan));
hb_buffer_set_content_type(engine->hbBuffer, HB_BUFFER_CONTENT_TYPE_GLYPHS);
} else {
fprintf(stderr, "\nERROR: all shapers failed\n");
exit(3);
}
}
hb_shape_plan_destroy(shape_plan);
int glyphCount = hb_buffer_get_length(engine->hbBuffer);
#ifdef DEBUG
char buf[1024];
unsigned int consumed;
printf ("shaper: %s\n", engine->shaper);
hb_buffer_serialize_flags_t flags = HB_BUFFER_SERIALIZE_FLAGS_DEFAULT;
hb_buffer_serialize_format_t format = HB_BUFFER_SERIALIZE_FORMAT_JSON;
hb_buffer_serialize_glyphs (engine->hbBuffer, 0, glyphCount, buf, sizeof(buf), &consumed, hbFont, format, flags);
if (consumed)
printf ("buffer glyphs: %s\n", buf);
#endif
return glyphCount;
}
int main (int argc, char** argv)
{
if (argc != 2)
{
std::cerr << "Usage: " << argv[0] << " <num-iter>" << std::endl;
return EXIT_FAILURE;
}
const unsigned NUM_ITER = atoi(argv[1]);
// open first face in the font
FT_Library ft_library = 0;
FT_Error error = FT_Init_FreeType(&ft_library);
if (error) throw std::runtime_error("Failed to initialize FreeType2 library");
FT_Face ft_face[NUM_EXAMPLES];
FT_New_Face(ft_library, "fonts/DejaVuSerif.ttf", 0, &ft_face[ENGLISH]);
FT_New_Face(ft_library, "fonts/amiri-0.104/amiri-regular.ttf", 0, &ft_face[ARABIC]);
FT_New_Face(ft_library, "fonts/fireflysung-1.3.0/fireflysung.ttf", 0, &ft_face[CHINESE]);
// Get our harfbuzz font structs
hb_font_t *hb_ft_font[NUM_EXAMPLES];
hb_ft_font[ENGLISH] = hb_ft_font_create(ft_face[ENGLISH], NULL);
hb_ft_font[ARABIC] = hb_ft_font_create(ft_face[ARABIC] , NULL);
hb_ft_font[CHINESE] = hb_ft_font_create(ft_face[CHINESE], NULL);
{
std::cerr << "Starting ICU shaping:" << std::endl;
progress_timer timer1(std::clog,"ICU shaping done");
UErrorCode err = U_ZERO_ERROR;
for (unsigned i = 0; i < NUM_ITER; ++i)
{
for (unsigned j = 0; j < NUM_EXAMPLES; ++j)
{
UnicodeString text = UnicodeString::fromUTF8(texts[j]);
int32_t length = text.length();
UnicodeString reordered;
UnicodeString shaped;
UBiDi *bidi = ubidi_openSized(length, 0, &err);
ubidi_setPara(bidi, text.getBuffer(), length, UBIDI_DEFAULT_LTR, 0, &err);
ubidi_writeReordered(bidi, reordered.getBuffer(length),
length, UBIDI_DO_MIRRORING, &err);
ubidi_close(bidi);
reordered.releaseBuffer(length);
u_shapeArabic(reordered.getBuffer(), length,
shaped.getBuffer(length), length,
U_SHAPE_LETTERS_SHAPE | U_SHAPE_LENGTH_FIXED_SPACES_NEAR |
U_SHAPE_TEXT_DIRECTION_VISUAL_LTR, &err);
shaped.releaseBuffer(length);
if (U_SUCCESS(err))
{
U_NAMESPACE_QUALIFIER StringCharacterIterator iter(shaped);
for (iter.setToStart(); iter.hasNext();)
{
UChar ch = iter.nextPostInc();
int32_t glyph_index = FT_Get_Char_Index(ft_face[j], ch);
if (i == 0)
{
std::cerr << glyph_index << ":";
}
}
if (i == 0) std::cerr << std::endl;
}
}
}
}
{
const char **shaper_list = hb_shape_list_shapers();
for ( ;*shaper_list; shaper_list++)
{
std::cerr << *shaper_list << std::endl;
}
std::cerr << "Starting Harfbuzz shaping" << std::endl;
progress_timer timer2(std::clog,"Harfbuzz shaping done");
const char* const shapers[] = { /*"ot",*/"fallback" };
hb_buffer_t *buffer(hb_buffer_create());
for (unsigned i = 0; i < NUM_ITER; ++i)
{
for (unsigned j = 0; j < NUM_EXAMPLES; ++j)
{
UnicodeString text = UnicodeString::fromUTF8(texts[j]);
int32_t length = text.length();
hb_buffer_clear_contents(buffer);
//hb_buffer_set_unicode_funcs(buffer.get(), hb_icu_get_unicode_funcs());
hb_buffer_pre_allocate(buffer, length);
hb_buffer_add_utf16(buffer, text.getBuffer(), text.length(), 0, length);
hb_buffer_set_direction(buffer, text_directions[j]);
hb_buffer_set_script(buffer, scripts[j]);
hb_buffer_set_language(buffer,hb_language_from_string(languages[j], std::strlen(languages[j])));
//hb_shape(hb_ft_font[j], buffer.get(), 0, 0);
hb_shape_full(hb_ft_font[j], buffer, 0, 0, shapers);
unsigned num_glyphs = hb_buffer_get_length(buffer);
hb_glyph_info_t *glyphs = hb_buffer_get_glyph_infos(buffer, NULL);
//hb_glyph_position_t *positions = hb_buffer_get_glyph_positions(buffer.get(), NULL);
for (unsigned k=0; k<num_glyphs; ++k)
{
int32_t glyph_index = glyphs[k].codepoint;
if (i == 0)
{
std::cerr << glyph_index << ":";
}
}
if (i == 0) std::cerr << std::endl;
}
}
hb_buffer_destroy(buffer);
}
// cleanup
for (int j=0; j < NUM_EXAMPLES; ++j)
{
hb_font_destroy(hb_ft_font[j]);
}
FT_Done_FreeType(ft_library);
return EXIT_SUCCESS;
}
int shape (lua_State *L) {
const char * text = luaL_checkstring(L, 1);
FT_Face face = lua_touserdata(L, 2);
const char * script = luaL_checkstring(L, 3);
const char * direction_s = luaL_checkstring(L, 4);
const char * lang = luaL_checkstring(L, 5);
double point_size = luaL_checknumber(L, 6);
const char * featurestring = luaL_checkstring(L, 7);
hb_segment_properties_t segment_props;
hb_shape_plan_t *shape_plan;
hb_direction_t direction;
hb_feature_t* features;
int nFeatures = 0;
unsigned int glyph_count = 0;
hb_font_t *hb_ft_font;
hb_face_t *hb_ft_face;
hb_buffer_t *buf;
hb_glyph_info_t *glyph_info;
hb_glyph_position_t *glyph_pos;
unsigned int j;
features = scan_feature_string(featurestring, &nFeatures);
if (!strcasecmp(direction_s,"RTL"))
direction = HB_DIRECTION_RTL;
else if (!strcasecmp(direction_s,"TTB"))
direction = HB_DIRECTION_TTB;
else
direction = HB_DIRECTION_LTR;
hb_ft_font = hb_ft_font_create(face, NULL);
hb_face_t* hbFace = hb_font_get_face(hb_ft_font);
buf = hb_buffer_create();
hb_buffer_add_utf8(buf, text, strlen(text), 0, strlen(text));
hb_buffer_set_script(buf, hb_tag_from_string(script, strlen(script)));
hb_buffer_set_direction(buf, direction);
hb_buffer_set_language(buf, hb_language_from_string(lang,strlen(lang)));
hb_buffer_guess_segment_properties(buf);
hb_buffer_get_segment_properties(buf, &segment_props);
shape_plan = hb_shape_plan_create_cached(hbFace, &segment_props, features, nFeatures, NULL);
int res = hb_shape_plan_execute(shape_plan, hb_ft_font, buf, features, nFeatures);
glyph_info = hb_buffer_get_glyph_infos(buf, &glyph_count);
glyph_pos = hb_buffer_get_glyph_positions(buf, &glyph_count);
lua_checkstack(L, glyph_count);
for (j = 0; j < glyph_count; ++j) {
char namebuf[255];
box glyph_extents = { 0.0, 0.0, 0.0 };
calculate_extents(&glyph_extents, glyph_info[j], glyph_pos[j], face, point_size, direction);
lua_newtable(L);
lua_pushstring(L, "name");
FT_Get_Glyph_Name( face, glyph_info[j].codepoint, namebuf, 255 );
lua_pushstring(L, namebuf);
lua_settable(L, -3);
if (direction != HB_DIRECTION_TTB) { /* XXX */
if (glyph_pos[j].x_offset) {
lua_pushstring(L, "x_offset");
lua_pushnumber(L, glyph_pos[j].x_offset / 64.0);
lua_settable(L, -3);
}
if (glyph_pos[j].y_offset) {
lua_pushstring(L, "y_offset");
lua_pushnumber(L, glyph_pos[j].y_offset / 64.0);
lua_settable(L, -3);
}
}
lua_pushstring(L, "codepoint");
lua_pushinteger(L, glyph_info[j].codepoint);
lua_settable(L, -3);
lua_pushstring(L, "width");
lua_pushnumber(L, glyph_extents.width);
lua_settable(L, -3);
lua_pushstring(L, "height");
lua_pushnumber(L, glyph_extents.height);
lua_settable(L, -3);
lua_pushstring(L, "depth");
lua_pushnumber(L, glyph_extents.depth);
lua_settable(L, -3);
}
/* Cleanup */
hb_buffer_destroy(buf);
hb_font_destroy(hb_ft_font);
hb_shape_plan_destroy(shape_plan);
free(features);
return glyph_count;
}
static void
test_buffer_properties (fixture_t *fixture, gconstpointer user_data HB_UNUSED)
{
hb_buffer_t *b = fixture->buffer;
hb_unicode_funcs_t *ufuncs;
/* test default properties */
g_assert (hb_buffer_get_unicode_funcs (b) == hb_unicode_funcs_get_default ());
g_assert (hb_buffer_get_direction (b) == HB_DIRECTION_INVALID);
g_assert (hb_buffer_get_script (b) == HB_SCRIPT_INVALID);
g_assert (hb_buffer_get_language (b) == NULL);
/* test property changes are retained */
ufuncs = hb_unicode_funcs_create (NULL);
hb_buffer_set_unicode_funcs (b, ufuncs);
hb_unicode_funcs_destroy (ufuncs);
g_assert (hb_buffer_get_unicode_funcs (b) == ufuncs);
hb_buffer_set_direction (b, HB_DIRECTION_RTL);
g_assert (hb_buffer_get_direction (b) == HB_DIRECTION_RTL);
hb_buffer_set_script (b, HB_SCRIPT_ARABIC);
g_assert (hb_buffer_get_script (b) == HB_SCRIPT_ARABIC);
hb_buffer_set_language (b, hb_language_from_string ("fa", -1));
g_assert (hb_buffer_get_language (b) == hb_language_from_string ("Fa", -1));
hb_buffer_set_flags (b, HB_BUFFER_FLAG_BOT);
g_assert (hb_buffer_get_flags (b) == HB_BUFFER_FLAG_BOT);
hb_buffer_set_replacement_codepoint (b, (unsigned int) -1);
g_assert (hb_buffer_get_replacement_codepoint (b) == (unsigned int) -1);
/* test clear_contents clears all these properties: */
hb_buffer_clear_contents (b);
g_assert (hb_buffer_get_unicode_funcs (b) == ufuncs);
g_assert (hb_buffer_get_direction (b) == HB_DIRECTION_INVALID);
g_assert (hb_buffer_get_script (b) == HB_SCRIPT_INVALID);
g_assert (hb_buffer_get_language (b) == NULL);
/* but not these: */
g_assert (hb_buffer_get_flags (b) != HB_BUFFER_FLAGS_DEFAULT);
g_assert (hb_buffer_get_replacement_codepoint (b) != HB_BUFFER_REPLACEMENT_CODEPOINT_DEFAULT);
/* test reset clears all properties */
hb_buffer_set_direction (b, HB_DIRECTION_RTL);
g_assert (hb_buffer_get_direction (b) == HB_DIRECTION_RTL);
hb_buffer_set_script (b, HB_SCRIPT_ARABIC);
g_assert (hb_buffer_get_script (b) == HB_SCRIPT_ARABIC);
hb_buffer_set_language (b, hb_language_from_string ("fa", -1));
g_assert (hb_buffer_get_language (b) == hb_language_from_string ("Fa", -1));
hb_buffer_set_flags (b, HB_BUFFER_FLAG_BOT);
g_assert (hb_buffer_get_flags (b) == HB_BUFFER_FLAG_BOT);
hb_buffer_set_replacement_codepoint (b, (unsigned int) -1);
g_assert (hb_buffer_get_replacement_codepoint (b) == (unsigned int) -1);
hb_buffer_reset (b);
g_assert (hb_buffer_get_unicode_funcs (b) == hb_unicode_funcs_get_default ());
g_assert (hb_buffer_get_direction (b) == HB_DIRECTION_INVALID);
g_assert (hb_buffer_get_script (b) == HB_SCRIPT_INVALID);
g_assert (hb_buffer_get_language (b) == NULL);
g_assert (hb_buffer_get_flags (b) == HB_BUFFER_FLAGS_DEFAULT);
g_assert (hb_buffer_get_replacement_codepoint (b) == HB_BUFFER_REPLACEMENT_CODEPOINT_DEFAULT);
}
bool GlyphString::shapeHarfBuzz()
{
if (mState != Analyzed)
return false;
hb_font_t *hb_font = hb_ft_font_create(mFace, NULL);
int totalGlyphs = 0;
for (int i = 0; i < mRunInfos.size(); ++i) {
RunInfo &runInfo = mRunInfos[i];
runInfo.buffer = hb_buffer_create();
hb_buffer_set_direction(runInfo.buffer, runInfo.direction);
hb_buffer_set_script(runInfo.buffer, runInfo.script);
hb_buffer_add_utf32(runInfo.buffer, mCodePoints + runInfo.startOffset,
runInfo.endOffset - runInfo.startOffset, 0,
runInfo.endOffset - runInfo.startOffset);
hb_shape(hb_font, runInfo.buffer, NULL, 0);
runInfo.glyphInfos = hb_buffer_get_glyph_infos(runInfo.buffer,
&runInfo.glyphCount);
runInfo.glyphPositions = hb_buffer_get_glyph_positions(runInfo.buffer,
&runInfo.glyphCount);
totalGlyphs += runInfo.glyphCount;
}
quint32 *newCodePoints = new quint32[totalGlyphs];
memset(newCodePoints, 0, totalGlyphs * sizeof(*newCodePoints));
int *newGlyphIndices = new int[totalGlyphs];
memset(newGlyphIndices, 0, totalGlyphs * sizeof(*newGlyphIndices));
QImage *newImages = new QImage[totalGlyphs];
Geometry *newGeometries = new Geometry[totalGlyphs];
int *newRuns = new int[totalGlyphs];
memset(newRuns, 0, totalGlyphs * sizeof(*newRuns));
int *newLines = new int[totalGlyphs];
memset(newLines, 0, totalGlyphs * sizeof(*newLines));
hb_script_t *newScripts = new hb_script_t[totalGlyphs];
memset(newScripts, 0, totalGlyphs * sizeof(*newScripts));
FriBidiCharType *newTypes = new FriBidiCharType[totalGlyphs];
memset(newTypes, 0, totalGlyphs * sizeof(*newTypes));
FriBidiLevel *newLevels = new FriBidiLevel[totalGlyphs];
memset(newLevels, 0, totalGlyphs * sizeof(*newLevels));
FriBidiStrIndex *newMap = new FriBidiStrIndex[totalGlyphs];
memset(newMap, 0, totalGlyphs * sizeof(*newMap));
int index = 0;
for (int i = 0; i < mRunInfos.size(); ++i) {
RunInfo &runInfo = mRunInfos[i];
hb_glyph_info_t *glyphInfos = runInfo.glyphInfos;
hb_glyph_position_t *glyphPositions = runInfo.glyphPositions;
for (unsigned int j = 0; j < runInfo.glyphCount; ++j) {
int runIndex = runInfo.direction == HB_DIRECTION_LTR ?
j : runInfo.glyphCount - 1 - j;
int sourceIndex = glyphInfos[runIndex].cluster
+ runInfo.startOffset;
//newCodePoints[index] = mCodePoints[sourceIndex];
newGlyphIndices[index] = glyphInfos[runIndex].codepoint;
newRuns[index] = mRuns[sourceIndex];
newScripts[index] = mScripts[sourceIndex];
newTypes[index] = mTypes[sourceIndex];
newLevels[index] = mLevels[sourceIndex];
newGeometries[index].xOffset = glyphPositions[runIndex].x_offset / 64;
newGeometries[index].yOffset = glyphPositions[runIndex].y_offset / 64;
newGeometries[index].xAdvance = glyphPositions[runIndex].x_advance / 64;
newGeometries[index].yAdvance = glyphPositions[runIndex].y_advance / 64;
++index;
}
}
delete[] mCodePoints;
delete[] mGlyphIndices;
delete[] mImages;
delete[] mGeometries;
delete[] mRuns;
delete[] mLines;
delete[] mScripts;
delete[] mTypes;
delete[] mLevels;
delete[] mMap;
mCodePoints = newCodePoints;
mGlyphIndices = newGlyphIndices;
mImages = newImages;
mGeometries = newGeometries;
mRuns = newRuns;
mLines = newLines;
mScripts = newScripts;
mTypes = newTypes;
mLevels = newLevels;
mMap = newMap;
mSize = totalGlyphs;
loadGlyphImages(true, true);
hb_font_destroy(hb_font);
for (int i = 0; i < mRunInfos.size(); ++i) {
hb_buffer_destroy(mRunInfos[i].buffer);
mRunInfos[i].buffer = 0;
mRunInfos[i].glyphInfos = 0;
mRunInfos[i].glyphPositions = 0;
mRunInfos[i].glyphCount = 0;
}
mState = Shaped;
return true;
}
// ------------------------------------------------------------------- main ---
int main( int argc, char **argv )
{
size_t i, j;
GLFWwindow* window;
glfwSetErrorCallback( error_callback );
if (!glfwInit( ))
{
exit( EXIT_FAILURE );
}
glfwWindowHint( GLFW_VISIBLE, GL_TRUE );
glfwWindowHint( GLFW_RESIZABLE, GL_FALSE );
window = glfwCreateWindow( 1, 1, argv[0], NULL, NULL );
if (!window)
{
glfwTerminate( );
exit( EXIT_FAILURE );
}
glfwMakeContextCurrent( window );
glfwSwapInterval( 1 );
glfwSetFramebufferSizeCallback( window, reshape );
glfwSetWindowRefreshCallback( window, display );
glfwSetKeyCallback( window, keyboard );
#ifndef __APPLE__
glewExperimental = GL_TRUE;
GLenum err = glewInit();
if (GLEW_OK != err)
{
/* Problem: glewInit failed, something is seriously wrong. */
fprintf( stderr, "Error: %s\n", glewGetErrorString(err) );
exit( EXIT_FAILURE );
}
fprintf( stderr, "Using GLEW %s\n", glewGetString(GLEW_VERSION) );
#endif
texture_atlas_t * atlas = texture_atlas_new( 512, 512, 3 );
texture_font_t *fonts[20];
for ( i=0; i< 20; ++i )
{
fonts[i] = texture_font_new_from_file(atlas, 12+i, font_filename),
texture_font_load_glyphs(fonts[i], text, direction, language, script );
}
typedef struct { float x,y,z, u,v, r,g,b,a, shift, gamma; } vertex_t;
vbuffer = vertex_buffer_new( "vertex:3f,tex_coord:2f,"
"color:4f,ashift:1f,agamma:1f" );
/* Create a buffer for harfbuzz to use */
hb_buffer_t *buffer = hb_buffer_create();
for (i=0; i < 20; ++i)
{
hb_buffer_set_direction( buffer, direction );
hb_buffer_set_script( buffer, script );
hb_buffer_set_language( buffer,
hb_language_from_string(language, strlen(language)) );
hb_buffer_add_utf8( buffer, text, strlen(text), 0, strlen(text) );
hb_shape( fonts[i]->hb_ft_font, buffer, NULL, 0 );
unsigned int glyph_count;
hb_glyph_info_t *glyph_info =
hb_buffer_get_glyph_infos(buffer, &glyph_count);
hb_glyph_position_t *glyph_pos =
hb_buffer_get_glyph_positions(buffer, &glyph_count);
texture_font_load_glyphs( fonts[i], text,
direction, language, script );
float gamma = 1.0;
float shift = 0.0;
float x = 0;
float y = 600 - i * (10+i) - 15;
float width = 0.0;
float hres = fonts[i]->hres;
for (j = 0; j < glyph_count; ++j)
{
int codepoint = glyph_info[j].codepoint;
float x_advance = glyph_pos[j].x_advance/(float)(hres*64);
float x_offset = glyph_pos[j].x_offset/(float)(hres*64);
texture_glyph_t *glyph = texture_font_get_glyph(fonts[i], codepoint);
if( i < (glyph_count-1) )
width += x_advance + x_offset;
else
width += glyph->offset_x + glyph->width;
}
x = 800 - width - 10 ;
for (j = 0; j < glyph_count; ++j)
{
int codepoint = glyph_info[j].codepoint;
// because of vhinting trick we need the extra 64 (hres)
float x_advance = glyph_pos[j].x_advance/(float)(hres*64);
float x_offset = glyph_pos[j].x_offset/(float)(hres*64);
float y_advance = glyph_pos[j].y_advance/(float)(64);
float y_offset = glyph_pos[j].y_offset/(float)(64);
texture_glyph_t *glyph = texture_font_get_glyph(fonts[i], codepoint);
float r = 0.0;
float g = 0.0;
float b = 0.0;
float a = 1.0;
float x0 = x + x_offset + glyph->offset_x;
float x1 = x0 + glyph->width;
float y0 = floor(y + y_offset + glyph->offset_y);
float y1 = floor(y0 - glyph->height);
float s0 = glyph->s0;
float t0 = glyph->t0;
float s1 = glyph->s1;
float t1 = glyph->t1;
vertex_t vertices[4] = {
{x0,y0,0, s0,t0, r,g,b,a, shift, gamma},
{x0,y1,0, s0,t1, r,g,b,a, shift, gamma},
{x1,y1,0, s1,t1, r,g,b,a, shift, gamma},
{x1,y0,0, s1,t0, r,g,b,a, shift, gamma} };
GLushort indices[6] = { 0,1,2, 0,2,3 };
vertex_buffer_push_back( vbuffer, vertices, 4, indices, 6 );
x += x_advance;
y += y_advance;
}
/* clean up the buffer, but don't kill it just yet */
hb_buffer_reset(buffer);
}
glClearColor(1,1,1,1);
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glBindTexture( GL_TEXTURE_2D, atlas->id );
texture_atlas_upload( atlas );
vertex_buffer_upload( vbuffer );
shader = shader_load("shaders/text.vert", "shaders/text.frag");
mat4_set_identity( &projection );
mat4_set_identity( &model );
mat4_set_identity( &view );
glfwSetWindowSize( window, 800, 600 );
glfwShowWindow( window );
while(!glfwWindowShouldClose( window ))
{
display( window );
glfwPollEvents( );
}
glfwDestroyWindow( window );
glfwTerminate( );
return 0;
}
// ------------------------------------------------------------------- init ---
void init( void )
{
size_t i, j;
texture_atlas_t * atlas = texture_atlas_new( 512, 512, 3 );
texture_font_t *fonts[20];
for ( i=0; i< 20; ++i )
{
fonts[i] = texture_font_new_from_file(atlas, 12+i, font_filename),
texture_font_load_glyphs(fonts[i], text, direction, language, script );
}
typedef struct { float x,y,z, u,v, r,g,b,a, shift, gamma; } vertex_t;
vbuffer = vertex_buffer_new( "vertex:3f,tex_coord:2f,"
"color:4f,ashift:1f,agamma:1f" );
/* Create a buffer for harfbuzz to use */
hb_buffer_t *buffer = hb_buffer_create();
for (i=0; i < 20; ++i)
{
hb_buffer_set_direction( buffer, direction );
hb_buffer_set_script( buffer, script );
hb_buffer_set_language( buffer,
hb_language_from_string(language, strlen(language)) );
hb_buffer_add_utf8( buffer, text, strlen(text), 0, strlen(text) );
hb_shape( fonts[i]->hb_ft_font, buffer, NULL, 0 );
unsigned int glyph_count;
hb_glyph_info_t *glyph_info =
hb_buffer_get_glyph_infos(buffer, &glyph_count);
hb_glyph_position_t *glyph_pos =
hb_buffer_get_glyph_positions(buffer, &glyph_count);
texture_font_load_glyphs( fonts[i], text,
direction, language, script );
float gamma = 1.0;
float shift = 0.0;
float x = 0;
float y = 600 - i * (10+i) - 15;
float width = 0.0;
float hres = fonts[i]->hres;
for (j = 0; j < glyph_count; ++j)
{
int codepoint = glyph_info[j].codepoint;
float x_advance = glyph_pos[j].x_advance/(float)(hres*64);
float x_offset = glyph_pos[j].x_offset/(float)(hres*64);
texture_glyph_t *glyph = texture_font_get_glyph(fonts[i], codepoint);
if( i < (glyph_count-1) )
width += x_advance + x_offset;
else
width += glyph->offset_x + glyph->width;
}
x = 800 - width - 10 ;
for (j = 0; j < glyph_count; ++j)
{
int codepoint = glyph_info[j].codepoint;
// because of vhinting trick we need the extra 64 (hres)
float x_advance = glyph_pos[j].x_advance/(float)(hres*64);
float x_offset = glyph_pos[j].x_offset/(float)(hres*64);
float y_advance = glyph_pos[j].y_advance/(float)(64);
float y_offset = glyph_pos[j].y_offset/(float)(64);
texture_glyph_t *glyph = texture_font_get_glyph(fonts[i], codepoint);
float r = 0.0;
float g = 0.0;
float b = 0.0;
float a = 1.0;
float x0 = x + x_offset + glyph->offset_x;
float x1 = x0 + glyph->width;
float y0 = floor(y + y_offset + glyph->offset_y);
float y1 = floor(y0 - glyph->height);
float s0 = glyph->s0;
float t0 = glyph->t0;
float s1 = glyph->s1;
float t1 = glyph->t1;
vertex_t vertices[4] = {
{x0,y0,0, s0,t0, r,g,b,a, shift, gamma},
{x0,y1,0, s0,t1, r,g,b,a, shift, gamma},
{x1,y1,0, s1,t1, r,g,b,a, shift, gamma},
{x1,y0,0, s1,t0, r,g,b,a, shift, gamma} };
GLuint indices[6] = { 0,1,2, 0,2,3 };
vertex_buffer_push_back( vbuffer, vertices, 4, indices, 6 );
x += x_advance;
y += y_advance;
}
/* clean up the buffer, but don't kill it just yet */
hb_buffer_reset(buffer);
}
glClearColor(1,1,1,1);
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glEnable( GL_TEXTURE_2D );
glBindTexture( GL_TEXTURE_2D, atlas->id );
texture_atlas_upload( atlas );
vertex_buffer_upload( vbuffer );
shader = shader_load("shaders/text.vert", "shaders/text.frag");
mat4_set_identity( &projection );
mat4_set_identity( &model );
mat4_set_identity( &view );
}
