Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez aussi afficher la version anglaise dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte.
Traduction
Anglais

Vue d'ensemble des graphiques 3D

 

Publication: juin 2016

La fonctionnalité 3-D de Windows Presentation Foundation (WPF) permet aux développeurs de dessiner, de transformer et d'animer des graphiques 3D dans le balisage et le code procédural. Les développeurs peuvent regrouper les graphiques 2-D et 3-D pour créer des contrôles riches, pour fournir les illustrations complexes de données ou pour améliorer l'expérience utilisateur de l'interface d'une application. La prise en charge de 3-D dans WPF n'est pas conçue pour fournir une plateforme complète de développement de jeu. Cette rubrique fournit une introduction de la fonctionnalité 3-D dans le système graphique WPF.

Le contenu graphique 3-D dans WPF est encapsulé dans un élément Viewport3D qui peut participer à la structure du document à deux dimensions. Le système graphique traite Viewport3D comme un élément visuel à deux dimensions semblable à bien d'autres dans WPF. Viewport3D fonctionne comme une fenêtre (d'affichage) dans une scène tridimensionnelle. Plus précisément, c'est une surface sur laquelle une scène 3-D est projetée.

Dans une application 2-D classique, utilisez Viewport3D comme vous le feriez avec un autre élément conteneur comme Grille ou Zone de dessin. Bien que vous puissiez utiliser Viewport3D avec d'autres objets de dessin 2-D dans la même scène graphique, vous ne pouvez pas interpénétrer d'objets 2-D et 3-D dans une Viewport3D. Cette rubrique se concentrera sur la façon de dessiner des graphiques 3-D à l'intérieur de la Viewport3D.

Le système de coordonnées WPF pour les graphiques 2-D localise l'origine dans la partie supérieure gauche de la zone de rendu (en général l'écran). Dans le système 2-D, les valeurs d'axe des abscisses positives continuent à droite et les valeurs d'axe des ordonnées positives continuent vers le bas. Dans le système de coordonnées 3-D toutefois, l'origine est située dans le centre de la zone de rendu, avec les valeurs d'axe des abscisses positives qui continuent à droite mais les valeurs d'axe des ordonnées positives qui continuent vers le haut, et les valeurs d'axe z positives qui continuent vers l'extérieur de l'origine, vers la visionneuse.

Systèmes de coordonnées

Représentations de systèmes de coordonnées 2D et 3D classiques

L'espace défini par ces axes est le système de référence stationnaire pour les objets 3-D dans WPF. Comme vous générez des modèles dans cet espace et créez des lumières et des caméras pour les consulter, il est utile de distinguer ce système de référence stationnaire, ou « espace universel », du système de référence local que vous créez pour chaque modèle lorsque vous lui appliquez des transformations. Souvenez-vous également que les objets dans espace universel peuvent sembler entièrement différents, ou ne pas être visibles du tout, selon les paramètres de lumière et de caméra, mais la position de la caméra ne modifie pas l'emplacement d'objets dans l'espace universel.

Les développeurs qui travaillent dans 2-D sont habitués à positionner des primitives de dessin sur un écran à deux dimensions. Lorsque vous créez une scène 3-D, il est important de se rappeler que vous créez vraiment une représentation 2-D d'objets 3-D. Du fait qu'une apparence de scène 3-D a un aspect différent selon le point de vue du spectateur, vous devez spécifier ce point de vue. La classe Camera vous permet de spécifier ce point de vue pour une scène 3-D.

Une autre méthode pour comprendre comment une scène 3-D est représentée sur une surface 2-D est de décrire la scène comme une projection sur la surface de visionnage. La ProjectionCamera vous permet de spécifier des projections différentes et leurs propriétés pour changer la manière dont le spectateur consulte les modèles 3-D. Une PerspectiveCamera spécifie une projection qui dessine en raccourci la scène. En d'autres termes, la PerspectiveCamera fournit la perspective de point de fuite. Vous pouvez spécifier la position de la caméra dans l'espace de coordonnées de la scène, la direction et le champ de vision pour la caméra, et un vecteur qui définit la direction « vers le haut » dans la scène. Le diagramme suivant illustre la projection de la PerspectiveCamera.

