diff options
Diffstat (limited to 'v_windows/v/old/vlib/x/ttf/ttf.v')
| -rw-r--r-- | v_windows/v/old/vlib/x/ttf/ttf.v | 1085 |
1 files changed, 1085 insertions, 0 deletions
diff --git a/v_windows/v/old/vlib/x/ttf/ttf.v b/v_windows/v/old/vlib/x/ttf/ttf.v new file mode 100644 index 0000000..fefa544 --- /dev/null +++ b/v_windows/v/old/vlib/x/ttf/ttf.v @@ -0,0 +1,1085 @@ +module ttf + +/********************************************************************** +* +* TrueTypeFont reader V implementation +* +* Copyright (c) 2021 Dario Deledda. All rights reserved. +* Use of this source code is governed by an MIT license +* that can be found in the LICENSE file. +* +* Note: +* - inspired by: http://stevehanov.ca/blog/?id=143 +* +* TODO: +* - check for unicode > 0xFFFF if supported +* - evaluate use a buffer for the points in the glyph +**********************************************************************/ +import strings + +/****************************************************************************** +* +* CMAP structs +* +******************************************************************************/ +struct Segment { +mut: + id_range_offset u32 + start_code u16 + end_code u16 + id_delta u16 +} + +struct TrueTypeCmap { +mut: + format int + cache []int = []int{len: 65536, init: -1} // for now we allocate 2^16 charcode + segments []Segment + arr []int +} + +/****************************************************************************** +* +* TTF_File structs +* +******************************************************************************/ +pub struct TTF_File { +pub mut: + buf []byte + pos u32 + length u16 + scalar_type u32 + search_range u16 + entry_selector u16 + range_shift u16 + tables map[string]Offset_Table + version f32 + font_revision f32 + checksum_adjustment u32 + magic_number u32 + flags u16 + units_per_em u16 + created u64 + modified u64 + x_min f32 + y_min f32 + x_max f32 + y_max f32 + mac_style u16 + lowest_rec_ppem u16 + font_direction_hint i16 + index_to_loc_format i16 + glyph_data_format i16 + font_family string + font_sub_family string + full_name string + postscript_name string + cmaps []TrueTypeCmap + ascent i16 + descent i16 + line_gap i16 + advance_width_max u16 + min_left_side_bearing i16 + min_right_side_bearing i16 + x_max_extent i16 + caret_slope_rise i16 + caret_slope_run i16 + caret_offset i16 + metric_data_format i16 + num_of_long_hor_metrics u16 + kern []Kern0Table + // cache + glyph_cache map[int]Glyph +} + +pub fn (mut tf TTF_File) init() { + tf.read_offset_tables() + tf.read_head_table() + // dprintln(tf.get_info_string()) + tf.read_name_table() + tf.read_cmap_table() + tf.read_hhea_table() + tf.read_kern_table() + tf.length = tf.glyph_count() + dprintln('Number of symbols: $tf.length') + dprintln('*****************************') +} + +/****************************************************************************** +* +* TTF_File Glyph Structs +* +******************************************************************************/ +pub struct Point { +pub mut: + x int + y int + on_curve bool +} + +struct Gylph_Component { +mut: + points []Point +} + +// type of glyph +const ( + g_type_simple = u16(1) // simple type + g_type_complex = u16(2) // compound type +) + +pub struct Glyph { +pub mut: + g_type u16 = ttf.g_type_simple + contour_ends []u16 + number_of_contours i16 + points []Point + x_min i16 + x_max i16 + y_min i16 + y_max i16 + valid_glyph bool + components []Component +} + +/****************************************************************************** +* +* TTF_File metrics and glyph +* +******************************************************************************/ +pub fn (mut tf TTF_File) get_horizontal_metrics(glyph_index u16) (int, int) { + assert 'hmtx' in tf.tables + old_pos := tf.pos + mut offset := tf.tables['hmtx'].offset + + mut advance_width := 0 + mut left_side_bearing := 0 + if glyph_index < tf.num_of_long_hor_metrics { + offset += glyph_index * 4 + tf.pos = offset + advance_width = tf.get_u16() + left_side_bearing = tf.get_i16() + // dprintln("Found h_metric aw: $advance_width lsb: $left_side_bearing") + } else { + // read the last entry of the hMetrics array + tf.pos = offset + (tf.num_of_long_hor_metrics - 1) * 4 + advance_width = tf.get_u16() + tf.pos = offset + tf.num_of_long_hor_metrics * 4 + + 2 * (glyph_index - tf.num_of_long_hor_metrics) + left_side_bearing = tf.get_fword() + } + tf.pos = old_pos + return advance_width, left_side_bearing +} + +fn (mut tf TTF_File) get_glyph_offset(index u32) u32 { + // check if needed tables exists + assert 'loca' in tf.tables + assert 'glyf' in tf.tables + mut old_pos := tf.pos + + table := tf.tables['loca'] + mut offset := u32(0) + mut next := u32(0) + if tf.index_to_loc_format == 1 { + tf.pos = table.offset + (index << 2) + offset = tf.get_u32() + next = tf.get_u32() + } else { + tf.pos = table.offset + (index << 1) + offset = tf.get_u16() << 1 + next = tf.get_u16() << 1 + } + + if offset == next { + // indicates glyph has no outline( eg space) + return 0 + } + // dprintln("Offset for glyph index $index is $offset") + tf.pos = old_pos + return offset + tf.tables['glyf'].offset +} + +fn (mut tf TTF_File) glyph_count() u16 { + assert 'maxp' in tf.tables + old_pos := tf.pos + tf.pos = tf.tables['maxp'].offset + 4 + count := tf.get_u16() + tf.pos = old_pos + return count +} + +pub fn (mut tf TTF_File) read_glyph_dim(index u16) (int, int, int, int) { + offset := tf.get_glyph_offset(index) + // dprintln("offset: $offset") + if offset == 0 || offset >= tf.tables['glyf'].offset + tf.tables['glyf'].length { + dprintln('No glyph found!') + return 0, 0, 0, 0 + } + + assert offset >= tf.tables['glyf'].offset + assert offset < tf.tables['glyf'].offset + tf.tables['glyf'].length + + tf.pos = offset + // dprintln("file seek read_glyph: $tf.pos") + + // number_of_contours + _ := tf.get_i16() + x_min := tf.get_fword() + y_min := tf.get_fword() + x_max := tf.get_fword() + y_max := tf.get_fword() + + return x_min, x_max, y_min, y_max +} + +pub fn (mut tf TTF_File) read_glyph(index u16) Glyph { + index_int := int(index) // index.str() + if index_int in tf.glyph_cache { + // dprintln("Found glyp: ${index}") + return tf.glyph_cache[index_int] + } + // dprintln("Create glyp: ${index}") + + offset := tf.get_glyph_offset(index) + // dprintln("offset: $offset") + if offset == 0 || offset >= tf.tables['glyf'].offset + tf.tables['glyf'].length { + dprintln('No glyph found!') + return Glyph{} + } + + assert offset >= tf.tables['glyf'].offset + assert offset < tf.tables['glyf'].offset + tf.tables['glyf'].length + + tf.pos = offset + // dprintln("file seek read_glyph: $tf.pos") + + /* + ---- BUG TO SOLVE ----- + --- Order of the data if printed in the main is shuffled!! Very Strange + mut tmp_glyph := Glyph{ + number_of_contours : tf.get_i16() + x_min : tf.get_fword() + y_min : tf.get_fword() + x_max : tf.get_fword() + y_max : tf.get_fword() + } + */ + + mut tmp_glyph := Glyph{} + tmp_glyph.number_of_contours = tf.get_i16() + tmp_glyph.x_min = tf.get_fword() + tmp_glyph.y_min = tf.get_fword() + tmp_glyph.x_max = tf.get_fword() + tmp_glyph.y_max = tf.get_fword() + + // dprintln("file seek after read_glyph: $tf.pos") + + assert tmp_glyph.number_of_contours >= -1 + + if tmp_glyph.number_of_contours == -1 { + // dprintln("read_compound_glyph") + tf.read_compound_glyph(mut tmp_glyph) + } else { + // dprintln("read_simple_glyph") + tf.read_simple_glyph(mut tmp_glyph) + } + + tf.glyph_cache[index_int] = tmp_glyph + return tmp_glyph +} + +const ( + tfk_on_curve = 1 + tfk_x_is_byte = 2 + tfk_y_is_byte = 4 + tfk_repeat = 8 + tfk_x_delta = 16 + tfk_y_delta = 32 +) + +fn (mut tf TTF_File) read_simple_glyph(mut in_glyph Glyph) { + if in_glyph.number_of_contours == 0 { + return + } + + for _ in 0 .. in_glyph.number_of_contours { + in_glyph.contour_ends << tf.get_u16() + } + + // skip over intructions + tf.pos = tf.get_u16() + tf.pos + + mut num_points := 0 + for ce in in_glyph.contour_ends { + if ce > num_points { + num_points = ce + } + } + num_points++ + + mut i := 0 + mut flags := []byte{} + for i < num_points { + flag := tf.get_u8() + flags << flag + in_glyph.points << Point{ + x: 0 + y: 0 + on_curve: (flag & ttf.tfk_on_curve) > 0 + } + if (flag & ttf.tfk_repeat) > 0 { + mut repeat_count := tf.get_u8() + assert repeat_count > 0 + i += repeat_count + for repeat_count > 0 { + flags << flag + in_glyph.points << Point{ + x: 0 + y: 0 + on_curve: (flag & ttf.tfk_on_curve) > 0 + } + repeat_count-- + } + } + i++ + } + + // read coords x + mut value := 0 + for i_x in 0 .. num_points { + flag_x := flags[i_x] + if (flag_x & ttf.tfk_x_is_byte) > 0 { + if (flag_x & ttf.tfk_x_delta) > 0 { + value += tf.get_u8() + } else { + value -= tf.get_u8() + } + } else if (~flag_x & ttf.tfk_x_delta) > 0 { + value += tf.get_i16() + } else { + // value is unchanged + } + // dprintln("$i_x x: $value") + in_glyph.points[i_x].x = value + } + + // read coords y + value = 0 + for i_y in 0 .. num_points { + flag_y := flags[i_y] + if (flag_y & ttf.tfk_y_is_byte) > 0 { + if (flag_y & ttf.tfk_y_delta) > 0 { + value += tf.get_u8() + } else { + value -= tf.get_u8() + } + } else if (~flag_y & ttf.tfk_y_delta) > 0 { + value += tf.get_i16() + } else { + // value is unchanged + } + // dprintln("$i_y y: $value") + in_glyph.points[i_y].y = value + } + + // ok we have a valid glyph + in_glyph.valid_glyph = true +} + +const ( + tfkc_arg_1_and_2_are_words = 1 + tfkc_args_are_xy_values = 2 + tfkc_round_xy_to_grid = 4 + tfkc_we_have_a_scale = 8 + // reserved = 16 + tfkc_more_components = 32 + tfkc_we_have_an_x_and_y_scale = 64 + tfkc_we_have_a_two_by_two = 128 + tfkc_we_have_instructions = 256 + tfkc_use_my_metrics = 512 + tfkc_overlap_component = 1024 +) + +struct Component { +mut: + glyph_index u16 + dest_point_index i16 + src_point_index i16 + matrix []f32 = [f32(1.0), 0, 0, 1.0, 0, 0] +} + +fn (mut tf TTF_File) read_compound_glyph(mut in_glyph Glyph) { + in_glyph.g_type = ttf.g_type_complex + mut component := Component{} + mut flags := ttf.tfkc_more_components + for (flags & ttf.tfkc_more_components) > 0 { + mut arg1 := i16(0) + mut arg2 := i16(0) + + flags = tf.get_u16() + + component.glyph_index = tf.get_u16() + + if (flags & ttf.tfkc_arg_1_and_2_are_words) > 0 { + arg1 = tf.get_i16() + arg2 = tf.get_i16() + } else { + arg1 = tf.get_u8() + arg2 = tf.get_u8() + } + + if (flags & ttf.tfkc_args_are_xy_values) > 0 { + component.matrix[4] = arg1 + component.matrix[5] = arg2 + } else { + component.dest_point_index = arg1 + component.src_point_index = arg2 + } + + if (flags & ttf.tfkc_we_have_a_scale) > 0 { + component.matrix[0] = tf.get_2dot14() + component.matrix[3] = component.matrix[0] + } else if (flags & ttf.tfkc_we_have_an_x_and_y_scale) > 0 { + component.matrix[0] = tf.get_2dot14() + component.matrix[3] = tf.get_2dot14() + } else if (flags & ttf.tfkc_we_have_a_two_by_two) > 0 { + component.matrix[0] = tf.get_2dot14() + component.matrix[1] = tf.get_2dot14() + component.matrix[2] = tf.get_2dot14() + component.matrix[3] = tf.get_2dot14() + } + // dprintln("Read component glyph index ${component.glyph_index}") + // dprintln("Transform: ${component.matrix}") + + old_pos := tf.pos + + simple_glyph := tf.read_glyph(component.glyph_index) + if simple_glyph.valid_glyph { + point_offset := in_glyph.points.len + for i in 0 .. simple_glyph.contour_ends.len { + in_glyph.contour_ends << u16(simple_glyph.contour_ends[i] + point_offset) + } + + for p in simple_glyph.points { + mut x := f32(p.x) + mut y := f32(p.y) + x = component.matrix[0] * x + component.matrix[1] * y + component.matrix[4] + y = component.matrix[2] * x + component.matrix[3] * y + component.matrix[5] + in_glyph.points << Point{ + x: int(x) + y: int(y) + on_curve: p.on_curve + } + } + } + tf.pos = old_pos + } + + in_glyph.number_of_contours = i16(in_glyph.contour_ends.len) + + if (flags & ttf.tfkc_we_have_instructions) > 0 { + tf.pos = tf.get_u16() + tf.pos + } + // ok we have a valid glyph + in_glyph.valid_glyph = true +} + +/****************************************************************************** +* +* TTF_File get functions +* +******************************************************************************/ +fn (mut tf TTF_File) get_u8() byte { + x := tf.buf[tf.pos] + tf.pos++ + return byte(x) +} + +fn (mut tf TTF_File) get_i8() i8 { + return i8(tf.get_u8()) +} + +fn (mut tf TTF_File) get_u16() u16 { + x := u16(tf.buf[tf.pos] << u16(8)) | u16(tf.buf[tf.pos + 1]) + tf.pos += 2 + return x +} + +fn (mut tf TTF_File) get_ufword() u16 { + return tf.get_u16() +} + +fn (mut tf TTF_File) get_i16() i16 { + return i16(tf.get_u16()) +} + +fn (mut tf TTF_File) get_fword() i16 { + return tf.get_i16() +} + +fn (mut tf TTF_File) get_u32() u32 { + x := (u32(tf.buf[tf.pos]) << u32(24)) | (u32(tf.buf[tf.pos + 1]) << u32(16)) | (u32(tf.buf[ + tf.pos + 2]) << u32(8)) | u32(tf.buf[tf.pos + 3]) + tf.pos += 4 + return x +} + +fn (mut tf TTF_File) get_i32() int { + return int(tf.get_u32()) +} + +fn (mut tf TTF_File) get_2dot14() f32 { + return f32(tf.get_i16()) / f32(i16(1 << 14)) +} + +fn (mut tf TTF_File) get_fixed() f32 { + return f32(tf.get_i32() / f32(1 << 16)) +} + +fn (mut tf TTF_File) get_string(length int) string { + tmp_pos := u64(tf.pos) + tf.pos += u32(length) + return unsafe { tos(&byte(u64(tf.buf.data) + tmp_pos), length) } +} + +fn (mut tf TTF_File) get_unicode_string(length int) string { + mut tmp_txt := strings.new_builder(length) + mut real_len := 0 + + for _ in 0 .. (length >> 1) { + c := tf.get_u16() + c_len := ((0xe5000000 >> ((c >> 3) & 0x1e)) & 3) + 1 + real_len += c_len + if c_len == 1 { + tmp_txt.write_b(byte(c & 0xff)) + } else { + tmp_txt.write_b(byte((c >> 8) & 0xff)) + tmp_txt.write_b(byte(c & 0xff)) + } + // dprintln("c: ${c:c}|${ byte(c &0xff) :c} c_len: ${c_len} str_len: ${real_len} in_len: ${length}") + } + tf.pos += u32(real_len) + res_txt := tmp_txt.str() + // dprintln("get_unicode_string: ${res_txt}") + return res_txt +} + +fn (mut tf TTF_File) get_date() u64 { + // get mac time and covert it to unix timestamp + mac_time := (u64(tf.get_u32()) << 32) + u64(tf.get_u32()) + utc_time := mac_time - u64(2082844800) + return utc_time +} + +fn (mut tf TTF_File) calc_checksum(offset u32, length u32) u32 { + old_index := tf.pos + mut sum := u64(0) + mut nlongs := int((length + 3) >> 2) + tf.pos = offset + // dprintln("offs: $offset nlongs: $nlongs") + for nlongs > 0 { + sum = sum + u64(tf.get_u32()) + nlongs-- + } + tf.pos = old_index + return u32(sum & u64(0xffff_ffff)) +} + +/****************************************************************************** +* +* Offset_Table +* +******************************************************************************/ +struct Offset_Table { +mut: + checksum u32 + offset u32 + length u32 +} + +fn (mut tf TTF_File) read_offset_tables() { + dprintln('*** READ TABLES OFFSET ***') + tf.pos = 0 + tf.scalar_type = tf.get_u32() + num_tables := tf.get_u16() + tf.search_range = tf.get_u16() + tf.entry_selector = tf.get_u16() + tf.range_shift = tf.get_u16() + + dprintln('scalar_type : [0x$tf.scalar_type.hex()]') + dprintln('num tables : [$num_tables]') + dprintln('search_range : [0x$tf.search_range.hex()]') + dprintln('entry_selector: [0x$tf.entry_selector.hex()]') + dprintln('range_shift : [0x$tf.range_shift.hex()]') + + mut i := 0 + for i < num_tables { + tag := tf.get_string(4) + tf.tables[tag] = Offset_Table{ + checksum: tf.get_u32() + offset: tf.get_u32() + length: tf.get_u32() + } + dprintln('Table: [$tag]') + // dprintln("${tf.tables[tag]}") + + if tag != 'head' { + assert tf.calc_checksum(tf.tables[tag].offset, tf.tables[tag].length) == tf.tables[tag].checksum + } + i++ + } + dprintln('*** END READ TABLES OFFSET ***') +} + +/****************************************************************************** +* +* Head_Table +* +******************************************************************************/ +fn (mut tf TTF_File) read_head_table() { + dprintln('*** READ HEAD TABLE ***') + tf.pos = tf.tables['head'].offset + dprintln('Offset: $tf.pos') + + tf.version = tf.get_fixed() + tf.font_revision = tf.get_fixed() + tf.checksum_adjustment = tf.get_u32() + tf.magic_number = tf.get_u32() + assert tf.magic_number == 0x5f0f3cf5 + tf.flags = tf.get_u16() + tf.units_per_em = tf.get_u16() + tf.created = tf.get_date() + tf.modified = tf.get_date() + tf.x_min = tf.get_i16() + tf.y_min = tf.get_i16() + tf.x_max = tf.get_i16() + tf.y_max = tf.get_i16() + tf.mac_style = tf.get_u16() + tf.lowest_rec_ppem = tf.get_u16() + tf.font_direction_hint = tf.get_i16() + tf.index_to_loc_format = tf.get_i16() + tf.glyph_data_format = tf.get_i16() +} + +/****************************************************************************** +* +* Name_Table +* +******************************************************************************/ +fn (mut tf TTF_File) read_name_table() { + dprintln('*** READ NAME TABLE ***') + assert 'name' in tf.tables + table_offset := tf.tables['name'].offset + tf.pos = tf.tables['name'].offset + + format := tf.get_u16() // must be 0 + assert format == 0 + count := tf.get_u16() + string_offset := tf.get_u16() + + for _ in 0 .. count { + platform_id := tf.get_u16() + // platform_specific_id := + tf.get_u16() + // language_id := + tf.get_u16() + name_id := tf.get_u16() + length := tf.get_u16() + offset := tf.get_u16() + + old_pos := tf.pos + tf.pos = table_offset + string_offset + offset + + mut name := '' + if platform_id == 0 || platform_id == 3 { + name = tf.get_unicode_string(length) + } else { + name = tf.get_string(length) + } + // dprintln("Name [${platform_id} / ${platform_specific_id}] id:[$name_id] language:[$language_id] [$name]") + tf.pos = old_pos + + match name_id { + 1 { tf.font_family = name } + 2 { tf.font_sub_family = name } + 4 { tf.full_name = name } + 6 { tf.postscript_name = name } + else {} + } + } +} + +/****************************************************************************** +* +* Cmap_Table +* +******************************************************************************/ +fn (mut tf TTF_File) read_cmap_table() { + dprintln('*** READ CMAP TABLE ***') + assert 'cmap' in tf.tables + table_offset := tf.tables['cmap'].offset + tf.pos = table_offset + + version := tf.get_u16() // must be 0 + assert version == 0 + number_sub_tables := tf.get_u16() + + // tables must be sorted by platform id and then platform specific + // encoding. + for _ in 0 .. number_sub_tables { + // platforms are: + // 0 - Unicode -- use specific id 6 for full coverage. 0/4 common. + // 1 - Macintosh (Discouraged) + // 2 - reserved + // 3 - Microsoft + platform_id := tf.get_u16() + platform_specific_id := tf.get_u16() + offset := tf.get_u32() + dprintln('CMap platform_id=$platform_id specific_id=$platform_specific_id offset=$offset') + if platform_id == 3 && platform_specific_id <= 1 { + tf.read_cmap(table_offset + offset) + } + } +} + +fn (mut tf TTF_File) read_cmap(offset u32) { + old_pos := tf.pos + tf.pos = offset + format := tf.get_u16() + length := tf.get_u16() + language := tf.get_u16() + + dprintln(' Cmap format: $format length: $length language: $language') + if format == 0 { + dprintln(' Cmap 0 Init...') + mut cmap := TrueTypeCmap{} + cmap.init_0(mut tf) + tf.cmaps << cmap + } else if format == 4 { + dprintln(' Cmap 4 Init...') + mut cmap := TrueTypeCmap{} + cmap.init_4(mut tf) + tf.cmaps << cmap + } + + tf.pos = old_pos +} + +/****************************************************************************** +* +* CMAPS 0/4 +* +******************************************************************************/ +fn (mut tf TTF_File) map_code(char_code int) u16 { + mut index := 0 + for i in 0 .. tf.cmaps.len { + mut cmap := tf.cmaps[i] + if cmap.format == 0 { + // dprintln("format 0") + index = cmap.map_0(char_code) + } else if cmap.format == 4 { + // dprintln("format 4") + index = cmap.map_4(char_code, mut tf) + } + } + return u16(index) +} + +fn (mut tm TrueTypeCmap) init_0(mut tf TTF_File) { + tm.format = 0 + for i in 0 .. 256 { + glyph_index := tf.get_u8() + dprintln(' Glyph[$i] = %glyph_index') + tm.arr << glyph_index + } +} + +fn (mut tm TrueTypeCmap) map_0(char_code int) int { + if char_code >= 0 && char_code <= 255 { + // dprintln("charCode $char_code maps to ${tm.arr[char_code]}") + return tm.arr[char_code] + } + return 0 +} + +fn (mut tm TrueTypeCmap) init_4(mut tf TTF_File) { + tm.format = 4 + + // 2x segcount + seg_count := tf.get_u16() >> 1 + // search_range := + tf.get_u16() + // entry_selector := + tf.get_u16() + // range_shift := + tf.get_u16() + + // Ending character code for each segment, last is 0xffff + for _ in 0 .. seg_count { + tm.segments << Segment{0, 0, tf.get_u16(), 0} + } + + // reservePAD + tf.get_u16() + + // starting character code for each segment + for i in 0 .. seg_count { + tm.segments[i].start_code = tf.get_u16() + } + + // Delta for all character codes in segment + for i in 0 .. seg_count { + tm.segments[i].id_delta = tf.get_u16() + } + + // offset in bytes to glyph indexArray, or 0 + for i in 0 .. seg_count { + ro := u32(tf.get_u16()) + if ro != 0 { + tm.segments[i].id_range_offset = tf.pos - 2 + ro + } else { + tm.segments[i].id_range_offset = 0 + } + } + /* + // DEBUG LOG + for i in 0..seg_count { + seg := tm.segments[i] + dprintln(" segments[$i] = $seg.start_code $seg.end_code $seg.id_delta $seg.id_range_offset") + } + */ +} + +fn (mut tm TrueTypeCmap) map_4(char_code int, mut tf TTF_File) int { + // dprintln("HERE map_4 for char [$char_code]") + old_pos := tf.pos + if tm.cache[char_code] == -1 { + // dprintln("Not found, search for it!") + mut found := false + for segment in tm.segments { + if segment.start_code <= char_code && segment.end_code >= char_code { + mut index := (segment.id_delta + char_code) & 0xffff + if segment.id_range_offset > 0 { + glyph_index_address := segment.id_range_offset + + 2 * u32(char_code - segment.start_code) + tf.pos = glyph_index_address + index = tf.get_u16() + } + + tm.cache[char_code] = index + found = true + break + } + } + if !found { + tm.cache[char_code] = 0 + } + } + tf.pos = old_pos + return tm.cache[char_code] +} + +/****************************************************************************** +* +* Hhea table +* +******************************************************************************/ +fn (mut tf TTF_File) read_hhea_table() { + dprintln('*** READ HHEA TABLE ***') + assert 'hhea' in tf.tables + table_offset := tf.tables['hhea'].offset + tf.pos = table_offset + + // version := + tf.get_fixed() // 0x00010000 + + tf.ascent = tf.get_fword() + tf.descent = tf.get_fword() + tf.line_gap = tf.get_fword() + tf.advance_width_max = tf.get_ufword() + tf.min_left_side_bearing = tf.get_fword() + tf.min_right_side_bearing = tf.get_fword() + tf.x_max_extent = tf.get_fword() + tf.caret_slope_rise = tf.get_i16() + tf.caret_slope_run = tf.get_i16() + tf.caret_offset = tf.get_fword() + tf.get_i16() // reserved + tf.get_i16() // reserved + tf.get_i16() // reserved + tf.get_i16() // reserved + tf.metric_data_format = tf.get_i16() + tf.num_of_long_hor_metrics = tf.get_u16() +} + +/****************************************************************************** +* +* Kern table +* +******************************************************************************/ +struct Kern0Table { +mut: + swap bool + offset u32 + n_pairs int + kmap map[u32]i16 + old_index int = -1 +} + +fn (mut kt Kern0Table) reset() { + kt.old_index = -1 +} + +fn (mut kt Kern0Table) get(glyph_index int) (int, int) { + mut x := 0 + + if kt.old_index >= 0 { + ch := ((u32(kt.old_index & 0xFFFF) << 16) | u32(glyph_index & 0xFFFF)) + // dprintln("kern_get: $ch") + if ch in kt.kmap { + x = int(kt.kmap[ch]) + } + } + kt.old_index = glyph_index + if kt.swap { + return 0, x + } + return x, 0 +} + +fn (mut tf TTF_File) create_kern_table0(vertical bool, cross bool) Kern0Table { + offset := tf.pos + n_pairs := tf.get_u16() + search_range := tf.get_u16() + entry_selector := tf.get_u16() + range_shift := tf.get_u16() + dprintln('n_pairs: $n_pairs search_range: $search_range entry_selector: $entry_selector range_shift: $range_shift') + + mut kt0 := Kern0Table{ + swap: (vertical && !cross) || (!vertical && cross) + offset: offset + n_pairs: n_pairs + } + + for _ in 0 .. n_pairs { + left := tf.get_u16() + right := tf.get_u16() + value := tf.get_fword() + tmp_index := (u32(left) << 16) | u32(right) + kt0.kmap[tmp_index] = value + // dprintln("index: ${tmp_index.hex()} val: ${value.hex()}") + } + kt0.old_index = -1 + return kt0 +} + +fn (mut tf TTF_File) read_kern_table() { + dprintln('*** READ KERN TABLE ***') + if !('kern' in tf.tables) { + return + } + table_offset := tf.tables['kern'].offset + tf.pos = table_offset + + version := tf.get_u16() // must be 0 + assert version == 0 // must be 0 + n_tables := tf.get_u16() + + dprintln('Kern Table version: $version Kern nTables: $n_tables') + + for _ in 0 .. n_tables { + st_version := tf.get_u16() // sub table version + length := tf.get_u16() + coverage := tf.get_u16() + format := coverage >> 8 + cross := coverage & 4 + vertical := (coverage & 0x1) == 0 + dprintln('Kerning subtable version [$st_version] format [$format] length [$length] coverage: [$coverage.hex()]') + if format == 0 { + dprintln('kern format: 0') + kern := tf.create_kern_table0(vertical, cross != 0) + tf.kern << kern + } else { + dprintln('Unknown format -- skip') + tf.pos = tf.pos + length + } + } +} + +fn (mut tf TTF_File) reset_kern() { + for i in 0 .. tf.kern.len { + tf.kern[i].reset() + } +} + +fn (mut tf TTF_File) next_kern(glyph_index int) (int, int) { + mut x := 0 + mut y := 0 + for i in 0 .. tf.kern.len { + tmp_x, tmp_y := tf.kern[i].get(glyph_index) + x = x + tmp_x + y = y + tmp_y + } + return x, y +} + +/****************************************************************************** +* +* TTF_File Utility +* +******************************************************************************/ +pub fn (tf TTF_File) get_info_string() string { + txt := '----- Font Info ----- +font_family : $tf.font_family +font_sub_family : $tf.font_sub_family +full_name : $tf.full_name +postscript_name : $tf.postscript_name +version : $tf.version +font_revision : $tf.font_revision +magic_number : $tf.magic_number.hex() +flags : $tf.flags.hex() +created unixTS : $tf.created +modified unixTS : $tf.modified +box : [x_min:$tf.x_min, y_min:$tf.y_min, x_Max:$tf.x_max, y_Max:$tf.y_max] +mac_style : $tf.mac_style +----------------------- +' + return txt +} + +/****************************************************************************** +* +* TTF_File test +* +******************************************************************************/ +fn tst() { + mut tf := TTF_File{} + + tf.buf = [ + byte(0xFF), /* 8 bit */ + 0xF1, + 0xF2, /* 16 bit */ + 0x81, + 0x23, + 0x45, + 0x67, /* 32 bit */ + 0x12, + 0x34, + 0x12, + 0x34, /* get_2dot14 16 bit */ + 0x12, + 0x34, + 0x12, + 0x34 /* get_fixed 32 bit int */, + ] + assert tf.get_u8().hex() == 'ff' + assert tf.get_u16().hex() == 'f1f2' + assert tf.get_u32().hex() == '81234567' + + dprintln('buf len: $tf.buf.len') + // dprintln( tf.get_u8().hex() ) + // dprintln( tf.get_u16().hex() ) + // dprintln( tf.get_u32().hex() ) + // dprintln( tf.get_2dot14() ) + // dprintln( tf.get_fixed() ) +} |