Referência da Classe Spectrum3D

#include <spectrum3D.hpp>

Membros Públicos
void	viewWaveform ()
	Visualiza a forma de onda do sinal de áudio. Mais...
void	viewWaveformFFT ()
	Visualiza a forma de onda com aplicação da FFT no sinal de áudio. Mais...
void	getWhellDelta (int w_delta)
void	run (std::function< void(std::vector< Float_Complex >, std::size_t)> handlePlot)
	Spectrum3D (std::shared_ptr< sf::RenderWindow > win, std::shared_ptr< HUD > hud, std::shared_ptr< FFT< sf::Int16 >> fft)

Atributos Protegidos
const glm::mat4	view_default_mat

Membros Privados
void	clear ()
	Limpa a tela. Mais...
void	initOpenGL ()
void	handleMouse ()
	Trata o movimento do mouse. Mais...
void	setupBuffers (GLuint &vao, GLuint &vbo, GLuint &ebo)
void	bindAndDraw (GLuint vao, GLuint vbo, GLuint ebo, std::vector< glm::vec3 > &vertices, std::vector< GLuint > &indices, GLenum mode)

Atributos Privados
std::shared_ptr< sf::RenderWindow >	window
std::shared_ptr< HUD >	hud_ptr
std::shared_ptr< FFT< sf::Int16 > >	fft_ptr
std::shared_ptr< Plane >	plane_ptr
std::shared_ptr< MobiusStrip >	mobius_ptr
std::shared_ptr< Timer >	timer_ptr
std::unique_ptr< Sample >	sample_ptr
glm::mat4	proj_mat
glm::mat4	view_wave_mat
glm::mat4	view_wff_mat
int	whell_delta
GLuint	vao_wave
GLuint	vbo_wave
GLuint	ebo_wave
std::shared_ptr< Shader >	shader_wave_ptr
GLuint	vao_fft
GLuint	vbo_fft
GLuint	ebo_fft
std::shared_ptr< Shader >	shader_wfft_ptr

Descrição detalhada

Esta classe renderiza a forma de onda e a FFT de um sinal de áudio.

A classe Spectrum3D utiliza bibliotecas externas como SFML, GLM e OpenGL para realizar a renderização gráfica da forma de onda e da FFT de um sinal de áudio fornecido. Ela também interage com outras classes como HUD, Spectrum e FFT para auxiliar na exibição e processamento dos dados.

Construtores e Destrutores

Spectrum3D()

Spectrum3D::Spectrum3D	(	std::shared_ptr< sf::RenderWindow >	win,
		std::shared_ptr< HUD >	hud,
		std::shared_ptr< FFT< sf::Int16 >>	fft
	)

Construtor da classe Spectrum3D.

• win: Ponteiro compartilhado para a janela renderizada pelo SFML.
• hud: Ponteiro compartilhado para a classe HUD.
• fft: Ponteiro compartilhado para a classe FFT.

    : window(win), hud_ptr(hud), fft_ptr(fft),
      plane_ptr(std::make_shared<Plane>(20.0f, 20.0f, 20)),
      mobius_ptr(std::make_shared<MobiusStrip>(8.0f, 6.0f, 10)),
      timer_ptr(std::make_shared<Timer>()),
      sample_ptr(std::make_unique<Sample>(hud)),
      proj_mat(
          glm::perspective(glm::radians(60.0f), 4.0f / 3.0f, 0.1f, 100.0f)),
      view_wave_mat(view_default_mat), view_wff_mat(view_default_mat) {
 
    glewExperimental = GL_TRUE;
    GLenum error = glewInit();
    if (error != GLEW_OK) {
        throw std::runtime_error(
            std::string("Error: ") +
            reinterpret_cast<const char *>(glewGetErrorString(error)));
    }
 
    if (!window->setActive()) {
        throw std::runtime_error("Failed to set window to active");
    }
 
    initOpenGL();
}

Funções membros

bindAndDraw()

void Spectrum3D::bindAndDraw ( GLuint  vao, GLuint  vbo, GLuint  ebo, std::vector< glm::vec3 > &  vertices, std::vector< GLuint > &  indices, GLenum  mode  )

private

