ShadowGeometry.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 __SHADOWGEOMETRY_H__
#define __SHADOWGEOMETRY_H__
 
#include <H3D/H3DShadowObjectNode.h>
#include <H3D/DirectionalLight.h>
#include <H3D/PointLight.h>
#include <H3D/SFRotation.h>
#include <H3D/MatrixTransform.h>
#include <H3D/X3DGeometryNode.h>
#include <H3D/ComposedShader.h>
 
namespace H3D {
 
  class H3DAPI_API ShadowGeometry : public H3DShadowObjectNode {
  public:
 
    class H3DAPI_API SFGeometryNode: public TypedSFNode< X3DGeometryNode > {
    protected:
      virtual void onAdd( Node *n );
      virtual void onRemove( Node *n );
    };
 
    ShadowGeometry( Inst< SFNode          > _metadata  = 0,
                    Inst< SFTransformNode > _transform = 0,
                    Inst< SFGeometryNode  > _geometry  = 0,
                    Inst< SFBool > _enabled = 0 );
 
    virtual void update();
  protected:
    //  This field has to be defined before geometry in the node since when
    //  geometry is destructed this field is used and have to exist.
    H3DUniquePtr<Field> triangles_changed; 
  public:
 
    H3DUniquePtr< SFGeometryNode > geometry;
 
    static H3DNodeDatabase database;
 
    virtual void computeShadowVolumeInformationCPU( const LightDataStruct& light_data, Matrix4f accumulated_fwd, bool render_caps, std::vector< Vec4d >& coord );
 
    virtual void renderShadowGPU( const LightDataStruct& light_data, Matrix4f accumulated_fwd, bool render_caps );
 
  protected:
 
    void buildShadowVolumeDataCPU( LightDataStruct light_data,
      bool render_caps,
      const Matrix4f &local_to_global,
      const Matrix4f &global_to_local,
      bool rebuild_triangle_info,
      std::vector< Vec4d >&  coord );
 
    void addDirectionalLightQuadPoints( vector< Vec4d > &triangle_points,
                                        const Vec3d &v1, const Vec3d &v2, 
                                        const Vec3d& dir );
 
    void addPointLightQuadPoints( vector< Vec4d > &triangle_points,
                                  const Vec3d &v1, const Vec3d &v2, 
                                  const Vec3d& light_pos );
 
 
 
    void updateNeighbours( const vector< HAPI::Collision::Triangle > &triangles);
 
    void updateSilhouetteEdgesDirectionalLight( const vector< HAPI::Collision::Triangle > &,
                                                const vector<int> &neighbours,
                                                const Vec3d &direction );
 
    void updateSilhouetteEdgesPointLight( const vector< HAPI::Collision::Triangle > &,
                                          const vector<int> &neighbours,
                                          const Vec3d &pos );
 
    void updateAdjacentVertexArray( const vector< HAPI::Collision::Triangle > &triangles, 
                                     vector< Vec3d > &triangle_points, 
                                     vector< unsigned int > &adjacency_index );
 
    int getMissingPointIndex( const HAPI::Collision::Triangle &t,
                              const Vec3d &p0, const Vec3d &p1 );
 
    vector< int > neighbours;
 
    vector< HAPI::Collision::Triangle > triangles;
 
    vector< Vec3d >triangle_points_geom_shader;
 
    std::map< X3DLightNode *, pair< H3DTime, vector< Vec4d > > > triangle_points_fallback;
 
    vector< unsigned int > index_geom_shader;
 
    vector< bool > is_silhouette_edge;
 
    vector< bool > triangle_facing_light;
 
    bool use_geometry_shader_last_loop;
 
    // copies of fields that are updated in traverse and are used in computation of shadow volumes
    // these are thread safe copies
    Matrix4f transform_matrix_ts;
    bool     is_enabled_ts;
    bool     rebuild_triangles_ts;
 
    std::vector< HAPI::Collision::Triangle >  triangles_ts;
 
 
  };
}
 
#endif