tavli: c3fbf9616dbd src/mesh.cc

tavli

view src/mesh.cc @ 21:c3fbf9616dbd

slot bounds, and ray testing

author	John Tsiombikas <nuclear@member.fsf.org>
date	Thu, 02 Jul 2015 00:01:39 +0300
parents	b1a195c3ee16
children

line source

1 #include <stdio.h>

2 #include <stdlib.h>

3 #include <float.h>

4 #include <assert.h>

5 #include "opengl.h"

6 #include "mesh.h"

7 //#include "xform_node.h"

9 #define USE_OLDGL

11 bool Mesh::use_custom_sdr_attr = true;

12 int Mesh::global_sdr_loc[NUM_MESH_ATTR] = { 0, 1, 2, 3, 4, 5, 6 };

13 /*

14 (int)SDR_ATTR_VERTEX,

15 (int)SDR_ATTR_NORMAL,

16 (int)SDR_ATTR_TANGENT,

17 (int)SDR_ATTR_TEXCOORD,

18 (int)SDR_ATTR_COLOR,

19 -1, -1};

20 */

21 unsigned int Mesh::intersect_mode = ISECT_DEFAULT;

22 float Mesh::vertex_sel_dist = 0.01;

23 float Mesh::vis_vecsize = 1.0;

25 Mesh::Mesh()

26 {

27 clear();

29 glGenBuffers(NUM_MESH_ATTR + 1, buffer_objects);

31 for(int i=0; i<NUM_MESH_ATTR; i++) {

32 vattr[i].vbo = buffer_objects[i];

33 }

34 ibo = buffer_objects[NUM_MESH_ATTR];

35 wire_ibo = 0;

36 }

38 Mesh::~Mesh()

39 {

40 glDeleteBuffers(NUM_MESH_ATTR + 1, buffer_objects);

42 if(wire_ibo) {

43 glDeleteBuffers(1, &wire_ibo);

44 }

45 }

47 Mesh::Mesh(const Mesh &rhs)

48 {

49 clear();

51 glGenBuffers(NUM_MESH_ATTR + 1, buffer_objects);

53 for(int i=0; i<NUM_MESH_ATTR; i++) {

54 vattr[i].vbo = buffer_objects[i];

55 }

56 ibo = buffer_objects[NUM_MESH_ATTR];

57 wire_ibo = 0;

59 clone(rhs);

60 }

62 Mesh &Mesh::operator =(const Mesh &rhs)

63 {

64 if(&rhs != this) {

65 clone(rhs);

66 }

67 return *this;

68 }

70 bool Mesh::clone(const Mesh &m)

71 {

72 clear();

74 for(int i=0; i<NUM_MESH_ATTR; i++) {

75 if(m.has_attrib(i)) {

76 m.get_attrib_data(i); // force validation of the actual data on the source mesh

78 vattr[i].nelem = m.vattr[i].nelem;

79 vattr[i].data = m.vattr[i].data; // copy the actual data

80 vattr[i].data_valid = true;

81 }

82 }

84 if(m.is_indexed()) {

85 m.get_index_data(); // again, force validation

87 // copy the index data

88 idata = m.idata;

89 idata_valid = true;

90 }

92 name = m.name;

93 nverts = m.nverts;

94 nfaces = m.nfaces;

96 //bones = m.bones;

98 memcpy(cur_val, m.cur_val, sizeof cur_val);

100 aabb = m.aabb;

101 aabb_valid = m.aabb_valid;

102 bsph = m.bsph;

103 bsph_valid = m.bsph_valid;

104

105 hitface = m.hitface;

106 hitvert = m.hitvert;

107

108 intersect_mode = m.intersect_mode;

109 vertex_sel_dist = m.vertex_sel_dist;

110 vis_vecsize = m.vis_vecsize;

111

112 return true;

113 }

114

115 void Mesh::set_name(const char *name)

116 {

117 this->name = name;

118 }

119

120 const char *Mesh::get_name() const

121 {

122 return name.c_str();

123 }

124

125 bool Mesh::has_attrib(int attr) const

126 {

127 if(attr < 0 || attr >= NUM_MESH_ATTR) {

128 return false;

129 }

130

131 // if neither of these is valid, then nobody has set this attribute

132 return vattr[attr].vbo_valid || vattr[attr].data_valid;

133 }

134

135 bool Mesh::is_indexed() const

136 {

137 return ibo_valid || idata_valid;

138 }

139

140 void Mesh::clear()

141 {

142 //bones.clear();

143

144 for(int i=0; i<NUM_MESH_ATTR; i++) {

145 vattr[i].nelem = 0;

146 vattr[i].vbo_valid = false;

147 vattr[i].data_valid = false;

148 //vattr[i].sdr_loc = -1;

149 vattr[i].data.clear();

150 }

151 ibo_valid = idata_valid = false;

152 idata.clear();

153

154 wire_ibo_valid = false;

155

156 nverts = nfaces = 0;

157

158 bsph_valid = false;

159 aabb_valid = false;

160 }

161

162 float *Mesh::set_attrib_data(int attrib, int nelem, unsigned int num, const float *data)

163 {

164 if(attrib < 0 || attrib >= NUM_MESH_ATTR) {

165 fprintf(stderr, "%s: invalid attrib: %d\n", __FUNCTION__, attrib);

166 return 0;

167 }

168

169 if(nverts && num != nverts) {

170 fprintf(stderr, "%s: attribute count missmatch (%d instead of %d)\n", __FUNCTION__, num, nverts);

171 return 0;

172 }

173 nverts = num;

174

175 vattr[attrib].data.clear();

176 vattr[attrib].nelem = nelem;

177 vattr[attrib].data.resize(num * nelem);

178

179 if(data) {

180 memcpy(&vattr[attrib].data[0], data, num * nelem * sizeof *data);

181 }

182

183 vattr[attrib].data_valid = true;

184 vattr[attrib].vbo_valid = false;

185 return &vattr[attrib].data[0];

186 }

