cubemapper: 8fc9e1d3aad2 src/mesh.cc

cubemapper

view src/mesh.cc @ 0:8fc9e1d3aad2

initial commit

author	John Tsiombikas <nuclear@member.fsf.org>
date	Thu, 27 Jul 2017 20:36:12 +0300
parents
children	2bfafdced01a

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 Vec4 &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 Vec4 Mesh::get_attrib(int attrib, int idx) const

244 {

245 Vec4 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] = Vec4(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] = Vec4(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] = Vec4(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] = Vec4(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] = Vec4(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] = Vec4(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 Mat4 &xform)

474 {

475 Mat4 dir_xform = xform.upper3x3();

476 apply_xform(xform, dir_xform);

477 }

478

479 void Mesh::apply_xform(const Mat4 &xform, const Mat4 &dir_xform)

480 {

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

482 Vec4 v = get_attrib(MESH_ATTR_VERTEX, i);

483 set_attrib(MESH_ATTR_VERTEX, i, xform * v);

484

485 if(has_attrib(MESH_ATTR_NORMAL)) {

486 Vec3 n = get_attrib(MESH_ATTR_NORMAL, i).xyz();

487 set_attrib(MESH_ATTR_NORMAL, i, Vec4(dir_xform * n));

488 }

489 if(has_attrib(MESH_ATTR_TANGENT)) {

490 Vec3 t = get_attrib(MESH_ATTR_TANGENT, i).xyz();

491 set_attrib(MESH_ATTR_TANGENT, i, Vec4(dir_xform * t));

492 }

493 }

494 }

495

496 void Mesh::flip()

497 {

498 flip_faces();

499 flip_normals();

500 }

501

502 void Mesh::flip_faces()

503 {

504 if(is_indexed()) {

505 unsigned int *indices = get_index_data();

506 if(!indices) return;

507

508 int idxnum = get_index_count();

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

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

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

512 indices[i + 1] = tmp;

513 }

514

515 } else {

516 Vec3 *verts = (Vec3*)get_attrib_data(MESH_ATTR_VERTEX);

517 if(!verts) return;

518

519 int vnum = get_attrib_count(MESH_ATTR_VERTEX);

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

521 Vec3 tmp = verts[i + 2];

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

523 verts[i + 1] = tmp;

524 }

525 }

526 }

527

528 void Mesh::flip_normals()

529 {

530 Vec3 *normals = (Vec3*)get_attrib_data(MESH_ATTR_NORMAL);

531 if(!normals) return;

532

533 int num = get_attrib_count(MESH_ATTR_NORMAL);

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

535 normals[i] = -normals[i];

536 }

537 }

538

539 /*

540 int Mesh::add_bone(XFormNode *bone)

541 {

542 int idx = bones.size();

543 bones.push_back(bone);

544 return idx;

545 }

546

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

548 {

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

550 return 0;

551 }

552 return bones[idx];

553 }

554

555 int Mesh::get_bones_count() const

556 {

557 return (int)bones.size();

558 }

559 */

560

561 bool Mesh::pre_draw() const

562 {

563 cur_sdr = 0;

564 glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr);

565

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

567

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

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

570 return false;

571 }

572

573 if(cur_sdr && use_custom_sdr_attr) {

574 // rendering with shaders

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

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

577 return false;

578 }

579

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

581 int loc = global_sdr_loc[i];

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

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

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

585 glEnableVertexAttribArray(loc);

586 }

587 }

588 } else {

589 #ifndef GL_ES_VERSION_2_0

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

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

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

593 glEnableClientState(GL_VERTEX_ARRAY);

594

595 if(vattr[MESH_ATTR_NORMAL].vbo_valid) {

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

597 glNormalPointer(GL_FLOAT, 0, 0);

598 glEnableClientState(GL_NORMAL_ARRAY);

599 }

600 if(vattr[MESH_ATTR_TEXCOORD].vbo_valid) {

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

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

603 glEnableClientState(GL_TEXTURE_COORD_ARRAY);

604 }

605 if(vattr[MESH_ATTR_COLOR].vbo_valid) {

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

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

608 glEnableClientState(GL_COLOR_ARRAY);

609 }

610 #endif

611 }

