<Guide du Rootard GeeXLab/>

Buffers

Dernière mise à jour: 2018.12.09 par JeGX

>> Retour <<

Depuis GeeXLab 0.26+ et le support des fichiers zip, il est possible de mapper en mémoire le contenu d'un fichier situé dans l'archive zip. Ce fichier est représenté par un simple buffer en mémoire et il est possible d'accéder à ce buffer en lecture et écriture. Le principe a rapidement été étendu aux fichiers classiques (situés sur le file system). Et finalement la possibilité de créer des buffers vides a aussi été ajoutée (pourquoi pas).

Mais pourquoi avoir ajouté ces nouvelles fonctions? Car il est possible de faire plus ou moins la même chose en Lua et en Python. Effectivement il est possible de créer des buffers en Lua et Python, d'y écrire et d'y lire et de les enregistrer dans un fichier.

La raison fondamentale de toutes ces fonctions est le besoin de pouvoir accéder au contenu d'un fichier quelconque situé dans une archive zip. Tout est parti de là. Python supporte les fichiers zip mais pas Lua. L'autre raison est que ces buffers sont directement accessibles au moteur GeeXLab en C/C++. Le principe peut être étendu à d'autres sources de données comme les vertex buffers par exemple.

Toutes les fonctions pour manipuler des buffers mémoire sont disponibles dans la librairie gh_utils (en Lua et en Python).

Regardons rapidement comment créer un buffer à partir d'un fichier contenu dans une archive zip. L'exemple suivant montre comment créer un buffer mémoire représentant le fichier params.txt stocké dans l'archive params.zip:

demo_dir = gh_utils.get_demo_dir()

zip_filename = demo_dir .. "params.zip"
filename = "params.txt"

ptr, size = gh_utils.zip_buffer_create(zip_filename, filename)

ptr est le point d'accès au buffer mémoire et size est la taille du buffer en octets.

Maintenant que nous avons notre buffer mémoire, nous pouvons y lire ou y écrire des octets grâce aux deux fonctions suivantes: buffer_read_byte et buffer_write_byte.

Voilà comment faire pour lire les deux premiers octets:

offset = 0
x0 = gh_utils.buffer_read_byte(ptr, offset)

offset = 1
x1 = gh_utils.buffer_read_byte(ptr, offset)

Voilà comment faire pour écrire les deux premiers octets:

offset = 0
gh_utils.buffer_write_byte(ptr, offset, x0)

offset = 1
gh_utils.buffer_write_byte(ptr, offset, x1)

Il existe aussi une fonction qui permet de lire une ligne complète. Pratique pour traiter les fichiers textes par exemple (fichier init...).

Voilà comment lire la première ligne du buffer:

offset = 0
line, line_len = gh_utils.buffer_read_line(ptr, size, offset)

line contient la première ligne du buffer et line_len est la taille de la ligne y compris le caractère de saut de ligne ('\n').

Après avoir utilisé le buffer, il faut le détuire:

gh_utils.zip_buffer_kill(ptr)

Un buffer peut également être créé à partir d'un fichier classique:

filename = demo_dir .. "params.txt"
ptr, size = gh_utils.file_buffer_create(filename)

...

gh_utils.file_buffer_kill(ptr)

Enfin, on peut créer un buffer vide en spécifiant sa taille:

ptr = gh_utils.buffer_create(1024)

...

gh_utils.buffer_kill(ptr)

Avant de détruire un buffer, on peut l'enregister dans un fichier:

demo_dir = gh_utils.get_demo_dir()
filename = demo_dir .. "buffer.txt"
if (gh_utils.buffer_to_file(ptr, size, filename) == 1) then
	-- OK
end

Pour finir le code de la démo en téléchargement, qui lit créé un buffer à partir d'un fichier zip et qui lit ensuite le buffer ligne par ligne:

local zip_filename = demo_dir .. "params.zip"
local filename = "params.txt"

ptr, size = gh_utils.zip_buffer_create(zip_filename, filename)
offset = 0
line, line_len = gh_utils.buffer_read_line(ptr, size, offset)
while (line_len > 0) do
	gh_utils.trace(line)
	offset = offset + line_len -- next line please!
	line, line_len = gh_utils.buffer_read_line(ptr, size, offset)
end

gh_utils.zip_buffer_kill(ptr)