187

188 float *Mesh::get_attrib_data(int attrib)

189 {

190 if(attrib < 0 || attrib >= NUM_MESH_ATTR) {

191 fprintf(stderr, "%s: invalid attrib: %d\n", __FUNCTION__, attrib);

192 return 0;

193 }

194

195 vattr[attrib].vbo_valid = false;

196 return (float*)((const Mesh*)this)->get_attrib_data(attrib);

197 }

198

199 const float *Mesh::get_attrib_data(int attrib) const

200 {

201 if(attrib < 0 || attrib >= NUM_MESH_ATTR) {

202 fprintf(stderr, "%s: invalid attrib: %d\n", __FUNCTION__, attrib);

203 return 0;

204 }

205

206 if(!vattr[attrib].data_valid) {

207 #if GL_ES_VERSION_2_0

208 fprintf(stderr, "%s: can't read back attrib data on CrippledGL ES\n", __FUNCTION__);

209 return 0;

210 #else

211 if(!vattr[attrib].vbo_valid) {

212 fprintf(stderr, "%s: unavailable attrib: %d\n", __FUNCTION__, attrib);

213 return 0;

214 }

215

216 // local data copy is unavailable, grab the data from the vbo

217 Mesh *m = (Mesh*)this;

218 m->vattr[attrib].data.resize(nverts * vattr[attrib].nelem);

219

220 glBindBuffer(GL_ARRAY_BUFFER, vattr[attrib].vbo);

221 void *data = glMapBuffer(GL_ARRAY_BUFFER, GL_READ_ONLY);

222 memcpy(&m->vattr[attrib].data[0], data, nverts * vattr[attrib].nelem * sizeof(float));

223 glUnmapBuffer(GL_ARRAY_BUFFER);

224

225 vattr[attrib].data_valid = true;

226 #endif

227 }

228

229 return &vattr[attrib].data[0];

230 }

231

232 void Mesh::set_attrib(int attrib, int idx, const Vector4 &v)

233 {

234 float *data = get_attrib_data(attrib);

235 if(data) {

236 data += idx * vattr[attrib].nelem;

237 for(int i=0; i<vattr[attrib].nelem; i++) {

238 data[i] = v[i];

239 }

240 }

241 }

242

243 Vector4 Mesh::get_attrib(int attrib, int idx) const

244 {

245 Vector4 v(0.0, 0.0, 0.0, 1.0);

246 const float *data = get_attrib_data(attrib);

247 if(data) {

248 data += idx * vattr[attrib].nelem;

249 for(int i=0; i<vattr[attrib].nelem; i++) {

250 v[i] = data[i];

251 }

252 }

253 return v;

254 }

255

256 int Mesh::get_attrib_count(int attrib) const

257 {

258 return has_attrib(attrib) ? nverts : 0;

259 }

260

261

262 unsigned int *Mesh::set_index_data(int num, const unsigned int *indices)

263 {

264 int nidx = nfaces * 3;

265 if(nidx && num != nidx) {

266 fprintf(stderr, "%s: index count missmatch (%d instead of %d)\n", __FUNCTION__, num, nidx);

267 return 0;

268 }

269 nfaces = num / 3;

270

271 idata.clear();

272 idata.resize(num);

273

274 if(indices) {

275 memcpy(&idata[0], indices, num * sizeof *indices);

276 }

277

278 idata_valid = true;

279 ibo_valid = false;

280

281 return &idata[0];

282 }

283

284 unsigned int *Mesh::get_index_data()

285 {

286 ibo_valid = false;

287 return (unsigned int*)((const Mesh*)this)->get_index_data();

288 }

289

290 const unsigned int *Mesh::get_index_data() const

291 {

292 if(!idata_valid) {

293 #if GL_ES_VERSION_2_0

294 fprintf(stderr, "%s: can't read back index data in CrippledGL ES\n", __FUNCTION__);

295 return 0;

296 #else

297 if(!ibo_valid) {

298 fprintf(stderr, "%s: indices unavailable\n", __FUNCTION__);

299 return 0;

300 }

301

302 // local data copy is unavailable, gram the data from the ibo

303 Mesh *m = (Mesh*)this;

304 int nidx = nfaces * 3;

305 m->idata.resize(nidx);

306

307 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);

308 void *data = glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_READ_ONLY);

309 memcpy(&m->idata[0], data, nidx * sizeof(unsigned int));

310 glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);

311

312 idata_valid = true;

313 #endif

314 }

315

316 return &idata[0];

317 }

318

319 int Mesh::get_index_count() const

320 {

321 return nfaces * 3;

322 }

323

324 void Mesh::append(const Mesh &mesh)

325 {

326 unsigned int idxoffs = nverts;

327

328 if(!nverts) {

329 clone(mesh);

330 return;

331 }

332

333 nverts += mesh.nverts;

334 nfaces += mesh.nfaces;

335

336 for(int i=0; i<NUM_MESH_ATTR; i++) {

337 if(has_attrib(i) && mesh.has_attrib(i)) {

338 // force validating the data arrays

339 get_attrib_data(i);

340 mesh.get_attrib_data(i);

341

342 // append the mesh data

343 vattr[i].data.insert(vattr[i].data.end(), mesh.vattr[i].data.begin(), mesh.vattr[i].data.end());

344 }

345 }

346

347 if(ibo_valid || idata_valid) {

348 // make index arrays valid

349 get_index_data();

350 mesh.get_index_data();

351

352 size_t orig_sz = idata.size();

353

354 idata.insert(idata.end(), mesh.idata.begin(), mesh.idata.end());

355

356 // fixup all the new indices

357 for(size_t i=orig_sz; i<idata.size(); i++) {

358 idata[i] += idxoffs;

359 }

360 }

361

362 // fuck everything

363 wire_ibo_valid = false;

364 aabb_valid = false;

365 bsph_valid = false;

366 }

