RotationBounds.h

#pragma once
#include <NDEVR/Model.h>
#include <NDEVR/ShapeConstructors.h>
#include <NDEVR/Effect.h>
#include <NDEVR/Geometry.h>
#include <NDEVR/Material.h>
#include <NDEVR/Scene.h>
#include <NDEVR/Translator.h>
#if NDEVR_GRIPS
namespace NDEVR
{
    class RotationBounds : public Model
    {
    public:
        RotationBounds(const Model& model)
            : Model(model)
        {
            if (!is<NDPN::type>(TypeName()))
            {
                setChildApplicationConstructed();
                m_vertical_rotation_grip = createChild();
                m_horizontal_rotation_grip = createChild();
                set<NDPN::type>(TypeName());
                set<NDPO::tree_visible>(false);
                set<NDPO::is_application_owned>(true);
                set<NDPO::application_locked>(true);
                set<NDPN::can_select_children>(true);
                Effect effect = createChildEffect();
                effect.setupAsBoundingBox(*this);
                setupRotationGrips(m_vertical_rotation_grip, 0);
                setupRotationGrips(m_horizontal_rotation_grip, 1);
            }
            else
            {
                m_vertical_rotation_grip   = getChild(0);
                m_horizontal_rotation_grip = getChild(1);
            }
        }

        void attachTo(const Model& model)
        {
            Effect effect = getEffect();
            if (effect.targetCount() < 2 || effect.getTarget(1) != model)
                effect.setupAsBoundingBox(*this, model);
            else
                effect.activate();
        }

        void setupRotationGrips(Model& grip, uint01 index)
        {
            grip.set<NDPOC::name>(_t("Rotate"));
            grip.set<NDPN::type>("rotation_grip");
            grip.set<NDPN::can_select_children>(true);
            Scene scene(grip.getScene());
            Geometry circle = ShapeConstructors::StaticCircleOutline(scene);
            Matrix<fltp08> matrix = Matrix<fltp08>::RotationMatrix(Angle<fltp08>(DEGREES, 90.0), IndexTangent(index));
            grip.set<NDPO::transform>(matrix);
            grip.setGeometryChild(circle);
            grip.set<NDPO::bounds_ignored>(true);
            BitFlag flag(0);
            //flag(ParentMatrixFlags::e_scale_to_camera, true);
            flag(ParentMatrixFlags::e_ignore_scale_distortion, true);
            grip.setParentMatrixFlags(flag);
            grip.update<NDPO::spacial_visible>(false);
            grip.updateModifiedTime();
 
            Material material = grip.createChildMaterial();
            material.setUVMode(UVType::e_KD, Material::UVMode::e_solid_color);
            switch (index)
            {
            case X: material.setUVColor(UVType::e_KD, RGBColor(255, 0, 0)); break;
            case Y: material.setUVColor(UVType::e_KD, RGBColor(0, 255, 0)); break;
            case Z: material.setUVColor(UVType::e_KD, RGBColor(0, 0, 255)); break;
            }
 
            material.set<NDPM::shading_model>(Material::ShadingModel::e_flat);
            material.set<NDPM::override_camera_material>(true);
            material.set<NDPM::wireframe>(true);
            material.set<NDPM::pixel_thickness>(10.0);
            material.set<NDPO::tree_visible>(false);
            material.updateModifiedTime();
            grip.updateModifiedTime();
        }

        static constexpr StringView TypeName()
        {
            return "rotation_bounds_model";
        }

        static Ray<3, fltp08> IndexNormal(uint04 index)
        {
            switch (index)
            {
            case 0: return Ray<3, fltp08>(1.0, 0.0, 0.0);
            case 1: return Ray<3, fltp08>(0.0, 1.0, 0.0);
            default:
                lib_assert(false, "Bad index normal");
                return Ray<3, fltp08>(0, 0, 1);
            }
        }

        static Ray<3, fltp08> IndexTangent(uint04 index)
        {
            switch (index)
            {
            case 0: return Ray<3, fltp08>(0.0, 1.0, 0.0);
            case 1: return Ray<3, fltp08>(1.0, 0.0, 0.0);
            default:
                lib_assert(false, "Bad index normal");
                return Ray<3, fltp08>(0, 0, 1);
            }
        }
    protected:
        Model m_vertical_rotation_grip;   
        Model m_horizontal_rotation_grip;  
    };
}
#endif