Rafraichir une animation pour changer le chemin d'un fichier externe [Résolu]

[nicolas2603]

Bonjour. Est-il possible dans Flash de rafraichir une animation à un instant donné ? Je m'explique. Sur ma scène j'ai un clip, dans lequel je charge par défaut x images externes (façon damier positionné en nLigne et nColonne) qui sont localisées dans un dossier en relation avec une variable de la scène :

Code :

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
var indiceZoom:Number = 0;
_global.indiceZoom = 0;
 
this.onEnterFrame = function () {
	if (this.hitTest(_root.ZoneFenetre)) {
		load(numLigne, numColonne);
	}
}
 
function load(nLigne:Number, nColonne:Number) {
	var tmp:MovieClip = this.createEmptyMovieClip("image", 1);
 
	var listener:Object = new Object();
	listener.onLoadInit = initialisation;
 
	var mcl:MovieClipLoader = new MovieClipLoader();
	mcl.addListener(listener);
	var fileName:String = "fonds/z" + _global.indiceZoom + "/0" + nColonne + "x0" + nLigne + ".jpg";
	mcl.loadClip(fileName, tmp);
}
 
function initialisation(aTarget:MovieClip) {
	aTarget._width = 160;
	aTarget._height = 160;
}

A un moment la variable indiceZoom va changer et passer à 1, à ce moment là, j'aimerai que les images qui ont été chargés au préalable depuis le dossier 0 se recharge, mais en puisant cette fois dans le dossier 1 !! J'ai essayé tout simplement de rajouter dans le EnterFrame

Code :

1
2
3
if (_global.indiceZoom == 1) {
	load(numLigne, numColonne);
}

pour forcer le rechargement mais ça supprime les images déjà chargées sans recharger les autres !!!

Suis-je assez clair ? Merci d'avance.

[beekeep]

Salut,

tu peux simplement créer un clip conteneur vide qui contiendra tout les conteneurs de tes images.

lorsque tu veux ensuite 'rafraichir' supprime le à l'aide de removeMovieClip
puis relance le chargement.

[nicolas2603]

salut, le truc c'est qu'il faut que lorsque l'indice change, les images se rechargent mais pas qu'elles disparaissent toutes pour se recharger ensuite. J'aimerai que le traitement se fasse image par image, tu vois ce que je veux dire ? De plus, chaque image est externe et chargée dans un clip qui lui même est chargé façon attachMovie dans un clip de départ
ClipGlobal > ClipConteneur_1 > image_1
ClipGlobal > ClipConteneur_2 > image_2
ClipGlobal > ClipConteneur_3 > image_3 ...
C'est pas évident à expliquer !!

[beekeep]

j'avoue,

c'est pas non plus évident à comprendre.

essaye de décrire le fonctionnement global que tu voudrai avoir.

[nicolas2603]

Alors l'idée c'est d'afficher une image (genre photo aérienne) de trés trés bonne qualité et donc trés trés lourde, et de pouvoir zoomer dessus. Pour ça, elle est découpée en dalles de x ligne et x colonne, afin de charger de façon dynamique uniquement la partie de l'image qui est visible sur la scène. Ce qui permet aussi (en théorie, pas encore en pratique) lors des seuils de zoom de remplacer la dalle de l'image chargée par une autre de meilleure qualité pour que ce ne soit pas moche au zoom. Alors, une démonstration sera plus parlante qu'autre chose, je cherche à faire cet effet là : http://supratlas.geogarage.com/fs.html.

Donc voici maintenant comment je m'y suis pris. Prêt, c'est parti ...

ETAPE 1 : J'ai sur ma scène un clip qui va me servir de conteneur pour toutes les dalles. C'est le clip DalleConteneur. Je détermine le nombre de dalles d'images à charger pour constituer l'image globale, soit x lignes et x colonnes, et j'attache x fois un sous-conteneur vide qui plus tard accueillera les images. Si je ne m'abuse cette étape c'est d'ailleurs toi qui m'a aidé à la réaliser. La variable tailleDalle détermine la taille du conteneur vide, je l'ai mise en globale car apparemment ça ne fonctionnait pas autrement. Ce code est sur un calque sur la scène principale :

Code :

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
var tailleDalle:Number;
_global.tailleDalle = 160;
 
var affichDalle:Number;
_global.affichDalle = 0;
 
var loadDalle:Number;
_global.loadDalle = 0;
 
var indiceZoom:Number;
_global.indiceZoom = 0;
 
var zoomPourcentage:Number;
_global.zoomPourcentage = 0;
 
var nbreLigne:Number = 8;
var nbreColonne:Number = 8;
var startX:Number = 0;
var startY:Number = 0;
 
