Demo Construction Kit

Scrolltext / commandes / sprites

Deux fonts, des commandes et des sprites indépendants

Les lettres entrent progressivement depuis le bord droit. Chaque font garde ses dimensions et son ordre de caractères ; les commandes changent la vitesse ou mettent le texte en pause. Les sprites continuent à rebondir grâce à leur propre file de recyclage.

L’avance des lettres, l’alignement, les rampes de vitesse, les pauses, la population, l’écartement en profondeur et les tailles sont paramétrables. La projection et les déformations restent des recettes modifiables, avec un ordre de calques choisi.

scroll, _ := scrolling.New(scrolling.Config{
    Insertion: &scrolling.InsertionConfig{
        Fonts: faces, Y: 325,
        Program: scrolltext.InsertionProgramConfig{
            Tokens: tokens,
            Speed: 4, TargetSpeed: 4,
            Entry: 640, OnCommand: controls,
        },
    },
})

Objets / matrices / matériaux

Trois objets, un moteur paramétrable

Trois objets partagent un modèle et une palette de lignes, avec une couleur différente pour chacune des six faces, leurs propres rotations et profondeurs. Le moteur gère les matrices entières, la projection, les faces visibles, le clipping et les matériaux. Une même pose calculée peut servir à plusieurs copies.

Les tables angulaires, arrondis, centres, modes de division, palettes, coordonnées de texture et instances sont configurables. Ce calcul conserve les particularités des anciennes machines ; le moteur Mesh habituel reste disponible pour la caméra et les éclairages en virgule flottante.

Images / points / signaux

Une banque, plusieurs palettes et des points projetés

Une seule image indexée apparaît avec deux palettes. Deux plans de points se superposent : à gauche les collisions utilisent OR, à droite XOR. Des barres en dégradé affichent les niveaux d’un vumètre. Chaque couche garde ses paramètres et peut être réutilisée dans une autre composition.

Les couleurs, la projection, le nombre de points, les règles de collision et la décroissance des niveaux sont configurables. Cet exemple utilise des registres YM synthétiques ; une démo peut fournir ceux de sa musique ou d’autres signaux. Le dessin réutilise les états préparés sans lecture des pixels du GPU.

Fontes vectorielles / trois projections

Sinus, zoom, anneau et perspective

Deux fontes vectorielles alternent sur un scrolltext qui ondule et grossit. Sur le même écran, un anneau de texte rose tourne tandis qu’un troisième texte bleu se projette en perspective. Trois instances de scrolling.New partagent les mêmes banques de contours ; leurs réglages et leurs projections définissent chaque rendu.

Chaque instance choisit sa fonte, sa couleur, son déphasage et sa vitesse. TablePolar transforme un angle et un rayon en position ; RationalGrid règle la projection par ses coefficients. Les contours et la table sont préparés une seule fois, puis le dessin réutilise ses buffers. Les fontes peuvent aussi être associées à Face.Contours pour utiliser du texte avec des caractères de contrôle.

text, _ := scrolling.New(scrolling.Config{
    Glyphs: glyphs, Speed: 110, Gap: 24,
    Y: 76, Repeat: true, Shape: "flat",
    Modes: map[string]scrolling.Mode{
        "flat": {
            Contours: &scrolling.ContourPainterConfig{
                Fonts: fonts, Font: "square",
            },
            Map: scrolling.Chain(
                scrolling.Sine(motion.Wave{
                    Amplitude: 14, Spatial: .022, Speed: 2,
                }).Map, zoomAndTint),
        },
    },
})

Composition / projet JSON

Un projet sauvegardé, plusieurs traitements

Un CRT et un reflet traitent la seule couche de texte ; une loupe traite ensuite la scène complète, avec ses huit sprites et son fond animé. L’ordre des passes, leurs paramètres et leurs fenêtres sont sauvegardés dans le JSON. Ici, la loupe revient sept secondes sur neuf, sur ordinateur comme sur Pixel.

