1 |
#ifndef lint |
2 |
static const char RCSid[] = "$Id: objutil.c,v 2.12 2021/02/12 20:44:04 greg Exp $"; |
3 |
#endif |
4 |
/* |
5 |
* Basic .OBJ scene handling routines. |
6 |
* |
7 |
* Created by Greg Ward on Wed Feb 11 2004. |
8 |
*/ |
9 |
|
10 |
#include <stdlib.h> |
11 |
#include <ctype.h> |
12 |
#include "rtio.h" |
13 |
#include "rtmath.h" |
14 |
#include "rterror.h" |
15 |
#include "lookup.h" |
16 |
#include "objutil.h" |
17 |
|
18 |
/* Find an existing name in a list of names */ |
19 |
int |
20 |
findName(const char *nm, const char **nmlist, int n) |
21 |
{ |
22 |
int i; |
23 |
|
24 |
for (i = n; i-- > 0; ) |
25 |
if (!strcmp(nmlist[i], nm)) |
26 |
break; |
27 |
return(i); |
28 |
} |
29 |
|
30 |
/* Clear face selection */ |
31 |
void |
32 |
clearSelection(Scene *sc, int set) |
33 |
{ |
34 |
Face *f; |
35 |
|
36 |
for (f = sc->flist; f != NULL; f = f->next) |
37 |
if (set) |
38 |
f->flags |= FACE_SELECTED; |
39 |
else |
40 |
f->flags &= ~FACE_SELECTED; |
41 |
} |
42 |
|
43 |
/* Select faces by object name (modifies current) */ |
44 |
void |
45 |
selectGroup(Scene *sc, const char *gname, int invert) |
46 |
{ |
47 |
int gid = getGroupID(sc, gname); |
48 |
Face *f; |
49 |
|
50 |
if (gid < 0) |
51 |
return; |
52 |
for (f = sc->flist; f != NULL; f = f->next) |
53 |
if (f->grp == gid) { |
54 |
if (invert) |
55 |
f->flags &= ~FACE_SELECTED; |
56 |
else |
57 |
f->flags |= FACE_SELECTED; |
58 |
} |
59 |
} |
60 |
|
61 |
/* Select faces by material name (modifies current) */ |
62 |
void |
63 |
selectMaterial(Scene *sc, const char *mname, int invert) |
64 |
{ |
65 |
int mid = getMaterialID(sc, mname); |
66 |
Face *f; |
67 |
|
68 |
if (mid < 0) |
69 |
return; |
70 |
for (f = sc->flist; f != NULL; f = f->next) |
71 |
if (f->mat == mid) { |
72 |
if (invert) |
73 |
f->flags &= ~FACE_SELECTED; |
74 |
else |
75 |
f->flags |= FACE_SELECTED; |
76 |
} |
77 |
} |
78 |
|
79 |
/* Invert face selection */ |
80 |
void |
81 |
invertSelection(Scene *sc) |
82 |
{ |
83 |
Face *f; |
84 |
|
85 |
for (f = sc->flist; f != NULL; f = f->next) |
86 |
f->flags ^= FACE_SELECTED; |
87 |
} |
88 |
|
89 |
/* Count selected faces */ |
90 |
int |
91 |
numberSelected(Scene *sc) |
92 |
{ |
93 |
int nsel = 0; |
94 |
Face *f; |
95 |
|
96 |
for (f = sc->flist; f != NULL; f = f->next) |
97 |
nsel += ((f->flags & FACE_SELECTED) != 0); |
98 |
return(nsel); |
99 |
} |
100 |
|
101 |
/* Execute callback on indicated faces */ |
102 |
int |
103 |
foreachFace(Scene *sc, int (*cb)(Scene *, Face *, void *), |
104 |
int flreq, int flexc, void *c_data) |
105 |
{ |
106 |
int fltest = flreq | flexc; |
107 |
int sum = 0; |
108 |
Face *f; |
109 |
|
110 |
if ((sc == NULL) | (cb == NULL)) |
111 |
return(0); |
112 |
for (f = sc->flist; f != NULL; f = f->next) |
113 |
if ((f->flags & fltest) == flreq) { |
114 |
int res = (*cb)(sc, f, c_data); |
115 |
if (res < 0) |
116 |
return(res); |
117 |
sum += res; |
118 |
} |
119 |
return(sum); |
120 |
} |
121 |
|
122 |
/* Callback for removeTexture() */ |
123 |
static int |
124 |
remFaceTexture(Scene *sc, Face *f, void *dummy) |
125 |
{ |
126 |
int hadTexture = 0; |
127 |
int i; |
128 |
|
129 |
for (i = f->nv; i-- > 0; ) { |
130 |
if (f->v[i].tid < 0) |
131 |
continue; |
132 |
f->v[i].tid = -1; |
133 |
hadTexture = 1; |
134 |
} |
135 |
return(hadTexture); |
136 |
} |
137 |
|
138 |
/* Remove texture coordinates from the indicated faces */ |
139 |
int |
140 |
removeTexture(Scene *sc, int flreq, int flexc) |
141 |
{ |
142 |
return(foreachFace(sc, remFaceTexture, flreq, flexc, NULL)); |
143 |
} |
144 |
|
145 |
/* Callback for removeNormals() */ |
146 |
static int |
147 |
remFaceNormal(Scene *sc, Face *f, void *dummy) |
148 |
{ |
149 |
int hadNormal = 0; |
150 |
int i; |
151 |
|
152 |
for (i = f->nv; i-- > 0; ) { |
153 |
if (f->v[i].nid < 0) |
154 |
continue; |
155 |
f->v[i].nid = -1; |
156 |
hadNormal = 1; |
157 |
} |
158 |
return(hadNormal); |
159 |
} |
160 |
|
161 |
/* Remove surface normals from the indicated faces */ |
162 |
int |
163 |
removeNormals(Scene *sc, int flreq, int flexc) |
164 |
{ |
165 |
return(foreachFace(sc, remFaceNormal, flreq, flexc, NULL)); |
166 |
} |
167 |
|
168 |
/* Callback for changeGroup() */ |
169 |
static int |
170 |
chngFaceGroup(Scene *sc, Face *f, void *ptr) |
171 |
{ |
172 |
int grp = *(int *)ptr; |
173 |
if (f->grp == grp) |
174 |
return(0); |
175 |
f->grp = grp; |
176 |
return(1); |
177 |
} |
178 |
|
179 |
/* Change group for the indicated faces */ |
180 |
int |
181 |
changeGroup(Scene *sc, const char *gname, int flreq, int flexc) |
182 |
{ |
183 |
int grp = getGroupID(sc, gname); |
184 |
if (grp < 0) { |
185 |
sc->grpname = chunk_alloc(char *, sc->grpname, sc->ngrps); |
186 |
sc->grpname[grp=sc->ngrps++] = savqstr((char *)gname); |
187 |
} |
188 |
return(foreachFace(sc, chngFaceGroup, flreq, flexc, (void *)&grp)); |
189 |
} |
190 |
|
191 |
/* Callback for changeMaterial() */ |
192 |
static int |
193 |
chngFaceMaterial(Scene *sc, Face *f, void *ptr) |
194 |
{ |
195 |
int mat = *(int *)ptr; |
196 |
if (f->mat == mat) |
197 |
return(0); |
198 |
f->mat = mat; |
199 |
return(1); |
200 |
} |
201 |
|
202 |
/* Change material for the indicated faces */ |
203 |
int |
204 |
changeMaterial(Scene *sc, const char *mname, int flreq, int flexc) |
205 |
{ |
206 |
int mat = getMaterialID(sc, mname); |
207 |
if (mat < 0) { |
208 |
sc->matname = chunk_alloc(char *, sc->matname, sc->nmats); |
209 |
sc->matname[mat=sc->nmats++] = savqstr((char *)mname); |
210 |
} |
211 |
return(foreachFace(sc, chngFaceMaterial, flreq, flexc, (void *)&mat)); |
212 |
} |
213 |
|
214 |
/* Compare floating point values for (near) equality */ |
215 |
static int |
216 |
fdiffer(double f1, double f2, double eps) |
217 |
{ |
218 |
if (f2 != .0) |
219 |
f1 = f1/f2 - 1.; |
220 |
return((f1 > eps) | (f1 < -eps)); |
221 |
} |
222 |
|
223 |
/* Compare two texture coordinates for (near) equality */ |
224 |
static int |
225 |
tex_diff(const TexCoord *t1, const TexCoord *t2, double eps) |
226 |
{ |
227 |
if (fdiffer(t1->u, t2->u, eps)) |
228 |
return(1); |
229 |
if (fdiffer(t1->v, t2->v, eps)) |
230 |
return(1); |
231 |
return(0); |
232 |
} |
233 |
|
234 |
/* Compare two surface normals for (near) equality */ |
235 |
static int |
236 |
norm_diff(const Normal n1, const Normal n2, double eps) |
237 |
{ |
238 |
if (fabs(n1[0]-n2[0]) > eps) |
239 |
return(1); |
240 |
if (fabs(n1[1]-n2[1]) > eps) |
241 |
return(1); |
242 |
if (fabs(n1[2]-n2[2]) > eps) |
243 |
return(1); |
244 |
return(0); |
245 |
} |
246 |
|
247 |
/* Replace the given vertex with an equivalent one */ |
248 |
static int |
249 |
replace_vertex(Scene *sc, int prev, int repl, double eps) |
250 |
{ |
251 |
int repl_tex[10]; |
252 |
int repl_norm[10]; |
253 |
Face *f, *flast=NULL; |
254 |
int i, j=0; |
255 |
/* check to see if it's even used */ |
256 |
if (sc->vert[prev].vflist == NULL) |
257 |
return(0); |
258 |
/* get replacement textures */ |
259 |
repl_tex[0] = -1; |
260 |
for (f = sc->vert[repl].vflist; f != NULL; f = f->v[j].fnext) { |
261 |
/* make sure prev isn't in there */ |
262 |
for (j = f->nv; j-- > 0; ) |
263 |
if (f->v[j].vid == prev) |
264 |
return(0); |
265 |
for (j = f->nv; j-- > 0; ) |
266 |
if (f->v[j].vid == repl) |
267 |
break; |
268 |
if (j < 0) |
269 |
goto linkerr; |
270 |
if (f->v[j].tid < 0) |
271 |
continue; |
272 |
/* see if it's new */ |
273 |
for (i = 0; repl_tex[i] >= 0; i++) { |
274 |
if (repl_tex[i] == f->v[j].tid) |
275 |
break; |
276 |
if (!tex_diff(&sc->tex[repl_tex[i]], |
277 |
&sc->tex[f->v[j].tid], eps)) { |
278 |
f->v[j].tid = repl_tex[i]; |
279 |
break; /* consolidate */ |
280 |
} |
281 |
} |
282 |
if (repl_tex[i] >= 0) |
283 |
continue; /* have this one already */ |
284 |
/* else add it */ |
285 |
repl_tex[i++] = f->v[j].tid; |
286 |
repl_tex[i] = -1; |
287 |
if (i >= 9) |
288 |
break; /* that's all we have room for */ |
289 |
} |
290 |
/* get replacement normals */ |
291 |
repl_norm[0] = -1; |
292 |
for (f = sc->vert[repl].vflist; f != NULL; f = f->v[j].fnext) { |
293 |
for (j = f->nv; j-- > 0; ) |
294 |
if (f->v[j].vid == repl) |
295 |
break; |
296 |
if (f->v[j].nid < 0) |
297 |
continue; |
298 |
/* see if it's new */ |
299 |
for (i = 0; repl_norm[i] >= 0; i++) { |
300 |
if (repl_norm[i] == f->v[j].nid) |
301 |
break; |
302 |
if (!norm_diff(sc->norm[repl_norm[i]], |
303 |
sc->norm[f->v[j].nid], eps)) { |
304 |
f->v[j].nid = repl_norm[i]; |
305 |
break; /* consolidate */ |
306 |
} |
307 |
} |
308 |
if (repl_norm[i] >= 0) |
309 |
continue; /* have this one already */ |
310 |
/* else add it */ |
311 |
repl_norm[i++] = f->v[j].nid; |
312 |
repl_norm[i] = -1; |
313 |
if (i >= 9) |
314 |
break; /* that's all we have room for */ |
315 |
} |
316 |
/* replace occurrences of vertex */ |
317 |
for (f = sc->vert[prev].vflist; f != NULL; f = f->v[j].fnext) { |
318 |
for (j = f->nv; j-- > 0; ) |
319 |
if (f->v[j].vid == prev) |
320 |
break; |
321 |
if (j < 0) |
322 |
goto linkerr; |
323 |
/* XXX doesn't allow for multiple references to prev in face */ |
324 |
f->v[j].vid = repl; /* replace vertex itself */ |
325 |
if (faceArea(sc, f, NULL) <= FTINY*FTINY) |
326 |
f->flags |= FACE_DEGENERATE; |
327 |
if (f->v[j].tid >= 0) /* replace texture if appropriate */ |
328 |
for (i = 0; repl_tex[i] >= 0; i++) { |
329 |
if (repl_tex[i] == f->v[j].tid) |
330 |
break; |
331 |
if (!tex_diff(&sc->tex[repl_tex[i]], |
332 |
&sc->tex[f->v[j].tid], eps)) { |
333 |
f->v[j].tid = repl_tex[i]; |
334 |
break; |
335 |
} |
336 |
} |
337 |
if (f->v[j].nid >= 0) /* replace normal if appropriate */ |
338 |
for (i = 0; repl_norm[i] >= 0; i++) { |
339 |
if (repl_norm[i] == f->v[j].nid) |
340 |
break; |
341 |
if (!norm_diff(sc->norm[repl_norm[i]], |
342 |
sc->norm[f->v[j].nid], eps)) { |
343 |
f->v[j].nid = repl_norm[i]; |
344 |
break; |
345 |
} |
346 |
} |
347 |
flast = f; |
348 |
} |
349 |
/* transfer face list */ |
350 |
flast->v[j].fnext = sc->vert[repl].vflist; |
351 |
sc->vert[repl].vflist = sc->vert[prev].vflist; |
352 |
sc->vert[prev].vflist = NULL; |
353 |
return(1); |
354 |
linkerr: |
355 |
error(CONSISTENCY, "Link error in replace_vertex()"); |
356 |
return(0); /* shouldn't return */ |
357 |
} |
358 |
|
359 |
/* Eliminate duplicate vertices, return # joined */ |
360 |
int |
361 |
coalesceVertices(Scene *sc, double eps) |
362 |
{ |
363 |
int nelim = 0; |
364 |
LUTAB myLookup; |
365 |
LUENT *le; |
366 |
char vertfmt[32], vertbuf[64]; |
367 |
double d; |
368 |
int i; |
369 |
|
370 |
if (eps >= 1.) |
371 |
return(0); |
372 |
if (sc->nverts <= 3) |
373 |
return(0); |
374 |
/* create hash table */ |
375 |
myLookup.hashf = lu_shash; |
376 |
myLookup.keycmp = (lut_keycmpf_t *)strcmp; |
377 |
myLookup.freek = (lut_free_t *)freeqstr; |
378 |
myLookup.freed = NULL; |
379 |
if (!lu_init(&myLookup, sc->nverts)) |
380 |
return(0); |
381 |
if (eps <= 5e-15) |
382 |
strcpy(vertfmt, "%.15e %.15e %.15e"); |
383 |
else { |
384 |
int nsigdig = 0; |
385 |
for (d = eps; d < 0.5; d *= 10.) |
386 |
++nsigdig; |
387 |
sprintf(vertfmt, "%%.%de %%.%de %%.%de", |
388 |
nsigdig, nsigdig, nsigdig); |
389 |
} |
390 |
/* find coicident vertices */ |
391 |
for (i = 0; i < sc->nverts; i++) { |
392 |
if (verbose && !((i+1) & 0x3fff)) |
393 |
fprintf(stderr, "%3d%% complete\r", 100*i/sc->nverts); |
394 |
/* check for match */ |
395 |
sprintf(vertbuf, vertfmt, sc->vert[i].p[0], |
396 |
sc->vert[i].p[1], sc->vert[i].p[2]); |
397 |
le = lu_find(&myLookup, vertbuf); |
398 |
if (le->data != NULL) { /* coincident vertex */ |
399 |
nelim += replace_vertex(sc, i, |
400 |
(Vertex *)le->data - sc->vert, eps); |
401 |
continue; |
402 |
} |
403 |
if (le->key == NULL) /* else create new entry */ |
404 |
le->key = savqstr(vertbuf); |
405 |
le->data = (char *)&sc->vert[i]; |
406 |
} |
407 |
lu_done(&myLookup); /* clean up */ |
408 |
return(nelim); |
409 |
} |
410 |
|
411 |
/* Identify duplicate faces */ |
412 |
int |
413 |
findDuplicateFaces(Scene *sc) |
414 |
{ |
415 |
int nchecked = 0; |
416 |
int nfound = 0; |
417 |
Face *f, *f1; |
418 |
int vid; |
419 |
int i, j; |
420 |
/* start fresh */ |
421 |
for (f = sc->flist; f != NULL; f = f->next) |
422 |
f->flags &= ~FACE_DUPLICATE; |
423 |
/* check each face */ |
424 |
for (f = sc->flist; f != NULL; f = f->next) { |
425 |
nchecked++; |
426 |
if (verbose && !(nchecked & 0x3fff)) |
427 |
fprintf(stderr, "%3d%% complete\r", |
428 |
100*nchecked/sc->nfaces); |
429 |
if (f->flags & FACE_DUPLICATE) |
430 |
continue; /* already identified */ |
431 |
vid = f->v[0].vid; |
432 |
/* look for duplicates */ |
433 |
for (f1 = sc->vert[vid].vflist; f1 != NULL; |
434 |
f1 = f1->v[j].fnext) { |
435 |
for (j = f1->nv; j-- > 0; ) |
436 |
if (f1->v[j].vid == vid) |
437 |
break; |
438 |
if (j < 0) |
439 |
break; /* missing link! */ |
440 |
if (f1 == f) |
441 |
continue; /* shouldn't happen */ |
442 |
if (f1->flags & FACE_DUPLICATE) |
443 |
continue; /* already marked */ |
444 |
if (f1->nv != f->nv) |
445 |
continue; /* couldn't be dup. */ |
446 |
for (i = f->nv; --i > 0; ) |
447 |
if (f->v[i].vid != f1->v[(j+i)%f1->nv].vid) |
448 |
break; /* vertex mismatch */ |
449 |
if (i) { |
450 |
#if DUP_CHECK_REVERSE /* check reverse direction */ |
451 |
for (i = f->nv; --i > 0; ) |
452 |
if (f1->v[(j+f1->nv-i)%f1->nv].vid |
453 |
!= f->v[i].vid) |
454 |
break; |
455 |
if (i) /* no match */ |
456 |
#endif |
457 |
continue; |
458 |
} |
459 |
f1->flags |= FACE_DUPLICATE; |
460 |
++nfound; |
461 |
} |
462 |
} |
463 |
if (verbose) |
464 |
fprintf(stderr, "Found %d duplicate faces\n", nfound); |
465 |
return(nfound); |
466 |
} |
467 |
|
468 |
/* Delete indicated faces */ |
469 |
int |
470 |
deleteFaces(Scene *sc, int flreq, int flexc) |
471 |
{ |
472 |
int fltest = flreq | flexc; |
473 |
int orig_nfaces = sc->nfaces; |
474 |
Face fhead; |
475 |
Face *f, *ftst; |
476 |
|
477 |
fhead.next = sc->flist; |
478 |
f = &fhead; |
479 |
while ((ftst = f->next) != NULL) |
480 |
if ((ftst->flags & fltest) == flreq) { |
481 |
Face *vf; /* remove from vertex lists */ |
482 |
int vid, i, j; |
483 |
for (i = 0; i < ftst->nv; i++) { |
484 |
vid = ftst->v[i].vid; |
485 |
vf = sc->vert[vid].vflist; |
486 |
if (vf == ftst) { |
487 |
sc->vert[vid].vflist = ftst->v[i].fnext; |
488 |
continue; |
489 |
} |
490 |
while (vf != NULL) { |
491 |
for (j = vf->nv; j-- > 0; ) |
492 |
if (vf->v[j].vid == vid) |
493 |
break; |
494 |
if (j < 0) |
495 |
break; /* error */ |
496 |
if (vf->v[j].fnext == ftst) { |
497 |
vf->v[j].fnext = |
498 |
ftst->v[i].fnext; |
499 |
break; |
500 |
} |
501 |
vf = vf->v[j].fnext; |
502 |
} |
503 |
} |
504 |
f->next = ftst->next; /* remove from scene list */ |
505 |
efree((char *)ftst); |
506 |
sc->nfaces--; |
507 |
} else |
508 |
f = f->next; |
509 |
sc->flist = fhead.next; |
510 |
return(orig_nfaces - sc->nfaces); |
511 |
} |
512 |
|
513 |
/* Compute face area (and normal) */ |
514 |
double |
515 |
faceArea(const Scene *sc, const Face *f, Normal nrm) |
516 |
{ |
517 |
FVECT fnrm; |
518 |
double area; |
519 |
FVECT v1, v2, v3; |
520 |
double *p0; |
521 |
int i; |
522 |
|
523 |
if (f->flags & FACE_DEGENERATE) |
524 |
return(.0); /* should we check this? */ |
525 |
fnrm[0] = fnrm[1] = fnrm[2] = .0; |
526 |
p0 = sc->vert[f->v[0].vid].p; |
527 |
VSUB(v1, sc->vert[f->v[1].vid].p, p0); |
528 |
for (i = 2; i < f->nv; i++) { |
529 |
VSUB(v2, sc->vert[f->v[i].vid].p, p0); |
530 |
fcross(v3, v1, v2); |
531 |
VADD(fnrm, fnrm, v3); |
532 |
VCOPY(v1, v2); |
533 |
} |
534 |
area = 0.5*normalize(fnrm); |
535 |
if (nrm != NULL) { |
536 |
if (area != 0.) |
537 |
VCOPY(nrm, fnrm); |
538 |
else |
539 |
nrm[0] = nrm[1] = nrm[2] = 0.; |
540 |
} |
541 |
return(area); |
542 |
} |
543 |
|
544 |
/* Add a descriptive comment */ |
545 |
void |
546 |
addComment(Scene *sc, const char *comment) |
547 |
{ |
548 |
sc->descr = chunk_alloc(char *, sc->descr, sc->ndescr); |
549 |
sc->descr[sc->ndescr++] = savqstr((char *)comment); |
550 |
} |
551 |
|
552 |
/* Find index for comment containing the given string (starting from n) */ |
553 |
int |
554 |
findComment(Scene *sc, const char *match, int n) |
555 |
{ |
556 |
if (n >= sc->ndescr) |
557 |
return(-1); |
558 |
n *= (n > 0); |
559 |
while (n < sc->ndescr) |
560 |
if (strstr(sc->descr[n], match) != NULL) |
561 |
return(n); |
562 |
return(-1); |
563 |
} |
564 |
|
565 |
/* Clear comments */ |
566 |
void |
567 |
clearComments(Scene *sc) |
568 |
{ |
569 |
while (sc->ndescr > 0) |
570 |
freeqstr(sc->descr[--sc->ndescr]); |
571 |
efree((char *)sc->descr); |
572 |
sc->ndescr = 0; |
573 |
} |
574 |
|
575 |
/* Add a face to a vertex face list */ |
576 |
static void |
577 |
add2facelist(Scene *sc, Face *f, int i) |
578 |
{ |
579 |
int vid = f->v[i].vid; |
580 |
Face *fp = sc->vert[vid].vflist; |
581 |
int j; |
582 |
|
583 |
f->v[i].fnext = NULL; /* will put at end */ |
584 |
if (fp == NULL) { /* new list */ |
585 |
sc->vert[vid].vflist = f; |
586 |
return; |
587 |
} |
588 |
for ( ; ; ) { /* else find position */ |
589 |
if (fp == f) |
590 |
return; /* already in list */ |
591 |
for (j = fp->nv; j-- > 0; ) |
592 |
if (fp->v[j].vid == vid) |
593 |
break; |
594 |
if (j < 0) |
595 |
error(CONSISTENCY, "Link error in add2facelist()"); |
596 |
if (fp->v[j].fnext == NULL) |
597 |
break; /* reached the end */ |
598 |
fp = fp->v[j].fnext; |
599 |
} |
600 |
fp->v[j].fnext = f; /* append new face */ |
601 |
} |
602 |
|
603 |
/* Allocate an empty scene */ |
604 |
Scene * |
605 |
newScene(void) |
606 |
{ |
607 |
Scene *sc = (Scene *)ecalloc(1, sizeof(Scene)); |
608 |
/* default group & material */ |
609 |
sc->grpname = chunk_alloc(char *, sc->grpname, sc->ngrps); |
610 |
sc->grpname[sc->ngrps++] = savqstr("DEFAULT_GROUP"); |
611 |
sc->matname = chunk_alloc(char *, sc->matname, sc->nmats); |
612 |
sc->matname[sc->nmats++] = savqstr("DEFAULT_MATERIAL"); |
613 |
|
614 |
return(sc); |
615 |
} |
616 |
|
617 |
/* Add a vertex to a scene */ |
618 |
int |
619 |
addVertex(Scene *sc, double x, double y, double z) |
620 |
{ |
621 |
sc->vert = chunk_alloc(Vertex, sc->vert, sc->nverts); |
622 |
sc->vert[sc->nverts].p[0] = x; |
623 |
sc->vert[sc->nverts].p[1] = y; |
624 |
sc->vert[sc->nverts].p[2] = z; |
625 |
sc->vert[sc->nverts].vflist = NULL; |
626 |
return(sc->nverts++); |
627 |
} |
628 |
|
629 |
/* Add a texture coordinate to a scene */ |
630 |
int |
631 |
addTexture(Scene *sc, double u, double v) |
632 |
{ |
633 |
sc->tex = chunk_alloc(TexCoord, sc->tex, sc->ntex); |
634 |
sc->tex[sc->ntex].u = u; |
635 |
sc->tex[sc->ntex].v = v; |
636 |
return(sc->ntex++); |
637 |
} |
638 |
|
639 |
/* Add a surface normal to a scene */ |
640 |
int |
641 |
addNormal(Scene *sc, double xn, double yn, double zn) |
642 |
{ |
643 |
FVECT nrm; |
644 |
|
645 |
nrm[0] = xn; nrm[1] = yn; nrm[2] = zn; |
646 |
if (normalize(nrm) == .0) |
647 |
return(-1); |
648 |
sc->norm = chunk_alloc(Normal, sc->norm, sc->nnorms); |
649 |
VCOPY(sc->norm[sc->nnorms], nrm); |
650 |
return(sc->nnorms++); |
651 |
} |
652 |
|
653 |
/* Set current (last) group */ |
654 |
void |
655 |
setGroup(Scene *sc, const char *nm) |
656 |
{ |
657 |
sc->lastgrp = getGroupID(sc, nm); |
658 |
if (sc->lastgrp >= 0) |
659 |
return; |
660 |
sc->grpname = chunk_alloc(char *, sc->grpname, sc->ngrps); |
661 |
sc->grpname[sc->lastgrp=sc->ngrps++] = savqstr((char *)nm); |
662 |
} |
663 |
|
664 |
/* Set current (last) material */ |
665 |
void |
666 |
setMaterial(Scene *sc, const char *nm) |
667 |
{ |
668 |
sc->lastmat = getMaterialID(sc, nm); |
669 |
if (sc->lastmat >= 0) |
670 |
return; |
671 |
sc->matname = chunk_alloc(char *, sc->matname, sc->nmats); |
672 |
sc->matname[sc->lastmat=sc->nmats++] = savqstr((char *)nm); |
673 |
} |
674 |
|
675 |
/* Add new face to a scene */ |
676 |
Face * |
677 |
addFace(Scene *sc, VNDX vid[], int nv) |
678 |
{ |
679 |
Face *f; |
680 |
int i; |
681 |
|
682 |
if (nv < 3) |
683 |
return(NULL); |
684 |
f = (Face *)emalloc(sizeof(Face)+sizeof(VertEnt)*(nv-3)); |
685 |
f->flags = 0; |
686 |
f->nv = nv; |
687 |
f->grp = sc->lastgrp; |
688 |
f->mat = sc->lastmat; |
689 |
for (i = 0; i < nv; i++) { /* add each vertex */ |
690 |
int j; |
691 |
f->v[i].vid = vid[i][0]; |
692 |
f->v[i].tid = vid[i][1]; |
693 |
f->v[i].nid = vid[i][2]; |
694 |
f->v[i].fnext = NULL; |
695 |
for (j = i; j-- > 0; ) |
696 |
if (f->v[j].vid == vid[i][0]) |
697 |
break; |
698 |
if (j < 0) { /* first occurrence? */ |
699 |
f->v[i].fnext = sc->vert[vid[i][0]].vflist; |
700 |
sc->vert[vid[i][0]].vflist = f; |
701 |
} else if (nv == 3) /* degenerate triangle? */ |
702 |
f->flags |= FACE_DEGENERATE; |
703 |
} |
704 |
f->next = sc->flist; /* push onto face list */ |
705 |
sc->flist = f; |
706 |
sc->nfaces++; |
707 |
/* check face area */ |
708 |
if (!(f->flags & FACE_DEGENERATE) && faceArea(sc, f, NULL) <= FTINY*FTINY) |
709 |
f->flags |= FACE_DEGENERATE; |
710 |
return(f); |
711 |
} |
712 |
|
713 |
/* Duplicate a scene, optionally selecting faces */ |
714 |
Scene * |
715 |
dupScene(const Scene *osc, int flreq, int flexc) |
716 |
{ |
717 |
int fltest = flreq | flexc; |
718 |
Scene *sc; |
719 |
const Face *fo; |
720 |
Face *f; |
721 |
int i; |
722 |
|
723 |
if (osc == NULL) |
724 |
return(NULL); |
725 |
sc = newScene(); |
726 |
for (i = 0; i < osc->ndescr; i++) |
727 |
addComment(sc, osc->descr[i]); |
728 |
if (osc->ngrps) { |
729 |
sc->grpname = (char **)emalloc(sizeof(char *) * |
730 |
(osc->ngrps+(CHUNKSIZ-1))); |
731 |
for (i = 0; i < osc->ngrps; i++) |
732 |
sc->grpname[i] = savqstr(osc->grpname[i]); |
733 |
sc->ngrps = osc->ngrps; |
734 |
} |
735 |
if (osc->nmats) { |
736 |
sc->matname = (char **)emalloc(sizeof(char *) * |
737 |
(osc->nmats+(CHUNKSIZ-1))); |
738 |
for (i = 0; i < osc->nmats; i++) |
739 |
sc->matname[i] = savqstr(osc->matname[i]); |
740 |
sc->nmats = osc->nmats; |
741 |
} |
742 |
if (osc->nverts) { |
743 |
sc->vert = (Vertex *)emalloc(sizeof(Vertex) * |
744 |
(osc->nverts+(CHUNKSIZ-1))); |
745 |
memcpy((void *)sc->vert, (const void *)osc->vert, |
746 |
sizeof(Vertex)*osc->nverts); |
747 |
sc->nverts = osc->nverts; |
748 |
for (i = 0; i < sc->nverts; i++) |
749 |
sc->vert[i].vflist = NULL; |
750 |
} |
751 |
if (osc->ntex) { |
752 |
sc->tex = (TexCoord *)emalloc(sizeof(TexCoord) * |
753 |
(osc->ntex+(CHUNKSIZ-1))); |
754 |
memcpy((void *)sc->tex, (const void *)osc->tex, |
755 |
sizeof(TexCoord)*osc->ntex); |
756 |
sc->ntex = osc->ntex; |
757 |
} |
758 |
if (osc->nnorms) { |
759 |
sc->norm = (Normal *)emalloc(sizeof(Normal) * |
760 |
(osc->nnorms+CHUNKSIZ)); |
761 |
memcpy((void *)sc->norm, (const void *)osc->norm, |
762 |
sizeof(Normal)*osc->nnorms); |
763 |
sc->nnorms = osc->nnorms; |
764 |
} |
765 |
for (fo = osc->flist; fo != NULL; fo = fo->next) { |
766 |
if ((fo->flags & fltest) != flreq) |
767 |
continue; |
768 |
f = (Face *)emalloc(sizeof(Face) + |
769 |
sizeof(VertEnt)*(fo->nv-3)); |
770 |
memcpy((void *)f, (const void *)fo, sizeof(Face) + |
771 |
sizeof(VertEnt)*(fo->nv-3)); |
772 |
for (i = 0; i < f->nv; i++) |
773 |
add2facelist(sc, f, i); |
774 |
f->next = sc->flist; |
775 |
sc->flist = f; |
776 |
sc->nfaces++; |
777 |
} |
778 |
deleteUnreferenced(sc); /* jetsam */ |
779 |
return(sc); |
780 |
} |
781 |
|
782 |
#define MAXAC 100 |
783 |
|
784 |
/* Transform entire scene */ |
785 |
int |
786 |
xfScene(Scene *sc, int xac, char *xav[]) |
787 |
{ |
788 |
char comm[24+MAXAC*8]; |
789 |
char *cp; |
790 |
XF myxf; |
791 |
FVECT vec; |
792 |
int i; |
793 |
|
794 |
if ((sc == NULL) | (xac <= 0) | (xav == NULL)) |
795 |
return(0); |
796 |
/* compute matrix */ |
797 |
if (xf(&myxf, xac, xav) < xac) |
798 |
return(0); |
799 |
/* transform vertices */ |
800 |
for (i = 0; i < sc->nverts; i++) { |
801 |
VCOPY(vec, sc->vert[i].p); |
802 |
multp3(vec, vec, myxf.xfm); |
803 |
VCOPY(sc->vert[i].p, vec); |
804 |
} |
805 |
/* transform normals */ |
806 |
for (i = 0; i < sc->nnorms; i++) { |
807 |
VCOPY(vec, sc->norm[i]); |
808 |
multv3(vec, vec, myxf.xfm); |
809 |
vec[0] /= myxf.sca; vec[1] /= myxf.sca; vec[2] /= myxf.sca; |
810 |
VCOPY(sc->norm[i], vec); |
811 |
} |
812 |
/* add comment */ |
813 |
cp = strcpy(comm, "Transformed by:"); |
814 |
for (i = 0; i < xac; i++) { |
815 |
while (*cp) cp++; |
816 |
*cp++ = ' '; |
817 |
strcpy(cp, xav[i]); |
818 |
} |
819 |
addComment(sc, comm); |
820 |
return(xac); /* all done */ |
821 |
} |
822 |
|
823 |
/* Ditto, using transform string rather than pre-parsed words */ |
824 |
int |
825 |
xfmScene(Scene *sc, const char *xfm) |
826 |
{ |
827 |
char *xav[MAXAC+1]; |
828 |
int xac, i; |
829 |
|
830 |
if ((sc == NULL) | (xfm == NULL)) |
831 |
return(0); |
832 |
/* skip spaces at beginning */ |
833 |
while (isspace(*xfm)) |
834 |
xfm++; |
835 |
if (!*xfm) |
836 |
return(0); |
837 |
/* parse string into words */ |
838 |
xav[0] = strcpy((char *)malloc(strlen(xfm)+1), xfm); |
839 |
xac = 1; i = 0; |
840 |
for ( ; ; ) { |
841 |
while (!isspace(xfm[++i])) |
842 |
if (!xfm[i]) |
843 |
break; |
844 |
while (isspace(xfm[i])) |
845 |
xav[0][i++] = '\0'; |
846 |
if (!xfm[i]) |
847 |
break; |
848 |
if (xac >= MAXAC-1) { |
849 |
free(xav[0]); |
850 |
return(0); |
851 |
} |
852 |
xav[xac++] = xav[0] + i; |
853 |
} |
854 |
xav[xac] = NULL; |
855 |
i = xfScene(sc, xac, xav); |
856 |
free(xav[0]); |
857 |
return(i); |
858 |
} |
859 |
#undef MAXAC |
860 |
|
861 |
/* Delete unreferenced vertices, normals, texture coords */ |
862 |
void |
863 |
deleteUnreferenced(Scene *sc) |
864 |
{ |
865 |
int *vmap; |
866 |
Face *f; |
867 |
int nused, i; |
868 |
/* allocate index map */ |
869 |
if (!sc->nverts) |
870 |
return; |
871 |
i = sc->nverts; |
872 |
if (sc->ntex > i) |
873 |
i = sc->ntex; |
874 |
if (sc->nnorms > i) |
875 |
i = sc->nnorms; |
876 |
vmap = (int *)emalloc(sizeof(int)*i); |
877 |
/* remap positions */ |
878 |
for (i = nused = 0; i < sc->nverts; i++) { |
879 |
if (sc->vert[i].vflist == NULL) { |
880 |
vmap[i] = -1; |
881 |
continue; |
882 |
} |
883 |
if (nused != i) |
884 |
sc->vert[nused] = sc->vert[i]; |
885 |
vmap[i] = nused++; |
886 |
} |
887 |
if (nused == sc->nverts) |
888 |
goto skip_pos; |
889 |
sc->vert = (Vertex *)erealloc((char *)sc->vert, |
890 |
sizeof(Vertex)*(nused+(CHUNKSIZ-1))); |
891 |
sc->nverts = nused; |
892 |
for (f = sc->flist; f != NULL; f = f->next) |
893 |
for (i = f->nv; i--; ) |
894 |
if ((f->v[i].vid = vmap[f->v[i].vid]) < 0) |
895 |
error(CONSISTENCY, |
896 |
"Link error in del_unref_verts()"); |
897 |
skip_pos: |
898 |
/* remap texture coord's */ |
899 |
if (!sc->ntex) |
900 |
goto skip_tex; |
901 |
memset((void *)vmap, 0, sizeof(int)*sc->ntex); |
902 |
for (f = sc->flist; f != NULL; f = f->next) |
903 |
for (i = f->nv; i--; ) |
904 |
if (f->v[i].tid >= 0) |
905 |
vmap[f->v[i].tid] = 1; |
906 |
for (i = nused = 0; i < sc->ntex; i++) { |
907 |
if (!vmap[i]) |
908 |
continue; |
909 |
if (nused != i) |
910 |
sc->tex[nused] = sc->tex[i]; |
911 |
vmap[i] = nused++; |
912 |
} |
913 |
if (nused == sc->ntex) |
914 |
goto skip_tex; |
915 |
sc->tex = (TexCoord *)erealloc((char *)sc->tex, |
916 |
sizeof(TexCoord)*(nused+(CHUNKSIZ-1))); |
917 |
sc->ntex = nused; |
918 |
for (f = sc->flist; f != NULL; f = f->next) |
919 |
for (i = f->nv; i--; ) |
920 |
if (f->v[i].tid >= 0) |
921 |
f->v[i].tid = vmap[f->v[i].tid]; |
922 |
skip_tex: |
923 |
/* remap normals */ |
924 |
if (!sc->nnorms) |
925 |
goto skip_norms; |
926 |
memset((void *)vmap, 0, sizeof(int)*sc->nnorms); |
927 |
for (f = sc->flist; f != NULL; f = f->next) |
928 |
for (i = f->nv; i--; ) |
929 |
if (f->v[i].nid >= 0) |
930 |
vmap[f->v[i].nid] = 1; |
931 |
for (i = nused = 0; i < sc->nnorms; i++) { |
932 |
if (!vmap[i]) |
933 |
continue; |
934 |
if (nused != i) |
935 |
memcpy((void *)sc->norm[nused], |
936 |
(void *)sc->norm[i], |
937 |
sizeof(Normal)); |
938 |
vmap[i] = nused++; |
939 |
} |
940 |
if (nused == sc->nnorms) |
941 |
goto skip_norms; |
942 |
sc->norm = (Normal *)erealloc((char *)sc->norm, |
943 |
sizeof(Normal)*(nused+(CHUNKSIZ-1))); |
944 |
sc->nnorms = nused; |
945 |
for (f = sc->flist; f != NULL; f = f->next) |
946 |
for (i = f->nv; i--; ) |
947 |
if (f->v[i].nid >= 0) |
948 |
f->v[i].nid = vmap[f->v[i].nid]; |
949 |
skip_norms: |
950 |
/* clean up */ |
951 |
efree((char *)vmap); |
952 |
} |
953 |
|
954 |
/* Free a scene */ |
955 |
void |
956 |
freeScene(Scene *sc) |
957 |
{ |
958 |
int i; |
959 |
Face *f; |
960 |
|
961 |
if (sc == NULL) |
962 |
return; |
963 |
clearComments(sc); |
964 |
for (i = sc->ngrps; i-- > 0; ) |
965 |
freeqstr(sc->grpname[i]); |
966 |
efree((char *)sc->grpname); |
967 |
for (i = sc->nmats; i-- > 0; ) |
968 |
freeqstr(sc->matname[i]); |
969 |
efree((char *)sc->matname); |
970 |
efree((char *)sc->vert); |
971 |
efree((char *)sc->tex); |
972 |
efree((char *)sc->norm); |
973 |
while ((f = sc->flist) != NULL) { |
974 |
sc->flist = f->next; |
975 |
efree((char *)f); |
976 |
} |
977 |
efree((char *)sc); |
978 |
} |