src/common/convertobj.c

#ifndef lint
static const char RCSid[] = "$Id: convertobj.c,v 2.5 2021/04/16 15:18:33 greg Exp $";
#endif
/*
 *  convertobj.c
 *
 *  Convert .OBJ scene to Radiance
 *
 *  Created by Greg Ward on Thu Apr 22 2004.
 */

#include "paths.h"
#include "fvect.h"
#include "tmesh.h"
#include "rterror.h"
#include "objutil.h"

#define TEXNAME         "T-nor"

static int      fcnt = 0;                       /* face output counter */

/* Callback for face smoothing detection */
static int
checksmooth(Scene *sc, Face *f, void *ptr)
{
        int     nrev = 0;
        Normal  fnrm;
        int     i;

        f->flags &= ~FACE_RESERVED;             /* using reserved flag */

        for (i = f->nv; i--; )
                if (f->v[i].nid < 0)
                        return(0);              /* missing normal */

        if (faceArea(sc, f, fnrm) == 0)         /* degenerate?? */
                return(0);
                                                /* check each normal */
        for (i = f->nv; i--; ) {
                float   *tnrm = sc->norm[f->v[i].nid];
                double  dprod = DOT(tnrm, fnrm);
                if (dprod >= COSTOL)            /* this one agrees? */
                        continue;
                if (dprod > -COSTOL)            /* active smoothing? */
                        break;
                ++nrev;                         /* count opposite face normal */
        }
        if ((i < 0) & !nrev)                    /* all normals agree w/ face? */
                return(0);
        if (nrev == f->nv) {                    /* all reversed? */
                for (i = f->nv/2; i--; ) {      /* swap vertices around */
                        int     j = f->nv-1 - i;
                        VertEnt tve = f->v[i];
                        f->v[i] = f->v[j];
                        f->v[j] = tve;
                }
                return(0);
        }
        f->flags |= FACE_RESERVED;              /* else we got one to smooth */
        return(1);
}

/* Callback to write out smoothed Radiance triangle */
static int
trismooth(Scene *sc, Face *f, void *ptr)
{
        FILE            *fp = (FILE *)ptr;
        BARYCCM         bcm;
        FVECT           coor[3];
        int             i;

        if (f->nv != 3)
                return(0);                      /* should never happen */
#ifdef  SMLFLT
        for (i = 3; i--; ) {
                double  *v = sc->vert[f->v[i].vid].p;
                VCOPY(coor[i], v);
        }
        if (comp_baryc(&bcm, coor[0], coor[1], coor[2]) < 0)
                return(0);                      /* degenerate?? */
#else
        if (comp_baryc(&bcm, sc->vert[f->v[0].vid].p,
                        sc->vert[f->v[1].vid].p, sc->vert[f->v[2].vid].p) < 0)
                return(0);                      /* degenerate?? */
#endif
        for (i = 3; i--; ) {                    /* assign BC normals */
                float   *tnrm = sc->norm[f->v[i].nid];
                coor[0][i] = tnrm[0];
                coor[1][i] = tnrm[1];
                coor[2][i] = tnrm[2];
        }                                       /* print texture */
        fprintf(fp, "\n%s texfunc %s\n4 dx dy dz %s\n0\n",
                        sc->matname[f->mat], TEXNAME, TCALNAME);
        fput_baryc(&bcm, coor, 3, fp);          /* with BC normals */
        fprintf(fp, "\n%s polygon %s.%d\n0\n0\n9\n",
                        TEXNAME, sc->grpname[f->grp], ++fcnt);
        for (i = 0; i < 3; i++) {               /* then triangle */
                double  *v = sc->vert[f->v[i].vid].p;
                fprintf(fp, "\t%18.12g %18.12g %18.12g\n", v[0], v[1], v[2]);
        }
        return(1);
}