{
  "kind": "magnifier",
  "window": {
    "start": 1, "duration": 7,
    "fadeIn": 0.5, "fadeOut": 0.5
  },
  "period": 9,
  "magnifier": {
    "center": {"x": 320, "y": 222},
    "radius": 72, "zoom": 1.7
  }
}

Fond / répétition finie

Trois colonnes, deux rangées

Grodan superpose deux fonds qui bougent indépendamment. Les limites de copies préservent les bords vides et l’écart de deux pixels entre les rangées, sans construire une grande texture.

cfg := composite.BackgroundConfig{
    PeriodX: 640, PeriodY: 400,
    CopiesX: 3, CopiesY: 2,
}
back, _ := composite.NewBackground(cfg)
back.DrawAt(screen, image, x, y)

Fond / vitesse

Une bande infinie sans compteur local

Dans Cuddly Fullscreen, une bande de 16 pixels se répète sur toute la largeur. Sa vitesse est un paramètre du calque, indépendant du texte et du logo placés devant.

back, _ := composite.NewBackground(
    composite.BackgroundConfig{
        Source: image.Rect(0, 0, 16, strip.Bounds().Dy()),
        PeriodX: 16,
    })
layer := &composite.BackgroundLayer{
    Renderer: back, Image: strip,
    Pose: composite.BackgroundPose{Y: 52},
    VelocityX: -240,
}
layer.Update(frame)
layer.Draw(screen)

Sprites / formation harmonique

Douze sprites, deux horloges

Grodan fait suivre aux douze sprites des phases différentes, avec deux vitesses et une amplitude verticale qui rebondit. La même formation anime les logos lumineux de MegaTwist et les lettres à phases irrégulières de Beat Dis et du LED Scroller.

formation, _ := motion.NewHarmonicFormation(
    presets.GrodanSpriteFormationConfig())
group, _ := sprites.NewGroup(sprites.GroupConfig{
    Frames: frames, Count: len(frames), FrameStride: 1,
    Harmonic: formation,
    HarmonicClockStep: [2]float64{.02, .03},
    HarmonicEnvelope: &motion.BounceBankConfig{
        Start: []float64{0}, Velocity: []float64{.1},
        Min: -50, Max: 50,
    },
})
group.Update(frame)
group.Draw(screen)

Sprites / trajectoires individuelles

Treize lettres, treize chemins

Dans Replicants, les treize lettres suivent les coordonnées du programme Atari d’origine : va-et-vient rapides, vagues et traversées en arc. Après une courte entrée, quatorze séquences composent une boucle de 25,46 secondes, au rythme original de 50 images par seconde. DCK gère les positions de chaque sprite ; les chemins, le rythme et les images peuvent être remplacés pour créer une autre formation.

// cycle: 1,273 poses of 13 XY points from native-motion.json.
// Each FormationFrame holds its pose with Ease returning 0.
formation, _ := motion.NewKeyframedFormation(
    motion.KeyframedFormationConfig{
        Count: len(letters), Loop: 25.46,
        Frames: cycle,
    })
nativeClock := func(seconds float64, index int) motion.Point {
    tick := int64(math.Floor(seconds*50 + 1e-9))
    return formation.At(float64(tick%1273)/50, index)
}
group, _ := sprites.NewGroup(sprites.GroupConfig{
    Frames: letters, Count: len(letters),
    FrameStride: 1, Formation: nativeClock, Speed: 1,
})

Sprites / musique

Trois boules, trois voix YM

Dans Delta Force, chaque voix du morceau déclenche sa propre séquence de huit images. Une banque DCK gère les changements de niveau, les décroissances et les positions sans boucle d'animation dans l'écran. Les canaux, les images et les enveloppes restent réglables ; des signaux de module ou de PCM peuvent aussi déclencher les sprites sur un seuil montant.

config, _ := presets.UnionDeltaVoiceBalls(ballAtlas)
balls, _ := sprites.NewSignalFrameBank(config)
if registers, ok := music.YMRegisters(); ok {
    balls.StepYM(registers[8:11])
}
balls.Draw(scene)

