GLProjectionParametersPerspective.hh

#ifndef __GLPROJECTIONPARAMSPERSP_HH__
#define __GLPROJECTIONPARAMSPERSP_HH__

#include <bias_config.h>
#include <OpenGLFramework/Base/glfRenderTarget.hh>
#include <GLviewer/GLProjectionParametersBase.hh>
#include <Geometry/ProjectionParametersPerspective.hh>

#include <GLviewer/OutputAttachments/OutputLensDistortion.hh>

namespace BIAS
{

  /** @class GLProjectionParametersPerspective
   *  @brief class for rendering with projection parameters of ProjectionParametersPerspective 
   *  @ingroup g_glviewer
   */

  class BIASGLviewer_EXPORT GLProjectionParametersPerspective:
    public GLProjectionParametersBase,
    public BIAS::ProjectionParametersPerspective
  {
  public:

    GLProjectionParametersPerspective();
    GLProjectionParametersPerspective(const BIAS::ProjectionParametersPerspective &ppp);

    /**
       the pure virtual GetMyselfAsProjectionParameterBase() forces the child
       classes to inherit from a projectionparameterbase class and
       allows to access the projectionparams in cases where only a GLPPB* is
       available. this avoids the undesired need to derive GLPPB from PPB.
    */
    virtual BIAS::ProjectionParametersBase* GetMyselfAsProjectionParametersBase()
      const{return((ProjectionParametersBase*) this);};

#ifdef BIAS_HAVE_XML2
    virtual int XMLRead (const std::string &Filename);
    virtual int XMLWrite(const std::string &Filename) const;
    virtual int Load    (const std::string& filename);
    virtual int Save    (const std::string& filename) const;
#endif

    int SetSimplePerspectiveCam(double fovyDEG,
                                int imageWidth = -1,
                                int imageHeight = -1);

    /** Method loads the parameters into the projection and modelview Matrix.
     * \param forceUpdate do not check if camera state changed always
     *        recalculate.
     * \attention make sure your rendering context is current.
     * \attention Method is not equivalent to draw yet. */
    virtual int SetGLMatrices(bool forceUpdate = true);

    void SetIntrinsics(BIAS::ProjectionParametersBase *p);

    void Set(BIAS::ProjectionParametersBase *p);

    /** setclearcolor is pure virtual. In some cases like for example
        distortion rendering the lower render layers (offscreen surfaces)
        must informed about changes of the clear color thus the child classes
        have to deal with the clear color on their own. */
    virtual void SetClearColor(const BIAS::Vector4<float>& cc);

    void UseStencilBuffer(bool b){useStencilBuffer_ = b;};
    void IgnoreDistortion(bool b){ignoreDistortion_ = b;};

    GLProjectionParametersPerspective& operator=(const GLProjectionParametersPerspective& glppp);
    GLProjectionParametersPerspective(const GLProjectionParametersPerspective& glppp);

  protected:
    virtual double Z2Depth_(const int x,const  int y, const double z) const;

    virtual void   InitShaders_();
    virtual void   Rescale_(float scale);

    virtual int    UpdateGLProjectionMatrix_(unsigned x0, unsigned y0,
                                             unsigned width, unsigned height);

    int DrawWithMatchedParamsAndViewport_(int viewport[4],int imageWidth,int imageHeight,
                      std::vector<SceneBase*>& scenes);



    /** Rendering with current matrices GLProjectionMatrix_,
        GLModelViewMatrix_. Those matrices are assumed to be up to date.
        Does not clear framebuffer. Sets informScenesOfChange_ to false.
    */
    virtual int Draw_(std::vector<SceneBase *>& scenes,
                      BIAS::glfFramebufferObject* theTarget = NULL);

    void ClearDepthAndAlpha_();

    bool ignoreDistortion_;

  private:

    int distorter_;
  };
}
#endif