eqemu: 3d3656360a82 src/objfile.cc

eqemu

view src/objfile.cc @ 4:3d3656360a82

rendering properly, added picking, almost done...

author	John Tsiombikas <nuclear@member.fsf.org>
date	Thu, 17 Jul 2014 08:51:17 +0300
parents	f9274bebe55e
children	9b5bb05ae53a

line source

1 #include <stdlib.h>

2 #include <string.h>

3 #include <ctype.h>

4 #include <limits.h>

5 #include <assert.h>

6 #include <vector>

7 #include <map>

8 #include <string>

9 #include <sstream>

10 #include <iomanip>

11 #include "scene.h"

13 using namespace std;

15 #define COMMANDS \

16 CMD(V), \

17 CMD(VN), \

18 CMD(VT), \

19 CMD(F), \

20 CMD(O), \

21 CMD(G), \

22 CMD(MTLLIB), \

23 CMD(USEMTL), \

24 CMD(NEWMTL), \

25 CMD(KA), \

26 CMD(KD), \

27 CMD(KS), \

28 CMD(NS), \

29 CMD(NI), \

30 CMD(D), \

31 CMD(TR), \

32 CMD(MAP_KD), \

33 CMD(MAP_KS), \

34 CMD(MAP_NS), \

35 CMD(MAP_D), \

36 CMD(REFL), \

37 CMD(BUMP)

39 #define CMD(x) CMD_##x

40 enum {

41 COMMANDS,

42 CMD_UNK

43 };

44 #undef CMD

46 #define CMD(x) #x

47 static const char *cmd_names[] = {

48 COMMANDS,

49 0

50 };

51 #undef CMD

54 struct ObjFace {

55 int elem;

56 int v[4], n[4], t[4];

57 };

59 struct ObjFile {

60 string cur_obj, cur_mat;

61 vector<Vector3> v, vn;

62 vector<Vector2> vt;

63 vector<ObjFace> f;

64 };

66 typedef Vector3 Color;

68 struct ObjMat {

69 string name; // newmtl <name>

70 Color ambient, diffuse, specular; // Ka, Kd, Ks

71 float shininess; // Ns

72 float ior; // Ni

73 float alpha; // d, Tr

75 string tex_dif, tex_spec, tex_shin, tex_alpha; // map_Kd, map_Ks, map_Ns, map_d

76 string tex_refl; // refl -type sphere|cube file

77 string tex_bump; // bump

79 ObjMat() { reset(); }

81 void reset() {

82 ambient = diffuse = Color(0.5, 0.5, 0.5);

83 specular = Color(0.0, 0.0, 0.0);

84 name = tex_dif = tex_spec = tex_shin = tex_alpha = tex_refl = tex_bump = "";

85 shininess = 0;

86 ior = alpha = 1;

87 }

88 };

90 static bool read_materials(FILE *fp, vector<ObjMat> *vmtl);

91 static Object *cons_object(ObjFile *obj);

93 static int get_cmd(char *str);

94 static bool is_int(const char *str);

95 static bool is_float(const char *str);

96 static bool parse_vec(Vector3 *vec);

97 static bool parse_color(Color *col);

98 static bool parse_face(ObjFace *face);

99 static const char *parse_map();

100

101

102 static map<string, Material> matlib;

103

104

105 #define INVALID_IDX INT_MIN

106

107 #define SEP " \t\n\r\v"

108 #define BUF_SZ 512

109 bool Scene::load_obj(FILE *fp)