Les propriétés NearPlaneDistance et FarPlaneDistance de ProjectionCamera limitent la plage de projection de la caméra. Étant donné que les caméras peuvent se trouver n'importe où dans la scène, il est possible de positionner la caméra à l'intérieur d'un modèle ou très près de lui, ce qui ne permet pas de distinguer facilement les objets. NearPlaneDistance vous permet de spécifier une distance minimum à respecter vis-à-vis de la caméra dans laquelle les objets ne seront pas dessinés. Inversement, FarPlaneDistance vous permet de spécifier une distance de la caméra au-delà de laquelle les objets ne seront pas dessinés, ce qui garantit que les objets trop loin pour être reconnus ne seront pas inclus dans la scène.

Installation de l'appareil photo

Position de la caméra

OrthographicCamera spécifie une projection orthogonale d'un modèle 3-D sur une surface visuelle 2-D. Comme les autres caméras , elle indique une position, une direction d'affichage et une direction « vers le haut ». Contrairement à la PerspectiveCamera, toutefois, la OrthographicCamera décrit une projection qui n'inclut pas de réduction de perspective. En d'autres termes, OrthographicCamera décrit une zone d'affichage dont les côtés sont parallèles, au lieu d'une zone dont les côtés se rejoignent à un point de la caméra. L'image suivante affiche le même modèle que celui visionné à l'aide de PerspectiveCamera et OrthographicCamera.

Projection orthographique et en perspective

Perspective et projections orthogonales

Le code suivant affiche des paramètres de caméra typiques.

// Defines the camera used to view the 3D object. In order to view the 3D object,
// the camera must be positioned and pointed such that the object is within view 
// of the camera.
PerspectiveCamera myPCamera = new PerspectiveCamera();

// Specify where in the 3D scene the camera is.
myPCamera.Position = new Point3D(0, 0, 2);

// Specify the direction that the camera is pointing.
myPCamera.LookDirection = new Vector3D(0, 0, -1);

// Define camera's horizontal field of view in degrees.
myPCamera.FieldOfView = 60;

// Asign the camera to the viewport
myViewport3D.Camera = myPCamera;

Model3D est la classe de base abstraite qui représente un objet 3-D générique. Pour générer une scène 3-D, vous avez besoin de quelques objets à afficher, et des objets qui composent le graphique de scène dérivé de Model3D. Actuellement, WPF prend en charge des géométries de modélisation avec GeometryModel3D. La propriété Geometry de ce modèle prend un maillage de base.

Pour générer un modèle, commencez en générant une primitive, ou maillage. Une primitive 3-D est une collection des sommets qui forment une entité 3-D unique. La plupart des systèmes 3-D fournissent des primitives modelées sur la figure fermée la plus simple : un triangle défini par trois sommets. Du fait que les trois points d'un triangle sont coplanaires, vous pouvez continuer à ajouter des triangles pour modeler plus de formes complexes, appelées mailles.

Le système WPF3-Dfournit actuellement la classe MeshGeometry3D, qui vous permet de spécifier n'importe quelle géométrie ; il ne actuellement prend pas en charge les primitives 3-D prédéfinies comme sphères et formes cubiques. Commencez à créer un MeshGeometry3D en spécifiant une liste de sommets de triangle comme sa propriété Positions. Chaque vertex est spécifié comme un Point3D. (En langage XAML (eXtensible Application Markup Language), spécifiez cette propriété comme une liste de nombres groupés par trois qui représente les coordonnées de chaque vertex.) Selon sa géométrie, votre maillage peut être composé de nombreux triangles, certains d'entre eux partageant les mêmes angles (sommets). Pour dessiner le maillage correctement, le WPF a besoin d'informations quant à quels sommets sont partagés par quels triangles. Vous fournissez cette information en spécifiant une liste d'index de triangle avec la propriété TriangleIndices. Cette liste spécifie l'ordre dans lequel les points spécifiés dans la liste Positions détermineront un triangle.

