Scene.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/Scene.h                            **
** Module : ICLGeom                                                **
** Authors: Christof Elbrechter, Erik Weitnauer, Daniel Dornbusch, **
**          Matthias Esau                                          **
**                                                                 **
**                                                                 **
** 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

#ifndef ICL_HAVE_OPENGL
  #ifdef 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
#else

#include <ICLUtils/CompatMacros.h>
#include <ICLGeom/SceneObject.h>
#include <ICLGeom/Camera.h>
#include <ICLGeom/SceneLight.h>
#include <ICLGeom/Primitive.h>
#include <ICLGeom/PointCloudGrabber.h>
#include <ICLCore/Img.h>
#include <ICLUtils/FPSEstimator.h>

#ifdef ICL_HAVE_QT
#include <ICLQt/MouseHandler.h>
#include <ICLQt/DrawWidget3D.h>
#include <ICLGeom/SceneMouseHandler.h>
#endif

#include <ICLUtils/Lockable.h>
#include <ICLUtils/Configurable.h>
#include <ICLUtils/SmartArray.h>
#include <map>
#include <ICLGeom/ShaderUtil.h>

namespace icl{
  namespace qt {class ICLDrawWidget;}
  namespace geom{
 



    class ICLGeom_API Scene : public utils::Lockable, public geom::PointCloudGrabber{
      public:

      friend class SceneObject;
    
      struct GLCallback;
    
      Scene();
    
      ~Scene();
    
      Scene(const Scene &scene);
    
      Scene &operator=(const Scene &scene);


      void addCamera(const Camera &cam, float visSize=1.0);
    
      void removeCamera(int index);
    

      Camera &getCamera(int camIndex = 0);
    
      const Camera &getCamera(int camIndex =0) const;
    
      inline int getCameraCount() const { return (int)m_cameras.size(); }


      std::vector<Camera*> getAllCameras(int firstIndex=0, int num=-1);
    

      void addObject(SceneObject *object, bool passOwnerShip=false);
    

      void removeObject(int idx);
    

      void removeObject(const SceneObject *obj);


      void removeObjects(int startIndex, int endIndex=-1);
    
      inline int getObjectCount() const { return m_objects.size(); }
    

      SceneObject *getObject(int index) throw (utils::ICLException);


      const SceneObject *getObject(int index) const throw (utils::ICLException);
    

      SceneObject *getObject(const std::vector<int> recursiveIndices) throw (utils::ICLException);


      SceneObject *getObject(const std::vector<int> recursiveIndices) const throw (utils::ICLException);
    

      std::vector<int> findPath(const SceneObject *o) const throw (utils::ICLException);
    

      void clear(bool camerasToo=false);

#ifdef ICL_HAVE_QT

      qt::MouseHandler *getMouseHandler(int camIndex=0);
    
      void setMouseHandler(SceneMouseHandler* sceneMouseHandler, int camIndex=0);
    

      qt::ICLDrawWidget3D::GLCallback *getGLCallback(int camIndex);

      enum DepthBufferMode{
        RawDepth01,      
        DistToCamPlane,  
        DistToCamCenter  
      };
      const core::Img8u &render(int camIndx, const core::ImgBase *background = 0, core::Img32f *depthBuffer = 0,
        DepthBufferMode mode = DistToCamCenter);
    


      mutable icl::qt::GLFragmentShader* m_shaders[ShaderUtil::COUNT];
      
      struct RenderSettings;
      mutable RenderSettings *m_renderSettings;
      struct FBOData;
      mutable FBOData *m_fboData;
#endif


      void setDrawCamerasEnabled(bool enabled);
    
      bool getDrawCamerasEnabled() const;

      void setDrawLightsEnabled(bool enabled, float lightSize=1);
    
      bool getDrawLightsEnabled() const;
    
      void setDrawCoordinateFrameEnabled(bool enabled, float size=120);
    
      bool getDrawCoordinateFrameEnabled() const;

      void setDrawObjectFramesEnabled(bool enabled, float size);
      
      bool getDrawObjectFramesEnabled() const;
      

      SceneLight &getLight(int index) throw (utils::ICLException);


      const SceneLight &getLight(int index) const throw (utils::ICLException);

    

      void setLightingEnabled(bool flag);


      void setGlobalAmbientLight(const GeomColor &color);
      

      inline Hit findObject(int camIndex, int xScreen, int yScreen){
        return findObject(getCamera(camIndex).getViewRay(utils::Point(xScreen,yScreen)));
      }
    

      Hit findObject(const ViewRay &v);
    
    
      std::vector<Hit> findObjects(const ViewRay &v);
    
      inline std::vector<Hit> findObjects(int camIndex, int xScreen, int ySceen){
        return findObjects(getCamera(camIndex).getViewRay(utils::Point(xScreen,ySceen)));
      }
    

      void setBounds(float minX, float maxX=0, float minY=0, float mayY=0, float minZ=0, float maxZ=0);
      

      void setBackgroundColor(const GeomColor &color);

      GeomColor getBackgroundColor() const;
      
      protected:

      void createDisplayList(SceneObject *o) const;

      void freeDisplayList(SceneObject *o) const;
      
      

      virtual void grab(PointCloudObjectBase &dst);

#ifdef ICL_HAVE_QT

      void renderScene(int camIndex, qt::ICLDrawWidget3D *widget=0) const;
      
      void renderShadow(const unsigned int light, const unsigned int shadow, unsigned int size = 512) const;
      
      void renderSceneObjectRecursiveShadow(ShaderUtil* util, SceneObject *o) const;
#endif

      void renderSceneObjectRecursive(SceneObject *o) const{
        ShaderUtil util;
        renderSceneObjectRecursive(&util, o);
      };
      
      void renderSceneObjectRecursive(ShaderUtil* util, SceneObject *o) const;

      void renderObjectFramesRecursive(SceneObject *o, SceneObject *cs) const;


      float getMaxSceneDim() const;
    
      void extendMaxSceneDimRecursive(float &minX, float &maxX, 
                                      float &minY, float &maxY, 
                                      float &minZ, float &maxZ,
                                      SceneObject *o) const;

      std::vector<Camera> m_cameras;

      std::vector<utils::SmartPtr<SceneObject> > m_objects;

      std::vector<utils::SmartPtr<SceneObject> > m_cameraObjects;

#ifdef ICL_HAVE_QT

      std::vector<utils::SmartPtr<SceneMouseHandler> > m_mouseHandlers;

      std::vector<utils::SmartPtr<GLCallback> > m_glCallbacks;

      struct PBuffer;

      void freeAllPBuffers();

      void freePBuffer(const utils::Size &size);

      struct PBufferIndex : public utils::Size{
        pthread_t threadID;
        PBufferIndex(const utils::Size &size);
        bool operator<(const PBufferIndex &other) const;
      };
      mutable std::map<PBufferIndex, PBuffer*> m_pbuffers;
#endif

      mutable utils::SmartPtr<SceneObject> m_coordinateFrameObject;

      mutable utils::SmartPtr<SceneObject> m_objectFrameObject;
      
      utils::SmartPtr<SceneLight> m_lights[8];
      
      utils::SmartPtr<SceneObject> m_shadowCameraObjects[8];
      
      mutable bool m_previousLightState[8][3];
    
      utils::SmartArray<utils::Range32f> m_bounds;
      
      math::FixedColVector<int,4> m_globalAmbientLight;

      GeomColor m_backgroundColor;
      
      utils::FPSEstimator m_fps;

      private:
      static void freeDisplayList(void *handle);
    };
  } // namespace geom

}

#endif