665 lines
15 KiB
C++
665 lines
15 KiB
C++
/*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#ifndef __FREESTYLE_BASIC_STROKE_SHADERS_H__
|
|
#define __FREESTYLE_BASIC_STROKE_SHADERS_H__
|
|
|
|
/** \file
|
|
* \ingroup freestyle
|
|
* \brief Class gathering basic stroke shaders
|
|
*/
|
|
|
|
#include <fstream>
|
|
|
|
#include "Stroke.h"
|
|
#include "StrokeShader.h"
|
|
|
|
#include "../geometry/Bezier.h"
|
|
#include "../geometry/Geom.h"
|
|
|
|
extern "C" {
|
|
struct MTex;
|
|
struct bNodeTree;
|
|
}
|
|
|
|
using namespace std;
|
|
|
|
namespace Freestyle {
|
|
|
|
using namespace Geometry;
|
|
|
|
namespace StrokeShaders {
|
|
|
|
//
|
|
// Thickness modifiers
|
|
//
|
|
//////////////////////////////////////////////////////
|
|
|
|
/*! [ Thickness Shader ].
|
|
* Assigns an absolute constant thickness to every vertices of the Stroke.
|
|
*/
|
|
class ConstantThicknessShader : public StrokeShader {
|
|
public:
|
|
/*! Builds the shader.
|
|
* \param thickness:
|
|
* The thickness that must be assigned to the stroke.
|
|
*/
|
|
ConstantThicknessShader(float thickness) : StrokeShader()
|
|
{
|
|
_thickness = thickness;
|
|
}
|
|
|
|
/*! Destructor. */
|
|
virtual ~ConstantThicknessShader()
|
|
{
|
|
}
|
|
|
|
/*! Returns the string "ConstantThicknessShader".*/
|
|
virtual string getName() const
|
|
{
|
|
return "ConstantThicknessShader";
|
|
}
|
|
|
|
/*! The shading method. */
|
|
virtual int shade(Stroke &stroke) const;
|
|
|
|
private:
|
|
float _thickness;
|
|
};
|
|
|
|
/* [ Thickness Shader ].
|
|
* Assigns an absolute constant external thickness to every vertices of the Stroke. The external
|
|
* thickness of a point is its thickness from the point to the strip border in the direction
|
|
* pointing outside the object the Stroke delimitates.
|
|
*/
|
|
class ConstantExternThicknessShader : public StrokeShader {
|
|
public:
|
|
ConstantExternThicknessShader(float thickness) : StrokeShader()
|
|
{
|
|
_thickness = thickness;
|
|
}
|
|
|
|
virtual ~ConstantExternThicknessShader()
|
|
{
|
|
}
|
|
|
|
virtual string getName() const
|
|
{
|
|
return "ConstantExternThicknessShader";
|
|
}
|
|
|
|
virtual int shade(Stroke &stroke) const;
|
|
|
|
private:
|
|
float _thickness;
|
|
};
|
|
|
|
/*! [ 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
|
|
* A to B.
|
|
*/
|
|
class IncreasingThicknessShader : public StrokeShader {
|
|
public:
|
|
/*! Builds the shader.
|
|
* \param iThicknessMin:
|
|
* The first thickness value.
|
|
* \param iThicknessMax:
|
|
* The second thickness value.
|
|
*/
|
|
IncreasingThicknessShader(float iThicknessMin, float iThicknessMax) : StrokeShader()
|
|
{
|
|
_ThicknessMin = iThicknessMin;
|
|
_ThicknessMax = iThicknessMax;
|
|
}
|
|
|
|
/*! Destructor.*/
|
|
virtual ~IncreasingThicknessShader()
|
|
{
|
|
}
|
|
|
|
virtual string getName() const
|
|
{
|
|
return "IncreasingThicknessShader";
|
|
}
|
|
|
|
/*! The shading method. */
|
|
virtual int shade(Stroke &stroke) const;
|
|
|
|
private:
|
|
float _ThicknessMin;
|
|
float _ThicknessMax;
|
|
};
|
|
|
|
/*! [ 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
|
|
*/
|
|
class ConstrainedIncreasingThicknessShader : public StrokeShader {
|
|
private:
|
|
float _ThicknessMin;
|
|
float _ThicknessMax;
|
|
float _ratio;
|
|
|
|
public:
|
|
/*! Builds the shader.
|
|
* \param iThicknessMin:
|
|
* The first thickness value.
|
|
* \param iThicknessMax:
|
|
* The second thickness value.
|
|
* \param iRatio:
|
|
* The ration thickness/length we don't want to exceed.
|
|
*/
|
|
ConstrainedIncreasingThicknessShader(float iThicknessMin, float iThicknessMax, float iRatio)
|
|
: StrokeShader()
|
|
{
|
|
_ThicknessMin = iThicknessMin;
|
|
_ThicknessMax = iThicknessMax;
|
|
_ratio = iRatio;
|
|
}
|
|
|
|
/*! Destructor.*/
|
|
virtual ~ConstrainedIncreasingThicknessShader()
|
|
{
|
|
}
|
|
|
|
virtual string getName() const
|
|
{
|
|
return "ConstrainedIncreasingThicknessShader";
|
|
}
|
|
|
|
/*! The shading method. */
|
|
virtual int shade(Stroke &stroke) const;
|
|
};
|
|
|
|
/* [ Thickness Shader ].
|
|
* Modifies the thickness in a relative way depending on its length.
|
|
*/
|
|
class LengthDependingThicknessShader : public StrokeShader {
|
|
private:
|
|
float _minThickness;
|
|
float _maxThickness;
|
|
// We divide the strokes in 4 categories:
|
|
// l > 300
|
|
// 100 < l < 300
|
|
// 50 < l < 100
|
|
// l < 50
|
|
|
|
public:
|
|
LengthDependingThicknessShader(float iMinThickness, float iMaxThickness) : StrokeShader()
|
|
{
|
|
_minThickness = iMinThickness;
|
|
_maxThickness = iMaxThickness;
|
|
}
|
|
|
|
virtual ~LengthDependingThicknessShader()
|
|
{
|
|
}
|
|
|
|
virtual string getName() const
|
|
{
|
|
return "LengthDependingThicknessShader";
|
|
}
|
|
|
|
virtual int shade(Stroke &stroke) const;
|
|
};
|
|
|
|
/*! [ Thickness Shader ].
|
|
* Adds some noise to the stroke thickness.
|
|
* \see \htmlonly <a href=noise/noise.html>noise/noise.html</a>\endhtmlonly
|
|
*/
|
|
class ThicknessNoiseShader : public StrokeShader {
|
|
private:
|
|
float _amplitude;
|
|
float _scale;
|
|
|
|
public:
|
|
ThicknessNoiseShader();
|
|
|
|
/*! Builds a Thickness Noise Shader
|
|
* \param iAmplitude:
|
|
* The amplitude of the noise signal
|
|
* \param iPeriod:
|
|
* The period of the noise signal
|
|
*/
|
|
ThicknessNoiseShader(float iAmplitude, float iPeriod);
|
|
|
|
virtual string getName() const
|
|
{
|
|
return "ThicknessNoiseShader";
|
|
}
|
|
|
|
/*! The shading method. */
|
|
virtual int shade(Stroke &stroke) const;
|
|
};
|
|
|
|
//
|
|
// Color shaders
|
|
//
|
|
/////////////////////////////////////////////////////////
|
|
/*! [ 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.
|
|
* \param iR:
|
|
* The red component
|
|
* \param iG:
|
|
* The green component
|
|
* \param iB:
|
|
* The blue component
|
|
* \param iAlpha:
|
|
* The alpha value
|
|
*/
|
|
ConstantColorShader(float iR, float iG, float iB, float iAlpha = 1.0f) : StrokeShader()
|
|
{
|
|
_color[0] = iR;
|
|
_color[1] = iG;
|
|
_color[2] = iB;
|
|
_color[3] = iAlpha;
|
|
}
|
|
|
|
virtual string getName() const
|
|
{
|
|
return "ConstantColorShader";
|
|
}
|
|
|
|
/*! The shading method. */
|
|
virtual int shade(Stroke &stroke) const;
|
|
|
|
private:
|
|
float _color[4];
|
|
};
|
|
|
|
/*! [ 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.
|
|
*/
|
|
class IncreasingColorShader : public StrokeShader {
|
|
private:
|
|
float _colorMin[4];
|
|
float _colorMax[4];
|
|
|
|
public:
|
|
/*! Builds the shader from 2 user-specified colors.
|
|
* \param iRm:
|
|
* The first color red component
|
|
* \param iGm:
|
|
* The first color green component
|
|
* \param iBm:
|
|
* The first color blue component
|
|
* \param iAlpham:
|
|
* The first color alpha value
|
|
* \param iRM:
|
|
* The second color red component
|
|
* \param iGM:
|
|
* The second color green component
|
|
* \param iBM:
|
|
* The second color blue component
|
|
* \param iAlphaM:
|
|
* The second color alpha value
|
|
*/
|
|
IncreasingColorShader(float iRm,
|
|
float iGm,
|
|
float iBm,
|
|
float iAlpham,
|
|
float iRM,
|
|
float iGM,
|
|
float iBM,
|
|
float iAlphaM)
|
|
: StrokeShader()
|
|
{
|
|
_colorMin[0] = iRm;
|
|
_colorMin[1] = iGm;
|
|
_colorMin[2] = iBm;
|
|
_colorMin[3] = iAlpham;
|
|
|
|
_colorMax[0] = iRM;
|
|
_colorMax[1] = iGM;
|
|
_colorMax[2] = iBM;
|
|
_colorMax[3] = iAlphaM;
|
|
}
|
|
|
|
virtual string getName() const
|
|
{
|
|
return "IncreasingColorShader";
|
|
}
|
|
|
|
/*! The shading method. */
|
|
virtual int shade(Stroke &stroke) const;
|
|
};
|
|
|
|
/* [ Color Shader ].
|
|
* Assigns a color to the stroke depending on the material of the shape to which ot belongs to.
|
|
* (Disney shader)
|
|
*/
|
|
class MaterialColorShader : public StrokeShader {
|
|
private:
|
|
float _coefficient;
|
|
|
|
public:
|
|
MaterialColorShader(float coeff = 1.0f) : StrokeShader()
|
|
{
|
|
_coefficient = coeff;
|
|
}
|
|
|
|
virtual string getName() const
|
|
{
|
|
return "MaterialColorShader";
|
|
}
|
|
|
|
virtual int shade(Stroke &stroke) const;
|
|
};
|
|
|
|
/*! [ Color Shader ].
|
|
* Shader to add noise to the stroke colors.
|
|
*/
|
|
class ColorNoiseShader : public StrokeShader {
|
|
private:
|
|
float _amplitude;
|
|
float _scale;
|
|
|
|
public:
|
|
ColorNoiseShader();
|
|
|
|
/*! Builds a Color Noise Shader
|
|
* \param iAmplitude:
|
|
* The amplitude of the noise signal
|
|
* \param iPeriod:
|
|
* The period of the noise signal
|
|
*/
|
|
ColorNoiseShader(float iAmplitude, float iPeriod);
|
|
|
|
virtual string getName() const
|
|
{
|
|
return "ColorNoiseShader";
|
|
}
|
|
|
|
/*! The shading method. */
|
|
virtual int shade(Stroke &stroke) const;
|
|
};
|
|
|
|
//
|
|
// Geometry Shaders
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
/*! [ Geometry Shader ].
|
|
* Stretches the stroke at its two extremities and following the respective directions: v(1)v(0)
|
|
* and v(n-1)v(n).
|
|
*/
|
|
class BackboneStretcherShader : public StrokeShader {
|
|
private:
|
|
float _amount;
|
|
|
|
public:
|
|
/*! Builds the shader.
|
|
* \param iAmount:
|
|
* The stretching amount value.
|
|
*/
|
|
BackboneStretcherShader(float iAmount = 2.0f) : StrokeShader()
|
|
{
|
|
_amount = iAmount;
|
|
}
|
|
|
|
virtual string getName() const
|
|
{
|
|
return "BackboneStretcherShader";
|
|
}
|
|
|
|
/*! The shading method */
|
|
virtual int shade(Stroke &stroke) const;
|
|
};
|
|
|
|
/*! [ Geometry Shader. ]
|
|
* Resamples the stroke.
|
|
* \see Stroke::Resample(float).
|
|
*/
|
|
class SamplingShader : public StrokeShader {
|
|
private:
|
|
float _sampling;
|
|
|
|
public:
|
|
/*! Builds the shader.
|
|
* \param sampling:
|
|
* The sampling to use for the stroke resampling
|
|
*/
|
|
SamplingShader(float sampling) : StrokeShader()
|
|
{
|
|
_sampling = sampling;
|
|
}
|
|
|
|
virtual string getName() const
|
|
{
|
|
return "SamplingShader";
|
|
}
|
|
|
|
/*! The shading method */
|
|
virtual int shade(Stroke &stroke) const;
|
|
};
|
|
|
|
class ExternalContourStretcherShader : public StrokeShader {
|
|
private:
|
|
float _amount;
|
|
|
|
public:
|
|
ExternalContourStretcherShader(float iAmount = 2.0f) : StrokeShader()
|
|
{
|
|
_amount = iAmount;
|
|
}
|
|
|
|
virtual string getName() const
|
|
{
|
|
return "ExternalContourStretcherShader";
|
|
}
|
|
|
|
virtual int shade(Stroke &stroke) const;
|
|
};
|
|
|
|
// Bezier curve stroke 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
|
|
*/
|
|
class BezierCurveShader : public StrokeShader {
|
|
private:
|
|
float _error;
|
|
|
|
public:
|
|
/*! 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.
|
|
*/
|
|
BezierCurveShader(float error = 4.0) : StrokeShader()
|
|
{
|
|
_error = error;
|
|
}
|
|
|
|
virtual string getName() const
|
|
{
|
|
return "BezierCurveShader";
|
|
}
|
|
|
|
/*! The shading method */
|
|
virtual int shade(Stroke &stroke) const;
|
|
};
|
|
|
|
/*! [ 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
|
|
* certain error is reached.
|
|
*/
|
|
class PolygonalizationShader : public StrokeShader {
|
|
private:
|
|
float _error;
|
|
|
|
public:
|
|
/*! 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.
|
|
* This error corresponds * to the maximum distance between the new stroke and the old one.
|
|
*/
|
|
PolygonalizationShader(float iError) : StrokeShader()
|
|
{
|
|
_error = iError;
|
|
}
|
|
|
|
virtual string getName() const
|
|
{
|
|
return "PolygonalizationShader";
|
|
}
|
|
|
|
/*! The shading method */
|
|
virtual int shade(Stroke &stroke) const;
|
|
};
|
|
|
|
/*! [ 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.
|
|
* The bigger the pieces, the rougher the approximation.
|
|
*/
|
|
class GuidingLinesShader : public StrokeShader {
|
|
private:
|
|
float _offset;
|
|
|
|
public:
|
|
/*! 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
|
|
* normal.
|
|
*/
|
|
GuidingLinesShader(float iOffset) : StrokeShader()
|
|
{
|
|
_offset = iOffset;
|
|
}
|
|
|
|
virtual string getName() const
|
|
{
|
|
return "GuidingLinesShader";
|
|
}
|
|
|
|
/*! The shading method */
|
|
virtual int shade(Stroke &stroke) const;
|
|
};
|
|
|
|
/*! [ Geometry Shader ].
|
|
* Removes the stroke's extremities.
|
|
*/
|
|
class TipRemoverShader : public StrokeShader {
|
|
public:
|
|
/*! Builds the shader.
|
|
* \param tipLength:
|
|
* The length of the piece of stroke we want to remove at each extremity.
|
|
*/
|
|
TipRemoverShader(real tipLength);
|
|
|
|
/*! Destructor. */
|
|
virtual ~TipRemoverShader()
|
|
{
|
|
}
|
|
|
|
/*! The shading method */
|
|
virtual string getName() const
|
|
{
|
|
return "TipRemoverShader";
|
|
}
|
|
|
|
virtual int shade(Stroke &stroke) const;
|
|
|
|
protected:
|
|
real _tipLength;
|
|
};
|
|
|
|
/*! [ Texture Shader ].
|
|
* Shader to assign texture to the Stroke material.
|
|
*/
|
|
|
|
class BlenderTextureShader : public StrokeShader {
|
|
private:
|
|
MTex *_mtex;
|
|
bNodeTree *_nodeTree;
|
|
|
|
public:
|
|
/*! Builds the shader.
|
|
* \param mtex:
|
|
* The blender texture to use.
|
|
*/
|
|
BlenderTextureShader(MTex *mtex) : StrokeShader()
|
|
{
|
|
_mtex = mtex;
|
|
_nodeTree = NULL;
|
|
}
|
|
|
|
/*! Builds the shader.
|
|
* \param nodetree:
|
|
* A node tree (of new shading nodes) to define textures.
|
|
*/
|
|
BlenderTextureShader(bNodeTree *nodetree) : StrokeShader()
|
|
{
|
|
_nodeTree = nodetree;
|
|
_mtex = NULL;
|
|
}
|
|
|
|
virtual string getName() const
|
|
{
|
|
return "BlenderTextureShader";
|
|
}
|
|
|
|
/*! The shading method */
|
|
virtual int shade(Stroke &stroke) const;
|
|
};
|
|
|
|
/*! [ Texture Shader ].
|
|
* Shader to assign texture to the Stroke material.
|
|
*/
|
|
|
|
class StrokeTextureStepShader : public StrokeShader {
|
|
private:
|
|
float _step;
|
|
|
|
public:
|
|
/*! Builds the shader.
|
|
* \param id:
|
|
* The number of the preset to use.
|
|
*/
|
|
StrokeTextureStepShader(float step) : StrokeShader()
|
|
{
|
|
_step = step;
|
|
}
|
|
|
|
virtual string getName() const
|
|
{
|
|
return "StrokeTextureStepShader";
|
|
}
|
|
|
|
/*! The shading method */
|
|
virtual int shade(Stroke &stroke) const;
|
|
};
|
|
|
|
} // end of namespace StrokeShaders
|
|
|
|
} /* namespace Freestyle */
|
|
|
|
#endif // __FREESTYLE_BASIC_STROKE_SHADERS_H__
|