<GeometryModel3D>
  <GeometryModel3D.Geometry>
          <MeshGeometry3D 
              Positions="-1 -1 0  1 -1 0  -1 1 0  1 1 0"
              Normals="0 0 1  0 0 1  0 0 1  0 0 1"
              TextureCoordinates="0 1  1 1  0 0  1 0   "
              TriangleIndices="0 1 2  1 3 2" />
      </GeometryModel3D.Geometry>
      <GeometryModel3D.Material>
          <DiffuseMaterial>
              <DiffuseMaterial.Brush>
                  <SolidColorBrush Color="Cyan" Opacity="0.3"/>
              </DiffuseMaterial.Brush>
          </DiffuseMaterial>
      </GeometryModel3D.Material>
  <!-- Translate the plane. -->
      <GeometryModel3D.Transform>
          <TranslateTransform3D
            OffsetX="2" OffsetY="0" OffsetZ="-1"   >
          </TranslateTransform3D>
      </GeometryModel3D.Transform>
  </GeometryModel3D>

Dans l'exemple précédent, la liste Positions spécifie huit sommets pour définir un maillage en forme de cube. La propriété TriangleIndices spécifie une liste de douze groupes de trois index. Chaque nombre dans la liste fait référence à un offset dans la liste Positions. Par exemple, les trois premiers sommets spécifiés par la liste Positions sont (1,1,0), (0,1,0) et (0,0,0). Les trois premiers index spécifiés par la liste TriangleIndices sont 0, 2 et 1, ce qui correspond aux premier, troisième et deuxième points dans la liste Positions. En conséquence, le premier triangle qui compose le modèle de cube sera composé de (1,1,0) à (0,1,0) à (0,0,0), et les onze triangles restants seront déterminé d'une façon similaire.

Vous pouvez continuer à définir le modèle en spécifiant des valeurs pour les propriétés Normals et TextureCoordinates. Pour restituer la surface du modèle, le système graphique a besoin d'informations quant à la direction faisant face à la surface sur tout triangle donné. Il utilise cette information pour faire des calculs d'éclairage pour le modèle : les surfaces qui font face directement à une source de lumière apparaissent plus claires que celles se trouvant en angle par rapport à la lumière. Bien que WPF puisse déterminer des vecteurs normaux par défaut en utilisant les coordonnées de position, vous pouvez également spécifier des vecteurs normaux différents pour se rapprocher de l'apparence de surfaces courbées.

La propriété TextureCoordinates spécifie une collection de Points qui indique au système graphique comment mapper les coordonnées qui déterminent la manière dont la texture est dessinée sur les sommets du maillage. Les TextureCoordinates sont spécifiées sous la forme d'une valeur comprise entre zéro et 1 (valeurs incluses). Comme avec la propriété Normals, le système graphique peut calculer des coordonnées de texture par défaut, mais vous pouvez choisir de définir des coordonnées de texture différentes pour contrôler le mappage d'une texture qui inclut une partie d'un modèle à répétition, par exemple. Plus d'informations à propos des coordonnées de texture se trouvent dans les rubriques suivantes ou dans le Kit de développement logiciel (SDK) Managed Direct3D.

L'exemple suivant indique comment créer une face du cube modèle en code procédural. Notez que vous pouvez dessiner le cube entier comme un GeometryModel3D unique ; cet exemple dessine la face du cube en tant que modèle distinct pour appliquer ultérieurement des textures séparées à chaque face.

MeshGeometry3D side1Plane = new MeshGeometry3D();

  Private side1Plane As New MeshGeometry3D()
side1Plane.Positions.Add(new Point3D(-0.5, -0.5, -0.5));
side1Plane.Positions.Add(new Point3D(-0.5, 0.5, -0.5));
side1Plane.Positions.Add(new Point3D(0.5, 0.5, -0.5));
side1Plane.Positions.Add(new Point3D(0.5, 0.5, -0.5));
side1Plane.Positions.Add(new Point3D(0.5, -0.5, -0.5));
side1Plane.Positions.Add(new Point3D(-0.5, -0.5, -0.5));

side1Plane.TriangleIndices.Add(0);
side1Plane.TriangleIndices.Add(1);
side1Plane.TriangleIndices.Add(2);
side1Plane.TriangleIndices.Add(3);
side1Plane.TriangleIndices.Add(4);
side1Plane.TriangleIndices.Add(5);

