0) Pré-requis

• Une PS4 en 4.05 ;
• Un PC (nous utiliserons Windows dans ce tuto. Vous pourrez aussi réaliser ce tuto sur Linux ou Mac, avec Wine pour installer les fichiers du SDK. Les commandes tapées dans le CMD seront identiques à celles que vous pourrez taper dans votre Terminal) ;
• Une gestionnaire d’archives (comme 7zip) ;
• Python 2.7.14 ;
• Visual Studio 2013 (2015 marche sans doute, mais nous ne l'avons pas testé) ;
• Le PS4 SDK 4.50 patché avec les fichiers du PS4 SDK 3.50 ;
• Des compétences de base en informatique, ça va de soit.

Les fichiers du SDK PS4 ne seront pas partagés dans cet article pour des raisons de légalité. Vous pouvez les trouver en demandant aux bonnes personnes ! Vous trouverez plus d'informations en bas de cette page.

1) Installation des fichiers nécessaires

Une fois les fichiers (trouvés par vos soins) téléchargés, vous pouvez extraire les fichiers du SDK. Exécutez SDK_Manager.exe en tant qu'administrateur.

Vous pouvez installer le tout si vous le souhaitez (y compris les samples). Vous pouvez aussi vous contenter du SDK, mais nous nous servirons de certains samples dans ce tutoriel. Par contre, ce qui est vraiment important, c'est de désactiver toutes les mises à jour et d'activer seulement le SDK Patch - 4.508.101 (contenu dans le dossier Update (2017-05-31)). Cette mise à jour truquée contient en fait les fichiers du SDK 3.50.

2) Utilisation du PS4 SDK

Une fois installé, vous pouvez lancer Visual Studio 2013 (en tant qu'administrateur, c'est important). Créez un nouveau projet pour PS4.

Vous pouvez également utiliser les samples déjà pré-installés si vous les aviez sélectionnés pendant l'installation. Rendez-vous dans C:\Program Files (x86)\SCE\ORBIS SDKs\4.500\target\samples\sample_code pour trouver ces samples. Quelques uns ne sont pas compatibles pour diverses raisons (certains nécessitent une PS4 devkit par exemple).

Pour ce tutoriel, nous allons prendre le projet situé dans "sample_code\graphics\api_font".

Cliquez sur Fichier > Ouvrir > Projet / Solution et sélectionnez votre sample (ici, donc, api_font.sln). Une fois lancé, vous verrez le code du projet. Je ne vais pas vous expliquer le fonctionnement du code de api_font car il est un peu complexe, mais si vous voulez vous amuser, vous pouvez modifier le texte contenu dans cette variable à la ligne 620.

Une fois votre code prêt, cliquez sur Build > Build Solution :

Une fois la construction terminée, rendez-vous dans le dossier \api_font\ORBIS_Debug\. Vous y trouverez le fichier simple_step.elf. Renommez-le en eboot.bin.

3) Signer les fichiers

Créez un dossier, où vous le souhaitez, qui va contenir votre homebrew. Placez-y le fichier eboot.bin, ainsi que le dossier sce_sys contenu dans cette archive. Si vous le souhaitez, vous pouvez changer l'icône.
Créez ensuite le dossier sce_module.

Dans le dossier \api_font\simple_step\sce_module\ ont été générés deux fichiers : libc.prx et libSceFios2.prx. Copiez ces fichiers dans sce_module. Votre dossier devrait ressembler à ça :

Maintenant, nous allons devoir signer l'eboot et les modules. Téléchargez le fichier make_fself.py à cette adresse, et glissez-le dans le dossier de votre homebrew, ainsi que dans le dossier sce_modules. Lancez ensuite l'Invité de commande et rentrez les commandes suivantes :

cd "chemin-vers-le-dossier-de-l'homebrew"
make_fself.py eboot.bin eboot.bin
cd sce_module
make_fself.py libc.prx libc.prx
make_fself.py libSceFios2.prx libSceFios2.prx

Une fois les fichiers signés, retirez make_fself.py du dossier. Nous allons maintenant construire le fichier .PKG installable sur votre PS4.

4) Construction du package

Commencez par télécharger cette archive, qui contient les outils nécessaires à la création de .PKG. Exécutez orbis-pub-sfo.exe, cliquez sur File > Open et sélectionnez le fichier param.sfo (présent dans le dossier sce_sys)

Éditons le param.sfo !

Ici, vous pourrez changer l'ID de votre application ainsi que son nom (Title Text). Sélectionnez le contenu de la case Content ID et copiez-le quelque part où vous pourrez le retrouver facilement plus tard (ici UP9000-NPXX12346_00-TESTAPP200000000).

Une fois vos modifications effectuées, sauvegardez en cliquant sur File > Save.

Fermez cette fenêtre, et exécutez le fichier orbis-pub-gen.exe. Vous allez vous retrouver face à cette fenêtre :

Double cliquez sur Image0. Une nouvelle fenêtre va s'ouvrir. Glissez-déposez-y (ça m'a fait aussi mal de l'écrire que vous de le lire) le contenu entier du dossier de votre homebrew. Votre fenêtre devrait alors ressembler à ça :

Rendez vous dans l'onglet Chunk, faites un clic droit sur Image0 Root, glissez votre souris sur Switch Chunk Assignment of the File(s) et sélectionnez #0 : Chunk #0.

Vous pouvez maintenant fermer cette fenêtre. De retour sur la fenêtre précédente, cliquez sur Command > Project Settings. Allez maintenant dans l'onglet Package et collez le Content ID que vous avez récupéré plus tôt et sélectionnez "Freemium App".