612 glBindBuffer(GL_ARRAY_BUFFER, 0);

613

614 return true;

615 }

616

617 void Mesh::draw() const

618 {

619 if(!pre_draw()) return;

620

621 if(ibo_valid) {

622 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);

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

624 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

625 } else {

626 glDrawArrays(GL_TRIANGLES, 0, nverts);

627 }

628

629 post_draw();

630 }

631

632 void Mesh::post_draw() const

633 {

634 if(cur_sdr && use_custom_sdr_attr) {

635 // rendered with shaders

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

637 int loc = global_sdr_loc[i];

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

639 glDisableVertexAttribArray(loc);

640 }

641 }

642 } else {

643 #ifndef GL_ES_VERSION_2_0

644 // rendered with fixed-function

645 glDisableClientState(GL_VERTEX_ARRAY);

646 if(vattr[MESH_ATTR_NORMAL].vbo_valid) {

647 glDisableClientState(GL_NORMAL_ARRAY);

648 }

649 if(vattr[MESH_ATTR_TEXCOORD].vbo_valid) {

650 glDisableClientState(GL_TEXTURE_COORD_ARRAY);

651 }

652 if(vattr[MESH_ATTR_COLOR].vbo_valid) {

653 glDisableClientState(GL_COLOR_ARRAY);

654 }

655 #endif

656 }

657 }

658

659 void Mesh::draw_wire() const

660 {

661 if(!pre_draw()) return;

662

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

664

665 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, wire_ibo);

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

667 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

668

669 post_draw();

670 }

671

672 void Mesh::draw_vertices() const

673 {

674 if(!pre_draw()) return;

675

676 glDrawArrays(GL_POINTS, 0, nverts);

677

678 post_draw();

679 }

680

681 void Mesh::draw_normals() const

682 {

683 #ifdef USE_OLDGL

684 int cur_sdr = 0;

685 glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr);

686

687 Vec3 *varr = (Vec3*)get_attrib_data(MESH_ATTR_VERTEX);

688 Vec3 *norm = (Vec3*)get_attrib_data(MESH_ATTR_NORMAL);

689 if(!varr || !norm) {

690 return;

691 }

692

693 glBegin(GL_LINES);

694 if(cur_sdr && use_custom_sdr_attr) {

695 int vert_loc = global_sdr_loc[MESH_ATTR_VERTEX];

696 if(vert_loc < 0) {

697 glEnd();

698 return;

699 }

700

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

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

703 Vec3 end = varr[i] + norm[i] * vis_vecsize;

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

705 }

706 } else {

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

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

709 Vec3 end = varr[i] + norm[i] * vis_vecsize;

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

711 }

712 }

713 glEnd();

714 #endif // USE_OLDGL

715 }

716

717 void Mesh::draw_tangents() const

718 {

719 #ifdef USE_OLDGL

720 int cur_sdr = 0;

721 glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr);

722

723 Vec3 *varr = (Vec3*)get_attrib_data(MESH_ATTR_VERTEX);

724 Vec3 *tang = (Vec3*)get_attrib_data(MESH_ATTR_TANGENT);

725 if(!varr || !tang) {

726 return;

727 }

728

729 glBegin(GL_LINES);

730 if(cur_sdr && use_custom_sdr_attr) {

731 int vert_loc = global_sdr_loc[MESH_ATTR_VERTEX];

732 if(vert_loc < 0) {

733 glEnd();

734 return;

735 }

736

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

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

739 Vec3 end = varr[i] + tang[i] * vis_vecsize;

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

741 }

742 } else {

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

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

745 Vec3 end = varr[i] + tang[i] * vis_vecsize;

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

747 }

748 }

749 glEnd();

750 #endif // USE_OLDGL

751 }

752

753 void Mesh::get_aabbox(Vec3 *vmin, Vec3 *vmax) const

754 {

755 if(!aabb_valid) {

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

757 }

758 *vmin = aabb.min;

759 *vmax = aabb.max;

760 }

761

762 const AABox &Mesh::get_aabbox() const

