Aller au contenu
SignalRGB

Extraits de Code

Cette section comprend trois extraits de code utiles pour vos LightScripts : les compteurs, les gestionnaires d’état et les gestionnaires d’effets.

Le Meter

Section intitulée « Le Meter »

En continuant depuis la section précédente, la classe Meter est conçue pour aider à suivre les changements significatifs dans des données de compteur instables. Pensez-y comme une pédale de frein pour votre code - offrant de la stabilité même dans des zones complexes. Chaque compteur contient un tableau personnalisable de valeurs collectées à chaque exécution de votre fonction update. Lorsque toutes les valeurs dans ce tableau sont identiques (c’est-à-dire que les données sont “stables”), le compteur met à jour sa valeur et déclenche une fonction de callback liée pour activer un effet.

MéthodeDescription
Meter(size, callback)Le constructeur accepte à la fois une size et un callback.\n\n\n\nsize - le nombre de fois qu’une valeur identique doit être présente pour que la valeur du compteur soit considérée suffisamment ‘stable’ pour être traitée. Des valeurs plus élevées donnent plus de précision, des valeurs plus basses donnent moins de latence.\n\n\ncallback - une fonction à appeler lorsque la valeur du compteur est stable et a changé.
Meter.setValue(value)Vous devriez appeler setValue(value) à chaque image, ou chaque fois que de nouvelles données brutes pour ce compteur sont disponibles.

Le processus de collecte des données d’écran devrait généralement suivre cette structure :

  1. La valeur engine.vision.meter se met à jour en fonction des nouvelles données de l’écran.
  2. À l’intérieur de la fonction update, Meter.setValue(engine.vision.meter) est appelé pour enregistrer la nouvelle valeur.
  3. Le Meter vérifie son tableau interne pour voir si toutes les valeurs sont identiques. Si c’est le cas, il met à jour son propre état et exécute sa fonction de callback assignée.
  4. La fonction de callback évalue ensuite des conditions spécifiques en utilisant les variables du Meter et exécute son code si ces conditions sont remplies.

NOTE IMPORTANTE :

Ne sautez pas l’utilisation des callbacks. Puisque la fonction update s’exécute en continu, elle doit rester aussi efficace que possible. Son rôle principal devrait être de mettre à jour les valeurs des Meters. Évitez de chaîner des conditionnels dans update pour vérifier les compteurs et déclencher des effets, car cela entraîne des vérifications inutiles à chaque cycle. À la place, définissez vos effets dans des fonctions séparées et passez-les dans votre Meter comme callbacks.

Variables du Meter

Section intitulée « Variables du Meter »

Lorsqu’il est stable, le Meter fournira quelques valeurs à sa fonction de callback :

VariablesDescription
Meter.valueLa valeur actuelle du compteur.
Meter.increasedUn booléen qui indique si notre valeur a augmenté lors de cette mise à jour
Meter.decreasedUn booléen qui indique si notre valeur a diminué lors de cette mise à jour
Meter.diffLa valeur absolue du changement que le compteur a subi lors de cette mise à jour.

Exemple de Meter

Section intitulée « Exemple de Meter »

Voici une configuration de compteur simple, incluant le code de la classe Meter :

<head>
  <title>Meter Example</title>
  <meta description="Step-by-step metering" />
  <meta meter="health" tags="vlc,fortnite" x= ".05"  y=".9" width=".189" h="70-140" s="40-100" l="40-100" type="linear" />
</head>


<body style="margin: 0; padding: 0; background: #000;">
  <canvas id="exCanvas" width="320" height="200"></canvas>
</body>


<script>
  var c = document.getElementById("exCanvas");
  var ctx = c.getContext("2d");


  // Initialize meter
  var healthMeter = new Meter(5, healthEffect);


  function update(){
   // Update Meter values
   healthMeter.setValue(engine.vision.health);


   window.requestAnimationFrame(update);
  }


  function healthEffect(){
    if(healthMeter.increased){
      // Trigger effect
    } else if (healthMeter.value == 0){
      // Trigger effect
    } else if (healthMeter.diff > .3){
      // Trigger effect
    }
  }


  function Meter(size, callback) {
    this.size = size;
    this.value = 0;
    this.diff = 0;
    this.increased = false;
    this.decreased = false;
    var values = [];


    this.setValue = function (updatedValue) {
      // Add and shift.
      values.push(updatedValue);
      if (values.length > this.size) {
        values.shift();
      }


      // Exit early if we don't have a long-term match.
      for (var i = 0; i < values.length - 1; i++) {
        if (values[i] !== values[i + 1]) return;
      }


      // We got here, so we've got a matching value collection. Set variables and execute callback.
      if (this.value !== values[0]) {
        this.diff = Math.abs(this.value - values[0]);
        this.increased = this.value < values[0];
        this.decreased = this.value > values[0];
        this.value = values[0];
        callback();
      }
    };
  }


  window.requestAnimationFrame(update);


