etxt

Etxt

O ETXT é um pacote para a renderização de texto vetorial ¹ em Golang, projetada para ser usada com o EbitEngine , o mecanismo de jogo 2D feito por Hajime Hoshi.

Enquanto o EbitEngine já inclui o pacote Ebiten/V2/Text/V2 , o ETXT tem algumas vantagens sobre ele:

• Torna o tamanho do texto fácil de alterar.
• Coloca ênfase em obter o escala de exibição corretamente.
• Livre -se da font.Face para sempre.
• Fornece documentação e exemplos de alta qualidade.
• Ajuda com alguns extras, como ousado falso, oblíquo falso, embalagem básica de linha, fontes incorporadas, quantização de glifos, espaçamento de linha, etc.
• Expõe caches, rasterizadores e sizers para você se adaptar se tiver necessidades mais avançadas.

O que o ETXT não faz:

• Nenhum layout de texto geral. Recursos como bidi, itemização, modelagem, testes gerais de acerto, justificativa e outros não são cobertos e, na maioria dos casos, não são uma meta primária para este pacote.
• Pobre ou nenhum suporte para scripts complexos (por exemplo, árabe) nem layouts de texto vertical (por exemplo, japonês). Observe que as tarifas EBITEN/V2/TEXT/V2 muito melhor nesse sentido.
• Nenhuma das coisas que as pessoas realmente querem: sombras e contornos, correção gama, subpixel antialiasing, quebra de linha de pluxes de cavaleiro, melhor suporte para shaders, etc. Alguns já podem ser falsos, outros serão adicionados no futuro ... mas essa é a situação agora.

Se você não está familiarizado com os termos e conceitos da tipografia, recomendo ler os primeiros capítulos das convenções de Glyph de Freetype; Uma das melhores referências sobre o tópico que você pode encontrar na Internet.

Exemplo de código

Menos conversa e mais código!

 package main

import ( "math" ; "image/color" )
import "github.com/hajimehoshi/ebiten/v2"
import "github.com/tinne26/etxt"
import "github.com/tinne26/fonts/liberation/lbrtserif"

const WordsPerSec = 2.71828
var Words = [] string {
	"solitude" , "joy" , "ride" , "whisper" , "leaves" , "cookie" ,
	"hearts" , "disdain" , "simple" , "death" , "sea" , "shallow" ,
	"self" , "rhyme" , "childish" , "sky" , "tic" , "tac" , "boom" ,
}

// ---- Ebitengine's Game interface implementation ----

type Game struct { text * etxt. Renderer ; wordIndex float64 }

func ( self * Game ) Layout ( winWidth int , winHeight int ) ( int , int ) {
	scale := ebiten . DeviceScaleFactor () // *
	// * ebiten.Monitor().DeviceScaleFactor() in >=v2.7.0
	self . text . SetScale ( scale ) // relevant for HiDPI
	canvasWidth  := int ( math . Ceil ( float64 ( winWidth ) * scale ))
	canvasHeight := int ( math . Ceil ( float64 ( winHeight ) * scale ))
	return canvasWidth , canvasHeight
}

func ( self * Game ) Update () error {
	newIndex := ( self . wordIndex + WordsPerSec / 60.0 )
	self . wordIndex = math . Mod ( newIndex , float64 ( len ( Words )))
	return nil
}

func ( self * Game ) Draw ( canvas * ebiten. Image ) {
	// background color
	canvas . Fill (color. RGBA { 229 , 255 , 222 , 255 })
	
	// get screen center position
	bounds := canvas . Bounds () // assumes origin (0, 0)
	x , y := bounds . Dx () / 2 , bounds . Dy () / 2

	// draw text
	word := Words [ int ( self . wordIndex )]
	self . text . Draw ( canvas , word , x , y )
}

// ---- main function ----

func main () {
	// create text renderer, set the font and cache
	renderer := etxt . NewRenderer ()
	renderer . SetFont ( lbrtserif . Font ())
	renderer . Utils (). SetCache8MiB ()
	
	// adjust main text style properties
	renderer . SetColor (color. RGBA { 239 , 91 , 91 , 255 })
	renderer . SetAlign ( etxt . Center )
	renderer . SetSize ( 72 )

	// set up Ebitengine and start the game
	ebiten . SetWindowTitle ( "etxt/examples/ebiten/words" )
	err := ebiten . RunGame ( & Game { text : renderer })
	if err != nil { panic ( err ) }
}

Você pode tentar executar isso você mesmo com ² :

 go run github.com/tinne26/etxt/examples/ebiten/words@latest

Como alternativa, você pode acessar https://tinne26.github.io/etxt-examples/ e clicar no primeiro exemplo da versão da Web.

Este é um exemplo muito simples e independente. Se você quiser aprender mais, verifique o ETXT/Exemplos!

Posso usar este pacote sem EbitEngine?

Sim, você pode compilá -lo com -tags gtxt . Observe que gtxt fará com que o desenho de texto ocorra na CPU; portanto, não tente usá-lo para aplicativos em tempo real. Em particular, tenha cuidado para não usar acidentalmente gtxt com o EbitEngine (eles são compatíveis em muitos casos, mas o desempenho morrerá).

Testes, contribuições e outros

• Para testes, consulte as instruções no etxt/test .
• Se você tiver alguma dúvida ou sugestão para melhorias, fique à vontade para falar, sempre fico feliz em explicar ou discutir.
• Caso contrário, não estou procurando contribuidores nem ajuda geral.

Notas de rodapé

1. Se você estiver usando fontes vetoriais do tipo pixel-AART, leia essas dicas. ↩

2. Você precisará de Golang> = 1,18 e, se nunca já usou o EbitEngine antes, pode ser necessário instalar algumas dependências (normalmente apenas no Linux ou FreeBSD). ↩