Du son générant une forme

[artemisart]

-est-il possible d'interpoler deux "positions" du mesh afin de créer une transition plus douce, même lorsqu'on augmente le temps de refresh ?
->j'ai commencé à regarder du coté de Lerp, que j'ai utilisé pour la couleur, mais il ne semble s'appliquer qu'aux transformations (position,localscale). Comment faire dans le cadre de changements de coordonnées ?

Tu peux regarder du côté de Vector3.Lerp (et Quaternion.Lerp).

-le "sol" est constitué de deux triangles (jusqu'ici rien de folichon - dans le void genSol ligne 182). Les dimensions sont paramétrables, mais le nombre de triangle reste le même. La déclaration du mesh par ligne était assez claire, j'ai plus de mal avec les triangles.
->J'ai essayé de dire "1 surface = 4 points = 6 valeurs(soit 2 triangles)" en rendant le nombre de "surfaces" publiques. Mais ça ne marche pas beaucoup du tout. Quelqu'un aurait déjà réussi à faire un plan paramétrique dont on peut choisir le nombre de triangle ?

"1 surface = 4 points = 6 valeurs(soit 2 triangles)" Oui, mais seulement si ta surface est 1 quad.
Si tu veux un code d'exemple, qui génère un plan d'une certaine dimension, avec 1 quad au m² : (certaines choses sont inutiles dans ton cas, faut trier, + un léger "bug" : les normales pointent vers le bas)

Code : Tout sélectionner

 // variables :
// int dimensions = 8; // dimensions du plan
// float resolution = 10; // scale du perlin noise
// int height = 8; // taille du terrain
	void CreateMesh ()
	{
		if (resolution < 1)
			resolution = 1;
		Vector3[] vertices = new Vector3[dimensions * dimensions];
		List<int> tris = new List<int> ();
		
		for (int x = 0; x < dimensions; x++)
		{
			for (int z = 0; z < dimensions; z++)
			{
				vertices[z * dimensions + x] = new Vector3 (x, Mathf.PerlinNoise (x / resolution, z / resolution) * height, z); // ici, la hauteur des vertices correspond à un bruit de perlin.
				if (x < dimensions - 1 && z < dimensions - 1)
				{
					tris.Add (z * dimensions + x);
					tris.Add (z * dimensions + x + 1);
					tris.Add ((z + 1) * dimensions + x + 1);
					tris.Add ((z + 1) * dimensions + x + 1);
					tris.Add ((z + 1) * dimensions + x);
					tris.Add (z * dimensions + x);
				}
			}
		}
		
		mesh.triangles = null;
		mesh.vertices = vertices;
		mesh.triangles = tris.ToArray ();
		mesh.RecalculateBounds ();
		mesh.RecalculateNormals ();
	}

Qu'est-ce que c'est pratique, mais j'ai une question. Peut-on instancier/Lister les lignes produites avec ? Ou le fait qu'elles viennent direct Renderer rend ça impossible ?

instancier ??
Pour les lister, tu peux ajouter une fonction qui renvoi private List<Line> linesZOn; et private List<Line> linesZOff;
Par contre attention : dès qu'une ligne ne doit plus être affichée (temps écoulé) elle est supprimée, et la différence entre les 2 listes et la prise en compte du z (2 shaders différents).

J'ai commencé à déchiffrer l'exemple posté plus haut qui permet de créer de la sphère à l'icosaèdre comme on crée des formes primitives. J'aimerai faire le même genre de chose : pouvoir créer plusieurs fonctions genX (générant chacune un mesh) et pouvoir les activer/désactiver depuis le GUI, c'est possible ? Quelqu'un aurait un petit exemple/tuto ?

Pas tout compris ^^.
Tu veux générer un mesh différent en fonction du bouton cliqué par exemple ? Si oui tu peux tous les générer et activer/désactiver leur rendu, ou tu peux regénérer le mesh à chaque fois qu'on clique sur un bouton différent.

[Rant]

Génial merci pour la vitesse et la précision des réponses !

Je vais tester tout ça et essayer de mettre une petite scène en place : )

je disais des bétises pour instancier, je pensais aux clones, mais ça ne marche qu'avec les GameObject si j'ai bien compris.

Pour ma dernière question je crois que j'ai voulu aller plus vite de la musique, au final je pensais aux trois :
-faire apparaitre-disparaitre par type de mesh
-arreter les valeurs (photo paysage à un moment donné)
-lancer manuellement le refresh une fois

Mais ça fait beaucoup, et c'est surtout lié à du "comment programmer" , et plus je fouille les exemples de scripts, plus je me dis que certaines des réponses à mes questions doivent bien s'y trouver, je vais chercher

Une des scènes que ça pourrait donner à l'idéal serait du genre (parce qu'on peut quand même se demander à quoi bon ?! et puis faut bien rêver un peu):

un sol mouvant reprenant la forme de l'onde, de l'herbe qui pousse par ligne avec hauteur=volume, inclinaison et couleur=spectre
+
un émetteur de particule qui se ballade à une certaine hauteur -> émission en fonction du volume, couleur et taille en fonction du spectre

->lorsqu'une particule touche le sol, elle lance un gameobject selon les variables de couleur et de taille (par grands intervals, par exemple les rouges donnent tout ce qui est sphères, les verts des structure fractale en ligne, les bleus relancent un émetteur de particule un peu liquide).

Vu que tout ça est très subjectif je voulais en plus intégrer un petit questionnaire au début du genre
- le rouge c'est plus rond/carré/triangle, et le bleu ?
-ce qui va vite est plus petit/grand que ce qui est lent ?
-s'ennuyer c'est : bleu/rouge/vert
etc...mais je pense commencer ça simplement. Avec par exemple 3 intervals de couleurs = 3 gameObject. Ca serait déjà bien.

En tout cas encore merci !

[Rant]

La suite, un dossier de projet et quelques screens : https://www.dropbox.com/sh/b8sbn9m36qup7sn/M0SoUNha6B



Normalement le projet est prêt à être lancé pour ceux qui veulent tester, faut juste choisir une musique(le script est sur la maincamera) et lancer.

Comment c'est censé marcher ? Le silence est représenté par une sphere au centre d'une "bulle grille". Lorsque le son se lance, un clone commence à se déplacer en laissant une trainée. Il est géré par deux systèmes de coordonnées, l'un orthogonal (smoothdamp), l'autre sphérique (slerp) à l'intérieur d'une fonction "rotate around". Le satellite passe de l'un à l'autre des systèmes en fonction du volume.

https://dl.dropboxusercontent.com/u/434 ... schema.jpg

les coordonnées X sont le log du nombre de samples, le Y celui du spectre (c'est ce que multiplie "amplitude"). et le Z l'inverse du spectre.La vitesse du rotate around est gérée par le volume. Le chiffre de l'orbite et relatif car multiplié par le volume. Plus le son est fort et aigu, plus l'orbite est grande, et inversement. (c'est d'ailleurs peut-être à inverser, car les basses fréquences ont une longueur d'onde plus grande, d'un autre coté elles vibrent moins vite, et plus son orbite est grande, plus le satellite va vite, je sais pas).

En se déplacant le satellite a une "chance" de se cloner en fonction du volume (plus le volume est haut, plus il y a de clones). Il génère aussi des particules dont plusieurs paramètres (taille, couleur, lifetime, vélocité) dépendent de lui et donc du son.

Les autres éléments :- les "troncs": ce sont les lignes rouges qui se balladent, c'est un projet de pelouse ou arbre (en fonction de si elles sont clonées une à une ou regroupées sous forme d'un bouquet). c'est un dessin vertical de l'onde, il est aussi influencé par l'amplitude.

-la mer : c'est le tuto 2 de catlike coding ; ) j'essaie de l'adapter aux valeurs du son mais c'est en cours.

Note : On peut aussi déplacer la sphère principale en mode scène, le satellite continue d'orbiter autour mais les clones laissent un genre de trainée du coup. Je pense mettre un rigidbody pour pouvoir faire ça même en mode game.
Voilà pour ce qui est fait ou en cours...maintenant ^^....

questions ?!??!

-Je cherche à déclencher les "troncs" et la "mer" lors de la collision de particules (la trainée du satellite, et une explosion à la mort des clones). Pour ça il y a des systemes de particules legacy avec un world collider dessus.
Jusque là tout va bien, seulement j'ai un doute sur la façon d'organiser ça et surtout, surtout, je n'arrive pas à trouver comment "cocher la case" "Send Collision message" par script. J'ai trouvé pas mal de réponse qui expliquent que c'est la solution, mais sans dire comment : ).

-J'aimerai intégrer de l'audio en direct (un micro par exemple). On trouve un exemple dans les script référence, qui marche assez bien. Seulement voilà il fait crasher la scène après quelques temps : http://docs.unity3d.com/Documentation/S ... Start.html

Eux : http://m1interactive.tumblr.com/post/43 ... nteractive , qui ont fait un visualisateur sympa avec unity ont trouvé un moyen de résoudre le problème en (traduis) "L'audio est en fait enregistré, "buffer", retardé, joué en playback, et détruit. " Apparement le délai créé est peu perceptible et c'est vrai que ca a l'air de marcher plutot bien : http://vimeo.com/60610326

Est-ce que c'est très compliqué de créer une boucle de buffer ? j'ai essayé de regarder un peu mais j'avoue que de but en blanc ca parait un peu insurmontable, ca ressemble à quoi ces choses ?

Est-ce qu'il existe un moyen simple de récupérer les delegates et de les utiliser dans le GUI ?

Voilà, tout commentaire, remarque, sur le script ou n'importe quel élément est bienvenue. Le script se nomme SonC2, il doit se trouver dans les assets.

[Rant]

Je compile ici quelques informations qui peuvent être intéréssantes concernant le spectre, et un essai d'extension du tuto/utilisation de listes

d'abord quelques liens généraux sur l'analyse de spectres :
http://www.ta-formation.com/cours-spect ... ectres.pdf
http://gia.agroparistech.fr:10000/educ/ ... ctrale.pdf

ensuite des liens plus directement liés à unity :
http://www.alastaircallum.com/u/audioVis/index4.html un exemple de visualisateur audio
http://www.youtube.com/watch?v=zvciEKEjuXI&hd=1 un autre, avec l'algorythme : http://www.smokycogs.com/blog/the-lorentz-attractor/

le fil des unity answers : http://forum.unity3d.com/threads/58769- ... ysis/page3

dont voici quelques infos :

-Les fréquences les plus basses sont séparées par de plus petits intervals que les fréquences les plus hautes
-GetSpectrumData retourne une transformation standard de Fourrier (FFT). Le fait que l'array doivent utiliser une puissance de 2 indique que l'algorythme est probablement celui de Cooley- Tukey.
http://en.wikipedia.org/wiki/Cooley-Tukey_FFT
-Dans la vie réelle il y a toujours un peu d'énergie sur toutes les fréquences. Pour l'audio "harmonique" comme la musique, le spectre est dominé par des pics
-Pour détecter une fréquence particulière : il faut traverser l'ensemble des données et récupérer celle dont la valeur en decibel est la plus importante.
-La fréquence du pic est égale au numsamples(volume) * numsamples(spectrum)/2.
-Lorsqu'il s'agit d'harmonique, la fondamentale est toujours la fréquence la plus basse, mais il ne s'agit pas toujours du pic le plus élevé.
-Les fréquences des autres pics dans un signal harmonique sont des multiplications de la fondamentale.
-pour les intéréssés il y a un pack d'analyse qui a l'air complet et date de fin 2012 mais il est à 50$ : )

partant de ça et des ref scripts : http://docs.unity3d.com/Documentation/S ... mData.html

J'ai fait une petite expérience pour essayer d'affiner les données tirées du premier tableau de spectre :



Je pense que c'est assez explicite, le spectre est divisé en plusieurs parties, d'abord égale puis dont la taille augmente progressivement. Il y a un son qui balaye toutes les fréquences et permet de voir la vague de l'onde se déplacer d'une ligne à l'autre. On peut régler la longueur et l'amplitude en cours pour voir quel ratio est le plus exploitable en fonction de la situation.

C'est fait avec des List à grand coup de .Add, j'ai bien vu un GetRange, InsertRange passer, mais j'en suis pas encore là. Désolé si le code est un peu...répétitif.

