Skip to content
GitLab
Projects
Groups
Snippets
/
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
Menu
Open sidebar
Hurstel
CGoGN
Commits
be1ee120
Commit
be1ee120
authored
Feb 15, 2011
by
Sylvain Thery
Browse files
Ajout rendu et interface OpenGL3
parent
ea955ff5
Changes
19
Expand all
Hide whitespace changes
Inline
Side-by-side
Apps/Tuto/CMakeLists.txt
View file @
be1ee120
...
...
@@ -16,6 +16,7 @@ include_directories(
${
CGoGN_ROOT_DIR
}
/ThirdParty/gzstream
${
CGoGN_ROOT_DIR
}
/ThirdParty/OpenCTM
${
CGoGN_ROOT_DIR
}
/ThirdParty/Assimp/include
${
CGoGN_ROOT_DIR
}
/ThirdParty/glm
${
CGoGN_ROOT_DIR
}
/include
)
...
...
@@ -56,3 +57,9 @@ add_executable( tuto_mt tuto_mt.cpp)
target_link_libraries
(
tuto_mt
containerD topologyD utilsD algoD
${
COMMON_LIBS
}
boost_thread
)
# container topology utils algo ${COMMON_LIBS} boost_thread)
add_executable
(
tuto_ogl3 tuto_ogl3.cpp
)
target_link_libraries
(
tuto_ogl3
containerD topologyD utilsD algoD
${
COMMON_LIBS
}
)
# container topology utils algo ${COMMON_LIBS} )
include/Algo/Render/gl3mapRender.h
0 → 100644
View file @
be1ee120
/*******************************************************************************
* CGoGN: Combinatorial and Geometric modeling with Generic N-dimensional Maps *
* version 0.1 *
* Copyright (C) 2009, IGG Team, LSIIT, University of Strasbourg *
* *
* This library is free software; you can redistribute it and/or modify it *
* under the terms of the GNU Lesser General Public License as published by the *
* Free Software Foundation; either version 2.1 of the License, or (at your *
* option) any later version. *
* *
* This library 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 Lesser General Public License *
* for more details. *
* *
* You should have received a copy of the GNU Lesser General Public License *
* along with this library; if not, write to the Free Software Foundation, *
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
* *
* Web site: https://iggservis.u-strasbg.fr/CGoGN/ *
* Contact information: cgogn@unistra.fr *
* *
*******************************************************************************/
#ifndef _GL3_MAP_RENDER_
#define _GL3_MAP_RENDER_
#include
<GL/glew.h>
#include
<vector>
#include
<list>
#include
"Topology/generic/dart.h"
#include
"Topology/generic/functor.h"
#include
"Topology/generic/attributeHandler.h"
#include
"Container/convert.h"
#include
"Geometry/vector_gen.h"
namespace
CGoGN
{
namespace
Algo
{
namespace
Render
{
namespace
GL3
{
enum
drawingType
{
TRIANGLES
=
1
,
LINES
=
2
,
POINTS
=
4
,
EXPLODED
=
8
,
FLAT_TRIANGLES
=
16
,
ERR
=
32
}
;
enum
bufferIndex
{
TRIANGLE_INDICES
=
0
,
LINE_INDICES
=
1
,
POINT_INDICES
=
2
,
FLAT_BUFFER
=
3
,
FIRST_ATTRIBUTE_BUFFER
=
4
,
}
;
const
unsigned
int
NB_BUFFERS
=
16
;
class
MapRender
{
protected:
/**
* vbo buffers
*/
GLuint
m_VBOBuffers
[
NB_BUFFERS
]
;
// bool m_allocatedBuffers[NB_BUFFERS] ;
// bool m_usedBuffers[NB_BUFFERS] ;
bool
m_allocatedAttributes
[
NB_BUFFERS
]
;
bool
m_usedAttributes
[
NB_BUFFERS
]
;
unsigned
int
m_AttributesDataSize
[
NB_BUFFERS
];
/**
* number of indices of triangles
*/
GLuint
m_nbIndicesTri
;
/**
* number of indices of lines
*/
GLuint
m_nbIndicesLines
;
/**
* number of indices of points
*/
GLuint
m_nbIndicesPoints
;
/**
* number of elts for flat vbo
*/
GLuint
m_nbFlatElts
;
public:
/**
* Constructor
*/
MapRender
()
;
/**
* Constructor that share vertices attributes vbo (position/normals/colors...)
*/
MapRender
(
const
MapRender
&
mrvbo
);
/**
* Destructor
*/
~
MapRender
()
;
/**
* update the data
* @param uptype that have to be updated: POSITIONS, NORMALS, COLORS, TEXCOORDS, ???
* @param attribId attribute where data is stored
* @param conv Callback of attribute conversion (NULL if direct copy, default value)
*/
template
<
typename
ATTR_HANDLER
>
void
updateData
(
unsigned
int
vertex_attrib
,
const
ATTR_HANDLER
&
attrib
,
ConvertAttrib
*
conv
=
NULL
)
;
/**
* enable a vertex attribute for rendering (updateDate automatically enable attrib)
*/
void
enableVertexAttrib
(
unsigned
int
index
);
/**
* disable a vertex attribute for rendering
*/
void
disableVertexAttrib
(
unsigned
int
index
);
protected:
/**
* fill buffer directly from attribute
*/
template
<
typename
ATTR_HANDLER
>
void
fillBufferDirect
(
unsigned
int
indexVBO
,
const
ATTR_HANDLER
&
attrib
)
;
/**
* fill buffer with conversion from attribute
*/
template
<
typename
ATTR_HANDLER
>
void
fillBufferConvert
(
unsigned
int
indexVBO
,
const
ATTR_HANDLER
&
attrib
,
ConvertAttrib
*
conv
)
;
/**
* addition of indices table of one triangle
* @param d a dart of the triangle
* @param tableIndices the indices table
*/
template
<
typename
PFP
>
void
addTri
(
typename
PFP
::
MAP
&
map
,
Dart
d
,
std
::
vector
<
GLuint
>&
tableIndices
)
;
public:
/**
* creation of indices table of triangles (optimized order)
* @param tableIndices the table where indices are stored
*/
template
<
typename
PFP
>
void
initTriangles
(
typename
PFP
::
MAP
&
map
,
const
FunctorSelect
&
good
,
std
::
vector
<
GLuint
>&
tableIndices
,
unsigned
int
thread
=
0
)
;
template
<
typename
PFP
>
void
initTrianglesOptimized
(
typename
PFP
::
MAP
&
map
,
const
FunctorSelect
&
good
,
std
::
vector
<
GLuint
>&
tableIndices
,
unsigned
int
thread
=
0
)
;
/**
* creation of indices table of lines (optimized order)
* @param tableIndices the table where indices are stored
*/
template
<
typename
PFP
>
void
initLines
(
typename
PFP
::
MAP
&
map
,
const
FunctorSelect
&
good
,
std
::
vector
<
GLuint
>&
tableIndices
,
unsigned
int
thread
=
0
)
;
template
<
typename
PFP
>
void
initLinesOptimized
(
typename
PFP
::
MAP
&
map
,
const
FunctorSelect
&
good
,
std
::
vector
<
GLuint
>&
tableIndices
,
unsigned
int
thread
=
0
)
;
/**
* creation of indices table of points
* @param tableIndices the table where indices are stored
*/
template
<
typename
PFP
>
void
initPoints
(
typename
PFP
::
MAP
&
map
,
const
FunctorSelect
&
good
,
std
::
vector
<
GLuint
>&
tableIndices
,
unsigned
int
thread
=
0
)
;
/**
* creation of VBO for flat faces rendering
*/
template
<
typename
PFP
>
void
initFlatTriangles
(
typename
PFP
::
MAP
&
map
,
unsigned
int
vertex_attrib_position
,
const
FunctorSelect
&
good
=
SelectorTrue
()
,
unsigned
int
thread
=
0
);
/**
* initialization of the VBO indices primitives
* computed by a traversal of the map
* @param prim primitive to draw: VBO_TRIANGLES, VBO_LINES
*/
template
<
typename
PFP
>
void
initPrimitives
(
typename
PFP
::
MAP
&
map
,
const
FunctorSelect
&
good
,
int
prim
,
bool
optimized
=
true
,
unsigned
int
thread
=
0
)
;
/**
* initialization of the VBO indices primitives
* using the given table
* @param prim primitive to draw: VBO_TRIANGLES, VBO_LINES
*/
void
initPrimitives
(
int
prim
,
std
::
vector
<
GLuint
>&
tableIndices
)
;
protected:
/**
* Drawing triangles function
*/
void
drawTriangles
(
bool
bindColors
=
true
)
;
/**
* Drawing lines function
*/
void
drawLines
(
bool
bindColors
=
true
)
;
/**
* Drawing points function
*/
void
drawPoints
(
bool
bindColors
=
true
)
;
/**
* Drawing flat faces function
*/
void
drawFlat
();
public:
/**
* draw the VBO (function to call in the drawing callback)
*/
void
draw
(
int
prim
,
bool
bindColors
=
true
)
;
}
;
}
// namespace VBO
}
// namespace Render
}
// namespace Algo
}
// namespace CGoGN
#include
"Algo/Render/gl3mapRender.hpp"
#endif
include/Algo/Render/gl3mapRender.hpp
0 → 100644
View file @
be1ee120
/*******************************************************************************
* CGoGN: Combinatorial and Geometric modeling with Generic N-dimensional Maps *
* version 0.1 *
* Copyright (C) 2009, IGG Team, LSIIT, University of Strasbourg *
* *
* This library is free software; you can redistribute it and/or modify it *
* under the terms of the GNU Lesser General Public License as published by the *
* Free Software Foundation; either version 2.1 of the License, or (at your *
* option) any later version. *
* *
* This library 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 Lesser General Public License *
* for more details. *
* *
* You should have received a copy of the GNU Lesser General Public License *
* along with this library; if not, write to the Free Software Foundation, *
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
* *
* Web site: https://iggservis.u-strasbg.fr/CGoGN/ *
* Contact information: cgogn@unistra.fr *
* *
*******************************************************************************/
#include
"Topology/generic/dartmarker.h"
#include
"Topology/generic/cellmarker.h"
namespace
CGoGN
{
namespace
Algo
{
namespace
Render
{
namespace
GL3
{
template
<
typename
ATTR_HANDLER
>
void
MapRender
::
updateData
(
unsigned
int
vertex_attrib
,
const
ATTR_HANDLER
&
attrib
,
ConvertAttrib
*
conv
)
{
// choisit le bon buffer en fonction du paramètre upType
unsigned
int
indexVBO
=
vertex_attrib
+
FIRST_ATTRIBUTE_BUFFER
;
if
(
!
m_allocatedAttributes
[
vertex_attrib
]
)
{
glGenBuffersARB
(
1
,
&
(
m_VBOBuffers
[
indexVBO
]))
;
m_allocatedAttributes
[
vertex_attrib
]
=
true
;
}
m_usedAttributes
[
vertex_attrib
]
=
true
;
m_AttributesDataSize
[
vertex_attrib
]
=
sizeof
(
typename
ATTR_HANDLER
::
DATA_TYPE
)
/
sizeof
(
float
);
if
(
conv
)
fillBufferConvert
(
indexVBO
,
attrib
,
conv
)
;
else
fillBufferDirect
(
indexVBO
,
attrib
)
;
}
template
<
typename
ATTR_HANDLER
>
void
MapRender
::
fillBufferDirect
(
unsigned
int
indexVBO
,
const
ATTR_HANDLER
&
attrib
)
{
AttribMultiVect
<
typename
ATTR_HANDLER
::
DATA_TYPE
>*
mv
=
attrib
.
getDataVector
()
;
std
::
vector
<
void
*>
addr
;
unsigned
int
byteTableSize
;
unsigned
int
nbb
=
mv
->
getStartAddresses
(
addr
,
byteTableSize
);
glBindBufferARB
(
GL_ARRAY_BUFFER
,
m_VBOBuffers
[
indexVBO
]);
glBufferDataARB
(
GL_ARRAY_BUFFER
,
nbb
*
byteTableSize
,
0
,
GL_STREAM_DRAW
);
unsigned
int
offset
=
0
;
for
(
unsigned
int
i
=
0
;
i
<
nbb
;
++
i
)
{
glBufferSubDataARB
(
GL_ARRAY_BUFFER
,
offset
,
byteTableSize
,
addr
[
i
]);
offset
+=
byteTableSize
;
}
}
template
<
typename
ATTR_HANDLER
>
void
MapRender
::
fillBufferConvert
(
unsigned
int
indexVBO
,
const
ATTR_HANDLER
&
attrib
,
ConvertAttrib
*
conv
)
{
AttribMultiVect
<
typename
ATTR_HANDLER
::
DATA_TYPE
>*
mv
=
attrib
.
getDataVector
()
;
std
::
vector
<
void
*>
addr
;
unsigned
int
byteTableSize
;
unsigned
int
nbb
=
mv
->
getStartAddresses
(
addr
,
byteTableSize
);
// alloue la memoire pour le buffer et initialise le conv
conv
->
reserve
(
mv
->
BlockSize
());
// bind buffer to update
glBindBufferARB
(
GL_ARRAY_BUFFER
,
m_VBOBuffers
[
indexVBO
]);
glBufferDataARB
(
GL_ARRAY_BUFFER
,
nbb
*
conv
->
sizeBuffer
(),
0
,
GL_STREAM_DRAW
);
unsigned
int
offset
=
0
;
for
(
unsigned
int
i
=
0
;
i
<
nbb
;
++
i
)
{
// convertit les donnees dans le buffer de conv
conv
->
convert
(
addr
[
i
]);
// update sub-vbo
glBufferSubDataARB
(
GL_ARRAY_BUFFER
,
offset
,
conv
->
sizeBuffer
(),
conv
->
buffer
());
// block suivant
offset
+=
conv
->
sizeBuffer
();
}
// libere la memoire de la conversion
conv
->
release
();
}
template
<
typename
PFP
>
inline
void
MapRender
::
addTri
(
typename
PFP
::
MAP
&
map
,
Dart
d
,
std
::
vector
<
GLuint
>&
tableIndices
)
{
Dart
a
=
d
;
Dart
b
=
map
.
phi1
(
a
);
Dart
c
=
map
.
phi1
(
b
);
// loop to cut a polygon in triangle on the fly (works only with convex faces)
do
{
tableIndices
.
push_back
(
map
.
getEmbedding
(
d
,
VERTEX_ORBIT
));
tableIndices
.
push_back
(
map
.
getEmbedding
(
b
,
VERTEX_ORBIT
));
tableIndices
.
push_back
(
map
.
getEmbedding
(
c
,
VERTEX_ORBIT
));
b
=
c
;
c
=
map
.
phi1
(
b
);
}
while
(
c
!=
d
);
}
template
<
typename
PFP
>
void
MapRender
::
initTriangles
(
typename
PFP
::
MAP
&
map
,
const
FunctorSelect
&
good
,
std
::
vector
<
GLuint
>&
tableIndices
,
unsigned
int
thread
)
{
DartMarker
m
(
map
,
thread
);
tableIndices
.
reserve
(
4
*
map
.
getNbDarts
()
/
3
);
for
(
Dart
dd
=
map
.
begin
();
dd
!=
map
.
end
();
map
.
next
(
dd
))
{
if
(
!
m
.
isMarked
(
dd
)
&&
good
(
dd
))
{
addTri
<
PFP
>
(
map
,
dd
,
tableIndices
);
m
.
markOrbit
(
FACE_ORBIT
,
dd
);
}
}
}
template
<
typename
PFP
>
void
MapRender
::
initTrianglesOptimized
(
typename
PFP
::
MAP
&
map
,
const
FunctorSelect
&
good
,
std
::
vector
<
GLuint
>&
tableIndices
,
unsigned
int
thread
)
{
#define LIST_SIZE 20
DartMarker
m
(
map
,
thread
);
// reserve memory for triangles ( nb indices == nb darts )
// and a little bit more
// if lots of polygonal faces, realloc is done by vector
tableIndices
.
reserve
(
4
*
map
.
getNbDarts
()
/
3
);
for
(
Dart
dd
=
map
.
begin
();
dd
!=
map
.
end
();
map
.
next
(
dd
))
{
if
(
!
m
.
isMarked
(
dd
))
{
std
::
list
<
Dart
>
bound
;
if
(
good
(
dd
))
addTri
<
PFP
>
(
map
,
dd
,
tableIndices
);
m
.
markOrbit
(
FACE_ORBIT
,
dd
);
bound
.
push_back
(
dd
);
int
nb
=
1
;
do
{
Dart
e
=
bound
.
back
();
Dart
ee
=
e
;
do
{
Dart
f
=
ee
;
do
{
if
(
!
m
.
isMarked
(
f
))
{
if
(
good
(
f
))
addTri
<
PFP
>
(
map
,
f
,
tableIndices
);
m
.
markOrbit
(
FACE_ORBIT
,
f
);
bound
.
push_back
(
map
.
phi1
(
f
));
++
nb
;
if
(
nb
>
LIST_SIZE
)
{
bound
.
pop_front
();
--
nb
;
}
}
f
=
map
.
phi1
(
map
.
phi2
(
f
));
}
while
(
f
!=
ee
);
ee
=
map
.
phi1
(
ee
);
}
while
(
ee
!=
e
);
bound
.
pop_back
();
--
nb
;
}
while
(
!
bound
.
empty
());
}
}
#undef LIST_SIZE
}
template
<
typename
PFP
>
void
MapRender
::
initLines
(
typename
PFP
::
MAP
&
map
,
const
FunctorSelect
&
good
,
std
::
vector
<
GLuint
>&
tableIndices
,
unsigned
int
thread
)
{
DartMarker
m
(
map
,
thread
);
tableIndices
.
reserve
(
map
.
getNbDarts
());
for
(
Dart
d
=
map
.
begin
();
d
!=
map
.
end
();
map
.
next
(
d
))
{
if
(
!
m
.
isMarked
(
d
)
&&
good
(
d
))
{
tableIndices
.
push_back
(
map
.
getEmbedding
(
d
,
VERTEX_ORBIT
));
tableIndices
.
push_back
(
map
.
getEmbedding
(
map
.
phi2
(
d
),
VERTEX_ORBIT
));
m
.
markOrbit
(
EDGE_ORBIT
,
d
);
}
}
}
template
<
typename
PFP
>
void
MapRender
::
initLinesOptimized
(
typename
PFP
::
MAP
&
map
,
const
FunctorSelect
&
good
,
std
::
vector
<
GLuint
>&
tableIndices
,
unsigned
int
thread
)
{
#define LIST_SIZE 20
DartMarker
m
(
map
,
thread
);
// reserve memory for edges indices ( nb indices == nb darts)
tableIndices
.
reserve
(
map
.
getNbDarts
());
for
(
Dart
dd
=
map
.
begin
();
dd
!=
map
.
end
();
map
.
next
(
dd
))
{
if
(
!
m
.
isMarked
(
dd
))
{
std
::
list
<
Dart
>
bound
;
bound
.
push_back
(
dd
);
int
nb
=
1
;
do
{
Dart
e
=
bound
.
back
();
Dart
ee
=
e
;
do
{
Dart
f
=
map
.
phi2
(
ee
);
if
(
!
m
.
isMarked
(
ee
))
{
if
(
good
(
ee
))
tableIndices
.
push_back
(
map
.
getEmbedding
(
ee
,
VERTEX_ORBIT
));
if
(
good
(
f
))
tableIndices
.
push_back
(
map
.
getEmbedding
(
map
.
phi1
(
ee
),
VERTEX_ORBIT
));
m
.
markOrbit
(
EDGE_ORBIT
,
f
);
bound
.
push_back
(
f
);
++
nb
;
if
(
nb
>
LIST_SIZE
)
{
bound
.
pop_front
();
--
nb
;
}
}
ee
=
map
.
phi1
(
f
);
}
while
(
ee
!=
e
);
bound
.
pop_back
();
--
nb
;
}
while
(
!
bound
.
empty
());
}
}
#undef LIST_SIZE
}
template
<
typename
PFP
>
void
MapRender
::
initPoints
(
typename
PFP
::
MAP
&
map
,
const
FunctorSelect
&
good
,
std
::
vector
<
GLuint
>&
tableIndices
,
unsigned
int
thread
)
{
CellMarker
m
(
map
,
VERTEX_ORBIT
,
thread
)
;
tableIndices
.
reserve
(
map
.
getNbDarts
()
/
5
);
for
(
Dart
d
=
map
.
begin
();
d
!=
map
.
end
();
map
.
next
(
d
))
{
if
(
!
m
.
isMarked
(
d
)
&&
good
(
d
))
{
tableIndices
.
push_back
(
map
.
getEmbedding
(
d
,
VERTEX_ORBIT
));
m
.
mark
(
d
)
;
}
}
}
template
<
typename
PFP
>
void
MapRender
::
initPrimitives
(
typename
PFP
::
MAP
&
map
,
const
FunctorSelect
&
good
,
int
prim
,
bool
optimized
,
unsigned
int
thread
)
{
std
::
vector
<
GLuint
>
tableIndices
;
// indice du VBO a utiliser
int
vbo_ind
=
0
;
switch
(
prim
)
{
case
FLAT_TRIANGLES
:
break
;
case
TRIANGLES
:
if
(
optimized
)
initTrianglesOptimized
<
PFP
>
(
map
,
good
,
tableIndices
,
thread
);
else
initTriangles
<
PFP
>
(
map
,
good
,
tableIndices
,
thread
)
;
m_nbIndicesTri
=
tableIndices
.
size
();
vbo_ind
=
m_VBOBuffers
[
TRIANGLE_INDICES
];
break
;
case
LINES
:
if
(
optimized
)
initLinesOptimized
<
PFP
>
(
map
,
good
,
tableIndices
,
thread
);
else
initLines
<
PFP
>
(
map
,
good
,
tableIndices
,
thread
)
;
m_nbIndicesLines
=
tableIndices
.
size
();
vbo_ind
=
m_VBOBuffers
[
LINE_INDICES
];
break
;
case
POINTS
:
initPoints
<
PFP
>
(
map
,
good
,
tableIndices
,
thread
);
m_nbIndicesPoints
=
tableIndices
.
size
();
vbo_ind
=
m_VBOBuffers
[
POINT_INDICES
];
break
;
default:
std
::
cerr
<<
"problem initializing VBO indices"
<<
std
::
endl
;
break
;
}
unsigned
int
size
=
tableIndices
.
size
();
// setup du buffer d'indices
glBindBufferARB
(
GL_ELEMENT_ARRAY_BUFFER
,
vbo_ind
);
glBufferDataARB
(
GL_ELEMENT_ARRAY_BUFFER
,
size
*
sizeof
(
GLuint
),
&
(
tableIndices
[
0
]),
GL_STREAM_DRAW
);
}
template
<
typename
PFP
>