/* Callback to convert face to Radiance */
static int
radface(Scene *sc, Face *f, void *ptr)
{
        FILE            *fp = (FILE *)ptr;
        int             i;
        
        fprintf(fp, "\n%s polygon %s.%d\n0\n0\n%d\n", sc->matname[f->mat],
                                sc->grpname[f->grp], ++fcnt, 3*f->nv);
        for (i = 0; i < f->nv; i++) {
                Vertex  *vp = sc->vert + f->v[i].vid;
                fprintf(fp, "\t%18.12g %18.12g %18.12g\n",
                                vp->p[0], vp->p[1], vp->p[2]);
        }
        return(1);
}

/* Convert indicated faces to Radiance, return # written or -1 on error */
int
toRadiance(Scene *sc, FILE *fp, int flreq, int flexc)
{
        int     n;

        if (sc == NULL || sc->nfaces <= 0 || fp == NULL)
                return(0);
                                                /* not passing empties */
        flexc |= FACE_DEGENERATE;
                                                /* reset counter if not stdout */
        fcnt *= (fp == stdout);
                                                /* write comments */
        for (n = 0; n < sc->ndescr; n++)
                fprintf(fp, "# %s\n", sc->descr[n]);
                                                /* flag faces to smooth */
        n = foreachFace(sc, checksmooth, flreq, flexc, NULL);
        if (n > 0) {                            /* write smooth faces */
                Scene   *smoothies = dupScene(sc, flreq|FACE_RESERVED, flexc);
                if (!smoothies)
                        return(-1);
                n = triangulateScene(smoothies);
                if (n >= 0)
                        n = foreachFace(smoothies, trismooth, 0, 0, fp);
                freeScene(smoothies);
        }
        if (n < 0)
                return(-1);
                                                /* write flat faces */
        n += foreachFace(sc, radface, flreq, flexc|FACE_RESERVED, fp);

        if (fflush(fp) < 0) {
                error(SYSTEM, "Error writing Radiance scene data");
                return(-1);
        }
        return(n);
}