763 {

764 if(!aabb_valid) {

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

766 }

767 return aabb;

768 }

769

770 float Mesh::get_bsphere(Vec3 *center, float *rad) const

771 {

772 if(!bsph_valid) {

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

774 }

775 *center = bsph.center;

776 *rad = bsph.radius;

777 return bsph.radius;

778 }

779

780 const Sphere &Mesh::get_bsphere() const

781 {

782 if(!bsph_valid) {

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

784 }

785 return bsph;

786 }

787

788 /// static function

789 void Mesh::set_intersect_mode(unsigned int mode)

790 {

791 Mesh::intersect_mode = mode;

792 }

793

794 /// static function

795 unsigned int Mesh::get_intersect_mode()

796 {

797 return Mesh::intersect_mode;

798 }

799

800 /// static function

801 void Mesh::set_vertex_select_distance(float dist)

802 {

803 Mesh::vertex_sel_dist = dist;

804 }

805

806 /// static function

807 float Mesh::get_vertex_select_distance()

808 {

809 return Mesh::vertex_sel_dist;

810 }

811

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

813 {

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

815

816 const Vec3 *varr = (Vec3*)get_attrib_data(MESH_ATTR_VERTEX);

817 const Vec3 *narr = (Vec3*)get_attrib_data(MESH_ATTR_NORMAL);

818 if(!varr) {

819 return false;

820 }

821 const unsigned int *idxarr = get_index_data();

822

823 // first test with the bounding box

824 AABox box;

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

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

827 return false;

828 }

829

830 HitPoint nearest_hit;

831 nearest_hit.dist = FLT_MAX;

832 nearest_hit.obj = 0;

833

834 if(Mesh::intersect_mode & ISECT_VERTICES) {

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

836 long nearest_vidx = -1;

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

838

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

840

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

842 continue;

843 }

844

845 // project the vertex onto the ray line

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

847 Vec3 vproj = ray.origin + ray.dir * t;

848

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

850 if(dist_sq < thres_sq) {

851 if(!hit) {

852 return true;

853 }

854 if(t < nearest_hit.dist) {

855 nearest_hit.dist = t;

856 nearest_vidx = i;

857 }

858 }

859 }

860

861 if(nearest_vidx != -1) {

862 hitvert = varr[nearest_vidx];

863 nearest_hit.obj = &hitvert;

864 }

865

866 } else {

867 // regular intersection test with polygons

868

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

870 Triangle face(i, varr, idxarr);

871

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

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

874 continue;

875 }

876

877 HitPoint fhit;

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

879 if(!hit) {

880 return true;

881 }

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

883 nearest_hit = fhit;

884 hitface = face;

885 }

886 }

887 }

888 }

889

890 if(nearest_hit.obj) {

891 if(hit) {

892 *hit = nearest_hit;

893

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

895 if(Mesh::intersect_mode & ISECT_FACE) {

896 hit->obj = &hitface;

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

898 hit->obj = &hitvert;

899 } else {

900 hit->obj = this;

901 }

902 }

903 return true;

904 }

905 return false;

906 }

907

908

909 // texture coordinate manipulation

910 void Mesh::texcoord_apply_xform(const Mat4 &xform)

911 {

912 if(!has_attrib(MESH_ATTR_TEXCOORD)) {

913 return;

914 }

915

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

917 Vec4 tc = get_attrib(MESH_ATTR_TEXCOORD, i);

918 set_attrib(MESH_ATTR_TEXCOORD, i, xform * tc);

919 }

920 }

921

922 void Mesh::texcoord_gen_plane(const Vec3 &norm, const Vec3 &tang)

923 {

924 if(!nverts) return;

925

926 if(!has_attrib(MESH_ATTR_TEXCOORD)) {

927 // allocate texture coordinate attribute array

928 set_attrib_data(MESH_ATTR_TEXCOORD, 2, nverts);

929 }

930

931 Vec3 n = normalize(norm);

932 Vec3 b = normalize(cross(n, tang));

933 Vec3 t = cross(b, n);

934

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

936 Vec3 pos = get_attrib(MESH_ATTR_VERTEX, i).xyz();

937

938 // distance along the tangent direction

939 float u = dot(pos, t);

940 // distance along the bitangent direction

941 float v = dot(pos, b);

942

943 set_attrib(MESH_ATTR_TEXCOORD, i, Vec4(u, v, 0, 1));

944 }

