OpenGL Evaluators

OpenGL的求值器很好用，对于显示和编辑曲面非常有用，不过遗憾的是它仅仅能够帮助显示曲面，而无法回传给用户真正的多边形数据，这也难怪，最初ogl在SGI的图形工作站上，Evaluators是以硬件加速实现的。
把手头的opengl driver代码打开，看来看去，还是mesa的好些，整理一下贴出来，顺便测试一下如何贴代码, 颜色显示的还不正常，需要上传一个css文件，不知道blogspot如何才能上传文件。

namespace sglib{
namespace gfx{

class bezier{
public:
  /*
     * Horner scheme for Bezier curves
     *
     * Bezier curves can be computed via a Horner scheme.
     * Horner is numerically less stable than the de Casteljau
     * algorithm, but it is faster. For curves of degree n
     * the complexity of Horner is O(n) and de Casteljau is O(n^2).
     * Since stability is not important for displaying curve
     * points I decided to use the Horner scheme.
     *
     * A cubic Bezier curve with control points b0, b1, b2, b3 can be
     * written as
     *
     *        (([3]        [3]     )     [3]       )     [3]
     * c(t) = (([0]*s*b0 + [1]*t*b1)*s + [2]*t^2*b2)*s + [3]*t^2*b3
     *
     *                                           [n]
     * where s=1-t and the binomial coefficients [i]. These can
     * be computed iteratively using the identity:
     *
     * [n]               [n  ]             [n]
     * [i] = (n-i+1)/i * [i-1]     and     [0] = 1
     */
  static void curve(
         const float * cp
       , float * out
       , float t
       , int dim
       , int order ) {

  #define MAX_EVAL_ORDER 30
      static float inv_tab[MAX_EVAL_ORDER];
      static bool inited = false;
      if(!inited){
         // KW: precompute 1/x for useful x.
          for (int i = 1; i < MAX_EVAL_ORDER; i++)
              inv_tab[i] = 1.0F / i;
          inited = true;
      }
      float s, powert, bincoeff;
      unsigned int i, k;

      if(t == 0){
          for (k = 0; k < dim; k++)
              out[k] = cp[k];
      }
      else if( t == 1.0){
          for (k = 0; k<dim; k++)
              out[k] = cp[dim*(order-1)+k];
      }
      else {
          if (order >= 2) {
              bincoeff = (float) (order - 1);
              s = 1.0F - t;

              for (k = 0; k < dim; k++)
                  out[k] = s * cp[k] + bincoeff * t * cp[dim + k];

              for (i = 2, cp += 2 * dim, powert = t * t; i < order; i++, powert *= t, cp += dim) {
                  bincoeff *= (float) (order - i);
                  bincoeff *= inv_tab[i];
                  for (k = 0; k < dim; k++)
                      out[k] = s * out[k] + bincoeff * powert * cp[k];
              }
          }
          else { /* order=1 -> constant curve */
              for (k = 0; k < dim; k++)
                  out[k] = cp[k];
          }
      }
  }
private:
  void cleanup(){
      if(_ver)
          delete []_ver;
      _ver = 0;
  }
  bool gen_vertex(int usize, int vsize){
      cleanup();

      int total = _dim * usize * vsize;

      float * vcp = new float [_dim*_vorder];
      _ver = new float[total];
      if(!_cp || !_ver || !vcp)
          return false;

      float ustep = 1.0f/(usize-1);
      float vstep = 1.0f/(vsize-1);
      float fu, fv;
      int u, v;
      for(u=0, fu=0 ; u<usize; u++, fu += ustep){
          //1. calc control point first
          for(v=0; v<_vorder; v++){
              curve (&_cp[_dim*v*_uorder], &vcp[v*_dim], fu, _dim, _uorder);
          }
          float * ver = _ver + _dim*u;
          //2. calc vertex along v dir
          for(v=0, fv=0; v<vsize; v++, fv += vstep){
              curve (vcp, ver, fv, _dim, _vorder);
              ver += usize*_dim;
          }
      }
      delete []vcp;
      return true;
  }
public:
  bezier(): _cp(0) , _ver(0) {
  }
  ~bezier(){
      cleanup();
  }
  void init(const float * cp, int dim, int uorder, int vorder){
      _cp = cp, _dim = dim, _uorder = uorder, _vorder = vorder;
  }

  bool gen(int usize, int vsize){
      bool b = true;
      b &= gen_vertex(usize, vsize);
      return b;
  }

  float * get_vertex() {
      return _ver;
  }
protected:
  const float * _cp; // control points
  int _uorder;
  int _vorder;
  int _dim;
  float * _ver;
};


}} //gfx, sglib