[Philippe]

Salut Bertrand, Regis,
Je suis désolé, on est au fond de la mine en ce moment… Mais on ne lâche pas l’affaire.

Nous avons prévu de produire une nouvelle bêta pour Windows cette semaine en espérant qu’elle corrige les problèmes d’instabilités introduits dans la précédente. Si c’est le cas, Logelloop 6.1 sortira prochainement avec beaucoup de nouvelles fonctionnalités et de corrections de bugs… Si ça n’est pas le cas, on travaillera encore sur la stabilité de la version Windows avant la publication.

On va faire tout notre possible également pour rendre le plus fonctionnels les VST3 sur Windows.
Désolé pour le dérangement !
À bientôt,
Philippe

[Philippe]

Salut Morgan,
Effectivement l’absence de fonction During pour les messages vers les inserts est dommage.
Peut-être qu’un jour nous disposerons d’une solution simple, mais pour l’instant, il n’y a pas d’autre solution que de faire sa propre routine.
Routine que tu peux déporter dans un slot macro spécifique qui gérera tous tes cas de during spécifiques.

Voici une autre proposition de macro pour faire un during, note qu’elle est encore plus longue que la tienne !

//***********************************************************************************
// Set the total duration of the value change
Declare Local int $duration_ms$ = 1000

// Set the start and end value
Declare Local float $startValue$ = 0
Declare Local float $endValue$ = 1

Declare Local int $steps$ = 100
Declare Local float $incrementDuration$ = 0
Declare Local float $targetValue$ = $startValue$
Declare Local float $increment$ = {($endValue$ – $targetValue$) / $steps$}

// calculate the number of needed steps for the current increment
$steps$ = {($endValue$ – $startValue$) / $increment$}
//Post $steps$

Declare Local int $startClock$ = {monotonic_ms()}

DoRepeat
$increment$ = {($endValue$ – $targetValue$) / $steps$}
$incrementDuration$ = { ($startClock$ + $duration_ms$ – monotonic_ms())/ $steps$ }

// Current step value calculation
$targetValue$ = {min($endValue$,$targetValue$ + $increment$)}

//******************** Put the destination here ********************
InsertSendMessage fx1 1 SpeedFloat $targetValue$

WaitDuration {$incrementDuration$}

$steps$ = {$steps$ – 1 }
While {$targetValue$ < $endValue$} //Post {monotonic_ms() - $startClock$} //***********************************************************************************

[Philippe]

Salut Morgan,
Les variables permettent :
– de connaître l’état d’une interface de Logelloop
– de mémoriser/modifier une valeur dans une ou plusieurs macros.

Mais les variables ne permettent pas de modifier l’état de Logelloop !
J’espère ne pas omettre une situation particulière en écrivant cela, mais si tu souhaites changer l’état de quelque chose dans Logelloop, tu dois envoyer un message à partir de la macro.

Lorsqu’il s’agit d’un VST, la variable $VST_fx1_rank1_SetParam_state$ te permet de connaître l’index et la valeur du dernier paramètre que tu as édité sur le plug-in. À ce jour, les variables string sont le moyen le plus simple de stocker plusieurs valeurs lisibles en un coup d’œil, c’est la raison pour laquelle cette variable est une string.

Pour modifier l’état du plug-in, tu n’auras pas d’autre choix donc que d’utiliser

InsertSendMessage fx1 1 SetParam

Je peux si cela est vraiment nécessaire ajouter une variable qui donnerait le nombre total de paramètres d’un plug-in, mais c’est un peu de travail et je ne suis pas certain que cela soit vraiment nécessaire, car ça donnera tellement de valeur dans certains cas que tu auras bien de la peine à les utiliser.

Je préconise dans l’état actuel des choses d’utiliser $VST_fx1_rank1_SetParam_state$ pour connaître les index des paramètres que tu souhaites contrôler avec ta macro et de procéder comme tu le précises ci-dessus.

Pour ma part, j’ai cette simple macro pour modifier la valeur d’un paramètre en boucle :

Declare Local int $VST_param_id$ = 1
Declare Local float $VST_param_value$ = 0

DoRepeat
If {$VST_param_value$ >= 1}
$VST_param_value$ = 0
EndIf
InsertSendMessage fx1 1 SetParam $VST_param_id$ $VST_param_value$

$VST_param_value$ = {$VST_param_value$ + 0.01}

Sleep 100
While true

Effectivement, je déclare moi-même deux variables, l’une sera générale pour ce plug-in, elle te permettra de choisir l’index du paramètre que tu souhaites éditer et l’autre sera la valeur que tu souhaites attribuer à ce paramètre…

