VRS - The Virtual Rendering System

version 3.3

scenepicker.h

Go to the documentation of this file.

#ifndef VRS_SG_SCENEPICKER_H__
#define VRS_SG_SCENEPICKER_H__

/******************************************************************************
 * VRS - The Virtual Rendering System
 * Copyright (C) 2000-2006 Computer Graphics Systems Group at the 
 * Hasso-Plattner-Institute (HPI), Potsdam, Germany.
 *
 * This  library  is  free  software; you can redistribute it and/or  modify it
 * under the terms of the GNU Lesser General Public  License  as  published  by
 * the  Free  Software  Foundation;  either  version 2.1 of the License, or (at
 * your option) any later version. This library  is  distributed  in  the  hope
 * that  it will be useful, but  WITHOUT ANY WARRANTY; without even the implied
 * warranty of  MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE.  See  the
 * GNU Lesser General Public License for more details. You should have received
 * a copy of the GNU Lesser+ General Public License along with this library; if
 * not, write to the FreeSoftware Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA, 02111-1307, USA.
 ******************************************************************************/

#include <vrs/config.h>
#include <vrs/sg/interactiontechnique.h>
#include <vrs/callback.h>
#include <vrs/so.h>
#include <vrs/matrix.h>
#include <vrs/vertexdata.h>


namespace VRS {

  class SceneThing;
  
  class ButtonEvent;
  class FrameBufferObjectGL;
  class BufferClearance;
  class RenderTextureGL;
  class RenderBufferGL;
  class Image;
  class GLCanvas;
  class PolygonSet;
  class Texture2DGL;
  class ImageTexture2DGL;
  class Shape;
  class TextureUnitSelectorGL;

  template<class C> class Array2D;

  namespace GL2{
    class ProgramObject;
    class VertexShaderObject;
    class FragmentShaderObject;
    class SamplerVariable;    
    template<class C> class UniformVariable;
  }


  class VRS_CORE_API ScenePicker : public InteractionTechnique{
    
  public:
    static const MouseButtonFunctionID pickFunction;

    struct PickResult {
      PickResult(unsigned id, Vector& position, bool hit, InputEvent::Button but, InputEvent::Modifier mod):id(id),position(position),hit(hit),button(but),mod(mod){};
      PickResult(){id = 0; position = Vector::origin; hit = false;};
      unsigned int id;
      Vector position;
      bool hit;
      InputEvent::Modifier mod;
      InputEvent::Button button;
    };

    class VRS_CORE_API GLImage : public VRS::SharedObj{
    public:
      GLImage(unsigned int width, unsigned int height);

      ~GLImage();

      float getValue(unsigned int xPos,unsigned int yPos, unsigned int component);
      float* getData(){return data;};
      unsigned int getPixelCount(){return width*height;};
      unsigned int getHeight(){return height;};
      unsigned int getWidth(){return width;};
      Color getColor(unsigned int xPos, unsigned int yPos);
      VertexData<4,float> getVector(unsigned int xPos, unsigned int yPos);
      SO<Image> toVRSImage();
    private:
      float* data;
      unsigned int width;
      unsigned int height;
    };

    typedef Callback3<SO<Iterator<PickResult> >,unsigned int, unsigned int> SelectionCallback;
    typedef CallbackR1<unsigned int,SO<Shape> > IdCreationCallback;

    ScenePicker(SO<SceneThing> scene, 
                  SO<IdCreationCallback> idCreationCallback,
                  SO<SelectionCallback> pickingCallback,
                  SO<GLCanvas> canvas,
                  unsigned int textureUnit,
                  unsigned int numberOfIdsToReserve = 10000,
                  bool renderPositionBuffer = true,
                  SO<Iterator<ScenePicker::MouseButtonFunctionID> > buttonFunctionsToRegister = 0);

    void setupFBO( SO<GLCanvas> canvas );

    virtual void onActivation();
    virtual void onDeactivation();

    virtual void onDragStart(int x, int y, SO<ButtonEvent>, MouseButtonFunctionID id);
    virtual void onDragMotion(int x, int y, SO<MotionEvent>, MouseButtonFunctionID id, int startX, int startY);
    virtual void onDragEnd(int x, int y, SO<ButtonEvent>, MouseButtonFunctionID id, int startX, int startY);

    virtual void onEvent(SO<Event> e);

    void updatePickingBuffers();

    inline bool preservingViewDirectionRequired(){ return true;}


    bool getRangeSelectionEnabled() const { return rangeSelectionEnabled_; }
    
    void setRangeSelectionEnabled(bool val) { rangeSelectionEnabled_ = val; }