Liga o buffer de vértices e o buffer de elementos (EBO) ao VAO especificado, e desenha a geometria utilizando o modo de desenho especificado.

vao: ID do Vertex Array Object (VAO) ao qual os buffers serão ligados. vbo: ID do Vertex Buffer Object (VBO) contendo os vértices a serem desenhados. vertices: Vetor contendo os vértices a serem carregados no VBO. ebo: ID do Element Buffer Object (EBO) contendo os índices de vértices a serem desenhados. indices: Vetor contendo os índices que especificam a ordem dos vértices. mode: Modo de desenho OpenGL (por exemplo, GL_TRIANGLES, GL_LINES, GL_POINTS).

                                                                      {
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(glm::vec3) * vertices.size(),
                    vertices.data());
 
    glBindVertexArray(vao);
 
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint) * indices.size(),
                 indices.data(), GL_STATIC_DRAW);
 
    glDrawElements(mode, indices.size(), GL_UNSIGNED_INT, 0);
 
    glBindVertexArray(0);
}

clear()

void Spectrum3D::clear ( )

private

Limpa a tela.

                       {
    glViewport(0, 0, window->getSize().x, window->getSize().y);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}

getWhellDelta()

void Spectrum3D::getWhellDelta

(

int

w_delta

)

Atualiza o delta do movimento da roda do mouse.

w_delta: Valor do delta do movimento da roda do mouse.

{ whell_delta = w_delta; }

handleMouse()

void Spectrum3D::handleMouse ( )

private

Trata o movimento do mouse.

                             {
    std::vector<bool> view_mode = {
        hud_ptr->option == 5,
        hud_ptr->option == 6,
    };
    static sf::Vector2i prev_pos;
    static bool first_click = true;
 
    if (sf::Mouse::isButtonPressed(sf::Mouse::Button::Left)) {
        sf::Vector2i curr_pos = sf::Mouse::getPosition();
        if (first_click) {
            prev_pos = curr_pos;
            first_click = false;
        } else {
            sf::Vector2i delta = curr_pos - prev_pos;
            float angle = atan2(delta.y, delta.x);
 
            if (view_mode[0]) {
                view_wff_mat = glm::rotate(view_wff_mat, glm::radians(angle),
                                           glm::vec3(1.0f, 1.0f, 0.0f));
            }
            if (view_mode[1]) {
                view_wave_mat = glm::rotate(view_wave_mat, glm::radians(angle),
                                            glm::vec3(1.0f, 1.0f, 0.0f));
            }
 
            prev_pos = curr_pos;
        }
    } else {
        first_click = true;
    }
 
    std::vector<float> zoom_factor = {0.5f, 0.5f};
    if (whell_delta != 0) {
        std::vector<float> zoom_amount = {
            1.0f + zoom_factor[0] * abs(whell_delta) / 10.0f,
            1.0f + zoom_factor[1] * abs(whell_delta) / 10.0f,
        };
 
        if (whell_delta > 0) {
            if (view_mode[1]) {
                view_wave_mat =
                    glm::scale(view_wave_mat, glm::vec3(zoom_amount[0]));
            } else if (view_mode[0]) {
                view_wff_mat =
                    glm::scale(view_wff_mat, glm::vec3(zoom_amount[1]));
            }
        } else if (whell_delta < 0) {
            if (view_mode[1]) {
                view_wave_mat =
                    glm::scale(view_wave_mat, glm::vec3(1.0f / zoom_amount[0]));
            } else if (view_mode[0]) {
                view_wff_mat =
                    glm::scale(view_wff_mat, glm::vec3(1.0f / zoom_amount[1]));
            }
        }
        whell_delta = 0;
    }
}

initOpenGL()

void Spectrum3D::initOpenGL ( )

private

Realiza a inicialização do OpenGL:

• Limpa o buffer de tela e define as configurações de profundidade e mistura.
• Carrega shaders para as formas de onda e FFT.
• Configura os buffers para desenho das geometrias.

                            {
    clear();
 
    glEnable(GL_DEPTH_TEST);
    glCullFace(GL_BACK);
    glEnable(GL_BLEND);
 
    glMatrixMode(GL_PROJECTION);
 
    shader_wave_ptr =
        std::make_shared<Shader>("./assets/shader/WaveSine.shader");
    shader_wfft_ptr =
        std::make_shared<Shader>("./assets/shader/WaveSineFFT.shader");
 
    setupBuffers(vao_wave, vbo_wave, ebo_wave);
    setupBuffers(vao_fft, vbo_fft, ebo_fft);
}

