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{

      SceneObject *m_cursor;
      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) ;


      const SceneObject *getObject(int index) const ;


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


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


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


      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, bool fastRendering=false);


      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;

      void setCursor(Vec newPosition);

      Vec getCursor();

      void activateCursor(bool activate = true);


      SceneLight &getLight(int index) ;


      const SceneLight &getLight(int index) const ;



      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;


      public:

      virtual void grab(PointCloudObjectBase &dst);

      protected:
#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,
                        int camID) const;

      void renderSceneObjectRecursiveShadow(ShaderUtil* util, SceneObject *o, int camID) const;
#endif

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

      void renderSceneObjectRecursive(ShaderUtil* util, SceneObject *o, int camID) const;

      void renderObjectFramesRecursive(SceneObject *o, SceneObject *cs, int camID) 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][4];

      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