945 }

946

947 void Mesh::texcoord_gen_box()

948 {

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

950

951 if(!has_attrib(MESH_ATTR_TEXCOORD)) {

952 // allocate texture coordinate attribute array

953 set_attrib_data(MESH_ATTR_TEXCOORD, 2, nverts);

954 }

955

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

957 Vec3 pos = Vec3(get_attrib(MESH_ATTR_VERTEX, i)) * 0.5 + Vec3(0.5, 0.5, 0.5);

958 Vec3 norm = get_attrib(MESH_ATTR_NORMAL, i).xyz();

959

960 float abs_nx = fabs(norm.x);

961 float abs_ny = fabs(norm.y);

962 float abs_nz = fabs(norm.z);

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

964

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

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

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

968

969 *uvptr++ = pos[j];

970 }

971 set_attrib(MESH_ATTR_TEXCOORD, i, Vec4(uv[0], uv[1], 0, 1));

972 }

973 }

974

975 void Mesh::texcoord_gen_cylinder()

976 {

977 if(!nverts) return;

978

979 if(!has_attrib(MESH_ATTR_TEXCOORD)) {

980 // allocate texture coordinate attribute array

981 set_attrib_data(MESH_ATTR_TEXCOORD, 2, nverts);

982 }

983

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

985 Vec3 pos = get_attrib(MESH_ATTR_VERTEX, i).xyz();

986

987 float rho = sqrt(pos.x * pos.x + pos.z * pos.z);

988 float theta = rho == 0.0 ? 0.0 : atan2(pos.z / rho, pos.x / rho);

989

990 float u = theta / (2.0 * M_PI) + 0.5;

991 float v = pos.y;

992

993 set_attrib(MESH_ATTR_TEXCOORD, i, Vec4(u, v, 0, 1));

994 }

995 }

996

997

998 bool Mesh::dump(const char *fname) const

999 {

1000 FILE *fp = fopen(fname, "wb");

1001 if(fp) {

1002 bool res = dump(fp);

1003 fclose(fp);

1004 return res;

1005 }

1006 return false;

1007 }

1008

1009 bool Mesh::dump(FILE *fp) const

1010 {

1011 if(!has_attrib(MESH_ATTR_VERTEX)) {

1012 return false;

1013 }

1014

1015 fprintf(fp, "VERTEX ATTRIBUTES\n");

1016 static const char *label[] = { "pos", "nor", "tan", "tex", "col", "bw", "bid" };

1017 static const char *elemfmt[] = { 0, " %s(%g)", " %s(%g, %g)", " %s(%g, %g, %g)", " %s(%g, %g, %g, %g)", 0 };

1018

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

1020 fprintf(fp, "%5u:", i);

1021 for(int j=0; j<NUM_MESH_ATTR; j++) {

1022 if(has_attrib(j)) {

1023 Vec4 v = get_attrib(j, i);

1024 int nelem = vattr[j].nelem;

1025 fprintf(fp, elemfmt[nelem], label[j], v.x, v.y, v.z, v.w);

1026 }

1027 }

1028 fputc('\n', fp);

1029 }

1030

1031 if(is_indexed()) {

1032 const unsigned int *idx = get_index_data();

1033 int numidx = get_index_count();

1034 int numtri = numidx / 3;

1035 assert(numidx % 3 == 0);

1036

1037 fprintf(fp, "FACES\n");

1038

1039 for(int i=0; i<numtri; i++) {

1040 fprintf(fp, "%5d: %d %d %d\n", i, idx[0], idx[1], idx[2]);

1041 idx += 3;

1042 }

1043 }

1044 return true;

1045 }

1046

1047 bool Mesh::dump_obj(const char *fname) const

1048 {

1049 FILE *fp = fopen(fname, "wb");

1050 if(fp) {

1051 bool res = dump_obj(fp);

1052 fclose(fp);

1053 return res;

1054 }

1055 return false;

1056 }

