ld33_umonster: bed0e207acb6 src/meshgen.cc

ld33_umonster

view src/meshgen.cc @ 1:bed0e207acb6

improved gen_box

author	John Tsiombikas <nuclear@member.fsf.org>
date	Sat, 22 Aug 2015 23:17:57 +0300
parents	4a6683050e29
children	35349df5392d

line source

1 #include <stdio.h>

2 #include "meshgen.h"

3 #include "mesh.h"

5 // -------- sphere --------

7 #define SURAD(u) ((u) * 2.0 * M_PI)

8 #define SVRAD(v) ((v) * M_PI)

10 static Vector3 sphvec(float theta, float phi)

11 {

12 return Vector3(sin(theta) * sin(phi),

13 cos(phi),

14 cos(theta) * sin(phi));

15 }

17 void gen_sphere(Mesh *mesh, float rad, int usub, int vsub, float urange, float vrange)

18 {

19 if(usub < 4) usub = 4;

20 if(vsub < 2) vsub = 2;

22 int uverts = usub + 1;

23 int vverts = vsub + 1;

25 int num_verts = uverts * vverts;

26 int num_quads = usub * vsub;

27 int num_tri = num_quads * 2;

29 mesh->clear();

30 Vector3 *varr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_VERTEX, 3, num_verts, 0);

31 Vector3 *narr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_NORMAL, 3, num_verts, 0);

32 Vector3 *tarr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_TANGENT, 3, num_verts, 0);

33 Vector2 *uvarr = (Vector2*)mesh->set_attrib_data(MESH_ATTR_TEXCOORD, 2, num_verts, 0);

34 unsigned int *idxarr = mesh->set_index_data(num_tri * 3, 0);

36 float du = urange / (float)(uverts - 1);

37 float dv = vrange / (float)(vverts - 1);

39 float u = 0.0;

40 for(int i=0; i<uverts; i++) {

41 float theta = SURAD(u * urange);

43 float v = 0.0;

44 for(int j=0; j<vverts; j++) {

45 float phi = SVRAD(v * vrange);

47 Vector3 pos = sphvec(theta, phi);

49 *varr++ = pos * rad;

50 *narr++ = pos;

51 *tarr++ = (sphvec(theta + 0.1f, (float)M_PI / 2.0f) - sphvec(theta - 0.1f, (float)M_PI / 2.0f)).normalized();

52 *uvarr++ = Vector2(u * urange, v * vrange);

54 if(i < usub && j < vsub) {

55 int idx = i * vverts + j;

56 *idxarr++ = idx;

57 *idxarr++ = idx + 1;

58 *idxarr++ = idx + vverts + 1;

60 *idxarr++ = idx;

61 *idxarr++ = idx + vverts + 1;

62 *idxarr++ = idx + vverts;

63 }

65 v += dv;

66 }

67 u += du;

68 }

69 }

72 // -------- cylinder --------

74 static Vector3 cylvec(float theta, float height)

75 {

76 return Vector3(sin(theta), height, cos(theta));

77 }

79 void gen_cylinder(Mesh *mesh, float rad, float height, int usub, int vsub, int capsub, float urange, float vrange)

80 {

81 if(usub < 4) usub = 4;

82 if(vsub < 1) vsub = 1;

84 int uverts = usub + 1;

85 int vverts = vsub + 1;

87 int num_body_verts = uverts * vverts;

88 int num_body_quads = usub * vsub;

89 int num_body_tri = num_body_quads * 2;

91 int capvverts = capsub ? capsub + 1 : 0;

92 int num_cap_verts = uverts * capvverts;

93 int num_cap_quads = usub * capsub;

94 int num_cap_tri = num_cap_quads * 2;

96 int num_verts = num_body_verts + num_cap_verts * 2;

97 int num_tri = num_body_tri + num_cap_tri * 2;

99 mesh->clear();

100 Vector3 *varr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_VERTEX, 3, num_verts, 0);

