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