Bonne journée,
Philippe

[Philippe]

Salut Timothée,
Je vois que tu as trouvé la solution, pour le Pitch, donc c’est bon pour ça.

Si tu souhaites modifier la vitesse d’un ou plusieurs loopers en utilisant un Midi contrôleur, tu peux le faire simplement en cliquant sur le ? qui se trouve dans le Looper.

1 – Cela ouvre la fenêtre d’aide.
2 – Dans l’onglet du milieu de la fenêtre d’aide, tu vois toutes les commandes et contrôles pour cet insert.

3 – En bas à droite se trouve la partie contrôleur, et c’est là que se trouve la liste des réglages modifiable en utilisant un contrôleur Midi.
4 – Dans cette liste se trouve Speed pour la vitesse.

5 – En cliquant l’engrenage qui se trouve au-dessus de ce tableau, tu ouvres la fenêtre qui te permet de configurer le contrôleur Midi qui modifiera la vitesse du/des loopers.

Note aussi que lorsque tu cliques le petit triangle orange, en bas à droite dans le looper, tu ouvres un tiroir.
Dans ce tiroir, tu trouveras “Speed midi ctl scale” qui te permet de choisir quelle sera la vitesse minimum et maximum pour des valeurs Midi de 0 à 127.

Bonne journée,
Philippe

[Philippe]

Salut Morgan,
Il faut utiliser la syntaxe suivante pour que la variable d’id soit correctement interprétée par la macro

TrackAuxState $auxID$ trk[$trkID$] 0

Bonne soirée,
Philippe

[Philippe]

Salut,
C’est un cas un peu coriace et j’ai l’impression qu’il y a un truc qui n’est pas très évident, mais c’est toujours un peu compliqué de faire avec deux asservissements au métronome : celui de la macro et celui du looper.

Concernant ta macro, le souci est que si tu demandes une action sur le premier temps et que le looper est asservi au premier temps du métronome, lorsque le signal de Mute ou Play arrive, c’est déjà trop tard… Il est donc préférable de lancer l’action à partir du seizième temps, ainsi, le démarrage de la lecture aura bien lieu sur le premier temps de la mesure…

Toutefois, cette histoire de 4 temps soulève une question : j’ai l’impression qu’il y a un bug quelque part, mais je n’arrive pas à le cerner, donc difficile d’en dire plus pour le moment.

La macro devient donc :

MetroActivateEvents true // activate events on metronome

WaitMetroBeat 16 //WaitMetroNextBarStart // playing A
InsertSendMessage fx1 1 Play

// Now we will play loops to fit song size
// A A B A
DoRepeat
Post { “WaitMetroNextBarStart playing A”}
WaitMetroBeat 1 //WaitMetroNextBarStart // playing A
Post { “WaitMetroNextBarStart still playing A”}
WaitMetroBeat 16 //WaitMetroNextBarStart // playing A
InsertSendMessage fx2 1 Play
InsertSendMessage fx1 1 Mute
WaitMetroBeat 1
//WaitDuration 80 // synchro
Post { “WaitMetroNextBarStart playing B”} // <============== ici, il se passe 4 temps avant que la boucle en fx2 ne se lance //WaitDuration 80 // synchro WaitMetroBeat 16 //WaitMetroNextBarStart // playing B InsertSendMessage fx2 1 Mute // InsertSendMessage fx1 1 Play // WaitMetroBeat 1 //WaitMetroNextBarStart // playing A While { true }

Si tu souhaites que ta macro fonctionne, quel que soit le nombre de temps par mesure, tu peux mettre :

WaitMetroBeat $metro_bar_beats$

à la place de :

WaitMetroBeat 16

J’enlève les WaitDuration qui sont toujours un peu bizarres…
J’ai l’impression qu’avec ces modifications, ça fonctionne, dis-moi ce que tu en penses.
Bonne soirée,
Philippe

[Philippe]

Salut Stephane,
Avant de commencer à creuser, les loopers sont en mode free ou en mode synchro?
Si synchro, ils sont sur quelle carrure?
Merci,
Philippe

[Philippe]

Salut William,
Oui, lorsque tu importes les presets d’un autre projet. Le preset contient toutes les informations nécessaires au chargement des réglages de plug-ins.
Mais pour Granulaterre et Granular, il faut aussi importer leurs propres présets !
Dans Granulaterre, c’est la même procédure que pour les présets principaux de Logelloop en revanche, pour Granular, il n’y a pas encore l’interface permettant de le faire automatiquement.

