Vue d'ensemble des graphiques 3D
Mise à jour : novembre 2007
Cette rubrique fournit une vue d'ensemble de fonctionnalités 3D dans le système de graphiques Windows Presentation Foundation (WPF). L'implémentation WPF3Dautorise les développeurs à dessiner, transformer et animer des graphiques 3D à la fois dans le code par balise ou par procédure, à l'aide des mêmes capacités offertes par la plateforme de graphiques 2D. Les développeurs peuvent combiner des graphiques 2D et 3D pour créer des contrôles enrichis, fournir des illustrations complexes de données ou améliorer l'expérience utilisateur de l'interface d'une application. La prise en charge 3D dans WPF n'est pas conçue pour fournir une plateforme de développement de jeu complète.
Cette rubrique contient les sections suivantes.
3D dans un conteneur 2D
Espace de coordonnées 3D
Caméras et projections
Modèle et primitives de maillage
Application de matières au modèle
Éclairage de la scène
Transformation de modèles
Animation de modèles
Ajout de contenu 3D à la fenêtre
Rubriques connexes
3D dans un conteneur 2D
Le contenu graphique 3D dans WPF est encapsulé dans un élément Viewport3D qui peut participer à la structure du document à deux dimensions. Le système de graphiques traite Viewport3D comme un élément visuel à deux dimensions comme tant d'autres dans WPF. Viewport3D fonctionne comme une fenêtre (une fenêtre d'affichage) dans une scène en trois dimensions. Plus précisément, c'est une surface sur laquelle une scène 3D est projetée.
Dans une application 2D 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 2D dans la même scène graphique, vous ne pouvez pas interpénétrer d'objets 2D et 3D dans une Viewport3D. Cette rubrique se concentrera sur la façon de dessiner des graphiques 3D à l'intérieur de la Viewport3D.
Espace de coordonnées 3D
Le système de coordonnées WPF pour les graphiques 2D localise l'origine dans la partie supérieure gauche de la zone de rendu (en général l'écran). Dans le système 2D, 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 3D 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.
Représentations de système de coordonnées 2D et 3D classiques
.png)
L'espace défini par ces axes est le système de référence stationnaire pour les objets 3D 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.
Caméras et projections
Les développeurs qui travaillent dans 2D sont habitués à positionner des primitives de dessin sur un écran à deux dimensions. Lorsque vous créez une scène 3D, il est important de se rappeler que vous créez vraiment une représentation 2D d'objets 3D. Du fait qu'une apparence de scène 3D 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 3D.
Une autre méthode pour comprendre comment une scène 3D est représentée sur une surface 2D 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 3D. 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. Du fait que les caméras ne peuvent pas se situer n'importe où dans la scène, il est possible pour la caméra d'être en fait positionnée à l'intérieur d'un modèle ou très près, ce qui rend la distinction correcte d'objets difficile. NearPlaneDistance vous permet de spécifier une distance minimum de la caméra au-delà de 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.
Position de la caméra
.png)
OrthographicCamera spécifie une projection orthogonale d'un modèle 3D sur une surface visuelle 2D. 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.
Perspective et projections orthogonales
.png)
Le code suivant affiche des paramètres de caméra typiques.
<!-- Add a camera. -->
<Viewport3D.Camera>
<PerspectiveCamera FarPlaneDistance="20" LookDirection="5,-2,-3" UpDirection="0,1,0" NearPlaneDistance="1" Position="-5,2,3" FieldOfView="45" />
</Viewport3D.Camera>
// 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;
// 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;
Modèle et primitives de maillage
Model3D est la classe de base abstraite qui représente un objet 3D générique. Pour générer une scène 3D, 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 3D est une collection des sommets qui forment une entité 3D unique. La plupart des systèmes 3D 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 WPF3Dfournit 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 3D 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 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'indices 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 indices. 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 indices spécifiés par la liste TriangleIndices sont 0, 2 et 1, lesquels correspondent au premier, troisième et deuxième point 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 comment une texture est attirée sur les sommets du maillage. TextureCoordinates sont spécifiés comme une valeur inclusive entre zéro et 1. 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();
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));
Application de matières au modèle
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 2D, 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 3D 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 3D que vous pouvez appliquer aux objets 2D, 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 2D ; 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 3D.
<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>
<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"]);
Éclairage de la scène
Les lumières dans les graphiques 3D 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 selon leur position et distance par rapport à la lumière. PointLightBase expose une propriété Range qui détermine un 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();
myDirLight.Color = Colors.White;
myDirLight.Direction = new Vector3D(-3, -4, -5);
modelGroup.Children.Add(myDirLight);
Transformation de modèles
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 2D, 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.
Animation de modèles
L'implémentation WPF 3D participe au même système de minutage et d'animation que les graphiques 2D. 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 tables de montage séquentiel, 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 3D 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));
Vector3DAnimation myVectorAnimation = new Vector3DAnimation(new Vector3D(-1, -1, -1), new Duration(TimeSpan.FromMilliseconds(5000)));
myVectorAnimation.RepeatBehavior = RepeatBehavior.Forever;
myRotateTransform.Rotation.BeginAnimation(AxisAngleRotation3D.AxisProperty, myVectorAnimation);
//Add transformation to the model
cube1TransformGroup.Children.Add(myRotateTransform);
Ajout de contenu 3D à la fenêtre
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).
Voir aussi
Concepts
Vue d'ensemble des transformations 3D