101 Vector3 *narr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_NORMAL, 3, num_verts, 0);

102 Vector3 *tarr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_TANGENT, 3, num_verts, 0);

103 Vector2 *uvarr = (Vector2*)mesh->set_attrib_data(MESH_ATTR_TEXCOORD, 2, num_verts, 0);

104 unsigned int *idxarr = mesh->set_index_data(num_tri * 3, 0);

105

106 float du = urange / (float)(uverts - 1);

107 float dv = vrange / (float)(vverts - 1);

108

109 float u = 0.0;

110 for(int i=0; i<uverts; i++) {

111 float theta = SURAD(u);

112

113 float v = 0.0;

114 for(int j=0; j<vverts; j++) {

115 float y = (v - 0.5) * height;

116 Vector3 pos = cylvec(theta, y);

117

118 *varr++ = Vector3(pos.x * rad, pos.y, pos.z * rad);

119 *narr++ = Vector3(pos.x, 0.0, pos.z);

120 *tarr++ = (cylvec(theta + 0.1, 0.0) - cylvec(theta - 0.1, 0.0)).normalized();

121 *uvarr++ = Vector2(u * urange, v * vrange);

122

123 if(i < usub && j < vsub) {

124 int idx = i * vverts + j;

125

126 *idxarr++ = idx;

127 *idxarr++ = idx + vverts + 1;

128 *idxarr++ = idx + 1;

129

130 *idxarr++ = idx;

131 *idxarr++ = idx + vverts;

132 *idxarr++ = idx + vverts + 1;

133 }

134

135 v += dv;

136 }

137 u += du;

138 }

139

140

141 // now the cap!

142 if(!capsub) {

143 return;

144 }

145

146 dv = 1.0 / (float)(capvverts - 1);

147

148 u = 0.0;

149 for(int i=0; i<uverts; i++) {

150 float theta = SURAD(u);

151

152 float v = 0.0;

153 for(int j=0; j<capvverts; j++) {

154 float r = v * rad;

155

156 Vector3 pos = cylvec(theta, height / 2.0) * r;

157 pos.y = height / 2.0;

158 Vector3 tang = (cylvec(theta + 0.1, 0.0) - cylvec(theta - 0.1, 0.0)).normalized();

159

160 *varr++ = pos;

161 *narr++ = Vector3(0, 1, 0);

162 *tarr++ = tang;

163 *uvarr++ = Vector2(u * urange, v);

164

165 pos.y = -height / 2.0;

166 *varr++ = pos;

167 *narr++ = Vector3(0, -1, 0);

168 *tarr++ = -tang;

169 *uvarr++ = Vector2(u * urange, v);

170

171 if(i < usub && j < capsub) {

172 unsigned int idx = num_body_verts + (i * capvverts + j) * 2;

173

174 unsigned int vidx[4] = {

175 idx,

176 idx + capvverts * 2,

177 idx + (capvverts + 1) * 2,

178 idx + 2

179 };

180

181 *idxarr++ = vidx[0];

182 *idxarr++ = vidx[2];

183 *idxarr++ = vidx[1];

184 *idxarr++ = vidx[0];

185 *idxarr++ = vidx[3];

186 *idxarr++ = vidx[2];

187

188 *idxarr++ = vidx[0] + 1;

189 *idxarr++ = vidx[1] + 1;

190 *idxarr++ = vidx[2] + 1;

191 *idxarr++ = vidx[0] + 1;

192 *idxarr++ = vidx[2] + 1;

193 *idxarr++ = vidx[3] + 1;

194 }

195

196 v += dv;

197 }

198 u += du;

199 }

200 }

201

202 // -------- cone --------

203

204 static Vector3 conevec(float theta, float y, float height)

205 {

206 float scale = 1.0 - y / height;

207 return Vector3(sin(theta) * scale, y, cos(theta) * scale);

208 }

