RotationBounds.h

Go to the documentation of this file.

#pragma once
#include <NDEVR/Model.h>
#include <NDEVR/ShapeConstructors.h>
#include <NDEVR/Effect.h>
#include <NDEVR/Geometry.h>
#include <NDEVR/Material.h>
#include <NDEVR/Translator.h>
#if NDEVR_GRIPS
namespace NDEVR
{
    /**--------------------------------------------------------------------------------------------------
    \brief A Model which provides rotational grips to a model.
    *-----------------------------------------------------------------------------------------------**/
    class RotationBounds : public Model
    {
    public:
        RotationBounds(const Model& model)
            : Model(model)
        {
            if (!isOfType(TypeName()))
            {
                setModelProperty(Model::e_application_constructed, true);
                m_vertical_rotation_grip = createChild();
                m_horizontal_rotation_grip = createChild();
                setModelProperty(Model::e_type, TypeName());
                setProperty(DesignObject::e_tree_visible, false);
                setProperty(DesignObject::e_is_application_owned, true);
                setProperty(DesignObject::e_is_application_locked, true);
                setModelProperty(Model::e_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.numberOfTargets() < 2 || effect.getTarget(1) != model)
                effect.setupAsBoundingBox(*this, model);
            else
                effect.activate();
        }
 
        void setupRotationGrips(Model& grip, uint01 index)
        {
            grip.setProperty(DesignObject::e_name, _t("Rotate"));
            grip.setModelProperty(Model::e_type, "rotation_grip");
            grip.setModelProperty(Model::e_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.setTransform(matrix);
            grip.setGeometryChild(circle);
            grip.setProperty(Model::e_bounds_ignored, true);
            BitFlag flag(0);
            //flag(ParentMatrixFlags::e_scale_to_camera, true);
            flag(ParentMatrixFlags::e_ignore_scale_distortion, true);
            grip.setParentMatrixFlags(flag);
            grip.updateVisible(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));
            case Y: material.setUVColor(UVType::e_KD, RGBColor(0, 255, 0));
            case Z: material.setUVColor(UVType::e_KD, RGBColor(0, 0, 255));
            }
            
            material.setShadingModel(Material::ShadingModel::e_flat);
            material.setMaterialProperty(Material::e_override_camera_material, true);
            material.setMaterialProperty(Material::e_wireframe, true);
            material.setMaterialProperty(Material::e_pixel_thickness, 10.0);
            material.setProperty(Material::e_tree_visible, false);
            material.updateModifiedTime();
            grip.updateModifiedTime();
        }
        static constexpr const char* 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