scene_Slider.cpp

Go to the documentation of this file.

#include "scene_Slider.hpp"
#include "opengl.hpp"
#include <iostream>

Slider::Slider()
: mEnabled(true)
, mDrag(false)
, mAxis(AXIS_X)
, mUpAxis(AXIS_Z)
, mAbsMode(ABSMODE_POSITIVE)
, mMin(0)
, mMax(1.0)
, mColor(1.0,1.0,1.0,0.8)
, mBGColor(0.0,0.0,0.0,0.5)
, mKnobType(KNOB_STRETCH)
{
  setBorder(0.02);
  setPosition( Point3d(0,0,0) );
}

bool Slider::hit(const Rayd& ray, double& t)
{
  mDrag = false;
  if (mEnabled)
  {
    unsigned int numHits;
    double t0,t1;

    if ( intersect( mAABoxControl, ray, numHits, t0, t1) )
    {
      if (numHits == 2)
      {
        t = (t0 < t1) ? t0 : t1;
        
        // t = (t0+t1)*0.5;
        return true;
      }
    }
  }
  return false;
}

bool Slider::select(const Rayd& ray, SceneView& view)
{
  mDrag = false;
  if (mEnabled)
  {
    unsigned int numHits;
    double t0,t1;
    if ( intersect( mAABoxControl, ray, numHits, t0, t1) )
    {
      if (numHits == 2)
      {
        mDrag = true;

        Point3d hitp = ray.getOrigin() + (t0+t1)*0.5*ray.getDir();
        double value = hitp[mAxis] - mPosition[mAxis];

        setValue(value);

        // initialize drag plane

        
        Point3d p0   = mPosition;
        p0[mUpAxis]  = 0;
        Point3d p1   = p0;
        p1[mAxis]   += 1;
        Point3d p2   = p1;
        p2[mUpAxis]  = 1;
        
        /*

        Vec3d d = ray.getDir();
        Vec3d up;
        up[mUpAxis] = 1;

        Vec3d side = makeCross(d,up);

        Point3d p0 = mPosition;
        p0[mUpAxis] = 0;
        Point3d p1 = p0 + up;
        Point3d p2 = p0 + side;
        */

        mDragPlane = Planed(p0,p1,p2);
        return true;
      }
      else
      {
        std::cout << "numHits " << numHits << "\n";
      }
    }
  }
  return false;
}

bool Slider::drag(const Rayd& ray, SceneView& view)
{
  if (mEnabled)
  {
    if (mDrag)
    {
      double t;
      if ( intersect(mDragPlane, ray, t) )
      {
        Point3d hitp = ray.getOrigin() + t*ray.getDir();
        double value = hitp[mAxis] - mPosition[mAxis];
        setValue(value);
      }
      return true;
    }
  }
  return false;
}

void Slider::setValue(double v)
{
  if (mAbsMode == ABSMODE_MIRROR)
  {
    v = abs(v);
  }
  mValue = clamp(v, mMin,mMax);

  if (mSlotValueChange)
    mSlotValueChange(mValue);
}

void Slider::updateSensorVolume()
{
  Point3d pMin = mPosition;
  pMin[(mAxis+1)%3] -= mBorder;
  pMin[(mAxis+2)%3] -= mBorder;
  Point3d pMax = mPosition;
  pMax[(mAxis+1)%3] += mBorder;
  pMax[(mAxis+2)%3] += mBorder;

  pMax[mAxis] += mMax;  
  
  if (mAbsMode == ABSMODE_MIRROR)
  {
    pMin[mAxis] -= mMax;
  }
  else
  {
    pMin[mAxis] =  mMin;
  }

  mAABoxControl.setMin( pMin );
  mAABoxControl.setMax( pMax );
}

void Slider::setBorder(double border)
{
  mBorder = border;
  updateSensorVolume();
}

void Slider::setPosition(const Point3d& p)
{
  mPosition = p;
  updateSensorVolume();
}

void Slider::display()
{
  if (mEnabled)
  {
    // display layer

    glPushAttrib(GL_ENABLE_BIT);
    glDisable(GL_DEPTH_TEST);
    glDisable(GL_ALPHA_TEST);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);


    // draw sensor volume

    gl_set_color(mBGColor);

    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    glTranslated(mPosition[0],mPosition[1],mPosition[2]);

    Point3d s(mBorder,mBorder,mBorder);
    // s[mAxis] = (mMax-mMin)*2;
    s[mAxis] = (mMax-mMin);

    glPushMatrix();
    glScaled(s[0],s[1],s[2]);
    glutSolidCube(1);
    glPopMatrix();

    // draw knob

    // glEnable(GL_LIGHTING);
    // glEnable(GL_DEPTH_TEST);

    GLfloat pointDiffuse[4] = { mColor[0], mColor[1], mColor[2], mColor[3] };
    // GLfloat pointAmbient[4] = { 0.2, 0.2, 0.2, 1.0 };
    GLfloat pointAmbient[4] = { 0.0, 0.0, 0.0, 1.0 };
    glMaterialfv(GL_FRONT, GL_DIFFUSE, pointDiffuse);
    glMaterialfv(GL_FRONT, GL_AMBIENT, pointAmbient);


    gl_set_color(mColor);

    Point3d t;
    t[mAxis] = mValue;

    switch(mKnobType)
    {
    case KNOB_TRANSLATE:
      {
        Point3d t;
        t[mAxis] = mValue;
        glTranslated(t[0],t[1],t[2]);
        glutSolidSphere(mBorder, 32, 16);
      }
      break;
    case KNOB_STRETCH:
      {
        switch(mAbsMode)
        {
        case ABSMODE_POSITIVE:
          {
            Point3d s(mBorder,mBorder,mBorder);
            s[mAxis] = mValue*0.5;
            Point3d t;
            t[mAxis] = mValue*0.5;
            glScaled(s[0],s[1],s[2]);
            glTranslated(t[0],t[1],t[2]);
          }
          break;
        case ABSMODE_MIRROR:
          {
            Point3d s(mBorder,mBorder,mBorder);
            s[mAxis] = mValue*2;
            glScaled(s[0],s[1],s[2]);
          }
          break;
        }
        glutSolidCube(1.0);
    
      }
      break;
    }

    glPopMatrix();
  
    glPopAttrib();
  }
}