Tu devras donc soit faire des copies à l’intérieur des fichiers de mémoires de Granular, sois recréer manuellement les preset.

Nous allons bientôt ajouter les routines permettant de faire les imports dans Granular aussi, car c’est effectivement très utile !
Philippe

[Philippe]

Salut William,
Je vois plusieurs trucs qui font que ça ne sera pas possible.
le premier étant que tu cherches à stocker des symbols (string) dans un tableau qui attend des entiers (int).
Le second est que tu mets une commande macro dans une variable, mais nous on a besoin de savoir qu’elle existe et où elle se trouve au moment de compiler la macro. Et ici, avec cette méthode, ça ne sera pas possible.

Ce que tu peux faire c’est stocker un nombre et ensuite, à l’aide de plusieurs IfThen tu fais des MacroSimulateUserActionByName en fonction du nombre que tu trouves dans $liste[3]$…

Bonne journée,
Philippe

[Philippe]

Salut William,
Sans trop comprendre où ça coince précisément…
Je vois quand même quelques trucs que l’on pourrait améliorer un peu dans la macro.

Je commence par déclarer la variable dans l’entête de la macro et je la mets en Local.
Je change le nom pour éviter le / dans le nom
Je m’assure que le bouton n’est pas en mode toggle (mode 0)
Je mets un MacroStop par acquit de conscience à la fin de la boucle IF.
En faisant tout ça, j’ai l'(impression que c’est plus table.
Dis-moi…
Bonne journée,
Philippe

Declare Local Once boolean $firstTime$ = true
Declare Local int $itemID$ = 0
Declare Local int $itemSize$ = 30

Declare Local int $TrackMute$ = 0

If { $firstTime$ }
$firstTime$ = false
SendData itemamount 0
WaitDuration 10
SendData itemamount 3
SendData basicdisposition
SendData mainWindow setsize 463 {30 + ($itemSize$ * 2)}
SendData item 0 mode 0
SendData item 1 name Mute
SendData MacroInitialized
MacroStop
EndIf

CaseBranch Mute
$TrackMute$ = {randomUrnInt(1,0,1)}
WaitDuration 20

MessageMain $TrackMute$

If {$TrackMute$== 0}
TrackMute fx1 1
TrackMute fx2 1
TrackMute fx3 1
TrackMute fx4 1
TrackMute fx5 1
TrackMute fx6 1
TrackMute fx7 1
TrackMute fx8 1
Else
TrackMute fx1 0
TrackMute fx2 0
TrackMute fx3 0
TrackMute fx4 0
TrackMute fx5 0
TrackMute fx6 0
TrackMute fx7 0
TrackMute fx8 0
EndIf
MacroStop
BreakCaseBranch

EndCaseBranches

[Philippe]

Salut Régis, Bertrand,
On continue à travailler sur cette histoire de VST3 dans Windows.
Je pense que l’on va trouver un correctif assez rapidement.

Les crashs qui arrivent avec ta version Régis sont liés à la bêta que nous t’avons envoyée pour tenter de corriger le pb des VST3, les autres utilisateurs n’ont pas ces crashs. Si tu veux revenir à une version plus stable, il faudrait prendre la version qui est sur le site.

Nous faisons de notre mieux pour corriger tout cela le plus rapidement.
merci pour votre compréhension,
Philippe

[Philippe]

Salut,
Oui, c’est possible.
C’est un peu complexe à mettre en œuvre, mais ça fonctionne bien.

Il faut utiliser BeginSignalCatchBlock, une variable, ici c’est $user_action_catched$ mais tu peux choisir un autre nom et la ligne
“EndSignalCatchBlock OnSignalCatched Do Set $user_action_catched$ = true”
qui change l’état de la variable $user_action_catched$

Tu trouveras un exemple ci-dessous :

//************************************************************************************************************************
//Cette macro est à utiliser avec le SFX Distortion inséré dans le slot 1
//Variable qui permet de choisir le canal dans lequel sera inséré la distorsion
Declare int $Canal_a_distordre$ = 0

//Durée en milliseconde de l’insert pour un canal
Declare int $Duree_de_disto$ = 50

Declare int $init_de_coda$ = 0

//Routine de chenillard – met en route et arrête la distorsion cycliquement
//Cette variable servira à arrêter la macro si l’utilisateur relance la macro
Declare boolean $user_action_catched$ = false

//Il faut mettre ici la macro en attente d’une sollicitation de l’utilisateur (comparable à WaitUserAction, mais non bloquant)
BeginSignalCatchBlock