1057

1058 bool Mesh::dump_obj(FILE *fp) const

1059 {

1060 if(!has_attrib(MESH_ATTR_VERTEX)) {

1061 return false;

1062 }

1063

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

1065 Vec4 v = get_attrib(MESH_ATTR_VERTEX, i);

1066 fprintf(fp, "v %g %g %g\n", v.x, v.y, v.z);

1067 }

1068

1069 if(has_attrib(MESH_ATTR_NORMAL)) {

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

1071 Vec4 v = get_attrib(MESH_ATTR_NORMAL, i);

1072 fprintf(fp, "vn %g %g %g\n", v.x, v.y, v.z);

1073 }

1074 }

1075

1076 if(has_attrib(MESH_ATTR_TEXCOORD)) {

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

1078 Vec4 v = get_attrib(MESH_ATTR_TEXCOORD, i);

1079 fprintf(fp, "vt %g %g\n", v.x, v.y);

1080 }

1081 }

1082

1083 if(is_indexed()) {

1084 const unsigned int *idxptr = get_index_data();

1085 int numidx = get_index_count();

1086 int numtri = numidx / 3;

1087 assert(numidx % 3 == 0);

1088

1089 for(int i=0; i<numtri; i++) {

1090 fputc('f', fp);

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

1092 unsigned int idx = *idxptr++ + 1;

1093 fprintf(fp, " %u/%u/%u", idx, idx, idx);

1094 }

1095 fputc('\n', fp);

1096 }

1097 } else {

1098 int numtri = nverts / 3;

1099 unsigned int idx = 1;

1100 for(int i=0; i<numtri; i++) {

1101 fputc('f', fp);

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

1103 fprintf(fp, " %u/%u/%u", idx, idx, idx);

1104 ++idx;

1105 }

1106 fputc('\n', fp);

1107 }

1108 }

1109 return true;

1110 }

1111

1112 // ------ private member functions ------

1113

1114 void Mesh::calc_aabb()

1115 {

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

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

1118 return;

1119 }

1120

1121 aabb.min = Vec3(FLT_MAX, FLT_MAX, FLT_MAX);

1122 aabb.max = -aabb.min;

1123

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

1125 Vec4 v = get_attrib(MESH_ATTR_VERTEX, i);

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

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

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

1129 }

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

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

1132 }

1133 }

1134 }

1135 aabb_valid = true;

1136 }

1137

1138 void Mesh::calc_bsph()

1139 {

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

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

1142 return;

1143 }

1144

1145 Vec3 v;

1146 bsph.center = Vec3(0, 0, 0);

1147

1148 // first find the center

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

1150 v = get_attrib(MESH_ATTR_VERTEX, i).xyz();

1151 bsph.center += v;

1152 }

1153 bsph.center /= (float)nverts;

1154

1155 bsph.radius = 0.0f;

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

1157 v = get_attrib(MESH_ATTR_VERTEX, i).xyz();

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

1159 if(dist_sq > bsph.radius) {

1160 bsph.radius = dist_sq;

1161 }

1162 }

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

1164

1165 bsph_valid = true;

1166 }

1167

1168 void Mesh::update_buffers()

1169 {

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

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

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

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

1174 vattr[i].vbo_valid = true;

1175 }

1176 }

1177 glBindBuffer(GL_ARRAY_BUFFER, 0);

1178

1179 if(idata_valid && !ibo_valid) {

1180 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);

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

1182 ibo_valid = true;

1183 }

1184 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

1185 }

1186

1187 void Mesh::update_wire_ibo()

