SceneObject.h

Go to the documentation of this file.

/********************************************************************
**                Image Component Library (ICL)                    **
**                                                                 **
** Copyright (C) 2006-2013 CITEC, University of Bielefeld          **
**                         Neuroinformatics Group                  **
** Website: www.iclcv.org and                                      **
**          http://opensource.cit-ec.de/projects/icl               **
**                                                                 **
** File   : ICLGeom/src/ICLGeom/SceneObject.h                      **
** Module : ICLGeom                                                **
** Authors: Christof Elbrechter                                    **
**                                                                 **
**                                                                 **
** GNU LESSER GENERAL PUBLIC LICENSE                               **
** This file may be used under the terms of the GNU Lesser General **
** Public License version 3.0 as published by the                  **
**                                                                 **
** Free Software Foundation and appearing in the file LICENSE.GPL  **
** included in the packaging of this file.  Please review the      **
** following information to ensure the license requirements will   **
** be met: http://www.gnu.org/licenses/lgpl-3.0.txt                **
**                                                                 **
** The development of this software was supported by the           **
** Excellence Cluster EXC 277 Cognitive Interaction Technology.    **
** The Excellence Cluster EXC 277 is a grant of the Deutsche       **
** Forschungsgemeinschaft (DFG) in the context of the German       **
** Excellence Initiative.                                          **
**                                                                 **
********************************************************************/

#pragma once

#ifndef HAVE_OPENGL
#warning "this header must not be included if HAVE_OPENGL is not defined"
#else

#include <ICLUtils/Mutex.h>
#include <ICLGeom/Primitive.h>
#include <ICLGeom/ViewRay.h>
#include <ICLGeom/Hit.h>
#include <ICLQt/GLFragmentShader.h>

namespace icl{
  namespace geom{
  
    class Scene;


    class SceneObject{
      public:
      
      friend class Scene;
      
      SceneObject();
      

      SceneObject(const std::string &type,const float *params);
      
      static inline SceneObject *cube(float x, float y, float z, float r){
        const float p[] = { x,y,z,r };
        return new SceneObject("cube",p);
      }
  
      static inline SceneObject *cuboid(float x, float y, float z, float dx, float dy, float dz){
        const float p[] = { x,y,z,dx,dy,dz };
        return new SceneObject("cuboid",p);
      }
  
      static inline SceneObject *sphere(float x, float y, float z, float r, int rzSteps, int xySlices){
        const float p[] = { x,y,z,r, float(rzSteps), float(xySlices) };
        return new SceneObject("sphere",p);
      }
  
      static inline SceneObject *spheroid(float x, float y, float z, float rx, float ry, float rz, int rzSteps, int xySlices){
        const float p[] = { x,y,z,rx, ry, rz, float(rzSteps), float(xySlices) };
        return new SceneObject("spheroid",p);
      }
  
      static inline SceneObject *superquadric(float x, float y, float z, float rx, float ry, float rz, 
                                              float dx, float dy, float dz, float e1, float e2, int rzSteps, int xySlices){
        const float p[] = { x,y,z,rx, ry, rz, dx, dy, dz, e1, e2, float(rzSteps), float(xySlices) };
        return new SceneObject("superquadric",p);
      }
  
      
      SceneObject(const std::string &objFileName) throw (utils::ICLException);
  

      SceneObject(const SceneObject &other) { 
        m_displayListHandle = 0;
        m_fragmentShader = 0;
        *this = other; 
        m_parent = 0;
      }
  

      SceneObject &operator=(const SceneObject &other);
      
      virtual ~SceneObject();
      

      std::vector<Vec> &getVertices();
  
      const std::vector<Vec> &getVertices() const;
  

      std::vector<GeomColor> &getVertexColors();
  
      const std::vector<GeomColor> &getVertexColors() const;
  
  
      std::vector<Primitive*> &getPrimitives();
  
      const std::vector<Primitive*> &getPrimitives() const;
  
      void setVisible(int oredTypes, bool visible, bool recursive=true);
      
      bool isVisible(Primitive::Type t) const;
      

      void addVertex(const Vec &p, const GeomColor &color=GeomColor(255,0,0,255));
  
      void addSharedTexture(utils::SmartPtr<qt::GLImg> gli);
      
      void addSharedTexture(const core::ImgBase *image, core::scalemode sm=core::interpolateLIN);
  
  
      void addNormal(const Vec &n);
      

      void addLine(int x, int y, const GeomColor &color=GeomColor(100,100,100,255));
  

      void addTriangle(int a, int b, int c, int na, int nb, int nc,
                       const GeomColor &color=GeomColor(0,100,250,255));
      
      inline void addTriangle(int a, int b, int c, const GeomColor &color=GeomColor(0,100,250,255)){
        addTriangle(a,b,c,-1,-1,-1,color);
      }
  
  

      void addQuad(int a, int b, int c, int d, int na, int nb, int nc, int nd, 
                   const GeomColor &color=GeomColor(0,100,250,255)); 
  
