Tamito Kajiyama
d8b00a3bf5
Previously individual strokes were represented by distinct mesh objects no matter how many vertices and materials each stroke has, although the vertex and material counts can be quite small depending on the input scene data. Now stroke meshes are packed into a minimum number of mesh objects, so as to reduce the overheads of Blender object creation.
896 lines
22 KiB
C++
896 lines
22 KiB
C++
/*
|
|
* ***** BEGIN GPL LICENSE BLOCK *****
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program 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 General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*
|
|
* ***** END GPL LICENSE BLOCK *****
|
|
*/
|
|
|
|
#ifndef __FREESTYLE_STROKE_H__
|
|
#define __FREESTYLE_STROKE_H__
|
|
|
|
/** \file blender/freestyle/intern/stroke/Stroke.h
|
|
* \ingroup freestyle
|
|
* \brief Classes to define a stroke
|
|
* \author Stephane Grabli
|
|
* \date 09/09/2002
|
|
*/
|
|
|
|
#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"
|
|
|
|
#ifdef WITH_CXX_GUARDEDALLOC
|
|
#include "MEM_guardedalloc.h"
|
|
#endif
|
|
|
|
extern "C" {
|
|
#include "DNA_material_types.h"
|
|
|
|
struct bNodeTree;
|
|
}
|
|
|
|
#ifndef MAX_MTEX
|
|
#define MAX_MTEX 18
|
|
#endif
|
|
|
|
namespace Freestyle {
|
|
|
|
//
|
|
// StrokeAttribute
|
|
//
|
|
////////////////////////////////////////////////////////
|
|
|
|
/*! Class to define an attribute associated to a Stroke Vertex.
|
|
* This attribute stores the color, alpha and thickness values for a Stroke Vertex.
|
|
*/
|
|
class StrokeAttribute
|
|
{
|
|
public:
|
|
/*! default constructor */
|
|
StrokeAttribute();
|
|
|
|
/*! Copy constructor */
|
|
StrokeAttribute(const StrokeAttribute& iBrother);
|
|
|
|
/*! Builds a stroke vertex attribute from a set of parameters.
|
|
* \param iRColor
|
|
* The Red Component value.
|
|
* \param iGColor
|
|
* The Green Component value.
|
|
* \param iBColor
|
|
* The Blue Component value.
|
|
* \param iAlpha
|
|
* The transparency value
|
|
* \param iRThickness
|
|
* The thickness of the stroke on the right
|
|
* \param iLThickness
|
|
* The Thickness of the stroke on the left
|
|
*/
|
|
StrokeAttribute(float iRColor, float iGColor, float iBColor, float iAlpha, float iRThickness, float iLThickness);
|
|
|
|
/*! Interpolation constructor.
|
|
* Builds a StrokeAttribute from two StrokeAttributes and an interpolation parameter.
|
|
* \param a1
|
|
* The first Attribute.
|
|
* \param a2
|
|
* The second parameter.
|
|
* \param t
|
|
* The interpolation parameter.
|
|
*/
|
|
StrokeAttribute(const StrokeAttribute& a1, const StrokeAttribute& a2, float t);
|
|
|
|
/*! destructor */
|
|
virtual ~StrokeAttribute();
|
|
|
|
/* operators */
|
|
/*! operator = */
|
|
StrokeAttribute& operator=(const StrokeAttribute& iBrother);
|
|
|
|
/* accessors */
|
|
/*! Returns the attribute's color.
|
|
* \return The array of 3 floats containing the R,G,B values of the attribute's color.
|
|
*/
|
|
inline const float *getColor() const
|
|
{
|
|
return _color;
|
|
}
|
|
|
|
/*! Returns the R color component. */
|
|
inline const float getColorR() const
|
|
{
|
|
return _color[0];
|
|
}
|
|
|
|
/*! Returns the G color component. */
|
|
inline const float getColorG() const
|
|
{
|
|
return _color[1];
|
|
}
|
|
|
|
/*! Returns the B color component. */
|
|
inline const float getColorB() const
|
|
{
|
|
return _color[2];
|
|
}
|
|
|
|
/*! Returns the RGB color components. */
|
|
inline Vec3f getColorRGB() const
|
|
{
|
|
return Vec3f(_color[0], _color[1], _color[2]);
|
|
}
|
|
|
|
/*! Returns the alpha color component. */
|
|
inline float getAlpha() const
|
|
{
|
|
return _alpha;
|
|
}
|
|
|
|
/*! Returns the attribute's thickness.
|
|
* \return an array of 2 floats. the first value is the thickness on the right of the vertex when following
|
|
* the stroke, the second one is the thickness on the left.
|
|
*/
|
|
inline const float *getThickness() const
|
|
{
|
|
return _thickness;
|
|
}
|
|
|
|
/*! Returns the thickness on the right of the vertex when following the stroke. */
|
|
inline const float getThicknessR() const
|
|
{
|
|
return _thickness[0];
|
|
}
|
|
|
|
/*! Returns the thickness on the left of the vertex when following the stroke. */
|
|
inline const float getThicknessL() const
|
|
{
|
|
return _thickness[1];
|
|
}
|
|
|
|
/*! Returns the thickness on the right and on the left of the vertex when following the stroke. */
|
|
inline Vec2f getThicknessRL() const
|
|
{
|
|
return Vec2f(_thickness[0], _thickness[1]);
|
|
}
|
|
|
|
/*! Returns true if the strokevertex is visible, false otherwise */
|
|
inline bool isVisible() const
|
|
{
|
|
return _visible;
|
|
}
|
|
|
|
/*! Returns an attribute of type real
|
|
* \param iName
|
|
* The name of the attribute
|
|
*/
|
|
float getAttributeReal(const char *iName) const;
|
|
|
|
/*! Returns an attribute of type Vec2f
|
|
* \param iName
|
|
* The name of the attribute
|
|
*/
|
|
Vec2f getAttributeVec2f(const char *iName) const;
|
|
|
|
/*! Returns an attribute of type Vec3f
|
|
* \param iName
|
|
* The name of the attribute
|
|
*/
|
|
Vec3f getAttributeVec3f(const char *iName) const;
|
|
|
|
/*! Checks whether the attribute iName is availbale */
|
|
bool isAttributeAvailableReal(const char *iName) const;
|
|
|
|
/*! Checks whether the attribute iName is availbale */
|
|
bool isAttributeAvailableVec2f(const char *iName) const;
|
|
|
|
/*! Checks whether the attribute iName is availbale */
|
|
bool isAttributeAvailableVec3f(const char *iName) const;
|
|
|
|
/* modifiers */
|
|
/*! sets the attribute's color.
|
|
* \param r
|
|
* The new R value.
|
|
* \param g
|
|
* The new G value.
|
|
* \param b
|
|
* The new B value.
|
|
*/
|
|
inline void setColor(float r, float g, float b)
|
|
{
|
|
_color[0] = r;
|
|
_color[1] = g;
|
|
_color[2] = b;
|
|
}
|
|
|
|
/*! sets the attribute's color.
|
|
* \param iRGB
|
|
* The new RGB values.
|
|
*/
|
|
inline void setColor(const Vec3f& iRGB)
|
|
{
|
|
_color[0] = iRGB[0];
|
|
_color[1] = iRGB[1];
|
|
_color[2] = iRGB[2];
|
|
}
|
|
|
|
/*! sets the attribute's alpha value.
|
|
* \param alpha
|
|
* The new alpha value.
|
|
*/
|
|
inline void setAlpha(float alpha)
|
|
{
|
|
_alpha = alpha;
|
|
}
|
|
|
|
/*! sets the attribute's thickness.
|
|
* \param tr
|
|
* The thickness on the right of the vertex when following the stroke.
|
|
* \param tl
|
|
* The thickness on the left of the vertex when following the stroke.
|
|
*/
|
|
inline void setThickness(float tr, float tl)
|
|
{
|
|
_thickness[0] = tr;
|
|
_thickness[1] = tl;
|
|
}
|
|
|
|
/*! sets the attribute's thickness.
|
|
* \param tRL
|
|
* The thickness on the right and on the left of the vertex when following the stroke.
|
|
*/
|
|
inline void setThickness(const Vec2f& tRL)
|
|
{
|
|
_thickness[0] = tRL[0];
|
|
_thickness[1] = tRL[1];
|
|
}
|
|
|
|
/*! sets the visible flag. True means visible. */
|
|
inline void setVisible(bool iVisible)
|
|
{
|
|
_visible = iVisible;
|
|
}
|
|
|
|
/*! Adds a user defined attribute of type real
|
|
* If there is no attribute of name iName, it is added.
|
|
* Otherwise, the new value replaces the old one.
|
|
* \param iName
|
|
* The name of the attribute
|
|
* \param att
|
|
* The attribute's value
|
|
*/
|
|
void setAttributeReal(const char *iName, float att);
|
|
|
|
/*! Adds a user defined attribute of type Vec2f
|
|
* If there is no attribute of name iName, it is added.
|
|
* Otherwise, the new value replaces the old one.
|
|
* \param iName
|
|
* The name of the attribute
|
|
* \param att
|
|
* The attribute's value
|
|
*/
|
|
void setAttributeVec2f(const char *iName, const Vec2f& att);
|
|
|
|
/*! Adds a user defined attribute of type Vec3f
|
|
* If there is no attribute of name iName, it is added.
|
|
* Otherwise, the new value replaces the old one.
|
|
* \param iName
|
|
* The name of the attribute
|
|
* \param att
|
|
* The attribute's value
|
|
*/
|
|
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]; //! the color
|
|
float _alpha; //! alpha
|
|
float _thickness[2]; //! the thickness on the right and on the left of the backbone vertex (the stroke is oriented)
|
|
bool _visible;
|
|
realMap *_userAttributesReal;
|
|
Vec2fMap *_userAttributesVec2f;
|
|
Vec3fMap *_userAttributesVec3f;
|
|
|
|
#ifdef WITH_CXX_GUARDEDALLOC
|
|
MEM_CXX_CLASS_ALLOC_FUNCS("Freestyle:StrokeAttribute")
|
|
#endif
|
|
};
|
|
|
|
|
|
//
|
|
// StrokeVertex
|
|
//
|
|
////////////////////////////////////////////////////////
|
|
|
|
/*! Class to define a stroke vertex. */
|
|
class StrokeVertex : public CurvePoint
|
|
{
|
|
public: // Implementation of Interface0D
|
|
/*! Returns the string "StrokeVertex" */
|
|
virtual string getExactTypeName() const
|
|
{
|
|
return "StrokeVertex";
|
|
}
|
|
|
|
private:
|
|
StrokeAttribute _Attribute; //! The attribute associated to the vertex
|
|
float _CurvilignAbscissa; //! the curvilign abscissa
|
|
float _StrokeLength; // stroke length
|
|
|
|
public:
|
|
/*! default constructor */
|
|
StrokeVertex();
|
|
|
|
/*! Copy constructor */
|
|
StrokeVertex(const StrokeVertex& iBrother);
|
|
|
|
/*! Builds a stroke vertex from a SVertex */
|
|
StrokeVertex(SVertex *iSVertex);
|
|
|
|
/*! Builds a stroke vertex from a CurvePoint */
|
|
StrokeVertex(CurvePoint *iPoint);
|
|
|
|
/*! Builds Stroke Vertex from 2 stroke vertices and an interpolation parameter*/
|
|
StrokeVertex(StrokeVertex *iA, StrokeVertex *iB, float t3);
|
|
|
|
/*! Builds a stroke from a view vertex and an attribute */
|
|
StrokeVertex(SVertex *iSVertex, const StrokeAttribute& iAttribute);
|
|
|
|
/*! destructor */
|
|
virtual ~StrokeVertex();
|
|
|
|
/* operators */
|
|
/*! operator = */
|
|
StrokeVertex& operator=(const StrokeVertex& iBrother);
|
|
|
|
/* accessors */
|
|
/*! Returns the 2D point x coordinate */
|
|
inline real x() const
|
|
{
|
|
return _Point2d[0];
|
|
}
|
|
|
|
/*! Returns the 2D point y coordinate */
|
|
inline real y() const
|
|
{
|
|
return _Point2d[1];
|
|
}
|
|
|
|
/*! Returns the 2D point coordinates as a Vec2r */
|
|
inline Vec2r getPoint() const
|
|
{
|
|
return getPoint2D();
|
|
}
|
|
|
|
/*! Returns the ith 2D point coordinate (i=0 or 1)*/
|
|
inline real operator[](const int i) const
|
|
{
|
|
return _Point2d[i];
|
|
}
|
|
|
|
/*! Returns the StrokeAttribute for this StrokeVertex */
|
|
inline const StrokeAttribute& attribute() const
|
|
{
|
|
return _Attribute;
|
|
}
|
|
|
|
/*! Returns a non-const reference to the StrokeAttribute of this StrokeVertex */
|
|
inline StrokeAttribute& attribute()
|
|
{
|
|
return _Attribute;
|
|
}
|
|
|
|
/*! Returns the curvilinear abscissa */
|
|
inline float curvilinearAbscissa() const
|
|
{
|
|
return _CurvilignAbscissa;
|
|
}
|
|
|
|
/*! Returns the length of the Stroke to which this StrokeVertex belongs */
|
|
inline float strokeLength() const
|
|
{
|
|
return _StrokeLength;
|
|
}
|
|
|
|
/*! Returns the curvilinear abscissa of this StrokeVertex in the Stroke */
|
|
inline float u() const
|
|
{
|
|
return _CurvilignAbscissa / _StrokeLength;
|
|
}
|
|
|
|
/* modifiers */
|
|
/*! sets the 2D x value */
|
|
inline void setX(real x)
|
|
{
|
|
_Point2d[0] = x;
|
|
}
|
|
|
|
/*! sets the 2D y value */
|
|
inline void setY(real y)
|
|
{
|
|
_Point2d[1] = y;
|
|
}
|
|
|
|
/*! sets the 2D x and y values */
|
|
inline void setPoint(real x, real y)
|
|
{
|
|
_Point2d[0] = x;
|
|
_Point2d[1] = y;
|
|
}
|
|
|
|
/*! sets the 2D x and y values */
|
|
inline void setPoint(const Vec2r& p)
|
|
{
|
|
_Point2d[0] = p[0];
|
|
_Point2d[1] = p[1];
|
|
}
|
|
|
|
/*! Returns a reference to the ith 2D point coordinate (i=0 or 1) */
|
|
inline real& operator[](const int i)
|
|
{
|
|
return _Point2d[i];
|
|
}
|
|
|
|
/*! sets the attribute. */
|
|
inline void setAttribute(const StrokeAttribute& iAttribute)
|
|
{
|
|
_Attribute = iAttribute;
|
|
}
|
|
|
|
/*! sets the curvilinear abscissa of this StrokeVertex in the Stroke */
|
|
inline void setCurvilinearAbscissa(float iAbscissa)
|
|
{
|
|
_CurvilignAbscissa = iAbscissa;
|
|
}
|
|
|
|
/*! sets the Stroke's length (it's only a value stored by the Stroke Vertex, it won't change the real
|
|
* Stroke's length.)
|
|
*/
|
|
inline void setStrokeLength(float iLength)
|
|
{
|
|
_StrokeLength = iLength;
|
|
}
|
|
|
|
/* interface definition */
|
|
/* inherited */
|
|
|
|
#ifdef WITH_CXX_GUARDEDALLOC
|
|
MEM_CXX_CLASS_ALLOC_FUNCS("Freestyle:StrokeVertex")
|
|
#endif
|
|
};
|
|
|
|
|
|
//
|
|
// 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 to define a stroke.
|
|
* A stroke is made of a set of 2D vertices (StrokeVertex), regularly spaced out.
|
|
* This set of vertices defines the stroke's backbone geometry.
|
|
* Each of these stroke vertices defines the stroke's shape and appearance at this vertex position.
|
|
*/
|
|
class Stroke : public Interface1D
|
|
{
|
|
public: // Implementation of Interface1D
|
|
/*! Returns the string "Stroke" */
|
|
virtual string getExactTypeName() const
|
|
{
|
|
return "Stroke";
|
|
}
|
|
|
|
// Data access methods
|
|
|
|
/*! Returns the Id of the Stroke */
|
|
virtual Id getId() const
|
|
{
|
|
return _id;
|
|
}
|
|
|
|
/*! The different blending modes available to similate the interaction media-medium. */
|
|
typedef enum {
|
|
DRY_MEDIUM, /*!< To simulate a dry medium such as Pencil or Charcoal.*/
|
|
HUMID_MEDIUM, /*!< To simulate ink painting (color substraction blending).*/
|
|
OPAQUE_MEDIUM, /*!< To simulate an opaque medium (oil, spray...).*/
|
|
} 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; //! The stroke's backbone vertices
|
|
Id _id;
|
|
float _Length; // The stroke length
|
|
viewedge_container _ViewEdges;
|
|
float _sampling;
|
|
float _textureStep;
|
|
// StrokeRenderer *_renderer; // mark implementation OpenGL renderer
|
|
MediumType _mediumType;
|
|
unsigned int _textureId;
|
|
MTex *_mtex[MAX_MTEX];
|
|
bNodeTree *_nodeTree;
|
|
bool _tips;
|
|
StrokeRep *_rep;
|
|
Vec2r _extremityOrientations[2]; // the orientations of the first and last extermity
|
|
|
|
public:
|
|
/*! default constructor */
|
|
Stroke();
|
|
|
|
/*! copy constructor */
|
|
Stroke(const Stroke& iBrother);
|
|
|
|
/*! Builds a stroke from a set of StrokeVertex.
|
|
* This constructor is templated by an iterator type.
|
|
* This iterator type must allow the vertices parsing using the ++ operator.
|
|
* \param iBegin
|
|
* The iterator pointing to the first vertex.
|
|
* \param iEnd
|
|
* The iterator pointing to the end of the vertex list.
|
|
*/
|
|
template<class InputVertexIterator>
|
|
Stroke(InputVertexIterator iBegin, InputVertexIterator iEnd);
|
|
|
|
/*! Destructor */
|
|
virtual ~Stroke();
|
|
|
|
/* operators */
|
|
/*! operator = */
|
|
Stroke& operator=(const Stroke& iBrother);
|
|
|
|
/*! Compute the sampling needed to get iNVertices vertices.
|
|
* If the specified number of vertices is less than the actual number of vertices, the actual sampling value
|
|
* is returned. (To remove Vertices, use the RemoveVertex() method of this class).
|
|
* \param iNVertices
|
|
* The number of StrokeVertices we eventually want in our Stroke.
|
|
* \return the sampling that must be used in the Resample(float) method.
|
|
* @see Resample(int)
|
|
* @see Resample(float)
|
|
*/
|
|
float ComputeSampling(int iNVertices);
|
|
|
|
/*! Resampling method.
|
|
* Resamples the curve so that it eventually has iNPoints. That means it is going to add iNPoints-vertices_size,
|
|
* if vertices_size is the number of points we already have.
|
|
* If vertices_size >= iNPoints, no resampling is done.
|
|
* \param iNPoints
|
|
* The number of vertices we eventually want in our stroke.
|
|
*/
|
|
int Resample(int iNPoints);
|
|
|
|
/*! Resampling method.
|
|
* Resamples the curve with a given sampling.
|
|
* If this sampling is < to the actual sampling value, no resampling is done.
|
|
* \param iSampling
|
|
* The new sampling value.
|
|
*/
|
|
int Resample(float iSampling);
|
|
|
|
/*! Removes all vertices from the Stroke.
|
|
*/
|
|
void RemoveAllVertices();
|
|
|
|
/*! Removes the stroke vertex iVertex
|
|
* from the stroke.
|
|
* The length and curvilinear abscissa are updated
|
|
* consequently.
|
|
*/
|
|
void RemoveVertex(StrokeVertex *iVertex);
|
|
|
|
/*! Inserts the stroke vertex iVertex in the stroke before next.
|
|
* The length, curvilinear abscissa are updated consequently.
|
|
* \param iVertex
|
|
* The StrokeVertex to insert in the Stroke.
|
|
* \param next
|
|
* A StrokeVertexIterator pointing to the StrokeVeretx before which iVertex must be inserted.
|
|
*/
|
|
void InsertVertex(StrokeVertex *iVertex, StrokeInternal::StrokeVertexIterator next);
|
|
|
|
/*! Updates the 2D length of the Stroke */
|
|
void UpdateLength();
|
|
|
|
/* Render method */
|
|
void ScaleThickness(float iFactor);
|
|
void Render(const StrokeRenderer *iRenderer);
|
|
void RenderBasic(const StrokeRenderer *iRenderer);
|
|
|
|
/* Iterator definition */
|
|
|
|
/* accessors */
|
|
/*! Returns the 2D length of the Stroke */
|
|
inline real getLength2D() const
|
|
{
|
|
return _Length;
|
|
}
|
|
|
|
/*! Returns a reference to the time stamp value of the stroke. */
|
|
/*! Returns the MediumType used for this Stroke. */
|
|
inline MediumType getMediumType() const
|
|
{
|
|
return _mediumType;
|
|
}
|
|
|
|
/*! Returns the id of the texture used to simulate th marks system for this Stroke */
|
|
inline unsigned int getTextureId() {return _textureId;}
|
|
|
|
/*! Returns the spacing of texture coordinates along the stroke lenght */
|
|
inline float getTextureStep() {return _textureStep;}
|
|
|
|
/*! Returns the texture used at given index to simulate the marks system for this Stroke */
|
|
inline MTex *getMTex(int idx) {
|
|
return _mtex[idx];
|
|
}
|
|
|
|
/*! Return the shader node tree to define textures. */
|
|
inline bNodeTree *getNodeTree()
|
|
{
|
|
return _nodeTree;
|
|
}
|
|
|
|
/*! Returns true if this Stroke has textures assigned, false otherwise. */
|
|
inline bool hasTex() const
|
|
{
|
|
return (_mtex[0] != NULL) || _nodeTree;
|
|
}
|
|
|
|
/*! Returns true if this Stroke uses a texture with tips, false otherwise. */
|
|
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 */
|
|
/*! sets the Id of the Stroke. */
|
|
inline void setId(const Id& id)
|
|
{
|
|
_id = id;
|
|
}
|
|
|
|
/*! sets the 2D length of the Stroke. */
|
|
void setLength(float iLength);
|
|
|
|
/*! sets the medium type that must be used for this Stroke. */
|
|
inline void setMediumType(MediumType iType)
|
|
{
|
|
_mediumType = iType;
|
|
}
|
|
|
|
/*! sets the texture id to be used to simulate the marks system for this Stroke. */
|
|
inline void setTextureId(unsigned int id)
|
|
{
|
|
_textureId = id;
|
|
}
|
|
|
|
/*! sets the spacing of texture coordinates along the stroke lenght. */
|
|
inline void setTextureStep(float step)
|
|
{
|
|
_textureStep = step;
|
|
}
|
|
|
|
/*! assigns a blender texture to the first available slot. */
|
|
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 */
|
|
}
|
|
|
|
/*! assigns a node tree (of new shading nodes) to define textures. */
|
|
inline void setNodeTree(bNodeTree *iNodeTree)
|
|
{
|
|
_nodeTree = iNodeTree;
|
|
}
|
|
|
|
/*! sets the flag telling whether this stroke is using a texture with tips or not. */
|
|
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 t = 0.0f);
|
|
const_vertex_iterator vertices_end() const;
|
|
vertex_iterator vertices_end();
|
|
|
|
/*! Returns a StrokeVertexIterator pointing on the first StrokeVertex of the Stroke. One can specify a sampling
|
|
* value to resample the Stroke on the fly if needed.
|
|
* \param t
|
|
* The resampling value with which we want our Stroke to be resampled.
|
|
* If 0 is specified, no resampling is done.
|
|
*/
|
|
StrokeInternal::StrokeVertexIterator strokeVerticesBegin(float t = 0.0f);
|
|
|
|
/*! Returns a StrokeVertexIterator pointing after the last StrokeVertex of the Stroke. */
|
|
StrokeInternal::StrokeVertexIterator strokeVerticesEnd();
|
|
|
|
/*! Returns the number of StrokeVertex constituting the Stroke. */
|
|
inline unsigned int strokeVerticesSize() const
|
|
{
|
|
return _Vertices.size();
|
|
}
|
|
|
|
/*! Returns the i-th StrokeVertex constituting the Stroke. */
|
|
inline StrokeVertex& strokeVerticeAt(unsigned int i)
|
|
{
|
|
return *(_Vertices.at(i));
|
|
}
|
|
|
|
// Iterator access (Interface1D)
|
|
/*! Returns an Interface0DIterator pointing on the first StrokeVertex of the Stroke. */
|
|
virtual Interface0DIterator verticesBegin();
|
|
|
|
/*! Returns an Interface0DIterator pointing after the last StrokeVertex of the Stroke. */
|
|
virtual Interface0DIterator verticesEnd();
|
|
|
|
virtual Interface0DIterator pointsBegin(float t = 0.0f);
|
|
virtual Interface0DIterator pointsEnd(float t = 0.0f);
|
|
|
|
#ifdef WITH_CXX_GUARDEDALLOC
|
|
MEM_CXX_CLASS_ALLOC_FUNCS("Freestyle:Stroke")
|
|
#endif
|
|
};
|
|
|
|
|
|
//
|
|
// 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 */
|
|
|
|
#endif // __FREESTYLE_STROKE_H__
|