367

368 // assemble a complete vertex by adding all the useful attributes

369 void Mesh::vertex(float x, float y, float z)

370 {

371 cur_val[MESH_ATTR_VERTEX] = Vector4(x, y, z, 1.0f);

372 vattr[MESH_ATTR_VERTEX].data_valid = true;

373 vattr[MESH_ATTR_VERTEX].nelem = 3;

374

375 for(int i=0; i<NUM_MESH_ATTR; i++) {

376 if(vattr[i].data_valid) {

377 for(int j=0; j<vattr[MESH_ATTR_VERTEX].nelem; j++) {

378 vattr[i].data.push_back(cur_val[i][j]);

379 }

380 }

381 vattr[i].vbo_valid = false;

382 }

383

384 if(idata_valid) {

385 idata.clear();

386 }

387 ibo_valid = idata_valid = false;

388 }

389

390 void Mesh::normal(float nx, float ny, float nz)

391 {

392 cur_val[MESH_ATTR_NORMAL] = Vector4(nx, ny, nz, 1.0f);

393 vattr[MESH_ATTR_NORMAL].data_valid = true;

394 vattr[MESH_ATTR_NORMAL].nelem = 3;

395 }

396

397 void Mesh::tangent(float tx, float ty, float tz)

398 {

399 cur_val[MESH_ATTR_TANGENT] = Vector4(tx, ty, tz, 1.0f);

400 vattr[MESH_ATTR_TANGENT].data_valid = true;

401 vattr[MESH_ATTR_TANGENT].nelem = 3;

402 }

403

404 void Mesh::texcoord(float u, float v, float w)

405 {

406 cur_val[MESH_ATTR_TEXCOORD] = Vector4(u, v, w, 1.0f);

407 vattr[MESH_ATTR_TEXCOORD].data_valid = true;

408 vattr[MESH_ATTR_TEXCOORD].nelem = 3;

409 }

410

411 void Mesh::boneweights(float w1, float w2, float w3, float w4)

412 {

413 cur_val[MESH_ATTR_BONEWEIGHTS] = Vector4(w1, w2, w3, w4);

414 vattr[MESH_ATTR_BONEWEIGHTS].data_valid = true;

415 vattr[MESH_ATTR_BONEWEIGHTS].nelem = 4;

416 }

417

418 void Mesh::boneidx(int idx1, int idx2, int idx3, int idx4)

419 {

420 cur_val[MESH_ATTR_BONEIDX] = Vector4(idx1, idx2, idx3, idx4);

421 vattr[MESH_ATTR_BONEIDX].data_valid = true;

422 vattr[MESH_ATTR_BONEIDX].nelem = 4;

423 }

424

425 int Mesh::get_poly_count() const

426 {

427 if(nfaces) {

428 return nfaces;

429 }

430 if(nverts) {

431 return nverts / 3;

432 }

433 return 0;

434 }

435

436 /// static function

437 void Mesh::set_attrib_location(int attr, int loc)

438 {

439 if(attr < 0 || attr >= NUM_MESH_ATTR) {

440 return;

441 }

442 Mesh::global_sdr_loc[attr] = loc;

443 }

444

445 /// static function

446 int Mesh::get_attrib_location(int attr)

447 {

448 if(attr < 0 || attr >= NUM_MESH_ATTR) {

449 return -1;

450 }

451 return Mesh::global_sdr_loc[attr];

452 }

453

454 /// static function

455 void Mesh::clear_attrib_locations()

456 {

457 for(int i=0; i<NUM_MESH_ATTR; i++) {

458 Mesh::global_sdr_loc[i] = -1;

459 }

460 }

461

462 /// static function

463 void Mesh::set_vis_vecsize(float sz)

464 {

465 Mesh::vis_vecsize = sz;

466 }

467

468 float Mesh::get_vis_vecsize()

469 {

470 return Mesh::vis_vecsize;

471 }

472

473 void Mesh::apply_xform(const Matrix4x4 &xform)

474 {

475 Matrix4x4 dir_xform = xform;

476 dir_xform[0][3] = dir_xform[1][3] = dir_xform[2][3] = 0.0f;

477 dir_xform[3][0] = dir_xform[3][1] = dir_xform[3][2] = 0.0f;

478 dir_xform[3][3] = 1.0f;

479

480 apply_xform(xform, dir_xform);

481 }

482

483 void Mesh::apply_xform(const Matrix4x4 &xform, const Matrix4x4 &dir_xform)

484 {

485 for(unsigned int i=0; i<nverts; i++) {

486 Vector4 v = get_attrib(MESH_ATTR_VERTEX, i);

487 set_attrib(MESH_ATTR_VERTEX, i, v.transformed(xform));

488

489 if(has_attrib(MESH_ATTR_NORMAL)) {

490 Vector3 n = get_attrib(MESH_ATTR_NORMAL, i);

491 set_attrib(MESH_ATTR_NORMAL, i, n.transformed(dir_xform));

492 }

493 if(has_attrib(MESH_ATTR_TANGENT)) {

494 Vector3 t = get_attrib(MESH_ATTR_TANGENT, i);

495 set_attrib(MESH_ATTR_TANGENT, i, t.transformed(dir_xform));

496 }

497 }

498 }

499

500 void Mesh::flip()

501 {

502 flip_faces();

503 flip_normals();

504 }

505

506 void Mesh::flip_faces()

