box_render_data_base.h

#pragma once
 
#include "render_data_base.h"
 
namespace cgv {
namespace render {
 
template <class RendererType, class RenderStyleType, typename ColorType = rgb>
class box_render_data_base : public render_data_base<RendererType, RenderStyleType, ColorType> {
private:
    // Base class we're going to use virtual functions from
    typedef render_data_base<RendererType, RenderStyleType, ColorType> super;
 
protected:
    bool transfer(context& ctx, RendererType& r) override {
        if(super::transfer(ctx, r)) {
            CGV_RDB_TRANSFER_ARRAY(extent, extents);
            CGV_RDB_TRANSFER_ARRAY(translation, translations);
            CGV_RDB_TRANSFER_ARRAY(rotation, rotations);
            return true;
        }
        return false;
    }
 
public:
    std::vector<vec3> extents;
    std::vector<vec3> translations;
    std::vector<quat> rotations;
 
    void clear() {
        super::clear();
        extents.clear();
        translations.clear();
        rotations.clear();
    }
 
    void add_extent(const vec3& extent) {
        extents.push_back(extent);
    }
 
    void add_translation(const vec3& translation) {
        translations.push_back(translation);
    }
 
    void add_rotation(const quat& rotation) {
        rotations.push_back(rotation);
    }
 
    // Explicitly use add from the base class since it is shadowed by the overloaded versions
    using super::add;
 
    void add(const vec3& position, const vec3& extent) {
        super::add_position(position);
        add_extent(extent);
    }
 
    void add(const vec3& position, const vec3& extent, const quat& rotation) {
        super::add_position(position);
        add_extent(extent);
        add_rotation(rotation);
    }
 
    void add(const vec3& position, const vec3& extent, const ColorType& color) {
        add(position, extent);
        super::add_color(color);
    }
 
    void add(const vec3& translation, const quat& rotation) {
        add_translation(translation);
        add_rotation(rotation);
    }
 
    void fill_extents(const vec3& extent) {
        super::fill(extents, extent);
    }
 
    void fill_translations(const vec3& translation) {
        super::fill(translations, translation);
    }
 
    void fill_rotations(const quat& rotation) {
        super::fill(rotations, rotation);
    }
};
 
}
}