Dans la case Passcode, mettez uniquement des "0". Ainsi, ils pourront être décryptés et modifiés par d'autres utilisateurs ;)
Toutefois, si vous êtes un égoïste, vous pouvez mettre autre chose (mais sachez que l'Univers ne vous apprécie pas beaucoup).

Une fois tout ceci configuré, cliquez sur "OK", puis sur "Build" lorsque vous en aurez l'occasion. Une autre fenêtre va alors s'ouvrir : sélectionnez l'endroit où votre fichier .PKG sera enregistré dans Output Path. Cliquez sur "Build".

La création du package va commencer ! Une fois terminée, vous aurez ce message:

Si tout s'est bien passé, vous devez trouver votre fichier .PKG à l'adresse de destination entrée précédemment.

5) Installation du package sur la PS4

Pour installer l'homebrew sur votre PS4, mettez votre fichier .PKG fraîchement généré sur une clé USB ou un disque dur formaté en FAT32 ou ExFAT (la console ne le reconnaîtra pas sinon). Lancez le hack (retrouvez notre tuto à cette adresse, si vous ne savez pas faire). Une fois terminé, transférez le payload PS4HEN sur votre console.

Si tout s'est bien déroulé, vous voir une option supplémentaire à la fin de vos paramètres : Debug Settings (avec la petite étoile devant).

Branchez votre clé USB à votre console et naviguez dans Game > Package Installer : vous verrez votre fichier .PKG ! Sélectionnez-le et installez-le. Allez ensuite dans le menu de votre PS4 

Vous pouvez évidemment lancer votre bel homebrew (sinon, quel est l'intérêt ?) :

Voilà voilà, vous savez maintenant comment construire des homebrews pour PS4 ! Plus d'excuses, développeurs et apprentis développeurs, développez vos meilleurs homebrews et jeux ! 

5) Post Scriptum

Nous allons ici revenir sur quelques points sur lesquels nous sommes passés trop rapidement dans ce tutoriel. 

Tout d'abord, nous ne partagerons pas dans cet article les fichiers du SDK PS4 officiel. Il s'agit en effet d'une suite de logiciels sous licence, et nous ne tenons pas à avoir de problèmes avec Sony (et accessoirement, la justice). On ne vous remet pas le petit panneau, mais on vous rappelle juste que la peine endurée peut s'élever jusqu'à 300 000€ et 3 ans d'emprisonnement. Sachez aussi que tout lien vers le SDK dans les commentaires de cet article (et n'importe où sur ce site/forum) sera systématiquement supprimé et le posteur pourra être banni.

Pour la petite histoire, il y eu d'abord un leak du SDK PS4 4.50, mais malheureusement il ne fonctionnait que pour les PS4 en firmware 4.70 minimum (étrange, n'est-ce pas ?). Donc, j'étais un peu bloqué quand un ami (Darbness, merci à lui) m'a contacté et donné les fichiers du SDK 3.50, qui lui est compatible avec le firmware 4.05. Nous avons donc fusionné les fichiers du 3.50 avec ceux du 4.50 pour obtenir un SDK fonctionnel.

Concernant le code du sample utilisé dans ce tutoriel, il est effectivement un peu compliqué car, vous vous en doutez sans doute, c'est un peu plus qu'un simple "Hello World". C'est en fait un exemple qui illustre le processus de rendu des caractères en utilisant des librairies de polices. Plus techniquement : ce programme montre en fait la méthode d'assignation de la mémoire à la librairie de polices, et le processus dans lequel les caractères sont rendus par la librairie de polices.
Après le chargement des modules de la librairie, ce programme effectue le rendu des caractères et décharge ensuite les modules de la bibliothèque.
Enfin, il copie les résultats qui ont effectué le rendu dans la mémoire de la même taille qu'un buffer frame dans les buffers frame. Après ceci, le programme l'affiche pendant 10 secondes, sans changer le contenu des buffers frame. Les résultats rendus sont alors affichés sur l'écran. Voilà, c'est pour cela que ce petit "Hello World" fait en fait 770 lignes !

Si vous êtes encore là, merci de nous avoir lu et à très bientôt! 

Crédits et remerciements :

• Flatz pour le fichier make_fself.py ;
• Darbness pour m'avoir donné les fichiers du SDK 3.50 ;
• cfwprophet pour son Fake PKG Generator ;
• VV1LD pour PS4HEN.

L’article [PS4] [PC] TUTO - Installer et utiliser le SDK PS4 officiel est apparu en premier sur Custom Protocol.

L'utilisation de ce format « .psv » vient d'être améliorée grâce aux codeurs pez2k et Kageurufu, qui ont partagé au public respectivement PSVTrimmer, un logiciel supprimant tous les espaces vides, et PSVTools, une boîte d'outils en langage python facilitant la manipulation de ces fichiers.

PSVTrimmer est donc un logiciel open-source développé par pez2k et compatible uniquement avec les ordinateurs sous Windows. Il n'est pour le moment doté que d'une seule fonctionnalité, à savoir la suppression des espaces vides dans les fichiers « .PSV ». L'auteur, qui dit par ailleurs trouver l'algorithme relativement simple, n'exclut cependant pas de mettre à jour son projet dans le futur afin d'y implémenter de nouvelles options et une interface graphique (pour afficher une barre de chargement notamment).

PSVTrimmer requiert .NET Framework 4.6.

