Rendu de centaines d'images "bloc" -vs- Rendu partiel d'une "carte" de blocs

Question

Il semble qu'aucune de ces solutions n'élimine le retard associé au rendu des images sur l'écran (que ce soit à partir de .png ou en utilisant CG).

Il y a une grille de blocs de 16x16 pixels de 28x16, et à certains endroits du jeu, environ la moitié d'entre eux ont besoin de changer d'image à cause d'un changement d'état. Avoir chaque bloc comme une sous-vue de la vue principale provoque un retard lorsque la moitié d'entre eux ont besoin de changer individuellement leur image (soit à partir de .png ou en utilisant CG).

J'ai essayé d'avoir une « carte » vue avec dont drawRect: méthode est:

CGContextRef context = UIGraphicsGetCurrentContext(); 
CGContextClearRect(context, rect); 

// width and height are defined as the width and height of the grid (28x16 for iPhone) 
for (int x = 0; x < width; x++) { 
    for (int y = 0; y < height; y++) { 
     // states[] is an enum instance variable that holds the states of each block in the map (state determines image) 
     if (states[(x * height) + y] == PXBlockStateEmpty) { 
      CGContextSetFillColorWithColor(context, [UIColor colorWithRed:153.0/255.0 green:153.0/255.0 blue:153.0/255.0 alpha:0.5].CGColor); 
      CGContextSetStrokeColorWithColor(context, [UIColor colorWithRed:0.0 green:0.0 blue:0.0 alpha:0.5].CGColor); 
      CGContextAddRect(context, CGRectMake(x * 16, y * 16, 16, 16)); 
      CGContextDrawPath(context, kCGPathFillStroke); 
     } else if (states[(x * height) + y] == PXBlockStateSolid || states[(x * height) + y] == PXBlockStateSolidEdge) { 
      CGContextSetFillColorWithColor(context, [UIColor colorWithRed:0.0 green:0.0 blue:102.0/255.0 alpha:0.9].CGColor); 
      CGContextSetStrokeColorWithColor(context, [UIColor colorWithRed:0.0 green:0.0 blue:0.0 alpha:0.5].CGColor); 
      CGContextAddRect(context, CGRectMake(x * 16, y * 16, 16, 16)); 
      CGContextDrawPath(context, kCGPathFillStroke); 
     } else if (states[(x * height) + y] == PXBlockStateBuilding) { 
      CGContextSetFillColorWithColor(context, [UIColor colorWithRed:51.0/255.0 green:51.0/255.0 blue:51.0/255.0 alpha:0.5].CGColor); 
      CGContextFillRect(context, CGRectMake(x * 16, y * 16, 16, 16)); 
     } 
    } 
} 

Donc ma solution était d'appeler setNeedsDisplayInRect: sur la carte, en passant le cadre (rect 16x16) du bloc dont état changé. Est-ce que j'utilise setNeedsDisplayInRect: incorrectement, ou est-ce juste un moyen inefficace de le faire? Les deux options (une sous-vue par rapport à des centaines de sous-vues) sont décalées lorsqu'un peu de la carte est remplie avec une image différente, et la seconde solution est particulièrement lente lorsque l'image de tout bloc doit être mise à jour.

Des idées? Merci de votre aide!

Answer 1

Appel de setNeedsDisplayInRect: affecte l'argument de drawRect: mais est par ailleurs identique à setneedsDisplay. Le rectangle drawRect: receive est l'union de tous les rectangles sales. Si vous ne dessinez que du contenu qui croise ce rectangle, sans toucher aux autres contenus, vous pouvez constater une amélioration de la vitesse. A en juger par l'extrait de code ci-dessus, vous dessinez chaque tuile à chaque fois. Comme il s'agit d'une union, vous pouvez également suivre les tuiles sales séparément et ne dessiner que des tuiles sales. Dans ce cas, appelez CGContextClearRect pour des tuiles individuelles au lieu de supprimer le contexte entier, à moins qu'elles ne soient toutes sales. CGContextAddRect ajoute un rectangle à un chemin qui sera dessiné.

Puisque vous tracez le chemin à chaque boucle sans commencer un nouveau chemin, vous redessinez les zones au fur et à mesure que la boucle progresse. Il serait probablement plus rapide d'utiliser CGContextFillRect et CGContextStrokeRect au lieu d'un chemin. Le fait de faire de chaque pavé un UIView séparé entraîne plus de frais généraux que le dessin dans son ensemble. Vous devriez être en mesure d'obtenir une meilleure vitesse de cette méthode une fois que les kinks sont élaborés.