include/division_engine/canvas/state.hpp - master - d.vision/division_engine_cpp

include/division_engine/canvas/state.hpp
87 строк2 KB
den163
Added advanced texture settings
03 дек 2024, 13:51
03 дек 2024, 13:51b256e8d
#pragma once

#include "division_engine/canvas/components/render_texture.hpp"
#include "division_engine/color.hpp"
#include "division_engine/core/context.hpp"
#include "division_engine_core/types/texture.h"
#include "render_queue.hpp"

#include <chrono>
#include <ctime>

#include <division_engine_core/types/id.h>

#include <flecs.h>
#include <glm/vec4.hpp>
#include <optional>

namespace division_engine::canvas
{

struct State
{
public:
    flecs::world world;
    glm::vec4 clear_color;

    core::Context context;
    DivisionId screen_size_uniform_id;
    DivisionId white_texture_id;
    flecs::entity_t white_texture_batch;
    std::optional<flecs::entity_t> selected_id;
    RenderQueue render_queue;

private:
    glm::vec2 _prev_screen_size;
    size_t _frame_count;
    bool _screen_size_changed;

public:
    State(State&) = delete;
    State operator=(State&) = delete;
    State(State&&) = delete;
    State& operator=(State&&) = delete;
    ~State() = default;

    explicit State(DivisionContext* ctx_ptr, const glm::vec4& clear_color = color::BLACK)
      : clear_color(clear_color)
      , context(ctx_ptr)
      , screen_size_uniform_id(context.create_uniform<glm::vec2>())
      , white_texture_id(context.create_texture(
            core::TextureSettings(
                { 1, 1 },
                DivisionTextureFormat::DIVISION_TEXTURE_FORMAT_RGBA32Uint
            )
                .with_min_mag_filter(
                    DIVISION_TEXTURE_MIN_MAG_FILTER_NEAREST,
                    DIVISION_TEXTURE_MIN_MAG_FILTER_NEAREST
                )
        ))
      , white_texture_batch(world.entity().set(components::RenderTexture { white_texture_id }))
      , _prev_screen_size(glm::vec2 { 0 })
      , _frame_count(0)
      , _screen_size_changed(true)
    {
        const uint32_t RGBA32_WHITE_PIXEL = 0xFF'FF'FF'FF;
        context.set_texture_data(
            white_texture_id,
            reinterpret_cast<const uint8_t*>(&RGBA32_WHITE_PIXEL) // NOLINT
        );
    }

    void update()
    {
        const auto screen_size = context.get_screen_size();
        auto screen_uniform_data = context.get_uniform_data<glm::vec2>(screen_size_uniform_id);
        *screen_uniform_data.data_ptr = screen_size;

        _screen_size_changed = screen_size != _prev_screen_size;
        _prev_screen_size = screen_size;

        _frame_count++;
    }

    bool screen_size_changed() const { return _screen_size_changed; }
    size_t frame_count() const { return _frame_count; }
};
}