UIVoir la transparence montre comment les saucisses sont fabriquées!

Question

J'ai un récipient UIView qui a deux UIImageView s à l'intérieur, un occultant partiellement l'autre (ils se composant comme celui-ci pour permettre une animation occasionnelle d'une « couche » ou d'une autre.

Parfois, je veux faire ce conteneur contient 50% d'alpha, donc ce que les utilisateurs voient s'estompe, voici le problème: régler ma vue conteneur à 50% alpha fait que toutes mes sous-vues en héritent aussi, et maintenant vous pouvez voir la première sous-vue dans la seconde l'application a un effet de rayon X bizarre que je ne recherche pas

Ce que je veux, bien sûr, c'est pour ce que l'utilisateur voit actuellement devenir transparent à 50% - l'équivalent de l'aplatissement de la vue visible dans un bitmap, puis en faisant ce 50% alpha.

Quels sont mes meilleurs paris pour accomplir cela? Idéalement, je voudrais éviter, en aplatissant dynamiquement les vues si je peux l'aider, mais aussi les meilleures pratiques sur cet accueil. Est-ce que je manque quelque chose d'évident? Comme la plupart des vues ont des sous-vues et rencontreraient ce problème, j'ai l'impression qu'il y a une solution évidente ici.

Merci!

EDIT: Merci pour les gens de pensées. Je déplace juste une image au-dessus d'une autre image, qu'elle obscurcit seulement partiellement. Et cette paire d'images doit parfois bouger ensemble. Et parfois, je veux effacer le tout, où que ce soit, et quel que soit l'état de la paire d'images en ce moment. Plus tard, je veux le ramener et continuer à l'animer. Prendre un instantané du conteneur, soit en rendant son calque (?), Soit en faisant d'autres compositing à la volée avant d'alpha-out le tout, est certainement possible, et je sais qu'il y a deux façons pour le faire. Mais que se passe-t-il si l'animation continue à se produire alors que le tout est à 50% alpha, par exemple?

Il semble qu'il n'y ait pas de solution évidente à ce que j'essaie de faire, ce qui me semble étrange, mais merci à tous pour vos commentaires.

Answer 1

Je pense que l'aplatissement de l'UIView dans un UIImageView est votre meilleur choix si vous avez le cœur sur cette fonction. En outre, je ne pense pas que l'aplatissement de l'image soit aussi compliqué que vous le pensez. Jetez un oeil à la réponse fournie dans this question.

Answer 2

Une façon de le faire serait d'ajouter les ImageViews au UIWindow (le conteneur serait un faux)

Answer 3

Régler le UIImageView bas pour avoir .hidden = YES, puis définissez .hidden = NO lorsque vous configurez une animation cross-fade entre les UIImageViews haut et bas.

Lorsque vous avez besoin de fondre le tout, vous pouvez définir .alpha = 0.5 dans la vue conteneur ou dans la vue d'image supérieure - cela ne devrait pas avoir d'importance. Il peut être plus efficace sur le plan informatique de définir .alpha = 0.5 sur la vue de l'image elle-même, mais je ne connais pas assez le pipeline graphique sur l'iPhone pour être sûr de cela. Le seul inconvénient de cette approche est que vous ne pouvez pas effectuer un fondu enchaîné lorsque votre image supérieure est définie sur 50% d'opacité.

Answer 4

Récemment j'ai eu ce même problème, où j'avais besoin d'animer des couches de contenu avec une transparence globale. Depuis mon animation était assez complexe, j'ai découvert que l'aplatissement de la hiérarchie UIView faite pour une animation saccadée.

La solution trouvée consistait à utiliser CALayers au lieu de UIViews et à définir la propriété .shouldRasterize sur YES dans la couche de conteneur, de sorte que toutes les sous-couches soient automatiquement aplaties avant l'application de l'opacité.

Voici ce que un UIView pourrait ressembler à:

#import <QuartzCore/QuartzCore.h> //< Needed to use CALayers 

... 

@interface MyView : UIView{ 
    CALayer *layer1; 
    CALayer *layer2; 
    CALayer *compositingLayer; //< Layer where compositing happens. 
} 

... 

- (void)initialization 
{ 
    UIImage *im1 = [UIImage imageNamed:@"image1.png"]; 
    UIImage *im2 = [UIImage imageNamed:@"image2.png"]; 

    /***** Setup the layers *****/ 
    layer1 = [CALayer layer]; 
    layer1.contents = im1.CGImage; 
    layer1.bounds = CGRectMake(0, 0, im1.size.width, im1.size.height); 
    layer1.position = CGPointMake(100, 100); 

    layer2 = [CALayer layer]; 
    layer2.contents = im2.CGImage; 
    layer2.bounds = CGRectMake(0, 0, im2.size.width, im2.size.height); 
    layer2.position = CGPointMake(300, 300); 

    compositingLayer = [CALayer layer]; 
    compositingLayer.shouldRasterize = YES; //< Here we turn this into a compositing layer. 
    compositingLayer.frame = self.bounds; 

    /***** Create the layer three *****/ 
    [compositingLayer addSublayer:layer1]; //< Add first, so it's in back. 
    [compositingLayer addSublayer:layer2]; //< Add second, so it's in front. 

    // Don't mess with the UIView's layer, it's picky; just add sublayers to it. 
    [self.layer addSublayer:compositingLayer]; 
} 

- (IBAction)animate:(id)sender 
{ 
    /* Since we're using CALayers, we can use implicit animation 
    * to move and change the opacity. 
    * Layer2 is over Layer1, the compositing is partially transparent. 
    */ 
    layer1.position = CGPointMake(200, 200); 
    layer2.position = CGPointMake(200, 200); 
    compositingLayer.opacity = 0.5; 
}