PVTools est quant à lui une boîte à outils conçue par kageurufu renfermant plusieurs... outils (merci captain obvious), accessibles via les commandes suivantes :

• psvtrim, pour couper (trim) des fichiers PSV (réduire leur taille) ;
• psvexpand, pour développer des fichiers coupés (trimmed) et revenir à la taille d'origine ;
• psverify, pour vérifier les sommes de contrôle (checksums) des fichiers PSV.

usage: psvtools [-h] [-t | -e | -v] [-o OUTPUT] file
positional arguments:
  file                  psv file to operate on
optional arguments:
  -h, --help            show this help message and exit
  -t, --trim            Trim a psv file. This is the default behavior
  -e, --expand          Expand a trimmed psv file
  -v, --verify          Validate the checksum of a psv file
  -o OUTPUT, --output OUTPUT
                        output file to write to
usage: psvexpand [-h] [-o OUTPUT] file
usage: psvtrim [-h] [-o OUTPUT] file
usage: psverify [-h] file

PSVTools ne requiert que l'installation de python, et est donc compatible avec un grand nombre de systèmes d'exploitation (dont MacOS).

pip install psvtools

L’article [Vita] PSVTrimmer & PSVTools : manipulez vos fichiers « .PSV » est apparu en premier sur Custom Protocol.

Utilisation du système de fichiers

A. Présentation du VFS

Comme défini plus haut, un système de fichiers va vous permettre de créer des fichiers et dossiers depuis votre système d'exploitation et vous déplacer, ouvrir, supprimer ces fichiers, dossiers, etc. Comme pour l'instant l'utilisation de Cosmos ne se fait essentiellement que sur machine virtuelle et non sur un support physique, nous allons utiliser ce qu'on appelle un système de fichiers virtuel (VFS) ou comme Wikipédia le définit : "Une couche d'abstraction au-dessus d'un système de fichiers plus concret".

B. Utilisation du VFS

Lancez Visual Studio, créez un projet ou ouvrez votre projet Cosmos C#. Rendez-vous maintenant dans le fichier Kernel.cs.

Initialisation

