Tutoriels Direct3D 10 : DXUT

Dans ce tutoriel, deux boîtes de dialogue sont ajoutées. L'une s'appelle g_HUD, et contient le même code que les exemples Direct3D 10. L'autre s'appelle g_SampleUI et illustre des fonctions qui sont spécifiques à ce tutoriel. La seconde boîte de dialogue sert à contrôler le caractère "bouffi" du modèle. Elle règle une variable qui est transmise aux shaders.

    CDXUTDialog g_HUD;      // gère la 3D UI
    CDXUTDialog g_SampleUI; // boîte de dialogue pour les commandes spécifiques de l'exemple

Les boîtes de dialogue sont contrôlées par une classe appelée CDXUTDialogResourceManager. Elle transfère les messages et gère des ressources qui sont partagées par les boîtes de dialogue.

    CDXUTDialogResourceManager g_DialogResourceManager; // gestionnaire des ressources partagées par les boîtes de dialogue

Finalement, une nouvelle fonction de rappel est associée aux évènements qui sont traités par le GUI. Cette fonction sert à gérer l'interaction entre les commandes.

    void CALLBACK OnGUIEvent( UINT nEvent, int nControlID, CDXUTControl* pControl, void* pUserContext );

Parce que davantage d'usages ont été introduits et doivent être initialisés, ce tutoriel reporte l'initialisation de ces modules vers une fonction séparée appelée InitApp().

Les commandes pour chaque boîte de dialogue sont initialisées dans cette fonction. Chaque boîte de dialogue appelle sa fonction Init et passe au gestionnaire de ressources pour spécifier où les commandes doivent être placées. Elle règle aussi la fonction de rappel pour traiter les réponses GUI. Dans ce cas, la fonction de rappel associée est OnGUIEvent.

    g_HUD.Init( &g_DialogResourceManager );
    g_SampleUI.Init( &g_DialogResourceManager );
    g_HUD.SetCallback( OnGUIEvent );
    g_SampleUI.SetCallback( OnGUIEvent );

Après que chaque boîte de dialogue ait été initialisée, elle peut insérer les commandes à utiliser. HUD ajoute trois boutons à la fonctionnalité de base : touche plein écran, touche rendu de référence (logiciel), et modifier le device.

Pour ajouter un bouton, spécifiez l'identifiant IDC à utiliser, une chaîne à afficher, les coordonnées, la largeur et la longueur, et facultativement un raccourci clavier à associer au bouton.

Notez que les coordonnées sont relatives à l'ancre de la boîte de dialogue.

    int iY = 10; 
    g_HUD.AddButton( IDC_TOGGLEFULLSCREEN, L"Toggle full screen", 35, iY, 125, 22 );
    g_HUD.AddButton( IDC_TOGGLEREF, L"Toggle REF (F3)", 35, iY += 24, 125, 22 );
    g_HUD.AddButton( IDC_CHANGEDEVICE, L"Change device (F2)", 35, iY += 24, 125, 22, VK_F2 );

De façon similaire, pour l'interface utilisateur de l'exemple, trois commandes sont ajoutées - un texte statique, une barre de défilement et une case à cocher.

Les paramètres du texte statique sont l'identifiant IDC, la chaîne, les coordonnées, la largeur et la hauteur.

Les paramètres de la barre de défilement sont l'identifiant IDC, les coordonnées, la largeur et la hauteur, puis les valeurs min et max de la barre de défilement, enfin la variable où stocker le résultat.

Les paramètres de la case à cocher sont l'identifiant IDC, une étiquette de chaîne, les coordonnées, la largeur et la hauteur, et la variable booléenne où stocker le résultat.

    iY = 10;
    WCHAR sz[100];
    iY += 24;
    StringCchPrintf( sz, 100, L"Puffiness: %0.2f", g_fModelPuffiness ); 
    g_SampleUI.AddStatic( IDC_PUFF_STATIC, sz, 35, iY += 24, 125, 22 );
    g_SampleUI.AddSlider( IDC_PUFF_SCALE, 50, iY += 24, 100, 22, 0, 2000, (int)(g_fModelPuffiness*100.0f) );
    
    iY += 24;
    g_SampleUI.AddCheckBox( IDC_TOGGLESPIN, L"Toggle Spinning", 35, iY += 24, 125, 22, g_bSpinning );

