Temas y colores

El aspecto de una escena sale de tres capas: el tema activo (colores semánticos, tipografía, reglas por tipo de objeto y tokens de espaciado), el fondo y los estilos que escribes en cada objeto, que siempre ganan.

from gaanim import BLUE, GOLD, Scene

scene = Scene(frame=(16, 9), theme="technical")
circle = scene.geometry.circle(1).fill(BLUE).stroke(GOLD, 0.05)
label = scene.text("Escena con tema", role="title").move_to(0, 2.5)
scene.play([circle.animate.create(), label.animate.write()])
scene.render()

Toda escena empieza con el tema technical: Scene() equivale a Scene(theme="technical"), scene.canvas.theme vale "technical" y el fondo es gris casi negro (#121212), con texto y ejes claros y formas rellenas con el color de acento. Otro tema (Scene(theme=...) o scene.canvas.set_theme(...)) sustituye al predeterminado, un fondo explícito (Scene(background=...)) gana al del tema y los colores que pones en cada objeto ganan a los del tema.

Para un lienzo sin tema, pasa Scene(theme=None) o llama a scene.canvas.set_theme(None). Sin tema el fondo vuelve a ser blanco (salvo que hayas elegido uno) y el texto, las formas y los ejes sin estilo propio son blancos, así que dales color o usa un fondo que contraste; gaanim check avisa cuando no se verían. Sin tema, scene.canvas.color(...) y scene.canvas.validate_theme() lanzan ValueError, y los componentes como badge o card usan los colores de technical.

from gaanim import Scene

scene = Scene(frame=(16, 9), theme=None, background="white")
dot = scene.geometry.circle(1).fill("#2563eb")
label = scene.text("Sin tema", color="black").move_to(0, 2)
scene.render()

Colores

Todo argumento ColorLike acepta un Color, una cadena CSS Color 4 ("#0f172a", "tomato", "oklch(62% 0.2 260)", "rgb(37 99 235 / 65%)") o una tupla (r, g, b) o (r, g, b, a) de enteros de 0 a 255. Una sintaxis inválida o un componente fuera de rango lanzan ValueError.

Para anotar tus propias funciones, importa esos tipos desde gaanim: ColorLike; Paint, que también acepta un Brush; ColorMapLike, y BackgroundLike, que también acepta un Background. Funcionan en el comprobador de tipos y al ejecutar la escena. El resto de alias de los stubs (Padding, TextAlign, Endpoint…) se importa desde gaanim.gaanim_core.

from gaanim import Paint, Scene

def disc(scene: Scene, paint: Paint):
    return scene.geometry.circle(1).fill(paint)

scene = Scene(frame=(16, 9))
disc(scene, "#2563eb").move_to(-2, 0)
disc(scene, (220, 38, 38)).move_to(2, 0)
scene.render()

navy = Color("#0f172a")
accent = Color("oklch(62.3% 0.214 259.815)")
translucent = Color("rgb(37 99 235 / 65%)")
purple = Color(128, 51, 204)
circle = scene.geometry.circle(1).fill(purple)

hexa = Color.from_hex("#ff8800")
rgb = Color.from_rgb(15, 23, 42)
glass = Color.from_rgba(255, 255, 255, 64)
computed = Color.from_hsl(215, 0.9, 0.55, 0.8)
perceptual = Color.from_oklch(0.68, 0.17, 240)

colors.tailwind contiene las 26 familias de Tailwind CSS v4.3.3, con escalas de 50 a 950: colors.tailwind.blue[500] o colors.tailwind["rose"][600]. colors.tailwind.families() las enumera y colors.tailwind.version da la versión incluida.

from gaanim import colors

brand = colors.tailwind.blue[600]
warning = colors.tailwind["amber"][500]
print(len(colors.tailwind.families()), colors.tailwind.version)

26 4.3.3

Constantes de color

Pinceles y gradientes

Drawable.fill(...) y Drawable.stroke(...) aceptan un ColorLike o un Brush reutilizable. Las coordenadas de un gradiente están en el espacio local del objeto, así que la pintura acompaña sus transformaciones. Los colores se reparten uniformemente y hacen falta al menos dos. extend decide qué pasa fuera de la rampa: "pad" (predeterminado) prolonga los extremos, "repeat" la repite y "reflect" la repite en espejo.

Un grupo pasa el pincel a cada miembro, que lo pinta en sus propias unidades locales: un gradiente no cruza el grupo, sino que se repite en cada pieza. Para que un solo gradiente recorra varias formas, únelas con scene.geometry.union(...) o da a cada una un pincel desplazado según su posición.

gradient = Brush.linear(["#7AA2F7", "#BB9AF7", "#F7768E"], start=(-3, 0), end=(3, 0))
card = scene.geometry.rounded_rect(6, 2.75, 0.35).fill(gradient)

orb = scene.geometry.circle(1.5).fill(
    Brush.radial(["white", scene.canvas.color("accent"), "#0000"], center=(-0.375, 0.44), radius=1.875)
)

ring = scene.geometry.circle(1.375).no_fill().stroke(
    Brush.sweep(["#7DCFFF", "#9ECE6A", "#E0AF68", "#F7768E", "#7DCFFF"], center=(0, 0)),
    0.25,
)

animate.fill(paint) y animate.stroke(paint, width) interpolan entre pinturas: dos gradientes del mismo tipo interpolan su geometría y sus colores (con números de paradas distintos, se normalizan sus posiciones), y un color sólido puede convertirse en gradiente y al revés. Cambiar entre tipos incompatibles, como lineal y radial, o entre modos de extend distintos, lanza un error al programar la animación. Consulta Anim.fill.

StrokeStyle agrupa todo un trazo reutilizable; se aplica con Drawable.stroke_style o dentro de un tema.

dashed = StrokeStyle(GOLD, 0.04, cap="butt", dashes=(0.2, 0.1))
guide = scene.geometry.line(-4, 0, 4, 0).stroke_style(dashed)

Fondos

Scene(background=...), scene.canvas.background y scene.segment(..., background=...) aceptan un color, un Brush o un Background. Sus coordenadas son las de la escena: con el marco de 16 × 9, un gradiente lineal de ancho completo va de x=-8 a x=8. El fondo explícito tiene prioridad sobre el del tema.

scene.canvas.background = Color(40, 42, 54)
scene.canvas.background = Brush.linear(["#071022", "#164E8A", "#7DD3FC"], start=(-8, 0), end=(8, 0))

from gaanim import Background, Scene

shader = Background.shader("""
fn gaanim_background(
    uv: vec2<f32>,
    resolution: vec2<f32>,
    time: f32,
) -> vec4<f32> {
    let center = vec2<f32>(0.35 + 0.1 * sin(time), 0.45);
    let glow = exp(-8.0 * distance(uv, center));
    return vec4<f32>(0.02, 0.08 + 0.4 * glow, 0.18 + 0.6 * glow, 1.0);
}
""", fallback="#071022")
scene = Scene(frame=(16, 9), background=shader)

from pathlib import Path
asset_shader = Background.shader(Path("assets/background.wgsl"), fallback="#071022")

source debe definir esta función:

fn gaanim_background(uv: vec2<f32>, resolution: vec2<f32>, time: f32) -> vec4<f32>

• uv=(0, 0) es la esquina superior izquierda y uv=(1, 1) la inferior derecha: uv.y crece hacia abajo, aunque la escena use y hacia arriba. Usa 1.0 - uv.y para trabajar hacia arriba.
• resolution es el tamaño efectivo en píxeles.
• time es la posición absoluta de la línea de tiempo en segundos, así que las búsquedas, las capturas y la exportación son deterministas.
• gaanim_frame_size(resolution) devuelve el tamaño del marco en unidades de la escena (por ejemplo (16, 9)), para dibujar en las mismas unidades que las formas.

El shader cubre el mismo rectángulo de escena que muestra el editor. En el visor se ejecuta en la misma GPU que dibuja la escena y solo se repite cuando cambian el tiempo o el tamaño en píxeles. Las exportaciones y las capturas producen los mismos píxeles.

Fondos vivos

Fondos procedurales listos para usar, construidos sobre Background.shader: se mueven con el tiempo de la línea de tiempo y la misma semilla da siempre la misma imagen. Los colores se mezclan en luz lineal. Un valor inválido lanza ValueError.

FÁBRICABackground.mesh_gradientmesh_gradient(colors, *, speed=0.1, seed=0) -> Background

Manchas suaves de 2 a 8 colors que derivan por órbitas y se mezclan como un mesh gradient. speed escala el movimiento (0 lo congela) y seed elige otra disposición.

Ejemplo

from gaanim import WHITE, Background, Scene
scene = Scene(frame=(16, 9))
scene.canvas.background = Background.mesh_gradient(
    ["#0b1040", "#6a2cc8", "#12b8a6", "#f25f8b"], speed=0.3, seed=4
)
scene.text("Mesh gradient", role="title").fill(WHITE)
scene.wait(2.0)
scene.render()

scene.canvas.background = Background.dot_grid(0.5, radius=0.05, color="#8fa3ff80", drift=(0.25, 0.0))

Postprocesado

Un PostProcess aplica una función WGSL sobre todo lo que la escena dibuja en 2D: fondo, texto, formas, imágenes y Lottie. Se ejecuta en el editor, en el modo presentación, en las capturas y en la exportación, siempre con el tiempo exacto de la línea de tiempo.

from gaanim import PostProcess, Scene

vignette = PostProcess.shader("""
fn gaanim_post(uv: vec2<f32>, resolution: vec2<f32>, time: f32) -> vec4<f32> {
    let color = gaanim_scene(uv);
    let edge = smoothstep(0.9, 0.35, distance(uv, vec2<f32>(0.5)));
    return vec4<f32>(color.rgb * edge, color.a);
}
""")
scene = Scene(frame=(16, 9), post=vignette)

source debe definir esta función:

fn gaanim_post(uv: vec2<f32>, resolution: vec2<f32>, time: f32) -> vec4<f32>

• uv=(0, 0) es la esquina superior izquierda del cuadro de la cámara y uv=(1, 1) la inferior derecha.
• resolution es el tamaño del cuadro en píxeles de salida.
• time es la posición absoluta de la línea de tiempo en segundos.
• gaanim_scene(uv) devuelve el color ya renderizado en ese punto: sRGB con alfa sin premultiplicar. Fuera del cuadro devuelve el píxel más cercano del borde.
• El resultado se limita a [0, 1].

Solo se procesa el cuadro de la cámara. El shader recibe píxeles, así que un radio fijo como 1.0 / 1920.0 cambia con la resolución de salida: para un número de píxeles usa offset / resolution y, para que se vea igual a cualquier resolución, expresa el radio como fracción de uv. También se aplica con una cámara en perspectiva, pero no a la salida SVG.

Uniforms animables y cadenas

Un uniform enlazado a un Parameter se anima como cualquier valor, y el efecto se ve igual en el editor y en la exportación. Varias pasadas se encadenan con una lista: cada una lee con gaanim_scene lo que escribió la anterior.

from gaanim import GOLD, PostProcess, Scene
scene = Scene(frame=(16, 9), background="#0b1020")
amount = scene.viz.parameter(0.0)
split = PostProcess.shader("""
fn gaanim_post(uv: vec2<f32>, resolution: vec2<f32>, time: f32) -> vec4<f32> {
    let shift = vec2<f32>(gaanim_uniforms.amount * 0.02, 0.0);
    let base = gaanim_scene(uv);
    return vec4<f32>(gaanim_scene(uv + shift).r, base.g, gaanim_scene(uv - shift).b, base.a);
}
""", uniforms={"amount": amount})
scene.canvas.post = [split, PostProcess.vignette(0.5)]
ring = scene.geometry.circle(2).no_fill().stroke(GOLD, 0.2)
scene.play([amount.animate.set(1.0).duration(0.5).repeat(2, yoyo=True)])
scene.render()

Presets de acabado

Pasadas listas para usar, sin escribir WGSL. Sus valores aceptan un número o un Parameter para animarlos. Los tamaños se miden en píxeles de un cuadro de 1080 de alto, así que se ven igual a cualquier resolución de salida, y el ruido cambia cada 1/24 s del tiempo de la línea de tiempo, así que un fotograma es siempre el mismo. Un número fuera de rango lanza ValueError.

FÁBRICAPostProcess.halftone / dither / crt / pixelate / glitchhalftone(dot=6.0) · dither(levels=4) · crt(strength=1.0) · pixelate(size=8.0) · glitch(intensity=0.5, seed=0)

halftone: puntos de imprenta en celdas de dot píxeles, más grandes cuanto más clara es la celda. dither: tramado ordenado (Bayer 4×4) a levels valores por canal. crt: pantalla curva, líneas de barrido y máscara RGB. pixelate: bloques de size píxeles. glitch: franjas que saltan de lado con separación RGB 12 veces por segundo; seed cambia el patrón y intensity se puede animar para dar golpes.

Ejemplo

from gaanim import BLUE, GOLD, PostProcess, Scene
scene = Scene(frame=(16, 9), background="#101826")
burst = scene.viz.parameter(0.0)
scene.canvas.post = [PostProcess.glitch(intensity=burst, seed=3), PostProcess.grain(0.05)]
scene.geometry.circle(1.6).fill(GOLD).move_to(-3, 0)
scene.geometry.rounded_rect(3, 3, 0.3).fill(BLUE).move_to(3, 0)
scene.play([burst.animate.set(1.0).duration(0.3).repeat(2, yoyo=True)])
scene.render()

FÁBRICAPostProcess.bloombloom(threshold=0.8, intensity=0.6, radius=0.5) -> PostProcess

Bloom multipaso: lo que supera threshold (brillo sRGB de 0 a 1, con rodilla suave) brilla. Extrae las zonas claras, las reduce en una cadena de mips y las vuelve a sumar con un filtro tienda, como el bloom de Blender. intensity escala la luz añadida y radius (0 a 1) la extiende de un halo ceñido a una neblina amplia. La luz se suma en luz lineal y los núcleos muy brillantes se vuelven blancos en vez de saturarse. Su alcance es una fracción del cuadro, así que se ve igual a cualquier resolución. Complementa el glow vectorial de cada objeto.

Ejemplo

from gaanim import PostProcess, Scene
scene = Scene(frame=(16, 9), background="#05060d")
glow = scene.viz.parameter(0.3)
scene.canvas.post = PostProcess.bloom(threshold=0.55, intensity=glow, radius=0.6)
ring = scene.geometry.circle(1.6).no_fill().stroke("#ff4fd8", 0.12).move_to(-3, 0)
star = scene.geometry.regular_polygon(5, 1.6).no_fill().stroke("#ffe45c", 0.12).move_to(3, 0)
scene.play([ring.animate.create(), star.animate.create()])
scene.play([glow.animate.set(1.4).duration(0.6).repeat(2, yoyo=True)])
scene.render()

MÉTODOCanvas.motion_blurmotion_blur(shutter_angle: Optional[float] = 180.0, samples: int = 8, *, phase: Optional[float] = None) -> None

Desenfoque de movimiento como el de una cámara de cine en las exportaciones y las capturas: cada cuadro promedia en luz lineal samples búsquedas exactas repartidas por el obturador, así que es determinista, y nunca mezcla dos segmentos. La duración del obturador sigue los fps de la exportación (las capturas usan 60). El visor interactivo se ve nítido, y renderizar cuesta samples veces más. Un valor fuera de rango lanza ValueError. Usa drawable.motion_blur(False) para mantener nítido un objeto, y Segment.motion_blur para darle a un segmento su propio obturador.

Parámetros

Nombre	Tipo	Predeterminado	Descripción
shutter_angle	float | None	180.0	Grados de un cuadro que el obturador está abierto, de 0 a 720: 180 es el estándar del cine y 360 difumina todo el cuadro. None lo desactiva.
samples	int	8	Subcuadros promediados por cuadro, de 2 a 64.
phase	float | None	None	Dónde se abre el obturador respecto al tiempo del cuadro, en grados de un cuadro; por defecto se centra en él.

Devuelve: None

Ejemplo

from gaanim import CORAL, GOLD, WHITE, Scene
scene = Scene(frame=(16, 9), background="#101826")
scene.canvas.motion_blur(180, samples=6)
title = scene.text("Motion blur", role="title").fill(WHITE).move_to(0, 3).motion_blur(False)
ball = scene.geometry.circle(0.5).fill(CORAL).move_to(-6, 0)
bar = scene.geometry.rect(4, 0.35).fill(GOLD).move_to(0, -2)
scene.play([ball.animate.move_to(6, 0).duration(0.6), bar.animate.rotate_by(6.2832).duration(1.0)])
scene.render()

from pathlib import Path

vignette = PostProcess.shader(Path("assets/grade.wgsl"))
scene.canvas.post = vignette
scene.segment("intro")                 # hereda scene.canvas.post
scene.wait(0.5)
scene.segment("datos", post=False)     # sin postprocesado
scene.wait(0.5)

Temas

Un tema reúne colores semánticos, tipografía, reglas de estilo por tipo de objeto, paletas de datos y tokens de espaciado. Los componentes (tarjetas, insignias, bandas, gráficas, tablas, paneles de código) toman de él sus colores de primer plano, acento, panel y regla. Un .fill(...) explícito siempre tiene prioridad.

from gaanim import Scene

scene = Scene(frame=(16, 9))
scene.canvas.set_theme("presentation")
title = scene.text("Transformada de Fourier", role="title")
subtitle = scene.text("Representación en frecuencia", role="subtitle").move_to(0, -1)
scene.play([title.animate.write(), subtitle.animate.fade_in()])
scene.render()

Los nombres no distinguen mayúsculas. En el stub, Scene(theme=...), Canvas.set_theme y Theme(base) tipan el nombre como ThemeName, un Literal con los doce nombres y los ocho alias de la tabla, así que el editor los autocompleta. Theme.schemes() devuelve solo los nombres canónicos.

print(Theme.schemes())

['technical', 'presentation', 'paper', 'dracula', 'nord', 'solarized-dark', 'solarized-light', 'gruvbox-dark', 'tokyo-night', 'catppuccin-mocha', 'catppuccin-latte', 'gaanim']

from gaanim import Scene

scene = Scene(frame=(16, 9), theme="technical")
scene.canvas.set_fonts(
    font="Inter",
    math_font="New Computer Modern Math",
    code_font="JetBrains Mono",
)
scene.text("Texto y $x^2$", role="body")
scene.text("fn main() {}", role="code").move_to(0, -1)

panel = scene.geometry.rounded_rect(5.25, 2.25, 0.3) \
    .fill(scene.canvas.color("panel")) \
    .stroke(scene.canvas.color("accent"), 0.04)

teams = ["Norte", "Sur", "Este"]
colors = scene.canvas.palette().colors(len(teams))
dots = [scene.geometry.dot(0.3).fill(color).move_to(index - 1, 0) for index, color in enumerate(colors)]

page = scene.layout.column(
    [title, body],
    padding=scene.canvas.layout_token("page_padding"),
    gap=scene.canvas.layout_token("space_lg"),
)

warnings = scene.canvas.validate_theme()
if warnings:
    raise ValueError("\n".join(warnings))

Temas propios

from gaanim import AxesStyle, Scene, StrokeStyle, Style, TextStyle, Theme, colors

theme = Theme(
    "nord",
    name="mis-diapositivas",
    colors={"title": "#A3D9FF", "accent": "#FFB86C", "chart": "#88C0D0"},
    fonts={"text": "Aleo", "code": "Victor Mono"},
    sizes={"title": 0.72, "body": 0.34},
    text={
        "body": TextStyle(size=0.32, letter_spacing=0.1),
        "label": TextStyle(size=0.24, weight=600),
    },
    styles={
        "shape": Style(fill="accent"),
        "line": Style(stroke=StrokeStyle("foreground", 0.04, cap="round")),
        ".warning": Style(fill=colors.tailwind.rose[600]),
        "axes": AxesStyle(grid=StrokeStyle("rule", 0.01), labels=TextStyle(size=0.24)),
    },
    series=[colors.tailwind.blue[600], colors.tailwind.amber[500]],
    layout={"page_padding": 0.7, "column_gap": 0.6},
    font_files={
        "Aleo": "assets/fonts/Aleo-VariableFont.ttf",
        "Victor Mono": "assets/fonts/VictorMono-VariableFont.ttf",
    },
)
scene = Scene(frame=(16, 9), theme=theme)

Los roles de color incluidos son background, foreground, muted, title, accent, chart, panel, header, rule, success, warning, danger y shadow (la sombra de shadow=True en las cajas: negro suave sobre un fondo claro y casi opaco sobre uno oscuro, salvo que el tema elija otro); colors también acepta tokens propios no vacíos para las reglas. Los tokens code, code_keyword, code_string, code_number, code_comment, code_function y code_type eligen los colores con los que scene.text.code resalta el código; sin ellos, los temas de editores usan su esquema y los demás los derivan de la paleta. Los roles de fuente son text, all, title, subtitle, heading, body, caption, label, math y code.

brand = Theme(
    name="marca",
    colors={
        "background": "#10131A", "foreground": "#F8FAFC", "muted": "#94A3B8",
        "title": "#FDE68A", "accent": "#38BDF8", "chart": "#22C55E",
        "panel": "#18202E", "header": "#202B3D", "rule": "#475569",
    },
    fonts={"text": "Aptos", "code": "Consolas"},
)
print_theme = Theme(brand, name="marca-impresa", colors={"background": "white", "foreground": "#172033"})
plain = Theme("paper", font_dir="assets/fonts", fonts={"text": "Aleo"}, text_markup=False)
scene = Scene(theme=plain)
scene.text("tb:dist_comp")          # literal, sin cursiva
scene.text("*Nota*", markup=True)   # negrita

theme = Theme("nord")
divider = scene.geometry.line(-5, 0, 5, 0).stroke(theme.color("rule"), 0.025)

Reglas por selector

Las claves de styles seleccionan una familia (shape, line, text, glyph para las llaves, axes, plot), el nombre exacto de una fábrica (circle, rounded_rect, arrow), una parte semántica como axes/grid o axes/labels, o una clase propia como .warning, que se asigna con Drawable.style_class. La precedencia es: tema base, familia, tipo exacto o parte semántica, clases en orden, valores del constructor y, por último, los setters del objeto. Las reglas se aplican al compilar, así que cambiar de tema actualiza también los objetos ya creados. La pintura de los recursos importados sigue la de su archivo salvo que la cambies explícitamente.

theme = Theme(
    "paper",
    colors={"brand": "#2563eb", "danger": "oklch(58% .24 25)"},
    styles={"shape": Style(fill="brand"), ".danger": Style(fill="danger")},
)
scene = Scene(theme=theme)
ordinary = scene.geometry.circle(0.75)
warning = scene.geometry.square(1.25).style_class("danger")
explicit = scene.geometry.circle(0.5).fill("gold")

Mapas de color

ColorMap ofrece 39 mapas canónicos de Matplotlib y 39 de Scientific Colour Maps, incluidos en Gaanim: no hace falta Matplotlib ni ningún archivo externo. Los nombres no distinguen mayúsculas. Las posiciones se normalizan a [0, 1]; los mapas continuos interpolan en sRGB y los categóricos conservan escalones. Un nombre, categoría, posición, alfa o lista de colores inválidos lanzan ValueError. Donde un parámetro acepta ColorMapLike, también vale el nombre como cadena.

viridis = ColorMap("viridis")
midpoint = viridis.sample(0.5)
swatches = viridis.colors(8)
reverse = viridis.reversed()

custom = ColorMap.from_colors(["#0f172a", "#06b6d4", "#f8fafc"], positions=[0.0, 0.4, 1.0])
transparent = custom.with_alpha(0.65)

print(ColorMap.names("scientific")[:5])

['acton', 'bam', 'bamako', 'bamO', 'batlow']

Paletas categóricas

Una Palette es una lista ordenada de colores que se reparten entre las categorías por turno: las de un campo color de texto, las porciones de una tarta o las barras de una carrera. La del tema (Theme(palette=...)) colorea toda la escena, y Scale.category().colors(...) la sustituye en un campo concreto. Cuando hay más categorías que colores, la paleta vuelve a empezar y cada vuelta aclara u oscurece un poco sus colores, así que dos categorías nunca comparten color. Donde un parámetro acepta PaletteLike, también vale el nombre de una paleta o una lista de colores.

Incluidas: gaanim (la predeterminada, de diez colores), tableau10, okabe_ito (siete colores distinguibles con daltonismo; sin el negro, que desaparece sobre un fondo oscuro), set2, dark2, paired y los mapas categóricos tab10, tab20, tab20b y tab20c. Los nombres no distinguen mayúsculas.

okabe = Palette("okabe_ito")
brand = Palette(["#7c6cff", GOLD, (40, 180, 160)])
scene = Scene(frame=(16, 9), theme=Theme("gaanim", palette=okabe.rotate(1)))

ramp = Palette.from_colormap("viridis", 5)

Efectos visuales

glow, blur y shadow se aplican a cualquier objeto y funcionan sobre rellenos y trazos, incluidos los gradientes; no_effects() los quita. Están en Drawable y sus versiones animadas en Animaciones.