507 {

508 if(is_indexed()) {

509 unsigned int *indices = get_index_data();

510 if(!indices) return;

511

512 int idxnum = get_index_count();

513 for(int i=0; i<idxnum; i+=3) {

514 unsigned int tmp = indices[i + 2];

515 indices[i + 2] = indices[i + 1];

516 indices[i + 1] = tmp;

517 }

518

519 } else {

520 Vector3 *verts = (Vector3*)get_attrib_data(MESH_ATTR_VERTEX);

521 if(!verts) return;

522

523 int vnum = get_attrib_count(MESH_ATTR_VERTEX);

524 for(int i=0; i<vnum; i+=3) {

525 Vector3 tmp = verts[i + 2];

526 verts[i + 2] = verts[i + 1];

527 verts[i + 1] = tmp;

528 }

529 }

530 }

531

532 void Mesh::flip_normals()

533 {

534 Vector3 *normals = (Vector3*)get_attrib_data(MESH_ATTR_NORMAL);

535 if(!normals) return;

536

537 int num = get_attrib_count(MESH_ATTR_NORMAL);

538 for(int i=0; i<num; i++) {

539 normals[i] = -normals[i];

540 }

541 }

542

543 /*

544 int Mesh::add_bone(XFormNode *bone)

545 {

546 int idx = bones.size();

547 bones.push_back(bone);

548 return idx;

549 }

550

551 const XFormNode *Mesh::get_bone(int idx) const

552 {

553 if(idx < 0 || idx >= (int)bones.size()) {

554 return 0;

555 }

556 return bones[idx];

557 }

558

559 int Mesh::get_bones_count() const

560 {

561 return (int)bones.size();

562 }

563 */

564

565 void Mesh::draw() const

566 {

567 int cur_sdr = 0;

568 if(glcaps.shaders) {

569 glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr);

570 }

571

572 ((Mesh*)this)->update_buffers();

573

574 if(!vattr[MESH_ATTR_VERTEX].vbo_valid) {

575 fprintf(stderr, "%s: invalid vertex buffer\n", __FUNCTION__);

576 return;

577 }

578

579 if(cur_sdr && use_custom_sdr_attr) {

580 // rendering with shaders

581 if(global_sdr_loc[MESH_ATTR_VERTEX] == -1) {

582 fprintf(stderr, "%s: shader attribute location for vertices unset\n", __FUNCTION__);

583 return;

584 }

585

586 for(int i=0; i<NUM_MESH_ATTR; i++) {

587 int loc = global_sdr_loc[i];

588 if(loc >= 0 && vattr[i].vbo_valid) {

589 glBindBuffer(GL_ARRAY_BUFFER, vattr[i].vbo);

590 glVertexAttribPointer(loc, vattr[i].nelem, GL_FLOAT, GL_FALSE, 0, 0);

591 glEnableVertexAttribArray(loc);

592 }

593 }

594 } else {

595 #ifndef GL_ES_VERSION_2_0

596 // rendering with fixed-function (not available in GLES2)

597 glBindBuffer(GL_ARRAY_BUFFER, vattr[MESH_ATTR_VERTEX].vbo);

598 glVertexPointer(vattr[MESH_ATTR_VERTEX].nelem, GL_FLOAT, 0, 0);

599 glEnableClientState(GL_VERTEX_ARRAY);

600

601 if(vattr[MESH_ATTR_NORMAL].vbo_valid) {

602 glBindBuffer(GL_ARRAY_BUFFER, vattr[MESH_ATTR_NORMAL].vbo);

603 glNormalPointer(GL_FLOAT, 0, 0);

604 glEnableClientState(GL_NORMAL_ARRAY);

605 }

606 if(vattr[MESH_ATTR_TEXCOORD].vbo_valid) {

607 glBindBuffer(GL_ARRAY_BUFFER, vattr[MESH_ATTR_TEXCOORD].vbo);

608 glTexCoordPointer(vattr[MESH_ATTR_TEXCOORD].nelem, GL_FLOAT, 0, 0);

609 glEnableClientState(GL_TEXTURE_COORD_ARRAY);

610 }

611 if(vattr[MESH_ATTR_COLOR].vbo_valid) {

612 glBindBuffer(GL_ARRAY_BUFFER, vattr[MESH_ATTR_COLOR].vbo);

613 glColorPointer(vattr[MESH_ATTR_COLOR].nelem, GL_FLOAT, 0, 0);

614 glEnableClientState(GL_COLOR_ARRAY);

615 }

616 #endif

617 }

618 glBindBuffer(GL_ARRAY_BUFFER, 0);

619

620 if(ibo_valid) {

621 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);

622 glDrawElements(GL_TRIANGLES, nfaces * 3, GL_UNSIGNED_INT, 0);

623 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

624 } else {

625 glDrawArrays(GL_TRIANGLES, 0, nverts);

626 }

627

628 if(cur_sdr && use_custom_sdr_attr) {

629 // rendered with shaders

630 for(int i=0; i<NUM_MESH_ATTR; i++) {

631 int loc = global_sdr_loc[i];

632 if(loc >= 0 && vattr[i].vbo_valid) {

633 glDisableVertexAttribArray(loc);

634 }

635 }

636 } else {

637 #ifndef GL_ES_VERSION_2_0

638 // rendered with fixed-function

639 glDisableClientState(GL_VERTEX_ARRAY);

640 if(vattr[MESH_ATTR_NORMAL].vbo_valid) {

641 glDisableClientState(GL_NORMAL_ARRAY);

642 }

643 if(vattr[MESH_ATTR_TEXCOORD].vbo_valid) {

644 glDisableClientState(GL_TEXTURE_COORD_ARRAY);

645 }

646 if(vattr[MESH_ATTR_COLOR].vbo_valid) {

647 glDisableClientState(GL_COLOR_ARRAY);

648 }

649 #endif

650 }

