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

Anticipate a conflict with another branch.

This commit is contained in:
Guillaume Damiand 2019-11-26 13:54:15 +01:00
parent 9a50c0f830
commit e4300e4ddc
2 changed files with 112 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -71,7 +71,7 @@ namespace internal
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()));
return typename Local_kernel::Point_3(converter(p.x()), 0, converter(p.y()));
}
static typename Local_kernel::Point_3 get_local_point(const typename K::Weighted_point_2& p)
{
@ -91,13 +91,18 @@ namespace internal
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()));
return typename Local_kernel::Vector_3(converter(v.x()), 0, converter(v.y()));
}
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);
}
static typename Local_kernel::Ray_2 get_local_ray(const typename K::Ray_2& r)
{
CGAL::Cartesian_converter<K, Local_kernel> converter;
return converter(r);
}
};
// Specialization when K==Local_kernel, because there is no need of convertion here.
@ -116,6 +121,8 @@ namespace internal
{ 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; }
static const typename Local_kernel::Ray_2& get_local_ray(const typename Local_kernel::Ray_2& r)
{ return r; }
};
} // End namespace internal
@ -127,6 +134,7 @@ public:
typedef CGAL::Exact_predicates_inexact_constructions_kernel Local_kernel;
typedef Local_kernel::Point_3 Local_point;
typedef Local_kernel::Vector_3 Local_vector;
typedef Local_kernel::Ray_2 Local_ray;
Buffer_for_vao(std::vector<BufferType>* pos=nullptr,
std::vector<IndexType>* indices=nullptr,
@ -143,6 +151,7 @@ public:
m_zero_x(true),
m_zero_y(true),
m_zero_z(true),
m_inverse_normal(false),
m_face_started(false)
{}
@ -193,6 +202,17 @@ public:
bool has_zero_z() const
{ return m_zero_z; }
void negate_normals()
{
m_inverse_normal=!m_inverse_normal;
for (std::vector<BufferType>*array=m_flat_normal_buffer; array!=nullptr;
array=(array==m_gouraud_normal_buffer?nullptr:m_gouraud_normal_buffer))
{
for (std::size_t i=0; i<array->size(); ++i)
{ (*array)[i]=-(*array)[i]; }
}
}
// 1.1) Add a point, without color. Return the index of the added point.
template<typename KPoint>
std::size_t add_point(const KPoint& kp)
@ -212,6 +232,16 @@ public:
return m_pos_buffer->size()-3;
}
template<typename KPoint>
std::size_t add_point_infinity(const KPoint& kp)
{
if (!has_position()) return (std::size_t)-1;
Local_point p=get_local_point(kp);
add_point_in_buffer(p, *m_pos_buffer);
return m_pos_buffer->size()-3;
}
// 1.2) Add a point, with color.
template<typename KPoint>
void add_point(const KPoint& kp, const CGAL::Color& c)
@ -253,6 +283,44 @@ public:
add_indexed_point(index2);
}
// 3.1) Add a ray segment, without color
template<typename KPoint, typename KVector>
void add_ray_segment(const KPoint& kp1, const KVector& kp2)
{
add_point(kp1);
add_point_infinity(kp2);
}
//3.2) Add a ray segment, with color
template<typename KPoint, typename KVector>
void add_ray_segment(const KPoint& kp1, const KVector& kp2,
const CGAL::Color& c)
{
add_point(kp1);
add_point_infinity(kp2);
add_color(c);
add_color(c);
}
// 4.1) Add a line, without color
template<typename KPoint>
void add_line_segment(const KPoint& kp1, const KPoint& kp2)
{
add_point_infinity(kp1);
add_point_infinity(kp2);
}
// 4.1) Add a line, with color
template<typename KPoint>
void add_line_segment(const KPoint& kp1, const KPoint& kp2,
const CGAL::Color& c)
{
add_point_infinity(kp1);
add_point_infinity(kp2);
add_color(c);
add_color(c);
}
/// @return true iff a face has begun.
bool is_a_face_started() const
{ return m_face_started; }
@ -340,7 +408,7 @@ public:
{
/* std::cerr<<"PB: you try to triangulate a face with "<<m_points_of_face.size()<<" vertices."
<<std::endl; */
m_face_started=false;
m_points_of_face.clear();
m_vertex_normals_for_face.clear();
@ -399,9 +467,10 @@ public:
/// adds `kv` coordinates to `buffer`
template<typename KVector>
static void add_normal_in_buffer(const KVector& kv, std::vector<float>& buffer)
static void add_normal_in_buffer(const KVector& kv, std::vector<float>& buffer,
bool inverse_normal=false)
{
Local_vector n=get_local_vector(kv);
Local_vector n=(inverse_normal?-get_local_vector(kv):get_local_vector(kv));
buffer.push_back(n.x());
buffer.push_back(n.y());
buffer.push_back(n.z());
@ -458,6 +527,8 @@ public:
return true;
}
CGAL::Bbox_3 *bb() const { return m_bb; }
protected:
void face_begin_internal(bool has_color, bool has_normal)
{
@ -484,23 +555,23 @@ protected:
if (m_indices_of_points_of_face.size()>0)
{
add_indexed_point(m_indices_of_points_of_face[i]);
}
}
else
{
add_point(m_points_of_face[i]); // Add the position of the point
if (m_started_face_is_colored)
{ add_color(m_color_of_face); } // Add the color
add_flat_normal(normal); // Add the flat normal
// Its smooth normal (if given by the user)
if (m_vertex_normals_for_face.size()>0)
{ // Here we have 3 vertex normals; we can use Gouraud
add_gouraud_normal(m_vertex_normals_for_face[i]);
}
else
{ // Here user does not provide all vertex normals: we use face normal istead
// and thus we will not be able to use Gouraud
add_gouraud_normal(normal);
}
if (m_started_face_is_colored)
{ add_color(m_color_of_face); } // Add the color
add_flat_normal(normal); // Add the flat normal
// Its smooth normal (if given by the user)
if (m_vertex_normals_for_face.size()>0)
{ // Here we have 3 vertex normals; we can use Gouraud
add_gouraud_normal(m_vertex_normals_for_face[i]);
}
else
{ // Here user does not provide all vertex normals: we use face normal istead
// and thus we will not be able to use Gouraud
add_gouraud_normal(normal);
}
}
}
}
@ -766,14 +837,14 @@ protected:
void add_flat_normal(const KVector& kv)
{
if(m_flat_normal_buffer != nullptr)
{ add_normal_in_buffer(kv, *m_flat_normal_buffer); }
{ add_normal_in_buffer(kv, *m_flat_normal_buffer, m_inverse_normal); }
}
template<typename KVector>
void add_gouraud_normal(const KVector& kv)
{
if(m_gouraud_normal_buffer != nullptr)
{ add_normal_in_buffer(kv, *m_gouraud_normal_buffer); }
{ add_normal_in_buffer(kv, *m_gouraud_normal_buffer, m_inverse_normal); }
}
protected:
@ -826,6 +897,8 @@ protected:
bool m_zero_x; /// True iff all points have x==0
bool m_zero_y; /// True iff all points have y==0
bool m_zero_z; /// True iff all points have z==0
bool m_inverse_normal;;
// Local variables, used when we started a new face.
bool m_face_started;

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