Lorsque les boîtes de dialogue ont été initialisées, il faut les placer à l'écran. Cela se fait en appelant OnD3D10ResizedSwapChain, parce que les coordonnées d'écran peuvent changer chaque fois que la swap chain est recréée - par exemple si l'on redimensionne la fenêtre.

    g_HUD.SetLocation( pBackBufferSurfaceDesc->Width-170, 0 );
    g_HUD.SetSize( 170, 170 );
    g_SampleUI.SetLocation( pBackBufferSurfaceDesc->Width-170, pBackBufferSurfaceDesc->Height-300 );
    g_SampleUI.SetSize( 170, 300 );

Finalement, les boîtes de dialogue doivent être identifiées dans la fonction OnD3D10FrameRender. Cela permet qu'elles soient dessinées afin que l'utilisateur puisse effectivement les voir.

    //
    // Rendu de l'interface utilisateur
    //
    g_HUD.OnRender( fElapsedTime ); 
    g_SampleUI.OnRender( fElapsedTime );

Après que tout ait été initialisé, on peut écrire du code pour traiter les interactions GUI. Pendant l'initialisation des boîtes de dialogue, on règle la fonction de rappel sur OnGUIEvent. On peut maintenant créer la fonction OnGUIEvent qui surveille les évènements liés au GUI puis les traite (le GUI est invoqué par l'environnement cadre).

OnGUIEvent est une fonction simple qui contient une instruction de cas pour chaque identifiant IDC détecté quand les boîtes de dialogue ont été créées. Chaque instruction de cas contient le code de gestion d'évènement, en présumant que l'utilisateur interagisse avec la commande. Le code ici est très similaire au code Win32 qui gère les commandes.

Les commandes liées aux fonctions d'appel HUD sont incorporées dans DXUT. Il existe une fonction DXUT pour alterner entre les modes plein écran et fenêtré, pour activer et désactiver le moteur de rendu du logiciel de référence et pour modifier les réglages du device.

La boîte de dialogue SampleUI contient un code personnalisé pour manipuler les variables associées à la barre de défilement. Elle collecte la valeur, actualise le texte associé et transfère la valeur au shader.

    void CALLBACK OnGUIEvent( UINT nEvent, int nControlID, CDXUTControl* pControl, void* pUserContext )
    {
        
        switch( nControlID )
        {
            case IDC_TOGGLEFULLSCREEN: DXUTToggleFullScreen(); break;
            case IDC_TOGGLEREF:        DXUTToggleREF(); break;
            case IDC_CHANGEDEVICE:     g_D3DSettingsDlg.SetActive( !g_D3DSettingsDlg.IsActive() ); break;
    
            case IDC_TOGGLESPIN:
            {
                g_bSpinning = g_SampleUI.GetCheckBox( IDC_TOGGLESPIN )->GetChecked();
                break;
            }
    
            case IDC_PUFF_SCALE: 
            {
                g_fModelPuffiness = (float) (g_SampleUI.GetSlider( IDC_PUFF_SCALE )->GetValue() * 0.01f);
    
                WCHAR sz[100];
                StringCchPrintf( sz, 100, L"Puffiness: %0.2f", g_fModelPuffiness ); 
                g_SampleUI.GetStatic( IDC_PUFF_STATIC )->SetText( sz );
    
                g_pPuffiness->SetFloat( g_fModelPuffiness );
                break;
            }
        }
        
    }

A présent, nous avons des messages de boîte de dialogue et des interactions d'utilisateur. Les messages qui sont transmis à l'application doivent être traités par les boîtes de dialogue. Le code correspondant est traité dans la fonction de rappel MsgProc qui est fournie par DXUT. Dans les tutoriels précédents, cette section est vide parce qu'il n'y a pas de message à traiter. A présent, on doit s'assurer que les messages destinés au gestionnaire de ressources et aux boîtes de dialogue sont convenablement acheminés.