C'est pas tout à fait fini, notamment j'essaye de mettre le type de fenetre FFT en enumerable dans l'inspecteur, et peut-être de calculer quelques fréquences. Et un genre de pitch avec des moyennes et des boolean peut-être
Au final personne n'aura jamais besoin de tout ces tableaux à la fois mais je me suis dit que puisqu'ils étaient fait, autant montrer ce que ça donnait, ne serait-ce que pour montrer cette histoire de fréquence inégalement étalées (peut-être que les plus mathématiciens vont trouver que c'est une évidence mais j'avoue que pour moi c'était loin d'en être une).
Quelques valeurs du peuvent encore envoyer une alerte "nulle", il manque quelques conditions.

J'ai actualisé le lien au début du post précédent, il y a une scène "Analyse" prête à être lancée.

Le code :

Code : Tout sélectionner

using UnityEngine;
using System.Collections.Generic;


public class Analyse : MonoBehaviour {
	
	//les données audios
	private int channel = 0;
	public int numSamples = 512;
	public float dimension = 1;
	public float amplitudeS = 1;
	public float amplitudeV = 1;
	
	/**public enum FFTtype {
		Triangle,
		Rectangular,
		Hanning,
		Hamming,
		BlackmanHarris,
		Blackman,
	}
	
	private delegate float FFTDelegate (float[] spectrum);
	private static FFTDelegate[] FFTDelegates = {
		Triangle,
		Rectangular,
		Hanning,
		Hamming,
		BlackmanHarris,
		Blackman,
	};
	
	public FFTtype ffttypes;/**/
	
	float[] volume;
	float[] spectrum;
	
	
	
	//tout le spectre et tout le volume
	List<float> spectrum0;
	List<float> spectrum1;
	
	List<float> spectrumLog0;
	List<float> spectrumLog1;
	
	List<float> volume0;
	List<float> volume1;
	
	private int numL2;
	private int numL4;
	private int numL8;
	private int numL16;
	
	//séparation en 2 parties Low / High
	List<float> spLow0;
	List<float> spLow1;
	List<float> volL0;
	List<float> volL1;
	
	List<float> spHigh0;
	List<float> spHigh1;
	List<float> volH0;
	List<float> volH1;
	
	//en 4 parties LowLow / LowHigh / HighLow / HighHigh
	List<float> spLL0;
	List<float>	spLL1;
	List<float> volLL0;
	List<float> volLL1;
	
	List<float> spLH0;
	List<float> spLH1;
	List<float> volLH0;
	List<float> volLH1;
	
	List<float> spHL0;
	List<float> spHL1;
	List<float> volHL0;
	List<float> volHL1;
	
	List<float> spHH0;
	List<float> spHH1;
	List<float> volHH0;
	List<float> volHH1;
	
	//en 8 et 16 pour les plus basses
	
	List<float> sbassLL0;
	List<float> sbassLL1;
	List<float> vbassLL0;
	List<float> vbassLL1;
	
	List<float> sbassLH0;
	List<float> sbassLH1;
	List<float> vbassLH0;
	List<float> vbassLH1;
	
	List<float> sbassHL0;
	List<float> sbassHL1;
	List<float> vbassHL0;
	List<float> vbassHL1;
	
	List<float> sbassHH0;
	List<float> sbassHH1;
	List<float> vbassHH0;
	List<float> vbassHH1;
	
	List<float> smedL0;
	List<float> smedL1;
	List<float> vmedL0;
	List<float> vmedL1;
	
	List<float> smedH0;
	List<float> smedH1;
	List<float> vmedH0;
	List<float> vmedH1;
	
	
	
	
	//des barres pour le volume
	
