FrameBufferTextureGenerator.h

Go to the documentation of this file.

//    Copyright 2004-2019, SenseGraphics AB
//
//    This file is part of H3D API.
//
//    H3D API is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation; either version 2 of the License, or
//    (at your option) any later version.
//
//    H3D API 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 General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with H3D API; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//    A commercial license is also available. Please contact us at 
//    www.sensegraphics.com for more information.
//
//
//
#ifndef __FRAMEBUFFERTEXTUREGENERATOR_H__
#define __FRAMEBUFFERTEXTUREGENERATOR_H__
 
#include <H3D/X3DGroupingNode.h>
#include <H3D/MFString.h>
#include <H3D/GeneratedTexture.h>
#include <H3D/X3DViewpointNode.h>
#include <H3D/NavigationInfo.h>
#include <H3D/X3DBackgroundNode.h>
#include <H3D/ShadowCaster.h>
#include <H3D/TypedField.h>
#include <H3D/FieldTemplates.h>
#include <H3D/SFColorRGBA.h>
#include <H3D/Field.h>
#include <H3D/MFColorRGBA.h>
#include <H3DUtil/AutoRef.h>
 
namespace H3D {
 
  class H3DAPI_API FrameBufferTextureGenerator : public X3DGroupingNode {
  public:
 
    typedef TypedSFNode< TextureProperties > SFTexturePropertiesNode;
    typedef TypedMFNode< TextureProperties > MFTexturePropertiesNode;
    typedef TypedSFNode< X3DViewpointNode > SFViewpointNode;
    typedef TypedSFNode< NavigationInfo > SFNavigationInfo;
    typedef TypedSFNode< X3DBackgroundNode > SFBackgroundNode;
    typedef TypedMFNode< H3DSingleTextureNode > MFGeneratedTextureNode;
    typedef TypedSFNode< H3DSingleTextureNode > SFGeneratedTextureNode;
    typedef void (*RenderCallbackFunc)( FrameBufferTextureGenerator *, int i, void * );
    typedef TypedSFNode< FrameBufferTextureGenerator > SFFrameBufferTextureGeneratorNode;
    typedef TypedMFNode< FrameBufferTextureGenerator > MFFrameBufferTextureGeneratorNode;
 
    class H3DAPI_API UpdateMode : public AutoUpdate < OnNewValueSField < SFString > > {
        virtual void onNewValue( const std::string& new_value );
    };
 
    FrameBufferTextureGenerator( Inst< AddChildren    > _addChildren     = 0,
                                 Inst< RemoveChildren > _removeChildren  = 0,
                                 Inst< MFChild        > _children        = 0,
                                 Inst< SFNode         > _metadata        = 0,
                                 Inst< SFBound        > _bound           = 0,
                                 Inst< SFVec3f        > _bboxCenter      = 0,
                                 Inst< SFVec3f        > _bboxSize        = 0, 
                                 Inst< MFString       > _generateColorTextures = 0,
                                 Inst< SFBool         > _generateDepthTexture  = 0,
                                 Inst< MFTexturePropertiesNode > _colorTextureProperties = 0,
                                 Inst< SFTexturePropertiesNode > _depthTextureProperties = 0,
                                 Inst< MFGeneratedTextureNode > _colorTextures = 0, 
                                 Inst< SFGeneratedTextureNode > _colorTexture  = 0,
                                 Inst< SFGeneratedTextureNode > _depthTexture  = 0,
                                 Inst< SFString         > _depthBufferType = 0,
                                 Inst< SFString         > _outputTextureType = 0,
                                 Inst< SFInt32          > _samples   = 0,
                                 Inst< UpdateMode       > _update    = 0,
                                 Inst< SFInt32          > _framesBeforeStop = 0,
                                 Inst< SFViewpointNode  > _viewpoint = 0,
                                 Inst< SFNavigationInfo > _navigationInfo = 0,
                                 Inst< SFBackgroundNode > _background = 0,
                                 Inst< SFInt32          > _width     = 0,
                                 Inst< SFInt32          > _height    = 0,
                                 Inst< SFInt32          > _widthInUse = 0,
                                 Inst< SFInt32          > _heightInUse = 0,
                                 Inst< SFBool           > _useStereo = 0,
                                 Inst< SFString         > _depthBufferStorage = 0,
                                 Inst< SFFrameBufferTextureGeneratorNode > _externalFBODepthBuffer = 0,
                                 Inst< MFString         > _colorBufferStorages = 0,
                                 Inst< MFFrameBufferTextureGeneratorNode > _externalFBOColorBuffers = 0,
                                 Inst< SFBool           > _useNavigation = 0,
                                 Inst< SFInt32          > _projectionWidth = 0,
                                 Inst< SFInt32          > _projectionHeight = 0,
                                 Inst< SFBool           > _useSpecifiedClearColor = 0,
                                 Inst< SFColorRGBA      > _clearColor = 0,
                                 Inst< SFBool           > _useDSA = 0,
                                 Inst< SFBool           > _splitScene = 0,
                                 Inst< SFBool           > _useScissor = 0,
                                 Inst< SFInt32          > _scissorBoxX = 0,
                                 Inst< SFInt32          > _scissorBoxY = 0,
                                 Inst< SFInt32          > _scissorBoxWidth = 0,
                                 Inst< SFInt32          > _scissorBoxHeight = 0,
                                 Inst< MFColorRGBA      > _clearColors = 0,
                                 Inst< SFInt32          > _nrLayers = 0,
                                 Inst< SFBool           > _generateStencilMask = 0,
                                 Inst< SFBool           > _applyStencilMask  = 0,
                                 Inst< SFBool           > _useInverseMasking = 0);
        