651 }

652

653 void Mesh::draw_wire() const

654 {

655 ((Mesh*)this)->update_wire_ibo();

656

657 if(!vattr[MESH_ATTR_VERTEX].vbo_valid || !wire_ibo_valid) {

658 fprintf(stderr, "%s: invalid vertex buffer\n", __FUNCTION__);

659 return;

660 }

661 if(global_sdr_loc[MESH_ATTR_VERTEX] == -1) {

662 fprintf(stderr, "%s: shader attribute location for vertices unset\n", __FUNCTION__);

663 return;

664 }

665

666 for(int i=0; i<NUM_MESH_ATTR; i++) {

667 int loc = global_sdr_loc[i];

668 if(loc >= 0 && vattr[i].vbo_valid) {

669 glBindBuffer(GL_ARRAY_BUFFER, vattr[i].vbo);

670 glVertexAttribPointer(loc, vattr[i].nelem, GL_FLOAT, GL_FALSE, 0, 0);

671 glEnableVertexAttribArray(loc);

672 }

673 }

674 glBindBuffer(GL_ARRAY_BUFFER, 0);

675

676 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, wire_ibo);

677 glDrawElements(GL_LINES, nfaces * 6, GL_UNSIGNED_INT, 0);

678 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

679

680 for(int i=0; i<NUM_MESH_ATTR; i++) {

681 int loc = global_sdr_loc[i];

682 if(loc >= 0 && vattr[i].vbo_valid) {

683 glDisableVertexAttribArray(loc);

684 }

685 }

686 }

687

688 void Mesh::draw_vertices() const

689 {

690 ((Mesh*)this)->update_buffers();

691

692 if(!vattr[MESH_ATTR_VERTEX].vbo_valid) {

693 fprintf(stderr, "%s: invalid vertex buffer\n", __FUNCTION__);

694 return;

695 }

696 if(global_sdr_loc[MESH_ATTR_VERTEX] == -1) {

697 fprintf(stderr, "%s: shader attribute location for vertices unset\n", __FUNCTION__);

698 return;

699 }

700

701 for(int i=0; i<NUM_MESH_ATTR; i++) {

702 int loc = global_sdr_loc[i];

703 if(loc >= 0 && vattr[i].vbo_valid) {

704 glBindBuffer(GL_ARRAY_BUFFER, vattr[i].vbo);

705 glVertexAttribPointer(loc, vattr[i].nelem, GL_FLOAT, GL_FALSE, 0, 0);

706 glEnableVertexAttribArray(loc);

707 }

708 }

709 glBindBuffer(GL_ARRAY_BUFFER, 0);

710

711 glDrawArrays(GL_POINTS, 0, nverts);

712

713 for(int i=0; i<NUM_MESH_ATTR; i++) {

714 int loc = global_sdr_loc[i];

715 if(loc >= 0 && vattr[i].vbo_valid) {

716 glDisableVertexAttribArray(loc);

717 }

718 }

719 }

720

721 void Mesh::draw_normals() const

722 {

723 #ifdef USE_OLDGL

724 int cur_sdr = 0;

725 if(glcaps.shaders) {

726 glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr);

727 }

728

729 Vector3 *varr = (Vector3*)get_attrib_data(MESH_ATTR_VERTEX);

730 Vector3 *norm = (Vector3*)get_attrib_data(MESH_ATTR_NORMAL);

731 if(!varr || !norm) {

732 return;

733 }

734

735 glBegin(GL_LINES);

736 if(cur_sdr && use_custom_sdr_attr) {

737 int vert_loc = global_sdr_loc[MESH_ATTR_VERTEX];

738 if(vert_loc < 0) {

739 glEnd();

740 return;

741 }

742

743 for(size_t i=0; i<nverts; i++) {

744 glVertexAttrib3f(vert_loc, varr[i].x, varr[i].y, varr[i].z);

745 Vector3 end = varr[i] + norm[i] * vis_vecsize;

746 glVertexAttrib3f(vert_loc, end.x, end.y, end.z);

747 }

748 } else {

749 for(size_t i=0; i<nverts; i++) {

750 glVertex3f(varr[i].x, varr[i].y, varr[i].z);

751 Vector3 end = varr[i] + norm[i] * vis_vecsize;

752 glVertex3f(end.x, end.y, end.z);

753 }

754 }

755 glEnd();

756 #endif // USE_OLDGL

757 }

758

759 void Mesh::draw_tangents() const

760 {

761 #ifdef USE_OLDGL

762 int cur_sdr = 0;

763 if(glcaps.shaders) {

764 glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr);

765 }

766

767 Vector3 *varr = (Vector3*)get_attrib_data(MESH_ATTR_VERTEX);

768 Vector3 *tang = (Vector3*)get_attrib_data(MESH_ATTR_TANGENT);

769 if(!varr || !tang) {

770 return;

771 }

772

773 glBegin(GL_LINES);

774 if(cur_sdr && use_custom_sdr_attr) {

775 int vert_loc = global_sdr_loc[MESH_ATTR_VERTEX];

776 if(vert_loc < 0) {

777 glEnd();

778 return;

779 }

780

781 for(size_t i=0; i<nverts; i++) {

782 glVertexAttrib3f(vert_loc, varr[i].x, varr[i].y, varr[i].z);

783 Vector3 end = varr[i] + tang[i] * vis_vecsize;

784 glVertexAttrib3f(vert_loc, end.x, end.y, end.z);

785 }

786 } else {

787 for(size_t i=0; i<nverts; i++) {

788 glVertex3f(varr[i].x, varr[i].y, varr[i].z);

789 Vector3 end = varr[i] + tang[i] * vis_vecsize;

790 glVertex3f(end.x, end.y, end.z);

791 }

792 }