Avant d'utiliser le système de fichiers virtuel, il va falloir l'initialiser depuis la boucle BeforeRun() de votre projet (voir le premier tutoriel à la partie 2B pour plus d'informations). Voici le code à utiliser :

FS = new Sys.FileSystem.CosmosVFS();
Sys.FileSystem.VFS.VFSManager.RegisterVFS(FS);

Il est bon de savoir que le système de fichiers utilisé par Cosmos ressemble à celui de Windows, chaque lecteur a sa propre lettre et le répertoire par défaut est "0:\" comme "C:\" sur Windows.

La variable dossier_actuel sera par défaut définie par :

string dossier_actuel = "0:\\";

Commande pour créer un fichier

var f = File.Create(dossier_actuel + "\\fichier.txt"); //Créer un fichier pour chemin dossier_actuel\fichier.txt
f.Close();

Commande pour lire un fichier

string texte = File.ReadAllText(dossier_actuel + "\\fichier.txt"); //La variable 'texte' contiendra le texte contenu dans le fichier

Commande pour supprimer un fichier

File.Delete(dossier_actuel + "\\fichier.txt");

Commande pour créer un dossier

FS.CreateDirectory(dossier_actuel + "\\nomdudossier");

Commande pour supprimer un dossier

Directory.Delete(dossier_actuel + "\\dossier", true); // 'true' signifie que le contenu du dossier va être également supprimé

Commande pour se déplacer vers un dossier

if (input.StartsWith("cd ")) //L'utilisateur entre 'cd nomdudossier'
            {
                var newdir = input.Remove(0, 3); //On extrait le nom du dossier
                if (Directory.Exists(dossier_actuel + newdir))
                //On vérifie si le dossier existe.
                {
                    Directory.SetCurrentDirectory(dossier_actuel);
                    dossier_actuel = dossier_actuel + newdir + "\\";
                }
                else
                {
                    Console.WriteLine("Ce dossier n'existe pas !");
                }
            }

Commande pour se déplacer vers un dossier parent (retour)

var dir = FS.GetDirectory(dossier_actuel);
dossier_actuel = dir.mParent.mFullPath;

Commande pour lister les dossiers et fichiers du dossier ouvert

Console.WriteLine("Type\t     Nom");
                foreach (var dir in Directory.GetDirectories(dossier_actuel))
                {
                    Console.WriteLine("<Dossier>\t" + dir);
                }
                foreach (var file in Directory.GetFiles(dossier_actuel))
                {
                    Console.WriteLine("<Fichier>\t" + file);
                }

Commande pour lister les lecteurs disponibles

var vols = FS.GetVolumes();
                Console.WriteLine("Nom\tTaille\tParent");
                foreach (var vol in vols)
                {
                    Console.WriteLine(vol.mName + "\t" + vol.mSize + "\t" + vol.mParent);
                }

Voilà voilà, vous avez pu voir une liste de différentes commandes utiles à la création d'un système d'exploitation, si vous voulez voir l'application réelle de ces commandes, vous pouvez aller voir la méthode InterpredCMD d'un petit système d'exploitation réalisé par mes soins, où ces commandes y sont inscrites (Ctrl + F pour rechercher dans la page ;) ).

C. Exemple d'implémentation du système de fichiers

Maintenant, depuis votre console, vous pouvez implémenter différentes commandes. Voici un algorithme basique qui va pouvoir interpréter les commandes transmises depuis l'utilisateur (comme depuis le CMD sur Windows) et permettre la création et suppression d'un dossier. Ensuite, à vous d'implémenter vos propres commandes !

using System;
using Sys = Cosmos.System;
using System.IO;
using Cosmos.System.FileSystem;
// Ceci permet d'importer des références.
namespace Custom_Protocol
{
    public class Kernel : Sys.Kernel
    {
        string dossier_actuel = "0:\\";
        public CosmosVFS FS { get; private set; }
        protected override void BeforeRun()
        //Ceci est le code exécuté avant l'exécution du programme.
        {
            Console.Clear();
            //Permet de nettoyer la console des logs de démarrage.
            //On met le clavier en français
            Sys.KeyboardManager.SetKeyLayout(new Sys.ScanMaps.FR_Standard());
            //Initialisation du système de fichier.
            FS = new Sys.FileSystem.CosmosVFS();
            Sys.FileSystem.VFS.VFSManager.RegisterVFS(FS);
            //Fin de l'initialisation
            Console.WriteLine("Tutoriel de customprotocol.com");
            Console.WriteLine("Cosmos a demarre avec succes.");
            //Ceci permet d'écrire une ligne.
        }
        protected override void Run()
        //Ceci est le code exécuté pendant l'exécution du programme, il se répétera indéfiniment.
        {
            Console.Write("commande> ");
            //Ceci permet d'écrire une ligne ou l'on peut écrire sur la même ligne.
            var input = Console.ReadLine();
            //Ceci est une variable qui permet de lire le texte écrit par l'utilisateur.
            InterpretCMD(input);
            //Ceci permet de lancer la méthode qui va interpréter la commande (input)
        }
        private void InterpretCMD(string input)
        //Ceci est la méthode qui interprète la commande envoyée (d'où le "string input") 
        {
            if (input.StartsWith("dir -c ")) //Si la commande commence par dir -c
            {
                string dir = input.Remove(0, 7); //On extrait la commande
                if (!Directory.Exists(dossier_actuel + dir)) //Si le dossier n'existe pas (! symbole de négation)
                {
                    FS.CreateDirectory(dossier_actuel + dir); //On créer le dossier
                    Console.WriteLine("Dossier cree !");
                }
                else if (Directory.Exists(dossier_actuel + dir)) //Sinon si le dossier existe alors
                {
                    Console.WriteLine("Le dossier existe deja !");
                    Console.WriteLine("Dossier cree !");
                    FS.CreateDirectory(dossier_actuel + dir + "-1"); //On créer tout de même un dossier avec comme nom 'nomdudossier-1'
                }
            }
            else if (input.StartsWith("dir -r ")) //Si la commande commence par dir -r alors
            {
                string dirr = input.Remove(0, 7); //On extrait le nom du dossier de la commande
                if (Directory.Exists(dossier_actuel + dirr)) //Si le dossier existe alors
                {
                    Directory.Delete(dossier_actuel + dirr, true); //On le supprime
                    Console.WriteLine("Le dossier '" + dirr + "' a ete supprime !");
                }
                else //Si il n'existe pas
                {
                    Console.WriteLine("Le dossier '" + dirr + "' n'existe pas !");
                }
            }
            else if (input == "dir -l") //Si la commande est égale à dir -l
            {
                Console.WriteLine("Type\t     Nom");
                foreach (var dir in Directory.GetDirectories(dossier_actuel)) //On récupere tous les dossiers
                {
                    Console.WriteLine("<Dossier>\t" + dir); //On affiche tous les dossiers
                }
            }
            else if (input == "hello")
            { //Si la commande est égale à hello alors
                Console.WriteLine("Bonjour!"); //Afficher "Bonjour!".
            }
            else if (input == "bye")
            { //Sinon si la commande est égale à bye
                Sys.Power.Shutdown(); //Éteindre le système.
            }
            else
            { //Sinon (si la commande n'est ni hello ni bye)
                Console.WriteLine("Erreur : Commande inconnue"); //Afficher la commande est inconnue.
            }
        }
    }
}

3) Conclusion

À travers ce tutoriel, vous avez pu voir comment utiliser un système de fichiers dans votre projet Cosmos. Amusez-vous, développez et partagez votre projet ! Si vous manquez d'inspiration, voici même une page comprenant plusieurs projets sous Cosmos : Cosmos Projects.

D'autres tutoriels à propos de Cosmos arriveront sur Custom Protocol bientôt, si vous avez besoin de quoi que ce soit vous pouvez poser une question en commentaire ou sur la conversation Gitter du projet Cosmos ! ;)

L’article [Windows] TUTO – [Partie 2] Utilisation du système de fichiers sous Cosmos est apparu en premier sur Custom Protocol.

Le développeur nop90 a décidé de créer un portage clean de SDL, afin qu'il puisse dans le futur être facilement fusionné avec la version officielle de SDL. Un ensemble de flags personnalisés a été ajouté par l'auteur afin de gérer les particularités de la console 3DS (le joystick droit par exemple).