209

210 void gen_cone(Mesh *mesh, float rad, float height, int usub, int vsub, int capsub, float urange, float vrange)

211 {

212 if(usub < 4) usub = 4;

213 if(vsub < 1) vsub = 1;

214

215 int uverts = usub + 1;

216 int vverts = vsub + 1;

217

218 int num_body_verts = uverts * vverts;

219 int num_body_quads = usub * vsub;

220 int num_body_tri = num_body_quads * 2;

221

222 int capvverts = capsub ? capsub + 1 : 0;

223 int num_cap_verts = uverts * capvverts;

224 int num_cap_quads = usub * capsub;

225 int num_cap_tri = num_cap_quads * 2;

226

227 int num_verts = num_body_verts + num_cap_verts;

228 int num_tri = num_body_tri + num_cap_tri;

229

230 mesh->clear();

231 Vector3 *varr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_VERTEX, 3, num_verts, 0);

232 Vector3 *narr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_NORMAL, 3, num_verts, 0);

233 Vector3 *tarr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_TANGENT, 3, num_verts, 0);

234 Vector2 *uvarr = (Vector2*)mesh->set_attrib_data(MESH_ATTR_TEXCOORD, 2, num_verts, 0);

235 unsigned int *idxarr = mesh->set_index_data(num_tri * 3, 0);

236

237 float du = urange / (float)(uverts - 1);

238 float dv = vrange / (float)(vverts - 1);

239

240 float u = 0.0;

241 for(int i=0; i<uverts; i++) {

242 float theta = SURAD(u);

243

244 float v = 0.0;

245 for(int j=0; j<vverts; j++) {

246 float y = v * height;

247 Vector3 pos = conevec(theta, y, height);

248

249 Vector3 tang = (conevec(theta + 0.1, 0.0, height) - conevec(theta - 0.1, 0.0, height)).normalized();

250 Vector3 bitang = (conevec(theta, y + 0.1, height) - pos).normalized();

251

252 *varr++ = Vector3(pos.x * rad, pos.y, pos.z * rad);

253 *narr++ = cross_product(tang, bitang);

254 *tarr++ = tang;

255 *uvarr++ = Vector2(u * urange, v * vrange);

256

257 if(i < usub && j < vsub) {

258 int idx = i * vverts + j;

259

260 *idxarr++ = idx;

261 *idxarr++ = idx + vverts + 1;

262 *idxarr++ = idx + 1;

263

264 *idxarr++ = idx;

265 *idxarr++ = idx + vverts;

266 *idxarr++ = idx + vverts + 1;

267 }

268

269 v += dv;

270 }

271 u += du;

272 }

273

274

275 // now the bottom cap!

276 if(!capsub) {

277 return;

278 }

279

280 dv = 1.0 / (float)(capvverts - 1);

281

282 u = 0.0;

283 for(int i=0; i<uverts; i++) {

284 float theta = SURAD(u);

285

286 float v = 0.0;

287 for(int j=0; j<capvverts; j++) {

288 float r = v * rad;

289

290 Vector3 pos = conevec(theta, 0.0, height) * r;

291 Vector3 tang = (cylvec(theta + 0.1, 0.0) - cylvec(theta - 0.1, 0.0)).normalized();

292

293 *varr++ = pos;

294 *narr++ = Vector3(0, -1, 0);

295 *tarr++ = tang;

296 *uvarr++ = Vector2(u * urange, v);

297

298 if(i < usub && j < capsub) {

299 unsigned int idx = num_body_verts + i * capvverts + j;

300

301 unsigned int vidx[4] = {

302 idx,

303 idx + capvverts,

304 idx + (capvverts + 1),

305 idx + 1

306 };

307

308 *idxarr++ = vidx[0];

309 *idxarr++ = vidx[1];

310 *idxarr++ = vidx[2];

311 *idxarr++ = vidx[0];

312 *idxarr++ = vidx[2];

313 *idxarr++ = vidx[3];

314 }

315

316 v += dv;

317 }

318 u += du;

319 }

