{"id":7853,"date":"2022-07-20T00:00:00","date_gmt":"2022-07-19T22:00:00","guid":{"rendered":"https:\/\/blog.ouidou.fr\/?p=7853"},"modified":"2024-02-02T15:22:50","modified_gmt":"2024-02-02T14:22:50","slug":"ecrire-un-core-libretro","status":"publish","type":"post","link":"https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-un-core-libretro","title":{"rendered":"\u00c9crire un Core Libretro"},"content":{"rendered":"<p><em>Article \u00e9crit par Hugo Fabre<\/em><\/p>\n<p>Aujourd&rsquo;hui j&rsquo;aimerais vous faire d\u00e9couvrir ce qu&rsquo;implique l&rsquo;\u00e9criture d&rsquo;un Core Libretro.<\/p>\n<p>Je vous conseille de lire d&rsquo;abord mon <a href=\"https:\/\/ouidou.fr\/blog\/2022\/10\/07\/libretro-et-au-dela\/\">article pr\u00e9c\u00e9dent<\/a> sur la Libretro. Pour ceux qui l&rsquo;auraient loup\u00e9, je vais faire un petit r\u00e9capitulatif.<\/p>\n<p>La Libretro est une interface distribu\u00e9e sous la forme d&rsquo;un fichier <em>header<\/em> en langage C. Il y a deux fa\u00e7ons de l&rsquo;impl\u00e9menter. D&rsquo;un c\u00f4t\u00e9, le Front qui impl\u00e9mente de mani\u00e8re ind\u00e9pendante toute la partie graphique et la r\u00e9cup\u00e9ration des entr\u00e9es utilisateur (clavier\/souris, manette) pour les plateformes qu&rsquo;il souhaite supporter. Charge \u00e0 lui ensuite d&rsquo;appeler les diff\u00e9rentes fonctions d\u00e9finies par la Libretro pour faire fonctionner les diff\u00e9rents Cores disponibles.<\/p>\n<p>Le Core quant \u00e0 lui impl\u00e9mente directement les fonctions d\u00e9finies par la Libretro que le Front pourra appeler au moment o\u00f9 il en a besoin. La majorit\u00e9 des Cores sont aujourd&rsquo;hui des \u00e9mulateurs de vieux mat\u00e9riels, mais il est tout \u00e0 faire possible d&rsquo;\u00e9crire directement un jeu vid\u00e9o. Les avantages pour le d\u00e9veloppeur du Core c&rsquo;est de pouvoir faire tourner son jeu sur la multitude de plateformes support\u00e9es par les diff\u00e9rents Fronts existants sans se soucier de l&rsquo;afficher de la gestion des <em>inputs<\/em> (ce qui peut \u00eatre un vrai casse-t\u00eate si l&rsquo;on souhaite supporter plusieurs plateformes tr\u00e8s diff\u00e9rentes).<\/p>\n<p>De mon c\u00f4t\u00e9 j&rsquo;ai d\u00e9cid\u00e9 de me lancer dans l&rsquo;aventure en \u00e9crivant un Core minimal pour en apprendre plus sur le fonctionnement de la Libretro et pourquoi pas aller plus loin plus tard. \u00c0 la fin de l&rsquo;article, nous aurons donc un core tout simple, capable de dessiner des rectangles de couleur o\u00f9 l&rsquo;on veut dans la fen\u00eatre et de r\u00e9cup\u00e9rer des entr\u00e9es utilisateur.<\/p>\n<h2 id=\"toc_1\">Les technologies<\/h2>\n<p>Bien s\u00fbr on utilisera le <em>header<\/em> de la Libretro dont la derni\u00e8re r\u00e9vision se trouve sur le <a href=\"https:\/\/github.com\/libretro\/RetroArch\/blob\/master\/libretro-common\/include\/libretro.h\">GitHub de Retroarch<\/a>. Ensuite, pour tester notre Core il nous faudra bien s\u00fbr un Front pour le lancer. Pour ma part j&rsquo;ai d\u00e9cid\u00e9 d&rsquo;utiliser le Front de r\u00e9f\u00e9rence <a href=\"https:\/\/www.retroarch.com\/\">Retroarch<\/a>, j&rsquo;ai fait ce choix, car il est stable et supporte une multitude de plateformes.<\/p>\n<p>Ensuite, il nous faut choisir un langage. La Libretro \u00e9tant un <em>header<\/em> C, naturellement on se tourne vers le C ou bien le C++. Pour ma part j&rsquo;ai d\u00e9cid\u00e9 de suivre une route diff\u00e9rente. En effet, m\u00eame si j&rsquo;aime bien le C, j&rsquo;ai beaucoup de mal \u00e0 me faire au manque d&rsquo;outillage moderne (je peux me tromper ne pratiquant pas r\u00e9guli\u00e8rement ni professionnellement) notamment au niveau des <em>build systems<\/em>. De plus j&rsquo;appr\u00e9cie d&rsquo;avoir sous la main certains avantages que peut offrir un langage plus moderne comme une biblioth\u00e8que standard plus fournie.<\/p>\n<p>Mais bon, c&rsquo;est bien de r\u00eaver, il faut quand m\u00eame un langage qui s&rsquo;interface bien avec le C, sinon on court \u00e0 la catastrophe ou au maintien tr\u00e8s complexe d&rsquo;un <em>binding<\/em> entre le C et le langage choisi. Je ne me lancerai pas ici dans une comparaison des diff\u00e9rents concurrents possibles, je ne maitrise pas assez le sujet et \u00e7a pourrait \u00eatre un article \u00e0 part enti\u00e8re. J&rsquo;ai donc limit\u00e9 mon choix au <a href=\"https:\/\/dlang.org\/\">D<\/a> et \u00e0 <a href=\"https:\/\/ziglang.org\/\">Zig<\/a>, les deux sont tr\u00e8s compatibles avec le C et ont une documentation \u00e0 disposition sur le sujet. J&rsquo;ai commenc\u00e9 par D pour lequel la documentation est plus fournie, mais pour diff\u00e9rentes raisons, j&rsquo;ai finalement bascul\u00e9 sur le Zig malgr\u00e9 le manque (\u00e0 mon gout) de documentation orient\u00e9e utilisateur et pas technique (c&rsquo;est un sujet connu dans la communaut\u00e9 qui souhaite prioriser la premi\u00e8re version stable).<\/p>\n<p>Bon, fini le bla-bla, passons au code !<\/p>\n<h2 id=\"toc_2\">Un Core<\/h2>\n<p>Je ne rentrerai pas en d\u00e9tail dans le fonctionnement de Zig parce que c&rsquo;est mon premier programme \u00e9crit dans ce langage, je ne le maitrise donc pas. Par contre, quand il y aura des petits d\u00e9tails int\u00e9ressants ou diff\u00e9rents de ce que l&rsquo;on voit d&rsquo;habitude, j&rsquo;expliquerai au mieux ce que j&rsquo;en ai compris. Pour que vous ne soyez pas perdu, voici l&rsquo;arborescence du projet :<\/p>\n<div>\n<pre><code class=\"language-none\">.\n\u251c\u2500\u2500 build.zig\n\u251c\u2500\u2500 readme.md\n\u251c\u2500\u2500 src\n\u2502   \u251c\u2500\u2500 libretro\n\u2502   \u2502   \u2514\u2500\u2500 libretro.h\n\u2502   \u2514\u2500\u2500 main.zig\n\u2514\u2500\u2500 zig-out\n\u2502   \u2514\u2500\u2500 lib\n\u2502       \u251c\u2500\u2500 libzigretro-core.0.0.1.dylib\n\u2502       \u251c\u2500\u2500 libzigretro-core.0.dylib -&gt; libzigretro-core.0.0.1.dylib\n\u2502       \u2514\u2500\u2500 libzigretro-core.dylib -&gt; libzigretro-core.0.dylib\n\u2514\u2500\u2500zig-cache<\/code><\/pre>\n<\/div>\n<p>Le fichier <code>build.zig<\/code> sera l&rsquo;\u00e9quivalent d&rsquo;un <code>Makefile<\/code>, dans <code>zig-out<\/code> nous retrouverons le r\u00e9sultat de nos <em>builds<\/em> (l&rsquo;extension peut varier selon votre syst\u00e8me d&rsquo;exploitation). Le dossier <code>zig-cache<\/code> est un peu \u00e0 part, il contient des <em>artifacts<\/em> de <em>build<\/em>, nous ne nous y int\u00e9resserons pas, il contient des informations uniquement utiles au compilateur.<\/p>\n<h2 id=\"toc_3\">Le build<\/h2>\n<p>C&rsquo;est bien beau d&rsquo;\u00e9crire un Core, mais il faut d\u00e9j\u00e0 \u00eatre capable de le compiler comme il faut pour qu&rsquo;il soit utilisable par un Front. Voil\u00e0 notre fichier de d\u00e9finition de <em>build<\/em> :<\/p>\n<div>\n<pre><code class=\"language-zig\">\/\/ build.zig\n\nconst std = @import(\"std\");\n\npub fn build(b: *std.build.Builder) void {\n    \/\/ Les options de version standard permettent \u00e0 la personne qui ex\u00e9cute\n    \/\/ `zig build` de s\u00e9lectionner entre Debug, ReleaseSafe, ReleaseFast et\n    \/\/ ReleaseSmall.\n    const mode = b.standardReleaseOptions();\n\n    \/\/ On veut obtenir une biblioth\u00e8que partag\u00e9e (en gros, utilisable\n    \/\/ au _runtime_ et pas au moment de la compilation).\n    const lib = b.addSharedLibrary(\"zigretro-core\", \"src\/main.zig\", b.version(0, 0, 1));\n    lib.setBuildMode(mode);\n    lib.addIncludePath(\"src\/libretro\");\n\n    \/\/ On link la biblioth\u00e8que standard C car nous en aurons besoin.\n    lib.linkLibC();\n    lib.install();\n}<\/code><\/pre>\n<\/div>\n<p>Pour plus d&rsquo;informations sur le sujet, vous pouvez lire <a href=\"https:\/\/zig.news\/xq\/zig-build-explained-part-1-59lf\">cette suite d&rsquo;articles d\u00e9di\u00e9e<\/a> (en anglais).<\/p>\n<h2 id=\"toc_4\">Notre Core<\/h2>\n<p>Vous pouvez retrouver le code source complet de cette premi\u00e8re partie <a href=\"https:\/\/github.com\/hfabre\/zigretro-core\/tree\/minimal-core\">ici<\/a>.<\/p>\n<p>En premier lieu, il va falloir faire le point sur le fonctionnement de la Libretro. D&rsquo;abord, nous devrons impl\u00e9menter un certain nombre de fonctions dont les symboles doivent obligatoirement se retrouver dans notre biblioth\u00e8que une fois compil\u00e9e, car le Front va les appeler et crasher si elles ne sont pas pr\u00e9sentes. La documentation sur le sujet \u00e9tant assez \u00e9parse, je me suis fix\u00e9 comme premier objectif de traduire le projet <a href=\"https:\/\/github.com\/libretro\/skeletor\">skeletor<\/a> qui est une impl\u00e9mentation minimale de la Libretro en C.<\/p>\n<p>En premier lieu tout en haut de notre fichier <code>main.zig<\/code>, je vous invite \u00e0 d\u00e9finir les imports donc nous aurons besoin.<\/p>\n<div>\n<pre><code class=\"language-none\">\/\/ main.zig\n\nconst std = @import(\"std\");\nconst print = @import(\"std\").debug.print;\nconst lr = @cImport(@cInclude(\"libretro.h\"));<\/code><\/pre>\n<\/div>\n<p>Tr\u00e8s simple jusque-l\u00e0, Zig nous offrant la possibilit\u00e9 d&rsquo;importer directement et d&rsquo;utiliser un <em>header<\/em> C sans action de notre part.<\/p>\n<p>Avant de passer \u00e0 la suite, deux petits points importants pour la compr\u00e9hension de la suite :<\/p>\n<p>M\u00eame si on ne g\u00e8re pas directement l&rsquo;affichage, on doit remplir un tableau de pixels (<em>framebuffer<\/em>) que l&rsquo;on renverra au front. Il y a diff\u00e9rents formats disponibles pour g\u00e9rer ces pixels, j&rsquo;ai choisi d&rsquo;utiliser le <code>RETRO_PIXEL_FORMAT_XRGB8888<\/code> en gros un pixel sera compos\u00e9 de 4 bits, un pour la transparence (non utilis\u00e9 par la Libretro mais d\u00e9fini dans le format), un pour le rouge, un pour vert et un pour le bleu (<code>ARGB<\/code>).<\/p>\n<p>Deuxi\u00e8me point, la Libretro fonctionne principalement avec un syst\u00e8me de <em>callbacks<\/em>, en C ce sont des pointeurs sur fonctions. Charge \u00e0 nous d&rsquo;appeler les diff\u00e9rents <em>callbacks<\/em> dont nous aurons besoin au bon moment.<\/p>\n<p>Petite aide au besoin, vous pourrez retrouver <a href=\"https:\/\/ziglang.org\/documentation\/master\/#toc-Primitive-Types\">ici un tableau<\/a> explicitant les diff\u00e9rences de nommage entre les types en C et en Zig<\/p>\n<p>Ensuite, nous aurons besoin de quelques valeurs (variables ou constantes) dont on se servira plus tard :<\/p>\n<div>\n<pre><code class=\"language-zig\">\/\/ main.zig\n\/\/ ...\n\n\/\/ Ici on d\u00e9finit la taille de notre fen\u00eatre\nconst video_width = 200;\nconst video_height = 150;\nconst video_pixels = video_height * video_width;\nconst pitch = bpp * video_width * @sizeOf(u8);\n\n\/\/ Bits par pixel\nconst bpp = 4;\n\n\/\/ Notre allocateur.\n\/\/ En effet en Zig, toutes les fonctions qui allouent de la m\u00e9moire le font\n\/\/ explicitement. Plusieurs avantages \u00e0 \u00e7a, on peut en changer facilement\n\/\/ et on sait lorsque de la m\u00e9moire est allou\u00e9e et doit \u00eatre lib\u00e9r\u00e9e.\n\/\/ Pour savoir comment choisir l'allocateur qui convient le mieux, il\n\/\/ existe une documentation d\u00e9di\u00e9e :\n\/\/ https:\/\/ziglang.org\/documentation\/0.9.1\/#Choosing-an-Allocator\n\/\/\n\/\/ Ici on choisit l'allocateur standard de la libc.\nconst allocator = std.heap.c_allocator;\n\n\/\/ Nous ne les utiliserons pas, mais il faut les d\u00e9finir ; on met donc tout \u00e0 0.\nvar last_aspect: f32 = 0.0;\nvar last_sample_rate: f32 = 0.0;\n\n\/\/ Et enfin nos callbacks. En zig une variable doit \u00eatre initialis\u00e9e.\n\/\/ Ici on ne connait pas leur valeur, c'est le front qui sera charg\u00e9 de\n\/\/ les d\u00e9finir en appelant les fonctions que nous impl\u00e9menterons plus tard.\nvar logging: lr.retro_log_callback = undefined;\nvar log_cb: lr.retro_log_printf_t = undefined;\nvar environ_cb: lr.retro_environment_t = undefined;\nvar video_cb: lr.retro_video_refresh_t = undefined;\nvar audio_cb: lr.retro_audio_sample_t = undefined;\nvar audio_batch_cb: lr.retro_audio_sample_batch_t = undefined;\nvar input_poll_cb: lr.retro_input_poll_t = undefined;\nvar input_state_cb: lr.retro_input_state_t = undefined;\n\n\/\/ Le framebuffer qu'on passera au callback utilis\u00e9 par le Front.\n\/\/ Un simple tableau de pixel.\nvar frame_buffer: []u8 = undefined;\n\n\/\/ Pour nous simplifier la vie nous travaillerons avec un tableau \u00e0 deux\n\/\/ dimensions pour pouvoir utiliser un syst\u00e8me de coordonn\u00e9es classique (x-y).\nvar screen: [video_height][video_width]Color = undefined;<\/code><\/pre>\n<\/div>\n<p>Nous aurons besoin ensuite de quelques utilitaires. D&rsquo;abord nous allons d\u00e9finir une structure pour nos couleurs et en pr\u00e9d\u00e9finir deux :<\/p>\n<div>\n<pre><code class=\"language-zig\">\/\/ main.zig\n\/\/ ...\n\nconst Color = struct {\n    a: u8,\n    r: u8,\n    g: u8,\n    b: u8\n};\n\nconst black = Color {\n    .a = 0,\n    .r = 0,\n    .g = 0,\n    .b = 0\n};\n\nconst white = Color {\n    .a = 0,\n    .r = 255,\n    .g = 255,\n    .b = 255\n};<\/code><\/pre>\n<\/div>\n<p>Rien de bien particulier ici si ce n&rsquo;est la syntaxe de Zig un peu diff\u00e9rente de ce dont on a l&rsquo;habitude.<\/p>\n<p>Puis deux fonctions, une pour dessiner sur notre \u00e9cran un rectangle \u00e0 une position donn\u00e9e de la couleur souhait\u00e9e, et une pour effectuer le rendu de notre \u00e9cran en deux dimensions dans notre <em>framebuffer<\/em> :<\/p>\n<div>\n<pre><code class=\"language-zig\">\/\/ main.zig\n\/\/ ...\n\nfn draw_rectangle(x: i32, y: i32, w: i32, h: i32, color: Color) void {\n    \/\/ En Zig il y a plusieurs moyens de caster un nombre entier selon\n    \/\/ le besoin (v\u00e9rification de d\u00e9passement par exemple).\n    \/\/ Vous pouvez retrouver plus d'information sur cet article :\n    \/\/ https:\/\/www.lagerdata.com\/articles\/an-intro-to-zigs-integer-casting-for-c-programmers\n    var i: usize = @intCast(usize, y);\n\n    while (i &lt; y + h) {\n        var j: usize = @intCast(usize, x);\n\n        while (j &lt; x + w) {\n            screen[i][j] = color;\n            j += 1;\n        }\n        i += 1;\n    }\n}\n\nfn screen_to_frame_buffer() void {\n    var y: usize = 0;\n\n    while (y &lt; video_height) {\n        var x: usize = 0;\n\n        while (x &lt; video_width) {\n            var pixel = screen[y][x];\n            var pixel_index = y * video_width + x;\n            var base_index = pixel_index * bpp;\n\n            frame_buffer[base_index] = pixel.r;\n            frame_buffer[base_index + 1] = pixel.g;\n            frame_buffer[base_index + 2] = pixel.b;\n            frame_buffer[base_index + 3] = pixel.a;\n            x += 1;\n        }\n        y += 1;\n    }\n}<\/code><\/pre>\n<\/div>\n<p>C&rsquo;est un code assez classique qui parlera \u00e0 tout le monde sauf le point expliqu\u00e9 en commentaire.<\/p>\n<p>C&rsquo;est bon, nous pouvons commencer \u00e0 impl\u00e9menter l&rsquo;interface de la Libretro. On commence par le principal, la fonction qui ex\u00e9cutera notre logique :<\/p>\n<div>\n<pre><code class=\"language-zig\">\/\/ main.zig\n\/\/ ...\n\n\/\/ L'utilisation d'export permet d'exposer la fonction\n\/\/ dans notre biblioth\u00e8que une fois compil\u00e9e.\nexport fn retro_run() void {\n    draw_rectangle(0, 0, video_width, video_height, black);\n    draw_rectangle(0, 0, 20, 20, white);\n    screen_to_frame_buffer();\n\n    \/\/ Alors, l\u00e0 c'est de la magie noire, j'explique \u00e7a hors commentaire.\n    video_cb.?(@ptrCast(*anyopaque, frame_buffer.ptr), video_width, video_height, bpp * video_width * @sizeOf(u8));\n}<\/code><\/pre>\n<\/div>\n<p>Premi\u00e8re chose, l&rsquo;appel \u00e0 la fonction qui est fait de mani\u00e8re un peu particuli\u00e8re <code>video_cb.?()<\/code>, en gros on signale une fonction <em>unsafe<\/em> qui pourrait renvoyer une erreur. Ensuite, le premier param\u00e8tre <code>@ptrCast(*anyopaque, frame_buffer.ptr)<\/code>. \u00c7a parait complexe mais c&rsquo;est assez simple. Le <em>callback<\/em> que l&rsquo;on appelle prend en premier param\u00e8tre un type <code>void*<\/code>, en gros en C c&rsquo;est un type un peu fourre-tout qui signale un pointeur vers n&rsquo;importe quel type. Son \u00e9quivalent en Zig (\u00e0 priori jamais utilis\u00e9 sauf pour la compatibilit\u00e9 avec le C) c&rsquo;est <code>*anyopaque<\/code>, et enfin en C on peut faire ce qu&rsquo;on veut et <em>caster<\/em> comme on souhaite un pointeur, en Zig il faut passer par une fonction <code>builtin<\/code> : <code>@ptrCast<\/code>.<\/p>\n<p>C&rsquo;est tout pour les grosses complexit\u00e9s ici, un petit point sur le dernier param\u00e8tre, c&rsquo;est la Libretro qui nous l&rsquo;impose, il s&rsquo;appelle le <code>pitch<\/code>. Vous pouvez retrouver dans la <a href=\"https:\/\/github.com\/libretro\/RetroArch\/blob\/master\/libretro-common\/include\/libretro.h#L3758\">Libretro<\/a> l&rsquo;explication exacte, en gros, c&rsquo;est la variable qui permettra de passer facilement de notre <em>framebuffer<\/em> \u00e0 plat \u00e0 un \u00e9cran en deux dimensions.<\/p>\n<p>Ensuite, nous allons devoir initialiser plusieurs choses. Certaines pour le bon fonctionnement du Front avec notre Core et d&rsquo;autres pour nous, par exemple, il va falloir allouer notre <em>framebuffer<\/em>. \u00c7a va prendre un peu de place, mais pas grand-chose de compliqu\u00e9 ici.<\/p>\n<div>\n<pre><code class=\"language-zig\">\/\/ main.zig\n\/\/ ...\n\n\/\/ On alloue donc notre framebuffer via notre allocateur.\n\/\/ Vous noterez la gestion d'erreur un peu particuli\u00e8re de Zig,\n\/\/ Pour plus d'information : https:\/\/ziglearn.org\/chapter-1\/#errors.\n\/\/ De plus lorsque qu'une fonction peu renvoyer une erreur,\n\/\/ Zig nous force \u00e0 la traiter.\n\/\/ C'est un avantage mais dans le cadre d'un PoC \u00e7a peut \u00eatre frustrant.\nexport fn retro_init() void {\n    frame_buffer = allocator.alloc(u8, video_pixels * bpp) catch {\n        std.log.info(\"Could not allocate memory\", .{});\n        std.os.exit(1);\n    };\n}\n\n\/\/ On n'oublie pas d'\u00eatre poli, on lib\u00e8re la m\u00e9moire qu'on avait r\u00e9serv\u00e9.\nexport fn retro_deinit() void {\n    allocator.free(frame_buffer);\n}\n\n\/\/ Second usage des callbacks, passer des informations au Front.\nexport fn retro_set_environment(cb: lr.retro_environment_t) void {\n    environ_cb = cb;\n    var allow_no_game = true;\n\n    \/\/ Si un logger est d\u00e9fini par le front, on l'utilise.\n    if (cb.?(lr.RETRO_ENVIRONMENT_GET_LOG_INTERFACE, &amp;logging)) {\n        log_cb = logging.log;\n    }\n\n    \/\/ On pr\u00e9vient le Front que notre Core peut se lancer sans jeu.\n    \/\/ La libretro \u00e9tant \u00e0 l'origine d\u00e9di\u00e9e aux \u00e9mulateurs, elle consid\u00e8re\n    \/\/ que les cores doivent \u00eatre d\u00e9marr\u00e9s avec un jeu. Nous n'allons\n    \/\/ pas utiliser cette fonctionnalit\u00e9 vu que nous d\u00e9veloppons une\n    \/\/ simple application.\n    if (cb.?(lr.RETRO_ENVIRONMENT_SET_SUPPORT_NO_GAME, &amp;allow_no_game)) {}\n    else {\n       print(\"Unable to allow no game booting\\n\", .{});\n       return;\n    }\n}\n\n\/\/ Ici on ne charge rien vu qu'on d\u00e9marre sans jeu,\n\/\/ en revanche on sp\u00e9cifie le format de pixel\n\/\/ qu'on va utiliser dans notre framebuffer.\nexport fn retro_load_game(_: [*c]lr.retro_game_info) bool {\n    var fmt = lr.RETRO_PIXEL_FORMAT_XRGB8888;\n    if (!environ_cb.?(lr.RETRO_ENVIRONMENT_SET_PIXEL_FORMAT, &amp;fmt))\n    {\n        print(\"XRGB8888 is not supported.\\n\", .{});\n        return false;\n    }\n\n    return true;\n}\n\n\/\/ Des informations sur notre Core qui sont mises \u00e0 disposition du Front.\nexport fn retro_get_system_info(info: [*c]lr.struct_retro_system_info) void {\n    info.*.library_name = \"zigretro\";\n    info.*.library_version = \"0.1\";\n    info.*.need_fullpath = true;\n    info.*.valid_extensions = \"\";\n}\n\n\/\/ Idem\nexport fn retro_get_system_av_info(info: [*c]lr.retro_system_av_info) void {\n    const aspect = 0.0;\n    const sampling_rate = 30000.0;\n\n\n    info.*.geometry.base_width = video_width;\n    info.*.geometry.base_height = video_height;\n    info.*.geometry.max_width = video_width;\n    info.*.geometry.max_height = video_height;\n    info.*.geometry.aspect_ratio = aspect;\n\n    last_aspect = aspect;\n    last_sample_rate = sampling_rate;\n}<\/code><\/pre>\n<\/div>\n<p>Ensuite, nous allons impl\u00e9menter les diff\u00e9rentes fonctions que le Front appellera pour assigner les diff\u00e9rents <em>callback<\/em> auxquels nous aurons acc\u00e8s :<\/p>\n<div>\n<pre><code class=\"language-zig\">\/\/ main.zig\n\/\/ ...\n\nexport fn retro_set_audio_sample(cb: lr.retro_audio_sample_t) void {\n    audio_cb = cb;\n}\n\nexport fn retro_set_audio_sample_batch(cb: lr.retro_audio_sample_batch_t) void {\n    audio_batch_cb = cb;\n}\n\nexport fn retro_set_input_poll(cb: lr.retro_input_poll_t) void {\n    input_poll_cb = cb;\n}\n\nexport fn retro_set_input_state(cb: lr.retro_input_state_t) void {\n    input_state_cb = cb;\n}\n\nexport fn retro_set_video_refresh(cb: lr.retro_video_refresh_t) void {\n    video_cb = cb;\n}<\/code><\/pre>\n<\/div>\n<p>Et enfin nous allons finir par impl\u00e9menter des fonctions obligatoires qui ne nous serviront pas pour notre Core et qui seront donc tout simplement vides :<\/p>\n<div>\n<pre><code class=\"language-zig\">\/\/ main.zig\n\/\/ ...\n\nexport fn retro_api_version() c_uint {\n   return lr.RETRO_API_VERSION;\n}\n\nexport fn retro_set_controller_port_device(_: c_uint, _: c_uint) void {\n\n}\n\n\nexport fn retro_reset() void {\n\n}\n\nexport fn audio_callback() void {\n\n}\n\nexport fn audio_set_state(_: bool) void {\n\n}\n\nexport fn retro_unload_game() void {\n\n}\n\nexport fn retro_get_region() c_uint {\n    return lr.RETRO_REGION_NTSC;\n}\n\nexport fn retro_load_game_special(_: c_uint, _: [*c]lr.retro_game_info, _: usize) bool {\n    return false;\n}\n\nexport fn retro_serialize_size() usize {\n    return 0;\n}\n\nexport fn retro_serialize(_: *anyopaque, _: usize) bool {\n    return false;\n}\n\nexport fn retro_unserialize(_: *anyopaque, _: usize) bool {\n    return false;\n}\n\nexport fn retro_get_memory_data(_: c_uint) ?*anyopaque {\n    return null;\n}\n\nexport fn retro_get_memory_size(_: c_uint) usize {\n    return 0;\n}\n\nexport fn retro_cheat_reset() void {\n\n}\n\nexport fn retro_cheat_set(_: c_uint, _: bool, _: [*c]u8) void {\n\n}<\/code><\/pre>\n<\/div>\n<p>Pas grand-chose \u00e0 signaler ici, si ce n&rsquo;est certaines syntaxes de Zig :<\/p>\n<ul>\n<li><code>[*c]u8<\/code> signaler un pointeur C vers un <code>u8<\/code><\/li>\n<li><code>_<\/code> Zig nous interdit de d\u00e9finir une variable non utilis\u00e9e, on lui donne donc le nom de <code>_<\/code> on retrouve cette convention (non obligatoire) en Ruby<\/li>\n<li><code>usize<\/code>, <code>c_uint<\/code>, <code>*anyopaque<\/code> on en a d\u00e9j\u00e0 parl\u00e9, l&rsquo;\u00e9quivalent Zig de <code>size_t<\/code>, <code>unsigned int<\/code> et <code>void*<\/code><\/li>\n<li>Le type de retour <code>?*anyopaque<\/code> qui signale qu&rsquo;on retourne un <code>void*<\/code> ou <code>null<\/code><\/li>\n<\/ul>\n<p>Voil\u00e0 pour cette premi\u00e8re partie. Pour tester tout \u00e7a, rien de plus simple :<\/p>\n<div>\n<pre><code class=\"language-bash\">zig build\nchemin_vers_retroarch -v -L chemin_vers_ce_projet\/zig-out\/lib\/libzigretro-core.0.0.1.dylib<\/code><\/pre>\n<\/div>\n<p>Le <code>-v<\/code> sert \u00e0 rendre Retroarch plus verbeux pour avoir des informations de <em>debug<\/em> et le <code>-L<\/code> \u00e0 pr\u00e9ciser le chemin vers notre Core. Si vous lancez les commandes, vous aurez un beau fond noir avec dessin\u00e9 par-dessus un petit rectangle blanc \u00e0 la position donn\u00e9e.<\/p>\n<h2 id=\"toc_5\">Les inputs<\/h2>\n<p>Vous pouvez retrouver directement le code source de cette partie <a href=\"https:\/\/github.com\/hfabre\/zigretro-core\/tree\/input-handling\">ici<\/a><\/p>\n<p>Bon c&rsquo;est sympa ce que nous avons, mais \u00e7a serait vraiment bien de dynamiser tout \u00e7a ! Pour \u00e7a nous allons r\u00e9cup\u00e9rer les <em>inputs<\/em> gr\u00e2ce \u00e0 la Libretro et faire bouger notre carr\u00e9 blanc. Il est important de noter que nous allons utiliser une toute petite partie de ce qui est possible de faire gr\u00e2ce \u00e0 la Libretro (g\u00e9rer deux joueurs via plusieurs manettes par exemple).<\/p>\n<p>Tout le code source pr\u00e9sent\u00e9 est \u00e0 rajouter dans le fichier <code>main.zig<\/code><\/p>\n<p>Vous allez voir c&rsquo;est tr\u00e8s simple, on va commencer par d\u00e9finir trois nouvelles variables pour la position de notre carr\u00e9 et la vitesse de d\u00e9placement :<\/p>\n<div>\n<pre><code class=\"language-zig\">var player_x: i32 = 0;\nvar player_y: i32 = 0;\nconst speed = 1;<\/code><\/pre>\n<\/div>\n<p>Ensuite, nous allons d\u00e9finir une structure de donn\u00e9es pour faire un <em>mapping<\/em> entre les d\u00e9finitions de touches dans la Libretro et chez nous :<\/p>\n<div>\n<pre><code class=\"language-zig\">\/\/ Un hash comme on peut en retrouver en Ruby,\n\/\/ avec pour clef un nombre entier non sign\u00e9 et pour valeur un enum maison.\nvar key_map = std.AutoHashMap(c_uint, Key).init(allocator);\n\nconst Key = enum {\n    up,\n    down,\n    left,\n    right\n};<\/code><\/pre>\n<\/div>\n<p>Avant toute chose, on va \u00e9craser notre fonction d&rsquo;initialisation pour allouer notre <code>HashMap<\/code> :<\/p>\n<div>\n<pre><code class=\"language-zig\">export fn retro_init() void {\n    frame_buffer = allocator.alloc(u8, video_pixels * bpp) catch {\n        handle_error(\"Could not allocate memory\");\n        \/\/ Pour \u00eatre tout \u00e0 fait franc, je ne comprend pas\n        \/\/ pourquoi j'ai besoin de faire \u00e7a, \u00e0 creuser.\n        return;\n    };\n\n    key_map.put(lr.RETRO_DEVICE_ID_JOYPAD_UP, Key.up) catch {\n        handle_error(\"Could not allocate memory\");\n    };\n\n    key_map.put(lr.RETRO_DEVICE_ID_JOYPAD_DOWN, Key.down) catch {\n        handle_error(\"Could not allocate memory\");\n    };\n\n    key_map.put(lr.RETRO_DEVICE_ID_JOYPAD_RIGHT, Key.right) catch {\n        handle_error(\"Could not allocate memory\");\n    };\n\n    key_map.put(lr.RETRO_DEVICE_ID_JOYPAD_LEFT, Key.left) catch {\n        handle_error(\"Could not allocate memory\");\n    };\n}\n\n\/\/ J'en ai profit\u00e9 pour d\u00e9finir une petite fonction pour g\u00e9rer les erreurs.\n\/\/ Pas d'export ici vu qu'elle est uniquement utilis\u00e9e dans notre code Zig.\nfn handle_error(message: []const u8) void {\n    std.log.info(\"{s}\", .{message});\n    std.os.exit(1);\n}\n\n\/\/ Et on n'oublie pas de lib\u00e9rer notre m\u00e9moire !\nexport fn retro_deinit() void {\n    allocator.free(frame_buffer);\n    key_map.deinit();\n}<\/code><\/pre>\n<\/div>\n<p>Ensuite nous aurons besoin de g\u00e9rer les <em>inputs<\/em>, pour \u00e7a on rajoute une fonction :<\/p>\n<div>\n<pre><code class=\"language-zig\">fn process_inputs() void {\n    var it = key_map.iterator();\n\n    while (it.next()) |kv| {\n        \/\/ On appelle un callback sur lequel le Front nous renvoie 0 si la\n        \/\/ touche en question n'est pas appuy\u00e9e.\n        var pressed = input_state_cb.?(0, lr.RETRO_DEVICE_JOYPAD, 0, kv.key_ptr.*);\n\n        \/\/ Si la touche demand\u00e9e est appuy\u00e9e, la Libretro nous renvoie autre\n        \/\/ chose que 0.\n        if (pressed != 0) {\n            switch (kv.value_ptr.*) {\n                Key.up =&gt; player_y -= speed,\n                Key.down =&gt; player_y += speed,\n                Key.right =&gt; player_x += speed,\n                Key.left =&gt; player_x -= speed\n            }\n        }\n    }\n}<\/code><\/pre>\n<\/div>\n<p>Assez classique hormis les syntaxes de Zig encore une fois.<\/p>\n<p>Et pour finir, il va falloir apporter quelques changements \u00e0 notre fonction principale :<\/p>\n<div>\n<pre><code class=\"language-zig\">export fn retro_run() void {\n    \/\/ On fait des actions en fonction des entr\u00e9es utilisateurs\n    process_inputs();\n\n    draw_rectangle(0, 0, video_width, video_height, black);\n\n    \/\/ On utilise maintenant notre position\n    draw_rectangle(player_x, player_y, 20, 20, white);\n\n    screen_to_frame_buffer();\n    video_cb.?(@ptrCast(*anyopaque, frame_buffer.ptr), video_width, video_height, pitch);\n}<\/code><\/pre>\n<\/div>\n<p>Et voil\u00e0, c&rsquo;est tout. On re-compile via <code>zig build<\/code> et on lance. Vous devriez avoir un carr\u00e9 blanc qui se d\u00e9place en fonction de vos appuis sur les fl\u00e8ches de votre clavier. Attention vous aurez remarqu\u00e9 qu&rsquo;on n&rsquo;a pas mis de garde-fou, si vous essayez de bouger en dehors de l&rsquo;\u00e9cran, vous aurez le droit \u00e0 un beau crash parce que vous tentez d&rsquo;acc\u00e9der \u00e0 une zone m\u00e9moire qui n&rsquo;est pas \u00e0 vous.<\/p>\n<p>Vous avez maintenant tout ce dont vous avez besoin pour impl\u00e9menter votre propre Core (bon il y a encore beaucoup de fonctionnalit\u00e9s \u00e0 explorer, comme le son), \u00e0 partir de maintenant votre imagination sera votre seule limite !<\/p>\n<p>Vous pouvez retrouver une version un peu plus travaill\u00e9e du code source <a href=\"https:\/\/github.com\/hfabre\/zigretro-core\/tree\/extract-engine\">ici<\/a>. Et pour les plus curieux, les \u00e9quivalents de la <a href=\"https:\/\/github.com\/hfabre\/dretro-core\/tree\/minimal-core\">premi\u00e8re partie<\/a> et de la <a href=\"https:\/\/github.com\/hfabre\/dretro-core\/tree\/input-handling\">deuxi\u00e8me partie<\/a> en D.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Les bases pour \u00e9crire un Core Libretro<\/p>\n","protected":false},"author":10,"featured_media":8580,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"content-type":"","inline_featured_image":false,"fifu_image_url":"","fifu_image_alt":"","footnotes":""},"categories":[34,1],"tags":[],"class_list":["post-7853","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-articles-techniques","category-non-classe"],"acf":[],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v28.9 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>\u00c9crire un Core Libretro - Ouidou<\/title>\n<meta name=\"description\" content=\"D\u00e9couvrez comment cr\u00e9er un Core Libretro minimal, capable de dessiner des rectangles de couleur et de r\u00e9cup\u00e9rer des entr\u00e9es utilisateur.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-un-core-libretro\" \/>\n<meta property=\"og:locale\" content=\"fr_FR\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"\u00c9crire un Core Libretro - Ouidou\" \/>\n<meta property=\"og:description\" content=\"D\u00e9couvrez comment cr\u00e9er un Core Libretro minimal, capable de dessiner des rectangles de couleur et de r\u00e9cup\u00e9rer des entr\u00e9es utilisateur.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-un-core-libretro\" \/>\n<meta property=\"og:site_name\" content=\"Ouidou\" \/>\n<meta property=\"article:published_time\" content=\"2022-07-19T22:00:00+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2024-02-02T14:22:50+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2022\/07\/Ecrire-un-Core-Libretro.png\" \/>\n\t<meta property=\"og:image:width\" content=\"1105\" \/>\n\t<meta property=\"og:image:height\" content=\"564\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"Sara Lourties\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"\u00c9crit par\" \/>\n\t<meta name=\"twitter:data1\" content=\"Sara Lourties\" \/>\n\t<meta name=\"twitter:label2\" content=\"Dur\u00e9e de lecture estim\u00e9e\" \/>\n\t<meta name=\"twitter:data2\" content=\"18 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/ecrire-un-core-libretro#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/ecrire-un-core-libretro\"},\"author\":{\"name\":\"Sara Lourties\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#\\\/schema\\\/person\\\/e1d66085fb7c22ede319ce56adc373a4\"},\"headline\":\"\u00c9crire un Core Libretro\",\"datePublished\":\"2022-07-19T22:00:00+00:00\",\"dateModified\":\"2024-02-02T14:22:50+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/ecrire-un-core-libretro\"},\"wordCount\":2024,\"publisher\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/ecrire-un-core-libretro#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/07\\\/Ecrire-un-Core-Libretro.png\",\"articleSection\":[\"Articles Techniques\"],\"inLanguage\":\"fr-FR\"},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/ecrire-un-core-libretro\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/ecrire-un-core-libretro\",\"name\":\"\u00c9crire un Core Libretro - Ouidou\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/ecrire-un-core-libretro#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/ecrire-un-core-libretro#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/07\\\/Ecrire-un-Core-Libretro.png\",\"datePublished\":\"2022-07-19T22:00:00+00:00\",\"dateModified\":\"2024-02-02T14:22:50+00:00\",\"description\":\"D\u00e9couvrez comment cr\u00e9er un Core Libretro minimal, capable de dessiner des rectangles de couleur et de r\u00e9cup\u00e9rer des entr\u00e9es utilisateur.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/ecrire-un-core-libretro#breadcrumb\"},\"inLanguage\":\"fr-FR\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/ecrire-un-core-libretro\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/ecrire-un-core-libretro#primaryimage\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/07\\\/Ecrire-un-Core-Libretro.png\",\"contentUrl\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/07\\\/Ecrire-un-Core-Libretro.png\",\"width\":1105,\"height\":564},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/ecrire-un-core-libretro#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Accueil\",\"item\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"\u00c9crire un Core Libretro\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#website\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/\",\"name\":\"Blog Ouidou\",\"description\":\"Conseil et expertise en technologies\",\"publisher\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"fr-FR\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#organization\",\"name\":\"Ouidou\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/04\\\/image_2022-04-13_150237378.png\",\"contentUrl\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/04\\\/image_2022-04-13_150237378.png\",\"width\":180,\"height\":180,\"caption\":\"Ouidou\"},\"image\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#\\\/schema\\\/person\\\/e1d66085fb7c22ede319ce56adc373a4\",\"name\":\"Sara Lourties\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g\",\"caption\":\"Sara Lourties\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"\u00c9crire un Core Libretro - Ouidou","description":"D\u00e9couvrez comment cr\u00e9er un Core Libretro minimal, capable de dessiner des rectangles de couleur et de r\u00e9cup\u00e9rer des entr\u00e9es utilisateur.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-un-core-libretro","og_locale":"fr_FR","og_type":"article","og_title":"\u00c9crire un Core Libretro - Ouidou","og_description":"D\u00e9couvrez comment cr\u00e9er un Core Libretro minimal, capable de dessiner des rectangles de couleur et de r\u00e9cup\u00e9rer des entr\u00e9es utilisateur.","og_url":"https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-un-core-libretro","og_site_name":"Ouidou","article_published_time":"2022-07-19T22:00:00+00:00","article_modified_time":"2024-02-02T14:22:50+00:00","og_image":[{"width":1105,"height":564,"url":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2022\/07\/Ecrire-un-Core-Libretro.png","type":"image\/png"}],"author":"Sara Lourties","twitter_card":"summary_large_image","twitter_misc":{"\u00c9crit par":"Sara Lourties","Dur\u00e9e de lecture estim\u00e9e":"18 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-un-core-libretro#article","isPartOf":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-un-core-libretro"},"author":{"name":"Sara Lourties","@id":"https:\/\/ouidou.fr\/blog\/#\/schema\/person\/e1d66085fb7c22ede319ce56adc373a4"},"headline":"\u00c9crire un Core Libretro","datePublished":"2022-07-19T22:00:00+00:00","dateModified":"2024-02-02T14:22:50+00:00","mainEntityOfPage":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-un-core-libretro"},"wordCount":2024,"publisher":{"@id":"https:\/\/ouidou.fr\/blog\/#organization"},"image":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-un-core-libretro#primaryimage"},"thumbnailUrl":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2022\/07\/Ecrire-un-Core-Libretro.png","articleSection":["Articles Techniques"],"inLanguage":"fr-FR"},{"@type":"WebPage","@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-un-core-libretro","url":"https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-un-core-libretro","name":"\u00c9crire un Core Libretro - Ouidou","isPartOf":{"@id":"https:\/\/ouidou.fr\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-un-core-libretro#primaryimage"},"image":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-un-core-libretro#primaryimage"},"thumbnailUrl":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2022\/07\/Ecrire-un-Core-Libretro.png","datePublished":"2022-07-19T22:00:00+00:00","dateModified":"2024-02-02T14:22:50+00:00","description":"D\u00e9couvrez comment cr\u00e9er un Core Libretro minimal, capable de dessiner des rectangles de couleur et de r\u00e9cup\u00e9rer des entr\u00e9es utilisateur.","breadcrumb":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-un-core-libretro#breadcrumb"},"inLanguage":"fr-FR","potentialAction":[{"@type":"ReadAction","target":["https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-un-core-libretro"]}]},{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-un-core-libretro#primaryimage","url":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2022\/07\/Ecrire-un-Core-Libretro.png","contentUrl":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2022\/07\/Ecrire-un-Core-Libretro.png","width":1105,"height":564},{"@type":"BreadcrumbList","@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/ecrire-un-core-libretro#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Accueil","item":"https:\/\/ouidou.fr\/blog\/"},{"@type":"ListItem","position":2,"name":"\u00c9crire un Core Libretro"}]},{"@type":"WebSite","@id":"https:\/\/ouidou.fr\/blog\/#website","url":"https:\/\/ouidou.fr\/blog\/","name":"Blog Ouidou","description":"Conseil et expertise en technologies","publisher":{"@id":"https:\/\/ouidou.fr\/blog\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/ouidou.fr\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"fr-FR"},{"@type":"Organization","@id":"https:\/\/ouidou.fr\/blog\/#organization","name":"Ouidou","url":"https:\/\/ouidou.fr\/blog\/","logo":{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/ouidou.fr\/blog\/#\/schema\/logo\/image\/","url":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2022\/04\/image_2022-04-13_150237378.png","contentUrl":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2022\/04\/image_2022-04-13_150237378.png","width":180,"height":180,"caption":"Ouidou"},"image":{"@id":"https:\/\/ouidou.fr\/blog\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/ouidou.fr\/blog\/#\/schema\/person\/e1d66085fb7c22ede319ce56adc373a4","name":"Sara Lourties","image":{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/secure.gravatar.com\/avatar\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g","caption":"Sara Lourties"}}]}},"_links":{"self":[{"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/posts\/7853","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/users\/10"}],"replies":[{"embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/comments?post=7853"}],"version-history":[{"count":6,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/posts\/7853\/revisions"}],"predecessor-version":[{"id":12785,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/posts\/7853\/revisions\/12785"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/media\/8580"}],"wp:attachment":[{"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/media?parent=7853"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/categories?post=7853"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/tags?post=7853"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}