Stroke.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 <vector>
 
#include "Curve.h"
 
#include "../view_map/Interface1D.h"
#include "../view_map/Silhouette.h"
 
#include "../system/FreestyleConfig.h"
#include "../system/StringUtils.h"
 
#include "MEM_guardedalloc.h"
 
extern "C" {
struct MTex;
struct bNodeTree;
}
 
#ifndef MAX_MTEX
#  define MAX_MTEX 18
#endif
 
namespace Freestyle {
 
//
//  StrokeAttribute
//

class StrokeAttribute {
 public:
  StrokeAttribute();

  StrokeAttribute(const StrokeAttribute &iBrother);

  StrokeAttribute(float iRColor,
                  float iGColor,
                  float iBColor,
                  float iAlpha,
                  float iRThickness,
                  float iLThickness);

  StrokeAttribute(const StrokeAttribute &a1, const StrokeAttribute &a2, float t);

  virtual ~StrokeAttribute();
 
  /* operators */
  StrokeAttribute &operator=(const StrokeAttribute &iBrother);
 
  /* accessors */
  inline const float *getColor() const
  {
    return _color;
  }

  inline float getColorR() const
  {
    return _color[0];
  }

  inline float getColorG() const
  {
    return _color[1];
  }

  inline float getColorB() const
  {
    return _color[2];
  }

  inline Vec3f getColorRGB() const
  {
    return Vec3f(_color[0], _color[1], _color[2]);
  }

  inline float getAlpha() const
  {
    return _alpha;
  }

  inline const float *getThickness() const
  {
    return _thickness;
  }

  inline float getThicknessR() const
  {
    return _thickness[0];
  }

  inline float getThicknessL() const
  {
    return _thickness[1];
  }

  inline Vec2f getThicknessRL() const
  {
    return Vec2f(_thickness[0], _thickness[1]);
  }

  inline bool isVisible() const
  {
    return _visible;
  }

  float getAttributeReal(const char *iName) const;

  Vec2f getAttributeVec2f(const char *iName) const;

  Vec3f getAttributeVec3f(const char *iName) const;

  bool isAttributeAvailableReal(const char *iName) const;

  bool isAttributeAvailableVec2f(const char *iName) const;

  bool isAttributeAvailableVec3f(const char *iName) const;
 
  /* modifiers */
  inline void setColor(float r, float g, float b)
  {
    _color[0] = r;
    _color[1] = g;
    _color[2] = b;
  }

  inline void setColor(const Vec3f &iRGB)
  {
    _color[0] = iRGB[0];
    _color[1] = iRGB[1];
    _color[2] = iRGB[2];
  }

  inline void setAlpha(float alpha)
  {
    _alpha = alpha;
  }

  inline void setThickness(float tr, float tl)
  {
    _thickness[0] = tr;
    _thickness[1] = tl;
  }

  inline void setThickness(const Vec2f &tRL)
  {
    _thickness[0] = tRL[0];
    _thickness[1] = tRL[1];
  }

  inline void setVisible(bool iVisible)
  {
    _visible = iVisible;
  }

  void setAttributeReal(const char *iName, float att);

  void setAttributeVec2f(const char *iName, const Vec2f &att);

  void setAttributeVec3f(const char *iName, const Vec3f &att);
 
 private:
  typedef std::map<const char *, float, StringUtils::ltstr> realMap;
  typedef std::map<const char *, Vec2f, StringUtils::ltstr> Vec2fMap;
  typedef std::map<const char *, Vec3f, StringUtils::ltstr> Vec3fMap;

  float _color[3];
  float _alpha;
  float _thickness[2];
  bool _visible;
  realMap *_userAttributesReal;
  Vec2fMap *_userAttributesVec2f;
  Vec3fMap *_userAttributesVec3f;
 
  MEM_CXX_CLASS_ALLOC_FUNCS("Freestyle:StrokeAttribute")
};
 
//
//  StrokeVertex
//

class StrokeVertex : public CurvePoint {
 public:  // Implementation of Interface0D
  virtual string getExactTypeName() const
  {
    return "StrokeVertex";
  }
 
 private:
  StrokeAttribute _Attribute;  
  float _CurvilignAbscissa;    
  float _StrokeLength;         // stroke length
 
 public:
  StrokeVertex();

  StrokeVertex(const StrokeVertex &iBrother);

  StrokeVertex(SVertex *iSVertex);

  StrokeVertex(CurvePoint *iPoint);

  StrokeVertex(StrokeVertex *iA, StrokeVertex *iB, float t3);

  StrokeVertex(SVertex *iSVertex, const StrokeAttribute &iAttribute);
 
  /* operators */
  StrokeVertex &operator=(const StrokeVertex &iBrother);
 
