rev |
line source |
nuclear@0
|
1 #include <stdio.h>
|
nuclear@0
|
2 #include <stdlib.h>
|
nuclear@0
|
3 #include <float.h>
|
nuclear@0
|
4 #include <assert.h>
|
nuclear@0
|
5 #include "opengl.h"
|
nuclear@0
|
6 #include "mesh.h"
|
nuclear@0
|
7 //#include "xform_node.h"
|
nuclear@0
|
8
|
nuclear@1
|
9 int Mesh::global_sdr_loc[NUM_MESH_ATTR] = { 0, 1, 2, 3, 4, 5, 6 };
|
nuclear@1
|
10 /*
|
nuclear@0
|
11 (int)SDR_ATTR_VERTEX,
|
nuclear@0
|
12 (int)SDR_ATTR_NORMAL,
|
nuclear@0
|
13 (int)SDR_ATTR_TANGENT,
|
nuclear@0
|
14 (int)SDR_ATTR_TEXCOORD,
|
nuclear@0
|
15 (int)SDR_ATTR_COLOR,
|
nuclear@0
|
16 -1, -1};
|
nuclear@1
|
17 */
|
nuclear@0
|
18 unsigned int Mesh::intersect_mode = ISECT_DEFAULT;
|
nuclear@0
|
19 float Mesh::vertex_sel_dist = 0.01;
|
nuclear@0
|
20 float Mesh::vis_vecsize = 1.0;
|
nuclear@0
|
21
|
nuclear@0
|
22 Mesh::Mesh()
|
nuclear@0
|
23 {
|
nuclear@0
|
24 clear();
|
nuclear@0
|
25
|
nuclear@0
|
26 glGenBuffers(NUM_MESH_ATTR + 1, buffer_objects);
|
nuclear@0
|
27
|
nuclear@0
|
28 for(int i=0; i<NUM_MESH_ATTR; i++) {
|
nuclear@0
|
29 vattr[i].vbo = buffer_objects[i];
|
nuclear@0
|
30 }
|
nuclear@0
|
31 ibo = buffer_objects[NUM_MESH_ATTR];
|
nuclear@0
|
32 wire_ibo = 0;
|
nuclear@0
|
33 }
|
nuclear@0
|
34
|
nuclear@0
|
35 Mesh::~Mesh()
|
nuclear@0
|
36 {
|
nuclear@0
|
37 glDeleteBuffers(NUM_MESH_ATTR + 1, buffer_objects);
|
nuclear@0
|
38
|
nuclear@0
|
39 if(wire_ibo) {
|
nuclear@0
|
40 glDeleteBuffers(1, &wire_ibo);
|
nuclear@0
|
41 }
|
nuclear@0
|
42 }
|
nuclear@0
|
43
|
nuclear@0
|
44 Mesh::Mesh(const Mesh &rhs)
|
nuclear@0
|
45 {
|
nuclear@0
|
46 clear();
|
nuclear@0
|
47
|
nuclear@0
|
48 glGenBuffers(NUM_MESH_ATTR + 1, buffer_objects);
|
nuclear@0
|
49
|
nuclear@0
|
50 for(int i=0; i<NUM_MESH_ATTR; i++) {
|
nuclear@0
|
51 vattr[i].vbo = buffer_objects[i];
|
nuclear@0
|
52 }
|
nuclear@0
|
53 ibo = buffer_objects[NUM_MESH_ATTR];
|
nuclear@0
|
54 wire_ibo = 0;
|
nuclear@0
|
55
|
nuclear@0
|
56 clone(rhs);
|
nuclear@0
|
57 }
|
nuclear@0
|
58
|
nuclear@0
|
59 Mesh &Mesh::operator =(const Mesh &rhs)
|
nuclear@0
|
60 {
|
nuclear@0
|
61 if(&rhs != this) {
|
nuclear@0
|
62 clone(rhs);
|
nuclear@0
|
63 }
|
nuclear@0
|
64 return *this;
|
nuclear@0
|
65 }
|
nuclear@0
|
66
|
nuclear@0
|
67 bool Mesh::clone(const Mesh &m)
|
nuclear@0
|
68 {
|
nuclear@0
|
69 clear();
|
nuclear@0
|
70
|
nuclear@0
|
71 for(int i=0; i<NUM_MESH_ATTR; i++) {
|
nuclear@0
|
72 if(m.has_attrib(i)) {
|
nuclear@0
|
73 m.get_attrib_data(i); // force validation of the actual data on the source mesh
|
nuclear@0
|
74
|
nuclear@0
|
75 vattr[i].nelem = m.vattr[i].nelem;
|
nuclear@0
|
76 vattr[i].data = m.vattr[i].data; // copy the actual data
|
nuclear@0
|
77 vattr[i].data_valid = true;
|
nuclear@0
|
78 }
|
nuclear@0
|
79 }
|
nuclear@0
|
80
|
nuclear@0
|
81 if(m.is_indexed()) {
|
nuclear@0
|
82 m.get_index_data(); // again, force validation
|
nuclear@0
|
83
|
nuclear@0
|
84 // copy the index data
|
nuclear@0
|
85 idata = m.idata;
|
nuclear@0
|
86 idata_valid = true;
|
nuclear@0
|
87 }
|
nuclear@0
|
88
|
nuclear@0
|
89 name = m.name;
|
nuclear@0
|
90 nverts = m.nverts;
|
nuclear@0
|
91 nfaces = m.nfaces;
|
nuclear@0
|
92
|
nuclear@0
|
93 //bones = m.bones;
|
nuclear@0
|
94
|
nuclear@0
|
95 memcpy(cur_val, m.cur_val, sizeof cur_val);
|
nuclear@0
|
96
|
nuclear@0
|
97 aabb = m.aabb;
|
nuclear@0
|
98 aabb_valid = m.aabb_valid;
|
nuclear@0
|
99 bsph = m.bsph;
|
nuclear@0
|
100 bsph_valid = m.bsph_valid;
|
nuclear@0
|
101
|
nuclear@0
|
102 hitface = m.hitface;
|
nuclear@0
|
103 hitvert = m.hitvert;
|
nuclear@0
|
104
|
nuclear@0
|
105 intersect_mode = m.intersect_mode;
|
nuclear@0
|
106 vertex_sel_dist = m.vertex_sel_dist;
|
nuclear@0
|
107 vis_vecsize = m.vis_vecsize;
|
nuclear@0
|
108
|
nuclear@0
|
109 return true;
|
nuclear@0
|
110 }
|
nuclear@0
|
111
|
nuclear@0
|
112 void Mesh::set_name(const char *name)
|
nuclear@0
|
113 {
|
nuclear@0
|
114 this->name = name;
|
nuclear@0
|
115 }
|
nuclear@0
|
116
|
nuclear@0
|
117 const char *Mesh::get_name() const
|
nuclear@0
|
118 {
|
nuclear@0
|
119 return name.c_str();
|
nuclear@0
|
120 }
|
nuclear@0
|
121
|
nuclear@0
|
122 bool Mesh::has_attrib(int attr) const
|
nuclear@0
|
123 {
|
nuclear@0
|
124 if(attr < 0 || attr >= NUM_MESH_ATTR) {
|
nuclear@0
|
125 return false;
|
nuclear@0
|
126 }
|
nuclear@0
|
127
|
nuclear@0
|
128 // if neither of these is valid, then nobody has set this attribute
|
nuclear@0
|
129 return vattr[attr].vbo_valid || vattr[attr].data_valid;
|
nuclear@0
|
130 }
|
nuclear@0
|
131
|
nuclear@0
|
132 bool Mesh::is_indexed() const
|
nuclear@0
|
133 {
|
nuclear@0
|
134 return ibo_valid || idata_valid;
|
nuclear@0
|
135 }
|
nuclear@0
|
136
|
nuclear@0
|
137 void Mesh::clear()
|
nuclear@0
|
138 {
|
nuclear@0
|
139 //bones.clear();
|
nuclear@0
|
140
|
nuclear@0
|
141 for(int i=0; i<NUM_MESH_ATTR; i++) {
|
nuclear@0
|
142 vattr[i].nelem = 0;
|
nuclear@0
|
143 vattr[i].vbo_valid = false;
|
nuclear@0
|
144 vattr[i].data_valid = false;
|
nuclear@0
|
145 //vattr[i].sdr_loc = -1;
|
nuclear@0
|
146 vattr[i].data.clear();
|
nuclear@0
|
147 }
|
nuclear@0
|
148 ibo_valid = idata_valid = false;
|
nuclear@0
|
149 idata.clear();
|
nuclear@0
|
150
|
nuclear@0
|
151 wire_ibo_valid = false;
|
nuclear@0
|
152
|
nuclear@0
|
153 nverts = nfaces = 0;
|
nuclear@0
|
154
|
nuclear@0
|
155 bsph_valid = false;
|
nuclear@0
|
156 aabb_valid = false;
|
nuclear@0
|
157 }
|
nuclear@0
|
158
|
nuclear@0
|
159 float *Mesh::set_attrib_data(int attrib, int nelem, unsigned int num, const float *data)
|
nuclear@0
|
160 {
|
nuclear@0
|
161 if(attrib < 0 || attrib >= NUM_MESH_ATTR) {
|
nuclear@0
|
162 fprintf(stderr, "%s: invalid attrib: %d\n", __FUNCTION__, attrib);
|
nuclear@0
|
163 return 0;
|
nuclear@0
|
164 }
|
nuclear@0
|
165
|
nuclear@0
|
166 if(nverts && num != nverts) {
|
nuclear@0
|
167 fprintf(stderr, "%s: attribute count missmatch (%d instead of %d)\n", __FUNCTION__, num, nverts);
|
nuclear@0
|
168 return 0;
|
nuclear@0
|
169 }
|
nuclear@0
|
170 nverts = num;
|
nuclear@0
|
171
|
nuclear@0
|
172 vattr[attrib].data.clear();
|
nuclear@0
|
173 vattr[attrib].nelem = nelem;
|
nuclear@0
|
174 vattr[attrib].data.resize(num * nelem);
|
nuclear@0
|
175
|
nuclear@0
|
176 if(data) {
|
nuclear@0
|
177 memcpy(&vattr[attrib].data[0], data, num * nelem * sizeof *data);
|
nuclear@0
|
178 }
|
nuclear@0
|
179
|
nuclear@0
|
180 vattr[attrib].data_valid = true;
|
nuclear@0
|
181 vattr[attrib].vbo_valid = false;
|
nuclear@0
|
182 return &vattr[attrib].data[0];
|
nuclear@0
|
183 }
|
nuclear@0
|
184
|
nuclear@0
|
185 float *Mesh::get_attrib_data(int attrib)
|
nuclear@0
|
186 {
|
nuclear@0
|
187 if(attrib < 0 || attrib >= NUM_MESH_ATTR) {
|
nuclear@0
|
188 fprintf(stderr, "%s: invalid attrib: %d\n", __FUNCTION__, attrib);
|
nuclear@0
|
189 return 0;
|
nuclear@0
|
190 }
|
nuclear@0
|
191
|
nuclear@0
|
192 vattr[attrib].vbo_valid = false;
|
nuclear@0
|
193 return (float*)((const Mesh*)this)->get_attrib_data(attrib);
|
nuclear@0
|
194 }
|
nuclear@0
|
195
|
nuclear@0
|
196 const float *Mesh::get_attrib_data(int attrib) const
|
nuclear@0
|
197 {
|
nuclear@0
|
198 if(attrib < 0 || attrib >= NUM_MESH_ATTR) {
|
nuclear@0
|
199 fprintf(stderr, "%s: invalid attrib: %d\n", __FUNCTION__, attrib);
|
nuclear@0
|
200 return 0;
|
nuclear@0
|
201 }
|
nuclear@0
|
202
|
nuclear@0
|
203 if(!vattr[attrib].data_valid) {
|
nuclear@0
|
204 #if GL_ES_VERSION_2_0
|
nuclear@0
|
205 fprintf(stderr, "%s: can't read back attrib data on CrippledGL ES\n", __FUNCTION__);
|
nuclear@0
|
206 return 0;
|
nuclear@0
|
207 #else
|
nuclear@0
|
208 if(!vattr[attrib].vbo_valid) {
|
nuclear@0
|
209 fprintf(stderr, "%s: unavailable attrib: %d\n", __FUNCTION__, attrib);
|
nuclear@0
|
210 return 0;
|
nuclear@0
|
211 }
|
nuclear@0
|
212
|
nuclear@0
|
213 // local data copy is unavailable, grab the data from the vbo
|
nuclear@0
|
214 Mesh *m = (Mesh*)this;
|
nuclear@0
|
215 m->vattr[attrib].data.resize(nverts * vattr[attrib].nelem);
|
nuclear@0
|
216
|
nuclear@0
|
217 glBindBuffer(GL_ARRAY_BUFFER, vattr[attrib].vbo);
|
nuclear@0
|
218 void *data = glMapBuffer(GL_ARRAY_BUFFER, GL_READ_ONLY);
|
nuclear@0
|
219 memcpy(&m->vattr[attrib].data[0], data, nverts * vattr[attrib].nelem * sizeof(float));
|
nuclear@0
|
220 glUnmapBuffer(GL_ARRAY_BUFFER);
|
nuclear@0
|
221
|
nuclear@0
|
222 vattr[attrib].data_valid = true;
|
nuclear@0
|
223 #endif
|
nuclear@0
|
224 }
|
nuclear@0
|
225
|
nuclear@0
|
226 return &vattr[attrib].data[0];
|
nuclear@0
|
227 }
|
nuclear@0
|
228
|
nuclear@0
|
229 void Mesh::set_attrib(int attrib, int idx, const Vector4 &v)
|
nuclear@0
|
230 {
|
nuclear@0
|
231 float *data = get_attrib_data(attrib);
|
nuclear@0
|
232 if(data) {
|
nuclear@0
|
233 data += idx * vattr[attrib].nelem;
|
nuclear@0
|
234 for(int i=0; i<vattr[attrib].nelem; i++) {
|
nuclear@0
|
235 data[i] = v[i];
|
nuclear@0
|
236 }
|
nuclear@0
|
237 }
|
nuclear@0
|
238 }
|
nuclear@0
|
239
|
nuclear@0
|
240 Vector4 Mesh::get_attrib(int attrib, int idx) const
|
nuclear@0
|
241 {
|
nuclear@0
|
242 Vector4 v(0.0, 0.0, 0.0, 1.0);
|
nuclear@0
|
243 const float *data = get_attrib_data(attrib);
|
nuclear@0
|
244 if(data) {
|
nuclear@0
|
245 data += idx * vattr[attrib].nelem;
|
nuclear@0
|
246 for(int i=0; i<vattr[attrib].nelem; i++) {
|
nuclear@0
|
247 v[i] = data[i];
|
nuclear@0
|
248 }
|
nuclear@0
|
249 }
|
nuclear@0
|
250 return v;
|
nuclear@0
|
251 }
|
nuclear@0
|
252
|
nuclear@0
|
253 int Mesh::get_attrib_count(int attrib) const
|
nuclear@0
|
254 {
|
nuclear@0
|
255 return has_attrib(attrib) ? nverts : 0;
|
nuclear@0
|
256 }
|
nuclear@0
|
257
|
nuclear@0
|
258
|
nuclear@0
|
259 unsigned int *Mesh::set_index_data(int num, const unsigned int *indices)
|
nuclear@0
|
260 {
|
nuclear@0
|
261 int nidx = nfaces * 3;
|
nuclear@0
|
262 if(nidx && num != nidx) {
|
nuclear@0
|
263 fprintf(stderr, "%s: index count missmatch (%d instead of %d)\n", __FUNCTION__, num, nidx);
|
nuclear@0
|
264 return 0;
|
nuclear@0
|
265 }
|
nuclear@0
|
266 nfaces = num / 3;
|
nuclear@0
|
267
|
nuclear@0
|
268 idata.clear();
|
nuclear@0
|
269 idata.resize(num);
|
nuclear@0
|
270
|
nuclear@0
|
271 if(indices) {
|
nuclear@0
|
272 memcpy(&idata[0], indices, num * sizeof *indices);
|
nuclear@0
|
273 }
|
nuclear@0
|
274
|
nuclear@0
|
275 idata_valid = true;
|
nuclear@0
|
276 ibo_valid = false;
|
nuclear@0
|
277
|
nuclear@0
|
278 return &idata[0];
|
nuclear@0
|
279 }
|
nuclear@0
|
280
|
nuclear@0
|
281 unsigned int *Mesh::get_index_data()
|
nuclear@0
|
282 {
|
nuclear@0
|
283 ibo_valid = false;
|
nuclear@0
|
284 return (unsigned int*)((const Mesh*)this)->get_index_data();
|
nuclear@0
|
285 }
|
nuclear@0
|
286
|
nuclear@0
|
287 const unsigned int *Mesh::get_index_data() const
|
nuclear@0
|
288 {
|
nuclear@0
|
289 if(!idata_valid) {
|
nuclear@0
|
290 #if GL_ES_VERSION_2_0
|
nuclear@0
|
291 fprintf(stderr, "%s: can't read back index data in CrippledGL ES\n", __FUNCTION__);
|
nuclear@0
|
292 return 0;
|
nuclear@0
|
293 #else
|
nuclear@0
|
294 if(!ibo_valid) {
|
nuclear@0
|
295 fprintf(stderr, "%s: indices unavailable\n", __FUNCTION__);
|
nuclear@0
|
296 return 0;
|
nuclear@0
|
297 }
|
nuclear@0
|
298
|
nuclear@0
|
299 // local data copy is unavailable, gram the data from the ibo
|
nuclear@0
|
300 Mesh *m = (Mesh*)this;
|
nuclear@0
|
301 int nidx = nfaces * 3;
|
nuclear@0
|
302 m->idata.resize(nidx);
|
nuclear@0
|
303
|
nuclear@0
|
304 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
|
nuclear@0
|
305 void *data = glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_READ_ONLY);
|
nuclear@0
|
306 memcpy(&m->idata[0], data, nidx * sizeof(unsigned int));
|
nuclear@0
|
307 glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
|
nuclear@0
|
308
|
nuclear@0
|
309 idata_valid = true;
|
nuclear@0
|
310 #endif
|
nuclear@0
|
311 }
|
nuclear@0
|
312
|
nuclear@0
|
313 return &idata[0];
|
nuclear@0
|
314 }
|
nuclear@0
|
315
|
nuclear@0
|
316 int Mesh::get_index_count() const
|
nuclear@0
|
317 {
|
nuclear@0
|
318 return nfaces * 3;
|
nuclear@0
|
319 }
|
nuclear@0
|
320
|
nuclear@0
|
321 void Mesh::append(const Mesh &mesh)
|
nuclear@0
|
322 {
|
nuclear@0
|
323 unsigned int idxoffs = nverts;
|
nuclear@0
|
324
|
nuclear@7
|
325 if(!nverts) {
|
nuclear@7
|
326 clone(mesh);
|
nuclear@7
|
327 return;
|
nuclear@7
|
328 }
|
nuclear@7
|
329
|
nuclear@0
|
330 nverts += mesh.nverts;
|
nuclear@0
|
331 nfaces += mesh.nfaces;
|
nuclear@0
|
332
|
nuclear@0
|
333 for(int i=0; i<NUM_MESH_ATTR; i++) {
|
nuclear@0
|
334 if(has_attrib(i) && mesh.has_attrib(i)) {
|
nuclear@0
|
335 // force validating the data arrays
|
nuclear@0
|
336 get_attrib_data(i);
|
nuclear@0
|
337 mesh.get_attrib_data(i);
|
nuclear@0
|
338
|
nuclear@0
|
339 // append the mesh data
|
nuclear@0
|
340 vattr[i].data.insert(vattr[i].data.end(), mesh.vattr[i].data.begin(), mesh.vattr[i].data.end());
|
nuclear@0
|
341 }
|
nuclear@0
|
342 }
|
nuclear@0
|
343
|
nuclear@0
|
344 if(ibo_valid || idata_valid) {
|
nuclear@0
|
345 // make index arrays valid
|
nuclear@0
|
346 get_index_data();
|
nuclear@0
|
347 mesh.get_index_data();
|
nuclear@0
|
348
|
nuclear@0
|
349 size_t orig_sz = idata.size();
|
nuclear@0
|
350
|
nuclear@0
|
351 idata.insert(idata.end(), mesh.idata.begin(), mesh.idata.end());
|
nuclear@0
|
352
|
nuclear@0
|
353 // fixup all the new indices
|
nuclear@0
|
354 for(size_t i=orig_sz; i<idata.size(); i++) {
|
nuclear@0
|
355 idata[i] += idxoffs;
|
nuclear@0
|
356 }
|
nuclear@0
|
357 }
|
nuclear@0
|
358
|
nuclear@0
|
359 // fuck everything
|
nuclear@0
|
360 wire_ibo_valid = false;
|
nuclear@0
|
361 aabb_valid = false;
|
nuclear@0
|
362 bsph_valid = false;
|
nuclear@0
|
363 }
|
nuclear@0
|
364
|
nuclear@0
|
365 // assemble a complete vertex by adding all the useful attributes
|
nuclear@0
|
366 void Mesh::vertex(float x, float y, float z)
|
nuclear@0
|
367 {
|
nuclear@0
|
368 cur_val[MESH_ATTR_VERTEX] = Vector4(x, y, z, 1.0f);
|
nuclear@0
|
369 vattr[MESH_ATTR_VERTEX].data_valid = true;
|
nuclear@0
|
370 vattr[MESH_ATTR_VERTEX].nelem = 3;
|
nuclear@0
|
371
|
nuclear@0
|
372 for(int i=0; i<NUM_MESH_ATTR; i++) {
|
nuclear@0
|
373 if(vattr[i].data_valid) {
|
nuclear@0
|
374 for(int j=0; j<vattr[MESH_ATTR_VERTEX].nelem; j++) {
|
nuclear@0
|
375 vattr[i].data.push_back(cur_val[i][j]);
|
nuclear@0
|
376 }
|
nuclear@0
|
377 }
|
nuclear@0
|
378 vattr[i].vbo_valid = false;
|
nuclear@0
|
379 }
|
nuclear@0
|
380
|
nuclear@0
|
381 if(idata_valid) {
|
nuclear@0
|
382 idata.clear();
|
nuclear@0
|
383 }
|
nuclear@0
|
384 ibo_valid = idata_valid = false;
|
nuclear@0
|
385 }
|
nuclear@0
|
386
|
nuclear@0
|
387 void Mesh::normal(float nx, float ny, float nz)
|
nuclear@0
|
388 {
|
nuclear@0
|
389 cur_val[MESH_ATTR_NORMAL] = Vector4(nx, ny, nz, 1.0f);
|
nuclear@0
|
390 vattr[MESH_ATTR_NORMAL].data_valid = true;
|
nuclear@0
|
391 vattr[MESH_ATTR_NORMAL].nelem = 3;
|
nuclear@0
|
392 }
|
nuclear@0
|
393
|
nuclear@0
|
394 void Mesh::tangent(float tx, float ty, float tz)
|
nuclear@0
|
395 {
|
nuclear@0
|
396 cur_val[MESH_ATTR_TANGENT] = Vector4(tx, ty, tz, 1.0f);
|
nuclear@0
|
397 vattr[MESH_ATTR_TANGENT].data_valid = true;
|
nuclear@0
|
398 vattr[MESH_ATTR_TANGENT].nelem = 3;
|
nuclear@0
|
399 }
|
nuclear@0
|
400
|
nuclear@0
|
401 void Mesh::texcoord(float u, float v, float w)
|
nuclear@0
|
402 {
|
nuclear@0
|
403 cur_val[MESH_ATTR_TEXCOORD] = Vector4(u, v, w, 1.0f);
|
nuclear@0
|
404 vattr[MESH_ATTR_TEXCOORD].data_valid = true;
|
nuclear@0
|
405 vattr[MESH_ATTR_TEXCOORD].nelem = 3;
|
nuclear@0
|
406 }
|
nuclear@0
|
407
|
nuclear@0
|
408 void Mesh::boneweights(float w1, float w2, float w3, float w4)
|
nuclear@0
|
409 {
|
nuclear@0
|
410 cur_val[MESH_ATTR_BONEWEIGHTS] = Vector4(w1, w2, w3, w4);
|
nuclear@0
|
411 vattr[MESH_ATTR_BONEWEIGHTS].data_valid = true;
|
nuclear@0
|
412 vattr[MESH_ATTR_BONEWEIGHTS].nelem = 4;
|
nuclear@0
|
413 }
|
nuclear@0
|
414
|
nuclear@0
|
415 void Mesh::boneidx(int idx1, int idx2, int idx3, int idx4)
|
nuclear@0
|
416 {
|
nuclear@0
|
417 cur_val[MESH_ATTR_BONEIDX] = Vector4(idx1, idx2, idx3, idx4);
|
nuclear@0
|
418 vattr[MESH_ATTR_BONEIDX].data_valid = true;
|
nuclear@0
|
419 vattr[MESH_ATTR_BONEIDX].nelem = 4;
|
nuclear@0
|
420 }
|
nuclear@0
|
421
|
nuclear@0
|
422 int Mesh::get_poly_count() const
|
nuclear@0
|
423 {
|
nuclear@0
|
424 if(nfaces) {
|
nuclear@0
|
425 return nfaces;
|
nuclear@0
|
426 }
|
nuclear@0
|
427 if(nverts) {
|
nuclear@0
|
428 return nverts / 3;
|
nuclear@0
|
429 }
|
nuclear@0
|
430 return 0;
|
nuclear@0
|
431 }
|
nuclear@0
|
432
|
nuclear@0
|
433 /// static function
|
nuclear@0
|
434 void Mesh::set_attrib_location(int attr, int loc)
|
nuclear@0
|
435 {
|
nuclear@0
|
436 if(attr < 0 || attr >= NUM_MESH_ATTR) {
|
nuclear@0
|
437 return;
|
nuclear@0
|
438 }
|
nuclear@0
|
439 Mesh::global_sdr_loc[attr] = loc;
|
nuclear@0
|
440 }
|
nuclear@0
|
441
|
nuclear@0
|
442 /// static function
|
nuclear@0
|
443 int Mesh::get_attrib_location(int attr)
|
nuclear@0
|
444 {
|
nuclear@0
|
445 if(attr < 0 || attr >= NUM_MESH_ATTR) {
|
nuclear@0
|
446 return -1;
|
nuclear@0
|
447 }
|
nuclear@0
|
448 return Mesh::global_sdr_loc[attr];
|
nuclear@0
|
449 }
|
nuclear@0
|
450
|
nuclear@0
|
451 /// static function
|
nuclear@0
|
452 void Mesh::clear_attrib_locations()
|
nuclear@0
|
453 {
|
nuclear@0
|
454 for(int i=0; i<NUM_MESH_ATTR; i++) {
|
nuclear@0
|
455 Mesh::global_sdr_loc[i] = -1;
|
nuclear@0
|
456 }
|
nuclear@0
|
457 }
|
nuclear@0
|
458
|
nuclear@0
|
459 /// static function
|
nuclear@0
|
460 void Mesh::set_vis_vecsize(float sz)
|
nuclear@0
|
461 {
|
nuclear@0
|
462 Mesh::vis_vecsize = sz;
|
nuclear@0
|
463 }
|
nuclear@0
|
464
|
nuclear@0
|
465 float Mesh::get_vis_vecsize()
|
nuclear@0
|
466 {
|
nuclear@0
|
467 return Mesh::vis_vecsize;
|
nuclear@0
|
468 }
|
nuclear@0
|
469
|
nuclear@0
|
470 void Mesh::apply_xform(const Matrix4x4 &xform)
|
nuclear@0
|
471 {
|
nuclear@0
|
472 Matrix4x4 dir_xform = xform;
|
nuclear@0
|
473 dir_xform[0][3] = dir_xform[1][3] = dir_xform[2][3] = 0.0f;
|
nuclear@0
|
474 dir_xform[3][0] = dir_xform[3][1] = dir_xform[3][2] = 0.0f;
|
nuclear@0
|
475 dir_xform[3][3] = 1.0f;
|
nuclear@0
|
476
|
nuclear@0
|
477 apply_xform(xform, dir_xform);
|
nuclear@0
|
478 }
|
nuclear@0
|
479
|
nuclear@0
|
480 void Mesh::apply_xform(const Matrix4x4 &xform, const Matrix4x4 &dir_xform)
|
nuclear@0
|
481 {
|
nuclear@0
|
482 for(unsigned int i=0; i<nverts; i++) {
|
nuclear@0
|
483 Vector4 v = get_attrib(MESH_ATTR_VERTEX, i);
|
nuclear@0
|
484 set_attrib(MESH_ATTR_VERTEX, i, v.transformed(xform));
|
nuclear@0
|
485
|
nuclear@0
|
486 if(has_attrib(MESH_ATTR_NORMAL)) {
|
nuclear@0
|
487 Vector3 n = get_attrib(MESH_ATTR_NORMAL, i);
|
nuclear@0
|
488 set_attrib(MESH_ATTR_NORMAL, i, n.transformed(dir_xform));
|
nuclear@0
|
489 }
|
nuclear@0
|
490 if(has_attrib(MESH_ATTR_TANGENT)) {
|
nuclear@0
|
491 Vector3 t = get_attrib(MESH_ATTR_TANGENT, i);
|
nuclear@0
|
492 set_attrib(MESH_ATTR_TANGENT, i, t.transformed(dir_xform));
|
nuclear@0
|
493 }
|
nuclear@0
|
494 }
|
nuclear@0
|
495 }
|
nuclear@0
|
496
|
nuclear@0
|
497 void Mesh::flip()
|
nuclear@0
|
498 {
|
nuclear@0
|
499 flip_faces();
|
nuclear@0
|
500 flip_normals();
|
nuclear@0
|
501 }
|
nuclear@0
|
502
|
nuclear@0
|
503 void Mesh::flip_faces()
|
nuclear@0
|
504 {
|
nuclear@0
|
505 if(is_indexed()) {
|
nuclear@0
|
506 unsigned int *indices = get_index_data();
|
nuclear@0
|
507 if(!indices) return;
|
nuclear@0
|
508
|
nuclear@0
|
509 int idxnum = get_index_count();
|
nuclear@0
|
510 for(int i=0; i<idxnum; i+=3) {
|
nuclear@0
|
511 unsigned int tmp = indices[i + 2];
|
nuclear@0
|
512 indices[i + 2] = indices[i + 1];
|
nuclear@0
|
513 indices[i + 1] = tmp;
|
nuclear@0
|
514 }
|
nuclear@0
|
515
|
nuclear@0
|
516 } else {
|
nuclear@0
|
517 Vector3 *verts = (Vector3*)get_attrib_data(MESH_ATTR_VERTEX);
|
nuclear@0
|
518 if(!verts) return;
|
nuclear@0
|
519
|
nuclear@0
|
520 int vnum = get_attrib_count(MESH_ATTR_VERTEX);
|
nuclear@0
|
521 for(int i=0; i<vnum; i+=3) {
|
nuclear@0
|
522 Vector3 tmp = verts[i + 2];
|
nuclear@0
|
523 verts[i + 2] = verts[i + 1];
|
nuclear@0
|
524 verts[i + 1] = tmp;
|
nuclear@0
|
525 }
|
nuclear@0
|
526 }
|
nuclear@0
|
527 }
|
nuclear@0
|
528
|
nuclear@0
|
529 void Mesh::flip_normals()
|
nuclear@0
|
530 {
|
nuclear@0
|
531 Vector3 *normals = (Vector3*)get_attrib_data(MESH_ATTR_NORMAL);
|
nuclear@0
|
532 if(!normals) return;
|
nuclear@0
|
533
|
nuclear@0
|
534 int num = get_attrib_count(MESH_ATTR_NORMAL);
|
nuclear@0
|
535 for(int i=0; i<num; i++) {
|
nuclear@0
|
536 normals[i] = -normals[i];
|
nuclear@0
|
537 }
|
nuclear@0
|
538 }
|
nuclear@0
|
539
|
nuclear@0
|
540 /*
|
nuclear@0
|
541 int Mesh::add_bone(XFormNode *bone)
|
nuclear@0
|
542 {
|
nuclear@0
|
543 int idx = bones.size();
|
nuclear@0
|
544 bones.push_back(bone);
|
nuclear@0
|
545 return idx;
|
nuclear@0
|
546 }
|
nuclear@0
|
547
|
nuclear@0
|
548 const XFormNode *Mesh::get_bone(int idx) const
|
nuclear@0
|
549 {
|
nuclear@0
|
550 if(idx < 0 || idx >= (int)bones.size()) {
|
nuclear@0
|
551 return 0;
|
nuclear@0
|
552 }
|
nuclear@0
|
553 return bones[idx];
|
nuclear@0
|
554 }
|
nuclear@0
|
555
|
nuclear@0
|
556 int Mesh::get_bones_count() const
|
nuclear@0
|
557 {
|
nuclear@0
|
558 return (int)bones.size();
|
nuclear@0
|
559 }
|
nuclear@0
|
560 */
|
nuclear@0
|
561
|
nuclear@0
|
562 void Mesh::draw() const
|
nuclear@0
|
563 {
|
nuclear@1
|
564 int cur_sdr;
|
nuclear@1
|
565 glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr);
|
nuclear@1
|
566
|
nuclear@0
|
567
|
nuclear@0
|
568 ((Mesh*)this)->update_buffers();
|
nuclear@0
|
569
|
nuclear@0
|
570 if(!vattr[MESH_ATTR_VERTEX].vbo_valid) {
|
nuclear@0
|
571 fprintf(stderr, "%s: invalid vertex buffer\n", __FUNCTION__);
|
nuclear@0
|
572 return;
|
nuclear@0
|
573 }
|
nuclear@0
|
574
|
nuclear@1
|
575 if(cur_sdr) {
|
nuclear@0
|
576 // rendering with shaders
|
nuclear@0
|
577 if(global_sdr_loc[MESH_ATTR_VERTEX] == -1) {
|
nuclear@0
|
578 fprintf(stderr, "%s: shader attribute location for vertices unset\n", __FUNCTION__);
|
nuclear@0
|
579 return;
|
nuclear@0
|
580 }
|
nuclear@0
|
581
|
nuclear@0
|
582 for(int i=0; i<NUM_MESH_ATTR; i++) {
|
nuclear@0
|
583 int loc = global_sdr_loc[i];
|
nuclear@0
|
584 if(loc >= 0 && vattr[i].vbo_valid) {
|
nuclear@0
|
585 glBindBuffer(GL_ARRAY_BUFFER, vattr[i].vbo);
|
nuclear@0
|
586 glVertexAttribPointer(loc, vattr[i].nelem, GL_FLOAT, GL_FALSE, 0, 0);
|
nuclear@0
|
587 glEnableVertexAttribArray(loc);
|
nuclear@0
|
588 }
|
nuclear@0
|
589 }
|
nuclear@0
|
590 } else {
|
nuclear@0
|
591 #ifndef GL_ES_VERSION_2_0
|
nuclear@0
|
592 // rendering with fixed-function (not available in GLES2)
|
nuclear@0
|
593 glBindBuffer(GL_ARRAY_BUFFER, vattr[MESH_ATTR_VERTEX].vbo);
|
nuclear@0
|
594 glVertexPointer(vattr[MESH_ATTR_VERTEX].nelem, GL_FLOAT, 0, 0);
|
nuclear@0
|
595 glEnableClientState(GL_VERTEX_ARRAY);
|
nuclear@0
|
596
|
nuclear@0
|
597 if(vattr[MESH_ATTR_NORMAL].vbo_valid) {
|
nuclear@0
|
598 glBindBuffer(GL_ARRAY_BUFFER, vattr[MESH_ATTR_NORMAL].vbo);
|
nuclear@0
|
599 glNormalPointer(GL_FLOAT, 0, 0);
|
nuclear@0
|
600 glEnableClientState(GL_NORMAL_ARRAY);
|
nuclear@0
|
601 }
|
nuclear@0
|
602 if(vattr[MESH_ATTR_TEXCOORD].vbo_valid) {
|
nuclear@0
|
603 glBindBuffer(GL_ARRAY_BUFFER, vattr[MESH_ATTR_TEXCOORD].vbo);
|
nuclear@0
|
604 glTexCoordPointer(vattr[MESH_ATTR_TEXCOORD].nelem, GL_FLOAT, 0, 0);
|
nuclear@0
|
605 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
|
nuclear@0
|
606 }
|
nuclear@0
|
607 if(vattr[MESH_ATTR_COLOR].vbo_valid) {
|
nuclear@0
|
608 glBindBuffer(GL_ARRAY_BUFFER, vattr[MESH_ATTR_COLOR].vbo);
|
nuclear@0
|
609 glColorPointer(vattr[MESH_ATTR_COLOR].nelem, GL_FLOAT, 0, 0);
|
nuclear@0
|
610 glEnableClientState(GL_COLOR_ARRAY);
|
nuclear@0
|
611 }
|
nuclear@0
|
612 #endif
|
nuclear@0
|
613 }
|
nuclear@0
|
614 glBindBuffer(GL_ARRAY_BUFFER, 0);
|
nuclear@0
|
615
|
nuclear@0
|
616 if(ibo_valid) {
|
nuclear@0
|
617 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
|
nuclear@0
|
618 glDrawElements(GL_TRIANGLES, nfaces * 3, GL_UNSIGNED_INT, 0);
|
nuclear@0
|
619 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
|
nuclear@0
|
620 } else {
|
nuclear@0
|
621 glDrawArrays(GL_TRIANGLES, 0, nverts);
|
nuclear@0
|
622 }
|
nuclear@0
|
623
|
nuclear@1
|
624 if(cur_sdr) {
|
nuclear@0
|
625 // rendered with shaders
|
nuclear@0
|
626 for(int i=0; i<NUM_MESH_ATTR; i++) {
|
nuclear@0
|
627 int loc = global_sdr_loc[i];
|
nuclear@0
|
628 if(loc >= 0 && vattr[i].vbo_valid) {
|
nuclear@0
|
629 glDisableVertexAttribArray(loc);
|
nuclear@0
|
630 }
|
nuclear@0
|
631 }
|
nuclear@0
|
632 } else {
|
nuclear@0
|
633 #ifndef GL_ES_VERSION_2_0
|
nuclear@0
|
634 // rendered with fixed-function
|
nuclear@0
|
635 glDisableClientState(GL_VERTEX_ARRAY);
|
nuclear@0
|
636 if(vattr[MESH_ATTR_NORMAL].vbo_valid) {
|
nuclear@0
|
637 glDisableClientState(GL_NORMAL_ARRAY);
|
nuclear@0
|
638 }
|
nuclear@0
|
639 if(vattr[MESH_ATTR_TEXCOORD].vbo_valid) {
|
nuclear@0
|
640 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
|
nuclear@0
|
641 }
|
nuclear@0
|
642 if(vattr[MESH_ATTR_COLOR].vbo_valid) {
|
nuclear@0
|
643 glDisableClientState(GL_COLOR_ARRAY);
|
nuclear@0
|
644 }
|
nuclear@0
|
645 #endif
|
nuclear@0
|
646 }
|
nuclear@0
|
647 }
|
nuclear@0
|
648
|
nuclear@0
|
649 void Mesh::draw_wire() const
|
nuclear@0
|
650 {
|
nuclear@0
|
651 ((Mesh*)this)->update_wire_ibo();
|
nuclear@0
|
652
|
nuclear@0
|
653 if(!vattr[MESH_ATTR_VERTEX].vbo_valid || !wire_ibo_valid) {
|
nuclear@0
|
654 fprintf(stderr, "%s: invalid vertex buffer\n", __FUNCTION__);
|
nuclear@0
|
655 return;
|
nuclear@0
|
656 }
|
nuclear@0
|
657 if(global_sdr_loc[MESH_ATTR_VERTEX] == -1) {
|
nuclear@0
|
658 fprintf(stderr, "%s: shader attribute location for vertices unset\n", __FUNCTION__);
|
nuclear@0
|
659 return;
|
nuclear@0
|
660 }
|
nuclear@0
|
661
|
nuclear@0
|
662 for(int i=0; i<NUM_MESH_ATTR; i++) {
|
nuclear@0
|
663 int loc = global_sdr_loc[i];
|
nuclear@0
|
664 if(loc >= 0 && vattr[i].vbo_valid) {
|
nuclear@0
|
665 glBindBuffer(GL_ARRAY_BUFFER, vattr[i].vbo);
|
nuclear@0
|
666 glVertexAttribPointer(loc, vattr[i].nelem, GL_FLOAT, GL_FALSE, 0, 0);
|
nuclear@0
|
667 glEnableVertexAttribArray(loc);
|
nuclear@0
|
668 }
|
nuclear@0
|
669 }
|
nuclear@0
|
670 glBindBuffer(GL_ARRAY_BUFFER, 0);
|
nuclear@0
|
671
|
nuclear@0
|
672 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, wire_ibo);
|
nuclear@0
|
673 glDrawElements(GL_LINES, nfaces * 6, GL_UNSIGNED_INT, 0);
|
nuclear@0
|
674 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
|
nuclear@0
|
675
|
nuclear@0
|
676 for(int i=0; i<NUM_MESH_ATTR; i++) {
|
nuclear@0
|
677 int loc = global_sdr_loc[i];
|
nuclear@0
|
678 if(loc >= 0 && vattr[i].vbo_valid) {
|
nuclear@0
|
679 glDisableVertexAttribArray(loc);
|
nuclear@0
|
680 }
|
nuclear@0
|
681 }
|
nuclear@0
|
682 }
|
nuclear@0
|
683
|
nuclear@0
|
684 void Mesh::draw_vertices() const
|
nuclear@0
|
685 {
|
nuclear@0
|
686 ((Mesh*)this)->update_buffers();
|
nuclear@0
|
687
|
nuclear@0
|
688 if(!vattr[MESH_ATTR_VERTEX].vbo_valid) {
|
nuclear@0
|
689 fprintf(stderr, "%s: invalid vertex buffer\n", __FUNCTION__);
|
nuclear@0
|
690 return;
|
nuclear@0
|
691 }
|
nuclear@0
|
692 if(global_sdr_loc[MESH_ATTR_VERTEX] == -1) {
|
nuclear@0
|
693 fprintf(stderr, "%s: shader attribute location for vertices unset\n", __FUNCTION__);
|
nuclear@0
|
694 return;
|
nuclear@0
|
695 }
|
nuclear@0
|
696
|
nuclear@0
|
697 for(int i=0; i<NUM_MESH_ATTR; i++) {
|
nuclear@0
|
698 int loc = global_sdr_loc[i];
|
nuclear@0
|
699 if(loc >= 0 && vattr[i].vbo_valid) {
|
nuclear@0
|
700 glBindBuffer(GL_ARRAY_BUFFER, vattr[i].vbo);
|
nuclear@0
|
701 glVertexAttribPointer(loc, vattr[i].nelem, GL_FLOAT, GL_FALSE, 0, 0);
|
nuclear@0
|
702 glEnableVertexAttribArray(loc);
|
nuclear@0
|
703 }
|
nuclear@0
|
704 }
|
nuclear@0
|
705 glBindBuffer(GL_ARRAY_BUFFER, 0);
|
nuclear@0
|
706
|
nuclear@0
|
707 glDrawArrays(GL_POINTS, 0, nverts);
|
nuclear@0
|
708
|
nuclear@0
|
709 for(int i=0; i<NUM_MESH_ATTR; i++) {
|
nuclear@0
|
710 int loc = global_sdr_loc[i];
|
nuclear@0
|
711 if(loc >= 0 && vattr[i].vbo_valid) {
|
nuclear@0
|
712 glDisableVertexAttribArray(loc);
|
nuclear@0
|
713 }
|
nuclear@0
|
714 }
|
nuclear@0
|
715 }
|
nuclear@0
|
716
|
nuclear@0
|
717 void Mesh::draw_normals() const
|
nuclear@0
|
718 {
|
nuclear@0
|
719 #ifdef USE_OLDGL
|
nuclear@0
|
720 Vector3 *varr = (Vector3*)get_attrib_data(MESH_ATTR_VERTEX);
|
nuclear@0
|
721 Vector3 *norm = (Vector3*)get_attrib_data(MESH_ATTR_NORMAL);
|
nuclear@0
|
722 if(!varr || !norm) {
|
nuclear@0
|
723 return;
|
nuclear@0
|
724 }
|
nuclear@0
|
725
|
nuclear@0
|
726 glBegin(GL_LINES);
|
nuclear@0
|
727 if(get_current_shader()) {
|
nuclear@0
|
728 int vert_loc = global_sdr_loc[MESH_ATTR_VERTEX];
|
nuclear@0
|
729 if(vert_loc < 0) {
|
nuclear@0
|
730 glEnd();
|
nuclear@0
|
731 return;
|
nuclear@0
|
732 }
|
nuclear@0
|
733
|
nuclear@0
|
734 for(size_t i=0; i<nverts; i++) {
|
nuclear@0
|
735 glVertexAttrib3f(vert_loc, varr[i].x, varr[i].y, varr[i].z);
|
nuclear@0
|
736 Vector3 end = varr[i] + norm[i] * vis_vecsize;
|
nuclear@0
|
737 glVertexAttrib3f(vert_loc, end.x, end.y, end.z);
|
nuclear@0
|
738 }
|
nuclear@0
|
739 } else {
|
nuclear@0
|
740 for(size_t i=0; i<nverts; i++) {
|
nuclear@0
|
741 glVertex3f(varr[i].x, varr[i].y, varr[i].z);
|
nuclear@0
|
742 Vector3 end = varr[i] + norm[i] * vis_vecsize;
|
nuclear@0
|
743 glVertex3f(end.x, end.y, end.z);
|
nuclear@0
|
744 }
|
nuclear@0
|
745 }
|
nuclear@0
|
746 glEnd();
|
nuclear@0
|
747 #endif // USE_OLDGL
|
nuclear@0
|
748 }
|
nuclear@0
|
749
|
nuclear@0
|
750 void Mesh::draw_tangents() const
|
nuclear@0
|
751 {
|
nuclear@0
|
752 #ifdef USE_OLDGL
|
nuclear@0
|
753 Vector3 *varr = (Vector3*)get_attrib_data(MESH_ATTR_VERTEX);
|
nuclear@0
|
754 Vector3 *tang = (Vector3*)get_attrib_data(MESH_ATTR_TANGENT);
|
nuclear@0
|
755 if(!varr || !tang) {
|
nuclear@0
|
756 return;
|
nuclear@0
|
757 }
|
nuclear@0
|
758
|
nuclear@0
|
759 glBegin(GL_LINES);
|
nuclear@0
|
760 if(get_current_shader()) {
|
nuclear@0
|
761 int vert_loc = global_sdr_loc[MESH_ATTR_VERTEX];
|
nuclear@0
|
762 if(vert_loc < 0) {
|
nuclear@0
|
763 glEnd();
|
nuclear@0
|
764 return;
|
nuclear@0
|
765 }
|
nuclear@0
|
766
|
nuclear@0
|
767 for(size_t i=0; i<nverts; i++) {
|
nuclear@0
|
768 glVertexAttrib3f(vert_loc, varr[i].x, varr[i].y, varr[i].z);
|
nuclear@0
|
769 Vector3 end = varr[i] + tang[i] * vis_vecsize;
|
nuclear@0
|
770 glVertexAttrib3f(vert_loc, end.x, end.y, end.z);
|
nuclear@0
|
771 }
|
nuclear@0
|
772 } else {
|
nuclear@0
|
773 for(size_t i=0; i<nverts; i++) {
|
nuclear@0
|
774 glVertex3f(varr[i].x, varr[i].y, varr[i].z);
|
nuclear@0
|
775 Vector3 end = varr[i] + tang[i] * vis_vecsize;
|
nuclear@0
|
776 glVertex3f(end.x, end.y, end.z);
|
nuclear@0
|
777 }
|
nuclear@0
|
778 }
|
nuclear@0
|
779 glEnd();
|
nuclear@0
|
780 #endif // USE_OLDGL
|
nuclear@0
|
781 }
|
nuclear@0
|
782
|
nuclear@0
|
783 void Mesh::get_aabbox(Vector3 *vmin, Vector3 *vmax) const
|
nuclear@0
|
784 {
|
nuclear@0
|
785 if(!aabb_valid) {
|
nuclear@0
|
786 ((Mesh*)this)->calc_aabb();
|
nuclear@0
|
787 }
|
nuclear@0
|
788 *vmin = aabb.min;
|
nuclear@0
|
789 *vmax = aabb.max;
|
nuclear@0
|
790 }
|
nuclear@0
|
791
|
nuclear@0
|
792 const AABox &Mesh::get_aabbox() const
|
nuclear@0
|
793 {
|
nuclear@0
|
794 if(!aabb_valid) {
|
nuclear@0
|
795 ((Mesh*)this)->calc_aabb();
|
nuclear@0
|
796 }
|
nuclear@0
|
797 return aabb;
|
nuclear@0
|
798 }
|
nuclear@0
|
799
|
nuclear@0
|
800 float Mesh::get_bsphere(Vector3 *center, float *rad) const
|
nuclear@0
|
801 {
|
nuclear@0
|
802 if(!bsph_valid) {
|
nuclear@0
|
803 ((Mesh*)this)->calc_bsph();
|
nuclear@0
|
804 }
|
nuclear@0
|
805 *center = bsph.center;
|
nuclear@0
|
806 *rad = bsph.radius;
|
nuclear@0
|
807 return bsph.radius;
|
nuclear@0
|
808 }
|
nuclear@0
|
809
|
nuclear@0
|
810 const Sphere &Mesh::get_bsphere() const
|
nuclear@0
|
811 {
|
nuclear@0
|
812 if(!bsph_valid) {
|
nuclear@0
|
813 ((Mesh*)this)->calc_bsph();
|
nuclear@0
|
814 }
|
nuclear@0
|
815 return bsph;
|
nuclear@0
|
816 }
|
nuclear@0
|
817
|
nuclear@0
|
818 /// static function
|
nuclear@0
|
819 void Mesh::set_intersect_mode(unsigned int mode)
|
nuclear@0
|
820 {
|
nuclear@0
|
821 Mesh::intersect_mode = mode;
|
nuclear@0
|
822 }
|
nuclear@0
|
823
|
nuclear@0
|
824 /// static function
|
nuclear@0
|
825 unsigned int Mesh::get_intersect_mode()
|
nuclear@0
|
826 {
|
nuclear@0
|
827 return Mesh::intersect_mode;
|
nuclear@0
|
828 }
|
nuclear@0
|
829
|
nuclear@0
|
830 /// static function
|
nuclear@0
|
831 void Mesh::set_vertex_select_distance(float dist)
|
nuclear@0
|
832 {
|
nuclear@0
|
833 Mesh::vertex_sel_dist = dist;
|
nuclear@0
|
834 }
|
nuclear@0
|
835
|
nuclear@0
|
836 /// static function
|
nuclear@0
|
837 float Mesh::get_vertex_select_distance()
|
nuclear@0
|
838 {
|
nuclear@0
|
839 return Mesh::vertex_sel_dist;
|
nuclear@0
|
840 }
|
nuclear@0
|
841
|
nuclear@0
|
842 bool Mesh::intersect(const Ray &ray, HitPoint *hit) const
|
nuclear@0
|
843 {
|
nuclear@0
|
844 assert((Mesh::intersect_mode & (ISECT_VERTICES | ISECT_FACE)) != (ISECT_VERTICES | ISECT_FACE));
|
nuclear@0
|
845
|
nuclear@0
|
846 const Vector3 *varr = (Vector3*)get_attrib_data(MESH_ATTR_VERTEX);
|
nuclear@0
|
847 const Vector3 *narr = (Vector3*)get_attrib_data(MESH_ATTR_NORMAL);
|
nuclear@0
|
848 if(!varr) {
|
nuclear@0
|
849 return false;
|
nuclear@0
|
850 }
|
nuclear@0
|
851 const unsigned int *idxarr = get_index_data();
|
nuclear@0
|
852
|
nuclear@0
|
853 // first test with the bounding box
|
nuclear@0
|
854 AABox box;
|
nuclear@0
|
855 get_aabbox(&box.min, &box.max);
|
nuclear@0
|
856 if(!box.intersect(ray)) {
|
nuclear@0
|
857 return false;
|
nuclear@0
|
858 }
|
nuclear@0
|
859
|
nuclear@0
|
860 HitPoint nearest_hit;
|
nuclear@0
|
861 nearest_hit.dist = FLT_MAX;
|
nuclear@0
|
862 nearest_hit.obj = 0;
|
nuclear@0
|
863
|
nuclear@0
|
864 if(Mesh::intersect_mode & ISECT_VERTICES) {
|
nuclear@0
|
865 // we asked for "intersections" with the vertices of the mesh
|
nuclear@0
|
866 long nearest_vidx = -1;
|
nuclear@0
|
867 float thres_sq = Mesh::vertex_sel_dist * Mesh::vertex_sel_dist;
|
nuclear@0
|
868
|
nuclear@0
|
869 for(unsigned int i=0; i<nverts; i++) {
|
nuclear@0
|
870
|
nuclear@0
|
871 if((Mesh::intersect_mode & ISECT_FRONT) && dot_product(narr[i], ray.dir) > 0) {
|
nuclear@0
|
872 continue;
|
nuclear@0
|
873 }
|
nuclear@0
|
874
|
nuclear@0
|
875 // project the vertex onto the ray line
|
nuclear@0
|
876 float t = dot_product(varr[i] - ray.origin, ray.dir);
|
nuclear@0
|
877 Vector3 vproj = ray.origin + ray.dir * t;
|
nuclear@0
|
878
|
nuclear@0
|
879 float dist_sq = (vproj - varr[i]).length_sq();
|
nuclear@0
|
880 if(dist_sq < thres_sq) {
|
nuclear@0
|
881 if(!hit) {
|
nuclear@0
|
882 return true;
|
nuclear@0
|
883 }
|
nuclear@0
|
884 if(t < nearest_hit.dist) {
|
nuclear@0
|
885 nearest_hit.dist = t;
|
nuclear@0
|
886 nearest_vidx = i;
|
nuclear@0
|
887 }
|
nuclear@0
|
888 }
|
nuclear@0
|
889 }
|
nuclear@0
|
890
|
nuclear@0
|
891 if(nearest_vidx != -1) {
|
nuclear@0
|
892 hitvert = varr[nearest_vidx];
|
nuclear@0
|
893 nearest_hit.obj = &hitvert;
|
nuclear@0
|
894 }
|
nuclear@0
|
895
|
nuclear@0
|
896 } else {
|
nuclear@0
|
897 // regular intersection test with polygons
|
nuclear@0
|
898
|
nuclear@0
|
899 for(unsigned int i=0; i<nfaces; i++) {
|
nuclear@0
|
900 Triangle face(i, varr, idxarr);
|
nuclear@0
|
901
|
nuclear@0
|
902 // ignore back-facing polygons if the mode flags include ISECT_FRONT
|
nuclear@0
|
903 if((Mesh::intersect_mode & ISECT_FRONT) && dot_product(face.get_normal(), ray.dir) > 0) {
|
nuclear@0
|
904 continue;
|
nuclear@0
|
905 }
|
nuclear@0
|
906
|
nuclear@0
|
907 HitPoint fhit;
|
nuclear@0
|
908 if(face.intersect(ray, hit ? &fhit : 0)) {
|
nuclear@0
|
909 if(!hit) {
|
nuclear@0
|
910 return true;
|
nuclear@0
|
911 }
|
nuclear@0
|
912 if(fhit.dist < nearest_hit.dist) {
|
nuclear@0
|
913 nearest_hit = fhit;
|
nuclear@0
|
914 hitface = face;
|
nuclear@0
|
915 }
|
nuclear@0
|
916 }
|
nuclear@0
|
917 }
|
nuclear@0
|
918 }
|
nuclear@0
|
919
|
nuclear@0
|
920 if(nearest_hit.obj) {
|
nuclear@0
|
921 if(hit) {
|
nuclear@0
|
922 *hit = nearest_hit;
|
nuclear@0
|
923
|
nuclear@0
|
924 // if we are interested in the mesh and not the faces set obj to this
|
nuclear@0
|
925 if(Mesh::intersect_mode & ISECT_FACE) {
|
nuclear@0
|
926 hit->obj = &hitface;
|
nuclear@0
|
927 } else if(Mesh::intersect_mode & ISECT_VERTICES) {
|
nuclear@0
|
928 hit->obj = &hitvert;
|
nuclear@0
|
929 } else {
|
nuclear@0
|
930 hit->obj = this;
|
nuclear@0
|
931 }
|
nuclear@0
|
932 }
|
nuclear@0
|
933 return true;
|
nuclear@0
|
934 }
|
nuclear@0
|
935 return false;
|
nuclear@0
|
936 }
|
nuclear@0
|
937
|
nuclear@0
|
938
|
nuclear@6
|
939 // texture coordinate manipulation
|
nuclear@6
|
940 void Mesh::texcoord_apply_xform(const Matrix4x4 &xform)
|
nuclear@6
|
941 {
|
nuclear@6
|
942 if(!has_attrib(MESH_ATTR_TEXCOORD)) {
|
nuclear@6
|
943 return;
|
nuclear@6
|
944 }
|
nuclear@6
|
945
|
nuclear@6
|
946 for(unsigned int i=0; i<nverts; i++) {
|
nuclear@6
|
947 Vector4 tc = get_attrib(MESH_ATTR_TEXCOORD, i);
|
nuclear@6
|
948 set_attrib(MESH_ATTR_TEXCOORD, i, tc.transformed(xform));
|
nuclear@6
|
949 }
|
nuclear@6
|
950 }
|
nuclear@6
|
951
|
nuclear@6
|
952 void Mesh::texcoord_gen_plane(const Vector3 &norm, const Vector3 &tang)
|
nuclear@6
|
953 {
|
nuclear@6
|
954 if(!nverts) return;
|
nuclear@6
|
955
|
nuclear@6
|
956 if(!has_attrib(MESH_ATTR_TEXCOORD)) {
|
nuclear@6
|
957 // allocate texture coordinate attribute array
|
nuclear@6
|
958 set_attrib_data(MESH_ATTR_TEXCOORD, 2, nverts);
|
nuclear@6
|
959 }
|
nuclear@6
|
960
|
nuclear@6
|
961 Vector3 n = norm.normalized();
|
nuclear@6
|
962 Vector3 b = cross_product(n, tang).normalized();
|
nuclear@6
|
963 Vector3 t = cross_product(b, n);
|
nuclear@6
|
964
|
nuclear@6
|
965 for(unsigned int i=0; i<nverts; i++) {
|
nuclear@6
|
966 Vector3 pos = get_attrib(MESH_ATTR_VERTEX, i);
|
nuclear@6
|
967
|
nuclear@6
|
968 // distance along the tangent direction
|
nuclear@6
|
969 float u = dot_product(pos, t);
|
nuclear@6
|
970 // distance along the bitangent direction
|
nuclear@6
|
971 float v = dot_product(pos, b);
|
nuclear@6
|
972
|
nuclear@6
|
973 set_attrib(MESH_ATTR_TEXCOORD, i, Vector4(u, v, 0, 1));
|
nuclear@6
|
974 }
|
nuclear@6
|
975 }
|
nuclear@6
|
976
|
nuclear@6
|
977 void Mesh::texcoord_gen_box()
|
nuclear@6
|
978 {
|
nuclear@6
|
979 if(!nverts || !has_attrib(MESH_ATTR_NORMAL)) return;
|
nuclear@6
|
980
|
nuclear@6
|
981 if(!has_attrib(MESH_ATTR_TEXCOORD)) {
|
nuclear@6
|
982 // allocate texture coordinate attribute array
|
nuclear@6
|
983 set_attrib_data(MESH_ATTR_TEXCOORD, 2, nverts);
|
nuclear@6
|
984 }
|
nuclear@6
|
985
|
nuclear@6
|
986 for(unsigned int i=0; i<nverts; i++) {
|
nuclear@6
|
987 Vector3 pos = Vector3(get_attrib(MESH_ATTR_VERTEX, i)) * 0.5 + Vector3(0.5, 0.5, 0.5);
|
nuclear@6
|
988 Vector3 norm = get_attrib(MESH_ATTR_NORMAL, i);
|
nuclear@6
|
989
|
nuclear@6
|
990 float abs_nx = fabs(norm.x);
|
nuclear@6
|
991 float abs_ny = fabs(norm.y);
|
nuclear@6
|
992 float abs_nz = fabs(norm.z);
|
nuclear@6
|
993 int dom = abs_nx > abs_ny && abs_nx > abs_nz ? 0 : (abs_ny > abs_nz ? 1 : 2);
|
nuclear@6
|
994
|
nuclear@6
|
995 float uv[2], *uvptr = uv;
|
nuclear@6
|
996 for(int j=0; j<3; j++) {
|
nuclear@6
|
997 if(j == dom) continue; // skip dominant axis
|
nuclear@6
|
998
|
nuclear@6
|
999 *uvptr++ = pos[j];
|
nuclear@6
|
1000 }
|
nuclear@6
|
1001 set_attrib(MESH_ATTR_TEXCOORD, i, Vector4(uv[0], uv[1], 0, 1));
|
nuclear@6
|
1002 }
|
nuclear@6
|
1003 }
|
nuclear@6
|
1004
|
nuclear@0
|
1005 // ------ private member functions ------
|
nuclear@0
|
1006
|
nuclear@0
|
1007 void Mesh::calc_aabb()
|
nuclear@0
|
1008 {
|
nuclear@0
|
1009 // the cast is to force calling the const version which doesn't invalidate
|
nuclear@0
|
1010 if(!((const Mesh*)this)->get_attrib_data(MESH_ATTR_VERTEX)) {
|
nuclear@0
|
1011 return;
|
nuclear@0
|
1012 }
|
nuclear@0
|
1013
|
nuclear@0
|
1014 aabb.min = Vector3(FLT_MAX, FLT_MAX, FLT_MAX);
|
nuclear@0
|
1015 aabb.max = -aabb.min;
|
nuclear@0
|
1016
|
nuclear@0
|
1017 for(unsigned int i=0; i<nverts; i++) {
|
nuclear@0
|
1018 Vector4 v = get_attrib(MESH_ATTR_VERTEX, i);
|
nuclear@0
|
1019 for(int j=0; j<3; j++) {
|
nuclear@0
|
1020 if(v[j] < aabb.min[j]) {
|
nuclear@0
|
1021 aabb.min[j] = v[j];
|
nuclear@0
|
1022 }
|
nuclear@0
|
1023 if(v[j] > aabb.max[j]) {
|
nuclear@0
|
1024 aabb.max[j] = v[j];
|
nuclear@0
|
1025 }
|
nuclear@0
|
1026 }
|
nuclear@0
|
1027 }
|
nuclear@0
|
1028 aabb_valid = true;
|
nuclear@0
|
1029 }
|
nuclear@0
|
1030
|
nuclear@0
|
1031 void Mesh::calc_bsph()
|
nuclear@0
|
1032 {
|
nuclear@0
|
1033 // the cast is to force calling the const version which doesn't invalidate
|
nuclear@0
|
1034 if(!((const Mesh*)this)->get_attrib_data(MESH_ATTR_VERTEX)) {
|
nuclear@0
|
1035 return;
|
nuclear@0
|
1036 }
|
nuclear@0
|
1037
|
nuclear@0
|
1038 Vector3 v;
|
nuclear@0
|
1039 bsph.center = Vector3(0, 0, 0);
|
nuclear@0
|
1040
|
nuclear@0
|
1041 // first find the center
|
nuclear@0
|
1042 for(unsigned int i=0; i<nverts; i++) {
|
nuclear@0
|
1043 v = get_attrib(MESH_ATTR_VERTEX, i);
|
nuclear@0
|
1044 bsph.center += v;
|
nuclear@0
|
1045 }
|
nuclear@0
|
1046 bsph.center /= (float)nverts;
|
nuclear@0
|
1047
|
nuclear@0
|
1048 bsph.radius = 0.0f;
|
nuclear@0
|
1049 for(unsigned int i=0; i<nverts; i++) {
|
nuclear@0
|
1050 v = get_attrib(MESH_ATTR_VERTEX, i);
|
nuclear@0
|
1051 float dist_sq = (v - bsph.center).length_sq();
|
nuclear@0
|
1052 if(dist_sq > bsph.radius) {
|
nuclear@0
|
1053 bsph.radius = dist_sq;
|
nuclear@0
|
1054 }
|
nuclear@0
|
1055 }
|
nuclear@0
|
1056 bsph.radius = sqrt(bsph.radius);
|
nuclear@0
|
1057
|
nuclear@0
|
1058 bsph_valid = true;
|
nuclear@0
|
1059 }
|
nuclear@0
|
1060
|
nuclear@0
|
1061 void Mesh::update_buffers()
|
nuclear@0
|
1062 {
|
nuclear@0
|
1063 for(int i=0; i<NUM_MESH_ATTR; i++) {
|
nuclear@0
|
1064 if(has_attrib(i) && !vattr[i].vbo_valid) {
|
nuclear@0
|
1065 glBindBuffer(GL_ARRAY_BUFFER, vattr[i].vbo);
|
nuclear@0
|
1066 glBufferData(GL_ARRAY_BUFFER, nverts * vattr[i].nelem * sizeof(float), &vattr[i].data[0], GL_STATIC_DRAW);
|
nuclear@0
|
1067 vattr[i].vbo_valid = true;
|
nuclear@0
|
1068 }
|
nuclear@0
|
1069 }
|
nuclear@0
|
1070 glBindBuffer(GL_ARRAY_BUFFER, 0);
|
nuclear@0
|
1071
|
nuclear@0
|
1072 if(idata_valid && !ibo_valid) {
|
nuclear@0
|
1073 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
|
nuclear@0
|
1074 glBufferData(GL_ELEMENT_ARRAY_BUFFER, nfaces * 3 * sizeof(unsigned int), &idata[0], GL_STATIC_DRAW);
|
nuclear@0
|
1075 ibo_valid = true;
|
nuclear@0
|
1076 }
|
nuclear@0
|
1077 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
|
nuclear@0
|
1078 }
|
nuclear@0
|
1079
|
nuclear@0
|
1080 void Mesh::update_wire_ibo()
|
nuclear@0
|
1081 {
|
nuclear@0
|
1082 update_buffers();
|
nuclear@0
|
1083
|
nuclear@0
|
1084 if(wire_ibo_valid) {
|
nuclear@0
|
1085 return;
|
nuclear@0
|
1086 }
|
nuclear@0
|
1087
|
nuclear@0
|
1088 if(!wire_ibo) {
|
nuclear@0
|
1089 glGenBuffers(1, &wire_ibo);
|
nuclear@0
|
1090 }
|
nuclear@0
|
1091
|
nuclear@0
|
1092 unsigned int *wire_idxarr = new unsigned int[nfaces * 6];
|
nuclear@0
|
1093 unsigned int *dest = wire_idxarr;
|
nuclear@0
|
1094
|
nuclear@0
|
1095 if(ibo_valid) {
|
nuclear@0
|
1096 // we're dealing with an indexed mesh
|
nuclear@0
|
1097 const unsigned int *idxarr = ((const Mesh*)this)->get_index_data();
|
nuclear@0
|
1098
|
nuclear@0
|
1099 for(unsigned int i=0; i<nfaces; i++) {
|
nuclear@0
|
1100 *dest++ = idxarr[0];
|
nuclear@0
|
1101 *dest++ = idxarr[1];
|
nuclear@0
|
1102 *dest++ = idxarr[1];
|
nuclear@0
|
1103 *dest++ = idxarr[2];
|
nuclear@0
|
1104 *dest++ = idxarr[2];
|
nuclear@0
|
1105 *dest++ = idxarr[0];
|
nuclear@0
|
1106 idxarr += 3;
|
nuclear@0
|
1107 }
|
nuclear@0
|
1108 } else {
|
nuclear@0
|
1109 // not an indexed mesh ...
|
nuclear@0
|
1110 for(unsigned int i=0; i<nfaces; i++) {
|
nuclear@0
|
1111 int vidx = i * 3;
|
nuclear@0
|
1112 *dest++ = vidx;
|
nuclear@0
|
1113 *dest++ = vidx + 1;
|
nuclear@0
|
1114 *dest++ = vidx + 1;
|
nuclear@0
|
1115 *dest++ = vidx + 2;
|
nuclear@0
|
1116 *dest++ = vidx + 2;
|
nuclear@0
|
1117 *dest++ = vidx;
|
nuclear@0
|
1118 }
|
nuclear@0
|
1119 }
|
nuclear@0
|
1120
|
nuclear@0
|
1121 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, wire_ibo);
|
nuclear@0
|
1122 glBufferData(GL_ELEMENT_ARRAY_BUFFER, nfaces * 6 * sizeof(unsigned int), wire_idxarr, GL_STATIC_DRAW);
|
nuclear@0
|
1123 delete [] wire_idxarr;
|
nuclear@0
|
1124 wire_ibo_valid = true;
|
nuclear@0
|
1125 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
|
nuclear@0
|
1126 }
|
nuclear@0
|
1127
|
nuclear@0
|
1128
|
nuclear@0
|
1129 // ------ class Triangle ------
|
nuclear@0
|
1130 Triangle::Triangle()
|
nuclear@0
|
1131 {
|
nuclear@0
|
1132 normal_valid = false;
|
nuclear@0
|
1133 id = -1;
|
nuclear@0
|
1134 }
|
nuclear@0
|
1135
|
nuclear@0
|
1136 Triangle::Triangle(const Vector3 &v0, const Vector3 &v1, const Vector3 &v2)
|
nuclear@0
|
1137 {
|
nuclear@0
|
1138 v[0] = v0;
|
nuclear@0
|
1139 v[1] = v1;
|
nuclear@0
|
1140 v[2] = v2;
|
nuclear@0
|
1141 normal_valid = false;
|
nuclear@0
|
1142 id = -1;
|
nuclear@0
|
1143 }
|
nuclear@0
|
1144
|
nuclear@0
|
1145 Triangle::Triangle(int n, const Vector3 *varr, const unsigned int *idxarr)
|
nuclear@0
|
1146 {
|
nuclear@0
|
1147 if(idxarr) {
|
nuclear@0
|
1148 v[0] = varr[idxarr[n * 3]];
|
nuclear@0
|
1149 v[1] = varr[idxarr[n * 3 + 1]];
|
nuclear@0
|
1150 v[2] = varr[idxarr[n * 3 + 2]];
|
nuclear@0
|
1151 } else {
|
nuclear@0
|
1152 v[0] = varr[n * 3];
|
nuclear@0
|
1153 v[1] = varr[n * 3 + 1];
|
nuclear@0
|
1154 v[2] = varr[n * 3 + 2];
|
nuclear@0
|
1155 }
|
nuclear@0
|
1156 normal_valid = false;
|
nuclear@0
|
1157 id = n;
|
nuclear@0
|
1158 }
|
nuclear@0
|
1159
|
nuclear@0
|
1160 void Triangle::calc_normal()
|
nuclear@0
|
1161 {
|
nuclear@0
|
1162 normal = cross_product(v[1] - v[0], v[2] - v[0]).normalized();
|
nuclear@0
|
1163 normal_valid = true;
|
nuclear@0
|
1164 }
|
nuclear@0
|
1165
|
nuclear@0
|
1166 const Vector3 &Triangle::get_normal() const
|
nuclear@0
|
1167 {
|
nuclear@0
|
1168 if(!normal_valid) {
|
nuclear@0
|
1169 ((Triangle*)this)->calc_normal();
|
nuclear@0
|
1170 }
|
nuclear@0
|
1171 return normal;
|
nuclear@0
|
1172 }
|
nuclear@0
|
1173
|
nuclear@0
|
1174 void Triangle::transform(const Matrix4x4 &xform)
|
nuclear@0
|
1175 {
|
nuclear@0
|
1176 v[0].transform(xform);
|
nuclear@0
|
1177 v[1].transform(xform);
|
nuclear@0
|
1178 v[2].transform(xform);
|
nuclear@0
|
1179 normal_valid = false;
|
nuclear@0
|
1180 }
|
nuclear@0
|
1181
|
nuclear@0
|
1182 void Triangle::draw() const
|
nuclear@0
|
1183 {
|
nuclear@0
|
1184 Vector3 n[3];
|
nuclear@0
|
1185 n[0] = get_normal();
|
nuclear@0
|
1186 n[1] = get_normal();
|
nuclear@0
|
1187 n[2] = get_normal();
|
nuclear@0
|
1188
|
nuclear@0
|
1189 int vloc = Mesh::get_attrib_location(MESH_ATTR_VERTEX);
|
nuclear@0
|
1190 int nloc = Mesh::get_attrib_location(MESH_ATTR_NORMAL);
|
nuclear@0
|
1191
|
nuclear@0
|
1192 glEnableVertexAttribArray(vloc);
|
nuclear@0
|
1193 glVertexAttribPointer(vloc, 3, GL_FLOAT, GL_FALSE, 0, &v[0].x);
|
nuclear@0
|
1194 glVertexAttribPointer(nloc, 3, GL_FLOAT, GL_FALSE, 0, &n[0].x);
|
nuclear@0
|
1195
|
nuclear@0
|
1196 glDrawArrays(GL_TRIANGLES, 0, 3);
|
nuclear@0
|
1197
|
nuclear@0
|
1198 glDisableVertexAttribArray(vloc);
|
nuclear@0
|
1199 glDisableVertexAttribArray(nloc);
|
nuclear@0
|
1200 }
|
nuclear@0
|
1201
|
nuclear@0
|
1202 void Triangle::draw_wire() const
|
nuclear@0
|
1203 {
|
nuclear@0
|
1204 static const int idxarr[] = {0, 1, 1, 2, 2, 0};
|
nuclear@0
|
1205 int vloc = Mesh::get_attrib_location(MESH_ATTR_VERTEX);
|
nuclear@0
|
1206
|
nuclear@0
|
1207 glEnableVertexAttribArray(vloc);
|
nuclear@0
|
1208 glVertexAttribPointer(vloc, 3, GL_FLOAT, GL_FALSE, 0, &v[0].x);
|
nuclear@0
|
1209
|
nuclear@0
|
1210 glDrawElements(GL_LINES, 6, GL_UNSIGNED_INT, idxarr);
|
nuclear@0
|
1211
|
nuclear@0
|
1212 glDisableVertexAttribArray(vloc);
|
nuclear@0
|
1213 }
|
nuclear@0
|
1214
|
nuclear@0
|
1215 Vector3 Triangle::calc_barycentric(const Vector3 &pos) const
|
nuclear@0
|
1216 {
|
nuclear@0
|
1217 Vector3 norm = get_normal();
|
nuclear@0
|
1218
|
nuclear@0
|
1219 float area_sq = fabs(dot_product(cross_product(v[1] - v[0], v[2] - v[0]), norm));
|
nuclear@0
|
1220 if(area_sq < 1e-5) {
|
nuclear@0
|
1221 return Vector3(0, 0, 0);
|
nuclear@0
|
1222 }
|
nuclear@0
|
1223
|
nuclear@0
|
1224 float asq0 = fabs(dot_product(cross_product(v[1] - pos, v[2] - pos), norm));
|
nuclear@0
|
1225 float asq1 = fabs(dot_product(cross_product(v[2] - pos, v[0] - pos), norm));
|
nuclear@0
|
1226 float asq2 = fabs(dot_product(cross_product(v[0] - pos, v[1] - pos), norm));
|
nuclear@0
|
1227
|
nuclear@0
|
1228 return Vector3(asq0 / area_sq, asq1 / area_sq, asq2 / area_sq);
|
nuclear@0
|
1229 }
|
nuclear@0
|
1230
|
nuclear@0
|
1231 bool Triangle::intersect(const Ray &ray, HitPoint *hit) const
|
nuclear@0
|
1232 {
|
nuclear@0
|
1233 Vector3 normal = get_normal();
|
nuclear@0
|
1234
|
nuclear@0
|
1235 float ndotdir = dot_product(ray.dir, normal);
|
nuclear@0
|
1236 if(fabs(ndotdir) < 1e-4) {
|
nuclear@0
|
1237 return false;
|
nuclear@0
|
1238 }
|
nuclear@0
|
1239
|
nuclear@0
|
1240 Vector3 vertdir = v[0] - ray.origin;
|
nuclear@0
|
1241 float t = dot_product(normal, vertdir) / ndotdir;
|
nuclear@0
|
1242
|
nuclear@0
|
1243 Vector3 pos = ray.origin + ray.dir * t;
|
nuclear@0
|
1244 Vector3 bary = calc_barycentric(pos);
|
nuclear@0
|
1245
|
nuclear@0
|
1246 if(bary.x + bary.y + bary.z > 1.00001) {
|
nuclear@0
|
1247 return false;
|
nuclear@0
|
1248 }
|
nuclear@0
|
1249
|
nuclear@0
|
1250 if(hit) {
|
nuclear@0
|
1251 hit->dist = t;
|
nuclear@0
|
1252 hit->pos = ray.origin + ray.dir * t;
|
nuclear@0
|
1253 hit->normal = normal;
|
nuclear@0
|
1254 hit->obj = this;
|
nuclear@0
|
1255 }
|
nuclear@0
|
1256 return true;
|
nuclear@0
|
1257 }
|