Referência da Classe Render

#include <render.hpp>

Membros Públicos
void	run ()
	Render ()
	~Render ()

Membros Privados
void	handlePlot (std::vector< Float_Complex > spectrum, std::size_t fft_size)
void	frameRate (time_point< high_resolution_clock > &prev_time)

Atributos Privados
const int	FPS = 60
const double	frame_duration = 1.0 / FPS
sf::Clock	clock
std::shared_ptr< sf::RenderWindow >	window
std::shared_ptr< sf::VideoMode >	desktop
std::shared_ptr< HUD >	hud_ptr
std::shared_ptr< Spectrum >	spectrum_ptr
std::shared_ptr< FFT< sf::Int16 > >	fft_ptr
std::shared_ptr< Spectrum3D >	spectrum3D_ptr

Descrição detalhada

Classe responsável pela renderização do programa.

A classe Render é responsável por inicializar a janela principal, gerenciar objetos como HUD, Spectrum e Spectrum3D, processar eventos, controlar a taxa de quadros e realizar a renderização do espectro de áudio de acordo com a opção selecionada na HUD.

Construtores e Destrutores

Render()

Render::Render

(

)

Construtor da classe Render.

Esta função inicializa os principais objetos usados pela classe Render:

• window: Janela principal da aplicação.
• desktop: Modo de exibição do desktop.
• hud_ptr: Ponteiro compartilhado para a instância da classe HUD.
• fft_ptr: Ponteiro compartilhado para a instância da classe FFT.
• spectrum_ptr: Ponteiro compartilhado para a instância da classe Spectrum.
• spectrum3D_ptr: Ponteiro compartilhado para a instância da classe Spectrum3D.

    : window(std::make_shared<sf::RenderWindow>(
          sf::VideoMode(WIDTH, HEIGHT), "Music Spectrum",
          sf::Style::Titlebar | sf::Style::Close)),
      desktop(
          std::make_shared<sf::VideoMode>(sf::VideoMode::getDesktopMode())) {
 
    window->setPosition(
        sf::Vector2i(desktop->width / 2.f - window->getSize().x / 2.f,
                     desktop->height / 2.f - window->getSize().y / 2.f));
 
    hud_ptr = std::make_shared<HUD>(window);
    fft_ptr = std::make_shared<FFT<sf::Int16>>();
    spectrum_ptr = std::make_shared<Spectrum>(window, hud_ptr, fft_ptr);
    spectrum3D_ptr = std::make_shared<Spectrum3D>(window, hud_ptr, fft_ptr);
}

~Render()

Render::~Render

(

)

{ ImGui_ImplOpenGL3_Shutdown(); }

Funções membros

frameRate()

void Render::frameRate ( time_point< high_resolution_clock > &  prev_time )

private

Ajuste da taxa de quadros.

Esta função controla a taxa de quadros da aplicação para manter uma renderização suave. Ela calcula o tempo decorrido desde o último frame e, se for menor que a duração desejada, coloca a thread em espera por um determinado tempo para garantir a taxa de quadros.

prev_time: Referência para o tempo do frame anterior.

                                                                   {
    auto current_time = high_resolution_clock::now();
    auto elapsed_time =
        duration_cast<duration<double>>(current_time - prev_time);
 
    if (elapsed_time.count() < frame_duration) {
        auto sleep_duration =
            duration<double>(frame_duration - elapsed_time.count());
        std::this_thread::sleep_for(
            duration_cast<milliseconds>(sleep_duration));
    }
 
    prev_time = high_resolution_clock::now();
}

handlePlot()

void Render::handlePlot ( std::vector< Float_Complex >  spectrum, std::size_t  fft_size  )

private

Processa o plot de acordo com a opção selecionada na HUD.

A função verifica a opção selecionada na HUD e chama o método apropriado do objeto spectrum_ptr ou spectrum3D_ptr para visualizar o espectro ou a forma de onda.

spectrum: Um vetor de números complexos que representam o espectro.

fft_size: O tamanho da transformada de Fourier rápida (FFT).

                                            {
    switch (hud_ptr->option) {
    case 1:
        fft_ptr->fftAnalyze(hud_ptr->sample_buffer, 1, spectrum, fft_size);
        spectrum_ptr->viewWaveformFFT();
        break;
    case 2:
        spectrum_ptr->viewWaveform();
        break;
    case 3:
        fft_ptr->fftAnalyze(hud_ptr->sample_buffer, 1, spectrum, fft_size);
        spectrum_ptr->viewWaveformRectFFT();
        break;
    case 4:
        spectrum_ptr->viewWaveformRect();
        break;
    case 5:
        fft_ptr->fftAnalyze(hud_ptr->sample_buffer, 1, spectrum, fft_size);
        spectrum3D_ptr->viewWaveformFFT();
        break;
    case 6:
        spectrum3D_ptr->viewWaveform();
        break;
    default:
        break;
    }
}

run()

void Render::run

(

)

Loop principal da aplicação.

Esta função é o loop principal da aplicação e é responsável por:

• Gerenciar eventos da janela e da HUD.
• Chamar os métodos run de HUD, Spectrum e Spectrum3D para realizar a atualização e renderização.
• Controlar a taxa de quadros da aplicação.

                 {
    ImGui_ImplOpenGL3_Init();
    window->setVerticalSyncEnabled(true);
    auto prev_time = high_resolution_clock::now();
 
    while (window->isOpen()) {
        sf::Event event;
        while (window->pollEvent(event)) {
            ImGui::SFML::ProcessEvent(event);
 
            switch (event.type) {
            case sf::Event::Closed:
                window->close();
                break;
            case sf::Event::KeyPressed:
                hud_ptr->handleEvents(event);
                break;
            case sf::Event::MouseWheelMoved:
                spectrum3D_ptr->getWhellDelta(event.mouseWheel.delta);
                break;
            default:
                break;
            }
        }
 
        ImGui::SFML::Update(*window, clock.restart());
 
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        window->clear();
 
        ImGui_ImplOpenGL3_NewFrame();
 
        hud_ptr->run();
        window->pushGLStates();
        spectrum_ptr->run(std::bind(&Render::handlePlot, this,
                                    std::placeholders::_1,
                                    std::placeholders::_2));
        window->popGLStates();
 
        spectrum3D_ptr->run(std::bind(&Render::handlePlot, this,
                                      std::placeholders::_1,
                                      std::placeholders::_2));
 
        ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
 
        window->display();
 
        frameRate(prev_time);
    }
}

Atributos

clock

sf::Clock Render::clock

private

desktop

std::shared_ptr<sf::VideoMode> Render::desktop

private

fft_ptr

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

private

FPS

const int Render::FPS = 60

private

frame_duration

const double Render::frame_duration = 1.0 / FPS

private

hud_ptr

std::shared_ptr<HUD> Render::hud_ptr

private

spectrum3D_ptr

std::shared_ptr<Spectrum3D> Render::spectrum3D_ptr

private

spectrum_ptr

std::shared_ptr<Spectrum> Render::spectrum_ptr

private

window

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

private

---

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

• render.hpp
• plot.cpp
• render.cpp