Referência da Classe HUD

#include <hud.hpp>

Membros Públicos
void	run ()
void	handleEvents (sf::Event &event)
	HUD (std::shared_ptr< sf::RenderWindow > win)
	~HUD ()

Atributos Públicos
int	option = 3
sf::Sound	sound
sf::SoundBuffer	sound_buffer
std::vector< sf::Int16 >	sample_buffer

Membros Privados
void	initFont ()
void	audioList ()
void	modeAudio ()
void	initTexture ()
void	styleWidget ()
void	drawAudioHUD ()
void	controlAudio ()
void	openFileDialog ()
void	showAudioListWindow ()
void	skipForward ()
void	skipBackward ()
void	playNextAudio ()
void	resetControls ()
void	toggleMusicMute ()
void	playPreviousAudio ()
void	toggleMusicPlayback ()
void	setSoundBuffer (const std::string &filename)

Atributos Privados
const float	icon_size = 17.0f
int	fftMode = 0
int	spectrumMode = 0
float	volume = 10.f
bool	isMuted = false
bool	isPlaying = false
bool	audioListWindow = false
std::size_t	selectedIndex = 0
std::vector< std::string >	list_audio
sf::Texture	play_tex
sf::Texture	pause_tex
sf::Texture	stop_tex
sf::Texture	forward_tex
sf::Texture	backward_tex
sf::Texture	previous_tex
sf::Texture	next_tex
sf::Texture	mute_tex
sf::Texture	volume_tex
std::shared_ptr< sf::RenderWindow >	window

Descrição detalhada

Classe que representa a interface gráfica do usuário (GUI) para interagir com arquivos de áudio.

A classe HUD (Heads-Up Display) gerencia a interface gráfica do usuário para interação com arquivos de áudio. Ela fornece controles para reproduzir, pausar, avançar, retroceder, ajustar volume, exibir e selecionar arquivos de áudio, entre outras funcionalidades.

Construtores e Destrutores

HUD()

HUD::HUD

(

std::shared_ptr< sf::RenderWindow >

win

)

Construtor da classe HUD.

Inicializa a interface gráfica do usuário (GUI) utilizando a biblioteca ImGui. Carrega a fonte e as texturas necessárias.

win: Um ponteiro compartilhado para uma janela RenderWindow do SFML.

                                          : window(win) {
    if (!ImGui::SFML::Init(*window, false)) {
        throw std::runtime_error("Error when Initializing RenderWindow!");
    }
    styleWidget();
 
    initFont();
 
    initTexture();
 
    sample_buffer.reserve(buffer_size);
}

~HUD()

HUD::~HUD

(

)

Destrutor da classe HUD.

{ ImGui::SFML::Shutdown(); }

Funções membros

audioList()

void HUD::audioList ( )

private

Função para exibir a lista de áudio disponível

                    {
    for (auto item = 0UL; item < list_audio.size(); ++item) {
        const bool isSelected = (selectedIndex == item);
 
        std::size_t lastSlash = list_audio[item].find_last_of('/');
        std::string filename = list_audio[item].substr(lastSlash + 1);
 
        if (ImGui::Selectable(filename.c_str(), isSelected)) {
            selectedIndex = item;
            setSoundBuffer(list_audio[selectedIndex]);
        }
    }
}

controlAudio()

void HUD::controlAudio ( )

private

Função para exibir controles de reprodução de áudio

                       {
    ImGui::Text("Audio");
    ImGui::Spacing();
    if (ImGui::ImageButton(!isPlaying ? play_tex : pause_tex,
                           sf::Vector2f(icon_size, icon_size))) {
        toggleMusicPlayback();
    }
    ImGui::SameLine();
    if (ImGui::ImageButton(previous_tex, sf::Vector2f(icon_size, icon_size))) {
        playPreviousAudio();
    }
    ImGui::SameLine();
    if (ImGui::ImageButton(backward_tex, sf::Vector2f(icon_size, icon_size))) {
        skipBackward();
    }
    ImGui::SameLine();
    if (ImGui::ImageButton(stop_tex, sf::Vector2f(icon_size, icon_size))) {
        sound.stop();
        isPlaying = false;
    }
    ImGui::SameLine();
    if (ImGui::ImageButton(forward_tex, sf::Vector2f(icon_size, icon_size))) {
        skipForward();
    }
    ImGui::SameLine();
    if (ImGui::ImageButton(next_tex, sf::Vector2f(icon_size, icon_size))) {
        playNextAudio();
    }
    ImGui::Spacing();
    ImGui::Spacing();
    if (ImGui::ImageButton(isMuted ? mute_tex : volume_tex,
                           sf::Vector2f(icon_size + 3, icon_size + 3))) {
        toggleMusicMute();
    }
    ImGui::SameLine();
    if (ImGui::SliderFloat(" ", &volume, 0.f, 100.f, "%.0f")) {
        volume += 0.f;
        volume = std::max(0.f, std::min(100.f, volume));
        sound.setVolume(volume);
    }
}

