ViewEdgeXBuilder.h

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once

 
#include <map>
#include <utility>
#include <vector>
 
#if 0  // soc
#  if defined(__GNUC__) && (__GNUC__ >= 3)
/* hash_map is not part of the C++ standard anymore;
 * hash_map.h has been kept though for backward compatibility */
#    include <hash_map.h>
#  else
#    include <hash_map>
#  endif
#endif
 
#include "Interface1D.h"
 
#include "../geometry/Geom.h"
 
#include "../system/FreestyleConfig.h"
 
#include "MEM_guardedalloc.h"
 
using namespace std;
 
namespace Freestyle {
 
using namespace Geometry;
 
class SVertex;

struct SVertexHasher {
#define _MUL 950706376UL
#define _MOD 2147483647UL
  inline size_t operator()(const Vec3r &p) const
  {
    size_t res = (ulong(p[0] * _MUL)) % _MOD;
    res = ((res + ulong(p[1]) * _MUL)) % _MOD;
    return ((res + ulong(p[2]) * _MUL)) % _MOD;
  }
#undef _MUL
#undef _MOD
};
 
// Key_compare predicate for hash_map. In particular, return false if equal.
struct epsilonEquals {
  bool operator()(const Vec3r &v1, const Vec3r &v2) const
  {
    real norm = (v1 - v2).norm();
    return (norm < 1.0e-06);
  }
};
 
// typedef hash_map<Vec3r, SVertex*, SVertexHasher, epsilonEquals> SVertexMap;
typedef map<Vec3r, SVertex *> SVertexMap;
 
class WXFaceLayer;

class OWXFaceLayer {
 public:
  WXFaceLayer *fl;
  bool order;
 
  OWXFaceLayer()
  {
    fl = nullptr;
    order = true;
  }
 
  OWXFaceLayer(WXFaceLayer *ifl, bool iOrder = true)
  {
    fl = ifl;
    order = iOrder;
  }
 
  OWXFaceLayer &operator=(const OWXFaceLayer &iBrother)
  {
    fl = iBrother.fl;
    order = iBrother.order;
    return *this;
  }
 
  bool operator==(const OWXFaceLayer &b)
  {
    return ((fl == b.fl) && (order == b.order));
  }
 
  bool operator!=(const OWXFaceLayer &b)
  {
    return !(*this == b);
  }
 
  MEM_CXX_CLASS_ALLOC_FUNCS("Freestyle:OWXFaceLayer")
};
 
class WXEdge;

class OWXEdge {
 public:
  WXEdge *e;
  bool order;
 
  OWXEdge()
  {
    e = nullptr;
    order = true;
  }
 
  OWXEdge(WXEdge *ie, bool iOrder = true)
  {
    e = ie;
    order = iOrder;
  }
 
  OWXEdge &operator=(const OWXEdge &iBrother)
  {
    e = iBrother.e;
    order = iBrother.order;
    return *this;
  }
 
  bool operator==(const OWXEdge &b)
  {
    return ((e == b.e) && (order == b.order));
  }
 
  bool operator!=(const OWXEdge &b)
  {
    return !(*this == b);
  }
 
  MEM_CXX_CLASS_ALLOC_FUNCS("Freestyle:OWXEdge")
};
 
class WOEdge;
class WXEdge;
class WXShape;
class SVertex;
class FEdge;
class ViewVertex;
class ViewEdge;
class ViewShape;
 
class ViewEdgeXBuilder {
 protected:
  int _currentViewId;     // Id for view edges
  int _currentFId;        // Id for FEdges
  int _currentSVertexId;  // Id for SVertex
 
 public:
  inline ViewEdgeXBuilder()
  {
    _currentViewId = 1;
    _currentFId = 0;
    _currentSVertexId = 0;
  }
 
  virtual ~ViewEdgeXBuilder() {}

  virtual void BuildViewEdges(WXShape *iWShape,
                              ViewShape *oVShape,
                              std::vector<ViewEdge *> &ioVEdges,
                              std::vector<ViewVertex *> &ioVVertices,
                              std::vector<FEdge *> &ioFEdges,
                              std::vector<SVertex *> &ioSVertices);

  ViewEdge *BuildSmoothViewEdge(const OWXFaceLayer &iFaceLayer);

  ViewEdge *BuildSharpViewEdge(const OWXEdge &iWEdge);
 
 public:
  inline int currentViewId() const
  {
    return _currentViewId;
  }
 
  inline int currentFId() const
  {
    return _currentFId;
  }
 
  inline int currentSVertexId() const
  {
    return _currentSVertexId;
  }

  inline void setCurrentViewId(int id)
  {
    _currentViewId = id;
  }
 
  inline void setCurrentFId(int id)
  {
    _currentFId = id;
  }
 
  inline void setCurrentSVertexId(int id)
  {
    _currentSVertexId = id;
  }
 
 protected:
  virtual void Init(ViewShape *oVShape);
 
  // SMOOTH //
  bool stopSmoothViewEdge(WXFaceLayer *iFaceLayer);
  OWXFaceLayer FindNextFaceLayer(const OWXFaceLayer &iFaceLayer);
  OWXFaceLayer FindPreviousFaceLayer(const OWXFaceLayer &iFaceLayer);
  FEdge *BuildSmoothFEdge(FEdge *feprevious, const OWXFaceLayer &ifl);
 
  // SHARP //
  bool stopSharpViewEdge(WXEdge *iEdge);
  int retrieveFaceMarks(WXEdge *iEdge);
  OWXEdge FindNextWEdge(const OWXEdge &iEdge);
  OWXEdge FindPreviousWEdge(const OWXEdge &iEdge);
  FEdge *BuildSharpFEdge(FEdge *feprevious, const OWXEdge &iwe);
 
  // GENERAL //
  SVertex *MakeSVertex(Vec3r &iPoint);
  SVertex *MakeSVertex(Vec3r &iPoint, bool shared);
  ViewVertex *MakeViewVertex(SVertex *iSVertex);
 
  // oldtmp values
  // IdHashTable _hashtable;
  // VVIdHashTable _multivertexHashTable;
  SVertexMap _SVertexMap;
  SShape *_pCurrentSShape;
  ViewShape *_pCurrentVShape;
 
  MEM_CXX_CLASS_ALLOC_FUNCS("Freestyle:ViewEdgeXBuilder")
};
 
} /* namespace Freestyle */