gpu

Documentation

Overview

Package gpu define la interfaz de dibujo de FlowCode y la aísla del API gráfico concreto que haya debajo.

El modelo es deliberadamente pobre: todo lo que FlowCode pinta —texto, rectángulos, bordes, iconos, cursores— se reduce a cuadriláteros texturizados. Un solo shader, un solo tipo de primitiva y un solo draw call por lote. Esa pobreza es lo que hace posible sostener 120 fps: no hay estado gráfico que reconfigurar entre elementos de la interfaz.

Las coordenadas son píxeles lógicos con el origen arriba a la izquierda. La conversión a píxeles físicos ocurre dentro del backend, una sola vez por frame.

Index

• type Device
• type DrawnQuad
• type FakeDevice
  • func NewFakeDevice() *FakeDevice
  • func (d *FakeDevice) BeginFrame(size geom.Size, scale float32) Frame
  • func (d *FakeDevice) Destroy()
  • func (d *FakeDevice) Info() Info
  • func (d *FakeDevice) LastFrame() *FakeFrame
  • func (d *FakeDevice) NewTexture(w, h int, f PixelFormat) (Texture, error)
  • func (d *FakeDevice) Solid() Texture
  • func (d *FakeDevice) Textures() []*FakeTexture
• type FakeFrame
  • func (f *FakeFrame) Clear(c geom.Color)
  • func (f *FakeFrame) DrawQuads(t Texture, quads []Quad, clip geom.Rect)
  • func (f *FakeFrame) End() Stats
  • func (f *FakeFrame) Fill(r geom.Rect, c geom.Color, clip geom.Rect)
• type FakeTexture
  • func (t *FakeTexture) Destroy()
  • func (t *FakeTexture) Destroyed() bool
  • func (t *FakeTexture) Size() (int, int)
  • func (t *FakeTexture) Upload(x, y, w, h int, pix []byte) error
• type Frame
• type Info
  • func (i Info) String() string
• type PixelFormat
• type Quad
• type Stats
• type Texture

Types

type Device

type Device interface {
	// BeginFrame prepara un fotograma para un área del tamaño lógico dado.
	// scale es la razón entre píxeles físicos y lógicos.
	BeginFrame(size geom.Size, scale float32) Frame

	// NewTexture reserva una textura vacía en la GPU.
	NewTexture(w, h int, f PixelFormat) (Texture, error)

	// Solid devuelve una textura de un píxel blanco y opaco. Sirve para pintar
	// rellenos lisos con la misma primitiva que el texto, y permite que
	// rectángulos y glifos convivan en un mismo lote cuando comparten atlas.
	// Pertenece al dispositivo: no debe liberarse.
	Solid() Texture

	// Info describe el hardware, para diagnósticos y para el registro de
	// arranque.
	Info() Info

	// Destroy libera todos los recursos del dispositivo.
	Destroy()
}

Device es el contexto gráfico de una ventana.

type DrawnQuad

type DrawnQuad struct {
	Quad
	Texture Texture
	Clip    geom.Rect
}

DrawnQuad es un cuadrilátero tal y como llegó al dispositivo, con la textura y el recorte que tenía en ese momento.

type FakeDevice

type FakeDevice struct {
	// contains filtered or unexported fields
}

FakeDevice es una implementación de Device en memoria.

func NewFakeDevice

func NewFakeDevice() *FakeDevice

NewFakeDevice crea un dispositivo que no habla con ninguna GPU: guarda las texturas en memoria y registra los cuadriláteros que se le envían.

Existe porque las máquinas de integración continua no tienen tarjeta gráfica, y sin esto todo lo que hay por encima de gpu —el motor tipográfico, el framework de interfaz, el editor— quedaría sin pruebas automáticas. Con él, la disposición del texto y la composición de la interfaz se verifican comparando la lista de cuadriláteros producida, que es una descripción exacta de lo que se habría pintado.

func (*FakeDevice) BeginFrame

func (d *FakeDevice) BeginFrame(size geom.Size, scale float32) Frame

func (*FakeDevice) Destroy

func (d *FakeDevice) Destroy()

func (*FakeDevice) Info

func (d *FakeDevice) Info() Info

func (*FakeDevice) LastFrame

func (d *FakeDevice) LastFrame() *FakeFrame

LastFrame devuelve el último fotograma dibujado.

func (*FakeDevice) NewTexture

func (d *FakeDevice) NewTexture(w, h int, f PixelFormat) (Texture, error)

func (*FakeDevice) Solid

func (d *FakeDevice) Solid() Texture

func (*FakeDevice) Textures

func (d *FakeDevice) Textures() []*FakeTexture

Textures devuelve todas las texturas creadas, para inspeccionarlas.

type FakeFrame

type FakeFrame struct {
	// Cleared es el último color de borrado, si lo hubo.
	Cleared *geom.Color

	// Drawn conserva, en orden, los cuadriláteros aceptados.
	Drawn []DrawnQuad
	// contains filtered or unexported fields
}