drawAudioHUD()

void HUD::drawAudioHUD ( )

private

handleEvents()

void HUD::handleEvents

(

sf::Event &

event

)

Trata os eventos de entrada da janela SFML.

Esta função trata os eventos de teclado da janela SFML, respondendo a diferentes teclas para controlar a reprodução de áudio, ajustar o volume, pular faixas e fechar a janela.

event: Referência ao objeto sf::Event que contém informações sobre o evento.

                                     {
    switch (event.key.code) {
    case sf::Keyboard::Space:
        toggleMusicPlayback();
        break;
    case sf::Keyboard::M:
        toggleMusicMute();
        break;
    case sf::Keyboard::Escape:
        window->close();
        break;
    case sf::Keyboard::Left:
        skipBackward();
        break;
    case sf::Keyboard::Right:
        skipForward();
        break;
    case sf::Keyboard::Period:
        playNextAudio();
        break;
    case sf::Keyboard::Comma:
        playPreviousAudio();
        break;
    case sf::Keyboard::Enter: {
        sound.stop();
        isPlaying = false;
        break;
    }
    case sf::Keyboard::Up: {
        volume += 10.f;
        volume > 100.f ? volume = 100.f : 0;
        sound.setVolume(volume);
        break;
    }
    case sf::Keyboard::Down: {
        volume -= 10.f;
        volume < .0f ? volume = 0.f : 0;
        sound.setVolume(volume);
        break;
    }
    default:
        break;
    }
}

initFont()

void HUD::initFont ( )

private

Função de inicialização da fonte da interface

                   {
    ImGui::GetIO().Fonts->Clear();
    ImGui::GetIO().Fonts->AddFontFromFileTTF("./assets/font/Roboto-Regular.ttf",
                                             18.f);
    if (!ImGui::SFML::UpdateFontTexture()) {
        throw std::runtime_error("Update Font Texture");
    }
}

initTexture()

void HUD::initTexture ( )

private

Função de inicialização dos icones

                      {
    if (!play_tex.loadFromFile("./assets/img/icon/botao-play.png")) {
        throw std::invalid_argument("Error Loading Texture Play");
    }
    if (!pause_tex.loadFromFile("./assets/img/icon/pausa.png")) {
        throw std::invalid_argument("Error Loading Texture Pause");
    }
    if (!stop_tex.loadFromFile("./assets/img/icon/pare.png")) {
        throw std::invalid_argument("Error Loading Texture Stop");
    }
    if (!forward_tex.loadFromFile("./assets/img/icon/avanco-rapido.png")) {
        throw std::invalid_argument("Error Loading Texture Forward");
    }
    if (!backward_tex.loadFromFile("./assets/img/icon/retroceder.png")) {
        throw std::invalid_argument("Error Loading Texture Backward");
    }
    if (!previous_tex.loadFromFile("./assets/img/icon/costas.png")) {
        throw std::invalid_argument("Error Loading Texture Previous");
    }
    if (!next_tex.loadFromFile("./assets/img/icon/proximo.png")) {
        throw std::invalid_argument("Error Loading Texture Next");
    }
    if (!mute_tex.loadFromFile("./assets/img/icon/mudo.png")) {
        throw std::invalid_argument("Error Loading Texture Mute");
    }
    if (!volume_tex.loadFromFile("./assets/img/icon/volume.png")) {
        throw std::invalid_argument("Error Loading Texture Volume");
    }
}

modeAudio()

void HUD::modeAudio ( )

private

Função para exibir opções de modo de áudio

                    {
    ImGui::Text("Mode");
    ImGui::Spacing();
 
    ImGui::RadioButton("NoFFT", &fftMode, 0);
    ImGui::SameLine();
    ImGui::RadioButton("FFT", &fftMode, 1);
    ImGui::Spacing();
    ImGui::RadioButton("Spectrum", &spectrumMode, 1);
    ImGui::SameLine();
    ImGui::RadioButton("Oscillation", &spectrumMode, 0);
    ImGui::SameLine();
    ImGui::RadioButton("Oscillation3D", &spectrumMode, 2);
 
    if (fftMode == 0) {
        switch (spectrumMode) {
        case 0:
            option = 2;
            break;
        case 1:
            option = 4;
            break;
        case 2:
            option = 6;
            break;
        default:
            break;
        }
    } else if (fftMode == 1) {
        switch (spectrumMode) {
        case 0:
            option = 1;
            break;
        case 1:
            option = 3;
            break;
        case 2:
            option = 5;
            break;
        default:
            break;
        }
    }
}

openFileDialog()

void HUD::openFileDialog ( )

private

