ShadowCaster.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 __SHADOWCASTER_H__
#define __SHADOWCASTER_H__
 
#include <H3D/H3DShadowObjectNode.h>
 
#include <H3D/X3DChildNode.h>
#include <H3D/X3DLightNode.h>
#include <H3D/MFNode.h>
#include <H3D/Shape.h> 
#include <H3D/SFString.h>
#include <H3D/X3DShaderNode.h>
#include <H3D/DEFNodes.h>
 
namespace H3D {
 
  class FrameBufferTextureGenerator;
  class H3DAPI_API ShadowCaster : public X3DChildNode,
                                  public H3DDisplayListObject {
  public:
 
    typedef TypedMFNode< X3DLightNode > MFLightNode;
    typedef TypedMFNode< H3DShadowObjectNode > MFShadowObjectNode;
    typedef TypedSFNode< X3DShaderNode > SFShaderNode;
 
    ShadowCaster( Inst< SFNode             > _metadata = 0,
                  Inst< MFShadowObjectNode > _object = 0,
                  Inst< MFLightNode        > _light = 0,
                  Inst< SFFloat            > _shadowDarkness = 0,
                  Inst< SFFloat            > _shadowDepthOffset = 0,
                  Inst< DisplayList        > _displayList = 0,
                  Inst< SFString           > _algorithm = 0,
                  Inst< SFShaderNode       > _shadowShader = 0,
                  Inst< SFBool             > _multiThreading = 0);
 
    virtual void render();
 
    virtual void traverseSG( TraverseInfo &ti );
 
    void addHeadLight();
    // This method updates & computes shadows
    // That are to be rendered in the scene
    // Note: This always has to be called after traverse
    static void  updateShadowInformation(TraverseInfo& ti, void* data);
 
    H3DUniquePtr< MFShadowObjectNode > object;
 
    H3DUniquePtr< MFLightNode > light;
 
    H3DUniquePtr< SFFloat > shadowDarkness;
 
    H3DUniquePtr< SFFloat > shadowDepthOffset;
 
    H3DUniquePtr< SFString > algorithm;
 
    H3DUniquePtr< SFShaderNode > shadowShader;
 
    H3DUniquePtr< SFBool > multiThreading;
 
    static H3DNodeDatabase database;
 
  protected:
    // Internal fbo that renders the main stencil buffer to a RGBA texture.
    AutoRef< Node > generator;
 
    // DEFNodes of the nodes in shape.
    X3D::DEFNodes dn;
 
    // holds the Shape used to render the texture from generator onto
    // a FullscreenRectangle with shadowShader applied.
    AutoRef<Shape> shape;
 
    // the shader that was used last loop.
    X3DShaderNode *last_shader;
 
    // Callback function to FrameBufferTextureGenerator to render the stencil buffer
    // to an fbo. 
    static void renderShadows( FrameBufferTextureGenerator *fbo, int i, void *args );
 
    // Map for all geometry mesh. One per light.
    struct BufferData {
      BufferData() {
      }
      ~BufferData() {
        coord3.clear();
        coord4.clear();
        index.clear();
      }
 
      // GPU
      std::vector< Vec3d > coord3;
      std::vector< H3DUInt32 > index;
      // CPU
      std::vector< Vec4d > coord4;
      
    };
 
    std::map< X3DLightNode*, BufferData > single_buffer_map;
    Matrix4f accumulated_fwd_mat;
 
    static void *   collectInformationCallback( void* data );
    void computeThreadedShadowVolumeInformation();
    void fillThreadSafeInformation( Matrix4f acc_fwd, bool is_render_caps );
 
    H3DUtil::MutexLock   synchronous_lock;
 
    Matrix4f      accumulated_fwd_ts;
    bool          render_caps_ts;
 
    std::vector<X3DLightNode*>    lights_ts;
    std::vector<H3DShadowObjectNode*>    shadow_objects_ts;
 
    //data is filled into these containers and then transfered 
    std::map< X3DLightNode*, std::vector<Vec4d> > data_container_cpu_ts;
    bool    should_transfer_data_ts;
  };
}
 
#endif