Scrolling / bandes déformées

Le texte suit deux passes de bandes

Dans 3D DOC, des bandes de deux pixels déplacent le texte selon une table, puis une seconde passe ajoute un mouvement vertical. Le même moteur lit des colonnes fractionnaires dans les deux fontes de Cuddly 3D DOC ; la fonte, la table, l’épaisseur et les vitesses restent réglables.

cfg := composite.RowWarpConfig{
    Mode: composite.RowWarpDestinationX,
    Thickness: 2, Wave: presets.DOCRowWave(),
    WaveStep: 1, VerticalBase: 30,
    VerticalAmplitude: 30, VerticalDivisor: 20,
    VerticalStep: 1.2,
}
warp, _ := composite.NewRowWarp(cfg)
warp.Step()
warp.DrawInto(rows, textSurface)

Logo / onde par ligne

Le logo ondule vraiment

Dans Multi-Plane, chaque ligne du logo Carebears lit un point différent de la table sinus. Le décalage d’un échantillon par ligne crée l’ondulation ; l’amplitude, la vitesse, l’image source et le cadrage restent modifiables. La composition DCK ajoute les montagnes, le scroller 3D et le petit logo retourné.

wave, _ := motion.CompileWaveTable(
    presets.TCBLogoWaveSections()...)
rows := presets.TCBLogoRowProfile(wave, 303)
rows.RowStep = 1
rows.ScaleX, rows.ScaleY = 2, 2
rows.OutputX, rows.OutputY = 64, 60
logoRows, _ := composite.NewProfileImage(
    logo.SubImage(image.Rect(0, 16, 303, 48)).(*ebiten.Image), rows)
logoRows.Advance()
logoRows.Draw(screen)

Scrolling / profondeur

Quatre textes en pseudo-3D

Viva TCB partage une seule fonction de scrolling pour quatre textes indépendants. Chaque banque garde sa vitesse, sa hauteur et son inversion de profondeur ; les phases X, Y et Z, le nombre de caractères visibles et le clipping sont réglables sans changer la fonte.

cfg := presets.VivaPseudo3D(face, nil,
    [4]string{text1, text2, text3, text4}, 768, 540)
cfg.Banks[0].BaseY = 500
cfg.Pose.XAmplitude = 32
scroll, _ := scrolling.New(
    scrolling.Config{Pseudo3D: &cfg})
scroll.Update(frame)
scroll.Draw(screen)

Titre / raster animé

Un titre, deux modes de rendu

Le titre Viva combine deux rasters mobiles et une troisième répétition. DCK peut les composer sur une petite surface ou les dessiner directement dans une zone découpée, comme dans Multiscreen. Une horloge à attente déclenche ensuite sa trajectoire cosinusoïdale.

material, _ := composite.NewRasterTitle(
    presets.VivaRasterTitleCanvas(title, raster))
clock, _ := motion.NewWaveClock(
    presets.VivaTitleMotion(768, 970))
clock.Step()
material.Step()
material.DrawAt(screen, clock.At(0), 14)

Rotozoom / texture répétée

Un fond qui tourne et grossit

Viva TCB répète une seule tuile avec un quadrilatère graphique. Un programme DCK enchaîne l’entrée, l’orbite, le zoom et la rotation ; vitesse, amplitude et déphasage sont réglables séparément.

motion, _ := presets.NewVivaRotozoom(
    presets.DefaultVivaRotozoomConfig(768, 540))
cfg := composite.RotozoomBackgroundConfig{
    Image: tile, Program: motion,
}
background, _ := composite.NewRotozoomBackground(cfg)
background.Update(frame)
background.Draw(screen)

Fond / déformation par lignes

Une vague différente par ligne

MegaTwist échantillonne 276 lignes d’une petite texture répétée. Le programme de décalage horizontal et le rebond vertical avancent à des rythmes indépendants du scrolltext placé au-dessus.

