
English: 
Over the past years, I have gotten many, many
comments and questions about how I create
my videos, so I'm going to make a few videos
to show how everything is done.
I'm doing this to satisfy everyone's curiousity,
and to share my methods so that others can
give it a try on their own to make some visualizations
that I might never get around to doing.
In this video I'll show how I sync up video
elements with gameplay footage like you see
in these examples.
The programs I use on my end are BizHawk and
After Effects, but its possible to get this
kind of workflow on other programs.
BizHawk runs the game and has a built in lua
scripting engine which allows it to run custom
code while the game is running to collect
information about what is going on.
And After Effects is good for interpretting
the data output by the lua script and combining
it with the captured video footage of the
game.
The first step is to record the video footage
that shows off the particular event or characteristic
I want.
At this point, I'll just record an emulator
movie, that way I can use save states during

French: 
Au cours des dernières années, j'ai eu beaucoup, beaucoup de commentaires et de questions sur comment je crée
mes vidéos. Je vais donc faire quelques vidéos montrant comment je fais.
Je fais cela pour satisfaire la curiosité de chacun, et pour partager mes méthodes afin que d'autres puissent
créer des visualisations que je n'aurais moi-même pas le temps de faire.
Dans cette vidéo, je vous montrerai comment je synchronise des éléments avec une vidéo de gameplay, comme
dans ces exemples.
Les programmes que j’utilise de mon côté sont BizHawk et After Effects, mais il est possible d'obtenir
le même effet avec d'autres programmes.
BizHawk exécute le jeu et possède un interpréteur Lua qui permet de faire tourner
du code personnalisé qui recueille des données sur ce qui se passe.
Et After Effects est utile pour interpréter
les données crées par le script Lua, et les combiner
avec la vidéo du jeu.
La première étape consiste à enregistrer la séquence vidéo qui montre l'évènement ou la chose
que je veux expliquer.
À ce stade, j'enregistre une séquence dans l'émulateur, ce qui me permet d'utiliser des save states

English: 
the recording to make sure I get exactly what
I want to show.
Having an emulator movie is also good so that
I can go back and extract even more data from
the same video if I forget something at first.
If I just made a video recording, I wouldn't
be able to poke around in the memory more
than once.
In this example, I am just going to have the
sprite ID and sprite slot number hovering
over each sprite.
I try to make the video eye catching--like
I could just have Toad stand still here and
you could see the Shy Guys walk by but that's
kind of boring.
Maybe I can show off how these logs are actually
sprites, and how the sprites are spawned when
you pick things up off of the ground.
And then for good measure I can go in this
door just to show how everything unloads and
new sprites are loaded during a room transition.
That's enough for now.
Next step is to get a list of all the game
variables I need to make the video work the
way I want.
For this video, I need the sprite's ID and
slot number.
Chances are, all of the sprites' IDs are stored
in a table in memory, in order of slot number.

French: 
afin d'obtenir exactement ce que je veux.
Utiliser un émulateur est également utile pour pouvoir revenir en arrière et réunir plus de données
si je me rends compte que j'ai oublié quelque chose plus tard.
Si je faisais un enregistrement vidéo, je ne pourrais explorer la mémoire
qu'une seule fois.
Dans cet exemple, je vais juste faire flotter le sprite ID et le numéro de slot
au dessus de chaque sprite.
J'essaie de rendre la vidéo amusante à regarder. Avoir Toad qui reste là sans bouger
et les Maskass qui se baladent à côté de lui ne serait pas très intéressant.
Je peux par exemple montrer que ces troncs sont des sprites, et comment les sprites sont générés
quand on les extrait du sol.
Et ensuite, je peux entrer par cette porte pour montrer comment tout est déchargé et
comment les nouveaux sprites sont chargés pendant la transition.
C'est déjà pas mal.
La prochaine étape consiste à obtenir une liste de toutes les variables dont j'ai besoin pour créer la vidéo
comme je l'entends.
Pour cette vidéo, j'ai besoin de l'ID du sprite et son numéro de slot.
Il est très probable que les IDs des sprites soient stockés dans un tableau en mémoire, dans l'ordre des slots.