  /* accessors */
  inline real x() const
  {
    return _Point2d[0];
  }

  inline real y() const
  {
    return _Point2d[1];
  }

  inline Vec2r getPoint() const
  {
    return getPoint2D();
  }

  inline real operator[](const int i) const
  {
    return _Point2d[i];
  }

  inline const StrokeAttribute &attribute() const
  {
    return _Attribute;
  }

  inline StrokeAttribute &attribute()
  {
    return _Attribute;
  }

  inline float curvilinearAbscissa() const
  {
    return _CurvilignAbscissa;
  }

  inline float strokeLength() const
  {
    return _StrokeLength;
  }

  inline float u() const
  {
    return _CurvilignAbscissa / _StrokeLength;
  }
 
  /* modifiers */
  inline void setX(real x)
  {
    _Point2d[0] = x;
  }

  inline void setY(real y)
  {
    _Point2d[1] = y;
  }

  inline void setPoint(real x, real y)
  {
    _Point2d[0] = x;
    _Point2d[1] = y;
  }

  inline void setPoint(const Vec2r &p)
  {
    _Point2d[0] = p[0];
    _Point2d[1] = p[1];
  }

  inline real &operator[](const int i)
  {
    return _Point2d[i];
  }

  inline void setAttribute(const StrokeAttribute &iAttribute)
  {
    _Attribute = iAttribute;
  }

  inline void setCurvilinearAbscissa(float iAbscissa)
  {
    _CurvilignAbscissa = iAbscissa;
  }

  inline void setStrokeLength(float iLength)
  {
    _StrokeLength = iLength;
  }
 
  /* interface definition */
  /* inherited */
 
  MEM_CXX_CLASS_ALLOC_FUNCS("Freestyle:StrokeVertex")
};
 
//
//  Stroke
//
 
class StrokeRenderer;
class StrokeRep;
 
namespace StrokeInternal {
 
class vertex_const_traits;
class vertex_nonconst_traits;
template<class Traits> class vertex_iterator_base;
class StrokeVertexIterator;
 
}  // end of namespace StrokeInternal

class Stroke : public Interface1D {
 public:  // Implementation of Interface1D
  virtual string getExactTypeName() const
  {
    return "Stroke";
  }
 
  // Data access methods

  virtual Id getId() const
  {
    return _id;
  }

  typedef enum {
    DRY_MEDIUM,    
    HUMID_MEDIUM,  
    OPAQUE_MEDIUM, 
  } MediumType;
 
 public:
  typedef std::deque<StrokeVertex *> vertex_container;  // the vertices container
  typedef std::vector<ViewEdge *> viewedge_container;   // the viewedges container
  typedef StrokeInternal::vertex_iterator_base<StrokeInternal::vertex_nonconst_traits>
      vertex_iterator;
  typedef StrokeInternal::vertex_iterator_base<StrokeInternal::vertex_const_traits>
      const_vertex_iterator;
 
 public:
  // typedef StrokeVertex vertex_type;
 
 private:
  vertex_container _Vertices;  
  Id _id;
  float _Length;  // The stroke length
  viewedge_container _ViewEdges;
  float _sampling;
  float _textureStep;
  // StrokeRenderer *_renderer; // mark implementation OpenGL renderer
  MediumType _mediumType;
  uint _textureId;
  MTex *_mtex[MAX_MTEX];
  bNodeTree *_nodeTree;
  bool _tips;
  StrokeRep *_rep;
  Vec2r _extremityOrientations[2];  // the orientations of the first and last extremity
 
 public:
  Stroke();

  Stroke(const Stroke &iBrother);

  template<class InputVertexIterator> Stroke(InputVertexIterator iBegin, InputVertexIterator iEnd);

  virtual ~Stroke();
 
  /* operators */
  Stroke &operator=(const Stroke &iBrother);

  float ComputeSampling(int iNVertices);

  int Resample(int iNPoints);

  int Resample(float iSampling);

  void RemoveAllVertices();

  void RemoveVertex(StrokeVertex *iVertex);

  void InsertVertex(StrokeVertex *iVertex, StrokeInternal::StrokeVertexIterator next);

  void UpdateLength();
 
  /* Render method */
  void ScaleThickness(float iFactor);
  void Render(const StrokeRenderer *iRenderer);
  void RenderBasic(const StrokeRenderer *iRenderer);
 
  /* Iterator definition */
 
  /* accessors */
  inline real getLength2D() const
  {
    return _Length;
  }

  inline MediumType getMediumType() const
  {
    return _mediumType;
  }

  inline uint getTextureId()
  {
    return _textureId;
  }

  inline float getTextureStep()
  {
    return _textureStep;
  }

  inline MTex *getMTex(int idx)
  {
    return _mtex[idx];
  }

