songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Update basic viewer to avoid conflict with another external function.

This commit is contained in:
Guillaume Damiand 2019-10-15 11:16:02 +02:00
parent 8fac29bda2
commit 0707d80d63
5 changed files with 86 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

112
GraphicsView/include/CGAL/Buffer_for_vao.h
View File

@ -39,9 +39,6 @@
namespace CGAL
{
typedef CGAL::Exact_predicates_inexact_constructions_kernel Local_kernel;
typedef Local_kernel::Point_3 Local_point;
typedef Local_kernel::Vector_3 Local_vector;
//------------------------------------------------------------------------------
namespace internal
@ -58,90 +55,77 @@ namespace internal
n.z()+((p.x()-q.x())*(p.y()+q.y())));
}
inline
Local_vector compute_normal_of_face(const std::vector<Local_point>& points)
template <class Point, class Vector>
Vector compute_normal_of_face(const std::vector<Point>& points)
{
Local_vector normal(CGAL::NULL_VECTOR);
Vector normal(CGAL::NULL_VECTOR);
unsigned int nb = 0;
for (std::size_t i=0; i<points.size(); ++i)
{
newell_single_step_3(points[i], points[(i+1)%points.size()], normal);
internal::newell_single_step_3(points[i], points[(i+1)%points.size()],
normal);
++nb;
}
assert(nb>0);
return (Local_kernel::Construct_scaled_vector_3()(normal, 1.0/nb));
return (typename Kernel_traits<Vector>::Kernel::Construct_scaled_vector_3()
(normal, 1.0/nb));
}
////////////////////////////////////////////////////////////////
// Structs to transform any CGAL point/vector into a Local_point/Local_vector
template<typename K>
template<typename K, typename Local_kernel>
struct Geom_utils
{
static Local_point get_local_point(const typename K::Point_2& p)
static typename Local_kernel::Point_3 get_local_point(const typename K::Point_2& p)
{
CGAL::Cartesian_converter<K, Local_kernel> converter;
return Local_point(converter(p.x()), 0, converter(p.y()));
}
static Local_point get_local_point(const typename K::Weighted_point_2& p)
static typename Local_kernel::Point_3 get_local_point(const typename K::Weighted_point_2& p)
{
typename K::Point_2 lp(p);
return Geom_utils<K>::get_local_point(lp);
return Geom_utils<K, Local_kernel>::get_local_point(lp);
}
static Local_point get_local_point(const typename K::Point_3& p)
static typename Local_kernel::Point_3 get_local_point(const typename K::Point_3& p)
{
CGAL::Cartesian_converter<K, Local_kernel> converter;
return converter(p);
}
static Local_point get_local_point(const typename K::Weighted_point_3& p)
static typename Local_kernel::Point_3 get_local_point(const typename K::Weighted_point_3& p)
{
typename K::Point_3 lp(p);
return Geom_utils<K>::get_local_point(lp);
return Geom_utils<K, Local_kernel>::get_local_point(lp);
}
static Local_vector get_local_vector(const typename K::Vector_2& v)
static typename Local_kernel::Vector_3 get_local_vector(const typename K::Vector_2& v)
{
CGAL::Cartesian_converter<K, Local_kernel> converter;
return Local_vector(converter(v.x()), 0, converter(v.y()));
}
static Local_vector get_local_vector(const typename K::Vector_3& v)
static typename Local_kernel::Vector_3 get_local_vector(const typename K::Vector_3& v)
{
CGAL::Cartesian_converter<K, Local_kernel> converter;
return converter(v);
}
};
// Specialization for Local_kernel, because there is no need of convertion here.
template<>
struct Geom_utils<Local_kernel>
// Specialization when K==Local_kernel, because there is no need of convertion here.
template<typename Local_kernel>
struct Geom_utils<Local_kernel, Local_kernel>
{
static Local_point get_local_point(const Local_kernel::Point_2& p)
{ return Local_point(p.x(), 0, p.y()); }
static Local_point get_local_point(const Local_kernel::Weighted_point_2& p)
{ return Local_point(p.point().x(), 0, p.point().y());}
static const Local_point & get_local_point(const Local_kernel::Point_3& p)
static typename Local_kernel::Point_3 get_local_point(const typename Local_kernel::Point_2& p)
{ return typename Local_kernel::Point_3(p.x(), 0, p.y()); }
static typename Local_kernel::Point_3 get_local_point(const typename Local_kernel::Weighted_point_2& p)
{ return typename Local_kernel::Point_3(p.point().x(), 0, p.point().y());}
static const typename Local_kernel::Point_3 & get_local_point(const typename Local_kernel::Point_3& p)
{ return p; }
static Local_point get_local_point(const Local_kernel::Weighted_point_3& p)
{ return Local_point(p);}
static Local_vector get_local_vector(const Local_kernel::Vector_2& v)
{ return Local_vector(v.x(), 0, v.y()); }
static const Local_vector& get_local_vector(const Local_kernel::Vector_3& v)
static typename Local_kernel::Point_3 get_local_point(const typename Local_kernel::Weighted_point_3& p)
{ return typename Local_kernel::Point_3(p);}
static typename Local_kernel::Vector_3 get_local_vector(const typename Local_kernel::Vector_2& v)
{ return typename Local_kernel::Vector_3(v.x(), 0, v.y()); }
static const typename Local_kernel::Vector_3& get_local_vector(const typename Local_kernel::Vector_3& v)
{ return v; }
};
////////////////////////////////////////////////////////////////
// Global function to simplify function calls.
template<typename KPoint>
Local_point get_local_point(const KPoint& p)
{
return Geom_utils<typename CGAL::Kernel_traits<KPoint>::Kernel>::
get_local_point(p);
}
template<typename KVector>
Local_vector get_local_vector(const KVector& v)
{
return Geom_utils<typename CGAL::Kernel_traits<KVector>::Kernel>::
get_local_vector(v);
}
};
} // End namespace internal
//------------------------------------------------------------------------------
@ -149,6 +133,10 @@ template<typename BufferType=float, typename IndexType=std::size_t>
class Buffer_for_vao
{
public:
typedef CGAL::Exact_predicates_inexact_constructions_kernel Local_kernel;
typedef Local_kernel::Point_3 Local_point;
typedef Local_kernel::Vector_3 Local_vector;
Buffer_for_vao(std::vector<BufferType>* pos=nullptr,
std::vector<IndexType>* indices=nullptr,
CGAL::Bbox_3* bbox=nullptr,
@ -220,7 +208,7 @@ public:
{
if (!has_position()) return (std::size_t)-1;
Local_point p=internal::get_local_point(kp);
Local_point p=get_local_point(kp);
add_point_in_buffer(p, *m_pos_buffer);
if (m_bb!=nullptr)
@ -293,7 +281,7 @@ public:
template<typename KNormal>
void face_begin(const KNormal& kv)
{
m_normal_of_face=internal::get_local_vector(kv);
m_normal_of_face=get_local_vector(kv);
face_begin_internal(false, true);
}
@ -302,7 +290,7 @@ public:
void face_begin(const CGAL::Color& c, const KNormal& kv)
{
m_color_of_face=c;
m_normal_of_face=internal::get_local_vector(kv);
m_normal_of_face=get_local_vector(kv);
face_begin_internal(true, true);
}
@ -314,7 +302,7 @@ public:
{
if (!is_a_face_started()) return false;
Local_point p=internal::get_local_point(kp);
Local_point p=get_local_point(kp);
if (m_points_of_face.empty() || m_points_of_face.back()!=p) // TODO test if the distance between prev point and kp is smaller than an epsilon (?? not sure ??)
{
m_points_of_face.push_back(p);
@ -331,7 +319,7 @@ public:
{
if (add_point_in_face(kp))
{
m_vertex_normals_for_face.push_back(internal::get_local_vector(p_normal));
m_vertex_normals_for_face.push_back(get_local_vector(p_normal));
return true;
}
return false;
@ -388,7 +376,8 @@ public:
}
Local_vector normal=(m_started_face_has_normal?m_normal_of_face:
internal::compute_normal_of_face(m_points_of_face));
internal::compute_normal_of_face
<Local_point, Local_vector>(m_points_of_face));
if (m_points_of_face.size()==3)
{ triangular_face_end_internal(normal); } // Triangle: no need to triangulate
@ -411,7 +400,7 @@ public:
template<typename KPoint>
static void add_point_in_buffer(const KPoint& kp, std::vector<float>& buffer)
{
Local_point p=internal::get_local_point(kp);
Local_point p=get_local_point(kp);
buffer.push_back(p.x());
buffer.push_back(p.y());
buffer.push_back(p.z());
@ -421,7 +410,7 @@ public:
template<typename KVector>
static void add_normal_in_buffer(const KVector& kv, std::vector<float>& buffer)
{
Local_vector n=internal::get_local_vector(kv);
Local_vector n=get_local_vector(kv);
buffer.push_back(n.x());
buffer.push_back(n.y());
buffer.push_back(n.z());
@ -796,6 +785,21 @@ protected:
{ add_normal_in_buffer(kv, *m_gouraud_normal_buffer); }
}
protected:
// Shortcuts to simplify function calls.
template<typename KPoint>
static Local_point get_local_point(const KPoint& p)
{
return internal::Geom_utils<typename CGAL::Kernel_traits<KPoint>::Kernel, Local_kernel>::
get_local_point(p);
}
template<typename KVector>
static Local_vector get_local_vector(const KVector& v)
{
return internal::Geom_utils<typename CGAL::Kernel_traits<KVector>::Kernel, Local_kernel>::
get_local_vector(v);
}
protected:
// Types usefull for triangulation
struct Vertex_info

14
GraphicsView/include/CGAL/Qt/Basic_viewer_qt.h
View File

@ -446,6 +446,20 @@ public:
}
protected:
// Shortcuts to simplify function calls.
template<typename KPoint>
static Local_point get_local_point(const KPoint& p)
{
return internal::Geom_utils<typename CGAL::Kernel_traits<KPoint>::Kernel, Local_kernel>::
get_local_point(p);
}
template<typename KVector>
static Local_vector get_local_vector(const KVector& v)
{
return internal::Geom_utils<typename CGAL::Kernel_traits<KVector>::Kernel, Local_kernel>::
get_local_vector(v);
}
void compile_shaders()
{
rendering_program_face.removeAllShaders();

19
Linear_cell_complex/include/CGAL/draw_linear_cell_complex.h
View File

@ -127,29 +127,30 @@ struct DefaultDrawingFunctorLCC
}
};
template<class LCC, class Kernel, int dim=LCC::ambient_dimension>
template<class LCC, class Local_kernel, int dim=LCC::ambient_dimension>
struct LCC_geom_utils;
template<class LCC, class Kernel>
struct LCC_geom_utils<LCC, Kernel, 3>
template<class LCC, class Local_kernel>
struct LCC_geom_utils<LCC, Local_kernel, 3>
{
static typename Kernel::Vector_3
static typename Local_kernel::Vector_3
get_vertex_normal(const LCC& lcc, typename LCC::Dart_const_handle dh)
{
typename Kernel::Vector_3 n = internal::Geom_utils<typename LCC::Traits>::
typename Local_kernel::Vector_3 n = internal::Geom_utils
<typename LCC::Traits, Local_kernel>::
get_local_vector(CGAL::compute_normal_of_cell_0<LCC>(lcc,dh));
n = n/(CGAL::sqrt(n*n));
return n;
}
};
template<class LCC, class Kernel>
struct LCC_geom_utils<LCC, Kernel, 2>
template<class LCC, class Local_kernel>
struct LCC_geom_utils<LCC, Local_kernel, 2>
{
static typename Kernel::Vector_3
static typename Local_kernel::Vector_3
get_vertex_normal(const LCC&, typename LCC::Dart_const_handle)
{
typename Kernel::Vector_3 n=CGAL::NULL_VECTOR;
typename Local_kernel::Vector_3 n=CGAL::NULL_VECTOR;
return n;
}
};

4
Polyhedron/include/CGAL/draw_polyhedron.h
View File

@ -157,8 +157,8 @@ protected:
do
{
internal::newell_single_step_3
(internal::Geom_utils<Kernel>::get_local_point(he->vertex()->point()),
internal::Geom_utils<Kernel>::get_local_point(he->next()->vertex()->point()),
(this->get_local_point(he->vertex()->point()),
this->get_local_point(he->next()->vertex()->point()),
normal);
++nb;
he=he->next();

4
Surface_mesh/include/CGAL/draw_surface_mesh.h
View File

@ -165,8 +165,8 @@ protected:
do
{
internal::newell_single_step_3
(internal::Geom_utils<Kernel>::get_local_point(sm.point(sm.source(he))),
internal::Geom_utils<Kernel>::get_local_point(sm.point(sm.target(he))), normal);
(this->get_local_point(sm.point(sm.source(he))),
this->get_local_point(sm.point(sm.target(he))), normal);
++nb;
he=sm.next(he);
}