@ -331,6 +331,9 @@ public:
setWindowTitle(title);
resize(500, 450);
if (inverse_normal)
{ negate_all_normals(); }
}
~Basic_viewer_qt()
@ -431,29 +434,27 @@ public:
{ m_buffer_for_colored_segments.add_segment(p1, p2, acolor); }
template <typename KPoint, typename KVector>
void update_bounding_box_for_ray(const KPoint &p, const KVector &v) {
// m_buffer_for_mono_points.add_point(p);
Local_point lp = internal::get_local_point(p);
Local_vector lv = internal::get_local_vector(v);
void update_bounding_box_for_ray(const KPoint &p, const KVector &v)
{
Local_point lp = get_local_point(p);
Local_vector lv = get_local_vector(v);
CGAL::Bbox_3 b = (lp + lv).bbox();
m_bounding_box += b;
// m_bounding_box += CGAL::Bbox_3(b.xmin(), 0, b.ymin(), b.xmax(), 0,
// b.ymax());
}
template <typename KPoint, typename KVector>
void update_bounding_box_for_line(const KPoint &p, const KVector &v,
const KVector &pv)
{
Local_point lp = internal::get_local_point(p);
Local_vector lv = internal::get_local_vector(v);
Local_vector lpv = internal::get_local_vector(pv);
Local_point lp = get_local_point(p);
Local_vector lv = get_local_vector(v);
Local_vector lpv = get_local_vector(pv);
CGAL::Bbox_3 b = lp.bbox() + (lp + lv).bbox() + (lp + lpv).bbox();
m_bounding_box += b;
}
/* template <typename KPoint, typename KVector>
template <typename KPoint, typename KVector>
void add_ray(const KPoint &p, const KVector &v)
{
double bigNumber = 1e30;
@ -481,12 +482,12 @@ public:
double bigNumber = 1e30;
m_buffer_for_colored_lines.add_line_segment((p - (bigNumber)*v),
(p + (bigNumber)*v), acolor);
}*/
}
template<typename KPoint>
void add_text(const KPoint& kp, const QString& txt)
{
Local_point p=internal::get_local_point(kp);
Local_point p=get_local_point(kp);
m_texts.push_back(std::make_tuple(p, txt));
}
@ -1180,9 +1181,9 @@ protected:
if (has_zero_x()) { cx=1.; }
else if (has_zero_y()) { cy=1.; }
else { cz=1.; }
camera()->setViewDirection(CGAL::qglviewer::Vec(cx,cy,cz));
constraint.setRotationConstraintDirection(CGAL::qglviewer::Vec(-cx, -cy, -cz));
camera()->setViewDirection(CGAL::qglviewer::Vec(-cx,-cy,-cz));
constraint.setRotationConstraintDirection(CGAL::qglviewer::Vec(cx, cy, cz));
camera()->frame()->setConstraint(&constraint);
}
@ -1266,11 +1267,8 @@ protected:
void negate_all_normals()
{
for (unsigned int k=BEGIN_NORMAL; k<END_NORMAL; ++k)
{
for (std::size_t i=0; i<arrays[k].size(); ++i)
{ arrays[k][i]=-arrays[k][i]; }
}
m_buffer_for_mono_faces.negate_normals();
m_buffer_for_colored_faces.negate_normals();
}
virtual void keyPressEvent(QKeyEvent *e)