	private GameObject barreVol;
	
	

void Start () {
		
	//ouverture des tableaux audios
	volume = new float[numSamples];
	spectrum = new float[numSamples];
		
	numL2 = (numSamples/2) ;
	numL4 = (numSamples/4) ;
	numL8 = (numSamples/8) ;
	numL16 = (numSamples/16) ;
		
	//tout le spectre et tout le volume
	spectrum0 = new List<float>();
	spectrum1 = new List<float>();
		
	spectrumLog0 = new List<float>();
	spectrumLog1 = new List<float>();
		
	volume0 = new List<float>();
	volume1 = new List<float>();
		
	//les partitions du spectre	
	//2
	spLow0 = new List<float>();
	spLow1 = new List<float>();	
	volL0 = new List<float>();
	volL1 = new List<float>();
		
	spHigh0 = new List<float>();
	spHigh1 = new List<float>();	
	volH0 = new List<float>();
	volH1 = new List<float>();
		
	//4
	
	spLL0 = new List<float>();
	spLL1 = new List<float>();	
	volLL0 = new List<float>();
	volLL1 = new List<float>();
		
	spLH0 = new List<float>();
	spLH1 = new List<float>();
	volLH0 = new List<float>();
	volLH1 = new List<float>();
		
	spHL0 = new List<float>();
	spHL1 = new List<float>();
	volHL0 = new List<float>();
	volHL1 = new List<float>();
		
	spHH0 = new List<float>();
	spHH1 = new List<float>();
	volHH0 = new List<float>();
	volHH1 = new List<float>();
		
	//8 - 16
		
	sbassLL0 = new List<float>();
	sbassLL1 = new List<float>();
	vbassLL0 = new List<float>();	
	vbassLL1 = new List<float>();
		
	sbassLH0 = new List<float>();
	sbassLH1 = new List<float>();
	vbassLH0 = new List<float>();	
	vbassLH1 = new List<float>();
		
	sbassHL0 = new List<float>();
	sbassHL1 = new List<float>();
	vbassHL0 = new List<float>();	
	vbassHL1 = new List<float>();	
		
	sbassHH0 = new List<float>();
	sbassHH1 = new List<float>();
	vbassHH0 = new List<float>();	
	vbassHH1 = new List<float>();	
		
	smedL0 = new List<float>();
	smedL1 = new List<float>();
	vmedL0 = new List<float>();
	vmedL1 = new List<float>();
		
	smedH0 = new List<float>();
	smedH1 = new List<float>();
	vmedH0 = new List<float>();
	vmedH1 = new List<float>();
		
	//le cube de volume général	
	barreVol = GameObject.CreatePrimitive (PrimitiveType.Cube);
	barreVol.transform.position = new Vector3 (0, 0, 0);
	}
	
	
/**private static float[] Triangle (float[] spectrum) {
		
		return audio.GetSpectrumData (spectrum, channel, FFTWindow.Triangle);
	}/**/
	
	
	
	
void Update () {
		
		
		//FFTDelegate ftt = FFTDelegates [(int)ffttypes];
		
		
		audio.GetOutputData (volume, channel);
		audio.GetSpectrumData(spectrum,  channel, FFTWindow.Blackman);
	
		//spectre et volume totaux
		
		for (var i = 1 ; i < numSamples ; i++)
		{
			/**if 	(float.IsInfinity (spectrum[i]) ||
				 float.IsInfinity (spectrum [i - 1]) ||
				 float.IsNaN (spectrum[i]) ||
				 float.IsNaN (spectrum [i-1])) {
				
			}else{/**/
				
			spectrum0.Add (spectrum[i - 1]);
			spectrum1.Add (spectrum[i]);
		
			spectrumLog0.Add (Mathf.Log (spectrum[i -1]));
			spectrumLog1.Add (Mathf.Log (spectrum[i]));
			
			volume0.Add (volume[i - 1]);
			volume1.Add (volume[i]);
			//}
		}
		
		Partition();
		SpectreBasic ();
		CubeV ();
		
	}
	
	
	
void SpectreBasic () {
	

	for (var i = 2 ; i < numSamples - 1; i++) 
	{
			//une repère simple
			
			Debug.DrawLine (new Vector3 (0, 0, 0),
						new Vector3 (200, 0, 0), Color.black);
			
			Debug.DrawLine (new Vector3 (0, -200, 0),
						new Vector3 (0, 200, 0), Color.black);
			
			Debug.DrawLine (new Vector3 (0, 0, -200),
						new Vector3 (0, 0, 200), Color.black);
			
			
			
			
			/**tracé "normal" - bruit important
            
            Debug.DrawLine (new Vector3 (i - 1 , spectrumLog0[i] , -200),
				
                        new Vector3 (i , spectrumLog1[i], -200), Color.cyan);
			
			//tracé atténué - quasi invisible (mais peut-être mieux pour détecter un seul pic ?)
            Debug.DrawLine (new Vector3 (Mathf.Log (i), spectrum0[i], -180),
				
                        new Vector3 (Mathf.Log (i + 1), spectrum1[i], -180), Color.green);/**/
			
			//tracé par pics - réduction du bruit
            Debug.DrawLine (new Vector3 (Mathf.Log (i) * dimension, (spectrumLog0[i] * amplitudeS) + 300, 100),
				
                        new Vector3 (Mathf.Log (i + 1) * dimension, (spectrumLog1[i] * amplitudeS) + 300, 100) , Color.yellow);
        
		
		}
		
	}
	
void CubeV () {
		
	for (var i = 10 ; i < numSamples - 1  ; i++) 
	{	
		barreVol.transform.position = new Vector3( 0 , 0 , 0 );
		barreVol.transform.localScale = Vector3.Lerp (new Vector3 (volume0[i] * 10 + amplitudeV + 5, volume0[i] * 10 + amplitudeV + 5, volume0[i] * 10 + amplitudeV + 5), 
													new Vector3(volume1[i] * 10 + amplitudeV + 5, volume1[i] * 10 + amplitudeV + 5, volume1[i] * 10 + amplitudeV + 5), 0.0001f * Time.deltaTime );	
	}
			
	}
		
	
void Partition () {
		
		
	if (spectrumLog0.Count > 0 && spectrumLog1.Count > 0 && volume0.Count > 0 && volume1.Count > 0)
	{	
			
		//en 2 parties	
			
		for (var i = 1 ; i < numL2 - 1 ; i++)	
		{	
		
					
			spLow0.Add (spectrumLog0[i]);
			spLow1.Add (spectrumLog1[i]);
			volL0.Add (volume0[i]);
			volL1.Add (volume1[i]);
			
			spHigh0.Add (spectrumLog0[(numL2 - 1) + i]);
			spHigh1.Add (spectrumLog1[(numL2 - 1) + i]);
			volH0.Add (volume0[(numL2 - 1) + i]);
			volH1.Add (volume1[(numL2 - 1) + i]);
		}
		
		
		Spectre2 ();
		
		
		
		//en 4 parties
		
		for (var i = 1 ; i < numL4 - 1; i ++)
		{
		
					
			spLL0.Add (spectrumLog0[i]);
			spLL1.Add (spectrumLog1[i]);
			volLL0.Add (volume0[i]);
			volLL1.Add (volume1[i]);
			
			spLH0.Add (spectrumLog0[numL4 + i]);
			spLH1.Add (spectrumLog1[numL4 + i]);
			volLH0.Add (volume0[numL4 + i]);
			volLH1.Add (volume0[numL4 + i]);
			
			spHL0.Add (spectrumLog0[(numL4 * 2) + i]);
			spHL1.Add (spectrumLog1[(numL4 * 2) + i]);
			volHL0.Add (volume0[(numL4 * 2) + i]);
			volHL1.Add (volume1[(numL4 * 2) + i]);
			
			spHH0.Add (spectrumLog0[((numL4 - 1) * 3) + i]);
			spHH1.Add (spectrumLog1[((numL4 - 1) * 3) + i]);
			volHH0.Add (volume0[((numL4 - 1) * 3) + i]);
			volHH0.Add (volume0[((numL4 - 1) * 3) + i]);		
		}
		
		Spectre4 ();
		
		
		
		//8 et 15
		
		for (var i = 1 ; i < numL16; i++)
		{
		
					
			sbassLL0.Add (spectrumLog0[i]);
			sbassLL1.Add (spectrumLog1[i]);
			vbassLL0.Add (volume0[i]);
			vbassLL1.Add (volume1[i]);
			
			sbassLH0.Add (spectrumLog0[numL8 + i]);
			sbassLH1.Add (spectrumLog1[numL8 + i]);
			vbassLH0.Add (volume0[numL8 + i]);
			vbassLH1.Add (volume1[numL8 + i]);
			
			sbassHL0.Add (spectrumLog0[(numL16 * 3) + i]);
			sbassHL1.Add (spectrumLog1[(numL16 * 3) + i]);
			vbassHL0.Add (volume0[(numL16 * 3) + i]);
			vbassHL1.Add (volume1[(numL16 * 3) + i]);
			
			sbassHH0.Add (spectrumLog0[numL4 + i]);
			sbassHH1.Add (spectrumLog1[numL4 + i]);
			vbassHH0.Add (volume0[numL4 + i]);
			vbassHH1.Add (volume1[numL4 + i]);
		}
		
		for (var i = 1 ; i < numL8 - 1 ; i++)
		{
		
					
			smedL0.Add (spectrumLog0[(numL8 * 3) + i]);
			smedL1.Add (spectrumLog1[(numL8 * 3) + i]);
			vmedL0.Add (volume0 [(numL8 * 3) + i]);
			vmedL1.Add (volume1 [(numL8 * 3) + i]);
			
			smedH0.Add (spectrumLog0[numL2 + i]);
			smedH1.Add (spectrumLog1[numL2 + i]);
			vmedH0.Add (volume0[numL2 + i]);
			vmedH1.Add (volume1[numL2 + i]);
		}
		}
		
		
		
		Spectre2816 ();
	}
	
	
	
void Spectre2 () {
		
		
			for (var i = 1 ; i < numL2 - 2; i++) 
			{
            //Low
            Debug.DrawLine (new Vector3 (i, spLow0[i], -200),
				
                        new Vector3 (i + 1, spLow1[i], -200), Color.red);
			
			 //Low /Log
            Debug.DrawLine (new Vector3 (Mathf.Log (i) * dimension, (spLow0[i] * amplitudeS) + 250 , 80),
				
                        new Vector3 (Mathf.Log (i + 1) * dimension, (spLow1[i] * amplitudeS) + 250 , 80), Color.red);
			
			
			//High
			 Debug.DrawLine (new Vector3 (i, spHigh0[i], -160),
				
                        new Vector3 (i + 1, spHigh1[i], -160), Color.blue);
			
			
			//High /Log
			 Debug.DrawLine (new Vector3 (Mathf.Log (i) * dimension, (spHigh0[i] * amplitudeS) + 250 , 150),
				
                        new Vector3 (Mathf.Log (i + 1) * dimension, (spHigh1[i] * amplitudeS) + 250 , 150), Color.blue);

			}
	
	}

	
	
void Spectre4 () {
		
		
		for (var i = 1 ; i < numL4 - 2; i++) 
		{
			//LowLow
			Debug.DrawLine (new Vector3 (i, spLL0[i], -30),
				
                        new Vector3 (i + 1, spLL1[i], -30), Color.red);
			
			//LowLow /Log
			 Debug.DrawLine (new Vector3 (Mathf.Log (i) * dimension, (spLL0[i] * amplitudeS) + 160 , 40),
				
                        new Vector3 (Mathf.Log (i + 1) * dimension, (spLL1[i] * amplitudeS) + 160 , 40), Color.red);
			
			
			//LowHigh
			 Debug.DrawLine (new Vector3 (i, spLH0[i], -40),
				
                        new Vector3 (i + 1, spLH1[i], -40), Color.magenta);
			
			//LowLow /Log
			 Debug.DrawLine (new Vector3 (Mathf.Log (i) * dimension, (spLH0[i] * amplitudeS) + 160 , 100),
				
                        new Vector3 (Mathf.Log (i + 1) * dimension, (spLH1[i] * amplitudeS) + 160 , 100), Color.magenta);
			
			
			//HighLow
			Debug.DrawLine (new Vector3 (i, spHL0[i], -50),
				
                        new Vector3 (i + 1, spHL1[i], -50), Color.cyan);
			
			//HighLow /Log
			 Debug.DrawLine (new Vector3 (Mathf.Log (i) * dimension, (spHL0[i] * amplitudeS) + 160 , 150),
				
                        new Vector3 (Mathf.Log (i + 1) * dimension, (spHL1[i] * amplitudeS) + 160 , 150), Color.cyan);
			
			//HighHigh
			Debug.DrawLine (new Vector3 (i, spHH0[i], -60),
				
                        new Vector3 (i + 1, spHH1[i], -60), Color.blue);
			
			//HighLow /Log
			 Debug.DrawLine (new Vector3 (Mathf.Log (i) * dimension, (spHL0[i] * amplitudeS) + 160 , 200),
				
                        new Vector3 (Mathf.Log (i + 1) * dimension, (spHL1[i] * amplitudeS) + 160 , 200), Color.blue);
		}	
	}
	
	
void Spectre2816 () {
		
	
	
			
		for (var i = 1 ; i < numL8 - 2 ; i++) 
		{	
		//medLow /Log
			 Debug.DrawLine (new Vector3 (Mathf.Log (i) * dimension, (smedL0[i] * amplitudeS) + 50 , 120),
				
                        new Vector3 (Mathf.Log (i + 1) * dimension, (smedL1[i] * amplitudeS) + 50 , 120), Color.white);
			
		//medHigh /Log
			 Debug.DrawLine (new Vector3 (Mathf.Log (i) * dimension, (smedH0[i] * amplitudeS) + 50 , 140),
				
                        new Vector3 (Mathf.Log (i + 1) * dimension, (smedH1[i] * amplitudeS) + 50 , 140), Color.cyan);	
		}
		
		
		for (var i = 1 ; i < numL16 - 2; i++)
		{
		
				
		//bassLowLow /Log
			 Debug.DrawLine (new Vector3 (Mathf.Log (i) * dimension, (sbassLL0[i] * amplitudeS) + 50 , 0),
				
                        new Vector3 (Mathf.Log (i + 1) * dimension, (sbassLL1[i] * amplitudeS) + 50 , 0), Color.red);
			
		
		//bassLowHigh /Log
			 Debug.DrawLine (new Vector3 (Mathf.Log (i) * dimension, (sbassLH0[i] * amplitudeS) + 50 , 40),
				
                        new Vector3 (Mathf.Log (i + 1) * dimension, (sbassLH1[i] * amplitudeS) + 50 , 40), Color.magenta);
			
		//bassHighLow /Log
			 Debug.DrawLine (new Vector3 (Mathf.Log (i) * dimension, (sbassHL0[i] * amplitudeS) + 50 , 60),
				
                        new Vector3 (Mathf.Log (i + 1) * dimension, (sbassHL1[i] * amplitudeS) + 50 , 60), Color.green);
			
		//bassHighHigh /Log
			 Debug.DrawLine (new Vector3 (Mathf.Log (i) * dimension, (sbassHH0[i] * amplitudeS) + 50 , 80),
				
                        new Vector3 (Mathf.Log (i + 1) * dimension, (sbassHH1[i] * amplitudeS) + 50 , 80), Color.yellow);
			
		}
			
		for (var i = 1 ; i < numL2 - 2; i++)
		{
		
				
			//La même que High /Log ; complète les autres
			 Debug.DrawLine (new Vector3 (Mathf.Log (i) * dimension, (spHigh0[i] * amplitudeS) + 50 , 180),
				
                        new Vector3 (Mathf.Log (i + 1) * dimension, (spHigh1[i] * amplitudeS) + 50 , 180), Color.blue);
			
		}
	
	if (spectrum0.Count >= numSamples + numL16)
		{	
		Trash ();
		}
	}
	
void Trash () {
		
			spectrum0.Clear ();
			spectrum1.Clear ();
			spectrumLog0.Clear ();
			spectrumLog1.Clear ();	
			volume0.Clear ();
			volume1.Clear ();
	
			spLow0.Clear ();
			spLow1.Clear ();
			volL0.Clear ();
			volL1.Clear ();
			
			spHigh0.Clear ();
			spHigh1.Clear ();
			volH0.Clear ();
			volH1.Clear ();

			spLL0.Clear();
			spLL1.Clear();
			spLH0.Clear();
			spLH1.Clear();
			spHL0.Clear();
			spHL1.Clear();
			spHH0.Clear();
			spHH1.Clear();
			
			volLL0.Clear ();
			volLL1.Clear ();
			volLH0.Clear ();
			volLH1.Clear ();
			volHL0.Clear ();
			volHL1.Clear ();
			volHH0.Clear ();
			volHH1.Clear ();	

			smedL0.Clear();
			smedL1.Clear();
			vmedL0.Clear();
			vmedL1.Clear();
			
			smedH0.Clear();
			smedH1.Clear();
			vmedH0.Clear();
			vmedH1.Clear();
	
			sbassLL0.Clear();
			sbassLL1.Clear();
			vbassLL0.Clear();
			vbassLL1.Clear();
			
			sbassLH0.Clear();
			sbassLH1.Clear();
			vbassLH0.Clear();
			vbassLH1.Clear();
			
			sbassHL0.Clear();
			sbassHL1.Clear();
			vbassHL0.Clear();
			vbassHL1.Clear();
			
			sbassHH0.Clear();
			sbassHH1.Clear();
			vbassHH0.Clear();
			vbassHH1.Clear();

	}
	
}

[Rant]

Suite ! Un script "d'analyse" un peu plus propre, avec les valeurs accessibles en mode jeu via les chiffres du haut de clavier

1-total
2-high, medium, bass (screen)
3-subdivision medium et bass

Ce qui a changé :
- Plus aucune valeur nulle/infinie (sans les supprimer)
- la partition se fait par AddRange/GetRange au lieu de .Add partout (si j'ai bien compris ça permet de faire une copie des objets de la liste originelle plutot que d'en créer de nouveaux).
-le volume est compris entre 1 et 3
-la fréquence est relative à la plage observée = de 10 à 40
-dans le code la récupération des données/ la partition/ l'analyse de chaque plage / le GUI pour chaque plage/ le dessin du spectre / sont des fonctions séparées (plus facilement récupérable-utilisable-compréhensible j'espère).

Pour chaque plage étudiée (total, High, Medium, Bass, et leurs subdivisions) : 3 boléenne dont une seule peut-être active : UP/DOWN/STABLE

Attention les *Av ne sont pas de vraies moyennes mais :
-volAv = moyenne volume + 1 (compris entre 1 et 2 donc)
-spectreAv = moyenne "fréquence" (10 à 40) * volAv (donc peut aller théoriquement de 10 à 80)