110 {

111 static int seq;

112 char cur_name[16];

113 stringstream sstr;

114

115 ObjFile obj;

116

117 sprintf(cur_name, "default%02d.obj", seq++);

118 obj.cur_obj = cur_name;

119

120 int prev_cmd = 0, obj_added = 0;

121 for(;;) {

122 Vector3 vec;

123 ObjFace face;

124

125 char line[BUF_SZ];

126 fgets(line, sizeof line, fp);

127 if(feof(fp)) {

128 break;

129 }

130

131 char *tok;

132 if(!(tok = strtok(line, SEP))) {

133 continue; // ignore empty lines

134 }

135

136 int cmd;

137 if((cmd = get_cmd(tok)) == -1) {

138 continue; // ignore unknown commands ...

139 }

140

141 switch(cmd) {

142 case CMD_V:

143 if(!parse_vec(&vec)) {

144 continue;

145 }

146 obj.v.push_back(vec);

147 break;

148

149 case CMD_VN:

150 if(!parse_vec(&vec)) {

151 continue;

152 }

153 obj.vn.push_back(vec);

154 break;

155

156 case CMD_VT:

157 if(!parse_vec(&vec)) {

158 continue;

159 }

160 vec.y = 1.0 - vec.y;

161 obj.vt.push_back(Vector2(vec.x, vec.y));

162 break;

163

164 case CMD_O:

165 case CMD_G:

166 if(prev_cmd == CMD_O || prev_cmd == CMD_G) {

167 break; // just in case we've got both of them in a row

168 }

169 /* if we have any previous data, group them up, add the object

170 * and continue with the new one...

171 */

172 if(!obj.f.empty()) {

173 Object *robj = cons_object(&obj);

174 robj->mtl = matlib[obj.cur_mat];

175 add_object(robj);

176 obj_added++;

177

178 obj.f.clear(); // clean the face list

179 }

180 if((tok = strtok(0, SEP))) {

181 obj.cur_obj = tok;

182 } else {

183 sprintf(cur_name, "default%02d.obj", seq++);

184 obj.cur_obj = cur_name;

185 }

186 break;

187

188 case CMD_MTLLIB:

189 if((tok = strtok(0, SEP))) {

190 FILE *mfile;

191 if(!(mfile = fopen(tok, "rb"))) {

192 fprintf(stderr, "failed to open material library: %s\n", tok);

193 continue;

194 }

195

196 // load all materials of the mtl file into a vector

197 vector<ObjMat> vmtl;

198 if(!read_materials(mfile, &vmtl)) {

199 continue;

200 }

201 fclose(mfile);

202

203 // and add them all to the scene

204 for(size_t i=0; i<vmtl.size(); i++) {

205 Material mat;

206 mat.ambient = vmtl[i].ambient;

207 mat.diffuse = vmtl[i].diffuse;

208 mat.specular = vmtl[i].specular;

209 mat.shininess = vmtl[i].shininess;

210 mat.alpha = vmtl[i].alpha;

211

212 /*if(vmtl[i].tex_dif.length()) {

213 mat.set_texture(get_texture(vmtl[i].tex_dif.c_str()));

214 }*/

215

216 matlib[vmtl[i].name] = mat;

217 }

218 }

219 break;

220

221 case CMD_USEMTL:

222 if((tok = strtok(0, SEP))) {

223 obj.cur_mat = tok;

224 } else {

225 obj.cur_mat = "";

226 }

227 break;

228

229 case CMD_F:

230 if(!parse_face(&face)) {

231 continue;

232 }

233

234 // convert negative indices to regular indices

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

236 if(face.v[i] < 0 && face.v[i] != INVALID_IDX) {

237 face.v[i] = obj.v.size() + face.v[i];

238 }

239 if(face.n[i] < 0 && face.n[i] != INVALID_IDX) {

240 face.n[i] = obj.vn.size() + face.n[i];

241 }

242 if(face.t[i] < 0 && face.t[i] != INVALID_IDX) {

243 face.t[i] = obj.vt.size() + face.t[i];

244 }

245 }

246

247 // break quads into triangles if needed

248 obj.f.push_back(face);

249 if(face.elem == 4) {

250 face.v[1] = face.v[2];

251 face.n[1] = face.n[2];

252 face.t[1] = face.t[2];

253

254 face.v[2] = face.v[3];

255 face.n[2] = face.n[3];

256 face.t[2] = face.t[3];

257

258 obj.f.push_back(face);

259 }

260 break;

261

262 default:

263 break; // ignore unknown commands

264 }

265

266 prev_cmd = cmd;

267 }