Les autres bibliothèques telles que SDL_Image (pour les images), SDL_TTF (pour les polices) ou SDL_Mixer (pour l'audio) peuvent également être compilées sans problème tant que la lib SDL-3DS est correctement compilée et installée dans votre boîte à outils DevkitArm. Nop90 a indiqué par ailleurs qu'il incluerait plus tard un Makefile afin de pouvoir tout compiler facilement.

Notez que c'est la version 1.2 de SDL qui a été portée, bien que ça soit la version 2 la plus populaire. L'auteur justifie cela en disant qu'il trouve la version 1.2 meilleure, mais annonce que de toute façon il planche sur un portage futur de la version 2, en reprenant les travaux non-finits de xerpi.

Et voici quelques screenshots issus de jeux développés à l'aide de SDL-3DS :

J'espère qu'avec la disponibilité de cette bibliothèque bien connue sur la 3DS, nous verrons de plus en plus de développeurs coder pour cette console.

nop90

L’article [3DS] La bibliothèque SDL portée par nop90 est apparu en premier sur Custom Protocol.

Ce tutoriel fut mise à jour le 18/05/2017, avec une autre méthode d'installation dev-kit bien plus pratique et efficace ! N'hésitez pas à re-suivre cette procédure au cas où ! 

Une petite présentation de notre support s'impose, comme ce tutoriel est ciblé aux débutants et que je ne suis pas expert en programmation, je vais m'appuyer sur le super, que dis-je, le magnifique projet Cosmos.

Cosmos est un système d'exploitation, ou plutôt un "kit de construction", basé sur SysLinux autour du compilateur IL2CPU (créé par les mêmes développeurs que CosmosOS). COSMOS signifie d'ailleurs C# Open Source Managed Operating System.

Bref, Cosmos n'est donc pas un système d'exploitation à proprement parler, mais plutôt un « kit de création de système d'exploitation ». Cosmos va vous permettre de créer des systèmes d'exploitation sur Visual Studio et en C# (ou Visual Basic). Le véritable point fort de Cosmos réside dans le fait qu'il est intégré à Visual Studio, ce qui va permettre un développement sous Windows accompagné d'éléments essentiels. En effet, Visual Studio (avec Cosmos) va débugger et générer votre OS avant de l'envoyer à une machine virtuelle.

1) Installation de Cosmos (dev-kit)

La dernière version officielle du projet Cosmos étant parue il y a déjà plusieurs années, il va falloir mettre à jour celle que vous avez déjà installée et si ce n'est pas déjà fait, l'installer. Car depuis, il y a eu plusieurs corrections de bugs, d'ajouts, qui améliorent fortement l'expérience utilisateur.

Il existe deux kits pour Cosmos, l'user-kit et le dev-kit. C'est ce dernier que nous allons compiler pour pouvoir profiter des mises à jour (dont beaucoup sur le système de fichiers que nous verrons un peu plus tard :P).

A. Pré-requis

• Un minimum de connaissances en algorithmique (C# ou VB par exemple) ;
• Être sous Windows 7 au minimum ;
• Visual Studio Community 2015 (à télécharger ici) ;
• .NET Framework 4.5 (à télécharger ici) ;
• VMWare Player (version gratuite) (à télécharger ici) ;
• .NET Framework 3.5 SP1, quelques composants requérant cette version (à télécharger ici).
  

B. Installation de Cosmos

Premièrement, commencez par télécharger ce répertoire (cliquez sur le bouton vert 'Clone or Download' puis 'Download ZIP') que je vous ai moi-même concocté, comprenant de nombreux correctifs et quelques ajouts. Décompressez ensuite l'archive ZIP sur votre bureau par exemple ou dans un dossier dédié (parce que c'est plus propre).

Lancez maintenant le fichier "install-VS2015.bat".

Une fois le programme d'installation lancé, il va tout effectuer tout seul et vous pourrez voir les résultats dans cette fenêtre :

L'installation n'a normalement pas dû prendre de temps et si tout s'est bien passé, Visual Studio s'est lancé en ouvrant la solution "Cosmos" (où vous pouvez éditer ou voir le code source si vous êtes curieux) et le programme d'installation affiche alors en vert : Build Complete!

2) Créer son premier OS

A. Création du projet

Lancez Visual Studio, appuyez sur "Nouveau projet...", cette fenêtre se lance alors :

Créez un nouveau projet comme n'importe quel projet C#, mais sélectionnez Cosmos comme type de projet. Vous pouvez ensuite choisir de programmer votre OS en C# ou en Visual Basic (je conseille le C# mais Visual Basic est tout aussi bien).

Renseignez ensuite le nom de votre projet, ici "Custom Protocol". Appuyez ensuite sur "OK".

Oh, diable, du code ! Ne vous inquiétez : tout va être expliqué.

B. Le code

Tout d'abord, on peut remarquer que votre nouveau projet ressemble beaucoup à une application console C # standard.

Pour l'instant, il faudra rester dans "C# Custom Protocol" et non dans "Custom ProtocolBoot".

Le fichier Kernel.cs contient le code d'amorçage et d'exécution de votre OS.

Quant au fichier AssemblyInfos.cs, il contient des informations relatives à votre programme.

Voici le code source de votre OS, j'ai traduit le texte pour plus de compréhension (vous pouvez copier coller celui-là) :

using System;
using System.Collections.Generic;
using System.Text;
using Sys = Cosmos.System;
// Ceci permet d'importer des références.
namespace Custom_Protocol
{
    public class Kernel : Sys.Kernel
    {
        protected override void BeforeRun() 
        //Ceci est le code exécuté avant l'exécution du programme
        {
            Console.Clear();
            //Permet de nettoyer la console des logs de démarrage
            Console.WriteLine("Tutoriel de customprotocol.com");
            Console.WriteLine("Cosmos a démarré avec succès. Tapez une ligne de texte pour la faire revenir."); 
            //Ceci permet d'écrire une ligne
        }
        protected override void Run() 
        //Ceci est le code exécuté pendant l'exécution du programme, il se répétera indéfiniment.
        {
            Console.Write("Votre texte: "); 
            //Ceci permet d'écrire une ligne ou l'on peut écrire sur la même ligne.
            var texteutilisateur = Console.ReadLine(); 
            //Ceci est une variable qui permet de lire le texte écrit par l'utilisateur
            Console.Write("Texte ecrit: ");
            //Ceci écrit une ligne
            Console.WriteLine(texteutilisateur); 
            //Ceci écrit le texte que l'utilisateur a écrit.
        }
    }
}