    void registerSelectionCallback(const SO<SelectionCallback> newSelectionCallback);
    void unregisterSelectionCallback(const SO<SelectionCallback> exisitingSelectioncallback);
    void clearSelectionCallbacks();
    
    void assignIdValues(SO<SceneThing> scene,SO<IdCreationCallback> idCreationCallback, unsigned int numberOfIdValues, unsigned int startId = 0);

    void setSceneForRender(SO<SceneThing> scene);

    const Vector addPolygonSet(unsigned int id,SO<PolygonSet> pset, bool updateLookupTexture = false);

    void incrementTextureCoordinate();
    SO<Iterator<Vector> > addPolygonSets(SO<Iterator<unsigned int> > ids,SO<Iterator<SO<PolygonSet> > > psets, bool updateLookupTexture = false);

     SO<Iterator<Vector> > addPolygonSets(SO<Iterator<unsigned int> > ids,SO<Iterator<SO<Iterator<SO<PolygonSet> > > > > psets, bool updateLookupTexture = false);

    void addSceneThing(SO<SceneThing> scene, unsigned int id, bool updateLookupTexture = false);

    const SO<GLImage> getPixelPositions() const {return this->positionPickingBufferData;};
    const SO<GLImage> getIdBufferImage();

    
    const bool getCameraSpaceCoordinateForPixel(unsigned int x, unsigned int y,Vector& coordinate) const;
    const unsigned int getIdForPixel(unsigned int x,unsigned int y) const;

    bool getCallOnNoHit() const { return callOnNoHit_; }
    void setCallOnNoHit(bool val) { callOnNoHit_ = val; }

    static VRS::UINT32 getIdForColor(const Color& c);
    static Color getColorForId(VRS::UINT32 id);

    
    static unsigned int ScenePicker::getPixelForCoordinate(float coordinate, unsigned int size);
    static float getCoordinateForPixel(unsigned pixel, unsigned int size);

    bool ScenePicker::hasUnassignedIds(unsigned int numberOfRequiredIds);

    unsigned int getTextureUnit(){return this->textureUnit_;};
    VRS_TYPEINFO(ScenePicker,InteractionTechnique);

  protected:

  private:

    void createRenderScene();

    void handleResize(unsigned int newWidth,unsigned int newHeight);

    // creates the image texture which can hold minimum numberOfIdValues entries
    void initIdImageTexture(unsigned int numberOfIdValues);
   
    // Callbacks to be called if a selection was made
    SO<Array<SO<SelectionCallback> > > selectionCallbacks_;
    // Number of the texture unit which is used to store the texture coordinates for
    unsigned int textureUnit_;
    // Framebufferobject used to render the id lookup texture and the position texture
    SO<FrameBufferObjectGL> fbo_;
    // source texture holding the color coded ids per mesh
    SO<Image> idImage_;
    // Texture for rendering the scene with id colors
    SO<ImageTexture2DGL> idTexture_;
    // fbo rendered texture containing 
    SO<Texture2DGL> idColorScreenTexture_;

    // Rendertarget for fbo id rendering
    SO<RenderTextureGL> idColorRenderTarget_;

    SO<Texture2DGL> pixelPositionScreenTexture_;
    // Rendertarget for position rendering
    SO<RenderTextureGL> pixelPositionRenderTarget_;
    SO<BufferClearance> clearance_;
    SO<RenderBufferGL> depthBuffer;
    SO<GL2::ProgramObject> idShaderProgram_;

    SO<TextureUnitSelectorGL> unitZeroSelector;

    SO<SceneThing> renderScene_;

    // Scene which is displayed on the canvas
    SO<SceneThing> contentScene_;

    SO<GLCanvas> canvas_;

    bool rangeSelectionEnabled_;

    // determines the usage of the position buffer rendering. If 'false' the selection Callback will be called with Vector::origin.
    bool renderPositionBuffer_;
    // if set to true, the selectioncallback will also be called if no known element has been hit.
    bool callOnNoHit_;

    // defines the width of the id image and therefore the number of possible identifiable objects.
    unsigned int imageWidth;
    unsigned int numberOfIdsGiven_;
    float currentStep_;
    float currentXVal_, currentYVal_;

    bool dragging_;
    

    SO<GLImage> idPickingBufferData;
    SO<GLImage> positionPickingBufferData;
    unsigned int pixelsInIdTexture;

  };
 

};

#endif // VRS_SG_OBJECTPICKER_H__

---

Generated on Wed May 23 06:00:13 2012 by Doxygen 1.5.6

© 2001-2010 Hasso-Plattner-Institut | Impressum | Contact