Blog de Kosh

Petite pub pour mes sessions aux TechDays 2009:

 DirectX10 pour les Windows Forms

 Nouveautés de WPF 3.5 SP1

 Coding4Fun

Comme toujours mes sessions sont très orientées 3D et présentation. Nous parlerons donc de DirectX10, de pixels shaders et avec Mitsu nous vous montrerons que l’on peut s’amuser avec des petites applications “ludiques” ;)

DirectX, .Net, Windows, WPF

Cela arrive même aux meilleurs! La fuite mémoire! Le truc horrible qui peut faire suer des heures durant.

J’ai donc découvert récemment une fuite mémoire dans Nova. Devant une telle horreur j’allais prévenir ma femme de mon indisponibilité sur les 7 prochaines nuits. Quand tout à coup j’ai découvert un superbe outil au sein même du SDK DirectX.

Lorsque l’on installe le SDK de DirectX, il ajoute un control panel spécifique. Ce dernier permet notamment d’activer le mode debug de DirectX.

Dans ce mode, lorsque l’on lance une application utilisant DirectX elle trace dans la fenêtre de sortie de nombreuses informations et notamment les fuites mémoires.

Dans les informations associées à une fuite, DirectX fait apparaitre le numéro d’allocation (AllocID). Or, il est possible avec le control panel de DirectX de demander un break de l’exécution lorsqu’une certaine allocation a lieu.

Cette merveilleuse fonctionnalité permet donc de déclencher le debuggeur à l’endroit précis ou a lieu l’allocation de mémoire qui ne sera pas libérée.

DirectX

Suite à plusieurs demandes, je viens de mettre en ligne le code de PowerPoint3D. Ce projet utilise le SDK de Nova 2008.

Il s'agit d'un projet Visual Studio 2008 qui va référencer à la fois Nova et les dll managed de DirectX. L'ensemble des assemblies sont présentes dans l'archive.

Attention toutefois, le SDK de Nova est en mode gratuit et donc ne peut fonctionner que 5 minutes d'affilée.

Le fonctionnement de l'ensemble est relativement simple: Le projet charge un fichier pptx (pres.pptx) et extrait les images de chaque slide. Il charge ensuite une scène Nova et remplace les textures d'un objet à la volée avec le slide courant.

Le projet Visual Studio 2008 : ici.

.Net, DirectX, Nova

Grande nouvelle!!! Le superbe SlimDX vient de sortir estampillé "Mars 2008". Et autant vous le dire tout de suite, ça déchire. Nous avons enfin un wrapper managed pour DirectX 9 ET 10.

Excité comme une puce je me suis levé à 6h ce matin (impossible de dormir avec ça en tête) et j'ai commencé le portage du provider DirectX 9 de Nova depuis Managed DirectX (celui de Microsoft en 1.1) vers SlimDX.

Résultat des courses : génial. SlimDX tire parti des generics ce qui donne un code bien plus concis. De plus, l'API parfois un peu lourde de Managed DirectX est maintenant plus logique (adieu les classes statiques utilitaires du style TextureLoader, tout est sur Texture).

DirectX 9 est quasi parfaitement couvert (j'ai juste noté l'absence d'un enum : FogMode).

Je ne me suis pas encore penché sur DirectX 10 mais ca sent très très bon:)

Pour découvrir tout ça en live : SlimDX.

.Net, DirectX

Si vous n'avez pu assister à mes sublimes sessions aux TechDays 2008, vous pouvez désormais les consulter en Webcasts aux adresses suivantes:

• Interop Windows Forms - WPF : le meilleur des deux mondes
• XNA, Introduction au développement de jeux PC et XBox360
• Utiliser la technologie DirectX 10 en .NET

Have fun.

.Net, DirectX, WPF

Je crois rêver!! Je me casse l'oignon à écrire un wrapper DirectX 10 sur le SDK C++ de Novembre pour Nova.

Je passe sur les grands moments d'euphorie que permet d'avoir l'interop .Net/C++ pour m'arrêter sur un truc super louche.

Une méthode du SDK C++ plante comme un gros veau bourré à la bière.

J'ai pourtant fait un test super simple (pour vos yeux sensibles je mets la version propre en C#:)

InputElement[] elements = new InputElement[]
{
    new InputElement("POSITION", 0, Format.R32G32B32Float, 

0, 0, InputClassification.PerVertexData, 0),
    new InputElement("TEXCOORD", 0, Format.R32G32Float, 

0, 12, InputClassification.PerVertexData, 0)
};
InputElement[] elements2 = new InputElement[]
{
    new InputElement("POSITION", 0, Format.R32G32B32Float, 

0, 0, InputClassification.PerVertexData, 0),
};


Mesh mesh = new Mesh(device, elements, "POSITION", 3, 1, MeshFlags.None);

Mesh totoMesh = new Mesh(mesh, elements2, "POSITION", MeshFlags.None);

Sur la ligne qui tente de créer totoMesh, j'ai un joli crash "attempted to read bla bla bla".

J'ai bien sur fait le même code en C++ et ça gaufre au moins autant (certes avec moins de classe).

Alors bien sur, vous allez me dire : "Google est ton ami". Et c'est là que c'est étrange.

J'ai trouvé quelques posts sur le même problème que moi mais bizarrement sans réponse.

Comme si on essayait d'étouffer l'affaire.

De là à croire que leurs auteurs ont essayé d'apprendre à nager avec des chaussettes en béton...

En tout cas si quelqu'un connaît une solution pour cloner mes meshs DirectX10 je suis preneur.

.Net, DirectX

Continuant ma quête du Graal, j'ai trouvé deux projets Open Source de wrappers de DirectX. Ces deux projets fournissent des projets C++ CLI fournissant une encapsulation de DirectX 9 et 10:

• SlimDX :Disponible sur Google Code

=>http://code.google.com/p/slimdx/

• Managed Layer for DirectX 10 (MD3D10): Disponible sur CodePlex

=>http://www.codeplex.com/MD3D10

SlimDX fournit une encapsulation très proche de celle de feu Managed DirectX 9 (développé par Tom Miller de Microsoft).

MD3D10 quand à lui fournit une API différente mais propose une encapsulation plus complète à l'heure actuelle et notamment un wrapper pour DirectX9 for Vista (Une version additionnelle de DirectX 9 présente sur Vista et qui permet d'améliorer les performances de DirectX 9 sous VIsta).

Aujourd'hui toutefois il semblerait que l'équipe qui se charge de SlimDX soit plus active car ce dernier évolue très vite.

Ceci est donc très rassurant, l'avenir de DirectX en .Net s'éclaircit mais il ne passera sans doute pas par Microsoft.

.Net, DirectX

Lors de ma session aux TechDays 2008, j'ai animé une session sur DirectX10 et .Net.

Or, lors d'une démo j'ai écris le code nécessaire à l'affichage d'un triangle 2D rouge sur un fond bleu.

Sauf que la démo a surtout affiché le fond bleu :).

La raison était toute simple : j'avais oublié de définir le viewport!!!

Les pixels étaient envoyés à l'écran entre (-1.0, -1.0) et (1.0, 1.0). Voila tout!!

Grâce au viewport, ils seront envoyés entre (0, 0) et (1024, 768).

Le code final donne donc ça (le projet complet est dispo ici) :

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using SlimDX.Direct3D10;
using SlimDX;
using SlimDX.Direct3D;
using System.IO;

public partial class Form1 : Form
{
    Device device;
    SwapChain swapChain;
    RenderTargetView view;
    SlimDX.Direct3D10.Buffer vertexBuffer;
    Effect effect;
    EffectTechnique technique;
    EffectPass pass;
    InputLayout layout;
    Viewport viewport = new Viewport();
    RasterizerState state;


    public Form1()
    {
        InitializeComponent();
    }

    private void cmdInitDevice_Click(object sender, EventArgs e)
    {
        // Device
        device = new Device(DriverType.Hardware, DeviceCreationFlags.Debug);

        CreateSwapChain();

        // Effect
        string err;
        effect = Effect.FromFile(device, "MyEffect.fx", "fx_4_0", out err);
        technique = effect.GetTechniqueByIndex(0);
        pass = technique.GetPassByIndex(0);


        InputElement[] elements = new InputElement[]
        {
            new InputElement("POSITION", 0, Format.R32G32B32_Float, 0, 0, 
                InputClassification.PerVertexData, 0),
        };

        layout = new InputLayout(device, elements, pass.Signature);
    }

    private void CreateSwapChain()
    {
        if (swapChain != null)
        {
            swapChain.Dispose();
            swapChain = null;
        }

        // Swap chain
        SwapChainDescription description = new SwapChainDescription();

        description.BufferCount = 1;
        description.Flags = SwapChainFlags.None;
        description.Format = Format.R8G8B8A8_UNorm;
        description.Height = panel1.Height;
        description.Width = panel1.Width;
        description.Windowed = true;
        description.RefreshRate = new Rational(60, 1);
        description.SampleCount = 1;
        description.SampleQuality = 0;
        description.Scaling = DisplayModeScaling.Unspecified;
        description.ScanlineOrdering = DisplayModeScanlineOrdering.Unspecified;
        description.Usage = SurfaceUsage.RenderTargetOutput;
        description.SwapEffect = SwapEffect.Discard;
        description.OutputHandle = panel1.Handle;

        swapChain = new SwapChain(device, description);

        using (Texture2D backBuffer = swapChain.GetBuffer(0))
        {
            view = new RenderTargetView(device, backBuffer);
            device.OutputMerger.SetTargets(view);
        }

        // Viewport
        viewport.X = panel1.ClientRectangle.Left;
        viewport.Y = panel1.ClientRectangle.Top;
        viewport.Width = panel1.ClientSize.Width;
        viewport.Height = panel1.ClientSize.Height;
        viewport.MinZ = 0.0f;
        viewport.MaxZ = 1.0f;

        device.Rasterizer.SetViewports(viewport);

        // States
        RasterizerStateDescription desc = new RasterizerStateDescription();
        desc.CullMode = CullMode.None;
        state = new RasterizerState(device, desc);
    }

    internal void Render()
    {
        if (view != null)
        {
            view.Clear(new SlimDX.Direct3D.ColorValue(0, 0, 1.0f));

            if (vertexBuffer != null)
            {
                device.InputAssembler.SetInputLayout(layout);
                device.InputAssembler.SetPrimitiveTopology(
                    PrimitiveTopology.TriangleList);
                device.InputAssembler.SetVertexBuffers(0, 
                    new VertexBufferBinding(vertexBuffer, 3 * sizeof(float), 0));

                // States
                device.Rasterizer.State = state;

                // Render
                for (int index = 0; index < technique.PassCount; index++)
                {
                    technique.GetPassByIndex(index).Apply();
                    device.Draw(3, 0);
                }
            }

            swapChain.Present(0, 0);
        }
    }

    private void cmdCreateGeometry_Click(object sender, EventArgs e)
    {
        // Vertex Buffer
        DataStream data = new DataStream(sizeof(float) * 9, false, true);

        data.Write(-1.0f);
        data.Write(0.0f);
        data.Write(0);

        data.Write(0.0f);
        data.Write(1.0f);
        data.Write(0);

        data.Write(1.0f);
        data.Write(0.0f);
        data.Write(0);

        data.Seek(0, System.IO.SeekOrigin.Begin);
        
        vertexBuffer = new SlimDX.Direct3D10.Buffer(device, sizeof(float) * 9
        , data, ResourceUsage.Immutable, BindFlags.VertexBuffer, 
        CpuAccessFlags.None, ResourceOptionFlags.None);
    }

    private void panel1_Resize(object sender, EventArgs e)
    {
        CreateSwapChain();
    }
}

.Net, DirectX

Je suis aterré, il n'y a pas d'autres termes. Je viens d'apprendre de source sure (Guillaume Random de Microsoft, qui a eu l'opportunité de poser la question aux développeurs en charge de DirectX 10) que Managed DirectX 10 ne verra pas le jour.

Chouette, donc si je récapitule, DirectX 10 ne marche QUE sur Vista et en plus il n'y aura pas de version managed. Mais quel message comprendre dans ce cas là? Le .Net n'est-il pas LA technologie majeure et d'avenir sur plateforme Windows?

Il faut être idiot quand même. D'autant plus qu'une version managed d'excellente facture existait pour DirectX 9.

C'est extrêmement rare mais là je suis très décu par l'attitude de l'équipe DirectX. Aucune justifcation aujourd'hui (à l'heure ou de plus en plus de technologies deviennent accessibles en .Net) n'est recevable. Il faut développer un wrapper Managed DirectX 10.

Quand je vois le tollé général que souléve le fait que DirectX 10 ne marche que sur Vista, rajouter à cela le non support pour .Net me semble suicidaire pour reprendre les termes de Gabe Newell (Patron de Valve qui a produit Half-Life 1 et 2).

DirectX