English: 
So I'll need to find the memory address that
holds all of the sprite IDs.
And then in order to get these values to stick
to the sprites on the video, I'll need each
sprites' X and Y positions relative to the
screen.
The position of sprites' position on the screen
is directly driven by OAM, but I happen to
know that often times OAM values are hard
to read from because of the way that some
developers implement sprite flickering when
they are on top of one another.
This is done by shuffling the OAM entries
every frame--so an object can be in a different
memory location every frame, which is quite
annoying.
An easier way to go about it is to just grab
the position of the sprite relative to the
level, and the position of the camera relative
to the level, then subtracting the two.
Those two values are usually stored in a static
place in memory.
So for this video, I'll need the X and Y position
of each sprite, which is probably stored in
a table similar to the IDs.
And I'll also need the X and Y position of
the camera, which shouldn't be too hard to
find either.
Once I have a list of all the values I need,
I'll go in with a memory viewer and find where

French: 
Je dois donc trouver l'adresse mémoire où sont stockés les IDs.
Et ensuite, pour que ces valeurs restent accrochés aux sprites sur la vidéo, j'ai besoin
de la position X et Y de chaque sprite par rapport à l'écran.
La position des sprites à l'écran est gérée par l'OAM, mais je sais que
les valeurs fournies par l'OAM sont parfois difficiles à lire, à cause de la façon qu'ont
certains développeurs à implémenter le clignotement des sprites quand ils sont l'un sur l'autre.
Ceci est géré en modifiant les entrées OAM à chaque frame. un objet peut donc être à une
position mémoire différente à chaque frame, ce qui est gênant.
Un moyen plus facile de s'y prendre est d'extraire la position du sprite par rapport
au niveau, et la position de la caméra par rapport au niveau, puis de soustraire les deux.
Ces deux valeurs sont en général stockés à un endroit statique en mémoire.
Donc, pour cette vidéo, il me faut les positions X et Y de chaque sprite, qui sont probablement stockés dans
une tableau similaire aux IDs.
J'aurai aussi besoin des positions X et Y de la caméra, qui ne devrait pas être trop difficile à
trouver non plus.
Une fois que j'ai une liste de toutes les valeurs dont j'ai besoin, j'utilise le visionneur de mémoire pour trouver où

French: 
elles sont tous situés en mémoire.
Je ferais peut-être une vidéo sur comment chercher des adresses mémoires, mais pour l'instant,
passons à l'étape suivante.
Voici les adresses mémoire dont nous avons besoin.
Les numéros de slots sont compris entre 0 et 9, et ne sont pas stockés dans une table.
Et pour cet exemple, la caméra ne monte et ne descend pas, nous n'avons donc besoin que de sa position X.
Maintenant que j'ai toutes les adresses nécessaires, il est temps d'extraire
les données à partir de l'émulateur.
J'ai écrit un script Lua qui permet d'extraire des données de la mémoire du jeu
et les exporter dans un format CSV que After Effects comprend.
Je dois juste remplir quelques tableaux avec les adresses mémoires que j'ai trouvées, et comment les organiser
pour que les valeurs soient lisibles.
Par exemple, cela créera automatiquement une position 2D signée 16-bits à partir des valeurs
de position, même si les octets hauts et bas ne se suivent pas en mémoire.
Vous trouverez une copie de ce script dans la description de cette vidéo si vous souhaitez
l'utiliser vous-même.
Pour l'exécuter, j'ouvre simplement la console Lua dans l'émulateur, je sélectionne le script, puis

English: 
they are all located in memory.
Maybe I'll make an entire video focused on
searching for memory addresses, but for now
let's fast forward through this step.
Here are the memory addresses for everything.
The slot numbers are just 0 through 9, not
stored in a table.
And for this example, the camera never actually
moves up and down, so we only need its X position.
Now that I have all of the memory addresses
for everything, its time to actually extract
the data from the emulator.
I've written a general purpose lua script
for extracting data from the game's memory
and outputting it into a CSV format that is
recognized by After Effects.
I just have to fill in a couple tables with
the memory addresses I found and how to organize
them into readable numbers.
For example, it will automatically create
16-bit signed 2D point data out of the position
values even though the high and low bytes
are not even contiguous.
You can find a copy of this script in the
description of this video if you would like
to use it yourself.
To run it, I'll just open up the lua console
in the emulator, select the script, and then

English: 
playback the movie I just recorded.
And at the same time I'll go ahead and encode
a video file for the movie as well.
In order to create this video at an acceptable
quality, I always encode using the AVI uncompressed
method.
It makes a pretty large file, but it lets
me scale it up in After Effects and it still
looks nice and sharp.
Once the movie is done playing, I'll have
my video file, and also a CSV file that contains
the screen and sprite data for every frame
of the movie.
Now for the fun part of putting everything
together in After Effects.
I'll make a new composition at 1920x1080 and
60 frames per second, and import the encoded
video.
Drag it onto the timeline, scale it up, and
set nearest neighbor interpolation.
I'll make a new null object and label it 'Raw
Data;' this layer will hold all of the data
for us.
To transfer everything over, I'll quickly
open up the CSV file with Notepad, select
all of the text and copy it to the clipboard.
Then back in After Effects I'll select the
null layer and hit paste.

