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.LGPL **
** 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

#include <ICLUtils/ICLConfig.h>
#ifndef ICL_HAVE_OPENGL
#if WIN32
#pragma WARNING("this header must not be included if ICL_HAVE_OPENGL is not defined");
#else
#warning "this header must not be included if ICL_HAVE_OPENGL is not defined"
#endif
#endif

#include <ICLUtils/CompatMacros.h>
#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 ShaderUtil;

    class SceneObject{
      public:

      friend class Scene;

      ICLGeom_API SceneObject();


      ICLGeom_API 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);
      }


      ICLGeom_API SceneObject(const std::string &objFileName) ;


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


      ICLGeom_API SceneObject &operator=(const SceneObject &other);

      ICLGeom_API virtual ~SceneObject();


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

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

                        ICLGeom_API const std::vector<Vec> &getNormals() const;


      ICLGeom_API std::vector<GeomColor> &getVertexColors();

      ICLGeom_API const std::vector<GeomColor> &getVertexColors() const;


      ICLGeom_API std::vector<Primitive*> &getPrimitives();

      ICLGeom_API const std::vector<Primitive*> &getPrimitives() const;

      ICLGeom_API void setVisible(int oredTypes, bool visible, bool recursive = true);


      ICLGeom_API void setVisible(const std::string &what, bool recursive=true);

      inline void setVisible(const char *what, bool recursive=true){
        setVisible(std::string(what),recursive);
      }

      ICLGeom_API bool isVisible(Primitive::Type t) const;


      ICLGeom_API virtual bool isInvisibleForCamera(int camIndex) const { return false; }


      ICLGeom_API void addVertex(const Vec &p, const GeomColor &color = GeomColor(255, 0, 0, 255));

      ICLGeom_API void addSharedTexture(utils::SmartPtr<qt::GLImg> gli);

      ICLGeom_API void addSharedTexture(const core::ImgBase *image, core::scalemode sm = core::interpolateLIN);


      ICLGeom_API void addNormal(const Vec &n);


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


      ICLGeom_API 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);
      }



      ICLGeom_API 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);
      }


      ICLGeom_API void addPolygon(int nPoints, const int *vertexIndices, const GeomColor &color = GeomColor(0, 100, 250, 255),
                      const int *normalIndices=0);


      ICLGeom_API 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);
      }


      ICLGeom_API void addTexture(int a, int b, int c, int d,
                      int sharedTextureIndex,
                      int na=-1, int nb=-1, int nc=-1, int nd=-1);

      ICLGeom_API void addTexture(const core::ImgBase *image, int numPoints, const int *vertexIndices,
                      const utils::Point32f *texCoords, const int *normalIndices = 0,
                      bool createTextureOnce=true);


      ICLGeom_API 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);


      ICLGeom_API 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);


      ICLGeom_API void addTwoSidedTGrid(int w, int h, const Vec *vertices, const Vec *normals = 0,
                            const GeomColor &frontColor=GeomColor(0,100,255,255),
                            const GeomColor &backColor=GeomColor(255,0,100,255),
                            const GeomColor &lineColor=GeomColor(0,255,100,255),
                            bool drawLines=false, bool drawQuads=true);



      ICLGeom_API 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);
      }


      ICLGeom_API 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);
      }


      ICLGeom_API 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);
      }


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


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


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


      ICLGeom_API void setColor(Primitive::Type t, const GeomColor &color, bool recursive = true);

      ICLGeom_API void setPointSize(float pointSize, bool recursive = true);

      ICLGeom_API void setLineWidth(float lineWidth, bool recursive = true);

      ICLGeom_API void setUseCustomRender(bool use, bool recursive = true);

      ICLGeom_API virtual SceneObject *copy() const;


      virtual void prepareForRendering() {}


      virtual void customRender() {}


      virtual void complexCustomRender(icl::geom::ShaderUtil* util) {customRender();}

      ICLGeom_API void setColorsFromVertices(Primitive::Type t, bool on, bool recursive = true);

      ICLGeom_API bool getSmoothShading() const;

      ICLGeom_API void setSmoothShading(bool on, bool recursive = true);



      ICLGeom_API virtual void setTransformation(const Mat &m);

      ICLGeom_API void removeTransformation();

      ICLGeom_API 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)));
      }

      ICLGeom_API virtual void rotate(float rx, float ry, float rz,
                          icl::math::AXES axes=icl::math::AXES_DEFAULT);

      template<class T>
      inline void rotate(const T &t, icl::math::AXES axes=icl::math::AXES_DEFAULT)
        { rotate((float)t[0],(float)t[1],(float)t[2]); }

      ICLGeom_API 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]); }

      ICLGeom_API 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]); }


      ICLGeom_API Mat getTransformation(bool relative = false) const;


      ICLGeom_API bool hasTransformation(bool relative = false) const;

      ICLGeom_API SceneObject *getParent();

      ICLGeom_API const SceneObject *getParent() const;


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


      void addChild(utils::SmartPtr<SceneObject> child);


      ICLGeom_API void removeChild(SceneObject *child);

      ICLGeom_API void removeAllChildren();

      ICLGeom_API bool hasChildren() const;

      ICLGeom_API int getChildCount() const;

      ICLGeom_API SceneObject *getChild(int index);

      ICLGeom_API const SceneObject *getChild(int index) const;

      utils::SmartPtr<SceneObject> getChildPtr(int index);

      ICLGeom_API bool hasChild(const SceneObject *o) const;

      ICLGeom_API void createAutoNormals(bool smooth = true);


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


      ICLGeom_API 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);
      }

      ICLGeom_API std::vector<Hit> hits(const ViewRay &v, bool recursive = true);

      ICLGeom_API std::vector<Vec> getTransformedVertices() const;


      ICLGeom_API Vec getClosestVertex(const Vec &pWorld, bool relative = false) ;

      ICLGeom_API 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() const{
        if(!m_enableLocking) return;
        m_mutex.lock();
      }


      virtual void unlock() const{
        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;
      }

      ICLGeom_API void clearAllPrimitives();

      ICLGeom_API virtual void clearObject(bool deleteAndRemoveChildren=true, bool resetTransform=false);


      ICLGeom_API void createDisplayList();

      ICLGeom_API void freeDisplayList();


      ICLGeom_API void setFragmentShader(qt::GLFragmentShader *shader);

      inline qt::GLFragmentShader *getFragmentShader() { return m_fragmentShader; }

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

      inline void setCastShadowsEnabled(bool castShadows = true) { m_castShadows = castShadows; }

      inline bool getCastShadowsEnabled() { return m_castShadows; }

      inline void setReceiveShadowsEnabled(bool receiveShadows = true) { m_receiveShadows = receiveShadows; }

      inline bool getReceiveShadowsEnabled() { return m_receiveShadows; }

      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, bool recursive = true){
        m_depthTestEnabled = enabled;
        if(recursive) {
            for(int i = 0; i < this->getChildCount(); i++) {
                this->getChild(i)->setDepthTestEnabled(enabled,true);
            }
        }
      }


      inline float getPointHitMaxDistance() const {
        return m_pointHitMaxDistance;
      }


      inline void setPointHitMaxDistance(float d){
        m_pointHitMaxDistance = d;
      }

      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;

      bool m_useCustomRender;

      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;

      mutable 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;

      bool m_castShadows;
      bool m_receiveShadows;

      float m_pointHitMaxDistance;
    };
  } // namespace geom
}