maillage = function () {
	for (var c=1; c<=nbreColonne; c++) {
		for (var l=1; l<=nbreLigne; l++) {
			this.DalleConteneur._visible = false;
			this.DalleConteneur.attachMovie("dalle", "_" + c + "x" + l, this.DalleConteneur.getNextHighestDepth());
			this.DalleConteneur["_" + c + "x" + l]._x = startX;
			this.DalleConteneur["_" + c + "x" + l]._y = startY;
			startY += _global.tailleDalle;
			if (startY >= _global.tailleDalle*nbreColonne) {
				startY = 0;
				startX += _global.tailleDalle;
			}
			this.DalleConteneur["_" + c + "x" + l].numLigne = l;
			this.DalleConteneur["_" + c + "x" + l].numColonne = c;
		}
	}
}
 
maillage();

ETAPE 2 : Sur ma scène je détermine un espace masque ZoneFenetre dans lequel vont se charger puis s'afficher les images, c'est à dire que si le sous-conteneur vide chargé est en dehors de ce masque, il ne charge pas l'image. Ce code là, je l'ai mis directement dans le clip qui va être x fois attaché dalle. Tu peux voir que les paramètres qui doivent être vérifiés pour lancer le chargement de l'image sont :
1) afficheDalle -> je le définis par défaut sur 0 et il passe à 1 quand je clique sur un checkbox "afficher l'image",
2) loadDalle -> par défaut à 0 il passe à 1 lorsque la fonction est faite une première fois, pour éviter que ça charge indéfiniment l'image,
3) this.hitTest -> si la dalle touche le masque on charge le tout.
Tu vois aussi que l'image qui est chargée sera l'image en x ligne et x colonne, et dans un répertoire zx ou x correspond au zoom d'affichage par défaut à 0.

Code :

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
this.onEnterFrame = function () {
	if (affichDalle == 1 && loadDalle == 0) {
		if (this.hitTest(_root.ZoneFenetre)) {
			load(numLigne, numColonne);
			loadDalle = 1;
		}
	}
}
 
function load(nLigne:Number, nColonne:Number) {
	var tmp:MovieClip = this.createEmptyMovieClip("image", 1);
	var listener:Object = new Object();
	listener.onLoadInit = initialisation;
 
	var mcl:MovieClipLoader = new MovieClipLoader();
	mcl.addListener(listener);
 
	var fileName:String = "fonds/z" + indiceZoom + "/0" + nColonne + "x0" + nLigne + ".jpg";
	mcl.loadClip(fileName, tmp);
}
 
function initialisation(aTarget:MovieClip) {
	aTarget._width = _global.tailleDalle;
	aTarget._height = _global.tailleDalle;
}

ETAPE 3 : J'ai une molette de zoom qui me permet de zoomer sur le clip DalleConteneur et donc d'agrandir tout ce qui est dedans. Ma molette de zoom est un clip Localisation, donc sur ma scène principale j'ai un code qui dit que, lorsque la variable zoomPourcentage (par défaut à 0) passe à 25% alors, l'indiceZoom passe de 0 à 1 pour changer le répertoire des images de z0 à z1, et loadDalle passe de 1 à 0 pour relancer la fonction load(dalle) vue au dessus :

Code :

1
2
3
4
5
6
this.Localisation.onEnterFrame = function () {
	if (zoomPourcentage >= 25){
		_global.indiceZoom = 1;
		_global.loadDalle = 0;
	}
}

Le problème c'est qu'apparemment dans le clip attaché Dalle, le changement de valeur pour la variable loadDalle n'est pas reconnu, alors que si je fais un trace le changement pour indiceZoom lui l'est bien !! Voilà voilà, j'espère que c'est plus clair, et au pire, je peux t'envoyer mon fichier si tu as envies et le courage d'y jeter un oeil !

[beekeep]

Salut

plutôt sympa comme animation !

et déjà merci pour toutes ces explications.


je pense qu'arriver au résultat de la carte Google de ton lien soit au dessus de mes compétences.
Je crois bien que c'est des algorithmes très évolués.

mais je vais me contenter de répondre à ton problème précis et ne pas m'étendre trop sur la façon de faire que tu as déjà choisis.

donc si j'ai bien compris il faudrai que les dalles relancent le chargement de l'image si elles sont dans la zone d'affichage lorsque tu change la valeur de la variable loadDalle.

- pour que ça se fasse automatiquement il faut que les dalles scrutent un changement de valeur,
donc définir la fonction onEnterFrame de chaque dalle et tester la valeur.

il se peut que ça surcharge un peu l'animation avec un grand nombre de dalle.
une autre solution est que lorsque tu change la valeur relance aussi la fonction load de chaque dalle.

j'espère avoir été compréhensible.

sinon sur le fonctionnement général :

l'image globale est divisée en plusieurs pour alléger l'affichage lorsque l'on zoom.
mais si le zoom est au minimum (par exemple quand on voit toute la planete) il n'y a pas de différence à charger l'image entière ?
(sauf peut-etre le chargement progressif des dalles)