run()

void Spectrum3D::run

(

std::function< void(std::vector< Float_Complex >, std::size_t)>

handlePlot

)

Executa o loop principal da aplicação, renderizando a forma de onda ou FFT e chamando a função de callback para tratar os dados do plot.

handlePlot: Função callback para processar os dados do plot (forma de onda ou FFT).

                                                                       {
    sample_ptr->processStereoToMono();
    std::vector<Float_Complex> spectrum;
 
    if (hud_ptr->sound.getStatus() == sf::SoundSource::Playing) {
        sample_ptr->getSampleBuffer();
 
        std::size_t fft_size = 1;
        while (fft_size < buffer_size) {
            fft_size *= 2;
        }
 
        spectrum.resize(fft_size, 0);
 
        handlePlot(spectrum, fft_size);
    }
    std::this_thread::sleep_for(std::chrono::milliseconds(10));
}

setupBuffers()

void Spectrum3D::setupBuffers ( GLuint &  vao, GLuint &  vbo, GLuint &  ebo  )

private

Configuração inicial dos buffers: vao: ID do Vertex Array Object (VAO) ao qual os buffers serão ligados. vbo: ID do Vertex Buffer Object (VBO) contendo os vértices a serem desenhados. ebo: ID do Element Buffer Object (EBO) contendo os índices de vértices a serem desenhados.

                                                                   {
    glGenVertexArrays(1, &vao);
    glGenBuffers(1, &vbo);
    glGenBuffers(1, &ebo);
 
    glBindVertexArray(vao);
 
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferData(GL_ARRAY_BUFFER,
                 sizeof(glm::vec3) * plane_ptr->genVertices().size(), nullptr,
                 GL_DYNAMIC_DRAW);
 
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(glm::vec3),
                          (void *)0);
    glEnableVertexAttribArray(0);
 
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindVertexArray(0);
}

viewWaveform()

void Spectrum3D::viewWaveform

(

)

Visualiza a forma de onda do sinal de áudio.

                              {
    float time = timer_ptr->elapsed();
    float red = sin(time) * 0.5f + 0.5f;
    float green = 0.5f;
    float blue = cos(time) * 0.5f + 0.5f;
 
    shader_wave_ptr->bind();
    shader_wave_ptr->setUniform4f("uColor", glm::vec4(red, green, blue, 1.0f));
 
    glm::mat4 view_mat_wave = view_default_mat;
 
    handleMouse();
 
    glm::mat4 mvp = proj_mat * view_mat_wave * view_wave_mat;
 
    float angle = time * glm::radians(90.0f);
    glm::mat4 rotationMatrix =
        glm::rotate(glm::mat4(1.0f), angle, glm::vec3(0.0f, 1.0f, 0.0f));
 
    mvp *= rotationMatrix;
 
    shader_wave_ptr->setUniformMat4f("uMVP", mvp);
 
    std::vector<GLuint> indices = mobius_ptr->genIndices();
    std::vector<glm::vec3> vertices = mobius_ptr->genVertices();
 
    for (std::size_t i = 0; i < vertices.size(); ++i) {
        sf::Int16 sample_value = hud_ptr->sample_buffer[i % buffer_size];
        GLfloat amplitude =
            std::abs(static_cast<float>(sample_value)) / 32767.f;
        GLfloat t = hud_ptr->sound_buffer.getDuration().asSeconds();
 
        GLfloat frequency = (t != 0) ? 1 / t : 1;
        GLfloat wave_speed = 0.5f;
        GLfloat phase = wave_speed * t;
        GLfloat w = 2 * pi * frequency;
 
        glm::vec3 &vertex = vertices[i];
        vertex.y += (4.5f * amplitude) * std::sin(w * (vertex.x + phase));
        vertex.y += (2.0f * amplitude) * std::cos(w * (vertex.x * phase));
    }
 
    bindAndDraw(vao_wave, vbo_wave, ebo_wave, vertices, indices, GL_LINE_STRIP);
 
    shader_wave_ptr->unbind();
}

