BasicStrokeShaders.h

Go to the documentation of this file.

/*
 * 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.
 */
 
#pragma once
 
#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
//
 
class ConstantThicknessShader : public StrokeShader {
 public:
  ConstantThicknessShader(float thickness)
  {
    _thickness = thickness;
  }
 
  virtual ~ConstantThicknessShader()
  {
  }
 
  virtual string getName() const
  {
    return "ConstantThicknessShader";
  }
 
  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)
  {
    _thickness = thickness;
  }
 
  virtual ~ConstantExternThicknessShader()
  {
  }
 
  virtual string getName() const
  {
    return "ConstantExternThicknessShader";
  }
 
  virtual int shade(Stroke &stroke) const;
 
 private:
  float _thickness;
};
 
class IncreasingThicknessShader : public StrokeShader {
 public:
  IncreasingThicknessShader(float iThicknessMin, float iThicknessMax)
  {
    _ThicknessMin = iThicknessMin;
    _ThicknessMax = iThicknessMax;
  }
 
  virtual ~IncreasingThicknessShader()
  {
  }
 
  virtual string getName() const
  {
    return "IncreasingThicknessShader";
  }
 
  virtual int shade(Stroke &stroke) const;
 
 private:
  float _ThicknessMin;
  float _ThicknessMax;
};
 
class ConstrainedIncreasingThicknessShader : public StrokeShader {
 private:
  float _ThicknessMin;
  float _ThicknessMax;
  float _ratio;
 
 public:
  ConstrainedIncreasingThicknessShader(float iThicknessMin, float iThicknessMax, float iRatio)
 
  {
    _ThicknessMin = iThicknessMin;
    _ThicknessMax = iThicknessMax;
    _ratio = iRatio;
  }
 
  virtual ~ConstrainedIncreasingThicknessShader()
  {
  }
 
  virtual string getName() const
  {
    return "ConstrainedIncreasingThicknessShader";
  }
 
  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)
  {
    _minThickness = iMinThickness;
    _maxThickness = iMaxThickness;
  }
 
  virtual ~LengthDependingThicknessShader()
  {
  }
 
  virtual string getName() const
  {
    return "LengthDependingThicknessShader";
  }
 
  virtual int shade(Stroke &stroke) const;
};
 
class ThicknessNoiseShader : public StrokeShader {
 private:
  float _amplitude;
  float _scale;
 
 public:
  ThicknessNoiseShader();
 
  ThicknessNoiseShader(float iAmplitude, float iPeriod);
 
  virtual string getName() const
  {
    return "ThicknessNoiseShader";
  }
 
  virtual int shade(Stroke &stroke) const;
};
 
//
//  Color shaders
//
 
class ConstantColorShader : public StrokeShader {
 public:
  ConstantColorShader(float iR, float iG, float iB, float iAlpha = 1.0f)
  {
    _color[0] = iR;
    _color[1] = iG;
    _color[2] = iB;
    _color[3] = iAlpha;
  }
 
  virtual string getName() const
  {
    return "ConstantColorShader";
  }
 
  virtual int shade(Stroke &stroke) const;
 
 private:
  float _color[4];
};
 
class IncreasingColorShader : public StrokeShader {
 private:
  float _colorMin[4];
  float _colorMax[4];
 
 public:
  IncreasingColorShader(float iRm,
                        float iGm,
                        float iBm,
                        float iAlpham,
                        float iRM,
                        float iGM,
                        float iBM,
                        float iAlphaM)
 
  {
    _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";
  }
 
  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)
  {
    _coefficient = coeff;
  }
 
  virtual string getName() const
  {
    return "MaterialColorShader";
  }
 
  virtual int shade(Stroke &stroke) const;
};
 
class ColorNoiseShader : public StrokeShader {
 private:
  float _amplitude;
  float _scale;
 
 public:
  ColorNoiseShader();
 
  ColorNoiseShader(float iAmplitude, float iPeriod);
 
  virtual string getName() const
  {
    return "ColorNoiseShader";
  }
 
  virtual int shade(Stroke &stroke) const;
};
 
//
//  Geometry Shaders
//
 
class BackboneStretcherShader : public StrokeShader {
 private:
  float _amount;
 
 public:
  BackboneStretcherShader(float iAmount = 2.0f)
  {
    _amount = iAmount;
  }
 
  virtual string getName() const
  {
    return "BackboneStretcherShader";
  }
 
  virtual int shade(Stroke &stroke) const;
};
 
class SamplingShader : public StrokeShader {
 private:
  float _sampling;
 
 public:
  SamplingShader(float sampling)
  {
    _sampling = sampling;
  }
 
  virtual string getName() const
  {
    return "SamplingShader";
  }
 
  virtual int shade(Stroke &stroke) const;
};
 
class ExternalContourStretcherShader : public StrokeShader {
 private:
  float _amount;
 
 public:
  ExternalContourStretcherShader(float iAmount = 2.0f)
  {
    _amount = iAmount;
  }
 
  virtual string getName() const
  {
    return "ExternalContourStretcherShader";
  }
 
  virtual int shade(Stroke &stroke) const;
};
 
// Bezier curve stroke shader
class BezierCurveShader : public StrokeShader {
 private:
  float _error;
 
 public:
  BezierCurveShader(float error = 4.0)
  {
    _error = error;
  }
 
  virtual string getName() const
  {
    return "BezierCurveShader";
  }
 
  virtual int shade(Stroke &stroke) const;
};
 
class PolygonalizationShader : public StrokeShader {
 private:
  float _error;
 
 public:
  PolygonalizationShader(float iError)
  {
    _error = iError;
  }
 
  virtual string getName() const
  {
    return "PolygonalizationShader";
  }
 
  virtual int shade(Stroke &stroke) const;
};
 
class GuidingLinesShader : public StrokeShader {
 private:
  float _offset;
 
 public:
  GuidingLinesShader(float iOffset)
  {
    _offset = iOffset;
  }
 
  virtual string getName() const
  {
    return "GuidingLinesShader";
  }
 
  virtual int shade(Stroke &stroke) const;
};
 
class TipRemoverShader : public StrokeShader {
 public:
  TipRemoverShader(real tipLength);
 
  virtual ~TipRemoverShader()
  {
  }
 
  virtual string getName() const
  {
    return "TipRemoverShader";
  }
 
  virtual int shade(Stroke &stroke) const;
 
 protected:
  real _tipLength;
};
 
class BlenderTextureShader : public StrokeShader {
 private:
  MTex *_mtex;
  bNodeTree *_nodeTree;
 
 public:
  BlenderTextureShader(MTex *mtex)
  {
    _mtex = mtex;
    _nodeTree = NULL;
  }
 
  BlenderTextureShader(bNodeTree *nodetree)
  {
    _nodeTree = nodetree;
    _mtex = NULL;
  }
 
  virtual string getName() const
  {
    return "BlenderTextureShader";
  }
 
  virtual int shade(Stroke &stroke) const;
};
 
class StrokeTextureStepShader : public StrokeShader {
 private:
  float _step;
 
 public:
  StrokeTextureStepShader(float step)
  {
    _step = step;
  }
 
  virtual string getName() const
  {
    return "StrokeTextureStepShader";
  }
 
  virtual int shade(Stroke &stroke) const;
};
 
}  // end of namespace StrokeShaders
 
} /* namespace Freestyle */