793 glEnd();

794 #endif // USE_OLDGL

795 }

796

797 void Mesh::get_aabbox(Vector3 *vmin, Vector3 *vmax) const

798 {

799 if(!aabb_valid) {

800 ((Mesh*)this)->calc_aabb();

801 }

802 *vmin = aabb.min;

803 *vmax = aabb.max;

804 }

805

806 const AABox &Mesh::get_aabbox() const

807 {

808 if(!aabb_valid) {

809 ((Mesh*)this)->calc_aabb();

810 }

811 return aabb;

812 }

813

814 float Mesh::get_bsphere(Vector3 *center, float *rad) const

815 {

816 if(!bsph_valid) {

817 ((Mesh*)this)->calc_bsph();

818 }

819 *center = bsph.center;

820 *rad = bsph.radius;

821 return bsph.radius;

822 }

823

824 const Sphere &Mesh::get_bsphere() const

825 {

826 if(!bsph_valid) {

827 ((Mesh*)this)->calc_bsph();

828 }

829 return bsph;

830 }

831

832 /// static function

833 void Mesh::set_intersect_mode(unsigned int mode)

834 {

835 Mesh::intersect_mode = mode;

836 }

837

838 /// static function

839 unsigned int Mesh::get_intersect_mode()

840 {

841 return Mesh::intersect_mode;

842 }

843

844 /// static function

845 void Mesh::set_vertex_select_distance(float dist)

846 {

847 Mesh::vertex_sel_dist = dist;

848 }

849

850 /// static function

851 float Mesh::get_vertex_select_distance()

852 {

853 return Mesh::vertex_sel_dist;

854 }

855

856 bool Mesh::intersect(const Ray &ray, HitPoint *hit) const

857 {

858 assert((Mesh::intersect_mode & (ISECT_VERTICES | ISECT_FACE)) != (ISECT_VERTICES | ISECT_FACE));

859

860 const Vector3 *varr = (Vector3*)get_attrib_data(MESH_ATTR_VERTEX);

861 const Vector3 *narr = (Vector3*)get_attrib_data(MESH_ATTR_NORMAL);

862 if(!varr) {

863 return false;

864 }

865 const unsigned int *idxarr = get_index_data();

866

867 // first test with the bounding box

868 AABox box;

869 get_aabbox(&box.min, &box.max);

870 if(!box.intersect(ray)) {

871 return false;

872 }

873

874 HitPoint nearest_hit;

875 nearest_hit.dist = FLT_MAX;

876 nearest_hit.obj = 0;

877

878 if(Mesh::intersect_mode & ISECT_VERTICES) {

879 // we asked for "intersections" with the vertices of the mesh

880 long nearest_vidx = -1;

881 float thres_sq = Mesh::vertex_sel_dist * Mesh::vertex_sel_dist;

882

883 for(unsigned int i=0; i<nverts; i++) {

884

885 if((Mesh::intersect_mode & ISECT_FRONT) && dot_product(narr[i], ray.dir) > 0) {

886 continue;

887 }

888

889 // project the vertex onto the ray line

890 float t = dot_product(varr[i] - ray.origin, ray.dir);

891 Vector3 vproj = ray.origin + ray.dir * t;

892

893 float dist_sq = (vproj - varr[i]).length_sq();

894 if(dist_sq < thres_sq) {

895 if(!hit) {

896 return true;

897 }

898 if(t < nearest_hit.dist) {

899 nearest_hit.dist = t;

900 nearest_vidx = i;

901 }

902 }

903 }

904

905 if(nearest_vidx != -1) {

906 hitvert = varr[nearest_vidx];

907 nearest_hit.obj = &hitvert;

908 }

909

910 } else {

911 // regular intersection test with polygons

912

913 for(unsigned int i=0; i<nfaces; i++) {

914 Triangle face(i, varr, idxarr);

915

916 // ignore back-facing polygons if the mode flags include ISECT_FRONT

917 if((Mesh::intersect_mode & ISECT_FRONT) && dot_product(face.get_normal(), ray.dir) > 0) {

918 continue;

919 }

920

921 HitPoint fhit;

922 if(face.intersect(ray, hit ? &fhit : 0)) {

923 if(!hit) {

924 return true;

925 }

926 if(fhit.dist < nearest_hit.dist) {

927 nearest_hit = fhit;

928 hitface = face;

929 }

930 }

931 }

932 }

933

934 if(nearest_hit.obj) {

935 if(hit) {

936 *hit = nearest_hit;

937

938 // if we are interested in the mesh and not the faces set obj to this

939 if(Mesh::intersect_mode & ISECT_FACE) {

940 hit->obj = &hitface;

941 } else if(Mesh::intersect_mode & ISECT_VERTICES) {

942 hit->obj = &hitvert;

943 } else {

944 hit->obj = this;

945 }

946 }

947 return true;

948 }

949 return false;

950 }

951

952

953 // texture coordinate manipulation

954 void Mesh::texcoord_apply_xform(const Matrix4x4 &xform)

955 {

956 if(!has_attrib(MESH_ATTR_TEXCOORD)) {

957 return;

958 }

959

960 for(unsigned int i=0; i<nverts; i++) {

961 Vector4 tc = get_attrib(MESH_ATTR_TEXCOORD, i);

962 set_attrib(MESH_ATTR_TEXCOORD, i, tc.transformed(xform));

963 }

964 }

965

966 void Mesh::texcoord_gen_plane(const Vector3 &norm, const Vector3 &tang)