    virtual ~FrameBufferTextureGenerator();
 
    virtual void render();
 
    virtual void traverseSG( TraverseInfo &ti );
 
    virtual void initialize();
 
    bool haveStencilBuffer();
 
    void setRenderCallback( RenderCallbackFunc func, void *args = NULL ); 
 
    H3DUniquePtr< SFString > depthBufferStorage;
 
    H3DUniquePtr< SFFrameBufferTextureGeneratorNode > externalFBODepthBuffer;
 
    H3DUniquePtr< MFString > colorBufferStorages;
 
    H3DUniquePtr< MFFrameBufferTextureGeneratorNode > externalFBOColorBuffers;
 
    H3DUniquePtr< MFString > generateColorTextures;
 
    H3DUniquePtr< SFBool > generateDepthTexture;
 
    H3DUniquePtr< MFTexturePropertiesNode > colorTextureProperties;
 
    H3DUniquePtr< SFTexturePropertiesNode > depthTextureProperties;
 
    H3DUniquePtr< MFGeneratedTextureNode > colorTextures;
 
    H3DUniquePtr< SFGeneratedTextureNode > colorTexture;
 
    H3DUniquePtr< SFGeneratedTextureNode > depthTexture;
    
    H3DUniquePtr< SFString > depthBufferType;
 
    H3DUniquePtr< SFString > outputTextureType;
    
    H3DUniquePtr< SFInt32 > samples;
 
    H3DUniquePtr< UpdateMode > update;
 
    H3DUniquePtr< SFInt32 > framesBeforeStop;
 
    H3DUniquePtr< SFViewpointNode > viewpoint;
 
    H3DUniquePtr< SFNavigationInfo > navigationInfo;
 
    H3DUniquePtr< SFBackgroundNode > background;
 
    H3DUniquePtr< SFInt32 > width;
 
    H3DUniquePtr< SFInt32 > height;
    
    H3DUniquePtr< SFBool > useScissor;
 
    H3DUniquePtr< SFInt32 > scissorBoxX;
 
    H3DUniquePtr< SFInt32 > scissorBoxY;
 
    H3DUniquePtr< SFInt32 > scissorBoxWidth;
 
    H3DUniquePtr< SFInt32 > scissorBoxHeight;
 
    H3DUniquePtr< SFInt32 > widthInUse;
 
    H3DUniquePtr< SFInt32 > heightInUse;
 
    H3DUniquePtr< SFInt32 > projectionWidth;
 
    H3DUniquePtr< SFInt32 > projectionHeight;
 
    H3DUniquePtr< SFBool > useStereo;
 
    H3DUniquePtr< SFBool > useNavigation;
 
 
    H3DUniquePtr< SFBool > useSpecifiedClearColor;
 
    H3DUniquePtr< SFColorRGBA > clearColor;
 
    H3DUniquePtr< MFColorRGBA > clearColors;
 
    H3DUniquePtr< SFBool > useDSA;
 
    H3DUniquePtr< SFBool > splitScene;
 
    H3DUniquePtr< SFBool > generateStencilMask;
 
    H3DUniquePtr< SFBool > applyStencilMask;
 
    H3DUniquePtr< SFBool > useInverseMasking;
 
    H3DUniquePtr < SFInt32 > nrLayers;
 