C. Votre premier boot !

Vous pouvez maintenant appuyer sur le petit bouton vert "Démarrer", il se situe sur la barre du haut de Visual Studio.

Si votre code n'a pas d'erreurs, et si VMWare est bien installé, la génération va commencer. Voici une petite vidéo d'exemple de génération. 

Après que VMWare se soit lancé, vous devriez normalement voir du texte défiler (il correspond à l'initialisation de l'ISO dans VMWare). Et après tout ceci, si vous avez correctement copié-collé le code plus haut, vous devriez obtenir ceci :

Voilà, vous venez de créer la première version de votre premier OS en 32 bits, bravo ! Vous pouvez évidemment continuer à le développer, avec l'aide de plusieurs tutoriels qui vont arriver très bientôt ou de la documentation officielle du projet Cosmos.

L’article [Windows] TUTO – [Partie 1] [MàJ le 18/05/2017] Créer son système d’exploitation avec Cosmos est apparu en premier sur Custom Protocol.

Ne nous attardons pas et passons directement au nouveautés venant du changelog officiel !

Nouvelles fonctions :

• Controls.rumble() - Change l'état de certain dualshock (PSTV uniquement) ;
• Screen.getPixel() - Permet d'obtenir la couleur d'un pixel sur l'écran ;
• Screen.waitVblankStart() - Permet d'effectuer une synchronisation verticale de l'écran (vSync) ;
• System.getTime() - Permet d'obtenir l'heure du système ;
• System.getDate() - La date aussi ! ;
• System.getLanguage() - Ainsi que le langage de la PS Vita ;
• System.getUsername() - Et même le pseudo PSN ! ;
• System.extractZIP() - Permet d'extraire un fichier ZIP ;
• System.extractFromZIP() - Permet d'extraire un fichier d'un ZIP ;
• Socket.init() - Initialiser une connexion "socket" ;
• Socket.term() - Terminer une connexion "socket" ;
• Socket.createServerSocket() - Créer un serveur "socket" ;
• Socket.send() - Envoie un message sur un serveur ;
• Socket.receive() - Reçoit un message depuis un serveur ;
• Socket.accept() - Accepter une connexion depuis un serveur ;
• Socket.close() - Ferme un réseau ;
• Socket.connect() - Connecter a un serveur, utilisant un "socket" ;
• Keyboard.show() - Permet d'afficher le clavier officiel Sony ;
• Keyboard.getState() - Permet de récupérer l'état du clavier ;
• Keyboard.getInput() - Prend le contenu du clavier ;
• Keyboard.clear() - Enlève le clavier officiel de Sony.

Cela fait beaucoup de nouveautés tiens donc, mais Rinnegatamante ne s'arrête pas là !

Nouvelles fonctionnalités :

• Maintenant lpp-vita permet d'utiliser des eboots "safe" pour vos homebrews, utile notamment pour l'installation depuis VitaShell ;
• Augmentation la RAM disponible à 192 MB ;
• Maintenant plusieurs instances du même son peuvent être mises en reproduction sans aucun problème ;
• Maintenant VSync est désactivé par défaut mais peut être activé avec Screen.waitVblankStart().

Changements et correction de bugs et ajout de 3 samples :

Changements :

• Maintenant, toutes les fonctions de dessin d'images graphiques acceptent un argument optionnel supplémentaire pour effectuer une teinte de texture ;
• Modification de l'ordre des arguments graphiques dessinant des images respectant le Lua Player Plus sur 3DS ;
• Maintenant Controls.read(), Controls.readLeftAnalog() et Controls.readRightAnalog() acceptent un argument supplémentaire qui indique quelle manette utiliser (PSTV seulement).

Corrections de bugs :

• Maintenant Sound.pause() et Sound.resume() fonctionnent correctement ;
• Maintenant Sound.play() ne provoquera pas de désynchronisation avec les pistes PCM WAV ;
• Correction de LOOP et NO_LOOP. Maintenant, ils fonctionnent comme prévu ;
• Correction d'une faille dans l'implémentation io.read ().

Projets test ajoutés :

• Syntaxe des fichiers audio corrigée ;
• Sample "clavier" ajouté ;

• Sample "téléchargeur de fichier" ajouté.

Merci encore à Rinnegatamante, et si vous voulez télécharger la version 0.5 du Lua Player Plus pour PS Vita, c'est juste en-dessous :

L’article [Vita] Le Lua Player Plus reçoit sa cinquième mise à jour est apparu en premier sur Custom Protocol.

Aujourd'hui, les développeurs gdljjrod, Davis et Rober Galarga reviennent avec une nouvelle version dédié à la PS Vita. On retrouve ainsi énormément de fonctions qu'ont en commun les deux consoles. Il est de ce fait très facile de porter son jeu d'une console à l'autre !

On retrouve également des fonctions dédiés à l'installation des fameux ".VPK" et l'utilisation des polices au format ".TTF" en plus des ".PGF". Néanmoins, il faudra oublier les fonctions dédiées au son et à la 3D avec cette première version.

Les développeurs proposent également un outil nommé ONEMaker. Il permet de personnaliser son homebrew en changeant les métadonnées (nom et id de votre homebrew). Cependant, l'utilitaire est compatible uniquement avec Windows.

