new render target class while working on the exhibit UI
[laserbrain_demo] / src / machine / gear.cc
1 #include <stdlib.h>
2 #include <GL/glew.h>
3 #include "gear.h"
4 #include "meshgen.h"
5 #include "app.h"
6
7 Gear::Gear()
8         : axis(0, 0, 1)
9 {
10         pdist = 0;
11         angle = 0;
12         teeth_length = 5;
13         thickness = 5;
14         bevel = 1.5;
15         init_angle = 0;
16         xform_valid = false;
17
18         set_teeth(42, 10);
19
20         supergear = 0;
21
22         mesh = 0;
23
24         color = Vec3(0.6, 0.6, 0.6);
25         roughness = 1.0;
26         metallic = false;
27 }
28
29 Gear::~Gear()
30 {
31         delete mesh;
32 }
33
34 void Gear::attach(Gear *g)
35 {
36         if(g->supergear) {
37                 if(g->supergear == this) {
38                         return;
39                 }
40                 g->supergear->detach(g);
41         }
42         g->supergear = this;
43         subgears.push_back(g);
44
45         // make co-axial
46         g->axis = axis;
47         g->pos.x = pos.x;
48         g->pos.y = pos.y;
49 }
50
51 bool Gear::detach(Gear *g)
52 {
53         int nsubgears = (int)subgears.size();
54         for(int i=0; i<nsubgears; i++) {
55                 if(subgears[i] == g) {
56                         subgears.erase(subgears.begin() + i);
57                         g->supergear = 0;
58                         return true;
59                 }
60         }
61         return false;
62 }
63
64 Gear *Gear::get_super() const
65 {
66         return supergear;
67 }
68
69 void Gear::set_angular_offset(float offs)
70 {
71         init_angle = offs;
72         xform_valid = false;
73 }
74
75 float Gear::get_angular_offset() const
76 {
77         return init_angle;
78 }
79
80 void Gear::set_teeth(int nt, float tooth_pitch)
81 {
82         if(tooth_pitch <= 0) {
83                 tooth_pitch = this->tooth_pitch;
84         } else {
85                 this->tooth_pitch = tooth_pitch;
86         }
87         float circ = tooth_pitch * nt;
88         radius = circ / (2.0 * M_PI);
89         nteeth = nt;
90 }
91
92 void Gear::set_axis(const Vec3 &axis)
93 {
94         this->axis = normalize(axis);
95         xform_valid = false;
96 }
97
98 const Vec3 &Gear::get_axis() const
99 {
100         return axis;
101 }
102
103 void Gear::set_position(const Vec3 &pos)
104 {
105         if(!supergear) {
106                 this->pos = pos;
107         } else {
108                 this->pos = supergear->pos;
109                 this->pos.z = pos.z;
110         }
111         xform_valid = false;
112
113         for(int i=0; i<(int)subgears.size(); i++) {
114                 Vec3 subpos = this->pos;
115                 subpos.z = subgears[i]->pos.z;
116                 subgears[i]->set_position(subpos);
117         }
118 }
119
120 const Vec3 &Gear::get_position() const
121 {
122         return pos;
123 }
124
125 Vec3 Gear::get_global_position() const
126 {
127         const Mat4 &m = get_matrix();
128         return m * Vec3(0, 0, 0);
129 }
130
131 void Gear::set_angle(float angle)
132 {
133         this->angle = angle;
134         xform_valid = false;
135 }
136
137 float Gear::get_angle() const
138 {
139         return angle;
140 }
141
142 float Gear::get_vis_rotation() const
143 {
144         return fmod(init_angle + angle, M_PI * 2.0);
145 }
146
147 const Mat4 &Gear::get_matrix() const
148 {
149         if(!xform_valid) {
150                 calc_matrix();
151                 xform_valid = true;
152         }
153         return xform;
154 }
155
156 const Mat4 &Gear::get_dir_matrix() const
157 {
158         if(!xform_valid) {
159                 calc_matrix();
160                 xform_valid = true;
161         }
162         return dir_xform;
163 }
164
165 float Gear::get_angular_pitch() const
166 {
167         return 2.0 * M_PI / (float)nteeth;
168 }
169
170 void Gear::draw() const
171 {
172         if(!mesh) {
173                 if(!((Gear*)this)->gen_mesh()) {
174                         abort();
175                 }
176         }
177         if(!xform_valid) {
178                 calc_matrix();
179         }
180
181         glPushAttrib(GL_ENABLE_BIT | GL_LINE_BIT | GL_LIGHTING_BIT);
182
183         glPushMatrix();
184         glMultMatrixf(xform[0]);
185
186         if(opt_gear_wireframe) {
187                 glPolygonOffset(1, 1);
188                 glEnable(GL_POLYGON_OFFSET_FILL);
189         }
190
191         Vec3 diffuse = metallic ? Vec3(0, 0, 0) : color;
192         float col[] = {diffuse.x, diffuse.y, diffuse.z, 1.0};
193         glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, col);
194
195         Vec3 specular = (metallic ? color : Vec3(1, 1, 1)) * (1.0 - roughness);
196         float scol[] = {specular.x, specular.y, specular.z, 1.0};
197         glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, scol);
198         glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 1.0 + (1.0 - roughness) * 60.0);
199
200         mesh->draw();
201
202         glDisable(GL_LIGHTING);
203
204         if(opt_gear_wireframe) {
205                 glColor3f(0.2, 0.4, 1.0);
206                 mesh->draw_wire();
207         }
208
209         glPopMatrix();
210         glPopAttrib();
211 }
212
213 void Gear::draw_wire(float wire_width) const
214 {
215         if(!mesh) {
216                 if(!((Gear*)this)->gen_mesh()) {
217                         abort();
218                 }
219         }
220         if(!xform_valid) {
221                 calc_matrix();
222         }
223
224         glPushAttrib(GL_ENABLE_BIT | GL_LINE_BIT);
225         glLineWidth(wire_width);
226         glDisable(GL_LIGHTING);
227
228         glPushMatrix();
229         glMultMatrixf(xform[0]);
230
231         mesh->draw_wire();
232
233         glPopMatrix();
234         glPopAttrib();
235 }
236
237 static Vec2 rev_pos(float u, float v, void *cls)
238 {
239         Gear *gear = (Gear*)cls;
240
241         float y = ((v - 1.0 / 3.0) / (1.0 / 3.0) - 0.5);
242         if(y < -0.5) y = -0.5;
243         if(y > 0.5) y = 0.5;
244         y *= gear->thickness;
245
246         if(v < 0.001 || v > 0.999) {
247                 return Vec2(0, -y);
248         }
249
250         float nt = (float)gear->nteeth * 4.0;
251
252         int part = (int)(u * nt) % 4;   /* 4 parts to a tooth /#\_ */
253         float t = fmod(u * nt * 4.0, 1.0);
254
255         float offs;
256         switch(part) {
257         case 0:
258                 offs = t;
259                 break;
260         case 1:
261                 offs = 1.0f;
262                 break;
263         case 2:
264                 offs = 1.0f - t;
265                 break;
266         case 3:
267                 offs = 0.0f;
268         }
269
270         float inner_rad = gear->radius - gear->teeth_length;
271         return Vec2(inner_rad + offs * gear->teeth_length, -y);
272 }
273
274 bool Gear::gen_mesh()
275 {
276         mesh = new Mesh;
277         gen_revol(mesh, nteeth * 4, 3, rev_pos, 0, this);
278         mesh->explode();
279         mesh->calc_face_normals();
280
281         float fix_tooth_up = get_angular_pitch() * 3.0 / 8.0;
282
283         Mat4 rot;
284         rot.rotation_x(M_PI / 2.0);
285         rot.rotate_z(fix_tooth_up);
286         mesh->apply_xform(rot, rot);
287
288         mesh->set_vis_vecsize(6.0);
289         return true;
290 }
291
292 void Gear::calc_matrix() const
293 {
294         Vec3 up = Vec3(0, 1, 0);
295         if(1.0 - fabs(dot(up, axis)) < 1e-4) {
296                 up = Vec3(0, 0, -1);
297         }
298         Vec3 right = normalize(cross(up, axis));
299         up = cross(axis, right);
300
301         dir_xform = Mat4(right, up, axis);
302
303         xform = dir_xform;
304         xform.rotate_z(get_vis_rotation());
305         xform.translate(pos);
306
307         axel_xform = dir_xform;
308         axel_xform.translate(pos);
309 }