    static H3DNodeDatabase database;
    
    inline void ensureInitialized() {
      if( !fbo_initialized ) initializeFBO();
    }
 
    inline bool isFBOInitialized() {
      return fbo_initialized;
    }
 
    inline GLuint getFBOId() {
      return fbo_id;
    }
 
    inline GLuint getDepthId() {
      return depth_id;
    }
 
    inline H3DSingleTextureNode* getDepthTexture() {
      return depthTexture->getValue();
    }
 
    inline vector<GLuint> getColorIds() {
      return color_ids;
    }
 
    inline NodeVector getColorTextures() {
      return colorTextures->getValue();
    }
 
    inline void setAlwaysUseExistingViewport( bool use ) {
      always_use_existing_viewport = use;
    }
 
    inline bool alwaysUseExistingViewpoint() {
      return always_use_existing_viewport;
    }
 
    static std::set< FrameBufferTextureGenerator * > fbo_nodes;
 
  protected:
 
    GLenum stringToInternalFormat( const string &format_string );
 
    GLenum stringToInternalDepthFormat( const string &s );
 
    GLenum stringToDepthFormat( const string &s );
 
    GLenum stringToDepthType( const string &s );
 
    bool checkFBOCompleteness();
 
    void initializeFBO();
 
    void createOutputTextures ();
 
    void setupScissor( bool needSinglePassStereo, float* viewports_size, int desired_fbo_width, int desired_fbo_height );
 
    void preProcessFBO(int srcX, int srcY, int w, int h, int depth);
 
    void blitDepthBuffer(GLenum src, GLenum dst, int srcX, int srcY, int w, int h);
 
    void blitColorBuffer(GLenum src, GLenum dst, 
      int srcX, int srcY, int w, int h, int src_index, int dst_index);
 
    void blitFBOBuffers(GLenum src, GLenum dst, 
      int srcX, int srcY, int w, int h );
 
 
    bool resizeBuffers( H3DInt32 w, H3DInt32 h, H3DInt32 d );
 
    bool parseColorBufferStorage( std::string color_buffer_storage, std::string& style, int& index );
 
    void _check_gl_error(const char *file, int line);
 
    void clearColorBuffer(GLenum src, int x, int y, int _width, int _height, 
                           GLfloat* value, GLint index );
 
    void clearBuffers(GLenum src, int x, int y, int _width, int _height, GLbitfield mask);
 
    class NeedMultiSample: public TypedField<SFBool, SFInt32>
    {
    public:
      virtual void update();
    };
 
    H3DUniquePtr< NeedMultiSample > needMultiSample;
 
    class GetNrSamples: public SFInt32{
    public:
      virtual void update();
    };
 
    H3DUniquePtr<GetNrSamples> getNrSamples;
 
    bool fbo_initialized;
 
    int last_samples;
 
    vector<GLuint> color_ids;
 
    GLuint multi_samples_depth_id;
    
    vector<GLuint> multi_samples_color_ids;
    
    GLuint multi_samples_fbo_id;
 
    H3DInt32 buffers_width;
 
    H3DInt32 buffers_height;
 
    H3DInt32 buffers_depth;
 
    GLuint fbo_id;
 
    GLuint depth_id;
 
    GLuint stencil_id;
 
    std::vector< GLenum > draw_buffers;
 
    bool last_resize_success;
 
    RenderCallbackFunc render_func;
 
    void *render_func_data;
 
    bool always_use_existing_viewport;
 
    AutoRef< ShadowCaster > shadow_caster;
 
    AutoRef< X3DGroupingNode > child_to_render;
 
  protected:
    class ResetPrintedFlag : public TypedField< SFBool, Types<Any<SFString,MFString> > >
    {
    public:
      virtual void update (){
        this->value = false;
      }
    };
    class ResetPrintedFlags: public TypedField< MFBool, 
      MFString > {
    public:
      virtual void update(){
        for( vector<bool>::iterator it = value.begin(); it!= value.end(); ++it) {
 
          (*it) = false;
        }
      }
    };
 
    H3DUniquePtr< ResetPrintedFlag > depthWarningPrinted;
 
    H3DUniquePtr< ResetPrintedFlag > colorMismatchWarningPrinted;
 
    H3DUniquePtr< ResetPrintedFlags > colorInitWarningPrinted;
 
    bool support_dsa;
 
    bool use_depth_stencil;
 
    vector<GLfloat> clear_color_value;
  };
}
 
#endif