French: 
je lance le film que je viens d'enregistrer.
J'en profite en même temps pour créer un fichier vidéo à partir de ce film.
Afin de créer une vidéo de bonne qualité, j'encode toujours avec un codec AVI
non compressé.
Cela crée un très gros fichier, mais je peux ensuite l'agrandir dans After Effects sans
que cela devienne flou.
Une fois que le film est fini, j'aurais mon fichier vidéo, ainsi que le fichier CSV qui contient
les données pour l'écran et les sprites, pour chaque frame du film.
Maintenant, la partie amusante : tout réunir dans After Effects.
Je vais faire créer nouvelle composition à 1920x1080 et 60 images par seconde, puis importer
la vidéo.
Je la glisse sur la timeline, je l'agrandis, et j'utilise l'interpolation au plus proche voisin.
Je crée un nouvel objet null et que j'appelle "Données brutes". Ce calque contiendra
toutes les données.
Pour tout transférer, j'ouvre le fichier CSV dans Notepad, je sélectionne
tout le texte et je le copie dans le presse-papier.
Puis, dans After Effects, je sélectionne le calque null, et je copie.

French: 
After Effects convertira tout automatiquement en images-clés.
Une dernière chose à faire et de s'assurer que l'interprétation est en mode "tenir"
plutôt qu'en mode "linéaire", car les valeurs changent de manière discrètes.
Maintenant, il faut créer les objets Texte qui vont bouger dans la vidéo.
Il y a 10 slots de sprites, il y aura donc dix calques de texte.
Je vais en créer un, puis le copier-coller pour aller plus vite.
Je règle le calque contenant la vidéo comme parent du calque textuel, pour qu'il utilise ses coordonnées
afin que 0 soit le côté gauche de la vidéo, et 256 soit le côté droit.
Je règle le contenu textuel du calque pour qu'il affiche l'ID du sprite que nous avons importé.
Celui-ci sera pour le slot 0. Je dois ensuite changer ça pour chaque calque.
Même chose pour la position, je vais lier la position de ce calque à la position du
sprite dans le slot 0, et soustraire la position de l'écran.
On copie-colle ce calque neuf fois, en prenant garde de les mettre à jour
pour qu'ils soient liés au bon slot.

English: 
After Effects will automatically convert everything
into keyframes.
One last thing to do to this data is to make
sure the interpolation mode is set to hold
instead of linear, since these values change
discretely.
Now to create the text objects that will move
around this video.
There are 10 sprite slots, so there will be
10 text layers.
I'll set one of them up, and then copy and
paste it to speed things up a bit.
I'll parent the text layer to the emulator
movie layer so it takes on its coordinate
space, so that zero is the left edge of the
video and 256 is the right edge.
I'll set the text content of the layer to
be the sprite ID data we imported.
This one will be slot 0, and I'll have to
update this for each of the layers.
Same goes for the position, I'll link this
layer's position to be the position data of
sprite slot 0 that was imported, and subtract
the screen's position.
Copy and paste this layer 9 times, and make
sure to update all of the links to point to
the correct sprite slot data.

English: 
And there we go, now all the data follows
the sprites on the video!
There are a few things that would help clean
this up a bit.
First, if you had a keen eye you might notice
that the text sort of swings around the sprites
instead of latching onto them exactly.
This is because it takes a frame for visuals
to update on screen usually, so to fix this,
I just move the video forward in time by one
frame.
Now the text actually follows the sprites
exactly.
The second thing I would do is mask away all
of the text that falls off of the video.
It's cool to see how the sprites still move
a bit when they are off screen, but it can
be distracting sometimes.
In order to do this, I'll select the video,
text, and null object layers, and precompose
them, which is sort of like filing all of
the layers into a separate folder.
I'll copy and paste the video layer and put
it on top of the precomp and add an alpha
matte to the precomp layer.
This will mask away everything that is outside
the bounds of the video.

