File: VisibilityCheck.h

package info (click to toggle)
meshlab 1.3.2+dfsg1-4
  • links: PTS, VCS
  • area: main
  • in suites: sid
  • size: 21,096 kB
  • ctags: 33,630
  • sloc: cpp: 224,813; ansic: 8,170; xml: 119; makefile: 80
file content (145 lines) | stat: -rw-r--r-- 5,889 bytes parent folder | download | duplicates (3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
/****************************************************************************
* MeshLab                                                           o o     *
* A versatile mesh processing toolbox                             o     o   *
*                                                                _   O  _   *
* Copyright(C) 2005                                                \/)\/    *
* Visual Computing Lab                                            /\/|      *
* ISTI - Italian National Research Council                           |      *
*                                                                    \      *
* All rights reserved.                                                      *
*                                                                           *
* This program 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.                                       *
*                                                                           *
* This program 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 (http://www.gnu.org/licenses/gpl.txt)          *
* for more details.                                                         *
*                                                                           *
****************************************************************************/

#ifndef FILTER_IMG_PATCH_PARAM_PLUGIN__VISIBILITYCHECK_H
#define FILTER_IMG_PATCH_PARAM_PLUGIN__VISIBILITYCHECK_H




#include <common/meshmodel.h>
#include <wrap/glw/glw.h>

#define USE_VBO




class VisibilityCheck
{
protected:
    enum VMarker
    {
        V_UNDEFINED ,
        V_BACKFACE  ,
        V_VISIBLE   ,
    };

    glw::Context                &m_Context;
    CMeshO                      *m_Mesh;
    RasterModel                 *m_Raster;
    std::vector<unsigned char>  m_VertFlag;

    static VisibilityCheck      *s_Instance;

    inline                  VisibilityCheck( glw::Context &ctx ) : m_Context(ctx), m_Mesh(NULL), m_Raster(NULL) {}
    virtual                 ~VisibilityCheck()                                                                  {}

public:
    static VisibilityCheck* GetInstance( glw::Context &ctx );
    static void             ReleaseInstance();

    virtual void            setMesh( CMeshO *mesh )                                 = 0;
    virtual void            setRaster( RasterModel *mesh )                          = 0;
    virtual void            checkVisibility()                                       = 0;

    inline bool             isVertVisible( const unsigned int n ) const             { return m_VertFlag[n]==V_VISIBLE; }
    inline bool             isVertVisible( const CVertexO *v ) const                { return isVertVisible( v - &m_Mesh->vert[0] ); }
    inline bool             isVertVisible( const CMeshO::VertexIterator &v ) const  { return isVertVisible( &*v ); }

    inline bool             isFaceVisible( const unsigned int n ) const             { return isFaceVisible( &m_Mesh->face[n] ); }
    inline bool             isFaceVisible( const CFaceO *f ) const                  { return isVertVisible(f->V(0)) || isVertVisible(f->V(1)) || isVertVisible(f->V(2)); }
    inline bool             isFaceVisible( const CMeshO::FaceIterator &f ) const    { return isFaceVisible( &*f ); }
};


class VisibilityCheck_VMV2002 : public VisibilityCheck
{
    friend class VisibilityCheck;

private:
	glw::RenderbufferHandle m_ColorRB;
	glw::RenderbufferHandle m_DepthRB;
	glw::FramebufferHandle  m_FrameBuffer;

    vcg::Point2i            m_ViewportMin;
    vcg::Point2i            m_ViewportMax;

    void        init( std::vector<unsigned char> &visBuffer );
    bool        iteration( std::vector<unsigned char> &visBuffer );
    void        release();

    inline      VisibilityCheck_VMV2002( glw::Context &ctx ) : VisibilityCheck(ctx) {}
    inline      ~VisibilityCheck_VMV2002()                                          {}

public:
    static bool isSupported();

    void        setMesh( CMeshO *mesh )                                             { m_Mesh = mesh; }
    void        setRaster( RasterModel *rm )                                        { m_Raster = rm; }
    void        checkVisibility();
};


class VisibilityCheck_ShadowMap : public VisibilityCheck
{
    friend class VisibilityCheck;

private:
    vcg::Matrix44f          m_Pose;
    vcg::Matrix44f          m_Proj;
    vcg::Matrix44f          m_ShadowProj;
	glw::Texture2DHandle    m_ShadowMap;

    glw::Texture2DHandle    m_VertexMap;
    glw::Texture2DHandle    m_NormalMap;
    glw::RenderbufferHandle m_ColorBuffer;
    glw::FramebufferHandle  m_FBuffer;

    glw::ProgramHandle      m_VisDetectionShader;

    static bool             s_AreVBOSupported;
    glw::BufferHandle       m_ShadowVBOVertices;
    glw::BufferHandle       m_ShadowVBOIndices;

    void        shadowProjMatrices();
    void        setupShadowTexture();
    void        updateShadowTexture();
    void        initMeshTextures();
    bool        initShaders();

                VisibilityCheck_ShadowMap( glw::Context &ctx );
    inline      ~VisibilityCheck_ShadowMap()    {}

public:
    static bool isSupported();

    void        setMesh( CMeshO *mesh );
    void        setRaster( RasterModel *rm );
    void        checkVisibility();
};




#endif // FILTER_IMG_PATCH_PARAM_PLUGIN__VISIBILITYCHECK_H