320 }

321

322

323 // -------- plane --------

324

325 void gen_plane(Mesh *mesh, float width, float height, int usub, int vsub)

326 {

327 gen_heightmap(mesh, width, height, usub, vsub, 0);

328 }

329

330

331 // ----- heightmap ------

332

333 void gen_heightmap(Mesh *mesh, float width, float height, int usub, int vsub, float (*hf)(float, float, void*), void *hfdata)

334 {

335 if(usub < 1) usub = 1;

336 if(vsub < 1) vsub = 1;

337

338 mesh->clear();

339

340 int uverts = usub + 1;

341 int vverts = vsub + 1;

342 int num_verts = uverts * vverts;

343

344 int num_quads = usub * vsub;

345 int num_tri = num_quads * 2;

346

347 Vector3 *varr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_VERTEX, 3, num_verts, 0);

348 Vector3 *narr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_NORMAL, 3, num_verts, 0);

349 Vector3 *tarr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_TANGENT, 3, num_verts, 0);

350 Vector2 *uvarr = (Vector2*)mesh->set_attrib_data(MESH_ATTR_TEXCOORD, 2, num_verts, 0);

351 unsigned int *idxarr = mesh->set_index_data(num_tri * 3, 0);

352

353 float du = 1.0 / (float)usub;

354 float dv = 1.0 / (float)vsub;

355

356 float u = 0.0;

357 for(int i=0; i<uverts; i++) {

358 float v = 0.0;

359 for(int j=0; j<vverts; j++) {

360 float x = (u - 0.5) * width;

361 float y = (v - 0.5) * height;

362 float z = hf ? hf(u, v, hfdata) : 0.0;

363

364 Vector3 normal = Vector3(0, 0, 1);

365 if(hf) {

366 float u1z = hf(u + du, v, hfdata);

367 float v1z = hf(u, v + dv, hfdata);

368

369 Vector3 tang = Vector3(du * width, 0, u1z - z);

370 Vector3 bitan = Vector3(0, dv * height, v1z - z);

371 normal = cross_product(tang, bitan).normalized();

372 }

373

374 *varr++ = Vector3(x, y, z);

375 *narr++ = normal;

376 *tarr++ = Vector3(1, 0, 0);

377 *uvarr++ = Vector2(u, v);

378

379 if(i < usub && j < vsub) {

380 int idx = i * vverts + j;

381

382 *idxarr++ = idx;

383 *idxarr++ = idx + vverts + 1;

384 *idxarr++ = idx + 1;

385

386 *idxarr++ = idx;

387 *idxarr++ = idx + vverts;

388 *idxarr++ = idx + vverts + 1;

389 }

390

391 v += dv;

392 }

393 u += du;

394 }

395 }

396

397 // ----- box ------

398 void gen_box(Mesh *mesh, float xsz, float ysz, float zsz, int usub, int vsub)

399 {

400 static const float face_angles[][2] = {

401 {0, 0},

402 {M_PI / 2.0, 0},

403 {M_PI, 0},

404 {3.0 * M_PI / 2.0, 0},

405 {0, M_PI / 2.0},

406 {0, -M_PI / 2.0}

407 };

408

409 if(usub < 1) usub = 1;

410 if(vsub < 1) vsub = 1;

411

412 mesh->clear();

413

414 for(int i=0; i<6; i++) {

415 Matrix4x4 xform;

416 Mesh m;

417

418 gen_plane(&m, 1, 1, usub, vsub);

419 xform.rotate(Vector3(face_angles[i][1], face_angles[i][0], 0));

420 xform.translate(Vector3(0, 0, 0.5));

421 m.apply_xform(xform);

422

423 mesh->append(m);

424 }

425

426 Matrix4x4 scale;

427 scale.set_scaling(Vector3(xsz, ysz, zsz));

428 mesh->apply_xform(scale, Matrix4x4::identity);

429 }