Implementação para abrir a caixa de diálogo e lidar com a seleção de arquivos de áudio

                         {
    ImVec2 dialog_maxsize = ImVec2(HUD_WIDTH * 2.f, HUD_HEIGHT * 2.f);
    ImGui::Text("Select Audio File");
 
    if (ImGui::Button("Select File")) {
        const char *filter = "Audio File (*.flac,*.wav){.flac,.wav}";
        IGFD::FileDialogConfig config;
        config.path = "../audio";
        config.sidePaneWidth = 450.0f;
 
        ImGuiFileDialog::Instance()->OpenDialog("ChooseFileDlgKey",
                                                "Choose File", filter, config);
    }
 
    if (ImGuiFileDialog::Instance()->Display("ChooseFileDlgKey",
                                             ImGuiWindowFlags_NoCollapse |
                                                 ImGuiWindowFlags_NoResize,
                                             dialog_maxsize, dialog_maxsize)) {
        if (ImGuiFileDialog::Instance()->IsOk()) {
            std::string filePathName =
                ImGuiFileDialog::Instance()->GetFilePathName();
            if (list_audio.empty()) {
                setSoundBuffer(filePathName);
            }
 
            auto it =
                std::find(list_audio.begin(), list_audio.end(), filePathName);
            if (it == list_audio.end()) {
                list_audio.push_back(filePathName);
            } else {
                setSoundBuffer(filePathName);
            }
        }
 
        ImGuiFileDialog::Instance()->Close();
    }
}

playNextAudio()

void HUD::playNextAudio ( )

private

Função para reproduzir a próxima faixa de áudio na lista

                        {
    if (!list_audio.empty()) {
        selectedIndex = (selectedIndex + 1) % list_audio.size();
        setSoundBuffer(list_audio[selectedIndex]);
        toggleMusicPlayback();
    }
}

playPreviousAudio()

void HUD::playPreviousAudio ( )

private

Função para reproduzir a faixa anterior de áudio na lista

                            {
    if (!list_audio.empty()) {
        selectedIndex =
            (selectedIndex - 1 + list_audio.size()) % list_audio.size();
        setSoundBuffer(list_audio[selectedIndex]);
        toggleMusicPlayback();
    }
}

resetControls()

void HUD::resetControls ( )

private

Função para resetar os controles de reprodução de áudio

                        {
    isPlaying = false;
    isMuted = false;
    volume = 10.f;
    sound.stop();
    sound.setVolume(volume);
}

run()

void HUD::run

(

)

Executa o loop principal da interface gráfica.

              {
    ImGui::Begin("Audio HUD", nullptr,
                 ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove);
    ImGui::SetWindowPos(ImVec2(0, 0));
    ImGui::SetWindowSize(ImVec2(HUD_WIDTH, HUD_HEIGHT));
 
    ImGui::PushFont(ImGui::GetIO().Fonts->Fonts[0]);
 
    ImGui::Separator();
    openFileDialog();
 
    ImGui::SameLine();
 
    showAudioListWindow();
 
    ImGui::Spacing();
    ImGui::Separator();
    ImGui::Spacing();
 
    controlAudio();
 
    ImGui::Spacing();
    ImGui::Separator();
    ImGui::Spacing();
 
    modeAudio();
 
    ImGui::PopFont();
    ImGui::End();
 
    ImGui::SFML::Render(*window);
}

setSoundBuffer()

void HUD::setSoundBuffer ( const std::string &  filename )

private

Define o buffer de som a partir de um arquivo de áudio.

filename: O caminho do arquivo de áudio.

                                                  {
    sound_buffer.loadFromFile(filename);
    sound.setBuffer(sound_buffer);
    resetControls();
}

showAudioListWindow()

void HUD::showAudioListWindow ( )

private

Função para exibir a janela de lista de áudio

                              {
    if (ImGui::Button("Show Audio List")) {
        audioListWindow = !audioListWindow;
    }
 
    if (audioListWindow) {
        ImGui::Begin("Audio List", nullptr,
                     ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove);
        ImGui::SetWindowPos(ImVec2(HUD_WIDTH + 10, 0));
        ImGui::SetWindowSize(ImVec2(HUD_WIDTH, HUD_HEIGHT - 100));
 
        audioList();
 
        ImGui::End();
    }
}

skipBackward()

void HUD::skipBackward ( )

private

Função para retroceder a reprodução de áudio

                       {
    sf::Time currentOffset = sound.getPlayingOffset();
    sf::Time newOffset = currentOffset - sf::seconds(10.0f);
    sound.setPlayingOffset(newOffset);
}

skipForward()

void HUD::skipForward ( )

private

Função para avançar a reprodução de áudio

                      {
    sf::Time currentOffset = sound.getPlayingOffset();
    sf::Time newOffset = currentOffset + sf::seconds(10.0f);
    sound.setPlayingOffset(newOffset);
}