967 {

968 if(!nverts) return;

969

970 if(!has_attrib(MESH_ATTR_TEXCOORD)) {

971 // allocate texture coordinate attribute array

972 set_attrib_data(MESH_ATTR_TEXCOORD, 2, nverts);

973 }

974

975 Vector3 n = norm.normalized();

976 Vector3 b = cross_product(n, tang).normalized();

977 Vector3 t = cross_product(b, n);

978

979 for(unsigned int i=0; i<nverts; i++) {

980 Vector3 pos = get_attrib(MESH_ATTR_VERTEX, i);

981

982 // distance along the tangent direction

983 float u = dot_product(pos, t);

984 // distance along the bitangent direction

985 float v = dot_product(pos, b);

986

987 set_attrib(MESH_ATTR_TEXCOORD, i, Vector4(u, v, 0, 1));

988 }

989 }

990

991 void Mesh::texcoord_gen_box()

992 {

993 if(!nverts || !has_attrib(MESH_ATTR_NORMAL)) return;

994

995 if(!has_attrib(MESH_ATTR_TEXCOORD)) {

996 // allocate texture coordinate attribute array

997 set_attrib_data(MESH_ATTR_TEXCOORD, 2, nverts);

998 }

999

1000 for(unsigned int i=0; i<nverts; i++) {

1001 Vector3 pos = Vector3(get_attrib(MESH_ATTR_VERTEX, i)) * 0.5 + Vector3(0.5, 0.5, 0.5);

1002 Vector3 norm = get_attrib(MESH_ATTR_NORMAL, i);

1003

1004 float abs_nx = fabs(norm.x);

1005 float abs_ny = fabs(norm.y);

1006 float abs_nz = fabs(norm.z);

1007 int dom = abs_nx > abs_ny && abs_nx > abs_nz ? 0 : (abs_ny > abs_nz ? 1 : 2);

1008

1009 float uv[2], *uvptr = uv;

1010 for(int j=0; j<3; j++) {

1011 if(j == dom) continue; // skip dominant axis

1012

1013 *uvptr++ = pos[j];

1014 }

1015 set_attrib(MESH_ATTR_TEXCOORD, i, Vector4(uv[0], uv[1], 0, 1));

1016 }

1017 }

1018

1019 // ------ private member functions ------

1020

1021 void Mesh::calc_aabb()

1022 {

1023 // the cast is to force calling the const version which doesn't invalidate

1024 if(!((const Mesh*)this)->get_attrib_data(MESH_ATTR_VERTEX)) {

1025 return;

1026 }

1027

1028 aabb.min = Vector3(FLT_MAX, FLT_MAX, FLT_MAX);

1029 aabb.max = -aabb.min;

1030

1031 for(unsigned int i=0; i<nverts; i++) {

1032 Vector4 v = get_attrib(MESH_ATTR_VERTEX, i);

1033 for(int j=0; j<3; j++) {

1034 if(v[j] < aabb.min[j]) {

1035 aabb.min[j] = v[j];

1036 }

1037 if(v[j] > aabb.max[j]) {

1038 aabb.max[j] = v[j];

1039 }

1040 }

1041 }

1042 aabb_valid = true;

1043 }

1044

1045 void Mesh::calc_bsph()

1046 {

1047 // the cast is to force calling the const version which doesn't invalidate

1048 if(!((const Mesh*)this)->get_attrib_data(MESH_ATTR_VERTEX)) {

1049 return;

1050 }

1051

1052 Vector3 v;

1053 bsph.center = Vector3(0, 0, 0);

1054

1055 // first find the center

1056 for(unsigned int i=0; i<nverts; i++) {

1057 v = get_attrib(MESH_ATTR_VERTEX, i);

1058 bsph.center += v;

1059 }

1060 bsph.center /= (float)nverts;

1061

1062 bsph.radius = 0.0f;

1063 for(unsigned int i=0; i<nverts; i++) {

1064 v = get_attrib(MESH_ATTR_VERTEX, i);

1065 float dist_sq = (v - bsph.center).length_sq();

1066 if(dist_sq > bsph.radius) {

1067 bsph.radius = dist_sq;

1068 }

1069 }

1070 bsph.radius = sqrt(bsph.radius);

1071

1072 bsph_valid = true;

1073 }

1074

1075 void Mesh::update_buffers()

1076 {

1077 for(int i=0; i<NUM_MESH_ATTR; i++) {

1078 if(has_attrib(i) && !vattr[i].vbo_valid) {

1079 glBindBuffer(GL_ARRAY_BUFFER, vattr[i].vbo);

1080 glBufferData(GL_ARRAY_BUFFER, nverts * vattr[i].nelem * sizeof(float), &vattr[i].data[0], GL_STATIC_DRAW);

1081 vattr[i].vbo_valid = true;

1082 }

1083 }

1084 glBindBuffer(GL_ARRAY_BUFFER, 0);

1085

1086 if(idata_valid && !ibo_valid) {

1087 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);

1088 glBufferData(GL_ELEMENT_ARRAY_BUFFER, nfaces * 3 * sizeof(unsigned int), &idata[0], GL_STATIC_DRAW);

1089 ibo_valid = true;

1090 }

1091 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

1092 }

1093

1094 void Mesh::update_wire_ibo()

1095 {

1096 update_buffers();

1097

1098 if(wire_ibo_valid) {

1099 return;

1100 }

1101

1102 if(!wire_ibo) {

1103 glGenBuffers(1, &wire_ibo);

1104 }

1105

1106 unsigned int *wire_idxarr = new unsigned int[nfaces * 6];

1107 unsigned int *dest = wire_idxarr;

1108

1109 if(ibo_valid) {

1110 // we're dealing with an indexed mesh

1111 const unsigned int *idxarr = ((const Mesh*)this)->get_index_data();

1112

1113 for(unsigned int i=0; i<nfaces; i++) {

1114 *dest++ = idxarr[0];

1115 *dest++ = idxarr[1];

1116 *dest++ = idxarr[1];

1117 *dest++ = idxarr[2];

1118 *dest++ = idxarr[2];

1119 *dest++ = idxarr[0];

1120 idxarr += 3;

1121 }

1122 } else {

1123 // not an indexed mesh ...

1124 for(unsigned int i=0; i<nfaces; i++) {

1125 int vidx = i * 3;

1126 *dest++ = vidx;

1127 *dest++ = vidx + 1;

1128 *dest++ = vidx + 1;

1129 *dest++ = vidx + 2;

1130 *dest++ = vidx + 2;

1131 *dest++ = vidx;

1132 }

1133 }

1134

1135 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, wire_ibo);

