Skip to content
Permalink
Branch: master
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
223 lines (182 sloc) 7.31 KB
/*
$Id: bezier.h,v 1.8 2001/09/22 15:52:11 plasmoid Exp $
------------------------------------------------------------------------
ClanLib, the platform independent game SDK.
This library is distributed under the GNU LIBRARY GENERAL PUBLIC LICENSE
version 2. See COPYING for details.
For a total list of contributers see CREDITS.
See http://www.clanlib.org
------------------------------------------------------------------------
*/
//! clanCore="Math"
//! header=core.h
#ifndef header_bezier
#define header_bezier
#include "cl_vector.h"
//: Class for Bezier curves
//- This class generates points on a Bezier curve from given control points
//-
//- <p>USE AT YOUR OWN RISK TILL THIS CLASS IS EXTENSIVELY TESTED!!! I WILL
//- REMOVE THIS WARNING ONCE IT BASICALLY WORKS.</p>
//-
//- <p>I hate documentation work and I won't document this code before any
//- one besides me actually uses it. So if you want to use it simply
//- write a mail on the ClanLib User list and I will do what I can :-) </p>
//-
//- 1999/12/30 vogel renamed CL_Bezier to CL_BezierCurve
//- added CL_BezierSurface
//-
//- 1999/07/07 vogel initial version
//-
//-
//- BezierCurve TODO:
//-
//- - length and stepping per curve
//-
//- <p>stepping per curve means that the generated points are equidistant to
//- each other and this requires get_length() working. So at the moment all
//- that is working is having 'n' equidistant points per segment.</p>
//-
//- same applies to BezierSurface.
class CL_BezierCurve
{
protected:
CL_Vector *curve; // the generated curve
CL_Vector *cp; // control points
int steps, cs; // number of steps, curve segments
bool stepping; // steps per segment or per curve
virtual void make_curve();
public:
//! Construction:
//: Constructor
//- cp - an array of control points with size (4 * cs)
//- cs - number of curve segments
//- steps - number of points to generate
//- stepping - whether steps is the number of points per segment or per curve.
CL_BezierCurve(const CL_Vector *cp, int cs, int steps, bool stepping = true);
//: Destructor
virtual ~CL_BezierCurve();
//! Attributes:
//: Returns the number of steps
//- Returns - number of steps
virtual int get_steps() const { return steps; }
//: Returns the number of curve segments
//- Returns - number of curve segments
virtual int get_cs() const { return cs; }
//: Returns whether steps is the number of points per segment or per curve.
//- Returns - stepping
virtual bool get_stepping() const { return stepping; }
//: Returns the lenght of a segment (or the curve)
//- segment - number of segment (-1 indicates whole curve)
//- Returns - length of segment (or curve)
virtual float get_length(int segment = -1) const;
//: Returns an array of cs * steps CL_Vectors -> the curve
//- Returns - the curve (cs * steps CL_Vectors)
virtual CL_Vector* get_curve() const { return curve; }
//: Returns the 4 * cs control points
//- Returns - the 4 * cs control points
virtual CL_Vector* get_control_points() const { return cp; }
//! Operations:
//: Sets the number of steps
//- steps - number of steps
virtual void set_steps(int steps);
//: Sets the stepping
//- stepping - whether steps is the number of points per segment or per curve.
virtual void set_stepping(bool stepping);
//! Operators:
//: Returns the n-th vector of the curve (_doesn't_ return a reference)
//- n - the vector to return (counting starts at 0)
//- Returns - the n-th vector of the curve (_doesn't_ return a reference)
CL_Vector operator [] (int n) { return curve[n]; }
};
//: Class for Bezier surfaces
//- This class generates points on a Bezier surface from given control points
//-
//- <p>USE AT YOUR OWN RISK TILL THIS CLASS IS EXTENSIVELY TESTED!!! I WILL
//- REMOVE THIS WARNING ONCE IT BASICALLY WORKS.</p>
//-
//- <p>I hate documentation work and I won't document this code before any
//- one besides me actually uses it. So if you want to use it simply
//- write a mail on the ClanLib User list and I will do what I can :-)</p>
//-
//- 1999/12/30 vogel renamed CL_Bezier to CL_BezierCurve
//- added CL_BezierSurface
//-
//- 1999/07/07 vogel initial version
//-
//-
//- BezierCurve TODO:
//-
//- - length and stepping per curve
//-
//- <p>stepping per curve means that the generated points are equidistant to
//- each other and this requires get_length() working. So at the moment all
//- that is working is having 'n' equidistant points per segment.</p>
//-
//- same applies to BezierSurface.
class CL_BezierSurface
{
protected:
CL_Vector *surface; // the generated surface
CL_Vector *cp; // control points
int xsteps, ysteps; // number of steps in x and y direction,
int xs, ys; // number of surface segments om x and y direction
bool stepping; // steps per segment or per surface
virtual CL_Vector evaluate(float, float, int);
virtual void make_surface();
public:
//! Construction:
//: Constructor
//- cp - an array of control points with size (16 * xs * ys)
//- xs - number of surface segments on x direction
//- ys - number of surface segments on y direction
//- xsteps - number of points to generate on x direction
//- ysteps - number of points to generate on x direction
//- stepping - whether steps is the number of points per segment or per surface.
CL_BezierSurface(const CL_Vector *cp, int xs, int ys, int xsteps, int ysteps, bool stepping = true);
//: Destructor
virtual ~CL_BezierSurface();
//! Attributes:
//: Returns the number of steps
//- Returns - number of steps
virtual int get_xsteps() const { return xsteps; }
virtual int get_ysteps() const { return ysteps; }
//: Returns the number of steps
//- Returns - number of steps
//: Returns the number of surface segments
//- Returns - number of surface segments
virtual int get_xs() const { return xs; }
//: Returns the number of surface segments
//- Returns - number of surface segments
virtual int get_ys() const { return ys; }
//: Returns whether steps is the number of points per segment or per curve.
//- Returns - stepping
virtual bool get_stepping() const { return stepping; }
//: Nak Nak - don't expect it to be implemented too soon...
//: Returns the length of a segment (or the surface)
//- segment - number of segment (-1 indicates whole surface)
//- Returns - length of segment (or surface)
// virtual float get_length(int segment = -1) const;
//: Returns an array of xs * xsteps * ys * ysteps CL_Vectors -> the surface
//- Returns - the curve (xs * xsteps * ys * ystepes CL_Vectors)
virtual CL_Vector* get_surface() const { return surface; }
//: Returns the 16 * xs * ys control points
//- Returns - the 16 * xs * ys control points
virtual CL_Vector* get_control_points() const { return cp; }
//! Operations:
//: Sets the number of steps
//- steps - number of steps
virtual void set_xsteps(int xsteps);
//: Sets the number of steps
//- steps - number of steps
virtual void set_ysteps(int ysteps);
//: Sets the stepping
//- stepping - whether steps is the number of points per segment or per curve.
virtual void set_stepping(bool stepping);
//! Operators:
//: Returns the n-th vector of the curve (_doesn't_ return a reference)
//- n - the vector to return (counting starts at 0)
//- Returns - the n-th vector of the curve (_doesn't_ return a reference)
CL_Vector operator [] (int n) { return surface[n]; }
};
#endif
You can’t perform that action at this time.