viewWaveformFFT()

void Spectrum3D::viewWaveformFFT

(

)

Visualiza a forma de onda com aplicação da FFT no sinal de áudio.

                                 {
    float time = timer_ptr->elapsed();
    float red = sin(time) * 0.5f + 0.5f;
    float green = cos(time) * 0.5f + 0.5f;
    float blue = 0.5f;
 
    shader_wfft_ptr->bind();
    shader_wfft_ptr->setUniform4f("uColor", glm::vec4(red, green, blue, 1.0f));
 
    glm::mat4 view_mat_fft = view_default_mat;
 
    handleMouse();
 
    glm::mat4 mvp = proj_mat * view_mat_fft * view_wff_mat;
 
    float angle = time * glm::radians(90.0f);
    glm::mat4 rotationMatrix =
        glm::rotate(glm::mat4(1.0f), angle, glm::vec3(0.0f, 1.0f, 0.0f));
 
    mvp *= rotationMatrix;
 
    shader_wfft_ptr->setUniformMat4f("uMVP", mvp);
 
    std::vector<GLuint> indices = plane_ptr->genIndices();
    std::vector<glm::vec3> vertices = plane_ptr->genVertices();
 
    for (std::size_t i = 0; i < vertices.size(); ++i) {
        sf::Int16 sample_value = hud_ptr->sample_buffer[i % buffer_size];
        GLfloat amplitude =
            std::abs(static_cast<float>(sample_value)) / 32767.f;
        GLfloat t = hud_ptr->sound_buffer.getDuration().asSeconds();
 
        glm::vec3 &vertex = vertices[i];
        GLfloat distance = std::sqrt(vertex.x * vertex.x + vertex.z * vertex.z);
        GLfloat frequency = (t != 0) ? 1 / t : 1;
 
        GLfloat current_time = t - distance;
        GLfloat w = 2 * pi * frequency;
        vertex.y = (4.5f * amplitude) * std::cos(w + current_time);
    }
 
    bindAndDraw(vao_fft, vbo_fft, ebo_fft, vertices, indices, GL_LINE_STRIP);
 
    shader_wfft_ptr->unbind();
}

Atributos

ebo_fft

GLuint Spectrum3D::ebo_fft

private

ebo_wave

GLuint Spectrum3D::ebo_wave

private

fft_ptr

std::shared_ptr<FFT<sf::Int16> > Spectrum3D::fft_ptr

private

hud_ptr

std::shared_ptr<HUD> Spectrum3D::hud_ptr

private

mobius_ptr

std::shared_ptr<MobiusStrip> Spectrum3D::mobius_ptr

private

plane_ptr

std::shared_ptr<Plane> Spectrum3D::plane_ptr

private

proj_mat

glm::mat4 Spectrum3D::proj_mat

private

sample_ptr

std::unique_ptr<Sample> Spectrum3D::sample_ptr

private

shader_wave_ptr

std::shared_ptr<Shader> Spectrum3D::shader_wave_ptr

private

shader_wfft_ptr

std::shared_ptr<Shader> Spectrum3D::shader_wfft_ptr

private

timer_ptr

std::shared_ptr<Timer> Spectrum3D::timer_ptr

private

vao_fft

GLuint Spectrum3D::vao_fft

private

vao_wave

GLuint Spectrum3D::vao_wave

private

vbo_fft

GLuint Spectrum3D::vbo_fft

private

vbo_wave

GLuint Spectrum3D::vbo_wave

private

view_default_mat

const glm::mat4 Spectrum3D::view_default_mat

protected

Valor inicial:

=
        glm::lookAt(glm::vec3(0.0f, 3.0f, 12.0f), glm::vec3(0.0f, 1.5f, 0.0f),
                    glm::vec3(0.0f, 1.0f, 0.0f))

view_wave_mat

glm::mat4 Spectrum3D::view_wave_mat

private

view_wff_mat

glm::mat4 Spectrum3D::view_wff_mat

private

whell_delta

int Spectrum3D::whell_delta

private

window

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

private

---

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

• spectrum3D.hpp
• setup.cpp
• spectrum3D.cpp
• Spectrum3D/waves_sine.cpp