      inline void addQuad(int a, int b, int c, int d, const GeomColor &color=GeomColor(0,100,250,255)){
        addQuad(a,b,c,d,-1,-1,-1,-1,color);
      }
  

      void addPolygon(int nPoints,const int *vertexIndices, const GeomColor &color=GeomColor(0,100,250,255), 
                      const int *normalIndices=0);
  
      
      void addTexture(int a, int b, int c, int d, 
                      const core::ImgBase *texture, 
                      int na, int nb, int nc, int nd,
                      bool createTextureOnce=true,
                      core::scalemode sm = core::interpolateLIN);
  
      inline void addTexture(int a, int b, int c, int d, 
                             const core::ImgBase *texture, 
                             bool createTextureOnce=true,
                             core::scalemode sm = core::interpolateLIN){
        addTexture(a,b,c,d,texture,-1,-1,-1,-1,createTextureOnce,sm);
      }
  

      void addTexture(int a, int b, int c, int d, 
                      int sharedTextureIndex,
                      int na=-1, int nb=-1, int nc=-1, int nd=-1);
  
      void addTexture(const core::ImgBase *image, int numPoints, const int *vertexIndices,
                      const utils::Point32f *texCoords, const int *normalIndices = 0,
                      bool createTextureOnce=true);
                 
  
      void addTextureGrid(int w, int h, const core::ImgBase *image,
                          const icl32f *px, const icl32f *py, const icl32f *pz,
                          const icl32f *pnx=0, const icl32f *pny=0, const icl32f *pnz=0,
                          int stride = 1,bool createTextureOnce=true,core::scalemode sm=core::interpolateLIN);
  

      void addTwoSidedTextureGrid(int w, int h, const core::ImgBase *front, const core::ImgBase *back,
                             const icl32f *px, const icl32f *py, const icl32f *pz,
                             const icl32f *pnx=0, const icl32f *pny=0, const icl32f *pnz=0,
                             int stride = 1,bool createFrontOnce=true,
                                  bool createBackOnce=true, core::scalemode sm=core::interpolateLIN);
  
  

      void addTextTexture(int a, int b, int c, int d, const std::string &text,
                          const GeomColor &color, 
                          int na, int nb, int nc, int nd,
                          int textSize,core::scalemode sm = core::interpolateLIN);
                          
  
      inline void addTextTexture(int a, int b, int c, int d, const std::string &text,
                          const GeomColor &color=GeomColor(255,255,255,255), 
                                 int textSize=30, core::scalemode sm = core::interpolateLIN){
        addTextTexture(a,b,c,d,text,color,-1,-1,-1,-1,textSize, sm);
      }
      

      void addText(int a, const std::string &text, float billboardHeight=10, 
                   const GeomColor &color=GeomColor(255,255,255,255),
                   int textRenderSize=30, core::scalemode sm=core::interpolateLIN);
  

      inline void addCustomPrimitive(Primitive *p){
        m_primitives.push_back(p);
      }
      

      SceneObject *addCube(float x, float y, float z, float d){
        return addCuboid(x,y,z,d,d,d);
      }
  

      SceneObject *addCuboid(float x, float y, float z, float dx, float dy, float dz);
  

      SceneObject *addSphere(float x, float y, float z, float r,int rzSteps, int xySlices){
        return addSpheroid(x,y,z,r,r,r,rzSteps,xySlices);
      }
  

      SceneObject *addSpheroid(float x, float y, float z, float rx, float ry, float rz, int rzSteps, int xySlices);
      

      SceneObject *addCylinder(float x, float y, float z, float rx, float ry, float h, int steps);
  

      SceneObject *addCone(float x, float y, float z, float rx, float ry, float h, int steps);
  
      
      void setColor(Primitive::Type t,const GeomColor &color,bool recursive=true);
      
      void setPointSize(float pointSize, bool recursive=true);
  
      void setLineWidth(float lineWidth, bool recursive=true);
  
     
      
      virtual SceneObject *copy() const;
  

      virtual void prepareForRendering() {}
  

      virtual void customRender() {}
  
      void setColorsFromVertices(Primitive::Type t, bool on, bool recursive=true);
      
      bool getSmoothShading() const;
      
      void setSmoothShading(bool on, bool recursive=true);
  
  


      virtual void setTransformation(const Mat &m);
      
      void removeTransformation();
  
      virtual void transform(const Mat &m);
  

      template<class T>
      void transform(const T &m){
        transform(Mat(m(0,0),m(1,0),m(2,0),m(3,0),
                      m(0,1),m(1,1),m(2,1),m(3,1),
                      m(0,2),m(1,2),m(2,2),m(3,2),
                      m(0,3),m(1,3),m(2,3),m(3,3)));
      } 
      
      virtual void rotate(float rx, float ry, float rz);
  
      template<class T>
      inline void rotate(const T &t) { rotate((float)t[0],(float)t[1],(float)t[2]); }
      
