I. Comment s'appelle la technologie Win32 qui permet de faire des animations en C++ ?

Le gestionnaire d'Animation de Windows (Windows Animation) permet une animation riche des éléments d'interface utilisateur. Il est conçu pour simplifier le processus d'ajout d'animation à l'interface utilisateur d'une application et pour permettre aux développeurs de mettre en œuvre des animations qui sont fluides, naturelles et interactives.

La plate-forme d'animation de Windows 7, gère la planification et l'exécution des animations, et fournit également une bibliothèque de fonctions mathématiques (des storyboards) utiles pour spécifier le comportement d'un élément d'interface utilisateur au fil du temps. Elle permet également aux développeurs de mettre en œuvre des fonctions personnalisées qui fournissent des comportements supplémentaires.

Il est à noter que, ce n'est pas elle qui est en charge du rendu, mais qu'elle peut être utilisée avec n'importe quelle plate-forme graphique, y compris Direct2D, Direct3D ou GDI +.

Les deux unités fondamentales d'une animation sont (1) la caractéristique d'un élément visuel à animer et (2) la description de la façon dont cette caractéristique change au fil du temps. Une application peut animer une grande variété de caractéristiques telles que la position, la couleur, taille, rotation, contraste et opacité.

Dans Windows Animation, une variable d'animation représente la caractéristique à animer. Une transition décrit l'évolution de la valeur de cette variable d'animation lorsqu'une animation se produit. Par exemple, un élément visuel pourrait avoir une variable d'animation qui spécifie son opacité, et une action de l'utilisateur pourrait générer une transition qui prend cette opacité d'une valeur de 50 à 100, ce qui représente une animation de semi-transparent entièrement opaque. Un storyboard est un ensemble de transitions appliquées à une ou plusieurs variables d'animation au fil du temps.

Pour utiliser Windows Animation, il faut initialiser la plateforme :

 
Sélectionnez
// Création du gestionnaire d'Animation
HRESULT hr = CoCreateInstance(
	CLSID_UIAnimationManager,
	NULL,
	CLSCTX_INPROC_SERVER,
	IID_PPV_ARGS(&m_pAnimationManager));
if (SUCCEEDED(hr))
{
	// Création du Timer d'animation
	hr = CoCreateInstance(
		CLSID_UIAnimationTimer,
		NULL,
		CLSCTX_INPROC_SERVER,
		IID_PPV_ARGS(&m_pAnimationTimer));
	if (SUCCEEDED(hr))
	{
		// Création de la librairie de Transition
		hr = CoCreateInstance(
			CLSID_UIAnimationTransitionLibrary,
			NULL,
			CLSCTX_INPROC_SERVER,
			IID_PPV_ARGS(&m_pTransitionLibrary));
	}
}

Créer les variables d'animations :

 
Sélectionnez
// Création des variables d'animations pour les coordonnées X et Y de la Bitmap
HRESULT hr = m_pAnimationManager->CreateAnimationVariable(
		x,
		&m_pAnimationVariableX);
if (SUCCEEDED(hr))
{
	hr = m_pAnimationManager->CreateAnimationVariable(
		y,
		&m_pAnimationVariableY);
}

Récupérer les variables d'animations avant de dessiner le bitmap :

 
Sélectionnez
HRESULT CThumbnail::Render(ID2D1RenderTarget* pRT)
{
    D2D1_SIZE_F size = GetSize();
    
    DOUBLE x = 0;
    HRESULT hr = m_pAnimationVariableX->GetValue(
        &x
        );
    if (SUCCEEDED(hr))
    {
        DOUBLE y = 0;
        hr = m_pAnimationVariableY->GetValue(
            &y
            );
        if (SUCCEEDED(hr))
        {
            D2D1_RECT_F rc = D2D1::Rect<FLOAT>(
                static_cast<FLOAT>(x - 0.5 * size.width),
                static_cast<FLOAT>(y - 0.5 * size.height),
                static_cast<FLOAT>(x + 0.5 * size.width),
                static_cast<FLOAT>(y + 0.5 * size.height) 
                );
			_data->PositionY =rc.top;
			_data->PositionX=rc.left ;
            pRT->DrawBitmap(
                m_pBitmap,
                rc,
                OPACITY
                );           
        }
    }
    return hr;
}
Pour plus d'infos :