/* Convert faces to Radiance file, return # written or -1 on error */
int
writeRadiance(Scene *sc, const char *fspec, int flreq, int flexc)
{
        extern char     *progname;
        FILE            *fp;
        int             n;

        if (sc == NULL || sc->nfaces <= 0 || fspec == NULL || !*fspec)
                return(0);
#if POPEN_SUPPORT
        if (fspec[0] == '!') {
                if ((fp = popen(fspec+1, "w")) == NULL) {
                        sprintf(errmsg, "%s: cannot execute", fspec);
                        error(SYSTEM, errmsg);
                        return(-1);
                }
        } else
#endif
        if ((fp = fopen(fspec, "w")) == NULL) {
                sprintf(errmsg, "%s: cannot open for writing", fspec);
                error(SYSTEM, errmsg);
                return(-1);
        }
                                                /* start off header */
        fprintf(fp, "# Radiance scene file converted from .OBJ by %s\n#\n",
                                                progname);
        n = toRadiance(sc, fp, flreq, flexc);   /* write file */
#if POPEN_SUPPORT
        if (fspec[0] == '!') {
                if (pclose(fp)) {
                        sprintf(errmsg, "%s: error writing to command\n", fspec);
                        error(SYSTEM, errmsg);
                        return(-1);
                }
        } else
#endif
        fclose(fp);                             /* close it (already flushed) */
        return(n);
}
Revision:	2.6
Committed:	Sat Apr 17 14:51:33 2021 UTC (3 years, 1 month ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad5R4, HEAD
Changes since 2.5:	+5 -10 lines
Log Message:	fix: vertex swapping code was missing face list pointer
#	User	Rev	Content
1	greg	2.1	#ifndef lint
2	greg	2.6	static const char RCSid[] = "$Id: convertobj.c,v 2.5 2021/04/16 15:18:33 greg Exp $";
3	greg	2.1	#endif
4			/*
5			* convertobj.c
6			*
7			* Convert .OBJ scene to Radiance
8			*
9			* Created by Greg Ward on Thu Apr 22 2004.
10			*/
11
12	greg	2.2	#include "paths.h"
13	greg	2.4	#include "fvect.h"
14			#include "tmesh.h"
15	greg	2.1	#include "rterror.h"
16			#include "objutil.h"
17
18	greg	2.4	#define TEXNAME "T-nor"
19
20			static int fcnt = 0; /* face output counter */
21
22			/* Callback for face smoothing detection */
23			static int
24			checksmooth(Scene sc, Face f, void *ptr)
25			{
26			int nrev = 0;
27			Normal fnrm;
28			int i;
29
30			f->flags &= ~FACE_RESERVED; /* using reserved flag */
31
32			for (i = f->nv; i--; )
33			if (f->v[i].nid < 0)
34			return(0); /* missing normal */
35
36			if (faceArea(sc, f, fnrm) == 0) /* degenerate?? */
37			return(0);
38			/* check each normal */
39			for (i = f->nv; i--; ) {
40			float *tnrm = sc->norm[f->v[i].nid];
41			double dprod = DOT(tnrm, fnrm);
42			if (dprod >= COSTOL) /* this one agrees? */
43			continue;
44			if (dprod > -COSTOL) /* active smoothing? */
45			break;
46			++nrev; /* count opposite face normal */
47			}
48			if ((i < 0) & !nrev) /* all normals agree w/ face? */
49			return(0);
50			if (nrev == f->nv) { /* all reversed? */
51	greg	2.6	for (i = f->nv/2; i--; ) { /* swap vertices around */
52	greg	2.4	int j = f->nv-1 - i;
53	greg	2.6	VertEnt tve = f->v[i];
54			f->v[i] = f->v[j];
55			f->v[j] = tve;
56	greg	2.4	}
57			return(0);
58			}
59			f->flags \|= FACE_RESERVED; /* else we got one to smooth */
60			return(1);
61			}
62
63			/* Callback to write out smoothed Radiance triangle */
64			static int
65			trismooth(Scene sc, Face f, void *ptr)
66			{
67			FILE fp = (FILE )ptr;
68			BARYCCM bcm;
69	greg	2.5	FVECT coor[3];
70	greg	2.4	int i;
71
72			if (f->nv != 3)
73			return(0); /* should never happen */
74	greg	2.5	#ifdef SMLFLT
75			for (i = 3; i--; ) {
76			double *v = sc->vert[f->v[i].vid].p;
77			VCOPY(coor[i], v);
78			}
79			if (comp_baryc(&bcm, coor[0], coor[1], coor[2]) < 0)
80			return(0); /* degenerate?? */
81			#else
82			if (comp_baryc(&bcm, sc->vert[f->v[0].vid].p,
83			sc->vert[f->v[1].vid].p, sc->vert[f->v[2].vid].p) < 0)
84	greg	2.4	return(0); /* degenerate?? */
85	greg	2.5	#endif
86	greg	2.4	for (i = 3; i--; ) { /* assign BC normals */
87			float *tnrm = sc->norm[f->v[i].nid];
88	greg	2.5	coor[0][i] = tnrm[0];
89			coor[1][i] = tnrm[1];
90			coor[2][i] = tnrm[2];
91	greg	2.4	} /* print texture */
92			fprintf(fp, "\n%s texfunc %s\n4 dx dy dz %s\n0\n",
93			sc->matname[f->mat], TEXNAME, TCALNAME);
94	greg	2.5	fput_baryc(&bcm, coor, 3, fp); /* with BC normals */
95	greg	2.4	fprintf(fp, "\n%s polygon %s.%d\n0\n0\n9\n",
96			TEXNAME, sc->grpname[f->grp], ++fcnt);
97			for (i = 0; i < 3; i++) { /* then triangle */
98			double *v = sc->vert[f->v[i].vid].p;
99			fprintf(fp, "\t%18.12g %18.12g %18.12g\n", v[0], v[1], v[2]);
100			}
101			return(1);
102			}
103
104	greg	2.1	/* Callback to convert face to Radiance */
105			static int
106			radface(Scene sc, Face f, void *ptr)
107			{
108			FILE fp = (FILE )ptr;
109			int i;
110
111			fprintf(fp, "\n%s polygon %s.%d\n0\n0\n%d\n", sc->matname[f->mat],
112			sc->grpname[f->grp], ++fcnt, 3*f->nv);
113			for (i = 0; i < f->nv; i++) {
114			Vertex *vp = sc->vert + f->v[i].vid;
115			fprintf(fp, "\t%18.12g %18.12g %18.12g\n",
116			vp->p[0], vp->p[1], vp->p[2]);
117			}
118			return(1);
119			}
120
121			/* Convert indicated faces to Radiance, return # written or -1 on error */
122			int
123			toRadiance(Scene sc, FILE fp, int flreq, int flexc)
124			{
125			int n;
126
127			if (sc == NULL \|\| sc->nfaces <= 0 \|\| fp == NULL)
128			return(0);
129	greg	2.4	/* not passing empties */
130			flexc \|= FACE_DEGENERATE;
131			/* reset counter if not stdout */
132			fcnt *= (fp == stdout);
133	greg	2.1	/* write comments */
134			for (n = 0; n < sc->ndescr; n++)
135			fprintf(fp, "# %s\n", sc->descr[n]);
136	greg	2.4	/* flag faces to smooth */
137			n = foreachFace(sc, checksmooth, flreq, flexc, NULL);
138			if (n > 0) { /* write smooth faces */
139			Scene *smoothies = dupScene(sc, flreq\|FACE_RESERVED, flexc);
140			if (!smoothies)
141			return(-1);
142			n = triangulateScene(smoothies);
143			if (n >= 0)
144			n = foreachFace(smoothies, trismooth, 0, 0, fp);
145			freeScene(smoothies);
146			}
147			if (n < 0)
148			return(-1);
149			/* write flat faces */
150			n += foreachFace(sc, radface, flreq, flexc\|FACE_RESERVED, fp);
151
152	greg	2.1	if (fflush(fp) < 0) {
153	greg	2.3	error(SYSTEM, "Error writing Radiance scene data");
154	greg	2.1	return(-1);
155			}
156			return(n);
157			}
158
159			/* Convert faces to Radiance file, return # written or -1 on error */
160			int
161			writeRadiance(Scene sc, const char fspec, int flreq, int flexc)
162			{
163			extern char *progname;
164			FILE *fp;
165			int n;
166
167			if (sc == NULL \|\| sc->nfaces <= 0 \|\| fspec == NULL \|\| !*fspec)
168			return(0);
169			#if POPEN_SUPPORT
170			if (fspec[0] == '!') {
171			if ((fp = popen(fspec+1, "w")) == NULL) {
172			sprintf(errmsg, "%s: cannot execute", fspec);
173			error(SYSTEM, errmsg);
174	greg	2.3	return(-1);
175	greg	2.1	}
176			} else
177			#endif
178			if ((fp = fopen(fspec, "w")) == NULL) {
179			sprintf(errmsg, "%s: cannot open for writing", fspec);
180			error(SYSTEM, errmsg);
181	greg	2.3	return(-1);
182	greg	2.1	}
183			/* start off header */
184			fprintf(fp, "# Radiance scene file converted from .OBJ by %s\n#\n",
185			progname);
186			n = toRadiance(sc, fp, flreq, flexc); /* write file */
187			#if POPEN_SUPPORT
188	greg	2.3	if (fspec[0] == '!') {
189			if (pclose(fp)) {
190			sprintf(errmsg, "%s: error writing to command\n", fspec);
191			error(SYSTEM, errmsg);
192			return(-1);
193			}
194			} else
195	greg	2.1	#endif
196	greg	2.3	fclose(fp); /* close it (already flushed) */
197	greg	2.1	return(n);
198			}