side1Plane.Normals.Add(new Vector3D(0, 0, -1));
side1Plane.Normals.Add(new Vector3D(0, 0, -1));
side1Plane.Normals.Add(new Vector3D(0, 0, -1));
side1Plane.Normals.Add(new Vector3D(0, 0, -1));
side1Plane.Normals.Add(new Vector3D(0, 0, -1));
side1Plane.Normals.Add(new Vector3D(0, 0, -1));

side1Plane.TextureCoordinates.Add(new Point(1, 0));
side1Plane.TextureCoordinates.Add(new Point(1, 1));
side1Plane.TextureCoordinates.Add(new Point(0, 1));
side1Plane.TextureCoordinates.Add(new Point(0, 1));
side1Plane.TextureCoordinates.Add(new Point(0, 0));
side1Plane.TextureCoordinates.Add(new Point(1, 0));
side1Plane.Positions.Add(New Point3D(-0.5, -0.5, -0.5))
side1Plane.Positions.Add(New Point3D(-0.5, 0.5, -0.5))
side1Plane.Positions.Add(New Point3D(0.5, 0.5, -0.5))
side1Plane.Positions.Add(New Point3D(0.5, 0.5, -0.5))
side1Plane.Positions.Add(New Point3D(0.5, -0.5, -0.5))
side1Plane.Positions.Add(New Point3D(-0.5, -0.5, -0.5))

side1Plane.TriangleIndices.Add(0)
side1Plane.TriangleIndices.Add(1)
side1Plane.TriangleIndices.Add(2)
side1Plane.TriangleIndices.Add(3)
side1Plane.TriangleIndices.Add(4)
side1Plane.TriangleIndices.Add(5)

side1Plane.Normals.Add(New Vector3D(0, 0, -1))
side1Plane.Normals.Add(New Vector3D(0, 0, -1))
side1Plane.Normals.Add(New Vector3D(0, 0, -1))
side1Plane.Normals.Add(New Vector3D(0, 0, -1))
side1Plane.Normals.Add(New Vector3D(0, 0, -1))
side1Plane.Normals.Add(New Vector3D(0, 0, -1))

side1Plane.TextureCoordinates.Add(New Point(1, 0))
side1Plane.TextureCoordinates.Add(New Point(1, 1))
side1Plane.TextureCoordinates.Add(New Point(0, 1))
side1Plane.TextureCoordinates.Add(New Point(0, 1))
side1Plane.TextureCoordinates.Add(New Point(0, 0))
side1Plane.TextureCoordinates.Add(New Point(1, 0))

Pour qu'un maillage ressemble à un objet tridimensionnel, il doit avoir une texture appliquée pour couvrir la surface définie par ses sommets et triangles afin de pouvoir être allumé et projeté par la caméra. Dans 2-D, vous utilisez la classe Brush pour appliquer des couleurs, des modèles, des dégradés ou d'autres contenus visuels aux zones de l'écran. Toutefois, l'apparence d'objets 3-D est une fonction du modèle d'éclairage, pas seulement de la couleur ou du modèle leur étant appliqué. Les objets réels reflètent différemment la lumière selon la qualité de leurs surfaces : les surfaces lustrées et brillantes n'ont pas la même apparence que les surfaces rugueuses ou mattes, et certains objets paraissent absorber la lumière pendant que d'autres brillent. Vous pouvez appliquer tous les mêmes pinceaux aux objets 3-D que vous pouvez appliquer aux objets 2-D, mais vous ne pouvez pas les appliquer directement.

Pour définir les caractéristiques de la surface d'un modèle, WPF utilise la classe abstraite Material. Les sous-classes concrètes de matière déterminent quelques-unes des caractéristiques d'apparence de la surface du modèle, et chacune fournit également une propriété Brush à laquelle vous pouvez passer un SolidColorBrush, TileBrush ou VisualBrush.

  • DiffuseMaterial spécifie que le pinceau sera appliqué au modèle comme si ce modèle était allumé indirectement. L'utilisation de DiffuseMaterial est très similaire à l'utilisation de pinceaux directement sur les modèles 2-D ; les surfaces de modèle ne reflètent pas la lumière bien que brillants.

  • SpecularMaterial spécifie que le pinceau sera appliqué au modèle comme si la surface du modèle était dure ou brillante, capable de refléter des surbrillances. Vous pouvez définir le degré auquel la texture suggérera cette qualité réflectrice, ou « brillant », en spécifiant une valeur pour la propriété SpecularPower.

  • EmissiveMaterial vous permet de spécifier que la texture sera appliquée comme si le modèle émettait une lumière équivalente à la couleur du pinceau. Cela ne transforme pas le modèle en lumière ; toutefois, il participera différemment à l'ombrage qu'il ne le ferait en cas de texture avec DiffuseMaterial ou SpecularMaterial.

