versão 2.0.1 - Correção do grid (Editor de Samples), loop, delete, resize, trim e streching funcionais

assets/js/creations/audio/audio_state.js

@@ -2,8 +2,9 @@
 import { DEFAULT_VOLUME, DEFAULT_PAN } from "../config.js";
 import { renderAudioEditor } from "./audio_ui.js";
 import { getMainGainNode } from "../audio.js";
+import { getAudioContext } from "../audio.js";
 
-const initialState = {
+export let audioState = {
     tracks: [],
     clips: [],
     audioEditorStartTime: 0,
@@ -12,33 +13,47 @@ const initialState = {
     isAudioEditorLoopEnabled: false,
 };
 
-export let audioState = { ...initialState };
-
 export function initializeAudioState() {
     audioState.clips.forEach(clip => {
-        if (clip.player) clip.player.dispose();
         if (clip.pannerNode) clip.pannerNode.dispose();
         if (clip.gainNode) clip.gainNode.dispose();
     });
-    Object.assign(audioState, initialState, { tracks: [], clips: [] });
+    Object.assign(audioState, {
+        tracks: [],
+        clips: [],
+        audioEditorStartTime: 0,
+        audioEditorAnimationId: null,
+        audioEditorPlaybackTime: 0,
+        isAudioEditorLoopEnabled: false,
+    });
 }
 
 export async function loadAudioForClip(clip) {
   if (!clip.sourcePath) return clip;
+  
+  const audioCtx = getAudioContext();
+  if (!audioCtx) {
+      console.error("AudioContext não disponível para carregar áudio.");
+      return clip;
+  }
+  
   try {
-    // Cria o player e o conecta à cadeia de áudio do clipe
-    clip.player = new Tone.Player();
-    clip.player.chain(clip.gainNode, clip.pannerNode, getMainGainNode());
+    const response = await fetch(clip.sourcePath);
+    if (!response.ok) throw new Error(`Falha ao buscar áudio: ${clip.sourcePath}`);
+    const arrayBuffer = await response.arrayBuffer();
+    const audioBuffer = await audioCtx.decodeAudioData(arrayBuffer);
 
-    // Carrega o áudio e espera a conclusão
-    await clip.player.load(clip.sourcePath);
-    
-    if (clip.duration === 0) {
-      clip.duration = clip.player.buffer.duration;
+    clip.buffer = audioBuffer; 
+
+    // --- CORREÇÃO: Salva a duração original ---
+    if (clip.durationInSeconds === 0) {
+      clip.durationInSeconds = audioBuffer.duration;
     }
+    // Salva a duração real do buffer para cálculos de stretch
+    clip.originalDuration = audioBuffer.duration;
+
   } catch (error) {
     console.error(`Falha ao carregar áudio para o clipe ${clip.name}:`, error);
-    clip.player = null;
   }
   return clip;
 }
@@ -49,18 +64,25 @@ export function addAudioClipToTimeline(samplePath, trackId = 1, startTime = 0) {
         trackId: trackId,
         sourcePath: samplePath,
         name: samplePath.split('/').pop(),
-        player: null,
-        startTime: startTime,
+        
+        startTimeInSeconds: startTime,
         offset: 0,
-        duration: 0,
+        durationInSeconds: 0, 
+        originalDuration: 0, // Será preenchido pelo loadAudioForClip
+
         pitch: 0,
         volume: DEFAULT_VOLUME,
         pan: DEFAULT_PAN,
-        isSoloed: true,
-        // --- ADICIONADO: Nós de áudio para cada clipe ---
+
         gainNode: new Tone.Gain(Tone.gainToDb(DEFAULT_VOLUME)),
         pannerNode: new Tone.Panner(DEFAULT_PAN),
+        
+        buffer: null,
+        player: null,
     };
+    
+    newClip.gainNode.connect(newClip.pannerNode);
+    newClip.pannerNode.connect(getMainGainNode());
 
     audioState.clips.push(newClip);
     
@@ -78,35 +100,52 @@ export function updateAudioClipProperties(clipId, properties) {
 
 export function sliceAudioClip(clipId, sliceTimeInTimeline) {
     const originalClip = audioState.clips.find(c => c.id == clipId);
-    if (!originalClip || sliceTimeInTimeline <= originalClip.startTime || sliceTimeInTimeline >= originalClip.startTime + originalClip.duration) {
+    
+    if (!originalClip || 
+        sliceTimeInTimeline <= originalClip.startTimeInSeconds || 
+        sliceTimeInTimeline >= (originalClip.startTimeInSeconds + originalClip.durationInSeconds)) {
+        console.warn("Corte inválido: fora dos limites do clipe.");
         return;
     }
 
-    const cutPointInClip = sliceTimeInTimeline - originalClip.startTime;
+    const originalOffset = originalClip.offset || 0;
+    const cutPointInClip = sliceTimeInTimeline - originalClip.startTimeInSeconds;
 
     const newClip = {
         id: Date.now() + Math.random(),
         trackId: originalClip.trackId,
         sourcePath: originalClip.sourcePath,
         name: originalClip.name,
-        player: originalClip.player,
-        startTime: sliceTimeInTimeline,
-        offset: originalClip.offset + cutPointInClip,
-        duration: originalClip.duration - cutPointInClip,
+        buffer: originalClip.buffer,
+        
+        startTimeInSeconds: sliceTimeInTimeline,
+        offset: originalOffset + cutPointInClip,
+        durationInSeconds: originalClip.durationInSeconds - cutPointInClip,
+        
+        // --- CORREÇÃO: Propaga a duração original ---
+        originalDuration: originalClip.originalDuration,
+
         pitch: originalClip.pitch,
         volume: originalClip.volume,
         pan: originalClip.pan,
-        isSoloed: false,
+
         gainNode: new Tone.Gain(Tone.gainToDb(originalClip.volume)),
         pannerNode: new Tone.Panner(originalClip.pan),
+        
+        player: null
     };
-    newClip.player.chain(newClip.gainNode, newClip.pannerNode, getMainGainNode());
 
+    newClip.gainNode.connect(newClip.pannerNode);
+    newClip.pannerNode.connect(getMainGainNode());
+
+    originalClip.durationInSeconds = cutPointInClip;
 
-    originalClip.duration = cutPointInClip;
     audioState.clips.push(newClip);
+    
+    console.log("Clipe dividido. Original:", originalClip, "Novo:", newClip);
 }
 
+// ... (resto do arquivo 'audio_state.js' sem alterações) ...
 export function updateClipVolume(clipId, volume) {
   const clip = audioState.clips.find((c) => c.id == clipId);
   if (clip) {
@@ -132,5 +171,27 @@ export function updateClipPan(clipId, pan) {
 export function addAudioTrackLane() {
     const newTrackName = `Pista de Áudio ${audioState.tracks.length + 1}`;
     audioState.tracks.push({ id: Date.now(), name: newTrackName });
-    // A UI será re-renderizada a partir do main.js
+}
+
+export function removeAudioClip(clipId) {
+    const clipIndex = audioState.clips.findIndex(c => c.id == clipId);
+    if (clipIndex === -1) return false; // Retorna false se não encontrou
+
+    const clip = audioState.clips[clipIndex];
+
+    // 1. Limpa os nós de áudio do Tone.js
+    if (clip.gainNode) {
+        clip.gainNode.disconnect();
+        clip.gainNode.dispose();
+    }
+    if (clip.pannerNode) {
+        clip.pannerNode.disconnect();
+        clip.pannerNode.dispose();
+    }
+    
+    // 2. Remove o clipe do array de estado
+    audioState.clips.splice(clipIndex, 1);
+
+    // 3. Retorna true para o chamador (Controller)
+    return true;
 }