</script>
<head>
  <title>Meter Example</title>
  <meta description="Step-by-step metering" />
  <meta meter="health" tags="vlc,fortnite" x= ".05"  y=".9" width=".189" h="70-140" s="40-100" l="40-100" type="linear" />
</head>
<body style="margin: 0; padding: 0; background: #000;">
  <canvas id="exCanvas" width="320" height="200"></canvas>
</body>
<script>
  var c = document.getElementById("exCanvas");
  var ctx = c.getContext("2d");


  // Initialize meter
  var healthMeter = new Meter(5, healthEffect);


  function update(){
   // Update Meter values
   healthMeter.setValue(engine.vision.health);


   window.requestAnimationFrame(update);
  }


  function healthEffect(){
    if(healthMeter.increased){
      // Trigger effect
    } else if (healthMeter.value == 0){
      // Trigger effect
    } else if (healthMeter.diff > .3){
      // Trigger effect
    }
  }


  function Meter(size, callback) {
    this.size = size;
    this.value = 0;
    this.diff = 0;
    this.increased = false;
    this.decreased = false;
    var values = [];


    this.setValue = function (updatedValue) {
      // Add and shift.
      values.push(updatedValue);
      if (values.length > this.size) {
        values.shift();
      }


      // Exit early if we don't have a long-term match.
      for (var i = 0; i < values.length - 1; i++) {
        if (values[i] !== values[i + 1]) return;
      }


      // We got here, so we've got a matching value collection. Set variables and execute callback.
      if (this.value !== values[0]) {
        this.diff = Math.abs(this.value - values[0]);
        this.increased = this.value < values[0];
        this.decreased = this.value > values[0];
        this.value = values[0];
        callback();
      }
    };
  }


  window.requestAnimationFrame(update);


</script>
function Meter(size, callback) {
    this.size = size;
    this.value = 0;
    this.diff = 0;
    this.increased = false;
    this.decreased = false;
    var values = [];


    this.setValue = function (updatedValue) {
      // Add and shift.
      values.push(updatedValue);
      if (values.length > this.size) {
        values.shift();
      }


      // Exit early if we don't have a long-term match.
      for (var i = 0; i < values.length - 1; i++) {
        if (values[i] !== values[i + 1]) return;
      }


      // We got here, so we've got a matching value collection. Set variables and execute callback.
      if (this.value !== values[0]) {
        this.diff = Math.abs(this.value - values[0]);
        this.increased = this.value < values[0];
        this.decreased = this.value > values[0];
        this.value = values[0];
        callback();
      }
    };
  }

Le Gestionnaire d’État

Section intitulée « Le Gestionnaire d’État »

Le gestionnaire d’état est une pile d’effets qui gère spécifiquement les effets qui ont la priorité sur tous les autres. Si vous voulez qu’une grande animation dominante s’exécute jusqu’à la fin sans interruption, insérez-la dans le gestionnaire d’état.

MéthodeDescription
StateHandler()Le constructeur ne nécessite aucun argument.
StateHandler.push(new State())Vous pouvez pousser un nouvel état sur la pile d’état avec push, et le traitement commencera immédiatement.
StateHandler.pop()Extrait l’état actuel de la pile d’état et commence à traiter l’état précédent dans la pile.

Tout objet poussé dans le gestionnaire d’état doit implémenter Process(). La fonction Process détermine la durée de vie d’un effet dans le gestionnaire.

Exemple de Gestionnaire d’État

Section intitulée « Exemple de Gestionnaire d’État »

Ce qui suit montre un gestionnaire d’état de base, plus la fonction Process qui devrait s’exécuter à l’intérieur de vos fonctions d’effets :

var stateHdlr = new StateHandler();