430

431 /*

432 void gen_box(Mesh *mesh, float xsz, float ysz, float zsz)

433 {

434 mesh->clear();

435

436 const int num_faces = 6;

437 int num_verts = num_faces * 4;

438 int num_tri = num_faces * 2;

439

440 float x = xsz / 2.0;

441 float y = ysz / 2.0;

442 float z = zsz / 2.0;

443

444 Vector3 *varr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_VERTEX, 3, num_verts, 0);

445 Vector3 *narr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_NORMAL, 3, num_verts, 0);

446 Vector3 *tarr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_TANGENT, 3, num_verts, 0);

447 Vector2 *uvarr = (Vector2*)mesh->set_attrib_data(MESH_ATTR_TEXCOORD, 2, num_verts, 0);

448 unsigned int *idxarr = mesh->set_index_data(num_tri * 3, 0);

449

450 static const Vector2 uv[] = { Vector2(0, 0), Vector2(1, 0), Vector2(1, 1), Vector2(0, 1) };

451

452 // front

453 for(int i=0; i<4; i++) {

454 *narr++ = Vector3(0, 0, 1);

455 *tarr++ = Vector3(1, 0, 0);

456 *uvarr++ = uv[i];

457 }

458 *varr++ = Vector3(-x, -y, z);

459 *varr++ = Vector3(x, -y, z);

460 *varr++ = Vector3(x, y, z);

461 *varr++ = Vector3(-x, y, z);

462 // right

463 for(int i=0; i<4; i++) {

464 *narr++ = Vector3(1, 0, 0);

465 *tarr++ = Vector3(0, 0, -1);

466 *uvarr++ = uv[i];

467 }

468 *varr++ = Vector3(x, -y, z);

469 *varr++ = Vector3(x, -y, -z);

470 *varr++ = Vector3(x, y, -z);

471 *varr++ = Vector3(x, y, z);

472 // back

473 for(int i=0; i<4; i++) {

474 *narr++ = Vector3(0, 0, -1);

475 *tarr++ = Vector3(-1, 0, 0);

476 *uvarr++ = uv[i];

477 }

478 *varr++ = Vector3(x, -y, -z);

479 *varr++ = Vector3(-x, -y, -z);

480 *varr++ = Vector3(-x, y, -z);

481 *varr++ = Vector3(x, y, -z);

482 // left

483 for(int i=0; i<4; i++) {

484 *narr++ = Vector3(-1, 0, 0);

485 *tarr++ = Vector3(0, 0, 1);

486 *uvarr++ = uv[i];

487 }

488 *varr++ = Vector3(-x, -y, -z);

489 *varr++ = Vector3(-x, -y, z);

490 *varr++ = Vector3(-x, y, z);

491 *varr++ = Vector3(-x, y, -z);

492 // top

493 for(int i=0; i<4; i++) {

494 *narr++ = Vector3(0, 1, 0);

495 *tarr++ = Vector3(1, 0, 0);

496 *uvarr++ = uv[i];

497 }

498 *varr++ = Vector3(-x, y, z);

499 *varr++ = Vector3(x, y, z);

500 *varr++ = Vector3(x, y, -z);

501 *varr++ = Vector3(-x, y, -z);

502 // bottom

503 for(int i=0; i<4; i++) {

504 *narr++ = Vector3(0, -1, 0);

505 *tarr++ = Vector3(1, 0, 0);

506 *uvarr++ = uv[i];

507 }

508 *varr++ = Vector3(-x, -y, -z);

509 *varr++ = Vector3(x, -y, -z);

510 *varr++ = Vector3(x, -y, z);

511 *varr++ = Vector3(-x, -y, z);

512

513 // index array

514 static const int faceidx[] = {0, 1, 2, 0, 2, 3};

515 for(int i=0; i<num_faces; i++) {

516 for(int j=0; j<6; j++) {

517 *idxarr++ = faceidx[j] + i * 4;

518 }

519 }

520 }

521 */