Pour optimiser les performances, les faces arrières d'un GeometryModel3D (ces faces qui sont hors de vue parce qu'elles sont sur le côté opposé du modèle par rapport à la caméra) sont éliminées de la scène. Pour spécifier un Material à appliquer à la face arrière d'un modèle comme un plan, définissez la propriété BackMaterial du modèle.

Pour accomplir des qualités de surface, comme les effects de brillance ou de reflet, vous pouvez appliquer plusieurs pinceaux différents à un modèle à la suite. Vous pouvez appliquer et réutiliser plusieurs matières à l'aide de la classe MaterialGroup. Les enfants du MaterialGroup sont appliqués du premier au dernier en plusieurs passes de rendu.

Les exemples de code suivants indiquent comment appliquer une couleur unie et un dessin comme pinceaux aux modèles 3-D.


  <
  GeometryModel3D.Material
  >
    <DiffuseMaterial>
        <DiffuseMaterial.Brush>
            <SolidColorBrush Color="Cyan" Opacity="0.3"/>
        </DiffuseMaterial.Brush>
    </DiffuseMaterial>
</GeometryModel3D.Material>

  <
  DrawingBrush
   x:Key
  ="patternBrush"
   Viewport
  ="0,0,0.1,0.1"
   TileMode
  ="Tile"
  >
  <DrawingBrush.Drawing>
    <DrawingGroup>
      <DrawingGroup.Children>
        <GeometryDrawing Geometry="M0,0.1 L0.1,0 1,0.9, 0.9,1z"
          Brush="Gray" />
        <GeometryDrawing Geometry="M0.9,0 L1,0.1 0.1,1 0,0.9z"
          Brush="Gray" />
        <GeometryDrawing Geometry="M0.25,0.25 L0.5,0.125 0.75,0.25 0.5,0.5z"
          Brush="#FFFF00" />
        <GeometryDrawing Geometry="M0.25,0.75 L0.5,0.875 0.75,0.75 0.5,0.5z"
          Brush="Black" />
        <GeometryDrawing Geometry="M0.25,0.75 L0.125,0.5 0.25,0.25 0.5,0.5z"
          Brush="#FF0000" />
        <GeometryDrawing Geometry="M0.75,0.25 L0.875,0.5 0.75,0.75 0.5,0.5z"
          Brush="MediumBlue" />
      </DrawingGroup.Children>
    </DrawingGroup>
  </DrawingBrush.Drawing>
</DrawingBrush>
DiffuseMaterial side5Material = new DiffuseMaterial((Brush)Application.Current.Resources["patternBrush"]);

  Dim side5Material As New DiffuseMaterial(CType(Application.Current.Resources("patternBrush"), Brush))

Les lumières dans les graphiques 3-D font la même chose que les vraies : elles rendent des surfaces visibles. Plus précisément, les lumières déterminent quelle partie d'une scène sera incluse dans la projection. Les objets de lumière dans WPF créent divers effets lumineux et d'effets d'ombre et sont modelés d'après le comportement de différentes lumières réelles. Vous devez inclure au moins une lumière dans votre scène, ou aucun modèle ne sera visible.