FakeFrame registra todo lo que se dibuja en un fotograma.

func (*FakeFrame) Clear

func (f *FakeFrame) Clear(c geom.Color)

func (*FakeFrame) DrawQuads

func (f *FakeFrame) DrawQuads(t Texture, quads []Quad, clip geom.Rect)

DrawQuads aplica exactamente los mismos descartes que el backend real —fuera de recorte, transparente o vacío—, de modo que lo que registra es lo que de verdad se habría pintado y no lo que el llamante pidió.

El recuento de draw calls no reproduce el agrupamiento en lotes del backend real: aquí cada llamada cuenta como una. Para comprobar el agrupamiento hace falta el backend de OpenGL.

func (*FakeFrame) End

func (f *FakeFrame) End() Stats

func (*FakeFrame) Fill

func (f *FakeFrame) Fill(r geom.Rect, c geom.Color, clip geom.Rect)

type FakeTexture

type FakeTexture struct {
	W, H   int
	Format PixelFormat
	Pix    []byte
	// contains filtered or unexported fields
}

FakeTexture es una textura residente en memoria del proceso.

func (*FakeTexture) Destroy

func (t *FakeTexture) Destroy()

func (*FakeTexture) Destroyed

func (t *FakeTexture) Destroyed() bool

Destroyed indica si la textura fue liberada, para detectar fugas y usos después de liberar en las pruebas.

func (*FakeTexture) Size

func (t *FakeTexture) Size() (int, int)

func (*FakeTexture) Upload

func (t *FakeTexture) Upload(x, y, w, h int, pix []byte) error

type Frame

type Frame interface {
	// Clear borra todo el framebuffer.
	Clear(c geom.Color)

	// Fill pinta un rectángulo liso, recortado a clip.
	Fill(r geom.Rect, c geom.Color, clip geom.Rect)

	// DrawQuads pinta un lote de cuadriláteros de la misma textura, recortados
	// a clip. Pasar muchos de golpe es lo que evita reconfigurar el estado
	// gráfico: una línea de texto entera es una sola llamada.
	DrawQuads(t Texture, quads []Quad, clip geom.Rect)

	// End cierra el fotograma y devuelve sus métricas. A partir de aquí el
	// Frame deja de ser válido.
	End() Stats
}

Frame acumula el dibujo de un fotograma. Las llamadas se agrupan en lotes y solo se envían a la GPU cuando cambia la textura o el recorte, o al terminar.

type Info

type Info struct {
	Vendor   string
	Renderer string
	Version  string
}

Info identifica la implementación de OpenGL en uso.

func (Info) String

func (i Info) String() string

String resume el dispositivo en una línea apta para el log de arranque.

type PixelFormat

type PixelFormat int

PixelFormat es la disposición de memoria de una textura.

const (
	// RGBA8 son cuatro bytes por píxel sin premultiplicar. Es el formato de
	// iconos e imágenes.
	RGBA8 PixelFormat = iota

	// Alpha8 es un byte por píxel, interpretado como cobertura. Es el formato
	// del atlas de glifos: un glifo no tiene color propio, solo dice cuánto
	// cubre cada píxel, y el color lo aporta el vértice.
	Alpha8
)

type Quad

type Quad struct {
	// Dst es el rectángulo de destino en píxeles lógicos.
	Dst geom.Rect

	// Src es la región de la textura de la que se toma el contenido, en
	// píxeles de la textura. Para un relleno liso apunta a un píxel opaco.
	Src geom.Rect

	// Color multiplica al texel. Con una textura de cobertura tiñe el glifo;
	// con una textura de color la modula.
	Color geom.Color
}

Quad es un cuadrilátero texturizado, la única primitiva del renderer.

type Stats

type Stats struct {
	// Quads es el número de cuadriláteros emitidos.
	Quads int

	// DrawCalls es el número de envíos reales a la GPU. Lo ideal es que crezca
	// con el número de texturas y recortes distintos, no con el contenido.
	DrawCalls int

	// CPUTime es lo que tardó la CPU en construir y enviar el fotograma, sin
	// contar lo que la GPU tarde en pintarlo.
	CPUTime time.Duration
}

Stats son las métricas de un fotograma. Existen para que los objetivos de rendimiento del proyecto sean comprobables y no una aspiración: un frame que necesita cientos de draw calls indica que el lote se está rompiendo.

type Texture

type Texture interface {
	// Size devuelve las dimensiones en píxeles.
	Size() (w, h int)

	// Upload sustituye una región de la textura. Los datos deben venir en el
	// formato con el que se creó y ocupar exactamente w*h*bytesPorPíxel.
	Upload(x, y, w, h int, pix []byte) error

	// Destroy libera la memoria de vídeo.
	Destroy()
}

Texture es una imagen residente en la GPU.