522

523 static inline Vector3 rev_vert(float u, float v, Vector2 (*rf)(float, float, void*), void *cls)

524 {

525 Vector2 pos = rf(u, v, cls);

526

527 float angle = u * 2.0 * M_PI;

528 float x = pos.x * cos(angle);

529 float y = pos.y;

530 float z = pos.x * sin(angle);

531

532 return Vector3(x, y, z);

533 }

534

535 // ------ surface of revolution -------

536 void gen_revol(Mesh *mesh, int usub, int vsub, Vector2 (*rfunc)(float, float, void*), void *cls)

537 {

538 gen_revol(mesh, usub, vsub, rfunc, 0, cls);

539 }

540

541 void gen_revol(Mesh *mesh, int usub, int vsub, Vector2 (*rfunc)(float, float, void*),

542 Vector2 (*nfunc)(float, float, void*), void *cls)

543 {

544 if(!rfunc) return;

545 if(usub < 3) usub = 3;

546 if(vsub < 1) vsub = 1;

547

548 mesh->clear();

549

550 int uverts = usub + 1;

551 int vverts = vsub + 1;

552 int num_verts = uverts * vverts;

553

554 int num_quads = usub * vsub;

555 int num_tri = num_quads * 2;

556

557 Vector3 *varr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_VERTEX, 3, num_verts, 0);

558 Vector3 *narr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_NORMAL, 3, num_verts, 0);

559 Vector3 *tarr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_TANGENT, 3, num_verts, 0);

560 Vector2 *uvarr = (Vector2*)mesh->set_attrib_data(MESH_ATTR_TEXCOORD, 2, num_verts, 0);

561 unsigned int *idxarr = mesh->set_index_data(num_tri * 3, 0);

562

563 float du = 1.0 / (float)(uverts - 1);

564 float dv = 1.0 / (float)(vverts - 1);

565

566 float u = 0.0;

567 for(int i=0; i<uverts; i++) {

568 float v = 0.0;

569 for(int j=0; j<vverts; j++) {

570 Vector3 pos = rev_vert(u, v, rfunc, cls);

571

572 Vector3 nextu = rev_vert(fmod(u + du, 1.0), v, rfunc, cls);

573 Vector3 tang = nextu - pos;

574 if(tang.length_sq() < 1e-6) {

575 float new_v = v > 0.5 ? v - dv * 0.25 : v + dv * 0.25;

576 nextu = rev_vert(fmod(u + du, 1.0), new_v, rfunc, cls);

577 tang = nextu - pos;

578 }

579

580 Vector3 normal;

581 if(nfunc) {

582 normal = rev_vert(u, v, nfunc, cls);

583 } else {

584 Vector3 nextv = rev_vert(u, v + dv, rfunc, cls);

585 Vector3 bitan = nextv - pos;

586 if(bitan.length_sq() < 1e-6) {

587 nextv = rev_vert(u, v - dv, rfunc, cls);

588 bitan = pos - nextv;

589 }

590

591 normal = cross_product(tang, bitan);

592 }

593

594 *varr++ = pos;

595 *narr++ = normal.normalized();

596 *tarr++ = tang.normalized();

597 *uvarr++ = Vector2(u, v);

598

599 if(i < usub && j < vsub) {

600 int idx = i * vverts + j;

601

602 *idxarr++ = idx;

603 *idxarr++ = idx + vverts + 1;

604 *idxarr++ = idx + 1;

605

606 *idxarr++ = idx;

607 *idxarr++ = idx + vverts;

608 *idxarr++ = idx + vverts + 1;

609 }

610

611 v += dv;

612 }

613 u += du;

614 }

615 }