//Début de la boucle
DoRepeat
$Canal_a_distordre$ = {$Canal_a_distordre$ + 1}
//La condition IfThen permet de n’insérer la distorsion que sur les pistes dans lesquelles il y a du son
//La variable $current_full_tracks_count$ est interne et nous renseigne du nombre de pistes contenant du son
IfThen { $Canal_a_distordre$ > $current_full_tracks_count$ } Do Set $Canal_a_distordre$ = 1

//Insere la distorsion et attend un temps avant de l’arrêter pour cette piste
SFXSendMessage 1 {“” + $Canal_a_distordre$ + “_DistoTrigger”} ON
Sleep $Duree_de_disto$
SFXSendMessage 1 {“” + $Canal_a_distordre$ + “_DistoTrigger”} OFF
Sleep $Duree_de_disto$
//! indique que l’inverse donc !false = true
//Tant que l’utilisateur ne fait rien, $user_action_catched$ reste à false, donc la condition !$user_action_catched$ est true
While { !$user_action_catched$ }

//Cette ligne fait que si l’utilisateur relance la macro, $user_action_catched$ passe à true
//Si c’est le cas, la routine s’arrête et on passe à la suite
EndSignalCatchBlock OnSignalCatched Do Set $user_action_catched$ = true

//Lorsque l’on quitte la routine, on fait une nouvelle routine qui remet tous les inserts sur OFF
//cela permet de s’assurer qu’aucun canal ne reste en distorsion à la fin de la macro
DoRepeat
Set $init_de_coda$ = {$init_de_coda$ + 1}
SFXSendMessage 1 $init_de_coda$ OFF
While {$init_de_coda$ < 10 } //************************************************************************************************************************

• This reply was modified 8 months, 2 weeks ago by Philippe.

[Philippe]

Salut,
Oui, cela est possible.
Il ne faut pas bien sûr que les variables soient globales et donc, tu ne mets pas Local lorsque tu déclares la variable.

Voici un exemple utilisant deux macros.
Cette première macro contient une fonction qui utilise During avec des variables :

//********************************** During function **********************************
Declare Once int $duringDuration$ = 1000
Declare Once int $duringTargetValue$ = 0
Declare Once int $duringTrackID$ = 1

During $duringDuration$ Reach $duringTargetValue$ TrackVolume trk[$duringTrackID$]
//************************************ . End ****************************************

Cette seconde macro modifie les valeurs de trois variables avant de lancer la première :

//*********************************** During trigger **********************************
Declare Once int $duringDuration$ = 1000
Declare Once int $duringTargetValue$ = 0
Declare Once int $duringTrackID$ = 1

$duringDuration$ = 100
$duringTargetValue$ = -23
$duringTrackID$ = 2
MacroStartIfNeededByName “During function”

WaitUserAction

$duringDuration$ = 10
$duringTargetValue$ = -50
$duringTrackID$ = 5
MacroStartIfNeededByName “During function”

WaitUserAction

$duringDuration$ = 500
$duringTargetValue$ = -67
$duringTrackID$ = 7
MacroStartIfNeededByName “During function”
//************************************ . End ****************************************

Note bien que tu dois déclarer les variables dans les deux macros, mais que tu le fais en indiquant bien Déclare Once pour ne pas réinitialiser les variables lorsque la seconde macro lance la première par exemple…

Philippe

[Philippe]

Bonjour Bertrand,
Oui, le problème semble affecter toutes les installations sous Windows.
Nous travaillons actuellement là-dessus.
Dès que nous avons une solution satisfaisante, je t’envoie le lien vers une beta.
Merci,
Bonne journée,
Philippe

[Philippe]

Salut Maxime,

1 – il te faut une carte son à 4 sorties minimum
2 – branche 4 haut-parleurs sur les quatre sorties de ta carte son
3 – dans Audio Settings de Logelloopk, choisi le mode spatialisé dans ‘active output organisation” du panneau Outputs
4 – choisi “Qaudri” dans le menu Apply model du panneau Spatialized.
5 – sauve les audio settings

Maintenant, tu as des bouton circulaire à la place des panoramiques et tu peux spatialiser le son sur tes quatre haut-parleurs.

Je me dis qu’il faudrait que je fasse un tuto court pour montrer ce processus…

Merci pour tes remerciements qui font plaisir !
Oui, Logelloop est un joli jouet -)
Bonne journée,
Philippe

• This reply was modified 8 months, 3 weeks ago by Philippe.

[Author]

Posts