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