268

269 // reached end of file...

270 if(!obj.f.empty()) {

271 Object *robj = cons_object(&obj);

272 robj->mtl = matlib[obj.cur_mat];

273 add_object(robj);

274 obj_added++;

275 }

276

277 return obj_added > 0;

278 }

279

280 static Object *cons_object(ObjFile *obj)

281 {

282 Object *robj;

283 Vector3 *varr, *narr;

284 Vector2 *tarr;

285

286 int nelem = obj->f.size() * 3;

287

288 assert(sizeof(Vector3) == 3 * sizeof(float));

289 assert(sizeof(Vector2) == 2 * sizeof(float));

290

291 try {

292 robj = new Object;

293 varr = new Vector3[nelem];

294 narr = new Vector3[nelem];

295 tarr = new Vector2[nelem];

296 }

297 catch(...) {

298 return 0;

299 }

300 if(obj->cur_obj.length() > 0) {

301 robj->set_name(obj->cur_obj.c_str());

302 }

303

304 // need at least one of each element

305 bool added_norm = false, added_tc = false;

306 if(obj->vn.empty()) {

307 obj->vn.push_back(Vector3(0, 0, 0));

308 added_norm = true;

309 }

310 if(obj->vt.empty()) {

311 obj->vt.push_back(Vector2(0, 0));

312 added_tc = true;

313 }

314

315 for(size_t i=0; i<obj->f.size(); i++) {

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

317 int idx = i * 3 + j;

318 ObjFace *f = &obj->f[i];

319

320 varr[idx] = obj->v[f->v[j]];

321 narr[idx] = obj->vn[f->n[j] < 0 ? 0 : f->n[j]];

322

323 float t = obj->vt[f->t[j] < 0 ? 0 : f->t[j]].x;

324 float s = obj->vt[f->t[j] < 0 ? 0 : f->t[j]].y;

325 tarr[idx] = Vector2(t, s);

326 }

327 }

328

329 if(added_norm) {

330 obj->vn.pop_back();

331 }

332 if(added_tc) {

333 obj->vt.pop_back();

334 }

335

336 Mesh *mesh = new Mesh;

337 mesh->set_attrib(MESH_ATTR_VERTEX, nelem, 3, &varr->x);

338 mesh->set_attrib(MESH_ATTR_NORMAL, nelem, 3, &narr->x);

339 mesh->set_attrib(MESH_ATTR_TEXCOORD, nelem, 2, &tarr->x);

340 robj->set_mesh(mesh);

341

342 printf("loaded object %s: %d faces\n", obj->cur_obj.c_str(), nelem / 3);

343

344 delete [] varr;

345 delete [] narr;

346 delete [] tarr;

347 return robj;

348 }

349

350 static bool read_materials(FILE *fp, vector<ObjMat> *vmtl)

351 {

352 ObjMat mat;

353

354 for(;;) {

355 char line[BUF_SZ];

356 fgets(line, sizeof line, fp);

357 if(feof(fp)) {

358 break;

359 }

360

361 char *tok;

362 if(!(tok = strtok(line, SEP))) {

363 continue;

364 }

365

366 int cmd;

367 if((cmd = get_cmd(tok)) == -1) {

368 continue;

369 }

370

371 switch(cmd) {

372 case CMD_NEWMTL:

373 // add the previous material, and start a new one

374 if(mat.name.length() > 0) {

375 vmtl->push_back(mat);

376 mat.reset();

377 }

378 if((tok = strtok(0, SEP))) {

379 mat.name = tok;

380 }

381 break;

382

383 case CMD_KA:

384 parse_color(&mat.ambient);

385 break;

386

387 case CMD_KD:

388 parse_color(&mat.diffuse);

389 break;

390

391 case CMD_KS:

392 parse_color(&mat.specular);

393 break;

394

395 case CMD_NS:

396 if((tok = strtok(0, SEP)) && is_float(tok)) {

397 mat.shininess = atof(tok);

398 }

399 break;

400

401 case CMD_NI:

402 if((tok = strtok(0, SEP)) && is_float(tok)) {

403 mat.ior = atof(tok);

404 }

405 break;

406

407 case CMD_D:

408 case CMD_TR:

409 {

410 Color c;

411 if(parse_color(&c)) {

412 mat.alpha = cmd == CMD_D ? c.x : 1.0 - c.x;

413 }

414 }

415 break;

416

417 case CMD_MAP_KD:

418 mat.tex_dif = parse_map();

419 break;

420

421 default:

422 break;

423 }

424 }

425

426 if(mat.name.length() > 0) {

427 vmtl->push_back(mat);

428 }

429 return true;

430 }