background, _ := composite.NewScanlineBackground(
    composite.ScanlineBackgroundConfig{
        Tile: tile, Program: wave,
        Width: 416, Height: 276,
        SurfaceWidth: 672, SurfaceHeight: 64,
        BaseX: 80, WaveDivisor: 2, WaveStep: 5,
        BounceAmplitude: 30, BounceRate: .1,
        AlternateDiagonal: true,
    })

Rotozoom / pixels indexés

Le rotozoomer de Second Reality

Cet écran utilise le même principe de rotation et de zoom que Viva, avec un échantillonnage différent : texture indexée 256 × 256, calculs en point fixe et bouclage sur 16 bits. DCK conserve ces règles pour restituer les pixels d’origine.

roto, _ := indexed.NewRotozoom256(
    indexed.Rotozoom256Config{
        Width: 160, Height: 100,
    })
roto.Render(dst, picture, rotated,
    x, y, xa, ya)

Rasters / deux horloges

Des barres colorées qui se croisent

Bilizir anime 300 barres sur tout l’écran avec deux phases indépendantes. Le même composant dessine 36 bandes dans le titre de Coco et sa scène Multiscreen, avec une vitesse fractionnaire et un autre mode de rendu.

cfg := presets.BilizirCopperBars(
    image, 600, composite.CopperQuads,
    composite.MaskedClock)
bars, _ := composite.NewCopperBars(cfg)
bars.Update(frame)
bars.Draw(screen)

Raster / masque animé

Colorer un scrolling sans le redessiner

Big Sprite applique un raster mobile sur les lettres avec SourceAtop : leur transparence reste intacte. Le même effet sert Starwars avec SourceIn et plusieurs écrans Union, sans ajouter de grande surface de rendu.

raster, _ := composite.NewRasterOverlay(
    composite.RasterOverlayConfig{
        Image: colors, ScaleX: 85, ScaleY: 1,
        Alpha: 1, VelocityY: -2,
        WrapY: &composite.RasterWrap{
            Boundary: -177, Restart: 0,
            Inclusive: true,
        },
        Filter: ebiten.FilterLinear,
        Blend: ebiten.BlendSourceAtop,
    })
raster.Draw(textSurface)
raster.Step()

Scrolling / fonte

Un scrolling qui entre progressivement

TeamG1 introduit les glyphes au bord de sa scène de 640 pixels, puis décale le ruban de six pixels par image. La largeur de sortie, la fonte, l’ordre des caractères et la vitesse restent réglables ; avant le CRT, les images correspondent à celles de la version Go d’origine.

feed := scrolling.FeedConfig{
    Font: atlas, Text: message,
    Width: 768, Height: 72,
    InsertX: 640, Scale: 2, Speed: 6,
    UppercaseASCII: true,
}
scroll, _ := scrolling.New(
    scrolling.Config{Feed: &feed})

Vectorballs / forme

Un cube construit avec des boules

La fabrique DCK fournit les points du cube, ses segments et son remplissage. Un atlas prépare quinze palettes et sept tailles de boules ; le projecteur lit directement les points animés. Le même écran peut choisir une pyramide, un plan ou un drapeau et ajouter un reflet.

points, _ := sprites.Cube(
    sprites.CubeConfig{
        Size: 640, Segments: 6,
        Fill: sprites.Edges,
        Image: 120,
    })

Calques / post-traitement

Reflet, puis loupe temporaire

L’exemple Effects Lab assemble logo, scrolling sur trajectoire et fond étoilé. Un pipeline applique le reflet à la scène, puis la loupe pendant une fenêtre de temps, avec deux surfaces réutilisées.

waterCfg := composite.DefaultWaterReflectionConfig()
waterCfg.Wave.Amplitude = 4
reflection, _ := composite.NewWaterReflection(waterCfg)
lens, _ := composite.NewMagnifier()
// Apply reflection before lens in kit.NewPipeline.