plugin v1.0.0

assets/js/creations/pattern/pattern_audio.js

@@ -8,6 +8,9 @@ import { initializeAudioContext } from "../audio.js";
 
 const timerDisplay = document.getElementById("timer-display");
 
+// Variável para armazenar as "Parts" (sequências melódicas) do Tone.js
+let activeParts = [];
+
 function formatTime(milliseconds) {
   const totalSeconds = Math.floor(milliseconds / 1000);
   const minutes = Math.floor(totalSeconds / 60)
@@ -46,7 +49,7 @@ export function playSample(filePath, trackId) {
         track.pannerNode.pan.value = track.pan ?? 0;
       }
 
-      // Garante conexão: player -> volumeNode (não usar mais gainNode)
+      // Garante conexão: player -> volumeNode
       try {
         track.player.disconnect();
       } catch {}
@@ -103,17 +106,29 @@ function tick() {
 
   // Percorre tracks e toca o step atual se ativo
   appState.pattern.tracks.forEach((track) => {
+    if (track.muted) return; // Respeita o Mute
     if (!track.patterns || track.patterns.length === 0) return;
 
-    // IMPORTANTE: usar o pattern ativo da PRÓPRIA TRILHA
     const activePattern = track.patterns[track.activePatternIndex];
 
-    if (
-      activePattern &&
-      activePattern.steps[appState.global.currentStep] &&
-      track.samplePath
-    ) {
-      playSample(track.samplePath, track.id);
+    // Verifica se o step atual está ativo
+    if (activePattern && activePattern.steps[appState.global.currentStep]) {
+      
+      // CASO 1: SAMPLER (Arquivo de Áudio)
+      if (track.samplePath) {
+        playSample(track.samplePath, track.id);
+      }
+      // CASO 2: PLUGIN (Sintetizador)
+      // Se for plugin e tiver step marcado, toca nota padrão (C5)
+      else if (track.type === 'plugin' && track.instrument) {
+         // "16n" é a duração de uma semicolcheia
+         // Usamos um try/catch para evitar travar o loop se o plugin falhar
+         try {
+             track.instrument.triggerAttackRelease("C5", "16n", Tone.now());
+         } catch (e) {
+             console.warn("Falha ao tocar step do plugin:", e);
+         }
+      }
     }
   });
 
@@ -125,6 +140,11 @@ export function startPlayback() {
   if (appState.global.isPlaying || appState.pattern.tracks.length === 0) return;
   initializeAudioContext();
 
+  // Garante que o contexto do Tone esteja rodando
+  if (Tone.context.state !== "running") {
+      Tone.start();
+  }
+
   if (appState.global.currentStep === 0) {
     rewindPlayback();
   }
@@ -136,6 +156,11 @@ export function startPlayback() {
   if (appState.global.playbackIntervalId)
     clearInterval(appState.global.playbackIntervalId);
 
+  // --- NOVO: Agenda o Piano Roll (Melodias) ---
+  schedulePianoRoll();
+  Tone.Transport.start(); // Inicia o relógio para as notas melódicas
+  // --------------------------------------------
+
   appState.global.isPlaying = true;
   const playBtn = document.getElementById("play-btn");
   if (playBtn) {
@@ -154,6 +179,21 @@ export function stopPlayback() {
   appState.global.playbackIntervalId = null;
   appState.global.isPlaying = false;
 
+  // --- NOVO: Para o Transport e Limpa Synths ---
+  Tone.Transport.stop();
+  
+  // Limpa agendamentos melódicos
+  activeParts.forEach(part => part.dispose());
+  activeParts = [];
+
+  // Solta notas travadas de todos os plugins
+  appState.pattern.tracks.forEach(track => {
+      try { track.player?.stop(); } catch {}
+      try { track.instrument?.releaseAll?.(); } catch {} // Para PolySynths
+      try { track.instrument?.triggerRelease?.(); } catch {} // Para MonoSynths
+  });
+  // --------------------------------------------
+
   document
     .querySelectorAll(".step.playing")
     .forEach((s) => s.classList.remove("playing"));
@@ -173,6 +213,9 @@ export function rewindPlayback() {
       ? appState.global.currentStep - 1
       : getTotalSteps() - 1;
   appState.global.currentStep = 0;
+  
+  Tone.Transport.position = 0; // Reseta o tempo do Tone.js
+
   if (!appState.global.isPlaying) {
     if (timerDisplay) timerDisplay.textContent = "00:00:00";
     highlightStep(lastStep, false);
@@ -190,51 +233,88 @@ export function togglePlayback() {
 }
 
 // =========================================================================
-// FUNÇÃO CORRIGIDA v3: Renderizar o Pattern atual para um Blob de Áudio
+// AGENDADOR DE PIANO ROLL (NOVA FUNÇÃO)
+// Agenda as notas melódicas (desenhadas no Piano Roll) para tocar no Tone.Transport
+// =========================================================================
+function schedulePianoRoll() {
+    // Limpa anteriores por segurança
+    activeParts.forEach(part => part.dispose());
+    activeParts = [];
+
+    appState.pattern.tracks.forEach(track => {
+        if (track.muted) return;
+        const pattern = track.patterns[track.activePatternIndex];
+        
+        // Só agenda se tiver notas E for um instrumento
+        if (pattern && pattern.notes && pattern.notes.length > 0 && track.instrument) {
+            
+            // Mapeia as notas para o formato de evento do Tone.js
+            const events = pattern.notes.map(note => {
+                return {
+                    // Converte Ticks (pos) para Tempo Musical do Tone.js
+                    // Assumindo 192 PPQ (padrão LMMS) -> Tone PPQ
+                    time: 0 + (note.pos * (Tone.Transport.PPQ / 192) / Tone.Transport.PPQ), 
+                    midi: note.key,
+                    duration: note.len + "i", // 'i' em Tone.js significa ticks
+                    velocity: (note.vol || 100) / 100
+                };
+            });
+
+            // Cria uma Part (sequência)
+            const part = new Tone.Part((time, value) => {
+                if (track.muted) return;
+                
+                const freq = Tone.Frequency(value.midi, "midi");
+                // Dispara o método que padronizamos em todos os plugins
+                if (track.instrument.triggerAttackRelease) {
+                    track.instrument.triggerAttackRelease(freq, value.duration, time, value.velocity);
+                }
+            }, events).start(0);
+
+            // Configura o Loop da Melodia
+            const bars = parseInt(document.getElementById('bars-input')?.value || 1);
+            part.loop = true;
+            part.loopEnd = bars + "m"; // 'm' = measure (compasso)
+
+            activeParts.push(part);
+        }
+    });
+}
+
+// =========================================================================
+// Renderizar o Pattern atual para um Blob de Áudio (MANTIDO ORIGINAL)
 // =========================================================================
 
 export async function renderActivePatternToBlob() {
-  initializeAudioContext(); // Garante que o contexto de áudio principal existe
+  initializeAudioContext(); 
 
-  // 1. Obter configs atuais
   const bpm = parseInt(document.getElementById("bpm-input").value, 10) || 120;
   const totalSteps = getTotalSteps();
-  const stepInterval = 60 / (bpm * 4); // Duração de 1 step (em segundos)
-  const duration = totalSteps * stepInterval; // Duração total em segundos
+  const stepInterval = 60 / (bpm * 4); 
+  const duration = totalSteps * stepInterval; 
 
-  // 2. Descobrir qual pattern está ativo (assume que todos estão no mesmo)
   const activePatternIndex =
     appState.pattern.tracks[0]?.activePatternIndex || 0;
 
-  // 3. Renderizar offline usando Tone.Offline
   const buffer = await Tone.Offline(async () => {
-    // ----------------------------------------------------
-    // Contexto de Áudio OFFLINE
-    // ----------------------------------------------------
     const masterGain = new Tone.Gain().toDestination();
 
-    // --- INÍCIO DA CORREÇÃO (Lógica de Polifonia) ---
-
-    // 1. Criamos as 'Parts'.
     const offlineTracksParts = appState.pattern.tracks
       .map((track) => {
         const pattern = track.patterns[activePatternIndex];
 
-        // Verificação crucial: Precisamos do 'track.buffer' (áudio carregado)
+        // Nota: O render atual suporta apenas Samplers (buffers carregados)
+        // Para suportar Plugins no futuro, precisaríamos recriar o synth aqui dentro.
         if (!pattern || !track.buffer || !pattern.steps.includes(true)) {
-          return null; // Pula trilha se não tiver áudio ou notas
+          return null; 
         }
 
-        // Obtém o buffer de áudio (que já está carregado)
         const trackBuffer = track.buffer;
-
-        // Cria a cadeia de áudio (Volume/Pan) para esta *trilha*
         const panner = new Tone.Panner(track.pan).connect(masterGain);
         const volume = new Tone.Volume(Tone.gainToDb(track.volume)).connect(
           panner
         );
 
-        // Cria a lista de eventos (tempos em que as notas devem tocar)
         const events = [];
         pattern.steps.forEach((isActive, stepIndex) => {
           if (isActive) {
@@ -243,48 +323,30 @@ export async function renderActivePatternToBlob() {
           }
         });
 
-        // Cria a Tone.Part
         const part = new Tone.Part((time) => {
-          // *** ESTA É A CORREÇÃO CRÍTICA ***
-          // Para cada nota (cada 'time' na lista de 'events'),
-          // nós criamos um PLAYER "ONE-SHOT" (descartável).
-          // Isso permite que vários sons da mesma trilha
-          // se sobreponham (polifonia).
+          new Tone.Player(trackBuffer) 
+            .connect(volume) 
+            .start(time); 
+        }, events); 
 
-          new Tone.Player(trackBuffer) // Usa o buffer carregado
-            .connect(volume) // Conecta na cadeia de áudio (Volume->Pan->Master)
-            .start(time); // Toca no tempo agendado
-        }, events); // Passa a lista de tempos [0, 0.25, 0.5, ...]
-
-        return part; // Retorna a Part (que sabe quando disparar)
+        return part; 
       })
-      .filter((t) => t !== null); // Remove trilhas nulas
+      .filter((t) => t !== null); 
 
-    // 2. Como estamos usando buffers já carregados,
-    //    não precisamos esperar (remover 'await Tone.loaded()')
-
-    // 3. Agenda todas as 'Parts' para começar
     offlineTracksParts.forEach((part) => {
       part.start(0);
     });
-    // --- FIM DA CORREÇÃO ---
 
-    // Define o BPM do transporte offline
     Tone.Transport.bpm.value = bpm;
-
-    // Inicia o transporte (para a renderização)
     Tone.Transport.start();
-    // ----------------------------------------------------
-  }, duration); // Duração total da renderização
+  }, duration); 
 
-  // 5. Converte o AudioBuffer resultante em um Blob (arquivo .wav)
   const blob = bufferToWave(buffer);
   return blob;
 }
 
 // =========================================================================
-// FUNÇÃO UTILITÁRIA: Converte AudioBuffer para Blob WAV
-// (Mantenha esta função como está)
+// FUNÇÃO UTILITÁRIA: Converte AudioBuffer para Blob WAV (MANTIDO ORIGINAL)
 // =========================================================================
 
 function bufferToWave(abuffer) {
@@ -298,7 +360,6 @@ function bufferToWave(abuffer) {
   let offset = 0;
   let pos = 0;
 
-  // setAll e setString são helpers
   function setAll(data) {
     for (i = 0; i < data.length; i++) {
       view.setUint8(pos + i, data[i]);
@@ -309,44 +370,41 @@ function bufferToWave(abuffer) {
     setAll(s.split("").map((c) => c.charCodeAt(0)));
   }
 
-  // Cabeçalho WAV
   setString("RIFF");
   view.setUint32(pos, length - 8, true);
   pos += 4;
   setString("WAVE");
   setString("fmt ");
   view.setUint32(pos, 16, true);
-  pos += 4; // Sub-chunk size
+  pos += 4; 
   view.setUint16(pos, 1, true);
-  pos += 2; // Audio format 1
+  pos += 2; 
   view.setUint16(pos, numOfChan, true);
   pos += 2;
   view.setUint32(pos, abuffer.sampleRate, true);
   pos += 4;
   view.setUint32(pos, abuffer.sampleRate * 2 * numOfChan, true);
-  pos += 4; // Byte rate
+  pos += 4; 
   view.setUint16(pos, numOfChan * 2, true);
-  pos += 2; // Block align
+  pos += 2; 
   view.setUint16(pos, 16, true);
-  pos += 2; // Bits per sample
+  pos += 2; 
   setString("data");
   view.setUint32(pos, length - 44, true);
   pos += 4;
 
-  // Pega os dados dos canais
   for (i = 0; i < numOfChan; i++) {
     channels.push(abuffer.getChannelData(i));
   }
 
-  // Escreve os dados (intercalando canais)
   for (i = 0; i < abuffer.length; i++) {
     for (let j = 0; j < numOfChan; j++) {
       sample = Math.max(-1, Math.min(1, channels[j][i]));
-      sample = (0.5 + sample * 32767.5) | 0; // Converte para 16-bit PCM
+      sample = (0.5 + sample * 32767.5) | 0; 
       view.setInt16(pos, sample, true);
       pos += 2;
     }
   }
 
   return new Blob([buffer], { type: "audio/wav" });
-}
+}