Les lumières suivantes dérivent de la classe de base Light :

  • AmbientLight : fournit une lumière ambiante qui éclaire uniformément tous les objets indépendamment de leur emplacement ou orientation.

  • DirectionalLight : éclaire comme une source de lumière distante. Les lumières directionnelles ont un Direction spécifié comme un Vector3D, mais aucun emplacement spécifié.

  • PointLight : Éclaire comme une source de lumière proche. Les PointLights ont une position et convertissent la lumière de cette position. Les objets dans la scène sont éclairés en fonction de leur position et de leur distance par rapport à la lumière. PointLightBase expose une propriété Range qui détermine une distance au-delà de laquelle les modèles ne seront pas éclairés par la lumière. PointLight expose également des propriétés d'atténuation qui déterminent comment l'intensité de la lumière diminue avec la distance. Vous pouvez spécifier des interpolations constantes, linéaires ou quadratiques pour l'atténuation de la lumière.

  • SpotLight : Hérite de PointLight. Les projecteurs éclairent comme PointLight et disposent à la fois de la position et de la direction. Ils projettent la lumière dans une zone en forme de cône définie par les propriétés InnerConeAngle et OuterConeAngle, indiquées en degrés.

Les lumières sont des objets Model3D, vous pouvez donc transformer et animer des propriétés de lumière, comme la position, la couleur, la direction et la plage.


  <
  ModelVisual3D.Content
  >
    <AmbientLight Color="#333333" />
</ModelVisual3D.Content>
DirectionalLight myDirLight = new DirectionalLight();

  Private myDirLight As New DirectionalLight()
myDirLight.Color = Colors.White;
myDirLight.Direction = new Vector3D(-3, -4, -5);
myDirLight.Color = Colors.White
myDirLight.Direction = New Vector3D(-3, -4, -5)
modelGroup.Children.Add(myDirLight);
modelGroup.Children.Add(myDirLight)

Lorsque vous créez des modèles, ils ont un emplacement particulier dans la scène. Pour déplacer ces modèles dans la scène, pour les faire pivoter ou pour modifier leur taille, il n'est pas pratique de modifier les vertex qui définissent les modèles eux-mêmes. À la place, comme dans 2-D, vous appliquez des transformations aux modèles.

Chaque objet modèle a une propriété Transform avec laquelle vous pouvez déplacer, réorienter ou redimensionner le modèle. Lorsque vous appliquez une transformation, vous compensez efficacement tous les points du modèle par quelque vecteur ou valeur que ce soit spécifié par la transformation. En d'autres termes, vous avez transformé l'espace de coordonnées dans lequel le modèle est défini (« espace modèle »), mais vous n'avez pas modifié les valeurs qui composent la géométrie du modèle dans le système de coordonnées de la scène entière (« espace universel »).

Pour plus d'informations sur la transformation de modèles, consultez Vue d'ensemble des transformations 3D.

L'implémentation WPF 3-D participe au même système de minutage et d'animation que les graphiques 2-D. En d'autres termes, pour animer une scène 3D, animez les propriétés de ses modèles. Il est possible d'animer directement des propriétés de primitives, mais il est en général plus facile d'animer des transformations qui modifient la position ou l'apparence de modèles. Comme les transformations peuvent être appliquées aux objets Model3DGroup aussi bien qu'aux modèles individuels, il est possible d'appliquer un jeu d'animations à un enfant d'un Model3DGroup et un autre jeu d'animations à un groupe d'objets enfants. Vous pouvez également accomplir divers effets visuels en animant les propriétés d'éclairage de votre scène. Enfin, vous pouvez choisir d'animer la projection elle-même en animant la position de la caméra ou du champ de vision. Pour les informations générales sur le système WPF de minutage et d'animation, consultez les rubriques Vue d'ensemble de l'animation, Vue d'ensemble des storyboards, et Vue d'ensemble des objets Freezable.

Pour animer un objet dans WPF, vous créez une chronologie, définissez une animation (qui est en fait une modification de quelques valeurs de propriété dans le temps) et spécifiez la propriété sur laquelle appliquer l'animation. Comme tous les objets dans une scène 3-D sont enfants de Viewport3D, les propriétés ciblées par toute animation que vous souhaitez appliquer à la scène sont des propriétés de propriétés de Viewport3D.

Supposez vous souhaitiez faire apparaître un modèle pour qu'il sembler dévier sur place. Vous pouvez choisir d'appliquer un RotateTransform3D au modèle et d'animer l'axe de sa rotation d'un vecteur à un autre. L'exemple de code suivant montre l'application d'un Vector3DAnimation à la propriété Axis du Rotation3D de la transformation, en assumant que le RotateTransform3D soit l'une des multiples transformations appliquées au modèle avec un TransformGroup.


  //Define a rotation