      virtual void translate(float dx, float dy, float dz);
  
      template<class T>
      inline void translate(const T &t) { translate((float)t[0],(float)t[1],(float)t[2]); }
  
      virtual void scale(float sx, float sy, float sz);
      
      template<class T>
      inline void scale(const T &t) { scale((float)t[0],(float)t[1],(float)t[2]); }
  

      Mat getTransformation(bool relative=false) const;
      

      bool hasTransformation(bool relative=false) const;
      
      SceneObject *getParent();
      
      const SceneObject *getParent() const;
  

      void addChild(SceneObject *child, bool passOwnerShip=true);
      

      void removeChild(SceneObject *child);
  
      void removeAllChildren();
      
      bool hasChildren() const;
      
      int getChildCount() const;
      
      SceneObject *getChild(int index);
      
      const SceneObject *getChild(int index) const;
      
      bool hasChild(const SceneObject *o) const;


      void createAutoNormals(bool smooth=true);
      

      virtual GeomColor getDefaultVertexColor() const{ return GeomColor(255,0,0,255); }
      

      Hit hit(const ViewRay &v, bool recursive=true);
      
      const Hit hit(const ViewRay &v, bool recursive=true) const{
        return const_cast<SceneObject*>(this)->hit(v,recursive);
      }
      
      std::vector<Hit> hits(const ViewRay &v, bool recursive=true);
  
      std::vector<Vec> getTransformedVertices() const;
      

      Vec getClosestVertex(const Vec &pWorld, bool relative=false) throw (utils::ICLException);
      
      void setVisible(bool visible, bool recursive=true);
      
      bool isVisible() const { return m_isVisible; }
  
      void hide(bool recursive=true){ setVisible(false); }
  
      void show(bool recursive=true){ setVisible(true); }
  
  

      inline void setLockingEnabled(bool enabled) { 
        m_mutex.lock();
        m_enableLocking = enabled; 
        m_mutex.unlock();
      }
      
      bool getLockingEnabled() const {
        return m_enableLocking;
      }
  

      virtual void lock(){
        if(!m_enableLocking) return;
        m_mutex.lock();
      }
      

      virtual void unlock(){
        if(!m_enableLocking) return;
        m_mutex.unlock();
      }
      
      friend struct Primitive;
      
  

      inline void setPointSmoothingEnabled(bool enabled=true){
        m_pointSmoothingEnabled = enabled;
      }
  

      inline void setLineSmoothingEnabled(bool enabled=true){
        m_lineSmoothingEnabled = enabled;
      }
   

      inline void setPolygonSmoothingEnabled(bool enabled=true){
        m_polygonSmoothingEnabled = enabled;
      }
  
      void clearAllPrimitives(); 
      

      void createDisplayList();
      
      void freeDisplayList();
      

      void setFragmentShader(qt::GLFragmentShader *shader);
      
      inline qt::GLFragmentShader *getFragmentShader() { return m_fragmentShader; }
      
      inline const qt::GLFragmentShader *getFragmentShader() const{ return m_fragmentShader; }

      inline void setShininess(icl8u value){
        m_shininess = value;
      }
      

      inline void setSpecularReflectance(const GeomColor &values){
        m_specularReflectance = values*(1.0/255);
      }
      
      inline bool getDepthTestEnabled() const{ return m_depthTestEnabled;  }
      
      inline void setDepthTestEnabled(bool enabled){
        m_depthTestEnabled = enabled;
      }

      protected:
      static void collect_hits_recursive(SceneObject *obj, const ViewRay &v, 
                                         std::vector<Hit> &hits, 
                                         bool recursive);
      
      std::vector<Vec> m_vertices;
      std::vector<Vec> m_normals;
      
      std::vector<GeomColor> m_vertexColors;
      std::vector<Primitive*> m_primitives;
      std::vector<utils::SmartPtr<qt::GLImg> > m_sharedTextures;
      int m_visibleMask;
  
      bool m_lineColorsFromVertices;
      bool m_triangleColorsFromVertices;
      bool m_quadColorsFromVertices;
      bool m_polyColorsFromVertices;
  
      float m_pointSize;
      float m_lineWidth;
      
      bool m_useSmoothShading;
      bool m_isVisible;
      
      Mat m_transformation;
      bool m_hasTransformation;
      SceneObject *m_parent;
      std::vector<utils::SmartPtr<SceneObject> > m_children;
  
      utils::Mutex m_mutex; 
      bool m_enableLocking; 
  
      bool m_pointSmoothingEnabled;
      bool m_lineSmoothingEnabled;
      bool m_polygonSmoothingEnabled;
      bool m_depthTestEnabled; 
      
      icl8u m_shininess;
      GeomColor m_specularReflectance;


      
      private:
  
      void *m_displayListHandle;

      int m_createDisplayListNextTime;
  
      qt::GLFragmentShader *m_fragmentShader;
  
    };
  } // namespace geom
}

#endif