Les trucs qui ont pas marché / à améliorer :
-Le coté "analyse temps réel" se fait par un Clear() des List une fois qu'elles atteignent une valeur max. J'ai bien vu dans la doc des histoires de "capacity" et TrimExcess, et j'ai cherché pas mal de temps sans réussir à mettre ça en place. C'est peut-être mieux pour les performances, mais bon, on peut déjà passer 256 - 512 - 1024 samples sans aucun soucis, je me suis dit que c'était suffisant pour commencer, mais si quelqu'un pouvait expliquer / envoyer un lien avec un petit exemple (je dis pas que les dinosaures sont pas clairs, c'est juste que là...^^)

-les boléennes sont déterminées par les valeurs max et passent très rapidement d'un état à l'autre, peut-être qu'en les calant sur la moyenne, ou une valeur intermédiaire "smoothée" le résultat serait plus significatif, ou via un "yield" avant le prochain changement d'état. Mais comme pour le TrimExcess() j'ai pas encore bien saisi son fonctionnement.

-il manque peut-être une boléenne pour dire quelle est la plage de fréquence dominante.

Il y a une scène prête à être lancée (lien vers la dropbox mis à jour) , avec un son qui balaye les fréquences dans un son puis dans l'autre, et en augmentant et baissant le volume.
(attention les oreilles)



Le script :

Code : Tout sélectionner

using UnityEngine;
using System.Collections.Generic;

public class AnalyseSC : MonoBehaviour { 
	
	//les données audios
	private int channel = 0;
	public int numSamples = 512;
	public float dimension = 1;
	public float amplitudeS = 1;
	public float amplitudeV = 1;
	public float delayAnalyse = 120.0f;
	
	float[] volume;
	float[] spectrum;
	
	//tout le spectre et tout le volume
	List<float> splog0;
	List<float> splog1;
	
	List<float> vol0;
	List<float> vol1;
	
	private int numL2;
	private int numL4;
	private int numL8;
	private int numL16;
	
	//partition spectre et volume : d'abord en 3 (Bass , Medium, High)
	List<float> spB0;
	List<float> spB1;
	List<float> volB0;
	List<float> volB1;
	
	List<float> spM0;
	List<float> spM1;
	List<float> volM0;
	List<float> volM1;
	
	List<float> spH0;
	List<float> spH1;
	List<float> volH0;
	List<float> volH1;
	
	//puis les Basses en 4 (LowLow, LowHigh, HighLow, HighHigh) , et les Medium en 2 (Low, High)
	List<float> spBLL0;
	List<float> spBLL1;
	List<float> volBLL0;
	List<float> volBLL1;
	
	List<float> spBLH0;
	List<float> spBLH1;
	List<float> volBLH0;
	List<float> volBLH1;
	
	List<float> spBHL0;
	List<float> spBHL1;
	List<float> volBHL0;
	List<float> volBHL1;
	
	List<float> spBHH0;
	List<float> spBHH1;
	List<float> volBHH0;
	List<float> volBHH1;
	
	List<float> spML0;
	List<float> spML1;
	List<float> volML0;
	List<float> volML1;
	
	List<float> spMH0;
	List<float> spMH1;
	List<float> volMH0;
	List<float> volMH1;
	
	private bool trashok = false;


	void Start () {
		
	//ouverture des tableaux audios
	volume = new float[numSamples];
	spectrum = new float[numSamples];
		
	
		
	//tout le spectre et tout le volume
	splog0 = new List<float>();
	splog1 = new List<float>();
	vol0 = new List<float>();
	vol1 = new List<float>();
		
	//les partitions
	spB0 = new List<float>();
	spB1 = new List<float>();
	volB0 = new List<float>();
	volB1 = new List<float>();
	
	spM0 = new List<float>();
	spM1 = new List<float>();
	volM0 = new List<float>();
	volM1 = new List<float>();
	
	spH0 = new List<float>();
	spH1 = new List<float>();
	volH0 = new List<float>();
	volH1 = new List<float>();
	
	spBLL0 = new List<float>();
	spBLL1 = new List<float>();
	volBLL0 = new List<float>();
	volBLL1 = new List<float>();
	
	spBLH0 = new List<float>();
	spBLH1 = new List<float>();
	volBLH0 = new List<float>();
	volBLH1 = new List<float>();
	
	spBHL0 = new List<float>();
	spBHL1 = new List<float>();
	volBHL0 = new List<float>();
	volBHL1 = new List<float>();
	
	spBHH0 = new List<float>();
	spBHH1 = new List<float>();
	volBHH0 = new List<float>();
	volBHH1 = new List<float>();
	
	spML0 = new List<float>();
	spML1 = new List<float>();
	volML0 = new List<float>();
	volML1 = new List<float>();
	
	spMH0 = new List<float>();
	spMH1 = new List<float>();
	volMH0 = new List<float>();
	volMH1 = new List<float>();

		numL2 =  (numSamples/2) - 1;
		numL4 =  (numSamples/4) - 1;
		numL8 =  (numSamples/8) - 1;
		numL16 = (numSamples/16) - 1;
	
		
	}
	
	
	void Update () {
			
	DataAudio ();
	Partition ();
	Spectre ();
	
	InvokeRepeating ("Analyse", 0.1f, delayAnalyse);
		
	
	
		
		
	}
	
void DataAudio () {
		
	audio.GetOutputData(volume, channel);
	audio.GetSpectrumData (spectrum, channel, FFTWindow.BlackmanHarris);
		
		for (int i = 1 ; i < numSamples - 1 ; i++)
		{
		var Splog0 = Mathf.Log10 (spectrum[i - 1]);
		var Splog1 = Mathf.Log10 (spectrum[i]);
			
			
		var vlog0 =  (volume [i - 1]);
		var vlog1 = (volume [i]);
			
			//en cas de problème de valeurs infinie
			
			/**if (float.IsInfinity (Splog0) || float.IsNaN (Splog0) ||
				float.IsInfinity (Splog1) || float.IsNaN (Splog1) ||
				float.IsInfinity (vlog0) || float.IsNaN (vlog0) ||
				float.IsInfinity (vlog1) || float.IsNaN (vlog1) ) {
				
				
			}else{/**/
			
			
				splog0.Add (Splog0);
				splog1.Add (Splog1);
				vol0.Add (vlog0);
				vol1.Add (vlog1);
			
		}	
	}
	
void Partition () {
		
		

		
	if (splog0.Count > 0  &&  splog1.Count > 0 && 
		vol0.Count > 0  &&  vol1.Count > 0)
		
		{
		spH0.AddRange(splog0.GetRange (numL2 - 1, numL2)); //High 2/2
		spH1.AddRange(splog1.GetRange (numL2 - 1, numL2));
		volH0.AddRange(vol0.GetRange (numL2 - 1, numL2));
		volH1.AddRange (vol1.GetRange (numL2 - 1, numL2));
			
		spM0.AddRange (splog0.GetRange (numL4, numL4)); //Medium 2/4
		spM1.AddRange (splog1.GetRange (numL4, numL4));
		volM0.AddRange (vol0.GetRange (numL4, numL4));
		volM1.AddRange (vol1.GetRange (numL4, numL4));
			
		spML0.AddRange (splog0.GetRange (numL4, numL8)); //MediumLow 3/8
		spML1.AddRange (splog1.GetRange (numL4, numL8));
		volML0.AddRange (vol0.GetRange (numL4, numL8));
		volML1.AddRange (vol1.GetRange (numL4, numL8));	
			
		spMH0.AddRange (splog0.GetRange (numL8 * 3, numL8)); //MediumHigh 4/8
		spMH1.AddRange (splog1.GetRange (numL8 * 3, numL8));
		volMH0.AddRange (vol0.GetRange (numL8 * 3, numL8));
		volMH1.AddRange (vol1.GetRange (numL8 * 3, numL8));	
			
		spB0.AddRange (splog0.GetRange (0, numL4)); //Bass 1/4
		spB1.AddRange (splog1.GetRange (0, numL4));
		volB0.AddRange (vol0.GetRange (0, numL4));
		volB1.AddRange (vol1.GetRange (0, numL4));
			
		spBLL0.AddRange (splog0.GetRange (0, numL16)); //BassLowLow 1/16
		spBLL1.AddRange (splog1.GetRange (0, numL16));
		volBLL0.AddRange (vol0.GetRange (0, numL16));
		volBLL1.AddRange (vol1.GetRange (0, numL16));
		
		spBLH0.AddRange (splog0.GetRange (numL16, numL16)); //BassLowHigh 2/16
		spBLH1.AddRange (splog1.GetRange (numL16, numL16));
		volBLH0.AddRange (vol0.GetRange (numL16, numL16));
		volBLH1.AddRange (vol1.GetRange (numL16, numL16));
			
		spBHL0.AddRange (splog0.GetRange (numL8, numL16)); //BassHighLow 3/16
		spBHL1.AddRange (splog1.GetRange (numL8, numL16));
		volBHL0.AddRange (vol0.GetRange (numL8, numL16));
		volBHL1.AddRange (vol1.GetRange (numL8, numL16));
			
		spBHH0.AddRange (splog0.GetRange (numL16 * 3, numL16)); //BassHighHigh 4/16
		spBHH1.AddRange (splog1.GetRange (numL16 * 3, numL16));
		volBHH0.AddRange (vol0.GetRange (numL16 * 3, numL16));
		volBHH1.AddRange (vol1.GetRange (numL16 * 3, numL16));
		}
		

	
	}
	


		
void Analyse () {
		
		
	AnalyseTotal ();
	AnalyseHigh ();
	AnalyseMediumBass ();
	AnalyseMedium2 ();
	AnalyseBass4 ();
		
	
	
	}	
	
	
//variables pour analyser les listes
//Tout		
private float volMax0 ;
private float volMax1 ;
private float volAvMax;
private float volAv;

private float volMin0;
private float volMin1;
private float volAvMin;
	
private bool volUp = false;
private bool volDown = false;
private bool volStable = true;
	
	
private float splogMax1;
private float splogMax0;
private float splogMax;
private float splogMin1;
private float splogMin0;
private float splogMin;
private float splogAv;

	
private bool splogUp = false;
private bool splogDown = false;
private bool splogStable = true;
	


	
	
void AnalyseTotal () {
		
		
		
		if (splog0.Count > 1  &&  splog1.Count > 1 && 
		vol0.Count > 1  &&  vol1.Count > 1)
			
			volMax0 = (Mathf.Max (vol0.ToArray ()) )  ;
			volMax1 = (Mathf.Max (vol1.ToArray ()) ) ;
			splogMax0 = Mathf.Max (splog0.ToArray ());
			splogMax1 = Mathf.Max (splog1.ToArray ());
		
			volMin0 = (Mathf.Min (vol0.ToArray ()) )  ;
			volMin1 = (Mathf.Min (vol1.ToArray ()) ) ;
			splogMin0 = Mathf.Min (splog0.ToArray ());
			splogMin1 = Mathf.Min (splog1.ToArray ());
				
			//La fréquence du pic est égale au numsamples(volume) * numsamples(spectrum)/2 ? Ou pas ici de 1 à 20	
			splogMax = 41 + ( ((splogMax0 + 1 + splogMax1 + 1)  *  Mathf.Log10 (numSamples)));
			splogMin = 41 + ( ((splogMin0 + 1 + splogMin1 + 1) * Mathf.Log10 (numSamples)));
			splogAv = volAv * ((splogMax + splogMin) / 2) ;
		
			//booleene pour augmentation ou baisse fréquence
			if ( splogMax1 > splogMax0 ){ 
				splogUp = true ;
				}else{ 
				splogUp = false ;
				}
				
			if ( splogMin1 < splogMin0) {
				splogDown = true ;
				}else{
				splogDown = false ;
				}
		
			if ( splogUp == true || splogDown == true) {
			splogStable = false;
			}else{ 
			splogStable = true;
			}
		
			// volume entre 1 et 2	
			volAvMax = 2 + (( 1 * (volMax0 + volMax1)  ) / Mathf.Log10 (numSamples)  ) ;
			volAvMin = 2 + (( 1 * (volMin0 + volMin1) ) / Mathf.Log10 (numSamples) ) ;
			volAv = 1 + ((volAvMax - volAvMin) / 2) ;
		
			//booleene pour augmentation ou baisse du volume
			if ( volMax1 > volMax0 ){ 
				volUp = true ;
				}else{ 
				volUp = false ;
				}
				
			if ( volMax1 < volMax0 )  {
				volDown = true ;
				}else{
				volDown = false ;
				}
		
			if ( volUp == true || volDown == true) {
			volStable = false;
			}else{ 
			volStable = true;
			}
	}
	
	
//High
private float volHMax0 ;
private float volHMax1 ;
private float volHAvMax;
private float volHAv;
private float volHMin1;
private float volHMin0;
private float volHAvMin;	
	
private bool volHUp = false;
private bool volHDown = false;
private bool volHStable = true;
	
private float spHMax1;
private float spHMax0;
private float spHMax;
private float spHAv;
private float spHMin1;
private float spHMin0;
private float spHMin;
	
private bool spHUp = false;
private bool spHDown = false;
private bool spHStable = true;	
	
	
void AnalyseHigh () {
		
		//High	
		if (splog0.Count > 1  &&  splog1.Count > 1 && 
		vol0.Count > 1  &&  vol1.Count > 1)
		
			volHMax0 = (Mathf.Max (volH0.ToArray ()) )  ;
			volHMax1 = (Mathf.Max (volH1.ToArray ()) ) ;
			spHMax0 = Mathf.Max (spH0.ToArray ());
			spHMax1 = Mathf.Max (spH1.ToArray ());
		
			volHMin0 = (Mathf.Min (volH0.ToArray ()) )  ;
			volHMin1 = (Mathf.Min (volH1.ToArray ()) ) ;
			spHMin0 = Mathf.Min (spH0.ToArray ());
			spHMin1 = Mathf.Min (spH1.ToArray ());

			//moyennes fréquences de 10 à 40
			
			spHMax = 41 + ( ((spHMax0 + 1 + spHMax1 + 1)  *  Mathf.Log10 (numSamples / 2)));
			spHMin = 41 + ( ((spHMin0 + 1 + spHMin1 + 1)  * Mathf.Log10 (numSamples / 2)));
			spHAv = volHAv * ((spHMax + spHMin) / 2) ;
		
			//booleene pour augmentation ou baisse fréquence
			if ( spHMax1 > spHMax0 ){ 
				spHUp = true ;
				}else{ 
				spHUp = false ;
				}
				
			if ( spHMax1 < spHMax0) {
				spHDown = true ;
				}else{
				spHDown = false ;
				}
		
			if ( spHUp == true || spHDown == true) {
			spHStable = false;
			}else{ 
			spHStable = true;
			}
		
			//moyennes volume de 1 à 3
			volHAvMax = 2 + (( 1 * (volHMax0 + volHMax1)  ) / Mathf.Log10 (numSamples / 2)  ) ;
			volHAvMin = 2 + (( 1 * (volHMin0 + volHMin1) ) / Mathf.Log10 (numSamples / 2) ) ;
			volHAv = 1 + ((volHAvMax-volHAvMin) / 2) ;
		
			//booleene pour augmentation ou baisse du volume
			if ( volHMax1 > volHMax0 ){ 
				volHUp = true ;
				}else{ 
				volHUp = false ;
				}
				
			if ( volHMax1 < volHMax0 )  {
				volHDown = true ;
				}else{
				volHDown = false ;
				}
		
			if ( volHUp == true || volHDown == true) {
			volHStable = false;
			}else{ 
			volHStable = true;
			}
		
		
		
		
	}

//Medium
private float volMMax0 ;
private float volMMax1 ;
private float volMAvMax;
private float volMAv;
private float volMMin1;
private float volMMin0;
private float volMAvMin;	
	
private bool volMUp = false;
private bool volMDown = false;
private bool volMStable = true;
		
private float spMMax1;
private float spMMax0;
private float spMMax;
private float spMAv;
private float spMMin1;
private float spMMin0;
private float spMMin;	
	
private bool spMUp = false;
private bool spMDown = false;
private bool spMStable = true;	
	
//Bass
private float volBMax0 ;
private float volBMax1 ;
private float volBAvMax;
private float volBAv;
private float volBMin1;
private float volBMin0;
private float volBAvMin;	
	
private bool volBUp = false;
private bool volBDown = false;
private bool volBStable = true;
		
private float spBMax1;
private float spBMax0;
private float spBMax;
private float spBAv;
private float spBMin1;
private float spBMin0;
private float spBMin;	
	
private bool spBUp = false;
private bool spBDown = false;
private bool spBStable = true;	

void AnalyseMediumBass () {
		
		
		if (splog0.Count > 1  &&  splog1.Count > 1 && 
		vol0.Count > 1  &&  vol1.Count > 1)
		
		
			volMMax0 = Mathf.Max (volM0.ToArray ());
			volMMax1 = Mathf.Max (volM1.ToArray ());
			volBMax0 = Mathf.Max (volB0.ToArray ());
			volBMax1 = Mathf.Max (volB1.ToArray ());

			volMMin0 = Mathf.Min (volM0.ToArray ());
			volMMin1 = Mathf.Min (volM1.ToArray ());
			volBMin0 = Mathf.Min (volB0.ToArray ());
			volBMin1 = Mathf.Min (volB1.ToArray ());		
					
			spMMax0 = Mathf.Max (spM0.ToArray ());
			spMMax1 = Mathf.Max (spM1.ToArray ());
			spBMax0 = Mathf.Max (spB0.ToArray ());
			spBMax1 = Mathf.Max (spB1.ToArray ());
			
			spMMin0 = Mathf.Min (spM0.ToArray ());
			spMMin1 = Mathf.Min (spM1.ToArray ());
			spBMin0 = Mathf.Min (spB0.ToArray ());
			spBMin1 = Mathf.Min (spB1.ToArray ());
	
			//moyennes fréquences
			spMMax = 41 + ( ((spMMax0 + 1 + spMMax1 + 1)  *  Mathf.Log10 (numSamples / 4)));
			spMMin = 41 + ( ((spMMin0 + 1 + spMMin1 + 1)  * Mathf.Log10 (numSamples / 4)));
			spMAv =  volMAv * ((spMMax + spMMin) / 2) ;
		
			spBMax = 41 + ( ((spBMax0 + 1 + spBMax1 + 1)  *  Mathf.Log10 (numSamples / 4)));
			spBMin = 41 + ( ((spBMin0 + 1 + spBMin1 + 1)  * Mathf.Log10 (numSamples / 4)));
			spBAv = volBAv * ((spBMax + spBMin) / 2) ;

		
			//booleene pour augmentation ou baisse fréquence
			if ( spMMax1 > spMMax0 ){ 
				spMUp = true ;
				}else{ 
				spMUp = false ;
				}
				
			if ( spMMax1 < spMMax0) {
				spMDown = true ;
				}else{
				spMDown = false ;
				}
		
			if ( spMUp == true || spMDown == true) {
			spMStable = false;
			}else{ 
			spMStable = true;
			}
		
			if ( spBMax1 > spBMax0 ){ 
				spBUp = true ;
				}else{ 
				spBUp = false ;
				}
				
			if ( spBMax1 < spBMax0) {
				spBDown = true ;
				}else{
				spBDown = false ;
				}
		
			if ( spBUp == true || spBDown == true) {
			spBStable = false;
			}else{ 
			spBStable = true;
			}
		
			//moyennes volume
			volMAvMax = 2 + (( 1 * (volMMax0 + volMMax1)  ) / Mathf.Log10 (numSamples / 4)  ) ;
			volMAvMin = 2 + (( 1 * (volMMin0 + volMMin1) ) / Mathf.Log10 (numSamples / 4) ) ;
			volMAv = 1 + ((volMAvMax-volMAvMin) / 2) ;
		
			volBAvMax = 2 + (( 1 * (volBMax0 + volBMax1)  ) / Mathf.Log10 (numSamples / 4)  ) ;
			volBAvMin = 2 + (( 1 * (volBMin0 + volBMin1) ) / Mathf.Log10 (numSamples / 4) ) ;
			volBAv = 1 + ((volBAvMax-volBAvMin) / 2) ;
	
			//booleene pour augmentation ou baisse du volume
			if ( volMMax1 > volMMax0 ){ 
				volMUp = true ;
				}else{ 
				volMUp = false ;
				}
				
			if ( volMMax1 < volMMax0 )  {
				volMDown = true ;
				}else{
				volMDown = false ;
				}
		
			if ( volMUp == true || volMDown == true) {
			volMStable = false;
			}else{ 
			volMStable = true;
			}
		
			if ( volBMax1 > volBMax0 ){ 
				volBUp = true ;
				}else{ 
				volBUp = false ;
				}
				
			if ( volBMax1 < volBMax0 )  {
				volBDown = true ;
				}else{
				volBDown = false ;
				}
		
			if ( volBUp == true || volBDown == true) {
			volBStable = false;
			}else{ 
			volBStable = true;
			}
		
	}
	
//MediumLow
private float volMLMax0 ;
private float volMLMax1 ;
private float volMLAvMax;
private float volMLAv;
private float volMLMin1;
private float volMLMin0;
private float volMLAvMin;	
	
private bool volMLUp = false;
private bool volMLDown = false;
private bool volMLStable = true;
	
private float spMLMax1;
private float spMLMax0;
private float spMLMax;
private float spMLAv;
private float spMLMin1;
private float spMLMin0;
private float spMLMin;	
	
private bool spMLUp = false;
private bool spMLDown = false;
private bool spMLStable = true;	
	
//MediumHigh
private float volMHMax0;
private float volMHMax1;	
private float volMHAvMax;
private float volMHAv;
private float volMHMin1;
private float volMHMin0;
private float volMHAvMin;	
	
private bool volMHUp = false;
private bool volMHDown = false;
private bool volMHStable = true;
		
private float spMHMax1;
private float spMHMax0;
private float spMHMax;
private float spMHAv;
private float spMHMin1;
private float spMHMin0;
private float spMHMin;	
	
private bool spMHUp = false;
private bool spMHDown = false;
private bool spMHStable = true;		
	
	
void AnalyseMedium2 () {
		
	if (splog0.Count > 1  &&  splog1.Count > 1 && 
		vol0.Count > 1  &&  vol1.Count > 1)

			volMLMax0 = Mathf.Max (volML0.ToArray ())  ;
			volMLMax1 = Mathf.Max (volML1.ToArray ()) ;
			volMHMax0 = Mathf.Max (volMH0.ToArray ())  ;
			volMHMax1 = Mathf.Max (volMH1.ToArray ());
		
			volMLMin0 = Mathf.Min (volML0.ToArray ())  ;
			volMLMin1 = Mathf.Min (volML1.ToArray ()) ;
			volMHMin0 = Mathf.Min (volMH0.ToArray ())  ;
			volMHMin1 = Mathf.Min (volMH1.ToArray ());

			spMLMax0 = Mathf.Max (spML0.ToArray ());
			spMLMax1 = Mathf.Max (spML1.ToArray ());
			spMHMax0 = Mathf.Max (spMH0.ToArray ());
			spMHMax1 = Mathf.Max (spMH1.ToArray ());
		
			spMLMin0 = Mathf.Min (spML0.ToArray ());
			spMLMin1 = Mathf.Min (spML1.ToArray ());
			spMHMin0 = Mathf.Min (spMH0.ToArray ());
			spMHMin1 = Mathf.Min (spMH1.ToArray ());	


			//moyennes fréquences
			spMLMax = 41 + ( ((spMLMax0 + 1 + spMLMax1 + 1)  *  Mathf.Log10 (numSamples / 8)));
			spMLMin = 41 + ( ((spMLMin0 + 1 + spMLMin1 + 1)  * Mathf.Log10 (numSamples / 8)));
			spMLAv =  volMLAv * ((spMLMax + spMLMin) / 2) ;
		
			spMHMax = 41 + ( ((spMHMax0 + 1 + spMHMax1 + 1)  *  Mathf.Log10 (numSamples / 8)));
			spMHMin = 41 + ( ((spMHMin0 + 1 + spMHMin1 + 1)  * Mathf.Log10 (numSamples / 8)));
			spMHAv =  volMHAv * ((spMHMax + spMHMin) / 2) ;

		
			//booleene pour augmentation ou baisse fréquence
			if ( spMLMax1 > spMLMax0 ){ 
				spMLUp = true ;
				}else{ 
				spMLUp = false ;
				}
				
			if ( spMLMax1 < spMLMax0) {
				spMLDown = true ;
				}else{
				spMLDown = false ;
				}
		
			if ( spMLUp == true || spMLDown == true) {
			spMLStable = false;
			}else{ 
			spMLStable = true;
			}
		
			if ( spMHMax1 > spMHMax0 ){ 
				spMHUp = true ;
				}else{ 
				spMHUp = false ;
				}
				
			if ( spMHMax1 < spMHMax0) {
				spMHDown = true ;
				}else{
				spMHDown = false ;
				}
		
			if ( spMHUp == true || spMHDown == true) {
			spMHStable = false;
			}else{ 
			spMHStable = true;
			}
		
			//moyennes volume
			volMLAvMax = 2 + (( 1 * (volMLMax0 + volMLMax1)  ) / Mathf.Log10 (numSamples / 8)  ) ;
			volMLAvMin = 2 + (( 1 * (volMLMin0 + volMLMin1) ) / Mathf.Log10 (numSamples / 8) ) ;
			volMLAv = 1 + ((volMLAvMax-volMLAvMin) / 2) ;

			volMHAvMax = 2 + (( 1 * (volMHMax0 + volMHMax1)  ) / Mathf.Log10 (numSamples / 8)  ) ;
			volMHAvMin = 2 + (( 1 * (volMHMin0 + volMHMin1) ) / Mathf.Log10 (numSamples / 8) ) ;
			volMHAv = 1 + ((volMHAvMax-volMHAvMin) / 2) ;
		
			//booleene pour augmentation ou baisse du volume
			if ( volMLMax1 > volMLMax0 ){ 
				volMLUp = true ;
				}else{ 
				volMLUp = false ;
				}
				
			if ( volMLMax1 < volMLMax0 )  {
				volMLDown = true ;
				}else{
				volMLDown = false ;
				}
		
			if ( volMLUp == true || volMLDown == true) {
			volMLStable = false;
			}else{ 
			volMLStable = true;
			}
		
			if ( volMHMax1 > volMHMax0 ){ 
				volMHUp = true ;
				}else{ 
				volMHUp = false ;
				}
				
			if ( volMHMax1 < volMHMax0 )  {
				volMHDown = true ;
				}else{
				volMHDown = false ;
				}
		
			if ( volMHUp == true || volMHDown == true) {
			volMHStable = false;
			}else{ 
			volMHStable = true;
			}	
		
	}
	
//BassLowLow
private float volBLLMax0 ;
private float volBLLMax1 ;
private float volBLLAvMax;
private float volBLLAv;
private float volBLLMin1;
private float volBLLMin0;
private float volBLLAvMin;	
	
private bool volBLLUp = false;
private bool volBLLDown = false;
private bool volBLLStable = true;
	
private float spBLLMax1;
private float spBLLMax0;
private float spBLLMax;
private float spBLLAv;
private float spBLLMin1;
private float spBLLMin0;
private float spBLLMin;	
	
private bool spBLLUp = false;
private bool spBLLDown = false;
private bool spBLLStable = true;
	
//BassLowHigh
private float volBLHMax0 ;
private float volBLHMax1 ;
private float volBLHAvMax;
private float volBLHAv;
private float volBLHMin1;
private float volBLHMin0;
private float volBLHAvMin;	
	
private bool volBLHUp = false;
private bool volBLHDown = false;
private bool volBLHStable = true;
	
private float spBLHMax1;
private float spBLHMax0;
private float spBLHMax;
private float spBLHAv;
private float spBLHMin1;
private float spBLHMin0;
private float spBLHMin;	
	
private bool spBLHUp = false;
private bool spBLHDown = false;
private bool spBLHStable = true;
	
//BassHighLow
private float volBHLMax0 ;
private float volBHLMax1 ;
private float volBHLAvMax;
private float volBHLAv;
private float volBHLMin1;
private float volBHLMin0;
private float volBHLAvMin;	
	
private bool volBHLUp = false;
private bool volBHLDown = false;
private bool volBHLStable = true;
	
private float spBHLMax1;
private float spBHLMax0;
private float spBHLMax;
private float spBHLAv;
private float spBHLMin1;
private float spBHLMin0;
private float spBHLMin;	
	
private bool spBHLUp = false;
private bool spBHLDown = false;
private bool spBHLStable = true;
	
//BassHighHigh
private float volBHHMax0 ;
private float volBHHMax1 ;
private float volBHHAvMax;
private float volBHHAv;
private float volBHHMin1;
private float volBHHMin0;
private float volBHHAvMin;	
	
private bool volBHHUp = false;
private bool volBHHDown = false;
private bool volBHHStable = true;
	
private float spBHHMax1;
private float spBHHMax0;
private float spBHHMax;
private float spBHHAv;
private float spBHHMin1;
private float spBHHMin0;
private float spBHHMin;	
	
private bool spBHHUp = false;
private bool spBHHDown = false;
private bool spBHHStable = true;
	
	
void AnalyseBass4 () {
		
		if (splog0.Count > 1  ||  splog1.Count > 1 || 
		vol0.Count > 1  || vol1.Count > 1)

			volBLLMax0 = Mathf.Max (volBLL0.ToArray ());
			volBLLMax1 = Mathf.Max (volBLL1.ToArray ());
			volBLLMin0 = Mathf.Min (volBLL0.ToArray ());
			volBLLMin1 = Mathf.Min (volBLL1.ToArray ());
		
			spBLLMax0 = Mathf.Max (spBLL0.ToArray ());
			spBLLMax1 = Mathf.Max (spBLL1.ToArray ());
			spBLLMin0 = Mathf.Min (spBLL0.ToArray ());
			spBLLMin1 = Mathf.Min (spBLL1.ToArray ());
		
			volBLHMax0 = Mathf.Max (volBLH0.ToArray ());
			volBLHMax1 = Mathf.Max (volBLH1.ToArray ());
			volBLHMin0 = Mathf.Min (volBLH0.ToArray ());
			volBLHMin1 = Mathf.Min (volBLH1.ToArray ());
		
			spBLHMax0 = Mathf.Max (spBLH0.ToArray ());
			spBLHMax1 = Mathf.Max (spBLH1.ToArray ());
			spBLHMin0 = Mathf.Min (spBLH0.ToArray ());
			spBLHMin1 = Mathf.Min (spBLH1.ToArray ());
		
			volBHLMax0 = Mathf.Max (volBHL0.ToArray ());
			volBHLMax1 = Mathf.Max (volBHL1.ToArray ());
			volBHLMin0 = Mathf.Min (volBHL0.ToArray ());
			volBHLMin1 = Mathf.Min (volBHL1.ToArray ());
		
			spBHLMax0 = Mathf.Max (spBHL0.ToArray ());
			spBHLMax1 = Mathf.Max (spBHL1.ToArray ());
			spBHLMin0 = Mathf.Min (spBHL0.ToArray ());
			spBHLMin1 = Mathf.Min (spBHL1.ToArray ());
		
			volBHHMax0 = Mathf.Max (volBHH0.ToArray ());
			volBHHMax1 = Mathf.Max (volBHH1.ToArray ());
			volBHHMin0 = Mathf.Min (volBHH0.ToArray ());
			volBHHMin1 = Mathf.Min (volBHH1.ToArray ());
		
			spBHHMax0 = Mathf.Max (spBHH0.ToArray ());
			spBHHMax1 = Mathf.Max (spBHH1.ToArray ());
			spBHHMin0 = Mathf.Min (spBHH0.ToArray ());
			spBHHMin1 = Mathf.Min (spBHH1.ToArray ());
			

			//moyennes fréquences
			spBLLMax = 41 + ( ((spBLLMax0 + 1 + spBLLMax1 + 1)  *  Mathf.Log10 (numSamples / 16)));
			spBLLMin = 41 + ( ((spBLLMin0 + 1 + spBLLMin1 + 1)  * Mathf.Log10 (numSamples / 16)));
			spBLLAv =  volBLLAv * ((spBLLMax + spBLLMin) / 2) ;
		
			spBLHMax = 41 + ( ((spBLHMax0 + 1 + spBLHMax1 + 1)  *  Mathf.Log10 (numSamples / 16)));
			spBLHMin = 41 + ( ((spBLHMin0 + 1 + spBLHMin1 + 1)  * Mathf.Log10 (numSamples / 16)));
			spBLHAv =  volBLHAv * ((spBLHMax + spBLHMin) / 2) ;
		
			spBHLMax = 41 + ( ((spBHLMax0 + 1 + spBHLMax1 + 1)  *  Mathf.Log10 (numSamples / 16)));
			spBHLMin = 41 + ( ((spBHLMin0 + 1 + spBHLMin1 + 1)  * Mathf.Log10 (numSamples / 16)));
			spBHLAv =  volBHLAv * ((spBHLMax + spBHLMin) / 2) ;
		
			spBHHMax = 41 + ( ((spBHHMax0 + 1 + spBHHMax1 + 1)  *  Mathf.Log10 (numSamples / 16)));
			spBHHMin = 41 + ( ((spBHHMin0 + 1 + spBHHMin1 + 1)  * Mathf.Log10 (numSamples / 16)));
			spBHHAv =  volBHHAv * ((spBHHMax + spBHHMin) / 2) ;
		
			//booleene pour augmentation ou baisse fréquence
			if ( spBLLMax1 > spBLLMax0 ){ 
				spBLLUp = true ;
				}else{ 
				spBLLUp = false ;
				}
				
			if ( spBLLMax1 < spBLLMax0) {
				spBLLDown = true ;
				}else{
				spBLLDown = false ;
				}
		
			if ( spBLLUp == true || spBLLDown == true) {
			spBLLStable = false;
			}else{ 
			spBLLStable = true;
			}
		
			if ( spBLHMax1 > spBLHMax0 ){ 
				spBLHUp = true ;
				}else{ 
				spBLHUp = false ;
				}
				
			if ( spBLHMax1 < spBLHMax0) {
				spBLHDown = true ;
				}else{
				spBLHDown = false ;
				}
		
			if ( spBLHUp == true || spBLHDown == true) {
			spBLHStable = false;
			}else{ 
			spBLHStable = true;
			}
		
			if ( spBHLMax1 > spBHLMax0 ){ 
				spBHLUp = true ;
				}else{ 
				spBHLUp = false ;
				}
				
			if ( spBHLMax1 < spBHLMax0) {
				spBHLDown = true ;
				}else{
				spBHLDown = false ;
				}
		
			if ( spBHLUp == true || spBHLDown == true) {
			spBHLStable = false;
			}else{ 
			spBHLStable = true;
			}
		
			if ( spBHHMax1 > spBHHMax0 ){ 
				spBHHUp = true ;
				}else{ 
				spBHHUp = false ;
				}
				
			if ( spBHHMax1 < spBHHMax0) {
				spBHHDown = true ;
				}else{
				spBHHDown = false ;
				}
		
			if ( spBHHUp == true || spBHHDown == true) {
			spBHHStable = false;
			}else{ 
			spBHHStable = true;
			}
		
			//moyennes volume
			volBLLAvMax = 2 + (( 1 * (volBLLMax0 + volBLLMax1)  ) / Mathf.Log10 (numSamples / 16)  ) ;
			volBLLAvMin = 2 + (( 1 * (volBLLMin0 + volBLLMin1) ) / Mathf.Log10 (numSamples / 16) ) ;
			volBLLAv = 1 + ((volBLLAvMax-volBLLAvMin) / 2) ;

			volBLHAvMax = 2 + (( 1 * (volBLHMax0 + volBLHMax1)  ) / Mathf.Log10 (numSamples / 16)  ) ;
			volBLHAvMin = 2 + (( 1 * (volBLHMin0 + volBLHMin1) ) / Mathf.Log10 (numSamples / 16) ) ;
			volBLHAv = 1 + ((volBLHAvMax-volBLHAvMin) / 2) ;
		
			volBHLAvMax = 2 + (( 1 * (volBHLMax0 + volBHLMax1)  ) / Mathf.Log10 (numSamples / 16)  ) ;
			volBHLAvMin = 2 + (( 1 * (volBHLMin0 + volBHLMin1) ) / Mathf.Log10 (numSamples / 16) ) ;
			volBHLAv = 1 + ((volBHLAvMax-volBHLAvMin) / 2) ;
		
			volBHHAvMax = 2 + (( 1 * (volBHHMax0 + volBHHMax1)  ) / Mathf.Log10 (numSamples / 16)  ) ;
			volBHHAvMin = 2 + (( 1 * (volBHHMin0 + volBHHMin1) ) / Mathf.Log10 (numSamples / 16) ) ;
			volBHHAv = 1 + ((volBHHAvMax-volBHHAvMin) / 2) ;
		
			//booleene pour augmentation ou baisse du volume
			if ( volBLLMax1 > volBLLMax0 ){ 
				volBLLUp = true ;
				}else{ 
				volBLLUp = false ;
				}
				
			if ( volBLLMax1 < volBLLMax0 )  {
				volBLLDown = true ;
				}else{
				volBLLDown = false ;
				}
		
			if ( volBLLUp == true || volBLLDown == true) {
			volBLLStable = false;
			}else{ 
			volBLLStable = true;
			}
		
			if ( volBLHMax1 > volBLHMax0 ){ 
				volBLHUp = true ;
				}else{ 
				volBLHUp = false ;
				}
				
			if ( volBLHMax1 < volBLHMax0 )  {
				volBLHDown = true ;
				}else{
				volBLHDown = false ;
				}
		
			if ( volBLHUp == true || volBLHDown == true) {
			volBLHStable = false;
			}else{ 
			volBLHStable = true;
			}
		
			if ( volBHLMax1 > volBHLMax0 ){ 
				volBHLUp = true ;
				}else{ 
				volBHLUp = false ;
				}
				
			if ( volBHLMax1 < volBHLMax0 )  {
				volBHLDown = true ;
				}else{
				volBHLDown = false ;
				}
		
			if ( volBHLUp == true || volBHLDown == true) {
			volBHLStable = false;
			}else{ 
			volBHLStable = true;
			}
		
			if ( volBHHMax1 > volBHHMax0 ){ 
				volBHHUp = true ;
				}else{ 
				volBHHUp = false ;
				}
				
			if ( volBHHMax1 < volBHHMax0 )  {
				volBHHDown = true ;
				}else{
				volBHHDown = false ;
				}
		
			if ( volBHHUp == true || volBHHDown == true) {
			volBHHStable = false;
			}else{ 
			volBHHStable = true;
			}
			
		
	}
	
	
void Spectre () {
		
		
		//Total
		for (int i = 1 ; i < splog1.Count; i++) 
		{
		var logi0 = Mathf.Log (i - 1);
		var logi1 = Mathf.Log (i);
			
			if (float.IsInfinity (logi0) || float.IsNaN (logi0) ||
				float.IsInfinity (logi1) || float.IsNaN (logi1) ) {
	
			}else{	
					Debug.DrawLine (new Vector3 (logi0 * dimension, (splog0[i] * amplitudeS), 0),
                        new Vector3 (logi1 * dimension, (splog1[i] * amplitudeS), 0) , Color.yellow);
			}
		}
		
		
		//Bass&Medium
		for (int i = 1 ; i < spM1.Count; i++) 
		{
		var logi0 = Mathf.Log (i - 1);
		var logi1 = Mathf.Log (i);
			
			if (float.IsInfinity (logi0) || float.IsNaN (logi0) ||
				float.IsInfinity (logi1) || float.IsNaN (logi1) ) {
	
			}else{
					Debug.DrawLine (new Vector3 (logi0 * dimension, (spB0[i] * amplitudeS), 20),
                        new Vector3 (logi1 * dimension, (spB1[i] * amplitudeS), 20) , Color.red);
	
					Debug.DrawLine (new Vector3 (logi0 * dimension, (spM0[i] * amplitudeS), 120),
                        new Vector3 (logi1 * dimension, (spM1[i] * amplitudeS), 120) , Color.green);
			}
		}
		
		
		//High
		for (int i = 1 ; i < spH1.Count; i++) 
		{
		var logi0 = Mathf.Log (i - 1);
		var logi1 = Mathf.Log (i);
			
			if (float.IsInfinity (logi0) || float.IsNaN (logi0) ||
				float.IsInfinity (logi1) || float.IsNaN (logi1) ) {
	
			}else{	
					Debug.DrawLine (new Vector3 (logi0 * dimension, (spH0[i] * amplitudeS), 180),
                        new Vector3 (logi1 * dimension, (spH1[i] * amplitudeS), 180) , Color.blue);
			}
		}
		
		
		
		//Mediums
		for (int i = 1 ; i < spMH1.Count; i++) 
		{
		var logi0 = Mathf.Log (i - 1);
		var logi1 = Mathf.Log (i);
			
			if (float.IsInfinity (logi0) || float.IsNaN (logi0) ||
				float.IsInfinity (logi1) || float.IsNaN (logi1) ) {
	
			}else{
					Debug.DrawLine (new Vector3 (logi0 * dimension, (spML0[i] * amplitudeS), 140),
                        new Vector3 (logi1 * dimension, (spML1[i] * amplitudeS), 140) , Color.green);
	
					Debug.DrawLine (new Vector3 (logi0 * dimension, (spMH0[i] * amplitudeS), 160),
                        new Vector3 (logi1 * dimension, (spMH1[i] * amplitudeS), 160) , Color.green);
			}
		}
		
			//Bass*4
		for (int i = 1 ; i < spBHH1.Count; i++) 
		{
		var logi0 = Mathf.Log (i - 1);
		var logi1 = Mathf.Log (i);
			
			if (float.IsInfinity (logi0) || float.IsNaN (logi0) ||
				float.IsInfinity (logi1) || float.IsNaN (logi1) ) {
	
			}else{
					Debug.DrawLine (new Vector3 (logi0 * dimension, (spBLL0[i] * amplitudeS), 40),
                        new Vector3 (logi1 * dimension, (spBLL1[i] * amplitudeS), 40) , Color.red);
	
					Debug.DrawLine (new Vector3 (logi0 * dimension, (spBLH0[i] * amplitudeS), 60),
                        new Vector3 (logi1 * dimension, (spBLH1[i] * amplitudeS), 60) , Color.red);
				
					Debug.DrawLine (new Vector3 (logi0 * dimension, (spBHL0[i] * amplitudeS), 80),
                        new Vector3 (logi1 * dimension, (spBHL1[i] * amplitudeS), 80) , Color.red);
				
					Debug.DrawLine (new Vector3 (logi0 * dimension, (spBHH0[i] * amplitudeS), 100),
                        new Vector3 (logi1 * dimension, (spBHH1[i] * amplitudeS), 100) , Color.red);
			}
		}
		
		
		
	}
	


void totalGUI () {
		
	 	
		GUI.contentColor = Color.yellow;
		GUI.Box (new Rect (10, 10, 320, 80),"VOLUME        TOTAL        SPECTRE" );
		
		GUI.Label (new Rect (10, 30, 100, 20),"Min " + volAvMin);	
		GUI.Label (new Rect (10, 50, 100, 20),"Max " + volAvMax);	
		GUI.Label (new Rect (10, 70, 100, 20),"*Av " + volAv);

		if (volUp == true) {
			GUI.Label (new Rect (110, 30, 60, 20),"UP" );
		}else{}
		
		if (volDown == true) {
			GUI.Label (new Rect (110, 50, 60, 20),"DOWN" );
		}else{}

		if (volStable == true) {
			GUI.Label (new Rect (110, 70, 60, 20),"STABLE" );
		}else{}
		
		GUI.Label (new Rect (170, 30, 200, 20),"Min " + splogMin);	
		GUI.Label (new Rect (170, 50, 200, 20),"Max " + splogMax);	
		GUI.Label (new Rect (170, 70, 200, 20),"*Av " + splogAv);
		
		if (splogUp == true) {
			GUI.Label (new Rect (270, 30, 60, 20),"UP" );
		}else{}
		
		if (splogDown == true) {
			GUI.Label (new Rect (270, 50, 60, 20),"DOWN" );
		}else{}

		if (splogStable == true) {
			GUI.Label (new Rect (270, 70, 60, 20),"STABLE" );
		}else{}
		
		
	}
	
void HGUI () {
		//high
		GUI.contentColor = Color.cyan;
		GUI.Box (new Rect (10, 10, 320, 80), "VOLUME        HIGH       SPECTRE" );
		
		GUI.Label (new Rect (10, 30, 100, 20),"Min " + volHAvMin);	
		GUI.Label (new Rect (10, 50, 100, 20),"Max " + volHAvMax);	
		GUI.Label (new Rect (10, 70, 100, 20),"*Av " + volHAv);

		if (volUp == true) {
			GUI.Label (new Rect (110, 30, 60, 20),"UP" );
		}else{}
		
		if (volDown == true) {
			GUI.Label (new Rect (110, 50, 60, 20),"DOWN" );
		}else{}

		if (volStable == true) {
			GUI.Label (new Rect (110, 70, 60, 20),"STABLE" );
		}else{}
		
		GUI.Label (new Rect (170, 30, 100, 20),"Min " + spHMin);	
		GUI.Label (new Rect (170, 50, 100, 20),"Max " + spHMax);	
		GUI.Label (new Rect (170, 70, 100, 20),"*Av " + spHAv);
		
		if (spHUp == true) {
			GUI.Label (new Rect (270, 30, 60, 20),"UP" );
		}else{}
		
		if (spHDown == true) {
			GUI.Label (new Rect (270, 50, 60, 20),"DOWN" );
		}else{}

		if (spHStable == true) {
			GUI.Label (new Rect (270, 70, 60, 20),"STABLE" );
		}else{}
		
	}
	
void MGUI () {
		
		//medium
		GUI.contentColor = Color.green;
		GUI.Box (new Rect (10, 110, 320, 80),"VOLUME        MEDIUM       SPECTRE" );
		
		GUI.Label (new Rect (10, 130, 100, 20),"Min " + volMAvMin);	
		GUI.Label (new Rect (10, 150, 100, 20),"Max " + volMAvMax);	
		GUI.Label (new Rect (10, 170, 100, 20),"*Av " + volMAv);

		if (volMUp == true) {
			GUI.Label (new Rect (110, 130, 60, 20),"UP" );
		}else{}
		
		if (volMDown == true) {
			GUI.Label (new Rect (110, 150, 60, 20),"DOWN" );
		}else{}

		if (volMStable == true) {
			GUI.Label (new Rect (110, 170, 60, 20),"STABLE" );
		}else{}
		
		GUI.Label (new Rect (170, 130, 100, 20),"Min " + spMMin);	
		GUI.Label (new Rect (170, 150, 100, 20),"Max " + spMMax);	
		GUI.Label (new Rect (170, 170, 100, 20),"*Av " + spMAv);
		
		if (spMUp == true) {
			GUI.Label (new Rect (270, 130, 60, 20),"UP" );
		}else{}
		
		if (spMDown == true) {
			GUI.Label (new Rect (270, 150, 60, 20),"DOWN" );
		}else{}

		if (spMStable == true) {
			GUI.Label (new Rect (270, 170, 60, 20),"STABLE" );
		}else{}
		
	}
	
void BGUI () {
		
		//bass
		GUI.contentColor = Color.red;
		GUI.Box (new Rect (10, 210, 320, 80),"VOLUME        BASS        SPECTRE" );
		
		GUI.Label (new Rect (10, 230, 100, 20),"Min " + volBAvMin);	
		GUI.Label (new Rect (10, 250, 100, 20),"Max " + volBAvMax);	
		GUI.Label (new Rect (10, 270, 100, 20),"*Av " + volBAv);

		if (volBUp == true) {
			GUI.Label (new Rect (110, 230, 60, 20),"UP" );
		}else{}
		
		if (volBDown == true) {
			GUI.Label (new Rect (110, 250, 60, 20),"DOWN" );
		}else{}

		if (volBStable == true) {
			GUI.Label (new Rect (110, 270, 60, 20),"STABLE" );
		}else{}
		
		GUI.Label (new Rect (170, 230, 100, 20),"Min " + spBMin);	
		GUI.Label (new Rect (170, 250, 100, 20),"Max " + spBMax);	
		GUI.Label (new Rect (170, 270, 100, 20),"*Av " + spBAv);
		
		if (spBUp == true) {
			GUI.Label (new Rect (270, 230, 60, 20),"UP" );
		}else{}
		
		if (spBDown == true) {
			GUI.Label (new Rect (270, 250, 60, 20),"DOWN" );
		}else{}

		if (spBStable == true) {
			GUI.Label (new Rect (270, 270, 60, 20),"STABLE" );
		}else{}
		
	}
	
void MLGUI () {
		
		//medium low
		GUI.contentColor = Color.green;
		GUI.Box (new Rect (10, 10, 320, 80),"VOLUME     MEDIUM LOW     SPECTRE" );
		
		GUI.Label (new Rect (10, 30, 100, 20),"Min " + volMLAvMin);	
		GUI.Label (new Rect (10, 50, 100, 20),"Max " + volMLAvMax);	
		GUI.Label (new Rect (10, 70, 100, 20),"*Av " + volMLAv);

		if (volMLUp == true) {
			GUI.Label (new Rect (110, 30, 60, 20),"UP" );
		}else{}
		
		if (volMLDown == true) {
			GUI.Label (new Rect (110, 50, 60, 20),"DOWN" );
		}else{}

		if (volMLStable == true) {
			GUI.Label (new Rect (110, 70, 60, 20),"STABLE" );
		}else{}
		
		GUI.Label (new Rect (170, 30, 100, 20),"Min " + spMLMin );	
		GUI.Label (new Rect (170, 50, 100, 20),"Max " + spMLMax);	
		GUI.Label (new Rect (170, 70, 100, 20),"*Av " + spMLAv);
		
		if (spMHUp == true) {
			GUI.Label (new Rect (270, 30, 60, 20),"   UP" );
		}else{}
		
		if (spMHDown == true) {
			GUI.Label (new Rect (270, 50, 60, 20),"DOWN" );
		}else{}

		if (spMHStable == true) {
			GUI.Label (new Rect (270, 70, 60, 20),"STABLE" );
		}else{}
		
		
	}
	
void MHGUI () {
		
			//medium high
		GUI.contentColor = Color.green;
		GUI.Box (new Rect (10, 110, 320, 80),"VOLUME     MEDIUM  HIGH     SPECTRE" );
		
		GUI.Label (new Rect (10, 130, 100, 20),"Min " + volMHAvMin);	
		GUI.Label (new Rect (10, 150, 100, 20),"Max " + volMHAvMax);	
		GUI.Label (new Rect (10, 170, 100, 20),"*Av " + volMHAv);

		if (volMHUp == true) {
			GUI.Label (new Rect (110, 130, 60, 20),"UP" );
		}else{}
		
		if (volMHDown == true) {
			GUI.Label (new Rect (110, 150, 60, 20),"DOWN" );
		}else{}

		if (volMHStable == true) {
			GUI.Label (new Rect (110, 170, 60, 20),"STABLE" );
		}else{}
		
		GUI.Label (new Rect (170, 130, 100, 20),"Min " + spMHMin);	
		GUI.Label (new Rect (170, 150, 100, 20),"Max " + spMHMax);	
		GUI.Label (new Rect (170, 170, 100, 20),"*Av " + spMHAv);
		
		if (spMHUp == true) {
			GUI.Label (new Rect (270, 130, 60, 20),"   UP" );
		}else{}
		
		if (spMHDown == true) {
			GUI.Label (new Rect (270, 150, 60, 20),"DOWN" );
		}else{}

		if (spMHStable == true) {
			GUI.Label (new Rect (270, 170, 60, 20),"STABLE" );
		}else{}
		
	}
	
void BLLGUI () {
		
			//bass low low
		GUI.contentColor = Color.red;
		GUI.Box (new Rect (10, 210, 320, 80),"VOLUME     BASS LOW LOW     SPECTRE" );
		
		GUI.Label (new Rect (10, 230, 100, 20),"Min " + volBLLAvMin);	
		GUI.Label (new Rect (10, 250, 100, 20),"Max " + volBLLAvMax);	
		GUI.Label (new Rect (10, 270, 100, 20),"*Av " + volBLLAv);

		if (volBLLUp == true) {
			GUI.Label (new Rect (110, 230, 60, 20),"UP" );
		}else{}
		
		if (volBLLDown == true) {
			GUI.Label (new Rect (110, 250, 60, 20),"DOWN" );
		}else{}

		if (volBLLStable == true) {
			GUI.Label (new Rect (110, 270, 60, 20),"STABLE" );
		}else{}
		
		GUI.Label (new Rect (170, 230, 100, 20),"Min " + spBLLMin);	
		GUI.Label (new Rect (170, 250, 100, 20),"Max " + spBLLMax);	
		GUI.Label (new Rect (170, 270, 100, 20),"*Av " + spBLLAv);
		
		if (spBLLUp == true) {
			GUI.Label (new Rect (270, 230, 60, 20),"   UP" );
		}else{}
		
		if (spBLLDown == true) {
			GUI.Label (new Rect (270, 250, 60, 20),"DOWN" );
		}else{}

		if (spBLLStable == true) {
			GUI.Label (new Rect (270, 270, 60, 20),"STABLE" );
		}else{}
		
		
	}
	
void BLHGUI () {
		
		//bass low high
		GUI.contentColor = Color.red;
		GUI.Box (new Rect (10, 310, 320, 80),"VOLUME     BASS LOW HIGH     SPECTRE" );
		
		GUI.Label (new Rect (10, 330, 100, 20),"Min " + volBLHAvMin);	
		GUI.Label (new Rect (10, 350, 100, 20),"Max " + volBLHAvMax);	
		GUI.Label (new Rect (10, 370, 100, 20),"*Av " + volBLHAv);

		if (volBLHUp == true) {
			GUI.Label (new Rect (110, 330, 60, 20),"UP" );
		}else{}
		
		if (volBLHDown == true) {
			GUI.Label (new Rect (110, 350, 60, 20),"DOWN" );
		}else{}

		if (volBLHStable == true) {
			GUI.Label (new Rect (110, 370, 60, 20),"STABLE" );
		}else{}
		
		GUI.Label (new Rect (170, 330, 100, 20),"Min " + spBLHMin);	
		GUI.Label (new Rect (170, 350, 100, 20),"Max " + spBLHMax);	
		GUI.Label (new Rect (170, 370, 100, 20),"*Av " + spBLHAv);
		
		if (spBLHUp == true) {
			GUI.Label (new Rect (270, 330, 60, 20),"   UP" );
		}else{}
		
		if (spBLHDown == true) {
			GUI.Label (new Rect (270, 350, 60, 20),"DOWN" );
		}else{}

		if (spBLHStable == true) {
			GUI.Label (new Rect (270, 370, 60, 20),"STABLE" );
		}else{}
		
	}
	
void BHLGUI () {
		
			//bass high low
		GUI.contentColor = Color.red;
		GUI.Box (new Rect (10, 410, 320, 80),"VOLUME     BASS HIGH LOW     SPECTRE" );
		
		GUI.Label (new Rect (10, 430, 100, 20),"Min " + volBHLAvMin);	
		GUI.Label (new Rect (10, 450, 100, 20),"Max " + volBHLAvMax);	
		GUI.Label (new Rect (10, 470, 100, 20),"*Av " + volBHLAv);

		if (volBHLUp == true) {
			GUI.Label (new Rect (110, 430, 60, 20),"UP" );
		}else{}
		
		if (volBHLDown == true) {
			GUI.Label (new Rect (110, 450, 60, 20),"DOWN" );
		}else{}

		if (volBHLStable == true) {
			GUI.Label (new Rect (110, 470, 60, 20),"STABLE" );
		}else{}
		
		GUI.Label (new Rect (170, 430, 100, 20),"Min " + spBHLMin);	
		GUI.Label (new Rect (170, 450, 100, 20),"Max " + spBHLMax);	
		GUI.Label (new Rect (170, 470, 100, 20),"*Av " + spBHLAv);
		
		if (spBHLUp == true) {
			GUI.Label (new Rect (270, 430, 60, 20),"   UP" );
		}else{}
		
		if (spBHLDown == true) {
			GUI.Label (new Rect (270, 450, 60, 20),"DOWN" );
		}else{}

		if (spBHLStable == true) {
			GUI.Label (new Rect (270, 470, 60, 20),"STABLE" );
		}else{}
		
	}
	
	
void BHHGUI () {
		
		//bass high high
		GUI.contentColor = Color.red;
		GUI.Box (new Rect (10, 510, 320, 80),"VOLUME     BASS HIGH HIGH    SPECTRE" );
		
		GUI.Label (new Rect (10, 530, 100, 20),"Min " + volBHHAvMin);	
		GUI.Label (new Rect (10, 550, 100, 20),"Max " + volBHHAvMax);	
		GUI.Label (new Rect (10, 570, 100, 20),"*Av " + volBHHAv);

		if (volBHHUp == true) {
			GUI.Label (new Rect (110, 530, 60, 20),"UP" );
		}else{}
		
		if (volBHHDown == true) {
			GUI.Label (new Rect (110, 550, 60, 20),"DOWN" );
		}else{}

		if (volBHHStable == true) {
			GUI.Label (new Rect (110, 570, 60, 20),"STABLE" );
		}else{}
		
		GUI.Label (new Rect (170, 530, 100, 20),"Min " + spBHHMin);	
		GUI.Label (new Rect (170, 550, 100, 20),"Max " + spBHHMax);	
		GUI.Label (new Rect (170, 570, 100, 20),"*Av " + spBHHAv);
		
		if (spBHHUp == true) {
			GUI.Label (new Rect (270, 530, 60, 20),"   UP" );
		}else{}
		
		if (spBHHDown == true) {
			GUI.Label (new Rect (270, 550, 60, 20),"DOWN" );
		}else{}

		if (spBHHStable == true) {
			GUI.Label (new Rect (270, 570, 60, 20),"STABLE" );
		}else{}
		
		
	}
	
	void OnGUI() {
		
		if (Input.GetKey (KeyCode.Alpha1))  
		{
		totalGUI ();
		}
		
		if (Input.GetKey (KeyCode.Alpha2))  
		{
		HGUI ();
		MGUI ();
		BGUI ();
		}
		
		if (Input.GetKey (KeyCode.Alpha3))  
		{
		MLGUI ();
		MHGUI ();
		BLLGUI ();
		BLHGUI ();
		BHLGUI ();
		BHHGUI ();
		}
		
		
		
		
		trashok = true;
		
		if (trashok = true)
		{
		Trash ();
		}

		//pour enlver les valeurs NaN
		/**if (float.IsNaN (volAvMin) || float.IsNaN (volAv) || 
			float.IsNaN (volAvMax) ||   float.IsNaN (freqGen) ) {
		}else{
			}/**/
		
		
		
		
		
}
		
public void Trash (){
			
		
		
	if (splog1.Count > numSamples - 2 && splog0.Count > numSamples - 2 && vol0.Count > numSamples - 2 && vol1.Count > numSamples - 2) 
		{
		splog0.Clear();
		splog1.Clear();
		vol0.Clear();
		vol1.Clear();
		}
		
	if (spH1.Count > numL2 - 2 && spH0.Count > numL2 - 2 && volH0.Count > numL2 - 2 && volH1.Count > numL2 - 2) 
		{		
		spH0.Clear();
		spH1.Clear();
		volH0.Clear();
		volH1.Clear();
		}
		
	if (spM1.Count > numL4 - 2 || spM0.Count > numL4 - 2 || volM0.Count > numL4 - 2 || volM1.Count > numL4 - 2) 
		{		
		spM0.Clear();
		spM1.Clear();
		volM0.Clear();
		volM1.Clear();
			
		spB0.Clear();
		spB1.Clear();
		volB0.Clear();
		volB1.Clear();
		}
		
		
	if (spML1.Count > numL8 - 2 && spML0.Count > numL8 - 2 && volML0.Count > numL8 - 2 && volML1.Count > numL8 - 2) 
		{
		spML0.Clear();
		spML1.Clear();
		volML0.Clear();
		volML1.Clear();
			
		spMH0.Clear();
		spMH1.Clear();
		volMH0.Clear();
		volMH1.Clear();	
		}
		
		if (spBLL1.Count > numL16 - 1 && spBLL0.Count > numL16 - 1 && volBLL0.Count > numL16 - 1 && volBLL1.Count > numL16 - 1) 
		{
		spBLL0.Clear();
		spBLL1.Clear();
		volBLL0.Clear();
		volBLL1.Clear();
		
		spBLH0.Clear();
		spBLH1.Clear();
		volBLH0.Clear();
		volBLH1.Clear();
			
		spBHL0.Clear();
		spBHL1.Clear();
		volBHL0.Clear();
		volBHL1.Clear();
			
		spBHH0.Clear();
		spBHH1.Clear();
		volBHH0.Clear();
		volBHH1.Clear();
		}
		
		
		
	trashok = false;
	
	}
	
}

[ZJP]

Pardon du remerciement tardif. Bon boulot.

[Rant]

https://www.dropbox.com/sh/b8sbn9m36qup7sn/M0SoUNha6B

Un dernier petit passage par ce post pour un de rien, ça a été un plaisir à faire ; )

pour ceux que ça intéresse y'a une version finale au lien ci-dessus d'une petite appli "ptosc", en résumé c'est une sphere dans laquelle on peut se ballader, et lancer des musiques qui génèrent ensuite des formes. C'est pas si loin du petit délire écrit en haut de la page.
Vous trouverez les explications et une notice à la fin du pdf "ptolulski". J'ai mis aussi le projet unity en l'état pour ceux qui voudraient voir les scripts utilisés et ceux faits (le zip "Soundcraft"). Surtout servez vous, même si vu mon niveau en programmation c'est loin d'être optimal à mon avis.

Voilà, work done ! xD

7*1717 = un max de plaisir.

[ZJP]