render_data_base.h

#pragma once
 
#include <cgv/data/optional.h>
 
#include "renderer.h"
 
#define CGV_RDB_TRANSFER_ARRAY(NAME, DATA) \
if(DATA.size() == super::size()) \
    r.set_##NAME##_array(ctx, DATA); \
else if(DATA.empty()) \
    r.remove_##NAME##_array(ctx);
 
namespace cgv {
namespace render {
 
template <class RendererType, class RenderStyleType, typename ColorType = rgb>
class render_data_base {
private:
    bool state_out_of_date = true;
    attribute_array_manager attribute_array;
 
protected:
    virtual RendererType& ref_renderer_singleton(context& ctx, int ref_count_change = 0) = 0;
 
    virtual bool transfer(context& ctx, RendererType& r) {
        state_out_of_date = false;
 
        // The positions array determines the amount of stored vertices.
        // All other arrays except indices must match its size.
        if(!positions.empty()) {
            r.set_position_array(ctx, positions);
            if(colors.size() == size())
                r.set_color_array(ctx, colors);
            else if(colors.empty())
                r.remove_color_array(ctx);
 
            //if(colors.size() == size())
            //  r.set_color_array(ctx, colors);
            if(!indices.empty())
                r.set_indices(ctx, indices);
            else
                r.remove_indices(ctx);
            return true;
        } else {
            // If no positions are set the render data is assumed to be empty. In this case the
            // attribute array manager is destructed and reinitialized to clear the GPU buffers.
            if(attribute_array.is_created()) {
                attribute_array.destruct(ctx);
                attribute_array.init(ctx);
            }
            // Return false since the attribute array manager holds no data anymore.
            return false;
        }
    }
 
    virtual void set_const_attributes(context& ctx, RendererType& r) {
        if(colors.empty() && const_color)
            r.set_color(ctx, const_color.value());
    }
 
    template<typename T>
    void fill(std::vector<T>& vector, const T& value) {
        if(vector.size() < size())
            vector.resize(size(), value);
    }
 
public:
    RenderStyleType style;
 
    std::vector<uint32_t> indices;
    std::vector<vec3> positions;
    std::vector<ColorType> colors;
    cgv::data::optional<ColorType> const_color;
 
    size_t size() {
        return positions.size();
    }
 
    bool empty() const {
        return positions.empty();
    }
 
    void clear() {
        indices.clear();
        positions.clear();
        colors.clear();
 
        state_out_of_date = true;
    }
 
    void set_out_of_date() {
        state_out_of_date = true;
    }
 
    size_t render_count() {
        if(indices.empty())
            return positions.size();
        else
            return indices.size();
    }
 
    const attribute_array_manager& ref_attribute_array_manager() const {
        return attribute_array;
    }
 
    bool init(context& ctx) {
        ref_renderer_singleton(ctx, 1);
        return attribute_array.init(ctx);
    }
 
    void destruct(context& ctx) {
        ref_renderer_singleton(ctx, -1);
        attribute_array.destruct(ctx);
    }
 
    void early_transfer(context& ctx, RendererType& r) {
        r.enable_attribute_array_manager(ctx, this->attribute_array);
        if(this->state_out_of_date)
            transfer(ctx, r);
        r.disable_attribute_array_manager(ctx, this->attribute_array);
    }
 
    bool enable(context& ctx, RendererType& r, const RenderStyleType& s) {
        if(this->size() > 0) {
            r.set_render_style(s);
            r.enable_attribute_array_manager(ctx, this->attribute_array);
 
            if(this->state_out_of_date)
                transfer(ctx, r);
            this->set_const_attributes(ctx, r);
 
            return r.validate_and_enable(ctx);
        } else if(this->state_out_of_date) {
            early_transfer(ctx, r);
        }
        return false;
    }
 
    bool disable(context& ctx, RendererType& r) {
        bool res = r.disable(ctx);
        r.disable_attribute_array_manager(ctx, this->attribute_array);
        return res;
    }
 
    void draw(context& ctx, renderer& r, unsigned offset = 0, int count = -1) {
        size_t draw_count = render_count();
        offset = std::min(offset, static_cast<unsigned>(draw_count));
        draw_count = std::min(offset + (count < 0 ? draw_count : count), draw_count) - offset;
 
        r.draw(ctx, offset, draw_count);
    }
 
    void render(context& ctx, unsigned offset = 0, int count = -1) {
        render(ctx, ref_renderer_singleton(ctx), style, offset, count);
    }
 
    void render(context& ctx, const RenderStyleType& s, unsigned offset = 0, int count = -1) {
        render(ctx, ref_renderer_singleton(ctx), s, offset, count);
    }
 
    void render(context& ctx, RendererType& r, unsigned offset = 0, int count = -1) {
        render(ctx, r, style, offset, count);
    }
 
    void render(context& ctx, RendererType& r, const RenderStyleType& s, unsigned offset = 0, int count = -1) {
        if(enable(ctx, r, s)) {
            this->draw(ctx, r, offset, count);
            this->disable(ctx, r);
        }
    }
 
    void add_index(const uint32_t index) {
        indices.push_back(index);
    }
 
    void add_position(const vec3& position) {
        positions.push_back(position);
    }
 
    void add_color(const ColorType& color) {
        colors.push_back(color);
    }
 
    void add(const vec3& position, const ColorType& color) {
        add_position(position);
        add_color(color);
    }
 
    void fill_colors(const ColorType& color) {
        fill(colors, color);
    }
};
 
}
}