1188 {

1189 update_buffers();

1190

1191 if(wire_ibo_valid) {

1192 return;

1193 }

1194

1195 if(!wire_ibo) {

1196 glGenBuffers(1, &wire_ibo);

1197 }

1198

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

1200 unsigned int *dest = wire_idxarr;

1201

1202 if(ibo_valid) {

1203 // we're dealing with an indexed mesh

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

1205

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

1207 *dest++ = idxarr[0];

1208 *dest++ = idxarr[1];

1209 *dest++ = idxarr[1];

1210 *dest++ = idxarr[2];

1211 *dest++ = idxarr[2];

1212 *dest++ = idxarr[0];

1213 idxarr += 3;

1214 }

1215 } else {

1216 // not an indexed mesh ...

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

1218 int vidx = i * 3;

1219 *dest++ = vidx;

1220 *dest++ = vidx + 1;

1221 *dest++ = vidx + 1;

1222 *dest++ = vidx + 2;

1223 *dest++ = vidx + 2;

1224 *dest++ = vidx;

1225 }

1226 }

1227

1228 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, wire_ibo);

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

1230 delete [] wire_idxarr;

1231 wire_ibo_valid = true;

1232 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

1233 }

1234

1235

1236 // ------ class Triangle ------

1237 Triangle::Triangle()

1238 {

1239 normal_valid = false;

1240 id = -1;

1241 }

1242

1243 Triangle::Triangle(const Vec3 &v0, const Vec3 &v1, const Vec3 &v2)

1244 {

1245 v[0] = v0;

1246 v[1] = v1;

1247 v[2] = v2;

1248 normal_valid = false;

1249 id = -1;

1250 }

1251

1252 Triangle::Triangle(int n, const Vec3 *varr, const unsigned int *idxarr)

1253 {

1254 if(idxarr) {

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

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

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

1258 } else {

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

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

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

1262 }

1263 normal_valid = false;

1264 id = n;

1265 }

1266

1267 void Triangle::calc_normal()

1268 {

1269 normal = normalize(cross(v[1] - v[0], v[2] - v[0]));

1270 normal_valid = true;

1271 }

1272

1273 const Vec3 &Triangle::get_normal() const

1274 {

1275 if(!normal_valid) {

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

1277 }

1278 return normal;

1279 }

1280

1281 void Triangle::transform(const Mat4 &xform)

1282 {

1283 v[0] = xform * v[0];

1284 v[1] = xform * v[1];

1285 v[2] = xform * v[2];

1286 normal_valid = false;

1287 }

1288

1289 void Triangle::draw() const

1290 {

1291 Vec3 n[3];

1292 n[0] = n[1] = n[2] = get_normal();

1293

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

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

1296

1297 glEnableVertexAttribArray(vloc);

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

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

1300

1301 glDrawArrays(GL_TRIANGLES, 0, 3);

1302

1303 glDisableVertexAttribArray(vloc);

1304 glDisableVertexAttribArray(nloc);

1305 }

1306

1307 void Triangle::draw_wire() const

1308 {

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

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

1311

1312 glEnableVertexAttribArray(vloc);

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

1314

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

1316

1317 glDisableVertexAttribArray(vloc);

1318 }

1319

1320 Vec3 Triangle::calc_barycentric(const Vec3 &pos) const

1321 {

1322 Vec3 norm = get_normal();

1323

1324 float area_sq = fabs(dot(cross(v[1] - v[0], v[2] - v[0]), norm));

1325 if(area_sq < 1e-5) {

1326 return Vec3(0, 0, 0);

1327 }

1328

1329 float asq0 = fabs(dot(cross(v[1] - pos, v[2] - pos), norm));

1330 float asq1 = fabs(dot(cross(v[2] - pos, v[0] - pos), norm));

1331 float asq2 = fabs(dot(cross(v[0] - pos, v[1] - pos), norm));

1332

1333 return Vec3(asq0 / area_sq, asq1 / area_sq, asq2 / area_sq);

1334 }

1335

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

1337 {

1338 Vec3 normal = get_normal();

1339

1340 float ndotdir = dot(ray.dir, normal);

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

1342 return false;

1343 }

1344

1345 Vec3 vertdir = v[0] - ray.origin;

1346 float t = dot(normal, vertdir) / ndotdir;

1347

1348 Vec3 pos = ray.origin + ray.dir * t;

1349 Vec3 bary = calc_barycentric(pos);

1350

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

1352 return false;

1353 }

1354

1355 if(hit) {

1356 hit->dist = t;

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

1358 hit->normal = normal;

1359 hit->obj = this;

1360 }

1361 return true;

1362 }