Petit programme PS Suite

Premièrement, essayez d'éxecuter le petit programme PS Suite.

Lancez PS Suite Studio et ouvrez le dossier "Sample/Tutorial" avec Fichier -> Ouvrir.. .

Le dossier Sample/Tutorial est installé dans à l'endroit suivant, par défaut.

• Windows XP: "C:/Documents and Settings/All Users/Documents/Pss/"
• Windows 7 : "C:/Users/Public/Documents/Pss/"

sample/Tutorial/Sample01

Les fichiers avec l'extension sln sont appelés solutions. Ils décrivent les structures des fichiers du project.

Les fichiers avec l'extension csproj sont appelés fichiers de projet. Ils dévcrivent les structures du code source (fichiers cs) et la méthode de compilation.

Le contenu du dossier Sample01 pour construire une application est appelé "Project".

Note: S'il vous plaît soyez conscient que "le fichier de projet: csproj" et "Projet" ont des sens différents.

Structure relationnel entre les fichiers Solutions et les fichiers Projets

Un fichier de solution est le point de départ d'un projet; ouvrez ce fichier lorsque vous commencez le développement d'une application.

Une fois que le fichier solution est ouvert, compiler et appuyez sur la touche F5 pour exécuter.

Félicitation! Toutefois, seul un écran noir s'affichera pour ce programme, rien d'autre ne va se passer. Cliquez sur le bouton X dans le coin supérieur droit de la fenêtre ou appuyez sur Maj + F5 dans PS Suite Studio pour quitter le programme.

Structure basique d'une application PS Suite

Tout d'abord, regardez le code source. Pour regarder le code source, double-cliquez sur AppMain.cs dans "Solution Explorer" sur le côté gauche.

public class AppMain
{
    static protected GraphicsContext graphics;

    public static void Main (string[] args)
    {
        Initialize ();

        while (true) {
            SystemEvents.CheckEvents();
            Update ();
            Render ();
        }
    }

    public static void Initialize ()
    {
        graphics = new GraphicsContext();
    }

    public static void Update ()
    {

    }

    public static void Render ()
    {
        graphics.Clear();


        graphics.SwapBuffers();

    }
}

Ici, notez Main(), Initialize(), SystemEvents.CheckEvents(), Update(), Render(), et SwapBuffers().

Main()

• Un programme commence par Main(). Toutes les applications recquiert une fonction Main(). Si il y en a deux ou plus, une erreur de compilation se produira.

Initialize()

• Le contenu de la fonction Initialize() décrit essentiellement le traitement d'initialisation. Ce traitement est effectué une seule fois lors du démarrage dans cette structure de programme.

while

• Ensuite, on entre dans une boucle avec "while". En d'autres mots, les processus SystemEvents.CheckEvents(), Update(), et Render() sont répétés à l'intérieur de cette boucle.

  SystemEvents.CheckEvents()

  • Les événements dépendants l'OS seront vérifiés avec SystemEvents.CheckEvents(). Un appareil sous android, par exemple, detectera un événement quand une application sera réduite. Dans Windows le traitement des messages en fenêtre sera détécté ici, etc.

  Update()

  • Le traitement de calcul, etc. Traités par le CPU est principalement décrit dans Update().

  Render()

  • Le traitement de rendu et le traitement de calcul, etc. Traités par le GPU est principalement décrit dans Render(). Dans Render(), les frame buffers (mémoires d'écran) sont d'abord effacé avec graphics.Clear().

  SwapBuffers()

  • Les frame buffers (mémoires d'écran) sont commutées avec le cadencement de synchronisation verticale à l'aide SwapBuffers ().

"Les frame buffers (mémoires d'écran) qui sont commutées avec le cadencement de synchronisation verticale" (décrit ci-dessus) seront expliqué plus en détail ici.

Pour faciliter la compréhension du fonctionnement du programme, nous allons changer le programme comme suit. <-sections à ajouter.

public class AppMain
{
    static protected GraphicsContext graphics;
    static int colorValue=0;    //<- here.

    public static void Main (string[] args)
    {
        Initialize ();

        while (true) {
            SystemEvents.CheckEvents ();
            Update ();
            Render ();
        }
    }

    public static void Initialize ()
    {
        graphics = new GraphicsContext();
    }

    public static void Update ()
    {
        colorValue++;       //<- here.
        if(colorValue>255)  //<- here.
            colorValue=0;   //<- here.

        graphics.SetClearColor(colorValue, colorValue, colorValue, 255);//<- here.
    }

    public static void Render ()
    {
        graphics.Clear();

        graphics.SwapBuffers();
    }
}

Lorsque ce programme est exécuté, la couleur de fond d'écran devient de plus en plus blanc, puis passe à nouveau au noir.

graphics.SetClearColor(int r, int g, int b, int a) efface l'écran avec les couleurs entrées en argument.

r=255, g=255, b=255 correspond au blanc.

"a" est appelé cannal alpha et indique le niveau de transparence. La valeur 0 correspond à totalement transparent, et 255 complétement opaque.

Donc vous pouvez voir que colorValue++; est traité encore et encore.

Sur le simulateur sur PC, cette valeur est mise à jour 60 fois à la seconde, en d'autres mots elle est mise à jour toutes les 16.6 millisecondes.

Déroulement des opérations

Double mémoire tampon

Le schéma suivant illustre le déroulement des opérations.

La zone de (mémoire vidéo) affichée sur l'écran est appelée un frame buffer.

En général, les applications de jeux ont deux zones d'images qui sont affichées sur l'écran. C'est appelé un double buffer (double mémoire tampon).

Les flux de rendu utilisent le mode opératoire suivant.

1. Tout d'abord la zone arrière(back) sera effacée avec r=1, g=1, b=1 (le schéma précédent a été ajusté en blanc pour être facilement compréhensible).
2. On attend pendant 16 millisecondes après que se soit terminé le rendu.
3. Quand 16 millisecondes se sont écoulées, la zone effacée avec r=1, g=1, b=1 est déplacée vers l'avant (front)..
4. Maintenant, la zone arrière devra être effacée par r=2, g=2, b=2.
5. Après, on attend 16 millisecondes que le rendu se termine.
6. Quand 16 millisecondes se sont écoulées, la zone effacée avec r=2, g=2, b=2 est déplacée vers l'avant (front).

Le programme s'exécute tant que ce traitement se répète.

La commutation des zones et l'affichage évite un écran brouillé au milieu du rendu.

Adapter la synchronisation de l'écran et commuter au moment où l'affichage est rafraîchi est appelé "En attente de (d'adaptation) synchronisation verticale de l'écran".

Parce que le rythme auquel l'affichage est rafraîchi est d'environ 16,6 millisecondes (Note 1), le moment auquel le frame buffer (mémoire écran) est commuté est adapté à cette valeur.

L'emplacement de cette série de traitement est SwapBuffers ().

La fenêtre affichée en attendant la fonction SwapBuffers() pour basculer d'affichage s'appelle une frame.

"FPS" (Frames Par Secondes) est utilisé comme unité pour indiquer le nombre de rafraichissement de la Frame par seconde. Quand la Frame est rafraichit 60 fois par seconde, on l'écrit 60fps.

(Note 1) Notez que sur certains appareils Android, le taux n'est pas de 60fps.