render.h

Go to the documentation of this file.

 
#ifndef NNGN_RENDER_RENDER_H
#define NNGN_RENDER_RENDER_H
 
#include <unordered_set>
#include <vector>
 
#include "lua/table.h"
#include "utils/flags.h"
 
#include "model.h"
#include "renderers.h"
 
namespace nngn {
 
struct Colliders;
struct Graphics;
class Fonts;
class Grid;
class Lighting;
class Map;
class Textures;
class Textbox;
 
class Renderers {
public:
    enum Debug : u8 {
        DEBUG_RENDERERS = 1u << 0,
        DEBUG_CIRCLE = 1u << 1,
        DEBUG_BB = 1u << 2,
        DEBUG_LIGHT = 1u << 3,
        DEBUG_DEPTH = 1u << 4,
        DEBUG_ALL = (1u << 5) - 1,
    };
    // Initialization
    void init(
        Textures *t, const Fonts *f, const Textbox *tb, const Grid *g,
        const Colliders *c, const Lighting *l, const Map *map);
    // Configuration
    auto debug(void) const { return *this->m_debug; }
    bool perspective(void) const;
    bool zsprites(void) const { return this->flags.is_set(Flag::ZSPRITES); }
    auto max_sprites(void) const { return this->sprites.capacity(); }
    auto max_screen_sprites(void) const;
    auto max_translucent(void) const { return this->translucent.capacity(); }
    auto max_cubes(void) const { return this->cubes.capacity(); }
    auto max_voxels(void) const { return this->voxels.capacity(); }
    std::size_t n(void) const;
    std::size_t n_sprites(void) const { return this->sprites.size(); }
    std::size_t n_screen_sprites(void) const { return this->sprites.size(); }
    std::size_t n_translucent(void) const { return this->translucent.size(); }
    std::size_t n_cubes(void) const { return this->cubes.size(); }
    std::size_t n_voxels(void) const { return this->voxels.size(); }
    bool selected(const Renderer *p) const;
    void set_debug(Debug d);
    void set_perspective(bool p);
    void set_zsprites(bool z);
    bool set_max_sprites(std::size_t n);
    bool set_max_screen_sprites(std::size_t n);
    bool set_max_translucent(std::size_t n);
    bool set_max_cubes(std::size_t n);
    bool set_max_voxels(std::size_t n);
    bool set_max_text(std::size_t n);
    bool set_max_colliders(std::size_t n);
    bool set_graphics(Graphics *g);
    // Operations
    Renderer *load(nngn::lua::table_view t);
    void remove(Renderer *p);
    void add_selection(const Renderer *p);
    void remove_selection(const Renderer *p);
    bool update(void);
private:
    bool update_renderers(
        bool sprites_updated, bool screen_sprites_updated,
        bool translucent_updated, bool models_updated, bool cubes_updated,
        bool voxels_updated);
    bool update_debug(
        bool sprites_updated, bool screen_sprites_updated, bool cubes_updated,
        bool voxels_updated);
    enum Flag : u16 {
        SPRITES_UPDATED = 1u << 0,
        SCREEN_SPRITES_UPDATED = 1u << 1,
        TRANSLUCENT_UPDATED = 1u << 2,
        CUBES_UPDATED = 1u << 3,
        VOXELS_UPDATED = 1u << 4,
        MODELS_UPDATED = 1u << 5,
        DEBUG_UPDATED = 1u << 6,
        SELECTION_UPDATED = 1u << 7,
        PERSPECTIVE = 1u << 8,
        ZSPRITES = 1u << 9,
    };
    Flags<Flag> flags = {};
    Flags<Debug> m_debug = {};
    Textures *textures = nullptr;
    Graphics *graphics = nullptr;
    const Fonts *fonts = nullptr;
    const Textbox *textbox = nullptr;
    const Grid *grid = nullptr;
    const Colliders *colliders = nullptr;
    const Lighting *lighting = nullptr;
    const Map *map = nullptr;
    std::vector<SpriteRenderer> sprites = {};
    std::vector<SpriteRenderer> screen_sprites = {};
    std::vector<SpriteRenderer> translucent = {};
    std::vector<CubeRenderer> cubes = {};
    std::vector<VoxelRenderer> voxels = {};
    std::vector<ModelRenderer> models = {};
    std::unordered_set<const Renderer*> selections = {};
    u32
        translucent_vbo = {}, translucent_ebo = {},
        sprite_vbo = {}, sprite_ebo = {},
        sprite_debug_vbo = {}, sprite_debug_ebo = {},
        screen_sprite_vbo = {}, screen_sprite_ebo = {},
        screen_sprite_debug_vbo = {}, screen_sprite_debug_ebo = {},
        model_vbo = {}, model_ebo = {},
        cube_vbo = {}, cube_ebo = {},
        cube_debug_vbo = {}, cube_debug_ebo = {},
        voxel_vbo = {}, voxel_ebo = {},
        voxel_debug_vbo = {}, voxel_debug_ebo = {},
        text_vbo = {}, text_ebo = {},
        textbox_vbo = {}, textbox_ebo = {},
        selection_vbo = {}, selection_ebo = {},
        aabb_vbo = {}, aabb_ebo = {},
        aabb_circle_vbo = {}, aabb_circle_ebo = {},
        bb_vbo = {}, bb_ebo = {},
        bb_circle_vbo = {}, bb_circle_ebo = {},
        sphere_vbo = {}, sphere_ebo = {},
        lights_vbo = {}, lights_ebo = {},
        range_vbo = {}, range_ebo = {},
        depth_vbo = {}, depth_ebo = {},
        depth_cube_vbo = {}, depth_cube_ebo = {};
};
 
inline bool Renderers::perspective(void) const {
    return this->flags.is_set(Flag::PERSPECTIVE);
}
 
inline auto Renderers::max_screen_sprites(void) const {
    return this->screen_sprites.capacity();
}
 
inline bool Renderers::selected(const Renderer *p) const {
    return this->selections.find(p) != cend(this->selections);
}
 
}
 
#endif