[nicolas2603]

Merci à toi ! Oui j'en ai déduis également qu'il fallait que je code un onEnterFrame pour chaque dalle, mais apparemment la valeur de la variable loadDalle n'est pas détectée dans le onEnterFrame. Est-ce que ça vient de l'utilisation de la variable loadDalle en temps que variable globale ? Est-ce que ça vient du fait que chaque dalle est le clip dalle attaché sur la scène x fois ? Lorsque la variable zoomPourcentage devient > à 25 je redonne à loadDalle la valeur 0 pour que dans le onEnterFrame du clip dalle la fonction de chargement soit relancée, mais lorsque je vérifie avec un trace dans la fonction la valeur a bien changée mais du coup le clip se vide et reste vide !! Ou alors il recharge indéfiniment et donne du coup l'impression qu'il n'y a rien ... C'est un sacré bordel !

Pour ce qui est de charger à zoom 0 l'image globale, il faudrait télécharger l'équivalent de 500 Mo, c'est pour ça que j'opte pour des dalles de qualité différente en fonction des zooms ...

[beekeep]

il faut bien distinguer la variable de chaque dalle (chargée ou non) et celle globale (lancer le chargement ou non)

au passage tu peux utiliser des booléens et choisir des noms plus parlants (ex: bImageLoaded)


quand tu testes la valeur de la variable globale dans le onEnterFrame utilise bien le ciblage '_global.'

pour la variable du clip dalle (bImageLoaded) que tu n'utilise que dans le clip dalle lui-même il faut y accéder avec le ciblage 'this.'

[nicolas2603]

OKKKKKKKKKKKK ça y est j'ai cerné le truc ! J'ai mis 2 variables globales zoomIndice qui détecte les seuils de zoom, et affichDalle qui détecte si la couche est affichée ou pas, et dans le clip j'ai mis 2 variables relatives, loadDalle qui charge l'image si elle n'est pas chargée :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
var loadDalle:Number = 0;
var indiceZoomDalle:Number = 0;
 
this.onEnterFrame = function () {
	if (affichDalle == 1 && loadDalle == 0) {
		if (this.hitTest(_root.ZoneFenetre)) {
			load(numLigne, numColonne);
			loadDalle = 1;
		}
	}
	if((_global.indiceZoom == 1) && (indiceZoomDalle == 0)) {
		loadDalle = 0;
		indiceZoomDalle = 1;
	}
}

J'ai rajouté la variable indiceZoomDalle car lorsque l'indiceZoom repassait à 1 ma loadDalle devenait 0 et donc le chargement se relancait, mais puisque l'indiceZoom restait > 1 ça se relançait tout le temps !! maintenant ça a l'air de fonctionner ... T'es trés trés fort toi ! Je vais faire des tests demain mais à priori ça roule. Vraiment un grand merci ...

[nicolas2603]

Salut, c'est encore moi ! Bon finalement il y a un soucis que je n'arrive pas à résoudre ! Au changement de la variable indiceZoom, j'ai bien mes dalles qui se rechargent, mais une seule fois, c'est à dire que lorsque la variable rechange, les dalles ne suivent pas. J'ai donc ma variable globale indiceZoom qui change de valeur comme ça :
0 à 25 % de zoom -> _global.indiceZoom == 0
25 à 50% -> 1
50 à 75% -> 2
75 à 100% -> 3
Ca c'est donc sur la scène principale.

Dans chaque dalle qui est attaché il y a ce code :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
var loadDalle:Number = 0;
var indiceZoomDalle:Number = 0;
 
this.onEnterFrame = function () {
	if (affichDalle == 1 && loadDalle == 0) {
		if (this.hitTest(_root.ZoneFenetre)) {
			load(numLigne, numColonne);
			loadDalle = 1;
		}
	}
	if((indiceZoom == 1) && (indiceZoomDalle == 0)) {
		loadDalle = 0;
		indiceZoomDalle = 1;
	}
	if ((indiceZoom == 2) && (indiceZoomDalle == 0)) {
		loadDalle = 0;
		indiceZoomDalle = 1;
	} 
	if ((indiceZoom == 3) && (indiceZoomDalle == 0)) {
		loadDalle = 0;
		indiceZoomDalle = 1;
	}
}

Lorsque indiceZoom passe à 1, ça relance bien le chargement de mes dalles, mais lorsque je continue à zoomer et donc que je passe à 2 ou 3, ça ne fais rien. Pourtant un trace m'indique qu'ici le changement de variable indiceZoom est détecté. Apparemment le code ne s'occupe que du premier if, et lorsque je rajoute les 2 autres if il ne les prend pas en compte ... Une idée du pourquoi ?

EDIT : ok problème résolu, en fait il fallait que je mette une variable indiceZoomDalle différente pour chaque IF, logique ...