  inline bNodeTree *getNodeTree()
  {
    return _nodeTree;
  }

  inline bool hasTex() const
  {
    return (_mtex[0] != nullptr) || _nodeTree;
  }

  inline bool hasTips() const
  {
    return _tips;
  }
 
  /* these advanced iterators are used only in C++ */
  inline int vertices_size() const
  {
    return _Vertices.size();
  }
 
  inline viewedge_container::const_iterator viewedges_begin() const
  {
    return _ViewEdges.begin();
  }
 
  inline viewedge_container::iterator viewedges_begin()
  {
    return _ViewEdges.begin();
  }
 
  inline viewedge_container::const_iterator viewedges_end() const
  {
    return _ViewEdges.end();
  }
 
  inline viewedge_container::iterator viewedges_end()
  {
    return _ViewEdges.end();
  }
 
  inline int viewedges_size() const
  {
    return _ViewEdges.size();
  }
 
  inline Vec2r getBeginningOrientation() const
  {
    return _extremityOrientations[0];
  }
 
  inline real getBeginningOrientationX() const
  {
    return _extremityOrientations[0].x();
  }
 
  inline real getBeginningOrientationY() const
  {
    return _extremityOrientations[0].y();
  }
 
  inline Vec2r getEndingOrientation() const
  {
    return _extremityOrientations[1];
  }
 
  inline real getEndingOrientationX() const
  {
    return _extremityOrientations[1].x();
  }
 
  inline real getEndingOrientationY() const
  {
    return _extremityOrientations[1].y();
  }
 
  /* modifiers */
  inline void setId(const Id &id)
  {
    _id = id;
  }

  void setLength(float iLength);

  inline void setMediumType(MediumType iType)
  {
    _mediumType = iType;
  }

  inline void setTextureId(uint id)
  {
    _textureId = id;
  }

  inline void setTextureStep(float step)
  {
    _textureStep = step;
  }

  inline int setMTex(MTex *mtex)
  {
    for (int a = 0; a < MAX_MTEX; a++) {
      if (!_mtex[a]) {
        _mtex[a] = mtex;
        return 0;
      }
    }
    return -1; /* no free slots */
  }

  inline void setNodeTree(bNodeTree *iNodeTree)
  {
    _nodeTree = iNodeTree;
  }

  inline void setTips(bool iTips)
  {
    _tips = iTips;
  }
 
  inline void push_back(StrokeVertex *iVertex)
  {
    _Vertices.push_back(iVertex);
  }
 
  inline void push_front(StrokeVertex *iVertex)
  {
    _Vertices.push_front(iVertex);
  }
 
  inline void AddViewEdge(ViewEdge *iViewEdge)
  {
    _ViewEdges.push_back(iViewEdge);
  }
 
  inline void setBeginningOrientation(const Vec2r &iOrientation)
  {
    _extremityOrientations[0] = iOrientation;
  }
 
  inline void setBeginningOrientation(real x, real y)
  {
    _extremityOrientations[0] = Vec2r(x, y);
  }
 
  inline void setEndingOrientation(const Vec2r &iOrientation)
  {
    _extremityOrientations[1] = iOrientation;
  }
 
  inline void setEndingOrientation(real x, real y)
  {
    _extremityOrientations[1] = Vec2r(x, y);
  }
 
  /* Information access interface */
 
  // embedding vertex iterator
  const_vertex_iterator vertices_begin() const;
  vertex_iterator vertices_begin(float sampling = 0.0f);
  const_vertex_iterator vertices_end() const;
  vertex_iterator vertices_end();

  StrokeInternal::StrokeVertexIterator strokeVerticesBegin(float t = 0.0f);

  StrokeInternal::StrokeVertexIterator strokeVerticesEnd();

  inline uint strokeVerticesSize() const
  {
    return _Vertices.size();
  }

  inline StrokeVertex &strokeVerticeAt(uint i)
  {
    return *(_Vertices.at(i));
  }
 
  // Iterator access (Interface1D)
  virtual Interface0DIterator verticesBegin();

  virtual Interface0DIterator verticesEnd();
 
  virtual Interface0DIterator pointsBegin(float t = 0.0f);
  virtual Interface0DIterator pointsEnd(float t = 0.0f);
 
  MEM_CXX_CLASS_ALLOC_FUNCS("Freestyle:Stroke")
};
 
//
//  Implementation
//
 
template<class InputVertexIterator>
Stroke::Stroke(InputVertexIterator iBegin, InputVertexIterator iEnd)
{
  for (InputVertexIterator v = iBegin, vend = iEnd; v != vend; v++) {
    _Vertices.push_back(*v);
  }
  _Length = 0;
  _id = 0;
}
 
} /* namespace Freestyle */