Graphic Stream : Tips

Ombre en Silverlight

valentin — Wed, 18 Mar 2009 03:13:00 GMT

Aujourd'hui pour faire une ombre sous un contrôle en Silverlight il n'y a pas beaucoup de possibilités.

Le faire en vectoriel s'avère difficile et on a l'habitude de passer par une image PNG, ce qui n'est pas forcement le plus optimisé.

Voici un simple code qui permet de corriger cela, et en vectoriel. Vivement l'ajout d'effet en Silverlight pour eviter de passer par ce genre de tips...

<UserControl x:Class="SmartInterface.TravelingPanel"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

xmlns:d="http://schemas.microsoft.com/expression/blend/2008"

xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"

mc:Ignorable="d"

d:DesignWidth="640" d:DesignHeight="480"

Width="340" Height="340"

RenderTransformOrigin="0.5,0.5">

<Grid.ColumnDefinitions>

</Grid.ColumnDefinitions>

<Border Name="ExternalBorder"

CornerRadius="10,10,10,10"

Background="#FF92B825"

BorderBrush="#FF6D8A17" BorderThickness="1"

RenderTransformOrigin="0.5,0.5">

<Border Name="InternalBorder"

CornerRadius="10,10,10,10"

Background="#FF92B825"

BorderBrush="#FFB7D265" BorderThickness="1">

<Rectangle.Fill>

<RadialGradientBrush.RelativeTransform>

</TransformGroup>

</RadialGradientBrush.RelativeTransform>

</RadialGradientBrush>

</Rectangle.Fill>

</Rectangle>

<Rectangle.Fill>

</LinearGradientBrush>

</Rectangle.Fill>

</Rectangle>

</Canvas>

</Border>

</Grid>

</UserControl>

Les deux Border d'affilés provoquent cet effet d'ombrage réalisé relativement facilement et sutout très rapide à afficher pour le moteur graphique de votre plugin préféré. Le resultat est le suivant :

J'utilise un Border dans la mesure où le contrôle sur lequel j'applique un ombrage possède des cotés arrondis. Sur les contrôles carrés ou rectangulaires, l'utilisation du shape Line sera un meilleur choix. Enfin, il suffit de jouer sur la taille de la bordure (Thickness) pour affiner l'ombrage ainsi que le nombre de couche pour améliorer le rendu (ici de 0,60d à 0,10d).

A bientôt sur ce Blog !

Optimization de code pour du Xna rapide et efficace !

valentin — Sat, 28 Feb 2009 13:53:00 GMT

Je dois en omettre un grand nombre, si vous en avez d'autres n'hesitez pas à me les soumettre que je les rajoute ici !

Première optimisation, les strings :

Eviter tout indexeur à base de string s’il y’a un équivalent à base d’int.

L'instruction :

myEffect.Techniques["Precompiled"] ;

Est bien moins efficace q'un :

const int TechnikIndex = 0;

myEffect.Technique[TechnikIndex]

Eviter au maximum la class string, si on a besoin de puissance. En C# tout modification d'une string entraine la création d'une nouvelle instance et donc une allocation mémoire. Une string N EST JAMAIS MODIFIABLE et l'allocation mémoire est une opération très couteuse en temps. Il faut donc travailler un maximum avec StringBuilder.

Besoin de comprendre le string intern pool. Quand on créé une string, le clr regarde dans un pool interne si elle existe avant de la créer. (méthode statique Intern de la classe string).

Donc string jamais collectés comme les objets communs dans le GC.

Boxing/unboxing

Boxing passage d'un value type (exemple int) à une classe objet .

Par exemple :

int a = 0;

object o = (object)a;

Unboxing est l'opération inverse.

boxed = 20 fois plus de traitement CPU qu'une simple affectation de ref

unboxed = 4 fois plus

= généric autant que faire se peux (optimization en Early binding)

Pour les struct, implementer la méthode ToString (sinon il y’a boxing en objet pour chaque appel à cette méthode)

Array

Jagged Arrays > Rectangular Array ([][] > [,])

Privilegier les for au foreach (moins nécessaire depuis le .Net 3.0)

addrange plutot que add

Range Check important, exemple :

//rapide
for(int i = 0; i < myArray.Length; i++)
{
Console.WriteLine(myArray.ToString());
}
//plus lent
for(int i = 0; i < myArray.Length + y; i++)
{
Console.WriteLine(myArray[i+x].ToString());
}

Dans la seconde boucle le test ne porte pas sur la longueur du tableau traité mais sur une autre valeur, il y’a donc des tests supplémentaire ajouté en IL pour générer une exception en cas de sortir de Bounds.

Methodes :

Il y’a quelque regles simples pour que le compilateur utilise de l’inlined (suppresion à la compilation d'une méthode pour inclure son code en lieu et place de l'instruction appellant la dite méthode) :

32o d'il (8instructions) max par méthode/accesseur/mutateur à "inliner"
pas de structures conditionnelles dans le bloc à inliner
pas de type struct utilisé dans le bloc à inliner
pas de bloc Try/Catch/Finaly dans le bloc à inliner.

Si il n’y a pas besoin de rendre le code compréhensible on priviligiera les chunky call au maximum (méthodes énormes en lieu et place de myriades de petites méthodes qui s’appellent les unes les autres).

Thread

Synchroniser les thread : System.Threading.Interlocked class

Exception

retourner des enum plutot que des exception sur les méthodes critiques

Eviter ce genre de code :

public static void Main(string[] args){
int j = 0;
for(int i = 0; i < 10000; i++){
    try{
      j = i;
      throw new System.Exception();
    } catch {}
}
}

En asp.net, à eviter :

L’instruction : Response.Redirect() elle provoque un ThreadAbortException

Un throw d'exception perturbe gravement l'activité CPU associée à votre applicatif.

Objets

Utiliser au maximum les structure là ou la notion de référence n’est pas importante (besoin ponctuelle d’agrégat ordonné de données) en lieu et place d’une class

(Exemple de la structure Point, Rectangle, etc.) . La gestion en mémoire est alors bien plus efficace et rapide.

Apprecier au maximum l’attribut Fieldoffset qui permet de réaliser l’équivalent de l’Union du langage C pour optimiser la mémoire

Utiliser les weakreference notamment pour le cache, afin de ne pas surcharger la mémoire.

Framework :

Working Set : charger une assembly pour profiter d'une seule de ses méthodes c'est pas bien !

Utiliser vadump.exe pour détecter ca dans son framework

Se servir de Perfmon et de ses attributs (nb de classes chargées, nombre de méthodes, temps passé à loader, JITed, etc.)

Executables :

Précompilation avec ngen.exe pour les exes critiques. Permet de précompiler son application pour un premier lancement rapide.

SQL

connexion ouverte longtemps < multiple ouverture /fermeture de connexion

Datareader > dataset

Annuler le transaction enlistment si inutile

SqlConnection conn = new SqlConnection(

"Server=exasrv01;

Integrated Security=true;

Enlist=false");

Les meilleures sessions Xna aux techdays

valentin — Fri, 25 Jan 2008 12:32:00 GMT

Pour ceux qui vont aux techdays voici ce que je selectionnerai pour approcher tout ce qui touche au multimédia, jeux, developpement :

http://galilee.microsoft.fr/TechDays2008/Recherche-Session.aspx?Key=xna&domID=&PRODUIT=&AUDIENCE=&LEVEL=&SpkID=

http://galilee.microsoft.fr/TechDays2008/Recherche-Session.aspx?Key=directx&domID=&PRODUIT=&AUDIENCE=&LEVEL=&SpkID=

http://galilee.microsoft.fr/TechDays2008/Recherche-Session.aspx?Key=&domID=&PRODUIT=897ed8b3-7e75-446c-b2d8-28adbd31f674&AUDIENCE=&LEVEL=&SpkID=&x=21&y=11

http://galilee.microsoft.fr/TechDays2008/Session.aspx?CellID=4cde9cee-db06-4f5b-bd6e-a9d031a4fdb2

http://galilee.microsoft.fr/TechDays2008/Session.aspx?CellID=b400af3d-5dfb-4b7f-afdb-af293ab0ba70

http://galilee.microsoft.fr/TechDays2008/Session.aspx?CellID=4435849c-bd65-47da-9eff-1405877f996e

http://galilee.microsoft.fr/TechDays2008/Session.aspx?CellID=64962a3a-9582-4d41-833a-e8a3e4fb986c

http://galilee.microsoft.fr/TechDays2008/Session.aspx?CellID=24d5fe9e-3a1d-4f76-b0c3-e7d5b50fa59d

Les sujets qu'on y trouve sont vastes... Peu abordent vraiment le multimedia, mais on peut facilement se débrouiller pour améliorer ses compétences dans des domaines paralleles mais au combien importants...

Wanted : Ressources 3D/2D pour projets Xna

valentin — Thu, 20 Dec 2007 09:53:00 GMT

Je reçois bcp de mails de personnes qui me demandent comment trouver des resources 3D ou 2D ou bien savoir quels logiciels utiliser pour en créer.

Il y'a un grand nombre de visites sur ce blog (pratiquement 100000 en un an), je propose que chacun d'entre nous indique où il trouve les ressources pour ses projets. Chaque contribution sera ajoutée à ce post.

Un gros merci.

Je commence :

Les SDK DirectX : http://msdn2.microsoft.com/en-us/directx/aa937788.aspx
Ils contiennent un grand nombre de fichiers X, texture et modèles en tout genre

Les projets MS Research : http://research.microsoft.com/research/allegiance/
Un jeu complet à la Microosft Game, futuriste avec un très grand nombre de ressources (X animés notament)

"Le type de projet n'est pas pris en charge par cette installation" pour les projets NetRumble / Marblets / Racing Game

valentin — Wed, 19 Dec 2007 13:31:00 GMT

Une réponse faite à feed dans les commentaires d'un de mes posts pour répondre à son probleme :

"Le template NetRumble se lance, mais pas Marblets ou Racing Game : "Le type de projet n'est pas pris en charge par cette installation"

En deux mots, tous les exemples du Xna Game Studio Engine 2.0 n'ont pas été portés de la 1.0 vers la 2.0, les projets sont donc incompatibles.

Différentes solutions pour utiliser ces projets d'exemple :

Utiliser un wizard de mise à jour (creators.xna.com/.../GettingStarted.aspx)

Créer un projet GSE 2.0 et ajoute manuellement tous les fichiers et ressources du projet au bon emplacement (un peu chiant :) )

Installer à nouveau la 1.0 refresh qui peut cohexister avec la 2.0.

Attendre la possible sortie d'une version upgradée de ces projets (soit de la part de MS soit de la part d'un passionné)

Fenêtre de création de projets vide sous Visual Studio 2005

valentin — Wed, 04 Apr 2007 09:29:00 GMT

Je ne sais pas si ca vous est déjà arrivé mais moi oui. En gros après l'installation d'un produit qui ajoute des extensions à Visual Studio 2005 on se retrouve avec la fenêtre de création de projets complètement vide : plus aucun template (exit Application Windows, Class Library, Web Site etc.). Souvent, il ne reste d'ailleur que les templates liés à l'extension qu'on vient de mettre (supppeeeer).

On se retrouve donc complètement bloqué. J'ai eu ce problème plusieurs fois, notamment avec WWF, Ajax et VSTO. C'est peut être moi qui opère mal,en tout cas, je me souviens que je n'étais pas le seul sur le net lorsque le problème s'est présenté la première fois.

Je viens d'aider deux personnes qui ont eu cette *** et je me suis dis qu'il serait cool de placer une solution en Francais sur le net, la voici :

Il suffit tout simplement d'aller dans Tools/Options/Environmet/International Settings/Language. A priori par défaut vous avez en langage celui de Windows. Changez ce langage pour English. Fermez Visual Studio et reouvrez le. Normalement tout est rétabli.

A l'époque de 2003 je me souviens d'un deven.exe /installvstemplates mais si cette option ne plante pas, elle ne change rien à ce problème.

Pas la peine de me demander le pourquoi du comment : je ne sais pas pourquoi ca rétabli tout :)

A bientôt sur ce Blog !

Annexe : Transformations et Matrices

valentin — Mon, 05 Feb 2007 23:58:00 GMT

Retourner au sommaire des cours

Les transformations dans l'espace représentent le traitement clé de voute dans toute application 3D. C'est par les transformations que les objets prennent vie. Une transformation pour parler simplement est une suite de multiplication de matrices. Généralement on distingue 3 types de matrices pour travailler sur un modèle 3D avant son affichage à l'écran : les matrices de rotation, les matrices de redimentionnement, les matrices de translation. Lorsqu'on veut déplacer un objet de le faire tourner il suffit donc de réaliser des traitements du type :

matriceTransformation = matriceRotation * matriceTranslation

Ici nous réalisons une rotation puis une translation. L'objet représente le résultat de cette transformation et peut être vu comme un condensé unique des deux matrices. C'est cette matrice qui sera affectée à la matrice monde (ou World) pour placer l'objet à l'écran avant son affichage.

Vous devez, lorsque vous effectuez ce genre de calculs, garder en tête que :

Toute transformation sur un objet s'effectué par rapport au repère de cet objet.
La multiplication de matrices, n'est pas commutative.

Revenons justement sur ces deux notions.

Repère de l'objet

Lorsqu'on effectue une transformation sur un objet, cette transformation se fait par rapport au point d'origine dans le repère de l'objet. Le repère de l'objet est le repère par rapport auquel vous vous référez lorsque vous placez les vertices du modèle que vous voulez afficher.

Prenons par exemple les huits points de ce cube :

vertices[0].Position = new Vector3(-10f, -10f, -10f);

vertices[1].Position = new Vector3(-10f, -10f, 10f);

vertices[2].Position = new Vector3(10f, -10f, 10f);

vertices[3].Position = new Vector3(10f, -10f, -10f);

vertices[4].Position = new Vector3(10f, 10f, 10f);

vertices[5].Position = new Vector3(10f, 10f, -10f);

vertices.Position = new Vector3(-10f, 10f, -10f);

vertices[7].Position = new Vector3(-10f, 10f, 10f);

Ici le cube fait 20 unités de coté (de -10 à +10). Le point d'origine (0, 0, 0) du repère qui lui est associé se trouve pile au centre du cube. Si nous effectuons une rotation du cube, celle-ci s'effectuera donc par rapport à cette origine qui, étant au centre du cube, donnera l'impression que le cube tourne sur lui-même. L'image suivant illustre cela :

(nous effectuons ici une rotation sur X et Y).

Maintenant regardons un cube créé avec les 8 points suivants :

vertices[0].Position = new Vector3(0f, 0f, 0f);vertices[1].Position = new Vector3(0f, 0f, 20f);vertices[2].Position = new Vector3(20f, 0f, 20f);vertices[3].Position = new Vector3(20f, 0f, 0f);vertices[4].Position = new Vector3(20f, 20f, 20f);vertices[5].Position = new Vector3(20f, 20f, 0f);vertices.Position = new Vector3(0f, 20f, 0f);//vertices[7].Position = new Vector3(0f, 20f, 20f);

Là encore, chaque coté du cube possède une taille de 20 unités. Mais le centre du repère (0 ,0 ,0) correspond au premier point. La rotation que nous avons effectué précédemment associée à ce cube se fera par rapport à ce point. Le cube ne tournera donc plus sur lui-même mais par rapport à un de ses sommets. L'image suivant illustre celà :

Ici, c'est le point de couleur jaune qui est au centre du repère.

Nous venons de faire un grand pas pour bien comprendre comment maitriser les matrices et les transformations associées.

Ordre des transformations / Communativité

Au tout début de cet article, nous avons vu l'instruction suivante :

matriceTransformation = matriceRotation * matriceTranslation

Sachant que la classe Matrix nous offre un ensemble de méthodes statiques clé en main pour créer ce type de matrices, en langage C# nous aurions quelque chose du genre

matriceTransformation = Matrix.CreateRotationY(MathHelper.PIOver2)* Matrix.CreateTranslation(20, 0, 0)

Pour créer une rotation de 90° suivie d'une translation. Le verbe au participe passé "suivie' est important dans cette phrase. Je n'ai pas utilisé le complément "et". En effet il y'a une notion d'ordre dans le multiplication des matrices ; C'est au niveau de ce genre de traitement qu'il nous faut faire attention. La multiplication de matrices n'est en effet pas commutative ; l'instruction précécent ne donne pas le même résultat que :

matriceTransformation = matriceTranslation *matriceRotation

On peut se référer au premier point de cet article où les transformations s'effectuent par rapport au modèle de l'objet. Prenons l'affichage suivant :

Nous disposons ici d'un cube. Si nous effectuons une rotation sur l'axe Z, l'arrete située sur l'axe X se trouvera sur l'axe Y. Le pavé aura tourné autour de son origine. Si maintenant nous effectuons une translation sur l'axe X, le pavé tourné va être déplacé et nous obtiendrons comme résultat pour :

matriceTransformation = matriceRotation * matriceTranslation

Le rendu :

Revenons maitenant au premier affichage et essayons l'instruction :

matriceTransformation = matriceTranslation *matriceRotation

La transformation commence d'abord ici par une translation d'une distance que nous appelerons D. Nous obtenons donc le même résultat que l'image précédente mais avec un pavé non tourné. Une rotation est ensuite effectée. C'est là que la différence se fait pleinement sentir : la rotation se situe non pas par rapport au pavé mais par rapport au centre du repère de l'objet qui se situe à une distance D de l'objet. La rotation va donc faire tourner l'objet autour d'un cercle imaginaire possèdant un rayon d'une taille équivalente à D. Le résultat donne donc :

Cet exemple illustre parfaitement la non commutativité de la multiplication de matrices. Même si cet exemple est simple, il faut toujour garder à l'esprit cette loi fondamentale, surtout lorsqu'on travaille sur un très grand nombre de matrices qui interagissent entre elles.

Exemple de classe "Transform-Safe"

Pour terminer cet article, voici une classe dont hérite la plupart des objets métier affiché à l'écran dans les applications 3D que je réalise. Elle donne à ses objets enfants un ensemble de propriétés et de méthodes simples qui permettent d'interragir avec l'objet de manière transparente et intuitive pour modifier l'objet avant son rendu.

/// <summary>/// <para>Defines a transformable object.</para>/// </summary>public class TransformBase{ #region Private members [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] private Matrix _translation; [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] private Matrix _rotation; [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] private Matrix _scale; [System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)] float _rotationX, _rotationY, _rotationZ; #endregion #region Properties /// <summary> /// <para>Gets the associated transformation matrix.</para> /// </summary> public Matrix Transform { get { return this._scale * this._rotation * this._translation; } } /// <summary> /// <para>Gets or sets the current object's position.</para> /// </summary> public Vector3 Position { get { return new Vector3(this._translation.M41, this._translation.M42, this._translation.M43); } set { this._translation.M41 = value.X; this._translation.M42 = value.Y; this._translation.M43 = value.Z; } } /// <summary> /// <para>Gets or sets the position on the X axis.</para> /// </summary> public float X { get { return this._translation.M41; } set { this._translation.M41 = value; } } /// <summary> /// <para>Gets or sets the position on the Y axis.</para> /// </summary> public float Y { get { return this._translation.M42; } set { this._translation.M42 = value; } } /// <summary> /// <para>Gets or sets the position on the Z axis.</para> /// </summary> public float Z { get { return this._translation.M43; } set { this._translation.M43 = value; } } /// <summary> /// <para>Gets or sets the current rotation in radian on X axis.</para> /// </summary> public float XRotation { get { return this._rotationX; } set { this.Rotate(value, _rotationY, _rotationZ); } } /// <summary> /// <para>Gets or sets the current rotation in radian on Y axis.</para> /// </summary> public float YRotation { get { return this._rotationY; } set { this.Rotate(_rotationX, value, _rotationZ); } } /// <summary> /// <para>Gets or sets the current rotation in radian on Z axis.</para> /// </summary> public float ZRotation { get { return this._rotationZ; } set { this.Rotate(_rotationX, _rotationY, value); } } /// <summary> /// <para>Gets or sets the current scale on X axis.</para> /// </summary> public float XScale { get { return this._scale.M11; } set { this._scale.M11 = value; } } /// <summary> /// <para>Gets or sets the current scale on X axis.</para> /// </summary> public float YScale { get { return this._scale.M22; } set { this._scale.M22 = value; } } /// <summary> /// <para>Gets or sets the current scale on X axis.</para> /// </summary> public float ZScale { get { return this._scale.M33; } set { this._scale.M33 = value; } } #endregion #region Constructor /// <summary> /// <para>Default constructor.</para> /// </summary> public TransformBase() { Reset(); } #endregion #region Public methods /// <summary> /// <para>Reset the matrices to default position.</para> /// </summary> public void Reset() { this._translation = Matrix.Identity; this._rotation = Matrix.Identity; this._scale = Matrix.Identity; this._rotationX = _rotationY = _rotationZ = 0.0f; } #endregion #region Transform methods #region Translate /// <summary> /// <para>Move current object to the specified location.</para> /// </summary> /// <param name="x">Position X-axis value.</param> /// <param name="y">Position Y-axis value.</param> /// <param name="z">Position Z-axis value.</param> public void MoveTo(float x, float y, float z) { this._translation.M41 = x; this._translation.M42 = y; this._translation.M43 = z; } /// <summary> /// <para>Move current object to the specified location.</para> /// </summary> /// <param name="translation">Position's vector.</param> public void MoveTo(Vector3 translation) { this.MoveTo(translation.X, translation.Y, translation.Z); } /// <summary> /// <para>Translate current object from the current position with the specified vector.</para> /// </summary> /// <param name="x">Vector X-axis value.</param> /// <param name="y">Vector Y-axis value.</param> /// <param name="z">Vector Z-axis value.</param> public void Translate(float x, float y, float z) { _translation.M41 += x; _translation.M42 += y; _translation.M43 += z; } /// <summary> /// <para>Translate current object from the current position with the specified vector.</para> /// </summary> /// <param name="translation">Translation vector</param> public void Translate(Vector3 translation) { this.Translate(translation.X, translation.Y, translation.Z); } #endregion #region Rotate /// <summary> /// <para>Rotate current object on the X,Y,Z axis.</para> /// </summary> /// <param name="x">X axis rotation in radians</param> /// <param name="y">Y axis rotation in radians</param> /// <param name="z">Z axis rotation in radians</param> public void Rotate(float x, float y, float z) { this._rotationX = x; this._rotationY = y; this._rotationZ = z; this._rotation = Matrix.CreateRotationX(x)*Matrix.CreateRotationY(y)*Matrix.CreateRotationZ(z); } /// <summary> /// <para>Make a rotation from the current rotation.</para> /// </summary> /// <param name="x">X axis rotation in radians</param> /// <param name="y">Y axis rotation in radians</param> /// <param name="z">Z axis rotation in radians</param> public void Turn(float x, float y, float z) { this._rotationX += x; this._rotationY += y; this._rotationZ += z; this.Rotate(this._rotationX, this._rotationY, this._rotationZ); } #endregion #region Scale /// <summary>Resize the current object.</summary> /// <param name="x">Scale factor for X values.</param> /// <param name="y">Scale factor for Y values</param> /// <param name="z">Scale factor for Z values</param> public void Resize(float x, float y, float z) { this._scale.M11 = x; this._scale.M22 = y; this._scale.M33 = z; } /// <summary>Scale current object from current size.</summary> /// <param name="x">X</param> /// <param name="y">Y</param> /// <param name="z">Z</param> public void Scale(float x, float y, float z) { this._scale.M11 += x; this._scale.M22 += y; this._scale.M33 += z; } #endregion #endregion }

Vous remarquerez ici des instructions du type :