French: 
Et voilà, toutes les données suivent maintenant les sprites dans la vidéo !
Il y a quelques astuces pour rendre ça plus agréable.
Déjà, si vous regardez bien, vous verrez que le texte se balance autour des sprites
plutôt que d'y être totalement lié.
C'est parce qu'il faut une frame supplémentaire pour que les données soient à jour. Pour corriger ça,
je déplace juste la vidéo d'une frame dans le futur.
Et voilà, le texte suit vraiment les sprites.
La deuxième chose que je ferais, c'est de retirer tout texte qui sort de la vidéo.
C'est intéressant de voir les sprites bouger alors qu'ils sont sortis de l'écran, mais ça peut être
distrayant parfois.
Pour ce faire, je sélectionne les calques de la vidéo, du texte, et des objets nulls, et je les précompose ensemble,
ce qui équivaut à les mettre tous dans un dossier séparé.
Je copie-colle le calque de la vidéo et l'ajoute au dessus de la précomposition, puis j'ajoute une couche alpha
au claque précomposé.
Cela masquera tout ce qui est à l'extérieur
des limites de la vidéo.

French: 
La dernière chose que je ferais est de supprimer le texte quand un sprite despawn de lui-même.
Dans cette vidéo, le 1up, le bloc POW, la bombe et le cœur despawnent quand ils sont à l'écran,
et leurs propriétés restent à l'écran jusqu'à ce qu'un autre sprite prenne leur slot.
Je pourrais faire ça manuellement, mais dans certains cas ça peut demander beaucoup de boulot.
Pour montrer ça, je vais chercher une autre adresse mémoire qui correspond
au statut du sprite, et je l'ajoute au calque de données brutes.
Sur l'émulateur, je dois juste mettre à jour le script Lua avec les nouvelles adresses,
puis relancer le film afin d'extraire les nouvelles données.
C'est tout l'intérêt d'avoir un film d'émulateur, je peux ainsi extraire des données
autant de fois que nécessaire.
Autrement, il serait impossible d'extraire de nouvelles données de cette partie.
Je relance tout ça et génère un nouveau fichier CSV.
Je copie-colle l'ensemble, et j'ai de nouvelles données que je peux utiliser.
Le moyen le plus simple est de lier le statut du sprite à l'opacité de

English: 
The final thing I would do is remove the text
when a sprite despawns on its own.
In this video, the 1up, the POW, the bomb,
and the heart despawn when they are on screen,
and their properties stay on screen until
another sprite takes its empty slot.
I could do this manually, but in some cases
that would also be a lot of work.
Just to show it off, I'll go ahead and find
another memory address that corresponds to
the sprite's status and add it to the Raw
Data layer.
Going back to the emulator, I just have to
update the lua script with the new addresses
and run the emulator movie again and I can
scrape additional data out of the game.
This is why I create an emulator input movie,
so I can run the same inputs as many times
as I need like in this case.
Without that, I wouldn't be able to scrape
data from that exact playthrough.
I'll go ahead and run the script and generate
another CSV file.
Copy and paste this data in, and I have more
keyframes to work with.
The easiest way to do this would be to have
the sprites' statuses link with the text objects'

French: 
l'objet texte.
Si le sprite est "mort" ou "despawné", je règle l'opacité à 0, et il
disparaît.
J'écris une courte expression pour l'opacité de chaque calque de texte, qui la réglera à 0% si
le statut du sprite est 0, et à 100% autrement.
Et voilà, c'est tout pour la partie technique.
Je pourrais changer un peu l'affichage et améliorer la position du texte
autour du sprite, mais ce sont des détails.
Voici le résultat final de cet exemple.
Dans cet exemple, j'ai utilisé les données pour avoir du texte qui suit les sprites, mais les possibilités sont vraiment

English: 
opacity.
If the sprite status is a 'dead' or 'despawned'
state, I can lower the opacity to 0 so it
disappears.
I'll write a short expression for each text
layer's opacity that will set it to 0 if the
sprite status is 0, otherwise it will stay
100%.
And there we go, that's about all the technical
parts of this.
I could tinker around with the styling a bit,
and maybe improve the positioning of the text
around the sprites, but that is all detail
work.
Here's the final result of this example.
In this one I used the data to have text follow
sprites, but the possibilities are really

English: 
endless with this sort of power.
Hopefully this video was useful--I'll be releasing
at least a couple more videos like this one
that answers a lot of the questions I get,
as well as some work-in-progress videos that
show how the main videos on this channel are
created.
Thanks for watching!

French: 
infinies avec ce genre de pouvoir.
J'espère que cette vidéo a été utile. J'en créerais quelques autres comme celle-ci
qui répondent aux questions qu'on me pose souvent, ainsi que des vidéos montrant
comment les vidéos principales de la chaîne sont créées.
Merci d'avoir regardé !