function StateHandler() {
    var stack = [];
    var state = null;


  // Set current state to the top item in the stack
    var updateState = function () {
      if (stack.length > 0) {
        state = stack[stack.length - 1];
      } else {
        state = null;
      }
    };


  // Allows dev to add effect to state handler
    this.Push = function (newState) {
      stack.push(newState);
      updateState();
    };
  // Allows dev to remove effect from handler
    this.Pop = function () {
      stack.pop();
      updateState();
    };
  // Call the Process function of the current state (effect)
    this.Process = function () {
      if (state != null) {
        state.Process();
      }
    };
  }


function update(){
  stateHdlr.Process();
}
this.start = new Date.now()
this.elapsed = 0;
this.duration = 1000;


this.Process = function () {
  // Evaluate time since effect start
      this.elapsed = new Date.now() - this.start;
  // If the effect has reached its lifespan, remove it from the state handler
      if (this.elapsed > this.duration) {
        stateMgr.Pop();
      }
  // If the effect is still running, call the effect draw function
      this.Draw();
};

Le Gestionnaire d’Effets

Section intitulée « Le Gestionnaire d’Effets »

Les gestionnaires d’effets sont excellents pour stocker et rendre ensemble des effets plus petits et plus légers. Chaque effet dans le gestionnaire sera évalué à chaque appel de mise à jour, et ils sont supprimés lorsqu’ils atteignent la fin de leur durée de vie.

Le gestionnaire d’effets n’est qu’un tableau pour stocker les effets. C’est tout.

// Declare effects array
let effects = [];


// (Not shown) Evaluate Meter, callback function pushes effect into effects array
effects.push(new SpecialEffect());


// Iterate through the array, animating a frame for each effect
for (let i = 0; i < effects.length; i++) {
      effects[i].draw();
  // Remove effect if the lifetime has ended
      if (effects[i].lifetime <= 0) {
        effects.splice(i, 1);
      }
}

AVERTISSEMENT EFFET VS. ÉTAT

Section intitulée « AVERTISSEMENT EFFET VS. ÉTAT »

Le gestionnaire d’état est spécifiquement pour les effets prioritaires, ce qui signifie que nous devons lui donner la priorité lors de l’exécution. Dans votre fonction update, traitez le gestionnaire d’effets PUIS le gestionnaire d’état. Cela dessinera l’effet d’état par-dessus les éléments du gestionnaire d’effets.

Comme ceci :

function update(){
  // Evaluate effects handler
    for (let i = 0; i < effects.length; i++) {
      effects[i].draw();
      if (effects[i].lifetime <= 0) {
        effects.splice(i, 1);
      }
    }


  // THEN evaluate state handler
    stateMgr.Process();
}

Guide de Capture de Données USB

Section intitulée « Guide de Capture de Données USB »

Sauvegarder les données USB est un processus simple, mais les pilotes utilisés par ces programmes sont connus pour entrer en conflit avec certains systèmes, désactivant parfois les ports USB jusqu’à ce que le logiciel soit supprimé. Le correctif courant est de désactiver le ‘Secure Boot’ dans vos paramètres BIOS/UEFI. Avant de continuer, il est fortement recommandé d’avoir une restauration système disponible sur une clé USB ou un moyen d’accéder à votre ordinateur à distance qui ne dépend pas de l’entrée utilisateur au démarrage. C’est important au cas où la désactivation de Secure Boot ne résout pas le problème et que vous ne pouvez pas accéder au système pour désinstaller le programme. Dans de tels cas, une actualisation Windows peut être nécessaire pour supprimer tous les programmes installés tout en conservant vos fichiers personnels. Vous faites cela à vos propres risques. Si vous ne vous sentez pas à l’aise, demandez votre appareil ici. N’utilisez pas un système portable pour ce processus.

Une fois installé, le processus est simple et capturera toutes les données passant par vos appareils USB. Ne tapez pas d’informations sensibles pendant la capture si vous prévoyez de partager les données, car les frappes de clavier sont incluses dans l’enregistrement. Deux programmes tiers qui peuvent être utilisés sont Usblyzer(essai gratuit) et Wireshark (gratuit). Les deux fonctionnent, mais si vous choisissez Wireshark, assurez-vous que USBPcap est sélectionné.

Consultez notre prochaine page, Callbacks, pour plus de détails sur la construction de callbacks de compteurs et de fonctions d’effets.