431

432 static int get_cmd(char *str)

433 {

434 char *s = str;

435 while((*s = toupper(*s))) s++;

436

437 for(int i=0; cmd_names[i]; i++) {

438 if(strcmp(str, cmd_names[i]) == 0) {

439 return i;

440 }

441 }

442 return CMD_UNK;

443 }

444

445 static bool is_int(const char *str)

446 {

447 char *tmp;

448 strtol(str, &tmp, 10);

449 return tmp != str;

450 }

451

452 static bool is_float(const char *str)

453 {

454 char *tmp;

455 strtod(str, &tmp);

456 return tmp != str;

457 }

458

459 static bool parse_vec(Vector3 *vec)

460 {

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

462 char *tok;

463

464 if(!(tok = strtok(0, SEP)) || !is_float(tok)) {

465 if(i < 2) {

466 return false;

467 }

468 vec->z = 0.0;

469 } else {

470 (*vec)[i] = atof(tok);

471 }

472 }

473 return true;

474 }

475

476 static bool parse_color(Color *col)

477 {

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

479 char *tok;

480

481 if(!(tok = strtok(0, SEP)) || !is_float(tok)) {

482 col->y = col->z = col->x;

483 return i > 0 ? true : false;

484 }

485 (*col)[i] = atof(tok);

486 }

487 return true;

488 }

489

490 static bool parse_face(ObjFace *face)

491 {

492 char *tok[] = {0, 0, 0, 0};

493 face->elem = 0;

494

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

496 if((!(tok[i] = strtok(0, SEP)) || !is_int(tok[i]))) {

497 if(i < 3) return false; // less than 3 verts? not a polygon

498 } else {

499 face->elem++;

500 }

501 }

502

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

504 char *subtok = tok[i];

505

506 if(!subtok || !*subtok || !is_int(subtok)) {

507 if(i < 3) {

508 return false;

509 }

510 face->v[i] = INVALID_IDX;

511 } else {

512 face->v[i] = atoi(subtok);

513 if(face->v[i] > 0) face->v[i]--; /* convert to 0-based */

514 }

515

516 while(subtok && *subtok && *subtok != '/') {

517 subtok++;

518 }

519 if(subtok && *subtok && *++subtok && is_int(subtok)) {

520 face->t[i] = atoi(subtok);

521 if(face->t[i] > 0) face->t[i]--; /* convert to 0-based */

522 } else {

523 face->t[i] = INVALID_IDX;

524 }

525

526 while(subtok && *subtok && *subtok != '/') {

527 subtok++;

528 }

529 if(subtok && *subtok && *++subtok && is_int(subtok)) {

530 face->n[i] = atoi(subtok);

531 if(face->n[i] > 0) face->n[i]--; /* convert to 0-based */

532 } else {

533 face->n[i] = INVALID_IDX;

534 }

535 }

536

537 return true;

538 }

539

540 static const char *parse_map()

541 {

542 char *tok, *prev = 0;

543

544 while((tok = strtok(0, SEP))) {

545 prev = tok;

546 }

547

548 return prev ? prev : "";

549 }