al_Pickable.hpp

#ifndef __PICKABLE_HPP__
#define __PICKABLE_HPP__
 
#include <vector>
 
#include "al/graphics/al_Graphics.hpp"
#include "al/math/al_Ray.hpp"
#include "al/ui/al_BoundingBox.hpp"
#include "al/ui/al_Parameter.hpp"
#include "al/ui/al_ParameterBundle.hpp"
 
namespace al {
 
enum PickEventType {
  Point,
  Pick,
  PickPose,
  Unpick,
  Drag,
  TranslateRay,
  RotateRay,
  RotateRayTrackball,
  RotateTurntable,
  RotatePose,
  Scale
};
 
struct PickEvent {
  PickEventType type;
  Rayd ray;
  Pose pose;
  Vec3f vec;
  float amount;
 
  PickEvent(PickEventType t, Rayd r) : type(t), ray(r) {}
  PickEvent(PickEventType t, Rayd r, Pose p) : type(t), ray(r), pose(p) {}
  PickEvent(PickEventType t, Rayd r, Vec3f v) : type(t), ray(r), vec(v) {}
  PickEvent(PickEventType t, Rayd r, Pose p, Vec3f v) : type(t), ray(r), pose(p), vec(v) {}
  PickEvent(PickEventType t, Rayd r, float v) : type(t), ray(r), amount(v) {}
  PickEvent(PickEventType t, Pose p) : type(t), pose(p) {}
  PickEvent(PickEventType t, float v) : type(t), amount(v) {}
};
 
struct Pickable;
 
struct Hit {
  bool hit;
  Rayd ray;
  double t;
  Pickable *p;
 
  Hit() : hit(false) {}
  Hit(bool h, Rayd r, double tt, Pickable *pp) : hit(h), ray(r), t(tt), p(pp) {}
  Vec3d operator()() { return hit ? ray(t) : Vec3d(); }
};
 
struct Pickable {
  std::string name;
 
  ParameterBool hover{"hover", name}, selected{"selected", name};
  ParameterPose pose{"pose", name};
  ParameterVec3 scaleVec{"scaleVec", name};
  Parameter scale{"scale", name, 1.0f, "", 0.0f, 10.0f};
  ParameterBundle bundle{"pickable"};
 
  Pickable *parent = nullptr;
  std::vector<Pickable *> children;
  bool testChildren = true;
  bool containChildren = false;
  bool containedChild = false;
  int depth = 0;
 
  // initial values, and previous values
  Pose pose0, prevPose;
  Vec3f scale0, prevScale;
 
  Pickable();
 
  virtual ~Pickable() {}
 
  virtual Hit intersect(Rayd r) = 0;
  virtual Hit intersect(Vec3d v) { return intersect(Rayd(v, Vec3d())); }
 
  virtual bool onEvent(PickEvent e, Hit hit) { return false; }
 
  virtual bool event(PickEvent e);
 
  void clearSelection();
 
  bool intersects(Rayd &r) { return intersect(r).hit; }
  bool intersectsChild(Rayd &r);
 
  Hit intersectChildren(Rayd &r);
 
  void addChild(Pickable &pickable);
  void addChild(Pickable *p) { addChild(*p); }
 
  inline void pushMatrix(Graphics &g) {
    g.pushMatrix();
    g.translate(pose.get().pos());
    g.rotate(pose.get().quat());
    g.scale(scaleVec.get());
  }
  inline void popMatrix(Graphics &g) { g.popMatrix(); }
 
  void draw(Graphics &g,
            std::function<void(Pickable &p)> f = [](Pickable &p) {});
 
  void foreach (std::function<void(Pickable &p)> pre,
                std::function<void(Pickable &p)> post = [](Pickable & /*p*/) {
                }) {
    pre(*this);
    for (auto *c : children) c->foreach (pre, post);
    post(*this);
  }
 
  Rayd transformRayLocal(const Rayd &ray);
  Vec3f transformVecWorld(const Vec3f &v, float w = 1);
  Vec3f transformVecLocal(const Vec3f &v, float w = 1);
};
 
struct PickableBB : Pickable {
  Mesh *mesh{nullptr};  // pointer to mesh that is wrapped
  BoundingBox bb;       // original bounding box
  BoundingBox aabb;  // axis aligned bounding box (after pose/scale transforms)
 
  // used for moving pickable naturally
  Vec3f selectPos;
  Vec3f selectOffset;
  Quatf selectQuat;
  float selectDist;
 
  PickableBB(std::string name_ = "") {
    Pickable::name = name_;
    bundle.name(name_);
  }
  PickableBB(Mesh &m) { set(m); }
 
  void set(Mesh &m);
 
  Hit intersect(Rayd r);
  // bool contains(Vec3d v){ auto p = transformVecLocal(v); return
  // bb.contains(p); }
 
  bool onEvent(PickEvent e, Hit h);
 
  void drawMesh(Graphics &g);
 
  void drawBB(Graphics &g);
 
  void setCenter(Vec3f &pos);
 
  void setQuat(Quatf &q);
 
  double intersectBB(Rayd localRay);
 
  double intersectAABB(Rayd ray);
 
  float intersectBoundingSphere(Rayd ray);
 
  void updateAABB();
};
 
}  // namespace al
 
#endif