diff options
author | Campbell Barton <ideasman42@gmail.com> | 2021-06-24 08:57:33 +0300 |
---|---|---|
committer | Campbell Barton <ideasman42@gmail.com> | 2021-06-24 08:59:34 +0300 |
commit | 1f778dbefcaf825dcad1f70a9cc45e503ad74ed5 (patch) | |
tree | d192550ac77a0f982fb43440d3c64d972cc2d011 /source/blender/freestyle/intern/stroke | |
parent | 4b9ff3cd42be427e478743648e9951bf8c189a04 (diff) |
Cleanup: use Blender's code style for doxygen commetns in freestyle
Diffstat (limited to 'source/blender/freestyle/intern/stroke')
27 files changed, 457 insertions, 457 deletions
diff --git a/source/blender/freestyle/intern/stroke/AdvancedFunctions0D.h b/source/blender/freestyle/intern/stroke/AdvancedFunctions0D.h index 17e419bed54..212187e598c 100644 --- a/source/blender/freestyle/intern/stroke/AdvancedFunctions0D.h +++ b/source/blender/freestyle/intern/stroke/AdvancedFunctions0D.h @@ -36,13 +36,13 @@ namespace Freestyle { namespace Functions0D { // DensityF0D -/*! Returns the density of the (result) image evaluated at an Interface0D. +/** Returns the density of the (result) image evaluated at an Interface0D. * This density is evaluated using a pixels square window around the evaluation point and * integrating these values using a gaussian. */ class DensityF0D : public UnaryFunction0D<double> { public: - /*! Builds the functor from the gaussian sigma value. + /** Builds the functor from the gaussian sigma value. * \param sigma: * sigma indicates the x value for which the gaussian function is 0.5. * It leads to the window size value. (the larger, the smoother) @@ -52,13 +52,13 @@ class DensityF0D : public UnaryFunction0D<double> { _filter.setSigma((float)sigma); } - /*! Returns the string "DensityF0D" */ + /** Returns the string "DensityF0D" */ string getName() const { return "DensityF0D"; } - /*! The () operator. */ + /** The () operator. */ int operator()(Interface0DIterator &iter); private: @@ -66,7 +66,7 @@ class DensityF0D : public UnaryFunction0D<double> { }; // LocalAverageDepthF0D -/*! Returns the average depth around a point. +/** Returns the average depth around a point. * The result is obtained by querying the depth buffer on a window around that point. */ class LocalAverageDepthF0D : public UnaryFunction0D<double> { @@ -74,31 +74,31 @@ class LocalAverageDepthF0D : public UnaryFunction0D<double> { GaussianFilter _filter; public: - /*! Builds the functor from the size of the mask that will be used. */ + /** Builds the functor from the size of the mask that will be used. */ LocalAverageDepthF0D(real maskSize = 5.0f) : UnaryFunction0D<double>() { _filter.setSigma((float)maskSize / 2.0f); } - /*! Returns the string "LocalAverageDepthF0D" */ + /** Returns the string "LocalAverageDepthF0D" */ string getName() const { return "LocalAverageDepthF0D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface0DIterator &iter); }; // ReadMapPixel -/*! Reads a pixel in a map. */ +/** Reads a pixel in a map. */ class ReadMapPixelF0D : public UnaryFunction0D<float> { private: const char *_mapName; int _level; public: - /*! Builds the functor from name of the + /** Builds the functor from name of the * Map that must be read. * \param iMapName: * The name of the map. @@ -111,25 +111,25 @@ class ReadMapPixelF0D : public UnaryFunction0D<float> { _level = level; } - /*! Returns the string "ReadMapPixelF0D" */ + /** Returns the string "ReadMapPixelF0D" */ string getName() const { return "ReadMapPixelF0D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface0DIterator &iter); }; // ReadSteerableViewMapPixel -/*! Reads a pixel in one of the level of one of the steerable viewmaps. */ +/** Reads a pixel in one of the level of one of the steerable viewmaps. */ class ReadSteerableViewMapPixelF0D : public UnaryFunction0D<float> { private: unsigned _orientation; int _level; public: - /*! Builds the functor + /** Builds the functor * \param nOrientation: * The integer belonging to [0,4] indicating the orientation (E,NE,N,NW) we are interested in. * \param level: @@ -141,24 +141,24 @@ class ReadSteerableViewMapPixelF0D : public UnaryFunction0D<float> { _level = level; } - /*! Returns the string "ReadSteerableViewMapPixelF0D" */ + /** Returns the string "ReadSteerableViewMapPixelF0D" */ string getName() const { return "ReadSteerableViewMapPixelF0D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface0DIterator &iter); }; // ReadCompleteViewMapPixel -/*! Reads a pixel in one of the level of the complete viewmap. */ +/** Reads a pixel in one of the level of the complete viewmap. */ class ReadCompleteViewMapPixelF0D : public UnaryFunction0D<float> { private: int _level; public: - /*! Builds the functor + /** Builds the functor * \param level: * The level of the pyramid from which the pixel must be read. */ @@ -167,25 +167,25 @@ class ReadCompleteViewMapPixelF0D : public UnaryFunction0D<float> { _level = level; } - /*! Returns the string "ReadCompleteViewMapPixelF0D" */ + /** Returns the string "ReadCompleteViewMapPixelF0D" */ string getName() const { return "ReadCompleteViewMapPixelF0D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface0DIterator &iter); }; // GetViewMapGradientNormF0D -/*! Returns the norm of the gradient of the global viewmap density image. */ +/** Returns the norm of the gradient of the global viewmap density image. */ class GetViewMapGradientNormF0D : public UnaryFunction0D<float> { private: int _level; float _step; public: - /*! Builds the functor + /** Builds the functor * \param level: * The level of the pyramid from which the pixel must be read. */ @@ -195,13 +195,13 @@ class GetViewMapGradientNormF0D : public UnaryFunction0D<float> { _step = (float)pow(2.0, _level); } - /*! Returns the string "GetOccludeeF0D" */ + /** Returns the string "GetOccludeeF0D" */ string getName() const { return "GetViewMapGradientNormF0D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface0DIterator &iter); }; diff --git a/source/blender/freestyle/intern/stroke/AdvancedFunctions1D.h b/source/blender/freestyle/intern/stroke/AdvancedFunctions1D.h index 349db393e17..07ef0a7039c 100644 --- a/source/blender/freestyle/intern/stroke/AdvancedFunctions1D.h +++ b/source/blender/freestyle/intern/stroke/AdvancedFunctions1D.h @@ -35,7 +35,7 @@ namespace Freestyle { namespace Functions1D { // DensityF1D -/*! Returns the density evaluated for an Interface1D. +/** Returns the density evaluated for an Interface1D. * The density is evaluated for a set of points along the Interface1D (using the DensityF0D * functor) with a user-defined sampling and then integrated into a single value using a * user-defined integration method. @@ -45,7 +45,7 @@ class DensityF1D : public UnaryFunction1D<double> { float _sampling; public: - /*! Builds the functor. + /** Builds the functor. * \param sigma: * Thesigma used in DensityF0D and determining the window size used in each density query. * \param iType: @@ -61,18 +61,18 @@ class DensityF1D : public UnaryFunction1D<double> { _sampling = sampling; } - /*! Destructor */ + /** Destructor */ virtual ~DensityF1D() { } - /*! Returns the string "DensityF1D"*/ + /** Returns the string "DensityF1D"*/ string getName() const { return "DensityF1D"; } - /*! the () operator.*/ + /** the () operator.*/ int operator()(Interface1D &inter) { result = integrate( @@ -85,14 +85,14 @@ class DensityF1D : public UnaryFunction1D<double> { }; // LocalAverageDepthF1D -/*! Returns the average depth evaluated for an Interface1D. +/** Returns the average depth evaluated for an Interface1D. * The average depth is evaluated for a set of points along the Interface1D (using the * LocalAverageDepthF0D functor) with a user-defined sampling and then integrated into a single * value using a user-defined integration method. */ class LocalAverageDepthF1D : public UnaryFunction1D<double> { public: - /*! Builds the functor. + /** Builds the functor. * \param sigma: * The sigma used in DensityF0D and determining the window size used in each density query. * \param iType: @@ -103,13 +103,13 @@ class LocalAverageDepthF1D : public UnaryFunction1D<double> { { } - /*! Returns the string "LocalAverageDepthF1D" */ + /** Returns the string "LocalAverageDepthF1D" */ string getName() const { return "LocalAverageDepthF1D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface1D &inter) { result = integrate(_fun, inter.verticesBegin(), inter.verticesEnd(), _integration); @@ -121,14 +121,14 @@ class LocalAverageDepthF1D : public UnaryFunction1D<double> { }; // GetCompleteViewMapDensity -/*! Returns the density evaluated for an Interface1D in the complete viewmap image. +/** Returns the density evaluated for an Interface1D in the complete viewmap image. * The density is evaluated for a set of points along the Interface1D (using the * ReadCompleteViewMapPixelF0D functor) and then integrated into a single value using a * user-defined integration method. */ class GetCompleteViewMapDensityF1D : public UnaryFunction1D<double> { public: - /*! Builds the functor. + /** Builds the functor. * \param level: * The level of the pyramid from which * the pixel must be read. @@ -147,13 +147,13 @@ class GetCompleteViewMapDensityF1D : public UnaryFunction1D<double> { _sampling = sampling; } - /*! Returns the string "GetCompleteViewMapDensityF1D" */ + /** Returns the string "GetCompleteViewMapDensityF1D" */ string getName() const { return "GetCompleteViewMapDensityF1D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface1D &inter); private: @@ -162,7 +162,7 @@ class GetCompleteViewMapDensityF1D : public UnaryFunction1D<double> { }; // GetDirectionalViewMapDensity -/*! Returns the density evaluated for an Interface1D in of the steerable viewmaps image. +/** Returns the density evaluated for an Interface1D in of the steerable viewmaps image. * The direction telling which Directional map to choose is explicitly specified by the user. * The density is evaluated for a set of points along the Interface1D * (using the ReadSteerableViewMapPixelF0D functor) @@ -170,7 +170,7 @@ class GetCompleteViewMapDensityF1D : public UnaryFunction1D<double> { */ class GetDirectionalViewMapDensityF1D : public UnaryFunction1D<double> { public: - /*! Builds the functor. + /** Builds the functor. * \param iOrientation: * The number of the directional map we must work with. * \param level: @@ -191,13 +191,13 @@ class GetDirectionalViewMapDensityF1D : public UnaryFunction1D<double> { _sampling = sampling; } - /*! Returns the string "GetDirectionalViewMapDensityF1D" */ + /** Returns the string "GetDirectionalViewMapDensityF1D" */ string getName() const { return "GetDirectionalViewMapDensityF1D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface1D &inter); private: @@ -206,7 +206,7 @@ class GetDirectionalViewMapDensityF1D : public UnaryFunction1D<double> { }; // GetSteerableViewMapDensityF1D -/*! Returns the density of the viewmap for a given Interface1D. The density of each FEdge is +/** Returns the density of the viewmap for a given Interface1D. The density of each FEdge is * evaluated in the proper steerable ViewMap depending on its orientation. */ class GetSteerableViewMapDensityF1D : public UnaryFunction1D<double> { @@ -215,7 +215,7 @@ class GetSteerableViewMapDensityF1D : public UnaryFunction1D<double> { float _sampling; public: - /*! Builds the functor from the level of the pyramid from which the pixel must be read. + /** Builds the functor from the level of the pyramid from which the pixel must be read. * \param level: * The level of the pyramid from which the pixel must be read. * \param iType: @@ -232,23 +232,23 @@ class GetSteerableViewMapDensityF1D : public UnaryFunction1D<double> { _sampling = sampling; } - /*! Destructor */ + /** Destructor */ virtual ~GetSteerableViewMapDensityF1D() { } - /*! Returns the string "GetSteerableViewMapDensityF1D" */ + /** Returns the string "GetSteerableViewMapDensityF1D" */ string getName() const { return "GetSteerableViewMapDensityF1D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface1D &inter); }; // GetViewMapGradientNormF1D -/*! Returns the density of the viewmap for a given Interface1D. The density of each FEdge is +/** Returns the density of the viewmap for a given Interface1D. The density of each FEdge is * evaluated in the proper steerable ViewMap depending on its orientation. */ class GetViewMapGradientNormF1D : public UnaryFunction1D<double> { @@ -258,7 +258,7 @@ class GetViewMapGradientNormF1D : public UnaryFunction1D<double> { Functions0D::GetViewMapGradientNormF0D _func; public: - /*! Builds the functor from the level of the pyramid from which the pixel must be read. + /** Builds the functor from the level of the pyramid from which the pixel must be read. * \param level: * The level of the pyramid from which the pixel must be read. * \param iType: @@ -275,13 +275,13 @@ class GetViewMapGradientNormF1D : public UnaryFunction1D<double> { _sampling = sampling; } - /*! Returns the string "GetSteerableViewMapDensityF1D" */ + /** Returns the string "GetSteerableViewMapDensityF1D" */ string getName() const { return "GetViewMapGradientNormF1D"; } - /*! the () operator. */ + /** the () operator. */ int operator()(Interface1D &inter); }; diff --git a/source/blender/freestyle/intern/stroke/AdvancedPredicates1D.h b/source/blender/freestyle/intern/stroke/AdvancedPredicates1D.h index 25a5efcce34..d7c501e97ad 100644 --- a/source/blender/freestyle/intern/stroke/AdvancedPredicates1D.h +++ b/source/blender/freestyle/intern/stroke/AdvancedPredicates1D.h @@ -38,12 +38,12 @@ namespace Freestyle { namespace Predicates1D { // DensityLowerThanUP1D -/*! Returns true if the density evaluated for the +/** Returns true if the density evaluated for the * Interface1D is less than a user-defined density value. */ class DensityLowerThanUP1D : public UnaryPredicate1D { public: - /*! Builds the functor. + /** Builds the functor. * \param threshold: * The value of the threshold density. * Any Interface1D having a density lower than this threshold will match. @@ -56,13 +56,13 @@ class DensityLowerThanUP1D : public UnaryPredicate1D { _sigma = sigma; } - /*! Returns the string "DensityLowerThanUP1D" */ + /** Returns the string "DensityLowerThanUP1D" */ string getName() const { return "DensityLowerThanUP1D"; } - /*! The () operator. */ + /** The () operator. */ int operator()(Interface1D &inter) { Functions1D::DensityF1D fun(_sigma); diff --git a/source/blender/freestyle/intern/stroke/AdvancedStrokeShaders.h b/source/blender/freestyle/intern/stroke/AdvancedStrokeShaders.h index 63c7d451599..52cd037a73a 100644 --- a/source/blender/freestyle/intern/stroke/AdvancedStrokeShaders.h +++ b/source/blender/freestyle/intern/stroke/AdvancedStrokeShaders.h @@ -25,14 +25,14 @@ namespace Freestyle { -/*! [ Thickness Shader ]. +/** [ Thickness Shader ]. * Assigns thicknesses to the stroke vertices so that the stroke looks like made with a * calligraphic tool. i.e. The stroke will be the thickest in a main direction, the thinnest in the * direction perpendicular to this one, and an interpolation in between. */ class CalligraphicShader : public StrokeShader { public: - /*! Builds the shader. + /** Builds the shader. * \param iMinThickness: * The minimum thickness in the direction perpendicular to the main direction. * \param iMaxThickness: @@ -47,12 +47,12 @@ class CalligraphicShader : public StrokeShader { const Vec2f &iOrientation, bool clamp); - /*! Destructor. */ + /** Destructor. */ virtual ~CalligraphicShader() { } - /*! The shading method */ + /** The shading method */ virtual int shade(Stroke &ioStroke) const; protected: @@ -62,14 +62,14 @@ class CalligraphicShader : public StrokeShader { bool _clamp; }; -/*! [ Geometry Shader ]. +/** [ Geometry Shader ]. * Spatial Noise stroke shader. * Moves the vertices to make the stroke more noisy. * \see \htmlonly <a href=noise/noise.html>noise/noise.html</a> \endhtmlonly */ class SpatialNoiseShader : public StrokeShader { public: - /*! Builds the shader. + /** Builds the shader. * \param iAmount: * The amplitude of the noise. * \param ixScale: @@ -83,12 +83,12 @@ class SpatialNoiseShader : public StrokeShader { */ SpatialNoiseShader(float iAmount, float ixScale, int nbOctave, bool smooth, bool pureRandom); - /*! Destructor. */ + /** Destructor. */ virtual ~SpatialNoiseShader() { } - /*! The shading method. */ + /** The shading method. */ virtual int shade(Stroke &ioStroke) const; protected: @@ -99,7 +99,7 @@ class SpatialNoiseShader : public StrokeShader { bool _pureRandom; }; -/*! [ Geometry Shader ]. +/** [ Geometry Shader ]. * Smooths the stroke. * (Moves the vertices to make the stroke smoother). * Uses curvature flow to converge towards a curve of constant curvature. The diffusion method we @@ -108,7 +108,7 @@ class SpatialNoiseShader : public StrokeShader { */ class SmoothingShader : public StrokeShader { public: - /*! Builds the shader. + /** Builds the shader. * \param iNbIteration: * The number of iterations. (400) * \param iFactorPoint: @@ -135,12 +135,12 @@ class SmoothingShader : public StrokeShader { real iAnisoCurvature, real icarricatureFactor); - /*! Destructor. */ + /** Destructor. */ virtual ~SmoothingShader() { } - /*! The shading method. */ + /** The shading method. */ virtual int shade(Stroke &ioStroke) const; protected: @@ -213,7 +213,7 @@ class Omitter : public Smoother { real _lengthFlat; }; -/*! Omission shader */ +/** Omission shader */ class OmissionShader : public StrokeShader { public: OmissionShader(real sizeWindow, real thrVari, real thrFlat, real lFlat); diff --git a/source/blender/freestyle/intern/stroke/BasicStrokeShaders.h b/source/blender/freestyle/intern/stroke/BasicStrokeShaders.h index 0ac0aa09cf9..fcf661ea72f 100644 --- a/source/blender/freestyle/intern/stroke/BasicStrokeShaders.h +++ b/source/blender/freestyle/intern/stroke/BasicStrokeShaders.h @@ -47,12 +47,12 @@ namespace StrokeShaders { // ////////////////////////////////////////////////////// -/*! [ Thickness Shader ]. +/** [ Thickness Shader ]. * Assigns an absolute constant thickness to every vertices of the Stroke. */ class ConstantThicknessShader : public StrokeShader { public: - /*! Builds the shader. + /** Builds the shader. * \param thickness: * The thickness that must be assigned to the stroke. */ @@ -61,18 +61,18 @@ class ConstantThicknessShader : public StrokeShader { _thickness = thickness; } - /*! Destructor. */ + /** Destructor. */ virtual ~ConstantThicknessShader() { } - /*! Returns the string "ConstantThicknessShader".*/ + /** Returns the string "ConstantThicknessShader".*/ virtual string getName() const { return "ConstantThicknessShader"; } - /*! The shading method. */ + /** The shading method. */ virtual int shade(Stroke &stroke) const; private: @@ -106,7 +106,7 @@ class ConstantExternThicknessShader : public StrokeShader { float _thickness; }; -/*! [ Thickness Shader ]. +/** [ Thickness Shader ]. * Assigns thicknesses values such as the thickness increases from a thickness value A to a * thickness value B between the first vertex to the midpoint vertex and then decreases from B to a * A between this midpoint vertex and the last vertex. The thickness is linearly interpolated from @@ -114,7 +114,7 @@ class ConstantExternThicknessShader : public StrokeShader { */ class IncreasingThicknessShader : public StrokeShader { public: - /*! Builds the shader. + /** Builds the shader. * \param iThicknessMin: * The first thickness value. * \param iThicknessMax: @@ -126,7 +126,7 @@ class IncreasingThicknessShader : public StrokeShader { _ThicknessMax = iThicknessMax; } - /*! Destructor.*/ + /** Destructor.*/ virtual ~IncreasingThicknessShader() { } @@ -136,7 +136,7 @@ class IncreasingThicknessShader : public StrokeShader { return "IncreasingThicknessShader"; } - /*! The shading method. */ + /** The shading method. */ virtual int shade(Stroke &stroke) const; private: @@ -144,7 +144,7 @@ class IncreasingThicknessShader : public StrokeShader { float _ThicknessMax; }; -/*! [ Thickness shader ]. +/** [ Thickness shader ]. * Same as previous but here we allow the user to control the ratio thickness/length so that we * don't get fat short lines */ @@ -155,7 +155,7 @@ class ConstrainedIncreasingThicknessShader : public StrokeShader { float _ratio; public: - /*! Builds the shader. + /** Builds the shader. * \param iThicknessMin: * The first thickness value. * \param iThicknessMax: @@ -171,7 +171,7 @@ class ConstrainedIncreasingThicknessShader : public StrokeShader { _ratio = iRatio; } - /*! Destructor.*/ + /** Destructor.*/ virtual ~ConstrainedIncreasingThicknessShader() { } @@ -181,7 +181,7 @@ class ConstrainedIncreasingThicknessShader : public StrokeShader { return "ConstrainedIncreasingThicknessShader"; } - /*! The shading method. */ + /** The shading method. */ virtual int shade(Stroke &stroke) const; }; @@ -217,7 +217,7 @@ class LengthDependingThicknessShader : public StrokeShader { virtual int shade(Stroke &stroke) const; }; -/*! [ Thickness Shader ]. +/** [ Thickness Shader ]. * Adds some noise to the stroke thickness. * \see \htmlonly <a href=noise/noise.html>noise/noise.html</a>\endhtmlonly */ @@ -229,7 +229,7 @@ class ThicknessNoiseShader : public StrokeShader { public: ThicknessNoiseShader(); - /*! Builds a Thickness Noise Shader + /** Builds a Thickness Noise Shader * \param iAmplitude: * The amplitude of the noise signal * \param iPeriod: @@ -242,7 +242,7 @@ class ThicknessNoiseShader : public StrokeShader { return "ThicknessNoiseShader"; } - /*! The shading method. */ + /** The shading method. */ virtual int shade(Stroke &stroke) const; }; @@ -250,12 +250,12 @@ class ThicknessNoiseShader : public StrokeShader { // Color shaders // ///////////////////////////////////////////////////////// -/*! [ Color Shader ]. +/** [ Color Shader ]. * Assigns a constant color to every vertices of the Stroke. */ class ConstantColorShader : public StrokeShader { public: - /*! Builds the shader from a user-specified color. + /** Builds the shader from a user-specified color. * \param iR: * The red component * \param iG: @@ -278,14 +278,14 @@ class ConstantColorShader : public StrokeShader { return "ConstantColorShader"; } - /*! The shading method. */ + /** The shading method. */ virtual int shade(Stroke &stroke) const; private: float _color[4]; }; -/*! [ Color Shader ]. +/** [ Color Shader ]. * Assigns a varying color to the stroke. * The user specifies 2 colors A and B. The stroke color will change linearly from A to B between * the first and the last vertex. @@ -296,7 +296,7 @@ class IncreasingColorShader : public StrokeShader { float _colorMax[4]; public: - /*! Builds the shader from 2 user-specified colors. + /** Builds the shader from 2 user-specified colors. * \param iRm: * The first color red component * \param iGm: @@ -340,7 +340,7 @@ class IncreasingColorShader : public StrokeShader { return "IncreasingColorShader"; } - /*! The shading method. */ + /** The shading method. */ virtual int shade(Stroke &stroke) const; }; @@ -366,7 +366,7 @@ class MaterialColorShader : public StrokeShader { virtual int shade(Stroke &stroke) const; }; -/*! [ Color Shader ]. +/** [ Color Shader ]. * Shader to add noise to the stroke colors. */ class ColorNoiseShader : public StrokeShader { @@ -377,7 +377,7 @@ class ColorNoiseShader : public StrokeShader { public: ColorNoiseShader(); - /*! Builds a Color Noise Shader + /** Builds a Color Noise Shader * \param iAmplitude: * The amplitude of the noise signal * \param iPeriod: @@ -390,7 +390,7 @@ class ColorNoiseShader : public StrokeShader { return "ColorNoiseShader"; } - /*! The shading method. */ + /** The shading method. */ virtual int shade(Stroke &stroke) const; }; @@ -398,7 +398,7 @@ class ColorNoiseShader : public StrokeShader { // Geometry Shaders // /////////////////////////////////////////////////////////////////////////////// -/*! [ Geometry Shader ]. +/** [ Geometry Shader ]. * Stretches the stroke at its two extremities and following the respective directions: v(1)v(0) * and v(n-1)v(n). */ @@ -407,7 +407,7 @@ class BackboneStretcherShader : public StrokeShader { float _amount; public: - /*! Builds the shader. + /** Builds the shader. * \param iAmount: * The stretching amount value. */ @@ -421,11 +421,11 @@ class BackboneStretcherShader : public StrokeShader { return "BackboneStretcherShader"; } - /*! The shading method */ + /** The shading method */ virtual int shade(Stroke &stroke) const; }; -/*! [ Geometry Shader. ] +/** [ Geometry Shader. ] * Resamples the stroke. * \see Stroke::Resample(float). */ @@ -434,7 +434,7 @@ class SamplingShader : public StrokeShader { float _sampling; public: - /*! Builds the shader. + /** Builds the shader. * \param sampling: * The sampling to use for the stroke resampling */ @@ -448,7 +448,7 @@ class SamplingShader : public StrokeShader { return "SamplingShader"; } - /*! The shading method */ + /** The shading method */ virtual int shade(Stroke &stroke) const; }; @@ -471,7 +471,7 @@ class ExternalContourStretcherShader : public StrokeShader { }; // Bezier curve stroke shader -/*! [ Geometry Shader ]. +/** [ Geometry Shader ]. * Transforms the stroke backbone geometry so that it corresponds to a Bezier Curve approximation * of the original backbone geometry. \see \htmlonly <a * href=bezier/bezier.html>bezier/bezier.html</a> \endhtmlonly @@ -481,7 +481,7 @@ class BezierCurveShader : public StrokeShader { float _error; public: - /*! Builds the shader. + /** Builds the shader. * \param error: * The error we're allowing for the approximation. * This error is the max distance allowed between the new curve and the original geometry. @@ -496,11 +496,11 @@ class BezierCurveShader : public StrokeShader { return "BezierCurveShader"; } - /*! The shading method */ + /** The shading method */ virtual int shade(Stroke &stroke) const; }; -/*! [ Geometry Shader ]. +/** [ Geometry Shader ]. * Shader to modify the Stroke geometry so that it looks more "polygonal". * The basic idea is to start from the minimal stroke approximation consisting in a line joining * the first vertex to the last one and to subdivide using the original stroke vertices until a @@ -511,7 +511,7 @@ class PolygonalizationShader : public StrokeShader { float _error; public: - /*! Builds the shader. + /** Builds the shader. * \param iError: * The error we want our polygonal approximation to have with respect to the original * geometry. The smaller, the closer the new stroke to the original one. @@ -527,11 +527,11 @@ class PolygonalizationShader : public StrokeShader { return "PolygonalizationShader"; } - /*! The shading method */ + /** The shading method */ virtual int shade(Stroke &stroke) const; }; -/*! [ Geometry Shader ]. +/** [ Geometry Shader ]. * Shader to modify the Stroke geometry so that it corresponds to its main direction line. * This shader must be used together with the splitting operator using the curvature criterion. * Indeed, the precision of the approximation will depend on the size of the stroke's pieces. @@ -542,7 +542,7 @@ class GuidingLinesShader : public StrokeShader { float _offset; public: - /*! Builds a Guiding Lines shader + /** Builds a Guiding Lines shader * \param iOffset: * The line that replaces the stroke is initially in the middle of the initial stroke * "bbox". iOffset is the value of the displacement which is applied to this line along its @@ -558,27 +558,27 @@ class GuidingLinesShader : public StrokeShader { return "GuidingLinesShader"; } - /*! The shading method */ + /** The shading method */ virtual int shade(Stroke &stroke) const; }; -/*! [ Geometry Shader ]. +/** [ Geometry Shader ]. * Removes the stroke's extremities. */ class TipRemoverShader : public StrokeShader { public: - /*! Builds the shader. + /** Builds the shader. * \param tipLength: * The length of the piece of stroke we want to remove at each extremity. */ TipRemoverShader(real tipLength); - /*! Destructor. */ + /** Destructor. */ virtual ~TipRemoverShader() { } - /*! The shading method */ + /** The shading method */ virtual string getName() const { return "TipRemoverShader"; @@ -590,7 +590,7 @@ class TipRemoverShader : public StrokeShader { real _tipLength; }; -/*! [ Texture Shader ]. +/** [ Texture Shader ]. * Shader to assign texture to the Stroke material. */ @@ -600,7 +600,7 @@ class BlenderTextureShader : public StrokeShader { bNodeTree *_nodeTree; public: - /*! Builds the shader. + /** Builds the shader. * \param mtex: * The blender texture to use. */ @@ -610,7 +610,7 @@ class BlenderTextureShader : public StrokeShader { _nodeTree = NULL; } - /*! Builds the shader. + /** Builds the shader. * \param nodetree: * A node tree (of new shading nodes) to define textures. */ @@ -625,11 +625,11 @@ class BlenderTextureShader : public StrokeShader { return "BlenderTextureShader"; } - /*! The shading method */ + /** The shading method */ virtual int shade(Stroke &stroke) const; }; -/*! [ Texture Shader ]. +/** [ Texture Shader ]. * Shader to assign texture to the Stroke material. */ @@ -638,7 +638,7 @@ class StrokeTextureStepShader : public StrokeShader { float _step; public: - /*! Builds the shader. + /** Builds the shader. * \param id: * The number of the preset to use. */ @@ -652,7 +652,7 @@ class StrokeTextureStepShader : public StrokeShader { return "StrokeTextureStepShader"; } - /*! The shading method */ + /** The shading method */ virtual int shade(Stroke &stroke) const; }; diff --git a/source/blender/freestyle/intern/stroke/Canvas.h b/source/blender/freestyle/intern/stroke/Canvas.h index 91676946b5d..8d71cd534ec 100644 --- a/source/blender/freestyle/intern/stroke/Canvas.h +++ b/source/blender/freestyle/intern/stroke/Canvas.h @@ -60,12 +60,12 @@ class ImagePyramid; class SteerableViewMap; class StyleModule; -/*! Class to define the canvas on which strokes are drawn. +/** Class to define the canvas on which strokes are drawn. * It's used to store state information about the drawing. */ class Canvas { public: - /*! Returns a pointer on the Canvas instance */ + /** Returns a pointer on the Canvas instance */ static Canvas *getInstance() { return _pInstance; @@ -136,7 +136,7 @@ class Canvas { } /* Maps management */ - /*! Loads an image map. The map will be scaled + /** Loads an image map. The map will be scaled * (without preserving the ratio in order to fit the actual canvas size.). * The image must be a gray values image... * \param iFileName: @@ -152,7 +152,7 @@ class Canvas { unsigned iNbLevels = 4, float iSigma = 1.0f); - /*! Reads a pixel value in a map. + /** Reads a pixel value in a map. * Returns a value between 0 and 1. * \param iMapName: * The name of the map @@ -167,19 +167,19 @@ class Canvas { */ float readMapPixel(const char *iMapName, int level, int x, int y); - /*! Sets the steerable viewmap */ + /** Sets the steerable viewmap */ void loadSteerableViewMap(SteerableViewMap *iSVM) { _steerableViewMap = iSVM; } - /*! Returns the steerable VM */ + /** Returns the steerable VM */ SteerableViewMap *getSteerableViewMap() { return _steerableViewMap; } - /*! accessors */ + /** accessors */ inline const FEdge *selectedFEdge() const { return _SelectedFEdge; @@ -215,13 +215,13 @@ class Canvas { return stroke_count; } - /*! modifiers */ + /** modifiers */ inline void setSelectedFEdge(FEdge *iFEdge) { _SelectedFEdge = iFEdge; } - /*! inserts a shader at pos index+1 */ + /** inserts a shader at pos index+1 */ void PushBackStyleModule(StyleModule *iStyleModule); void InsertStyleModule(unsigned index, StyleModule *iStyleModule); void RemoveStyleModule(unsigned index); diff --git a/source/blender/freestyle/intern/stroke/Chain.h b/source/blender/freestyle/intern/stroke/Chain.h index d5dae5c35ba..bcc6957b714 100644 --- a/source/blender/freestyle/intern/stroke/Chain.h +++ b/source/blender/freestyle/intern/stroke/Chain.h @@ -27,7 +27,7 @@ namespace Freestyle { -/*! Class to represent a 1D elements issued from the chaining process. +/** Class to represent a 1D elements issued from the chaining process. * A Chain is the last step before the Stroke and is used in the Splitting and Creation processes. */ class Chain : public Curve { @@ -38,28 +38,28 @@ class Chain : public Curve { _fedgeB; // the last FEdge of the ViewEdge passed to the last call for push_viewedge_back(). public: - /*! Default constructor. */ + /** Default constructor. */ Chain() : Curve() { _splittingId = 0; _fedgeB = 0; } - /*! Builds a chain from its Id. */ + /** Builds a chain from its Id. */ Chain(const Id &id) : Curve(id) { _splittingId = 0; _fedgeB = 0; } - /*! Copy Constructor */ + /** Copy Constructor */ Chain(const Chain &iBrother) : Curve(iBrother) { _splittingId = iBrother._splittingId; _fedgeB = iBrother._fedgeB; } - /*! Destructor. */ + /** Destructor. */ virtual ~Chain() { // only the last splitted deletes this id @@ -70,13 +70,13 @@ class Chain : public Curve { } } - /*! Returns the string "Chain" */ + /** Returns the string "Chain" */ virtual string getExactTypeName() const { return "Chain"; } - /*! Adds a ViewEdge at the end of the chain + /** Adds a ViewEdge at the end of the chain * \param iViewEdge: * The ViewEdge that must be added. * \param orientation: @@ -84,7 +84,7 @@ class Chain : public Curve { */ void push_viewedge_back(ViewEdge *iViewEdge, bool orientation); - /*! Adds a ViewEdge at the beginning of the chain + /** Adds a ViewEdge at the beginning of the chain * \param iViewEdge: * The ViewEdge that must be added. * \param orientation: diff --git a/source/blender/freestyle/intern/stroke/ChainingIterators.h b/source/blender/freestyle/intern/stroke/ChainingIterators.h index 0a9e7114ecb..c0259471277 100644 --- a/source/blender/freestyle/intern/stroke/ChainingIterators.h +++ b/source/blender/freestyle/intern/stroke/ChainingIterators.h @@ -98,11 +98,11 @@ class AdjacencyIterator : public Iterator { return _internalIterator.isBegin(); } - /*! Returns true if the current ViewEdge is coming towards the iteration vertex. + /** Returns true if the current ViewEdge is coming towards the iteration vertex. * False otherwise. */ bool isIncoming() const; - /*! Returns a *pointer* to the pointed ViewEdge. */ + /** Returns a *pointer* to the pointed ViewEdge. */ virtual ViewEdge *operator*(); virtual ViewEdge *operator->() @@ -140,7 +140,7 @@ class AdjacencyIterator : public Iterator { // /////////////////////////////////////////////////////////// -/*! Base class for chaining iterators. +/** Base class for chaining iterators. * This class is designed to be overloaded in order to describe chaining rules. * It makes the works of chaining rules description easier. * The two main methods that need to overloaded are traverse() and init(). @@ -159,7 +159,7 @@ class ChainingIterator : public ViewEdgeInternal::ViewEdgeIterator { ViewEdge *result; void *py_c_it; - /*! Builds a Chaining Iterator from the first ViewEdge used for iteration and its orientation. + /** Builds a Chaining Iterator from the first ViewEdge used for iteration and its orientation. * \param iRestrictToSelection: * Indicates whether to force the chaining to stay within * the set of selected ViewEdges or not. @@ -183,7 +183,7 @@ class ChainingIterator : public ViewEdgeInternal::ViewEdgeIterator { py_c_it = NULL; } - /*! Copy constructor */ + /** Copy constructor */ ChainingIterator(const ChainingIterator &brother) : ViewEdgeIterator(brother) { _restrictToSelection = brother._restrictToSelection; @@ -192,19 +192,19 @@ class ChainingIterator : public ViewEdgeInternal::ViewEdgeIterator { py_c_it = brother.py_c_it; } - /*! Returns the string "ChainingIterator" */ + /** Returns the string "ChainingIterator" */ virtual string getExactTypeName() const { return "ChainingIterator"; } - /*! Inits the iterator context. + /** Inits the iterator context. * This method is called each time a new chain is started. * It can be used to reset some history information that you might want to keep. */ virtual int init(); - /*! This method iterates over the potential next ViewEdges and returns the one that will be + /** This method iterates over the potential next ViewEdges and returns the one that will be * followed next. returns the next ViewEdge to follow or 0 when the end of the chain is reached. * \param it: * The iterator over the ViewEdges adjacent to the end vertex of the current ViewEdge. @@ -214,11 +214,11 @@ class ChainingIterator : public ViewEdgeInternal::ViewEdgeIterator { virtual int traverse(const AdjacencyIterator &it); /* accessors */ - /*! Returns true if the orientation of the current ViewEdge corresponds to its natural + /** Returns true if the orientation of the current ViewEdge corresponds to its natural * orientation */ // inline bool getOrientation() const {} - /*! Returns the vertex which is the next crossing */ + /** Returns the vertex which is the next crossing */ inline ViewVertex *getVertex() { if (_increment) { @@ -239,7 +239,7 @@ class ChainingIterator : public ViewEdgeInternal::ViewEdgeIterator { } } - /*! Returns true if the current iteration is an incrementation */ + /** Returns true if the current iteration is an incrementation */ inline bool isIncrementing() const { return _increment; @@ -255,7 +255,7 @@ class ChainingIterator : public ViewEdgeInternal::ViewEdgeIterator { // /////////////////////////////////////////////////////////// -/*! A ViewEdge Iterator used to follow ViewEdges the most naturally. +/** A ViewEdge Iterator used to follow ViewEdges the most naturally. * For example, it will follow visible ViewEdges of same nature. * As soon, as the nature or the visibility changes, the iteration stops (by setting the pointed * ViewEdge to 0). In the case of an iteration over a set of ViewEdge that are both Silhouette @@ -263,7 +263,7 @@ class ChainingIterator : public ViewEdgeInternal::ViewEdgeIterator { */ class ChainSilhouetteIterator : public ChainingIterator { public: - /*! Builds a ChainSilhouetteIterator from the first ViewEdge used for iteration and its + /** Builds a ChainSilhouetteIterator from the first ViewEdge used for iteration and its * orientation. * \param iRestrictToSelection: * Indicates whether to force the chaining to stay within the set of selected ViewEdges or @@ -282,24 +282,24 @@ class ChainSilhouetteIterator : public ChainingIterator { { } - /*! Copy constructor */ + /** Copy constructor */ ChainSilhouetteIterator(const ChainSilhouetteIterator &brother) : ChainingIterator(brother) { } - /*! Returns the string "ChainSilhouetteIterator" */ + /** Returns the string "ChainSilhouetteIterator" */ virtual string getExactTypeName() const { return "ChainSilhouetteIterator"; } - /*! This method iterates over the potential next ViewEdges and returns the one that will be + /** This method iterates over the potential next ViewEdges and returns the one that will be * followed next. * When reaching the end of a chain, 0 is returned. */ virtual int traverse(const AdjacencyIterator &it); - /*! Inits the iterator context */ + /** Inits the iterator context */ virtual int init() { return 0; @@ -311,7 +311,7 @@ class ChainSilhouetteIterator : public ChainingIterator { // /////////////////////////////////////////////////////////// -/*! A "generic" user-controlled ViewEdge iterator. This iterator is in particular built from a +/** A "generic" user-controlled ViewEdge iterator. This iterator is in particular built from a * unary predicate and a binary predicate. * First, the unary predicate is evaluated for all potential next ViewEdges in order to only * keep the ones respecting a certain constraint. @@ -327,7 +327,7 @@ class ChainPredicateIterator : public ChainingIterator { UnaryPredicate1D *_unary_predicate; // the caller is responsible for the deletion of this object public: - /*! Builds a ChainPredicateIterator from a starting ViewEdge and its orientation. + /** Builds a ChainPredicateIterator from a starting ViewEdge and its orientation. * \param iRestrictToSelection: * Indicates whether to force the chaining to stay * within the set of selected ViewEdges or not. @@ -350,7 +350,7 @@ class ChainPredicateIterator : public ChainingIterator { _unary_predicate = 0; } - /*! Builds a ChainPredicateIterator from a unary predicate, a binary predicate, a starting + /** Builds a ChainPredicateIterator from a unary predicate, a binary predicate, a starting * ViewEdge and its orientation. * \param iRestrictToSelection: * Indicates whether to force the chaining to stay @@ -381,32 +381,32 @@ class ChainPredicateIterator : public ChainingIterator { _binary_predicate = &bpred; } - /*! Copy constructor */ + /** Copy constructor */ ChainPredicateIterator(const ChainPredicateIterator &brother) : ChainingIterator(brother) { _unary_predicate = brother._unary_predicate; _binary_predicate = brother._binary_predicate; } - /*! Destructor. */ + /** Destructor. */ virtual ~ChainPredicateIterator() { _unary_predicate = 0; _binary_predicate = 0; } - /*! Returns the string "ChainPredicateIterator" */ + /** Returns the string "ChainPredicateIterator" */ virtual string getExactTypeName() const { return "ChainPredicateIterator"; } - /*! This method iterates over the potential next ViewEdges and returns the one that will be + /** This method iterates over the potential next ViewEdges and returns the one that will be * followed next. When reaching the end of a chain, 0 is returned. */ virtual int traverse(const AdjacencyIterator &it); - /*! Inits the iterator context */ + /** Inits the iterator context */ virtual int init() { return 0; diff --git a/source/blender/freestyle/intern/stroke/ContextFunctions.h b/source/blender/freestyle/intern/stroke/ContextFunctions.h index 334bdd657c1..4878d2a6c54 100644 --- a/source/blender/freestyle/intern/stroke/ContextFunctions.h +++ b/source/blender/freestyle/intern/stroke/ContextFunctions.h @@ -33,34 +33,34 @@ namespace Freestyle { // Context Functions definitions // /////////////////////////////////////////////////////////// -/*! namespace containing all the Context related functions */ +/** namespace containing all the Context related functions */ namespace ContextFunctions { // GetTimeStamp -/*! Returns the system time stamp */ +/** Returns the system time stamp */ unsigned GetTimeStampCF(); // GetCanvasWidth -/*! Returns the canvas width */ +/** Returns the canvas width */ unsigned GetCanvasWidthCF(); // GetCanvasHeight -/*! Returns the canvas height */ +/** Returns the canvas height */ unsigned GetCanvasHeightCF(); // GetBorder -/*! Returns the border */ +/** Returns the border */ BBox<Vec2i> GetBorderCF(); // Load map -/*! Loads an image map for further reading */ +/** Loads an image map for further reading */ void LoadMapCF(const char *iFileName, const char *iMapName, unsigned iNbLevels = 4, float iSigma = 1.0f); // ReadMapPixel -/*! Reads a pixel in a user-defined map +/** Reads a pixel in a user-defined map * \return the floating value stored for that pixel * \param iMapName: * The name of the map @@ -74,7 +74,7 @@ void LoadMapCF(const char *iFileName, float ReadMapPixelCF(const char *iMapName, int level, unsigned x, unsigned y); // ReadCompleteViewMapPixel -/*! Reads a pixel in the complete view map +/** Reads a pixel in the complete view map * \return the floating value stored for that pixel * \param level: * The level of the pyramid in which we wish to read the pixel @@ -86,7 +86,7 @@ float ReadMapPixelCF(const char *iMapName, int level, unsigned x, unsigned y); float ReadCompleteViewMapPixelCF(int level, unsigned x, unsigned y); // ReadOrientedViewMapPixel -/*! Reads a pixel in one of the oriented view map images +/** Reads a pixel in one of the oriented view map images * \return the floating value stored for that pixel * \param iOrientation: * The number telling which orientation we want to check diff --git a/source/blender/freestyle/intern/stroke/Curve.cpp b/source/blender/freestyle/intern/stroke/Curve.cpp index 768e9efa15d..08d7a0b792a 100644 --- a/source/blender/freestyle/intern/stroke/Curve.cpp +++ b/source/blender/freestyle/intern/stroke/Curve.cpp @@ -573,7 +573,7 @@ Curve::~Curve() } } -/*! iterators access */ +/** iterators access */ Curve::point_iterator Curve::points_begin(float step) { vertex_container::iterator second = _Vertices.begin(); diff --git a/source/blender/freestyle/intern/stroke/Curve.h b/source/blender/freestyle/intern/stroke/Curve.h index f0db45150a9..cce5353a5c7 100644 --- a/source/blender/freestyle/intern/stroke/Curve.h +++ b/source/blender/freestyle/intern/stroke/Curve.h @@ -52,7 +52,7 @@ using namespace Geometry; /* */ /**********************************/ -/*! Class to represent a point of a curve. +/** Class to represent a point of a curve. * A CurvePoint can be any point of a 1D curve (it doesn't have to be a vertex of the curve). * Any Interface1D is built upon ViewEdges, themselves built upon FEdges. Therefore, a curve is * basically a polyline made of a list SVertex. Thus, a CurvePoint is built by linearly @@ -61,56 +61,56 @@ using namespace Geometry; */ class CurvePoint : public Interface0D { public: // Implementation of Interface0D - /*! Returns the string "CurvePoint"*/ + /** Returns the string "CurvePoint"*/ virtual string getExactTypeName() const { return "CurvePoint"; } // Data access methods - /*! Returns the 3D X coordinate of the point */ + /** Returns the 3D X coordinate of the point */ virtual real getX() const { return _Point3d.x(); } - /*! Returns the 3D Y coordinate of the point */ + /** Returns the 3D Y coordinate of the point */ virtual real getY() const { return _Point3d.y(); } - /*! Returns the 3D Z coordinate of the point */ + /** Returns the 3D Z coordinate of the point */ virtual real getZ() const { return _Point3d.z(); } - /*! Returns the 3D point. */ + /** Returns the 3D point. */ virtual Vec3r getPoint3D() const { return _Point3d; } - /*! Returns the projected 3D X coordinate of the point */ + /** Returns the projected 3D X coordinate of the point */ virtual real getProjectedX() const { return _Point2d.x(); } - /*! Returns the projected 3D Y coordinate of the point */ + /** Returns the projected 3D Y coordinate of the point */ virtual real getProjectedY() const { return _Point2d.y(); } - /*! Returns the projected 3D Z coordinate of the point */ + /** Returns the projected 3D Z coordinate of the point */ virtual real getProjectedZ() const { return _Point2d.z(); } - /*! Returns the 2D point. */ + /** Returns the 2D point. */ virtual Vec2r getPoint2D() const { return Vec2r(_Point2d.x(), _Point2d.y()); @@ -118,7 +118,7 @@ class CurvePoint : public Interface0D { virtual FEdge *getFEdge(Interface0D &inter); - /*! Returns the CurvePoint's Id */ + /** Returns the CurvePoint's Id */ virtual Id getId() const { Id id; @@ -131,7 +131,7 @@ class CurvePoint : public Interface0D { return id; } - /*! Returns the CurvePoint's Nature */ + /** Returns the CurvePoint's Nature */ virtual Nature::VertexNature getNature() const { Nature::VertexNature nature = Nature::POINT; @@ -144,7 +144,7 @@ class CurvePoint : public Interface0D { return nature; } - /*! Cast the Interface0D in SVertex if it can be. */ + /** Cast the Interface0D in SVertex if it can be. */ virtual SVertex *castToSVertex() { if (_t2d == 0) { @@ -156,7 +156,7 @@ class CurvePoint : public Interface0D { return Interface0D::castToSVertex(); } - /*! Cast the Interface0D in ViewVertex if it can be. */ + /** Cast the Interface0D in ViewVertex if it can be. */ virtual ViewVertex *castToViewVertex() { if (_t2d == 0) { @@ -168,7 +168,7 @@ class CurvePoint : public Interface0D { return Interface0D::castToViewVertex(); } - /*! Cast the Interface0D in NonTVertex if it can be. */ + /** Cast the Interface0D in NonTVertex if it can be. */ virtual NonTVertex *castToNonTVertex() { if (_t2d == 0) { @@ -180,7 +180,7 @@ class CurvePoint : public Interface0D { return Interface0D::castToNonTVertex(); } - /*! Cast the Interface0D in TVertex if it can be. */ + /** Cast the Interface0D in TVertex if it can be. */ virtual TVertex *castToTVertex() { if (_t2d == 0) { @@ -204,10 +204,10 @@ class CurvePoint : public Interface0D { Vec3r _Point3d; public: - /*! Default Constructor. */ + /** Default Constructor. */ CurvePoint(); - /*! Builds a CurvePoint from two SVertex and an interpolation parameter. + /** Builds a CurvePoint from two SVertex and an interpolation parameter. * \param iA: * The first SVertex * \param iB: @@ -217,7 +217,7 @@ class CurvePoint : public Interface0D { */ CurvePoint(SVertex *iA, SVertex *iB, float t); - /*! Builds a CurvePoint from two CurvePoint and an interpolation parameter. + /** Builds a CurvePoint from two CurvePoint and an interpolation parameter. * \param iA: * The first CurvePoint * \param iB: @@ -229,35 +229,35 @@ class CurvePoint : public Interface0D { // CurvePoint(SVertex *iA, SVertex *iB, float t2d, float t3d); - /*! Copy Constructor. */ + /** Copy Constructor. */ CurvePoint(const CurvePoint &iBrother); - /*! Operator = */ + /** Operator = */ CurvePoint &operator=(const CurvePoint &iBrother); - /*! Destructor */ + /** Destructor */ virtual ~CurvePoint() = default; - /*! Operator == */ + /** Operator == */ bool operator==(const CurvePoint &b) { return ((__A == b.__A) && (__B == b.__B) && (_t2d == b._t2d)); } /* accessors */ - /*! Returns the first SVertex upon which the CurvePoint is built. */ + /** Returns the first SVertex upon which the CurvePoint is built. */ inline SVertex *A() { return __A; } - /*! Returns the second SVertex upon which the CurvePoint is built. */ + /** Returns the second SVertex upon which the CurvePoint is built. */ inline SVertex *B() { return __B; } - /*! Returns the interpolation parameter. */ + /** Returns the interpolation parameter. */ inline float t2d() const { return _t2d; @@ -271,19 +271,19 @@ class CurvePoint : public Interface0D { #endif /* modifiers */ - /*! Sets the first SVertex upon which to build the CurvePoint. */ + /** Sets the first SVertex upon which to build the CurvePoint. */ inline void setA(SVertex *iA) { __A = iA; } - /*! Sets the second SVertex upon which to build the CurvePoint. */ + /** Sets the second SVertex upon which to build the CurvePoint. */ inline void setB(SVertex *iB) { __B = iB; } - /*! Sets the 2D interpolation parameter to use. */ + /** Sets the 2D interpolation parameter to use. */ inline void setT2d(float t) { _t2d = t; @@ -339,7 +339,7 @@ class CurvePoint : public Interface0D { } Vec3r curvature2d_as_vector() const; - /*! angle in radians */ + /** angle in radians */ real curvature2d_as_angle() const; real curvatureFredo() const; @@ -368,7 +368,7 @@ class CurvePointIterator; } // end of namespace CurveInternal -/*! Base class for curves made of CurvePoints. +/** Base class for curves made of CurvePoints. * SVertex is the type of the initial curve vertices. * A Chain is a specialization of a Curve. */ @@ -396,7 +396,7 @@ class Curve : public Interface1D { unsigned _nSegments; // number of segments public: - /*! Default Constructor. */ + /** Default Constructor. */ Curve() { _Length = 0; @@ -404,7 +404,7 @@ class Curve : public Interface1D { _nSegments = 0; } - /*! Builds a Curve from its id */ + /** Builds a Curve from its id */ Curve(const Id &id) { _Length = 0; @@ -412,7 +412,7 @@ class Curve : public Interface1D { _nSegments = 0; } - /*! Copy Constructor. */ + /** Copy Constructor. */ Curve(const Curve &iBrother) { _Length = iBrother._Length; @@ -421,10 +421,10 @@ class Curve : public Interface1D { _nSegments = 0; } - /*! Destructor. */ + /** Destructor. */ virtual ~Curve(); - /*! Returns the string "Curve" */ + /** Returns the string "Curve" */ virtual string getExactTypeName() const { return "Curve"; @@ -435,7 +435,7 @@ class Curve : public Interface1D { void computeCurvatureAndOrientation(); #endif - /*! Adds a single vertex (CurvePoint) at the end of the Curve */ + /** Adds a single vertex (CurvePoint) at the end of the Curve */ inline void push_vertex_back(Vertex *iVertex) { if (!_Vertices.empty()) { @@ -447,7 +447,7 @@ class Curve : public Interface1D { _Vertices.push_back(new_vertex); } - /*! Adds a single vertex (SVertex) at the end of the Curve */ + /** Adds a single vertex (SVertex) at the end of the Curve */ inline void push_vertex_back(SVertex *iVertex) { if (!_Vertices.empty()) { @@ -459,7 +459,7 @@ class Curve : public Interface1D { _Vertices.push_back(new_vertex); } - /*! Adds a single vertex (CurvePoint) at the front of the Curve */ + /** Adds a single vertex (CurvePoint) at the front of the Curve */ inline void push_vertex_front(Vertex *iVertex) { if (!_Vertices.empty()) { @@ -471,7 +471,7 @@ class Curve : public Interface1D { _Vertices.push_front(new_vertex); } - /*! Adds a single vertex (SVertex) at the front of the Curve */ + /** Adds a single vertex (SVertex) at the front of the Curve */ inline void push_vertex_front(SVertex *iVertex) { if (!_Vertices.empty()) { @@ -483,25 +483,25 @@ class Curve : public Interface1D { _Vertices.push_front(new_vertex); } - /*! Returns true is the Curve doesn't have any Vertex yet. */ + /** Returns true is the Curve doesn't have any Vertex yet. */ inline bool empty() const { return _Vertices.empty(); } - /*! Returns the 2D length of the Curve. */ + /** Returns the 2D length of the Curve. */ inline real getLength2D() const { return _Length; } - /*! Returns the Id of the 1D element. */ + /** Returns the Id of the 1D element. */ virtual Id getId() const { return _Id; } - /*! Returns the number of segments in the polyline constituting the Curve. */ + /** Returns the number of segments in the polyline constituting the Curve. */ inline unsigned int nSegments() const { return _nSegments; @@ -549,7 +549,7 @@ class Curve : public Interface1D { float local_depth_variance(int iCombination = 0) const; real local_average_density(float sigma = 2.3f, int iCombination = 0) const; Vec3r curvature2d_as_vector(int iCombination = 0) const; - /*! angle in radians */ + /** angle in radians */ real curvature2d_as_angle(int iCombination = 0) const; #endif @@ -573,23 +573,23 @@ class Curve : public Interface1D { CurveInternal::CurvePointIterator curveVerticesEnd(); // Iterators access - /*! Returns an Interface0DIterator pointing onto the first vertex of the Curve and that can + /** Returns an Interface0DIterator pointing onto the first vertex of the Curve and that can * iterate over the \a vertices of the Curve. */ virtual Interface0DIterator verticesBegin(); - /*! Returns an Interface0DIterator pointing after the last vertex of the Curve and that can + /** Returns an Interface0DIterator pointing after the last vertex of the Curve and that can * iterate over the \a vertices of the Curve. */ virtual Interface0DIterator verticesEnd(); - /*! Returns an Interface0DIterator pointing onto the first point of the Curve and that can + /** Returns an Interface0DIterator pointing onto the first point of the Curve and that can * iterate over the \a points of the Curve at any resolution. At each iteration a virtual * temporary CurvePoint is created. */ virtual Interface0DIterator pointsBegin(float t = 0.0f); - /*! Returns an Interface0DIterator pointing after the last point of the Curve and that can + /** Returns an Interface0DIterator pointing after the last point of the Curve and that can * iterate over the \a points of the Curve at any resolution. At each iteration a virtual * temporary CurvePoint is created. */ diff --git a/source/blender/freestyle/intern/stroke/CurveAdvancedIterators.h b/source/blender/freestyle/intern/stroke/CurveAdvancedIterators.h index 1896a674477..5cb5ab69711 100644 --- a/source/blender/freestyle/intern/stroke/CurveAdvancedIterators.h +++ b/source/blender/freestyle/intern/stroke/CurveAdvancedIterators.h @@ -50,7 +50,7 @@ class CurvePoint_nonconst_traits : public Nonconst_traits<CurvePoint *> { /* */ /**********************************/ -/*! iterator on a curve. Allows an iterating outside initial vertices. A CurvePoint is +/** iterator on a curve. Allows an iterating outside initial vertices. A CurvePoint is * instantiated and returned when the iterator is dereferenced. */ template<class Traits> diff --git a/source/blender/freestyle/intern/stroke/CurveIterators.h b/source/blender/freestyle/intern/stroke/CurveIterators.h index 9d1cf33ed80..abbde02979d 100644 --- a/source/blender/freestyle/intern/stroke/CurveIterators.h +++ b/source/blender/freestyle/intern/stroke/CurveIterators.h @@ -28,7 +28,7 @@ namespace Freestyle { namespace CurveInternal { -/*! iterator on a curve. Allows an iterating outside +/** iterator on a curve. Allows an iterating outside * initial vertices. A CurvePoint is instantiated an returned * when the iterator is dereferenced. */ diff --git a/source/blender/freestyle/intern/stroke/Modifiers.h b/source/blender/freestyle/intern/stroke/Modifiers.h index 0aac6f58658..1952659dab7 100644 --- a/source/blender/freestyle/intern/stroke/Modifiers.h +++ b/source/blender/freestyle/intern/stroke/Modifiers.h @@ -35,16 +35,16 @@ namespace Freestyle { * * * ----------------------------------------- */ -/*! Base class for modifiers. +/** Base class for modifiers. * Modifiers are used in the Operators in order to "mark" the processed Interface1D. */ template<class Edge> struct EdgeModifier : public unary_function<Edge, void> { - /*! Default construction */ + /** Default construction */ EdgeModifier() : unary_function<Edge, void>() { } - /*! the () operator */ + /** the () operator */ virtual void operator()(Edge &iEdge) { } @@ -54,14 +54,14 @@ template<class Edge> struct EdgeModifier : public unary_function<Edge, void> { #endif }; -/*! Modifier that sets the time stamp of an Interface1D to the time stamp of the system. */ +/** Modifier that sets the time stamp of an Interface1D to the time stamp of the system. */ template<class Edge> struct TimestampModifier : public EdgeModifier<Edge> { - /*! Default constructor */ + /** Default constructor */ TimestampModifier() : EdgeModifier<Edge>() { } - /*! The () operator. */ + /** The () operator. */ virtual void operator()(Edge &iEdge) { TimeStamp *timestamp = TimeStamp::instance(); diff --git a/source/blender/freestyle/intern/stroke/Operators.h b/source/blender/freestyle/intern/stroke/Operators.h index e721e9fb837..4de331993f7 100644 --- a/source/blender/freestyle/intern/stroke/Operators.h +++ b/source/blender/freestyle/intern/stroke/Operators.h @@ -41,7 +41,7 @@ namespace Freestyle { -/*! Class defining the operators used in a style module. +/** Class defining the operators used in a style module. * There are 4 classes of operators: Selection, Chaining, Splitting and Creating. * All these operators are user controlled in the scripting language through Functors, Predicates * and Shaders that are taken as arguments. @@ -57,12 +57,12 @@ class Operators { // //////////////////////////////////////////////// - /*! Selects the ViewEdges of the ViewMap verifying a specified condition. + /** Selects the ViewEdges of the ViewMap verifying a specified condition. * \param pred: The predicate expressing this condition */ static int select(UnaryPredicate1D &pred); - /*! Builds a set of chains from the current set of ViewEdges. + /** Builds a set of chains from the current set of ViewEdges. * Each ViewEdge of the current list starts a new chain. * The chaining operator then iterates over the ViewEdges * of the ViewMap using the user specified iterator. @@ -80,7 +80,7 @@ class Operators { UnaryPredicate1D &pred, UnaryFunction1D_void &modifier); - /*! Builds a set of chains from the current set of ViewEdges. + /** Builds a set of chains from the current set of ViewEdges. * Each ViewEdge of the current list starts a new chain. The chaining operator then iterates * over the ViewEdges * of the ViewMap using the user specified iterator. @@ -95,7 +95,7 @@ class Operators { */ static int chain(ViewEdgeInternal::ViewEdgeIterator &it, UnaryPredicate1D &pred); - /*! Builds a set of chains from the current set of ViewEdges. + /** Builds a set of chains from the current set of ViewEdges. * Each ViewEdge of the current list potentially starts a new chain. The chaining operator then * iterates over the ViewEdges of the ViewMap using the user specified iterator. * This operator iterates both using the increment and decrement operators and is therefore @@ -111,7 +111,7 @@ class Operators { */ static int bidirectionalChain(ChainingIterator &it, UnaryPredicate1D &pred); - /*! The only difference with the above bidirectional chaining algorithm is that we don't need to + /** The only difference with the above bidirectional chaining algorithm is that we don't need to * pass a stopping criterion. This might be desirable when the stopping criterion is already * contained in the iterator definition. Builds a set of chains from the current set of * ViewEdges. Each ViewEdge of the current list potentially starts a new chain. The chaining @@ -127,7 +127,7 @@ class Operators { */ static int bidirectionalChain(ChainingIterator &it); - /*! Splits each chain of the current set of chains in a sequential way. + /** Splits each chain of the current set of chains in a sequential way. * The points of each chain are processed (with a specified sampling) sequentially. * Each time a user specified starting condition is verified, a new chain begins and ends as * soon as a user-defined stopping predicate is verified. @@ -147,7 +147,7 @@ class Operators { UnaryPredicate0D &stoppingPred, float sampling = 0.0f); - /*! Splits each chain of the current set of chains in a sequential way. + /** Splits each chain of the current set of chains in a sequential way. * The points of each chain are processed (with a specified sampling) sequentially and each time * a user specified condition is verified, the chain is split into two chains. * The resulting set of chains is a partition of the initial chain @@ -160,7 +160,7 @@ class Operators { */ static int sequentialSplit(UnaryPredicate0D &pred, float sampling = 0.0f); - /*! Splits the current set of chains in a recursive way. + /** Splits the current set of chains in a recursive way. * We process the points of each chain (with a specified sampling) to find the point * minimizing a specified function. The chain is split in two at this point and the two new * chains are processed in the same way. The recursivity level is controlled through a @@ -181,7 +181,7 @@ class Operators { UnaryPredicate1D &pred, float sampling = 0); - /*! Splits the current set of chains in a recursive way. + /** Splits the current set of chains in a recursive way. * We process the points of each chain (with a specified sampling) to find the point minimizing * a specified function. The chain is split in two at this point and the two new chains are * processed in the same way. The user can specify a 0D predicate to make a first selection on @@ -210,14 +210,14 @@ class Operators { UnaryPredicate1D &pred, float sampling = 0.0f); - /*! Sorts the current set of chains (or viewedges) + /** Sorts the current set of chains (or viewedges) * according to the comparison predicate given as argument. * \param pred: * The binary predicate used for the comparison */ static int sort(BinaryPredicate1D &pred); - /*! Creates and shades the strokes from the current set of chains. + /** Creates and shades the strokes from the current set of chains. * A predicate can be specified to make a selection pass on the chains. * \param pred: * The predicate that a chain must verify in order to be transform as a stroke diff --git a/source/blender/freestyle/intern/stroke/PSStrokeRenderer.h b/source/blender/freestyle/intern/stroke/PSStrokeRenderer.h index 46bb46ad8b2..349392a4c0e 100644 --- a/source/blender/freestyle/intern/stroke/PSStrokeRenderer.h +++ b/source/blender/freestyle/intern/stroke/PSStrokeRenderer.h @@ -41,7 +41,7 @@ class PSStrokeRenderer : public StrokeRenderer { public: PSStrokeRenderer(const char *iFileName = NULL); - /*! Renders a stroke rep */ + /** Renders a stroke rep */ virtual void RenderStrokeRep(StrokeRep *iStrokeRep) const; virtual void RenderStrokeRepBasic(StrokeRep *iStrokeRep) const; diff --git a/source/blender/freestyle/intern/stroke/Predicates0D.h b/source/blender/freestyle/intern/stroke/Predicates0D.h index 89dbaeb339d..cd00d582b30 100644 --- a/source/blender/freestyle/intern/stroke/Predicates0D.h +++ b/source/blender/freestyle/intern/stroke/Predicates0D.h @@ -34,7 +34,7 @@ namespace Freestyle { // /////////////////////////////////////////////////////////// -/*! Base class for Unary Predicates that work on Interface0DIterator. +/** Base class for Unary Predicates that work on Interface0DIterator. * A UnaryPredicate0D is a functor that evaluates a condition on a Interface0DIterator and returns * true or false depending on whether this condition is satisfied or not. * The UnaryPredicate0D is used by calling its () operator. @@ -45,24 +45,24 @@ class UnaryPredicate0D { bool result; void *py_up0D; - /*! Default constructor. */ + /** Default constructor. */ UnaryPredicate0D() { py_up0D = 0; } - /*! Destructor. */ + /** Destructor. */ virtual ~UnaryPredicate0D() { } - /*! Returns the string of the name of the UnaryPredicate0D. */ + /** Returns the string of the name of the UnaryPredicate0D. */ virtual string getName() const { return "UnaryPredicate0D"; } - /*! The () operator. Must be overload by inherited classes. + /** The () operator. Must be overload by inherited classes. * \param it: * The Interface0DIterator pointing onto the Interface0D at which we wish to evaluate the * predicate. \return true if the condition is satisfied, false otherwise. @@ -79,7 +79,7 @@ class UnaryPredicate0D { // /////////////////////////////////////////////////////////// -/*! Base class for Binary Predicates working on Interface0D. +/** Base class for Binary Predicates working on Interface0D. * A BinaryPredicate0D is typically an ordering relation between two Interface0D. * It evaluates a relation between 2 Interface0D and returns true or false. * It is used by calling the () operator. @@ -89,24 +89,24 @@ class BinaryPredicate0D { bool result; void *py_bp0D; - /*! Default constructor. */ + /** Default constructor. */ BinaryPredicate0D() { py_bp0D = 0; } - /*! Destructor. */ + /** Destructor. */ virtual ~BinaryPredicate0D() { } - /*! Returns the string of the name of the binary predicate. */ + /** Returns the string of the name of the binary predicate. */ virtual string getName() const { return "BinaryPredicate0D"; } - /*! The () operator. Must be overload by inherited classes. + /** The () operator. Must be overload by inherited classes. * It evaluates a relation between 2 Interface0D. * \param inter1: * The first Interface0D. @@ -129,21 +129,21 @@ class BinaryPredicate0D { namespace Predicates0D { // TrueUP0D -/*! Returns true any time */ +/** Returns true any time */ class TrueUP0D : public UnaryPredicate0D { public: - /*! Default constructor. */ + /** Default constructor. */ TrueUP0D() { } - /*! Returns the string "TrueUP0D"*/ + /** Returns the string "TrueUP0D"*/ string getName() const { return "TrueUP0D"; } - /*! The () operator. */ + /** The () operator. */ int operator()(Interface0DIterator &) { result = true; @@ -152,21 +152,21 @@ class TrueUP0D : public UnaryPredicate0D { }; // FalseUP0D -/*! Returns false any time */ +/** Returns false any time */ class FalseUP0D : public UnaryPredicate0D { public: - /*! Default constructor. */ + /** Default constructor. */ FalseUP0D() { } - /*! Returns the string "FalseUP0D"*/ + /** Returns the string "FalseUP0D"*/ string getName() const { return "FalseUP0D"; } - /*! The () operator. */ + /** The () operator. */ int operator()(Interface0DIterator &) { result = false; diff --git a/source/blender/freestyle/intern/stroke/Predicates1D.h b/source/blender/freestyle/intern/stroke/Predicates1D.h index c174162b214..ceb2e7fcc17 100644 --- a/source/blender/freestyle/intern/stroke/Predicates1D.h +++ b/source/blender/freestyle/intern/stroke/Predicates1D.h @@ -41,7 +41,7 @@ namespace Freestyle { // /////////////////////////////////////////////////////////// -/*! Base class for Unary Predicates that work on Interface1D. +/** Base class for Unary Predicates that work on Interface1D. * A UnaryPredicate1D is a functor that evaluates a condition on a Interface1D and returns * true or false depending on whether this condition is satisfied or not. * The UnaryPredicate1D is used by calling its () operator. @@ -52,24 +52,24 @@ class UnaryPredicate1D { bool result; void *py_up1D; - /*! Default constructor. */ + /** Default constructor. */ UnaryPredicate1D() { py_up1D = NULL; } - /*! Destructor. */ + /** Destructor. */ virtual ~UnaryPredicate1D() { } - /*! Returns the string of the name of the UnaryPredicate1D. */ + /** Returns the string of the name of the UnaryPredicate1D. */ virtual string getName() const { return "UnaryPredicate1D"; } - /*! The () operator. Must be overload by inherited classes. + /** The () operator. Must be overload by inherited classes. * \param inter: * The Interface1D on which we wish to evaluate the predicate. * \return true if the condition is satisfied, false otherwise. @@ -86,7 +86,7 @@ class UnaryPredicate1D { // /////////////////////////////////////////////////////////// -/*! Base class for Binary Predicates working on Interface1D. +/** Base class for Binary Predicates working on Interface1D. * A BinaryPredicate1D is typically an ordering relation between two Interface1D. * It evaluates a relation between 2 Interface1D and returns true or false. * It is used by calling the () operator. @@ -96,24 +96,24 @@ class BinaryPredicate1D { bool result; void *py_bp1D; - /*! Default constructor. */ + /** Default constructor. */ BinaryPredicate1D() { py_bp1D = NULL; } - /*! Destructor. */ + /** Destructor. */ virtual ~BinaryPredicate1D() { } - /*! Returns the string of the name of the binary predicate. */ + /** Returns the string of the name of the binary predicate. */ virtual string getName() const { return "BinaryPredicate1D"; } - /*! The () operator. Must be overload by inherited classes. + /** The () operator. Must be overload by inherited classes. * It evaluates a relation between 2 Interface1D. * \param inter1: * The first Interface1D. @@ -136,21 +136,21 @@ class BinaryPredicate1D { namespace Predicates1D { // TrueUP1D -/*! Returns true */ +/** Returns true */ class TrueUP1D : public UnaryPredicate1D { public: - /*! Constructor */ + /** Constructor */ TrueUP1D() { } - /*! Returns the string "TrueUP1D"*/ + /** Returns the string "TrueUP1D"*/ string getName() const { return "TrueUP1D"; } - /*! the () operator */ + /** the () operator */ int operator()(Interface1D &) { result = true; @@ -159,21 +159,21 @@ class TrueUP1D : public UnaryPredicate1D { }; // FalseUP1D -/*! Returns false */ +/** Returns false */ class FalseUP1D : public UnaryPredicate1D { public: - /*! Constructor */ + /** Constructor */ FalseUP1D() { } - /*! Returns the string "FalseUP1D"*/ + /** Returns the string "FalseUP1D"*/ string getName() const { return "FalseUP1D"; } - /*! the () operator */ + /** the () operator */ int operator()(Interface1D &) { result = false; @@ -182,12 +182,12 @@ class FalseUP1D : public UnaryPredicate1D { }; // QuantitativeInvisibilityUP1D -/*! Returns true if the Quantitative Invisibility evaluated at an Interface1D, using the +/** Returns true if the Quantitative Invisibility evaluated at an Interface1D, using the * QuantitativeInvisibilityF1D functor, equals a certain user-defined value. */ class QuantitativeInvisibilityUP1D : public UnaryPredicate1D { public: - /*! Builds the Predicate. + /** Builds the Predicate. * \param qi: * The Quantitative Invisibility you want the Interface1D to have */ @@ -195,13 +195,13 @@ class QuantitativeInvisibilityUP1D : public UnaryPredicate1D { { } - /*! Returns the string "QuantitativeInvisibilityUP1D" */ + /** Returns the string "QuantitativeInvisibilityUP1D" */ string getName() const { return "QuantitativeInvisibilityUP1D"; } - /*! the () operator */ + /** the () operator */ int operator()(Interface1D &inter) { Functions1D::QuantitativeInvisibilityF1D func; @@ -217,7 +217,7 @@ class QuantitativeInvisibilityUP1D : public UnaryPredicate1D { }; // ContourUP1D -/*! Returns true if the Interface1D is a contour. +/** Returns true if the Interface1D is a contour. * An Interface1D is a contour if it is bordered by a different shape on each of its sides. */ class ContourUP1D : public UnaryPredicate1D { @@ -225,13 +225,13 @@ class ContourUP1D : public UnaryPredicate1D { Functions1D::CurveNatureF1D _getNature; public: - /*! Returns the string "ContourUP1D"*/ + /** Returns the string "ContourUP1D"*/ string getName() const { return "ContourUP1D"; } - /*! The () operator. */ + /** The () operator. */ int operator()(Interface1D &inter) { if (_getNature(inter) < 0) { @@ -252,7 +252,7 @@ class ContourUP1D : public UnaryPredicate1D { }; // ExternalContourUP1D -/*! Returns true if the Interface1D is an external contour. +/** Returns true if the Interface1D is an external contour. * An Interface1D is an external contour if it is bordered by no shape on one of its sides. */ class ExternalContourUP1D : public UnaryPredicate1D { @@ -260,13 +260,13 @@ class ExternalContourUP1D : public UnaryPredicate1D { Functions1D::CurveNatureF1D _getNature; public: - /*! Returns the string "ExternalContourUP1D" */ + /** Returns the string "ExternalContourUP1D" */ string getName() const { return "ExternalContourUP1D"; } - /*! The () operator. */ + /** The () operator. */ int operator()(Interface1D &inter) { if (_getNature(inter) < 0) { @@ -289,7 +289,7 @@ class ExternalContourUP1D : public UnaryPredicate1D { }; // EqualToTimeStampUP1D -/*! Returns true if the Interface1D's time stamp is equal to a certain user-defined value. */ +/** Returns true if the Interface1D's time stamp is equal to a certain user-defined value. */ class EqualToTimeStampUP1D : public UnaryPredicate1D { protected: unsigned _timeStamp; @@ -300,13 +300,13 @@ class EqualToTimeStampUP1D : public UnaryPredicate1D { _timeStamp = ts; } - /*! Returns the string "EqualToTimeStampUP1D"*/ + /** Returns the string "EqualToTimeStampUP1D"*/ string getName() const { return "EqualToTimeStampUP1D"; } - /*! The () operator. */ + /** The () operator. */ int operator()(Interface1D &inter) { result = (inter.getTimeStamp() == _timeStamp); @@ -315,7 +315,7 @@ class EqualToTimeStampUP1D : public UnaryPredicate1D { }; // EqualToChainingTimeStampUP1D -/*! Returns true if the Interface1D's time stamp is equal to a certain user-defined value. */ +/** Returns true if the Interface1D's time stamp is equal to a certain user-defined value. */ class EqualToChainingTimeStampUP1D : public UnaryPredicate1D { protected: unsigned _timeStamp; @@ -326,13 +326,13 @@ class EqualToChainingTimeStampUP1D : public UnaryPredicate1D { _timeStamp = ts; } - /*! Returns the string "EqualToChainingTimeStampUP1D"*/ + /** Returns the string "EqualToChainingTimeStampUP1D"*/ string getName() const { return "EqualToChainingTimeStampUP1D"; } - /*! The () operator. */ + /** The () operator. */ int operator()(Interface1D &inter) { ViewEdge *edge = dynamic_cast<ViewEdge *>(&inter); @@ -346,14 +346,14 @@ class EqualToChainingTimeStampUP1D : public UnaryPredicate1D { }; // ShapeUP1D -/*! Returns true if the shape to which the Interface1D belongs to has the same Id as the one +/** Returns true if the shape to which the Interface1D belongs to has the same Id as the one * specified by the user. */ class ShapeUP1D : public UnaryPredicate1D { private: Id _id; public: - /*! Builds the Predicate. + /** Builds the Predicate. * \param idFirst: * The first Id component. * \param idSecond: @@ -364,13 +364,13 @@ class ShapeUP1D : public UnaryPredicate1D { _id = Id(idFirst, idSecond); } - /*! Returns the string "ShapeUP1D"*/ + /** Returns the string "ShapeUP1D"*/ string getName() const { return "ShapeUP1D"; } - /*! The () operator. */ + /** The () operator. */ int operator()(Interface1D &inter) { set<ViewShape *> shapes; @@ -387,13 +387,13 @@ class ShapeUP1D : public UnaryPredicate1D { }; // WithinImageBoundaryUP1D -/*! Returns true if the Interface1D is (partly) within the image boundary. */ +/** Returns true if the Interface1D is (partly) within the image boundary. */ class WithinImageBoundaryUP1D : public UnaryPredicate1D { private: real _xmin, _ymin, _xmax, _ymax; public: - /*! Builds the Predicate. + /** Builds the Predicate. * \param xmin: * The X lower bound of the image boundary. * \param ymin: @@ -408,13 +408,13 @@ class WithinImageBoundaryUP1D : public UnaryPredicate1D { { } - /*! Returns the string "WithinImageBoundaryUP1D" */ + /** Returns the string "WithinImageBoundaryUP1D" */ string getName() const { return "WithinImageBoundaryUP1D"; } - /*! The () operator. */ + /** The () operator. */ int operator()(Interface1D &inter) { // 1st pass: check if a point is within the image boundary. @@ -454,16 +454,16 @@ class WithinImageBoundaryUP1D : public UnaryPredicate1D { /////////////////////////////////////////////////////////// // TrueBP1D -/*! Returns true. */ +/** Returns true. */ class TrueBP1D : public BinaryPredicate1D { public: - /*! Returns the string "TrueBP1D" */ + /** Returns the string "TrueBP1D" */ string getName() const { return "TrueBP1D"; } - /*! The () operator. */ + /** The () operator. */ int operator()(Interface1D & /*i1*/, Interface1D & /*i2*/) { result = true; @@ -472,16 +472,16 @@ class TrueBP1D : public BinaryPredicate1D { }; // FalseBP1D -/*! Returns false. */ +/** Returns false. */ class FalseBP1D : public BinaryPredicate1D { public: - /*! Returns the string "FalseBP1D" */ + /** Returns the string "FalseBP1D" */ string getName() const { return "FalseBP1D"; } - /*! The () operator. */ + /** The () operator. */ int operator()(Interface1D & /*i1*/, Interface1D & /*i2*/) { result = false; @@ -490,17 +490,17 @@ class FalseBP1D : public BinaryPredicate1D { }; // Length2DBP1D -/*! Returns true if the 2D length of the Interface1D i1 is less than the 2D length of the +/** Returns true if the 2D length of the Interface1D i1 is less than the 2D length of the * Interface1D i2. */ class Length2DBP1D : public BinaryPredicate1D { public: - /*! Returns the string "Length2DBP1D" */ + /** Returns the string "Length2DBP1D" */ string getName() const { return "Length2DBP1D"; } - /*! The () operator. */ + /** The () operator. */ int operator()(Interface1D &i1, Interface1D &i2) { result = (i1.getLength2D() > i2.getLength2D()); @@ -509,16 +509,16 @@ class Length2DBP1D : public BinaryPredicate1D { }; // SameShapeIdBP1D -/*! Returns true if the Interface1D i1 and i2 belong to the same shape. */ +/** Returns true if the Interface1D i1 and i2 belong to the same shape. */ class SameShapeIdBP1D : public BinaryPredicate1D { public: - /*! Returns the string "SameShapeIdBP1D" */ + /** Returns the string "SameShapeIdBP1D" */ string getName() const { return "SameShapeIdBP1D"; } - /*! The () operator. */ + /** The () operator. */ int operator()(Interface1D &i1, Interface1D &i2) { set<ViewShape *> shapes1; @@ -542,7 +542,7 @@ class SameShapeIdBP1D : public BinaryPredicate1D { }; // ViewMapGradientNormBP1D -/*! Returns true if the evaluation of the Gradient norm Function is higher for Interface1D i1 than +/** Returns true if the evaluation of the Gradient norm Function is higher for Interface1D i1 than * for i2. */ class ViewMapGradientNormBP1D : public BinaryPredicate1D { private: @@ -554,13 +554,13 @@ class ViewMapGradientNormBP1D : public BinaryPredicate1D { { } - /*! Returns the string "ViewMapGradientNormBP1D" */ + /** Returns the string "ViewMapGradientNormBP1D" */ string getName() const { return "ViewMapGradientNormBP1D"; } - /*! The () operator. */ + /** The () operator. */ int operator()(Interface1D &i1, Interface1D &i2) { if (_func(i1) < 0) { diff --git a/source/blender/freestyle/intern/stroke/Stroke.h b/source/blender/freestyle/intern/stroke/Stroke.h index 4a9ed7288c5..96a4d2d61ea 100644 --- a/source/blender/freestyle/intern/stroke/Stroke.h +++ b/source/blender/freestyle/intern/stroke/Stroke.h @@ -52,18 +52,18 @@ namespace Freestyle { // //////////////////////////////////////////////////////// -/*! Class to define an attribute associated to a Stroke Vertex. +/** 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 */ + /** default constructor */ StrokeAttribute(); - /*! Copy constructor */ + /** Copy constructor */ StrokeAttribute(const StrokeAttribute &iBrother); - /*! Builds a stroke vertex attribute from a set of parameters. + /** Builds a stroke vertex attribute from a set of parameters. * \param iRColor: * The Red Component value. * \param iGColor: @@ -84,7 +84,7 @@ class StrokeAttribute { float iRThickness, float iLThickness); - /*! Interpolation constructor. + /** Interpolation constructor. * Builds a StrokeAttribute from two StrokeAttributes and an interpolation parameter. * \param a1: * The first Attribute. @@ -95,15 +95,15 @@ class StrokeAttribute { */ StrokeAttribute(const StrokeAttribute &a1, const StrokeAttribute &a2, float t); - /*! destructor */ + /** destructor */ virtual ~StrokeAttribute(); /* operators */ - /*! operator = */ + /** operator = */ StrokeAttribute &operator=(const StrokeAttribute &iBrother); /* accessors */ - /*! Returns the attribute's color. + /** 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 @@ -111,37 +111,37 @@ class StrokeAttribute { return _color; } - /*! Returns the R color component. */ + /** Returns the R color component. */ inline const float getColorR() const { return _color[0]; } - /*! Returns the G color component. */ + /** Returns the G color component. */ inline const float getColorG() const { return _color[1]; } - /*! Returns the B color component. */ + /** Returns the B color component. */ inline const float getColorB() const { return _color[2]; } - /*! Returns the RGB color components. */ + /** Returns the RGB color components. */ inline Vec3f getColorRGB() const { return Vec3f(_color[0], _color[1], _color[2]); } - /*! Returns the alpha color component. */ + /** Returns the alpha color component. */ inline float getAlpha() const { return _alpha; } - /*! Returns the attribute's thickness. + /** 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. */ @@ -150,60 +150,60 @@ class StrokeAttribute { return _thickness; } - /*! Returns the thickness on the right of the vertex when following the stroke. */ + /** 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. */ + /** 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. + /** 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 */ + /** Returns true if the strokevertex is visible, false otherwise */ inline bool isVisible() const { return _visible; } - /*! Returns an attribute of type real + /** 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 + /** 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 + /** 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 available */ + /** Checks whether the attribute iName is available */ bool isAttributeAvailableReal(const char *iName) const; - /*! Checks whether the attribute iName is available */ + /** Checks whether the attribute iName is available */ bool isAttributeAvailableVec2f(const char *iName) const; - /*! Checks whether the attribute iName is available */ + /** Checks whether the attribute iName is available */ bool isAttributeAvailableVec3f(const char *iName) const; /* modifiers */ - /*! sets the attribute's color. + /** sets the attribute's color. * \param r: * The new R value. * \param g: @@ -218,7 +218,7 @@ class StrokeAttribute { _color[2] = b; } - /*! sets the attribute's color. + /** sets the attribute's color. * \param iRGB: * The new RGB values. */ @@ -229,7 +229,7 @@ class StrokeAttribute { _color[2] = iRGB[2]; } - /*! sets the attribute's alpha value. + /** sets the attribute's alpha value. * \param alpha: * The new alpha value. */ @@ -238,7 +238,7 @@ class StrokeAttribute { _alpha = alpha; } - /*! sets the attribute's thickness. + /** sets the attribute's thickness. * \param tr: * The thickness on the right of the vertex when following the stroke. * \param tl: @@ -250,7 +250,7 @@ class StrokeAttribute { _thickness[1] = tl; } - /*! sets the attribute's thickness. + /** sets the attribute's thickness. * \param tRL: * The thickness on the right and on the left of the vertex when following the stroke. */ @@ -260,13 +260,13 @@ class StrokeAttribute { _thickness[1] = tRL[1]; } - /*! sets the visible flag. True means visible. */ + /** sets the visible flag. True means visible. */ inline void setVisible(bool iVisible) { _visible = iVisible; } - /*! Adds a user defined attribute of type real + /** 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: @@ -276,7 +276,7 @@ class StrokeAttribute { */ void setAttributeReal(const char *iName, float att); - /*! Adds a user defined attribute of type Vec2f + /** 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: @@ -286,7 +286,7 @@ class StrokeAttribute { */ void setAttributeVec2f(const char *iName, const Vec2f &att); - /*! Adds a user defined attribute of type Vec3f + /** 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: @@ -322,10 +322,10 @@ class StrokeAttribute { // //////////////////////////////////////////////////////// -/*! Class to define a stroke vertex. */ +/** Class to define a stroke vertex. */ class StrokeVertex : public CurvePoint { public: // Implementation of Interface0D - /*! Returns the string "StrokeVertex" */ + /** Returns the string "StrokeVertex" */ virtual string getExactTypeName() const { return "StrokeVertex"; @@ -337,129 +337,129 @@ class StrokeVertex : public CurvePoint { float _StrokeLength; // stroke length public: - /*! default constructor */ + /** default constructor */ StrokeVertex(); - /*! Copy constructor */ + /** Copy constructor */ StrokeVertex(const StrokeVertex &iBrother); - /*! Builds a stroke vertex from a SVertex */ + /** Builds a stroke vertex from a SVertex */ StrokeVertex(SVertex *iSVertex); - /*! Builds a stroke vertex from a CurvePoint */ + /** Builds a stroke vertex from a CurvePoint */ StrokeVertex(CurvePoint *iPoint); - /*! Builds Stroke Vertex from 2 stroke vertices and an interpolation parameter*/ + /** 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 */ + /** Builds a stroke from a view vertex and an attribute */ StrokeVertex(SVertex *iSVertex, const StrokeAttribute &iAttribute); /* operators */ - /*! operator = */ + /** operator = */ StrokeVertex &operator=(const StrokeVertex &iBrother); /* accessors */ - /*! Returns the 2D point x coordinate */ + /** Returns the 2D point x coordinate */ inline real x() const { return _Point2d[0]; } - /*! Returns the 2D point y coordinate */ + /** Returns the 2D point y coordinate */ inline real y() const { return _Point2d[1]; } - /*! Returns the 2D point coordinates as a Vec2r */ + /** Returns the 2D point coordinates as a Vec2r */ inline Vec2r getPoint() const { return getPoint2D(); } - /*! Returns the ith 2D point coordinate (i=0 or 1)*/ + /** 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 */ + /** Returns the StrokeAttribute for this StrokeVertex */ inline const StrokeAttribute &attribute() const { return _Attribute; } - /*! Returns a non-const reference to the StrokeAttribute of this StrokeVertex */ + /** Returns a non-const reference to the StrokeAttribute of this StrokeVertex */ inline StrokeAttribute &attribute() { return _Attribute; } - /*! Returns the curvilinear abscissa */ + /** Returns the curvilinear abscissa */ inline float curvilinearAbscissa() const { return _CurvilignAbscissa; } - /*! Returns the length of the Stroke to which this StrokeVertex belongs */ + /** 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 */ + /** Returns the curvilinear abscissa of this StrokeVertex in the Stroke */ inline float u() const { return _CurvilignAbscissa / _StrokeLength; } /* modifiers */ - /*! sets the 2D x value */ + /** sets the 2D x value */ inline void setX(real x) { _Point2d[0] = x; } - /*! sets the 2D y value */ + /** sets the 2D y value */ inline void setY(real y) { _Point2d[1] = y; } - /*! sets the 2D x and y values */ + /** 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 */ + /** 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) */ + /** 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. */ + /** sets the attribute. */ inline void setAttribute(const StrokeAttribute &iAttribute) { _Attribute = iAttribute; } - /*! sets the curvilinear abscissa of this StrokeVertex in the Stroke */ + /** 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 + /** 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) @@ -492,7 +492,7 @@ class StrokeVertexIterator; } // end of namespace StrokeInternal -/*! Class to define a stroke. +/** 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 @@ -500,7 +500,7 @@ class StrokeVertexIterator; */ class Stroke : public Interface1D { public: // Implementation of Interface1D - /*! Returns the string "Stroke" */ + /** Returns the string "Stroke" */ virtual string getExactTypeName() const { return "Stroke"; @@ -508,17 +508,17 @@ class Stroke : public Interface1D { // Data access methods - /*! Returns the Id of the Stroke */ + /** Returns the Id of the Stroke */ virtual Id getId() const { return _id; } - /*! The different blending modes available to similate the interaction media-medium. */ + /** 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 subtraction blending).*/ - OPAQUE_MEDIUM, /*!< To simulate an opaque medium (oil, spray...).*/ + DRY_MEDIUM, /**< To simulate a dry medium such as Pencil or Charcoal.*/ + HUMID_MEDIUM, /**< To simulate ink painting (color subtraction blending).*/ + OPAQUE_MEDIUM, /**< To simulate an opaque medium (oil, spray...).*/ } MediumType; public: @@ -549,13 +549,13 @@ class Stroke : public Interface1D { Vec2r _extremityOrientations[2]; // the orientations of the first and last extermity public: - /*! default constructor */ + /** default constructor */ Stroke(); - /*! copy constructor */ + /** copy constructor */ Stroke(const Stroke &iBrother); - /*! Builds a stroke from a set of StrokeVertex. + /** 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: @@ -565,14 +565,14 @@ class Stroke : public Interface1D { */ template<class InputVertexIterator> Stroke(InputVertexIterator iBegin, InputVertexIterator iEnd); - /*! Destructor */ + /** Destructor */ virtual ~Stroke(); /* operators */ - /*! operator = */ + /** operator = */ Stroke &operator=(const Stroke &iBrother); - /*! Compute the sampling needed to get iNVertices vertices. + /** 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: @@ -583,7 +583,7 @@ class Stroke : public Interface1D { */ float ComputeSampling(int iNVertices); - /*! Resampling method. + /** 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. @@ -592,7 +592,7 @@ class Stroke : public Interface1D { */ int Resample(int iNPoints); - /*! Resampling method. + /** Resampling method. * Resamples the curve with a given sampling. * If this sampling is < to the actual sampling value, no resampling is done. * \param iSampling: @@ -600,18 +600,18 @@ class Stroke : public Interface1D { */ int Resample(float iSampling); - /*! Removes all vertices from the Stroke. + /** Removes all vertices from the Stroke. */ void RemoveAllVertices(); - /*! Removes the stroke vertex iVertex + /** 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. + /** 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. @@ -620,7 +620,7 @@ class Stroke : public Interface1D { */ void InsertVertex(StrokeVertex *iVertex, StrokeInternal::StrokeVertexIterator next); - /*! Updates the 2D length of the Stroke */ + /** Updates the 2D length of the Stroke */ void UpdateLength(); /* Render method */ @@ -631,50 +631,50 @@ class Stroke : public Interface1D { /* Iterator definition */ /* accessors */ - /*! Returns the 2D length of the Stroke */ + /** 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. */ + /** 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 */ + /** 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 length */ + /** Returns the spacing of texture coordinates along the stroke length */ inline float getTextureStep() { return _textureStep; } - /*! Returns the texture used at given index to simulate the marks system for this Stroke */ + /** 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. */ + /** Return the shader node tree to define textures. */ inline bNodeTree *getNodeTree() { return _nodeTree; } - /*! Returns true if this Stroke has textures assigned, false otherwise. */ + /** 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. */ + /** Returns true if this Stroke uses a texture with tips, false otherwise. */ inline bool hasTips() const { return _tips; @@ -742,34 +742,34 @@ class Stroke : public Interface1D { } /* modifiers */ - /*! sets the Id of the Stroke. */ + /** sets the Id of the Stroke. */ inline void setId(const Id &id) { _id = id; } - /*! sets the 2D length of the Stroke. */ + /** sets the 2D length of the Stroke. */ void setLength(float iLength); - /*! sets the medium type that must be used for this Stroke. */ + /** 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. */ + /** 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 length. */ + /** sets the spacing of texture coordinates along the stroke length. */ inline void setTextureStep(float step) { _textureStep = step; } - /*! assigns a blender texture to the first available slot. */ + /** assigns a blender texture to the first available slot. */ inline int setMTex(MTex *mtex) { for (int a = 0; a < MAX_MTEX; a++) { @@ -781,13 +781,13 @@ class Stroke : public Interface1D { return -1; /* no free slots */ } - /*! assigns a node tree (of new shading nodes) to define textures. */ + /** 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. */ + /** sets the flag telling whether this stroke is using a texture with tips or not. */ inline void setTips(bool iTips) { _tips = iTips; @@ -836,7 +836,7 @@ class Stroke : public Interface1D { const_vertex_iterator vertices_end() const; vertex_iterator vertices_end(); - /*! Returns a StrokeVertexIterator pointing on the first StrokeVertex of the Stroke. One can + /** Returns a StrokeVertexIterator pointing on the first StrokeVertex of the Stroke. One can * specify a sampling value to re-sample the Stroke on the fly if needed. * * \param t: The resampling value with which we want our Stroke to be resampled. @@ -844,26 +844,26 @@ class Stroke : public Interface1D { */ StrokeInternal::StrokeVertexIterator strokeVerticesBegin(float t = 0.0f); - /*! Returns a StrokeVertexIterator pointing after the last StrokeVertex of the Stroke. */ + /** Returns a StrokeVertexIterator pointing after the last StrokeVertex of the Stroke. */ StrokeInternal::StrokeVertexIterator strokeVerticesEnd(); - /*! Returns the number of StrokeVertex constituting the Stroke. */ + /** Returns the number of StrokeVertex constituting the Stroke. */ inline unsigned int strokeVerticesSize() const { return _Vertices.size(); } - /*! Returns the i-th StrokeVertex constituting the Stroke. */ + /** 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. */ + /** 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. */ + /** Returns an Interface0DIterator pointing after the last StrokeVertex of the Stroke. */ virtual Interface0DIterator verticesEnd(); virtual Interface0DIterator pointsBegin(float t = 0.0f); diff --git a/source/blender/freestyle/intern/stroke/StrokeAdvancedIterators.h b/source/blender/freestyle/intern/stroke/StrokeAdvancedIterators.h index 4256cdebe86..0fbf94f609e 100644 --- a/source/blender/freestyle/intern/stroke/StrokeAdvancedIterators.h +++ b/source/blender/freestyle/intern/stroke/StrokeAdvancedIterators.h @@ -158,7 +158,7 @@ class vertex_iterator_base : public IteratorBase<Traits, BidirectionalIteratorTa return &(operator*()); } - /*! accessors */ + /** accessors */ inline vertex_container_iterator it() const { return _it; diff --git a/source/blender/freestyle/intern/stroke/StrokeIterators.h b/source/blender/freestyle/intern/stroke/StrokeIterators.h index d4cbffd535e..20c29b21c22 100644 --- a/source/blender/freestyle/intern/stroke/StrokeIterators.h +++ b/source/blender/freestyle/intern/stroke/StrokeIterators.h @@ -32,7 +32,7 @@ namespace StrokeInternal { // ///////////////////////////////////////////////// -/*! Class defining an iterator designed to iterate over the StrokeVertex of a Stroke. +/** Class defining an iterator designed to iterate over the StrokeVertex of a Stroke. * An instance of a StrokeVertexIterator can only be obtained from a Stroke by calling * strokeVerticesBegin() or strokeVerticesEnd(). It is iterating over the same vertices as an * Interface0DIterator. The difference resides in the object access. Indeed, an Interface0DIterator @@ -46,12 +46,12 @@ namespace StrokeInternal { */ class StrokeVertexIterator : public Interface0DIteratorNested { public: - /*! Default constructor. */ + /** Default constructor. */ StrokeVertexIterator() { } - /*! Copy constructor. */ + /** Copy constructor. */ StrokeVertexIterator(const StrokeVertexIterator &vi) { _it = vi._it; @@ -72,7 +72,7 @@ class StrokeVertexIterator : public Interface0DIteratorNested { { } - /*! Casts this StrokeVertexIterator into an Interface0DIterator. + /** Casts this StrokeVertexIterator into an Interface0DIterator. * Useful for any call to a function of the type UnaryFunction0D. */ inline Interface0DIterator castToInterface0DIterator() const @@ -81,7 +81,7 @@ class StrokeVertexIterator : public Interface0DIteratorNested { return ret; } - /*! operator= + /** operator= * \attention In the scripting language, you must call \code it2 = StrokeVertexIterator(it1) * \endcode instead of \code it2 = it1 \endcode where \a it1 and \a it2 are 2 * StrokeVertexIterator. Otherwise, incrementing \a it1 will also increment \a it2. @@ -94,13 +94,13 @@ class StrokeVertexIterator : public Interface0DIteratorNested { return *this; } - /*! Returns the string "StrokeVertexIterator". */ + /** Returns the string "StrokeVertexIterator". */ virtual string getExactTypeName() const { return "StrokeVertexIterator"; } - /*! Returns a reference to the pointed StrokeVertex. + /** Returns a reference to the pointed StrokeVertex. * In the scripting language, you must call "getObject()"instead. */ virtual StrokeVertex &operator*() @@ -108,7 +108,7 @@ class StrokeVertexIterator : public Interface0DIteratorNested { return **_it; } - /*! Returns a pointer to the pointed StrokeVertex. + /** Returns a pointer to the pointed StrokeVertex. * Can't be called in the scripting language. */ virtual StrokeVertex *operator->() @@ -116,14 +116,14 @@ class StrokeVertexIterator : public Interface0DIteratorNested { return &(operator*()); } - /*! Increments. In the scripting language, call "increment()". */ + /** Increments. In the scripting language, call "increment()". */ virtual StrokeVertexIterator &operator++() { increment(); return *this; } - /*! Increments. In the scripting language, call "increment()". */ + /** Increments. In the scripting language, call "increment()". */ virtual StrokeVertexIterator operator++(int) { StrokeVertexIterator ret(*this); @@ -131,14 +131,14 @@ class StrokeVertexIterator : public Interface0DIteratorNested { return ret; } - /*! Decrements. In the scripting language, call "decrement()". */ + /** Decrements. In the scripting language, call "decrement()". */ virtual StrokeVertexIterator &operator--() { decrement(); return *this; } - /*! Decrements. In the scripting language, call "decrement()". */ + /** Decrements. In the scripting language, call "decrement()". */ virtual StrokeVertexIterator operator--(int) { StrokeVertexIterator ret(*this); @@ -146,27 +146,27 @@ class StrokeVertexIterator : public Interface0DIteratorNested { return ret; } - /*! Increments. */ + /** Increments. */ virtual int increment() { ++_it; return 0; } - /*! Decrements. */ + /** Decrements. */ virtual int decrement() { --_it; return 0; } - /*! Returns true if the pointed StrokeVertex is the first of the Stroke. */ + /** Returns true if the pointed StrokeVertex is the first of the Stroke. */ bool isBegin() const { return _it == _begin; } - /*! Returns true if the pointed StrokeVertex is the final valid StrokeVertex of the Stroke. */ + /** Returns true if the pointed StrokeVertex is the final valid StrokeVertex of the Stroke. */ bool atLast() { if (_it == _end) { @@ -179,13 +179,13 @@ class StrokeVertexIterator : public Interface0DIteratorNested { return result; } - /*! Returns true if the pointed StrokeVertex is after the last StrokeVertex of the Stroke. */ + /** Returns true if the pointed StrokeVertex is after the last StrokeVertex of the Stroke. */ bool isEnd() const { return _it == _end; } - /*! operator == */ + /** operator == */ virtual bool operator==(const Interface0DIteratorNested &it) const { const StrokeVertexIterator *it_exact = dynamic_cast<const StrokeVertexIterator *>(&it); @@ -195,19 +195,19 @@ class StrokeVertexIterator : public Interface0DIteratorNested { return (_it == it_exact->_it); } - /*! Returns the curvilinear abscissa of the current point */ + /** Returns the curvilinear abscissa of the current point */ virtual float t() const { return (*_it)->curvilinearAbscissa(); } - /*! Returns the point's parameter in the stroke */ + /** Returns the point's parameter in the stroke */ virtual float u() const { return (*_it)->u(); } - /*! Cloning method */ + /** Cloning method */ virtual StrokeVertexIterator *copy() const { return new StrokeVertexIterator(*this); diff --git a/source/blender/freestyle/intern/stroke/StrokeLayer.h b/source/blender/freestyle/intern/stroke/StrokeLayer.h index 2101e7732ce..3bcd675d295 100644 --- a/source/blender/freestyle/intern/stroke/StrokeLayer.h +++ b/source/blender/freestyle/intern/stroke/StrokeLayer.h @@ -55,15 +55,15 @@ class StrokeLayer { virtual ~StrokeLayer(); - /*! Render method */ + /** Render method */ void ScaleThickness(float iFactor); void Render(const StrokeRenderer *iRenderer); void RenderBasic(const StrokeRenderer *iRenderer); - /*! clears the layer */ + /** clears the layer */ void clear(); - /*! accessors */ + /** accessors */ inline stroke_container::iterator strokes_begin() { return _strokes.begin(); @@ -84,7 +84,7 @@ class StrokeLayer { return _strokes.empty(); } - /*! modifiers */ + /** modifiers */ inline void setStrokes(stroke_container &iStrokes) { _strokes = iStrokes; diff --git a/source/blender/freestyle/intern/stroke/StrokeRenderer.h b/source/blender/freestyle/intern/stroke/StrokeRenderer.h index d3ed8bde8a3..61b530b9643 100644 --- a/source/blender/freestyle/intern/stroke/StrokeRenderer.h +++ b/source/blender/freestyle/intern/stroke/StrokeRenderer.h @@ -46,7 +46,7 @@ namespace Freestyle { /* */ /**********************************/ -/*! Class to load textures */ +/** Class to load textures */ class TextureManager { public: TextureManager(); @@ -117,13 +117,13 @@ class TextureManager { /* */ /**********************************/ -/*! Class to render a stroke. Creates a triangle strip and stores it strip is lazily created at the +/** Class to render a stroke. Creates a triangle strip and stores it strip is lazily created at the * first rendering */ class StrokeRenderer { public: virtual ~StrokeRenderer(); - /*! Renders a stroke rep */ + /** Renders a stroke rep */ virtual void RenderStrokeRep(StrokeRep *iStrokeRep) const = 0; virtual void RenderStrokeRepBasic(StrokeRep *iStrokeRep) const = 0; diff --git a/source/blender/freestyle/intern/stroke/StrokeRep.h b/source/blender/freestyle/intern/stroke/StrokeRep.h index 09048b8e147..cc889aac364 100644 --- a/source/blender/freestyle/intern/stroke/StrokeRep.h +++ b/source/blender/freestyle/intern/stroke/StrokeRep.h @@ -197,13 +197,13 @@ class StrokeRep { StrokeRep(Stroke *iStroke); virtual ~StrokeRep(); - /*! Creates the strips */ + /** Creates the strips */ virtual void create(); - /*! Renders the stroke using a Renderer */ + /** Renders the stroke using a Renderer */ virtual void Render(const StrokeRenderer *iRenderer); - /*! accessors */ + /** accessors */ inline Stroke::MediumType getMediumType() const { return _strokeType; @@ -249,7 +249,7 @@ class StrokeRep { return _stroke; } - /*! modifiers */ + /** modifiers */ inline void setMediumType(Stroke::MediumType itype) { _strokeType = itype; diff --git a/source/blender/freestyle/intern/stroke/StrokeShader.h b/source/blender/freestyle/intern/stroke/StrokeShader.h index f4984136747..e4a8412d52a 100644 --- a/source/blender/freestyle/intern/stroke/StrokeShader.h +++ b/source/blender/freestyle/intern/stroke/StrokeShader.h @@ -39,7 +39,7 @@ namespace Freestyle { class Stroke; -/*! Base class for Stroke Shaders. +/** Base class for Stroke Shaders. * Any Stroke Shader must inherit from this class and overload the shade() method. * A StrokeShader is designed to modify any Stroke's attribute such as Thickness, Color, * Geometry, Texture, Blending mode... @@ -65,24 +65,24 @@ class StrokeShader { public: void *py_ss; - /*! Default constructor. */ + /** Default constructor. */ StrokeShader() { py_ss = 0; } - /*! Destructor. */ + /** Destructor. */ virtual ~StrokeShader() { } - /*! Returns the string corresponding to the shader's name. */ + /** Returns the string corresponding to the shader's name. */ virtual string getName() const { return "StrokeShader"; } - /*! The shading method. This method must be overloaded by inherited classes. + /** The shading method. This method must be overloaded by inherited classes. * \param ioStroke: * The stroke we wish to shade. this Stroke is modified by the Shader (which typically * modifies the Stroke's attribute's values such as Color, Thickness, Geometry...) diff --git a/source/blender/freestyle/intern/stroke/StrokeTesselator.h b/source/blender/freestyle/intern/stroke/StrokeTesselator.h index 0c1efb873bc..b03db823d18 100644 --- a/source/blender/freestyle/intern/stroke/StrokeTesselator.h +++ b/source/blender/freestyle/intern/stroke/StrokeTesselator.h @@ -43,10 +43,10 @@ class StrokeTesselator { { } - /*! Builds a line rep contained from a Stroke */ + /** Builds a line rep contained from a Stroke */ LineRep *Tesselate(Stroke *iStroke); - /*! Builds a set of lines rep contained under a a NodeShape, itself contained under a NodeGroup + /** Builds a set of lines rep contained under a a NodeShape, itself contained under a NodeGroup * from a set of strokes. */ template<class StrokeIterator> NodeGroup *Tesselate(StrokeIterator begin, StrokeIterator end); diff --git a/source/blender/freestyle/intern/stroke/TextStrokeRenderer.h b/source/blender/freestyle/intern/stroke/TextStrokeRenderer.h index bbc3b5058a3..09c597791a2 100644 --- a/source/blender/freestyle/intern/stroke/TextStrokeRenderer.h +++ b/source/blender/freestyle/intern/stroke/TextStrokeRenderer.h @@ -54,7 +54,7 @@ class TextStrokeRenderer : public StrokeRenderer { public: TextStrokeRenderer(const char *iFileName = NULL); - /*! Renders a stroke rep */ + /** Renders a stroke rep */ virtual void RenderStrokeRep(StrokeRep *iStrokeRep) const; virtual void RenderStrokeRepBasic(StrokeRep *iStrokeRep) const; |