gee_path.h

Go to the documentation of this file.

/* -*- C++ -*- */

/* COPYRIGHT
 *
 * This file is part of the Visual Effects Engine - VEE
 *
 * Read the "VEE-LICENSE" file for the license.
 *
 * Authors & Copyright:   
 *
 * Tommi Ilmonen, Tuukka Heikura, Marko Myllymaa and 
 * Janne Kontkanen 2001-2004
 *
 * Additional copyrights: Tekes 2003-2004
 *
 * firstname.lastname@hut.fi
 *
 */

#ifndef GEE_PATH_H
#define GEE_PATH_H

#include <gee_geometry.h>
#include <gee_param_writer.h>

#include <vee_bounding_box.h>
#include <vee_math.h>
#include <vee_matrix3.h>
#include <vee_vector3.h>

#include <map>
#include <strings.h>


class GEE_PathVertex3D
{
public:
  GEE_PathVertex3D(const VEE_Vector3 &loc = VEE_Vector3ZERO,
       const VEE_Matrix3 &rot = VEE_Matrix3IDENTITY,
       float time = 0.0f)
    : m_location(loc), m_rotation(rot), m_time(time)
  {
    bzero(m_tips, sizeof(m_tips));
  }

  void clear() { m_location.clear(); m_rotation.identity(); }

  float edgesLength() const
  {
    return (m_tips[2] - m_tips[1]).length() + 
      (m_tips[1] - m_tips[0]).length() + 
      (m_tips[2] - m_tips[0]).length();
  }

  float calculateToolRadius(float radiusBase, 
          float radiusNorm, 
          float exaggerate) const
  {
    float r = edgesLength();
    float rel = r / radiusNorm;    
    float boost = pow(rel, exaggerate);
    return boost * r * radiusBase;
  }

  VEE_Vector3 calculateLinearMix(const VEE_Vector3 & inValue,
         float mixRatio,
         const VEE_Vector3 & origin,
         float minSpan,
         float maxSpan) const
  {
    VEE_Vector3 res;

    float amplitude = maxSpan - minSpan;

    for(int i = 0; i <3; i++) {
      float d = ((origin - m_tips[i]).length() - minSpan) / amplitude;

      d = VEE_clamp(d, 0.0f, 1.0f) - 0.5f;

      res[i] = VEE_clamp(inValue[i] + d * mixRatio, 0.0f, 1.0f);
    }

    return res;
  }
  
  VEE_Vector3 tipAverage() const 
  { return (m_tips[0] + m_tips[1] + m_tips[2]) * 0.333333333333333333f; }

  VEE_Vector3 calculateToolCenter() const
  { return m_location + m_rotation * tipAverage(); }

  bool operator == (const GEE_PathVertex3D &that) const
  {
    return m_location == that.m_location && m_rotation == that.m_rotation;    
  }

  bool read(GEE_Io *);
  bool write(GEE_Io *);

  VEE_Vector3 & tip(int index) { return m_tips[index]; }

  VEE_Vector3 m_location;
  VEE_Matrix3 m_rotation;
  float       m_time;

  VEE_Vector3 m_tips[3];
};


class GEE_Path3D : public GEE_Geometry
{
public:

  typedef std::map<int, GEE_PathVertex3D> container;
  typedef container::iterator iterator;
  typedef container::const_iterator const_iterator;

  GEE_Path3D();
  virtual ~GEE_Path3D();
  
  static GEE_Geometry * create();
  virtual GEE_Geometry * clone() const;
  virtual bool intersects(GEE_Containment *);

  virtual bool getBoundingBox(VEE_BoundingBox *);
  virtual void render(GEE_Renderer *);

  virtual bool read(const char *);
  virtual bool write(const char *);
  virtual bool read(GEE_Io *);
  virtual bool write(GEE_Io *);

  void addVertex(const GEE_PathVertex3D &v);

  void addVertex(int index, const GEE_PathVertex3D &v) 
  { 
    m_vertices[index++] = v; 
    m_bbox.expand(v.m_location); 
    if(m_counter < index) m_counter = index; 
  }

  void addVertex(float time,
     const VEE_Vector3 &loc,
     const VEE_Matrix3 &rot) 
  { 
    m_vertices[m_counter++] = GEE_PathVertex3D(loc, rot, time);
    m_bbox.expand(loc);
  }

  void addVertex(const VEE_Vector3 &loc,
     const VEE_Matrix3 &rot) 
  { 
    float t = endTime() + 1.0f;
    m_vertices[m_counter++] = GEE_PathVertex3D(loc, rot, t);
    m_bbox.expand(loc);
  }

  iterator begin() { return m_vertices.begin(); }
  iterator end()   { return m_vertices.end(); }
  iterator lower_bound(int index) { return m_vertices.lower_bound(index); }

  const_iterator begin() const { return m_vertices.begin(); }
  const_iterator end()   const { return m_vertices.end(); }

  uint vertexCount() const { return m_vertices.size(); }
  int counter() const { return m_counter; }

  bool activeNapra() const { return m_activeNapra; }
  void setActiveNapra(bool isActive) { m_activeNapra = isActive; }

  void clear() { m_vertices.clear(); }

  static int getIndex(iterator & it) 
  { return (*it).first; }
  static float getTime(iterator & it) 
  { return (*it).second.m_time; }
  static GEE_PathVertex3D & getVertex(iterator & it) 
  { return (*it).second; }
  static VEE_Vector3 & getVertexLocation(iterator & it) 
  { return (*it).second.m_location; }
  static VEE_Matrix3 & getVertexRotation(iterator & it) 
  { return (*it).second.m_rotation; }

  float beginTime() 
  { 
    if(!m_vertices.size()) 
      return 0.0f; 
    return (*m_vertices.begin()).second.m_time; 
  }

  float endTime() 
  { 
    if(!m_vertices.size()) 
      return 0.0f; 
    return (*(--m_vertices.end())).second.m_time; 
  }

  void create3DSpiral(int rounds = 3, 
          int segmentsPerRound = 6, 
          float secondsPerRound = 2.0,
          float initialRadius = 2.0,
          float depth = 2.0);

  bool operator == (const GEE_Path3D &that) const;

protected:
  container m_vertices;
  int m_counter;

  bool m_activeNapra;
  GEE_ParamWriter m_writer;

  VEE_BoundingBox m_bbox;
};

#endif

---