Vous trouverez d'ailleurs une documentation en anglais et en espagnol sur les fonctions disponibles. De plus, l'archive du ONELua R1 dispose de tout un tas d'exemples.

Avec cette version, les développeurs hispaniques proposent un Lua Player pour la compétition GekiHEN qui risque de faire parler de lui. En effet, beaucoup de homebrews risquent de l'utiliser, grâce aux diverses fonctions, mais également pour sa rétrocompatibilité avec son homologue PSP.

Si vous avez envie d'apprendre le Lua pour PSP et PS Vita, laissez un commentaire et je ferais peut être une série de tutoriels ! 

En attendant, bon développement ! ^^

L’article [GekiHEN] [Vita] Le ONELua maintenant compatible avec la PS Vita est apparu en premier sur Custom Protocol.

0) Pré-requis

• Une PS Vita en 3.60 avec HENkaku installé ;
• Un PC (Windows de préférence, c’est l’OS que nous utiliserons pour ce tutoriel) ;
• Le gestionnaire d’archives 7zip ou WinRar ;
• Le fichier d'installation de devkitPro ;
• La dernière version du VitaSDK selon votre OS ;
• L'archive de vitahelloworld ;
• Des compétences en C (pour programmer votre homebrew, c’est pas nécessaire pour simplement compiler).

Ce tutoriel sera mis à jour si des personnes souhaitent savoir comment l'installer sur Mac OS ou Linux.

Partie I - Installation des fichiers nécessaires

Commencez par télécharger les fichiers nécessaires. Pour les fichiers du VitaSDK, prenez la version la plus récente correspondant à votre système d'exploitation.

N'oubliez pas de télécharger le fichier d'installation de devkitPro.

1) Installation de devkitPro

Commencer par lancer devkitProUpdater-1.6.0.exe et suivez les étapes d'installations.

Laissez cochées toutes les cases à la première étape, mais pour la deuxième étape, cochez l'option pour supprimer les fichiers téléchargés.

Il nous faudra seulement le Minimal System et le devkitARM pour faire fonctionner le VitaSDK.

Laissez le chemin d'installation par défaut et cliquez sur "Install".

Patientez pendant que le logiciel télécharge et installe les fichiers pour vous. Dès que l’installation est terminée, cliquez sur « Next » puis « Finish ». Si l'installation s'est bien effectuée, vous devriez avoir à la racine de votre disque dur un dossier « devkitPro ».

2) Installation du VitaSDK

Maintenant que cela est fait, décompressez l'archive du VitaSDK. À l'intérieur, vous devriez retrouver ces 4 dossiers (voir image ci-dessous).

Déplacez les 4 dossiers dans "C:\devkitPro\devkitARM" et acceptez de « Remplacer les fichiers dans la destination ».

Maintenant que cela est fait, ne pensez pas que c'est déjà fini. Il nous reste un dernier petit quelque chose.

3) Configuration du système

Cliquez droit sur « Ordinateur » et sélectionnez l’option « Propriétés ». Si vous ne le trouvez vraiment pas, allez dans « Panneau de configuration -> Système et sécurité -> Système ».

Sur la nouvelle fenêtre qui s’ouvre, choisissez à gauche l’option « Paramètres système avancés ».

Sur la nouvelle fenêtre (encore) qui s’ouvre, cliquez sur le bouton tout en bas « Variables d’environnement ».

Une troisième fenêtre (eh beh purée, qu’est-ce qu’il fait chier lui) va être ouverte. Sur celle-ci, 2 listes s’afficheront à vous : « Variables utilisateur pour X » et « Variables système ». Dans cette liste-ci, trouvez la variable « Path » (et non « PATHTEXT » ! D’ailleurs c’est rigolo, quand on le prononce, ça sonne presque « pastèque ». Lol, qu’est-ce qu’on s’marre ici).

Cliquez une fois dessus pour le sélectionner (il sera mis en surbrillance/surligné). Cliquez ensuite sur le bouton « Modifier » juste en bas. Une quatrième fenêtre va être appelée (y en a encore 5 autres, accrochez-vous ! Non j’déconne, c’est la dernière, promis).

Copiez, après le dernier « bin; », ceci (n’oubliez pas le point-virgule à la fin !) :

C:\devkitPro\devkitARM\bin;C:\devkitPro\arm-vita-eabi\bin;

N’oubliez surtout pas d’enregistrer en cliquant sur « OK », puis fermez toutes les fenêtres des propriétés Windows (ouf, enfin). Voilà, le VitaSDK est enfin installé ! Bon maintenant faut tester !

Partie II - Utiliser le VitaSDK

1) Compilation d'un homebrew

Cette partie va vous surprendre par sa durée. Téléchargez le vitahelloworld (voir dans les Pré-requis) de xerpi et décompressez l'archive. Ouvrez le dossier vitahelloworld-master et cliquez sur "Fichier" puis "Ouvrir l'invite de commandes". Tapez simplement « make » et ça compilera tout seul !

Vous pouvez installer le ".VPK" créé et lancer le homebrew que vous avez compilé sur votre console ! 

Vous pourriez vous arrêtez là mais si vous souhaitez créer vos propres applications, il vous faudra installer des librairies supplémentaires.

2) Installation de bibliothèques supplémentaires

Il est parfois intéressant d'ajouter de nouvelles bibliothèques pour avoir de nouvelles fonctions à utiliser. Pour cela, il faut télécharger la librairie en question et la compiler. Cependant, il faudra parfois suivre les instructions données avec la librairie pour réussir la compilation.