RotateTransform3D myRotateTransform = new RotateTransform3D(new AxisAngleRotation3D(new Vector3D(0, 1, 0), 1));

  'Define a rotation
Dim myRotateTransform As New RotateTransform3D(New AxisAngleRotation3D(New Vector3D(0, 1, 0), 1))
Vector3DAnimation myVectorAnimation = new Vector3DAnimation(new Vector3D(-1, -1, -1), new Duration(TimeSpan.FromMilliseconds(5000)));
myVectorAnimation.RepeatBehavior = RepeatBehavior.Forever;

  Dim myVectorAnimation As New Vector3DAnimation(New Vector3D(-1, -1, -1), New Duration(TimeSpan.FromMilliseconds(5000)))
myVectorAnimation.RepeatBehavior = RepeatBehavior.Forever
myRotateTransform.Rotation.BeginAnimation(AxisAngleRotation3D.AxisProperty, myVectorAnimation);
myRotateTransform.Rotation.BeginAnimation(AxisAngleRotation3D.AxisProperty, myVectorAnimation)

  //Add transformation to the model
cube1TransformGroup.Children.Add(myRotateTransform);

  'Add transformation to the model
cube1TransformGroup.Children.Add(myRotateTransform)

Pour restituer la scène, ajoutez des modèles et des lumières à un Model3DGroup, puis définissez le Model3DGroup comme Content d'un ModelVisual3D. Ajoutez le ModelVisual3D à la collection Children du Viewport3D. Ajoutez des caméras au Viewport3D en définissant sa propriété Camera.

Enfin, ajoutez le Viewport3D à la fenêtre. Lorsque le Viewport3D est inclus en tant que contenu d'un élément de disposition telle que la zone de dessin, indiquez la taille du Viewport3D en définissant ses propriétés Height et Width (héritées de FrameworkElement).