this._scale.M11 = x; this._scale.M22 = y; this._scale.M33 = z;

Les propriété comme M11 ou M23 correspondent à des valeurs situées dans la matrices. Nous reviendrons dans un prochain article sur leur raison d'être.

Conclusion

Cet article est incontournable si vous ne maitrisez pas encore la notion de transformation. Ayez toujours en tête les principes élémentaires qu'il a énuméré afin de vous éviter de nombreuses heures de recherches après des invraissemblances graphiques, qui sont, au final, relativement simples à éviter.

A bientôt sur ce Blog !

Valentin Billotte

N'hesitez surtout pas à me faire part de vos incomprehensions afin de pemettre d'améliorer ce cours pour le rendre plus accessible aux autres (trèèèès important)!

Retourner au sommaire des cours

Coût de l'application des states au Device

valentin — Tue, 02 Jan 2007 16:16:00 GMT

Changer l'état (state) du device que ce soit pour le texture stage, le render stage ou autre ... a un coût. Ce post vise a les expliciter afin que vous puissiez fournir à vos application une gestion intelligente qui évitera de changer les états quand il y'en a pas besoin, réduira le nombre de changements et surtout qui va regrouper l'affichage des objets par état...

Voici les différents états applicables au device et leur coût (classés du plus important au plus faible) :

API Call

Avg # of Cycles

SetVertexDeclaration

SetFVF

SetVertexShader

SetPixelShader

SPECULARENABLE

SetRenderTarget

SetPixelShaderConstant (1 Constant)

NORMALIZENORMALS

LightEnable

SetStreamSource

LIGHTING

DIFFUSEMATERIALSOURCE

AMBIENTMATERIALSOURCE

COLORVERTEX

SetLight

SetTransform

SetIndices

AMBIENT

SetTexture

SPECULARMATERIALSOURCE

EMISSIVEMATERIALSOURCE

SetMaterial

ZENABLE

WRAP0

MINFILTER

MAGFILTER

SetVertexShaderConstant (1 Constant)

COLOROP

COLORARG2

COLORARG1

CULLMODE

CLIPPING

DrawIndexedPrimitive

ADDRESSV

ADDRESSU

DrawPrimitive

SRGBTEXTURE

STENCILMASK

STENCILZFAIL

STENCILREF

ALPHABLENDENABLE

STENCILFUNC

STENCILWRITEMASK

STENCILFAIL

ZFUNC

ZWRITEENABLE

STENCILENABLE

STENCILPASS

SRCBLEND

TWOSIDEDSTENCILMODE

ALPHATESTENABLE

ALPHAREF

ALPHAFUNC

DESTBLEND

COLORWRITEENABLE

CCW_STENCILFAIL

CCW_STENCILPASS

CCW_STENCILZFAIL

SCISSORTESTENABLE

CCW_STENCILFUNC

SetScissorRect

6500 - 11250

6400 - 11200

3000 - 12100

6300 - 7000

1900 - 11200

6000 - 6250

1500 - 9000

2200 - 8100

1300 - 9000

3700 - 5800

1700 - 7500

900 - 8300

900 - 8200

800 - 7800

2200 - 5100

3200 - 3750

900 - 5600

1150 - 4800

2500 - 3100

900 - 4600

900 - 4500

1000 - 3700

700 - 3900

1600 - 2700

1700 - 2500

1700 - 2400

1000 - 2700

1500 - 2100

1300 - 2000

1300 - 1980

500 - 2570

500 - 2550

1200 - 1400

1090 - 1500

1070 - 1500

1050 - 1150

150 - 1500

570 - 700

500 - 800

550 - 700

560 - 680

520 - 700

500 - 750

510 - 700

520 - 680

540 - 650

560 - 630

500 - 685

450 - 590

470 - 525

460 - 530

450 - 540

475 - 510

465 - 515

340 - 560

340 - 545

330 - 495

375 - 440

250 - 480

150 - 340

Conclusion

On evite les

device.VertexDeclaration = ...

en masse :)

A bientôt sur ce Blog !

Valentin