Pour vous donner un exemple, nous allons compiler et installer la libftpvita de xerpi. Commencez par téléchargez et extraire les fichiers. Ouvrez le dossier "libftpvita", et cliquez droit tout en maintenant la touche Shift pour sélectionner "Ouvrir l'invite de commandes" (il se peut que cette option n'apparaisse pas, dans ce cas déplacez le dossier "libftpvita" sur votre Bureau). Comme pour compiler un homebrew, écrivez simplement « make ». La librairie est compilée, maintenant, il faut l'installer !

Dans le dossier "libftpvita", un fichier libftpvita.a a été créé. Déplacez-le dans le dossier "C:\devkitPro\arm-vita-eabi\lib". Retournez dans le dossier où la bibliothèque a été compilée et copiez le fichier "ftpvita.h" dans le dossier "C:\devkitPro\arm-vita-eabi\include". Voilà, la librairie est installée ! 

Si vous voulez faire des tests, sachez que les librairies sont souvent accompagnées d'exemples qu'il vous suffit de compiler.

Si vous avez le moindre problème, n'hésitez pas à poser votre question dans la section programmation de notre forum. Si vous voulez lâcher un commentaire de remerciement, c'est aussi possible à la suite de ce tutoriel !  Merci pour votre lecture passionnée !

L’article [PSV] [PSTV] [PC] TUTO - Installer et utiliser le VitaSDK est apparu en premier sur Custom Protocol.

@Applelo1 @MisterAl3x There are a lot of things that need to be changed in lpp-vita but PSVITA scene is so dead that i lost interest on it.

— Rinnegatamante (@Rinnegatamante) 9 avril 2016

Sur PSP, de nombreux homebrews étaient développés en Lua et le nombre de Lua Player disponible étaient conséquents. On retrouve une dizaine de Lua Player tous différents les uns des autres par leurs fonctionnalités et les performances proposés. 

Cependant, avec l'arrivé de HENKaku, le développeur italien a décidé de reprendre le développement du Lua Player Plus pour PSVita. Pour cette version 0.3, le développeur a changé le nom de plusieurs fonctions pour les faire coïncider avec son homologue 3DS. Ainsi de nombreuses fonctions ne sont plus dans la catégorie "Screen" mais dans "Graphics".

Deux fonctions, System.loadElf() et Screen.getFramerate() ont été retirés car elles ne sont plus utiles avec le nouveau hack HENKaku. Cependant deux autres ont été ajoutés, System.setCpuSpeed() et System.getCpuSpeed() qui permettent de choisir et d'obtenir la fréquence du processeur.

Plusieurs améliorations ont été également effectuées comme le support du Multi-Touch pour le tactile avant et arrière ou la possibilité de générer son propre .VPK avec ses fichiers Lua à l'intérieur !

On regrette cependant le manque de nouvelles fonctions sachant que le VitaSDK et de nombreuses librairies proposent des fonctionnalités supplémentaires.

Espérons que les prochaines versions apporteront leurs lots de nouveautés comme le support du son.

L’article [Vita] Le Lua Player Plus est de retour ! est apparu en premier sur Custom Protocol.

L'un des gros inconvénients était son incompatibilité avec l'émulateur de PSP pour PC et Android, PPSSPP, notamment au niveau des polices d'écritures. Voilà qui est corrigé si vous nommez votre police "oneFont.pgf" à la racine de votre homebrew, celle-ci sera utilisée alors par l'émulateur. N'oubliez pas de désactiver le Sofware Rendering et de cocher Fast Memory (unstable) dans les options de PPSSPP pour que votre homebrew se lance correctement ! ^^

Vous avez envie d'ajouter vos propres fonctions en C ? C'est possible grâce à la fonction os.requiere() via l'API (interface de programmation) incorporé au ONELua. Si vous aimez la syntaxe d'écriture du C, vous pouvez maintenant utiliser les opérations du langage comme la somme avec "+=" ou la soustraction "-=" par exemple.

Vous pouvez aussi dorénavant utiliser tous les boutons présents sur la PSP. Ainsi les boutons de volumes, Home/,  et  sont disponibles.

Comme si cela ne suffisait pas, vous pouvez maintenant utiliser les fonctionnalités infrarouges de votre PSP 1000 et si vous possédez une caméra, la Go! Cam ou celle de votre PS Vita, vous pouvez également utiliser des fonctions dédiés.

Si vous aimez dessiner des formes, vous allez être servi. Le ONELua peut maintenant dessiner des cercles, des triangles, des arcs... avec ou sans dégradé, remplis ou non, partiellement ou entièrement affichés.

De nombreuses autres nouveautés comme de nouveaux effets de splash screen, la possibilité de charger des images BMP, de récupérer de nouvelles données pour les autorisations de fichier ou récupérer la jaquette d'un MP3 par exemple sont au menu de cette version V4R1, ainsi que de nouveaux effets 3D et de nouvelles fonctions relatives au hardware. On peut noter également de nombreuses optimisations et corrections de bugs.

Peut on dire que le ONELua est le meilleur Lua Player sur PSP ? La réponse est oui car celui-ci propose un lot de fonctions conséquents tout en étant optimisé ! Le trio va continuer de développer le Lua Player mais sur d'autres plateformes comme sur PC. On attend cela avec impatience ! ;)

L’article [PSP] Le ONELua revient avec une mise à jour V4R1 est apparu en premier sur Custom Protocol.