styleWidget()

void HUD::styleWidget ( )

private

Função para estilizar os elementos do ImGui

                      {
    ImGuiStyle &style = ImGui::GetStyle();
    // Window
    style.WindowRounding = 5.3f;
    style.FrameRounding = 2.3f;
    style.ScrollbarRounding = 0;
 
    style.Colors[ImGuiCol_Text] = ImVec4(0.9f, 0.9f, 0.9f, 0.9f);
    style.Colors[ImGuiCol_TextDisabled] = ImVec4(0.6f, 0.6f, 0.6f, 1.0f);
    style.Colors[ImGuiCol_WindowBg] = ImVec4(0.3f, 0.3f, 0.3f, 0.3f);
    style.Colors[ImGuiCol_Border] = ImVec4(0.3f, 0.3f, 0.3f, 0.3f);
    style.Colors[ImGuiCol_FrameBg] = ImVec4(0.0f, 0.0f, 0.1f, 1.0f);
    style.Colors[ImGuiCol_FrameBgHovered] = ImVec4(0.9f, 0.8f, 0.8f, 0.4f);
    style.Colors[ImGuiCol_FrameBgActive] = ImVec4(0.9f, 0.6f, 0.6f, 0.4f);
    style.Colors[ImGuiCol_TitleBg] = ImVec4(0.0f, 0.0f, 0.0f, 0.8f);
    style.Colors[ImGuiCol_TitleBgActive] = ImVec4(0.1f, 0.1f, 0.1f, 0.8f);
    // Botões
    style.Colors[ImGuiCol_Button] = ImVec4(0.16f, 0.16f, 0.16f, 0.0f);
    style.Colors[ImGuiCol_ButtonHovered] = ImVec4(0.16f, 0.16f, 0.16f, 0.5f);
    style.Colors[ImGuiCol_ButtonActive] = ImVec4(0.31f, 0.28f, 0.28f, 1.0f);
    // Slider
    style.Colors[ImGuiCol_SliderGrab] = ImVec4(0.70f, 0.70f, 0.70f, 0.62f);
    style.Colors[ImGuiCol_SliderGrabActive] =
        ImVec4(0.30f, 0.30f, 0.30f, 0.84f);
    // RadioButton
    style.Colors[ImGuiCol_CheckMark] = ImVec4(0.90f, 0.90f, 0.90f, 0.83f);
    // Header
    style.Colors[ImGuiCol_Header] = ImVec4(0.12f, 0.12f, 0.12f, 1.0f);
    style.Colors[ImGuiCol_HeaderHovered] = ImVec4(0.24f, 0.24f, 0.24f, 1.0f);
    style.Colors[ImGuiCol_HeaderActive] = ImVec4(0.31f, 0.31f, 0.31f, 1.0f);
}

toggleMusicMute()

void HUD::toggleMusicMute ( )

private

Função que alterna o estado de mudo do áudio

                          {
    isMuted = !isMuted;
    sound.setVolume(isMuted ? 0.f : volume);
}

toggleMusicPlayback()

void HUD::toggleMusicPlayback ( )

private

Função que alterna a reprodução de áudio

                              {
    if (isPlaying) {
        sound.pause();
        isPlaying = false;
    } else {
        sound.play();
        sound.setVolume(volume);
        isPlaying = true;
    }
}

Atributos

audioListWindow

bool HUD::audioListWindow = false

private

backward_tex

sf::Texture HUD::backward_tex

private

fftMode

int HUD::fftMode = 0

private

forward_tex

sf::Texture HUD::forward_tex

private

icon_size

const float HUD::icon_size = 17.0f

private

isMuted

bool HUD::isMuted = false

private

isPlaying

bool HUD::isPlaying = false

private

list_audio

std::vector<std::string> HUD::list_audio

private

mute_tex

sf::Texture HUD::mute_tex

private

next_tex

sf::Texture HUD::next_tex

private

option

int HUD::option = 3

pause_tex

sf::Texture HUD::pause_tex

private

play_tex

sf::Texture HUD::play_tex

private

previous_tex

sf::Texture HUD::previous_tex

private

sample_buffer

std::vector<sf::Int16> HUD::sample_buffer

selectedIndex

std::size_t HUD::selectedIndex = 0

private

sound

sf::Sound HUD::sound

sound_buffer

sf::SoundBuffer HUD::sound_buffer

spectrumMode

int HUD::spectrumMode = 0

private

stop_tex

sf::Texture HUD::stop_tex

private

volume

float HUD::volume = 10.f

private

volume_tex

sf::Texture HUD::volume_tex

private

window

std::shared_ptr<sf::RenderWindow> HUD::window

private

---

A documentação para essa classe foi gerada a partir dos seguintes arquivos:

• hud.hpp
• events.cpp
• hud.cpp
• ui.cpp