<UserControl x:Class="HostingWpfUserControlInWf.UserControl1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    >

    <Grid>

      <!-- Place a Label control at the top of the view. -->
      <Label 
				HorizontalAlignment="Center" 
				TextBlock.TextAlignment="Center" 
				FontSize="20" 
				Foreground="Red" 
				Content="Model: Cone"/>

      <!-- Viewport3D is the rendering surface. -->
      <Viewport3D Name="myViewport" >

        <!-- Add a camera. -->
        <Viewport3D.Camera>
          <PerspectiveCamera 
						FarPlaneDistance="20" 
						LookDirection="0,0,1" 
						UpDirection="0,1,0" 
						NearPlaneDistance="1" 
						Position="0,0,-3" 
						FieldOfView="45" />
        </Viewport3D.Camera>

        <!-- Add models. -->
        <Viewport3D.Children>

          <ModelVisual3D>
            <ModelVisual3D.Content>

              <Model3DGroup >
                <Model3DGroup.Children>

                  <!-- Lights, MeshGeometry3D and DiffuseMaterial objects are added to the ModelVisual3D. -->
                  <DirectionalLight Color="#FFFFFFFF" Direction="3,-4,5" />

                  <!-- Define a red cone. -->
                  <GeometryModel3D>

                    <GeometryModel3D.Geometry>
                      <MeshGeometry3D 
    Positions="0.293893 -0.5 0.404509  0.475528 -0.5 0.154509  0 0.5 0  0.475528 -0.5 0.154509  0 0.5 0  0 0.5 0  0.475528 -0.5 0.154509  0.475528 -0.5 -0.154509  0 0.5 0  0.475528 -0.5 -0.154509  0 0.5 0  0 0.5 0  0.475528 -0.5 -0.154509  0.293893 -0.5 -0.404509  0 0.5 0  0.293893 -0.5 -0.404509  0 0.5 0  0 0.5 0  0.293893 -0.5 -0.404509  0 -0.5 -0.5  0 0.5 0  0 -0.5 -0.5  0 0.5 0  0 0.5 0  0 -0.5 -0.5  -0.293893 -0.5 -0.404509  0 0.5 0  -0.293893 -0.5 -0.404509  0 0.5 0  0 0.5 0  -0.293893 -0.5 -0.404509  -0.475528 -0.5 -0.154509  0 0.5 0  -0.475528 -0.5 -0.154509  0 0.5 0  0 0.5 0  -0.475528 -0.5 -0.154509  -0.475528 -0.5 0.154509  0 0.5 0  -0.475528 -0.5 0.154509  0 0.5 0  0 0.5 0  -0.475528 -0.5 0.154509  -0.293892 -0.5 0.404509  0 0.5 0  -0.293892 -0.5 0.404509  0 0.5 0  0 0.5 0  -0.293892 -0.5 0.404509  0 -0.5 0.5  0 0.5 0  0 -0.5 0.5  0 0.5 0  0 0.5 0  0 -0.5 0.5  0.293893 -0.5 0.404509  0 0.5 0  0.293893 -0.5 0.404509  0 0.5 0  0 0.5 0  " 
    Normals="0.7236065,0.4472139,0.5257313  0.2763934,0.4472138,0.8506507  0.5308242,0.4294462,0.7306172  0.2763934,0.4472138,0.8506507  0,0.4294458,0.9030925  0.5308242,0.4294462,0.7306172  0.2763934,0.4472138,0.8506507  -0.2763934,0.4472138,0.8506507  0,0.4294458,0.9030925  -0.2763934,0.4472138,0.8506507  -0.5308242,0.4294462,0.7306172  0,0.4294458,0.9030925  -0.2763934,0.4472138,0.8506507  -0.7236065,0.4472139,0.5257313  -0.5308242,0.4294462,0.7306172  -0.7236065,0.4472139,0.5257313  -0.858892,0.429446,0.279071  -0.5308242,0.4294462,0.7306172  -0.7236065,0.4472139,0.5257313  -0.8944269,0.4472139,0  -0.858892,0.429446,0.279071  -0.8944269,0.4472139,0  -0.858892,0.429446,-0.279071  -0.858892,0.429446,0.279071  -0.8944269,0.4472139,0  -0.7236065,0.4472139,-0.5257313  -0.858892,0.429446,-0.279071  -0.7236065,0.4472139,-0.5257313  -0.5308242,0.4294462,-0.7306172  -0.858892,0.429446,-0.279071  -0.7236065,0.4472139,-0.5257313  -0.2763934,0.4472138,-0.8506507  -0.5308242,0.4294462,-0.7306172  -0.2763934,0.4472138,-0.8506507  0,0.4294458,-0.9030925  -0.5308242,0.4294462,-0.7306172  -0.2763934,0.4472138,-0.8506507  0.2763934,0.4472138,-0.8506507  0,0.4294458,-0.9030925  0.2763934,0.4472138,-0.8506507  0.5308249,0.4294459,-0.7306169  0,0.4294458,-0.9030925  0.2763934,0.4472138,-0.8506507  0.7236068,0.4472141,-0.5257306  0.5308249,0.4294459,-0.7306169  0.7236068,0.4472141,-0.5257306  0.8588922,0.4294461,-0.27907  0.5308249,0.4294459,-0.7306169  0.7236068,0.4472141,-0.5257306  0.8944269,0.4472139,0  0.8588922,0.4294461,-0.27907  0.8944269,0.4472139,0  0.858892,0.429446,0.279071  0.8588922,0.4294461,-0.27907  0.8944269,0.4472139,0  0.7236065,0.4472139,0.5257313  0.858892,0.429446,0.279071  0.7236065,0.4472139,0.5257313  0.5308242,0.4294462,0.7306172  0.858892,0.429446,0.279071  "                   TriangleIndices="0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 " />
                    </GeometryModel3D.Geometry>

                    <GeometryModel3D.Material>
                      <DiffuseMaterial>
                        <DiffuseMaterial.Brush>
                          <SolidColorBrush 
                            Color="Red" 
                            Opacity="1.0"/>
                        </DiffuseMaterial.Brush>
                      </DiffuseMaterial>
                    </GeometryModel3D.Material>

                  </GeometryModel3D>

                </Model3DGroup.Children>
              </Model3DGroup>

            </ModelVisual3D.Content>

          </ModelVisual3D>

        </Viewport3D.Children>

      </Viewport3D>
    </Grid>

</UserControl>
Afficher: