Initial project import

tools/v/vlib/x/ttf/common.v

@@ -0,0 +1,209 @@
+module ttf
+
+/**********************************************************************
+*
+* Common data for the module
+*
+* 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:
+*
+* TODO:
+**********************************************************************/
+import os
+import math
+
+// text align
+pub enum Text_align {
+	left
+	center
+	right
+	justify
+}
+
+// draw style
+pub enum Style {
+	outline
+	outline_aliased
+	filled
+	raw
+}
+
+/******************************************************************************
+*
+* DEBUG Utility
+*
+******************************************************************************/
+
+// dprintln prints the `txt` message, *only* when `-d debug_flag` is passed while compiling a program
+@[if debug_flag ?]
+pub fn dprintln(txt string) {
+	println(txt)
+}
+
+/******************************************************************************
+*
+* Utility
+*
+******************************************************************************/
+// format_texture transforms the bitmap from one layer to color layers
+pub fn (mut bmp BitMap) format_texture() {
+	r := u8(bmp.color >> 24)
+	g := u8((bmp.color >> 16) & 0xFF)
+	b := u8((bmp.color >> 8) & 0xFF)
+	a := u8(bmp.color & 0xFF)
+
+	b_r := u8(bmp.bg_color >> 24)
+	b_g := u8((bmp.bg_color >> 16) & 0xFF)
+	b_b := u8((bmp.bg_color >> 8) & 0xFF)
+	b_a := u8(bmp.bg_color & 0xFF)
+
+	// transform buffer in a texture
+	x := bmp.buf
+	unsafe {
+		mut i := 0
+		for i < bmp.buf_size {
+			data := x[i]
+			if data > 0 {
+				x[i + 0] = r
+				x[i + 1] = g
+				x[i + 2] = b
+				// alpha
+				x[i + 3] = u8(u16(u16(a) * data) >> 8)
+			} else {
+				x[i + 0] = b_r
+				x[i + 1] = b_g
+				x[i + 2] = b_b
+				x[i + 3] = b_a
+			}
+			i += 4
+		}
+	}
+}
+
+// save_as_ppm saves the `BitMap` data in .ppm file format to `file_name`.
+pub fn (mut bmp BitMap) save_as_ppm(file_name string) {
+	tmp_buf := bmp.buf
+	mut buf := unsafe { malloc_noscan(bmp.buf_size) }
+	unsafe { vmemcpy(buf, tmp_buf, bmp.buf_size) }
+	bmp.buf = buf
+
+	bmp.format_texture()
+	npixels := bmp.width * bmp.height
+	mut f_out := os.create(file_name) or { panic(err) }
+	f_out.writeln('P3') or { panic(err) }
+	f_out.writeln('${bmp.width} ${bmp.height}') or { panic(err) }
+	f_out.writeln('255') or { panic(err) }
+	for i in 0 .. npixels {
+		pos := i * bmp.bp
+		unsafe {
+			c_r := bmp.buf[pos]
+			c_g := bmp.buf[pos + 1]
+			c_b := bmp.buf[pos + 2]
+			f_out.write_string('${c_r} ${c_g} ${c_b} ') or { panic(err) }
+		}
+	}
+	f_out.close()
+
+	unsafe {
+		free(buf)
+	}
+	bmp.buf = tmp_buf
+}
+
+// get_raw_bytes returns the raw bytes of the bitmap.
+pub fn (mut bmp BitMap) get_raw_bytes() []u8 {
+	mut f_buf := []u8{len: bmp.buf_size / 4}
+	mut i := 0
+	for i < bmp.buf_size {
+		unsafe {
+			f_buf[i >> 2] = *(bmp.buf + i)
+		}
+		i += 4
+	}
+	return f_buf
+}
+
+// save_raw_data saves the raw data to `file_name`.
+pub fn (mut bmp BitMap) save_raw_data(file_name string) {
+	os.write_file_array(file_name, bmp.get_raw_bytes()) or { panic(err) }
+}
+
+//
+// Math functions
+//
+// integer part of x
+@[inline]
+fn ipart(x f32) f32 {
+	return f32(math.floor(x))
+}
+
+@[inline]
+fn round(x f32) f32 {
+	return ipart(x + 0.5)
+}
+
+// fractional part of x
+@[inline]
+fn fpart(x f32) f32 {
+	return x - f32(math.floor(x))
+}
+
+@[inline]
+fn rfpart(x f32) f32 {
+	return 1 - fpart(x)
+}
+
+/******************************************************************************
+*
+* Colors
+*
+******************************************************************************/
+
+// @[inline]
+// pub fn (mut dev BitMap) get_color(x int, y int) (int, int, int, int){
+// 	if x < 0 || x >= dev.width || y < 0 || y >= dev.height {
+// 		return 0,0,0,0
+// 	}
+// 	mut i := (x + y * dev.width)*dev.bp
+// 	unsafe{
+// 		return dev.buf[i], dev.buf[i+1], dev.buf[i+2], dev.buf[i+3]
+// 	}
+// }
+
+// @[inline]
+// pub fn (mut dev BitMap) get_color_u32(x int, y int) u32{
+// 	r, g, b, a := dev.get_color(x, y)
+// 	unsafe{
+// 		return u32(r<<24) | u32(g<<16) | u32(b<<8) | u32(a)
+// 	}
+// }
+
+/******************************************************************************
+*
+* Drawing
+*
+******************************************************************************/
+
+// color_multiply_alpha multiplies color `c`'s alpha channel with the `level` value.
+@[inline]
+pub fn color_multiply_alpha(c u32, level f32) u32 {
+	return u32(f32(c & 0xFF) * level)
+}
+
+// color_multiply multiplies R,G,B channels of color `c` with the `level` value.
+@[inline]
+pub fn color_multiply(c u32, level f32) u32 {
+	mut r := (f32((c >> 24) & 0xFF) / 255.0) * level
+	mut g := (f32((c >> 16) & 0xFF) / 255.0) * level
+	mut b := (f32((c >> 8) & 0xFF) / 255.0) * level
+	mut a := (f32(c & 0xFF) / 255.0) * level
+	r = if r > 1.0 { 1.0 } else { r }
+	g = if g > 1.0 { 1.0 } else { g }
+	b = if b > 1.0 { 1.0 } else { b }
+	a = if a > 1.0 { 1.0 } else { a }
+
+	return (u32(r * 255) << 24) | (u32(g * 255) << 16) | (u32(b * 255) << 8) | u32(a * 255)
+}