Aucun code de traitement de message spécial n'est requis. On se contente d'appeler les MsgProcs pour chaque boîte de dialogue pour s'assurer que le message est traité. On le fait en appelant la fonction MsgProc qui correspond à chaque classe. Notez que la fonction fournit un registre pour notifier à l'environnement cadre qu'aucun autre traitement du message n'est nécessaire, et donc que l'environnement cadre peut se fermer.

    LRESULT CALLBACK MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, bool* pbNoFurtherProcessing, void* pUserContext )
    {
        // Toujours permettre aux appels du gestionnaire de ressources de boîte de dialogue de gérer les messages globaux
        // ainsi l'état GUI sera actualisé correctement
        *pbNoFurtherProcessing = g_DialogResourceManager.MsgProc( hWnd, uMsg, wParam, lParam );
        if( *pbNoFurtherProcessing )
            return 0;
    
        if( g_D3DSettingsDlg.IsActive() )
        {
            g_D3DSettingsDlg.MsgProc( hWnd, uMsg, wParam, lParam );
            return 0;
        }
    
        // Permettez aux boîtes de dialogue de traiter le message en premier
        *pbNoFurtherProcessing = g_HUD.MsgProc( hWnd, uMsg, wParam, lParam );
        if( *pbNoFurtherProcessing )
            return 0;
        *pbNoFurtherProcessing = g_SampleUI.MsgProc( hWnd, uMsg, wParam, lParam );
        if( *pbNoFurtherProcessing )
            return 0;
    
        if( uMsg == WM_CHAR && wParam == '1' )
            DXUTToggleFullScreen();
    
        return 0;
    }

Le premier paramètre transmis est la fonte à tracer. Cette fonte est du type ID3DXFont qui est fourni par D3DX. Pour initialiser la fonte, appelez D3DX10CreateFont et transférez le device, la hauteur, la largeur, la nuance, les niveaux mipmap (généralement 1), l'italique, le jeu de caractères, la précision, la qualité, la chasse et la famille, le nom de la fonte et le pointeur de l'objet. Seuls les quatre premiers et les deux derniers éléments de cette liste sont vraiment importants.

    V_RETURN( D3DX10CreateFont( pd3dDevice, 15, 0, FW_BOLD, 1, FALSE, DEFAULT_CHARSET, 
                                OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, 
                                L"Arial", &g_pFont ) );

Le deuxième paramètre exige que l'on initialise une classe ID3DXSprite. Pour le faire, on appelle D3DX10CreateSprite. Les seules choses que la fonction exige comme paramètres sont le device, le nombre maximum de sprites dessinés sur une trame et le pointeur de l'objet.

    // Initialise le sprite
    V_RETURN( D3DX10CreateSprite( pd3dDevice, MAX_SPRITES, &g_pSprite ) );

Comme pour tout autre objet, la fonte et le sprite doivent être détruits après que l'on en ait fini avec eux. On peut le faire en utilisant la macro SAFE_RELEASE.

    SAFE_RELEASE( g_pFont );
    SAFE_RELEASE( g_pSprite );

Le texte dans cet exemple inclut des statistiques sur le rendu. Il y a aussi une section d'aide qui explique comment manipuler le modèle en utilisant la souris.

Les appels de rendu doivent être faits dans OnD3D10FrameRender. Ici, on appelle RenderText10 dans le cadre de l'appel de rendu de trame.

La première section est toujours rendue la première. Le premier appel à rendu de texte est Begin(). Cela notifie à l'appareil de commencer à envoyer du texte à l'écran. Ensuite, on règle la position du curseur et la couleur du texte. A présent, on peut tracer.

La sortie de la chaîne de texte s'effectue en appelant DrawTextLine. La transmission de la chaîne et la sortie qui correspond à la chaîne sont assurées à la position en cours. Le curseur est incrémenté pendant l'écriture du texte. Par exemple, si la chaîne contient "\n", le curseur est automatiquement déplacé à la ligne suivante.

    // Statistiques de sortie
    txtHelper.Begin();
    txtHelper.SetInsertionPos( 2, 0 );
    txtHelper.SetForegroundColor( D3DXCOLOR( 1.0f, 1.0f, 0.0f, 1.0f ) );
    txtHelper.DrawTextLine( DXUTGetFrameStats() );
    txtHelper.DrawTextLine( DXUTGetDeviceStats() );

Il existe une autre méthode pour assurer la sortie de texte, qui est similaire à printf. Formatez la chaîne en utilisant des caractères spéciaux puis insérez des variables dans la chaîne. Utilisez DrawFormattedTextLine à cette fin.

    txtHelper.SetForegroundColor( D3DXCOLOR( 1.0f, 1.0f, 1.0f, 1.0f ) );
    txtHelper.DrawFormattedTextLine( L"fTime: %0.1f  sin(fTime): %0.4f", fTime, sin(fTime) );

Puisque le texte d'aide est tracé de la même manière, on n'a pas besoin de passer en revue son code.

Vous pouvez repositionnez le pointeur à tout moment en appelant SetInsertionPos.

Quand vous êtes satisfait de la sortie de texte, appelez End() pour en notifier le device.