1136 glBufferData(GL_ELEMENT_ARRAY_BUFFER, nfaces * 6 * sizeof(unsigned int), wire_idxarr, GL_STATIC_DRAW);

1137 delete [] wire_idxarr;

1138 wire_ibo_valid = true;

1139 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

1140 }

1141

1142

1143 // ------ class Triangle ------

1144 Triangle::Triangle()

1145 {

1146 normal_valid = false;

1147 id = -1;

1148 }

1149

1150 Triangle::Triangle(const Vector3 &v0, const Vector3 &v1, const Vector3 &v2)

1151 {

1152 v[0] = v0;

1153 v[1] = v1;

1154 v[2] = v2;

1155 normal_valid = false;

1156 id = -1;

1157 }

1158

1159 Triangle::Triangle(int n, const Vector3 *varr, const unsigned int *idxarr)

1160 {

1161 if(idxarr) {

1162 v[0] = varr[idxarr[n * 3]];

1163 v[1] = varr[idxarr[n * 3 + 1]];

1164 v[2] = varr[idxarr[n * 3 + 2]];

1165 } else {

1166 v[0] = varr[n * 3];

1167 v[1] = varr[n * 3 + 1];

1168 v[2] = varr[n * 3 + 2];

1169 }

1170 normal_valid = false;

1171 id = n;

1172 }

1173

1174 void Triangle::calc_normal()

1175 {

1176 normal = cross_product(v[1] - v[0], v[2] - v[0]).normalized();

1177 normal_valid = true;

1178 }

1179

1180 const Vector3 &Triangle::get_normal() const

1181 {

1182 if(!normal_valid) {

1183 ((Triangle*)this)->calc_normal();

1184 }

1185 return normal;

1186 }

1187

1188 void Triangle::transform(const Matrix4x4 &xform)

1189 {

1190 v[0].transform(xform);

1191 v[1].transform(xform);

1192 v[2].transform(xform);

1193 normal_valid = false;

1194 }

1195

1196 void Triangle::draw() const

1197 {

1198 Vector3 n[3];

1199 n[0] = get_normal();

1200 n[1] = get_normal();

1201 n[2] = get_normal();

1202

1203 int vloc = Mesh::get_attrib_location(MESH_ATTR_VERTEX);

1204 int nloc = Mesh::get_attrib_location(MESH_ATTR_NORMAL);

1205

1206 glEnableVertexAttribArray(vloc);

1207 glVertexAttribPointer(vloc, 3, GL_FLOAT, GL_FALSE, 0, &v[0].x);

1208 glVertexAttribPointer(nloc, 3, GL_FLOAT, GL_FALSE, 0, &n[0].x);

1209

1210 glDrawArrays(GL_TRIANGLES, 0, 3);

1211

1212 glDisableVertexAttribArray(vloc);

1213 glDisableVertexAttribArray(nloc);

1214 }

1215

1216 void Triangle::draw_wire() const

1217 {

1218 static const int idxarr[] = {0, 1, 1, 2, 2, 0};

1219 int vloc = Mesh::get_attrib_location(MESH_ATTR_VERTEX);

1220

1221 glEnableVertexAttribArray(vloc);

1222 glVertexAttribPointer(vloc, 3, GL_FLOAT, GL_FALSE, 0, &v[0].x);

1223

1224 glDrawElements(GL_LINES, 6, GL_UNSIGNED_INT, idxarr);

1225

1226 glDisableVertexAttribArray(vloc);

1227 }

1228

1229 Vector3 Triangle::calc_barycentric(const Vector3 &pos) const

1230 {

1231 Vector3 norm = get_normal();

1232

1233 float area_sq = fabs(dot_product(cross_product(v[1] - v[0], v[2] - v[0]), norm));

1234 if(area_sq < 1e-5) {

1235 return Vector3(0, 0, 0);

1236 }

1237

1238 float asq0 = fabs(dot_product(cross_product(v[1] - pos, v[2] - pos), norm));

1239 float asq1 = fabs(dot_product(cross_product(v[2] - pos, v[0] - pos), norm));

1240 float asq2 = fabs(dot_product(cross_product(v[0] - pos, v[1] - pos), norm));

1241

1242 return Vector3(asq0 / area_sq, asq1 / area_sq, asq2 / area_sq);

1243 }

1244

1245 bool Triangle::intersect(const Ray &ray, HitPoint *hit) const

1246 {

1247 Vector3 normal = get_normal();

1248

1249 float ndotdir = dot_product(ray.dir, normal);

1250 if(fabs(ndotdir) < 1e-4) {

1251 return false;

1252 }

1253

1254 Vector3 vertdir = v[0] - ray.origin;

1255 float t = dot_product(normal, vertdir) / ndotdir;

1256

1257 Vector3 pos = ray.origin + ray.dir * t;

1258 Vector3 bary = calc_barycentric(pos);

1259

1260 if(bary.x + bary.y + bary.z > 1.00001) {

1261 return false;

1262 }

1263

1264 if(hit) {

1265 hit->dist = t;

1266 hit->pos = ray.origin + ray.dir * t;

1267 hit->normal = normal;

1268 hit->obj = this;

1269 }

1270 return true;

1271 }