summaryrefslogtreecommitdiff
path: root/Build/source/utils/asymptote/beziercurve.h
blob: 573b48a79294f227898607c60112027a249bfe82 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
/*****
 * beziercurve.h
 * Author: John C. Bowman
 *
 * Render a Bezier curve.
 *****/

#ifndef BEZIERCURVE_H
#define BEZIERCURVE_H

#include "drawelement.h"

namespace camp {

#ifdef HAVE_GL

extern const double Fuzz;
extern const double Fuzz2;

class vertexData1 {
public:
  GLfloat position[3];
  GLint  material;
  vertexData1() {};
  vertexData1(const triple& v) {
    position[0]=v.getx();
    position[1]=v.gety();
    position[2]=v.getz();
    material=drawElement::materialIndex;
  }
};

class pixelData {
public:
  GLfloat position[3];
  GLint  material;
  GLfloat width;
  pixelData() {};
  pixelData(const triple& v, double width) : width(width) {
    position[0]=v.getx();
    position[1]=v.gety();
    position[2]=v.getz();
    material=drawElement::materialIndex;
  }
};

struct BezierCurve
{
  static std::vector<vertexData1> vertexbuffer;
  static std::vector<GLuint> indices;
  double res,res2;
  triple Min,Max;

  static GLuint vertsBufferIndex; 
  static GLuint elemBufferIndex; 
  
  void init(double res, const triple& Min, const triple& Max);
    
// Store the vertex v in the buffer.
  static GLuint vertex(const triple &v) {
    size_t nvertices=vertexbuffer.size();
    vertexbuffer.push_back(vertexData1(v));
    return nvertices;
  }
  
  void createBuffers() {
    glGenBuffers(1,&vertsBufferIndex);
    glGenBuffers(1,&elemBufferIndex);

    //vbo
    registerBuffer(vertexbuffer,vertsBufferIndex);

    //ebo
    registerBuffer(indices,elemBufferIndex);
  }
  
// Approximate bounds by bounding box of control polyhedron.
  bool offscreen(size_t n, const triple *v) {
    double x,y,z;
    double X,Y,Z;
    
    boundstriples(x,y,z,X,Y,Z,n,v);
    return
      X < Min.getx() || x > Max.getx() ||
      Y < Min.gety() || y > Max.gety() ||
      Z < Min.getz() || z > Max.getz();
  }
  
  static void clear() {
    vertexbuffer.clear();
    indices.clear();
  }
  
  ~BezierCurve() {}
  
  void render(const triple *p, GLuint I0, GLuint I1);
  void render(const triple *p, bool straight);
  
  void queue(const triple *g, bool straight, double ratio,
              const triple& Min, const triple& Max) {
    init(pixel*ratio,Min,Max);
    render(g,straight);
  }
  
  void draw();
  void draw(const triple *g, bool straight, double ratio,
            const triple& Min, const triple& Max) {
    queue(g,straight,ratio,Min,Max);
    draw();
  }
};

struct Pixel
{
  static std::vector<pixelData> vertexbuffer;
  
// Store the vertex v in the buffer.
  static void vertex(const triple &v, double width) {
    vertexbuffer.push_back(pixelData(v,width));
  }
  
  static void clear() {
    vertexbuffer.clear();
  }
  
  Pixel() {}
  ~Pixel() {}
  
  void queue(const triple& p, double width);
  void draw();
};

#endif

} //namespace camp

#endif