void objtopie()
{
FILE *input = NULL;
FILE *output = NULL;
input = fopen(input_file, "rt");
if (input == NULL)
{
perror("Couldn't open input file");
return;
}
output = fopen(output_file, "wt");
if (output == NULL)
{
perror("Couldn't open output file");
fclose(input);
return;
}
readobj(input);
writepie(output);
fclose(input);
fclose(output);
}
/* Read a lisp object. This is the main interface to the reader. */
sexpr *readobj(IC *ic) {
reader *r = ic->r;
char *token;
/* These are used by strtod(). Number is the return value, and
unparsed is set to the portion of the string not parsed.
If it is not pointing at the terminating '\0' when we are done, then
we failed to get a number. */
double number;
char *unparsed;
token = gettoken(r);
if(token == NULL) return ic->eof;
if(!strcmp(token, "(")) return readlist(ic);
if(!strcmp(token, "\'") ||
!strcmp(token, "`") ||
!strcmp(token, ",") ||
!strcmp(token, ",@")) {
/* We are going to read the following object, and then wrap it in
a call to something. Figure out what that something is. */
sexpr *quoter = NULL;
protect_ptr(ic->g, (void **)"er);
if(!strcmp(token, "\'"))
STORE(ic->g, NULL, quoter, ic->n_quote);
else if(!strcmp(token, "`"))
STORE(ic->g, NULL, quoter, ic->n_quasiquote);
else if(!strcmp(token, ","))
STORE(ic->g, NULL, quoter, ic->n_unquote);
else if(!strcmp(token, ",@"))
STORE(ic->g, NULL, quoter, ic->n_unquote_splicing);
else {
fprintf(stderr,
"Fatal error in lisp reader - this should never happen!\n");
longjmp(ic->quit, 1);
}
sexpr *obj = readobj(ic);
protect_ptr(ic->g, (void **)&obj);
sexpr *ret = listl(ic, quoter, obj, NULL);
unprotect_ptr(ic->g);
unprotect_ptr(ic->g);
return ret;
}
/* Check to see if it's a valid number. */
if(strcasecmp(token, "inf") &&
strcasecmp(token, "infinity") &&
strcasecmp(token, "nan")) {
number = strtod(token, &unparsed);
if(unparsed != token && *unparsed == '\0')
return mk_number(ic, number);
}
return intern(ic, token);
}
/* Read a list. The opening '(' has already been read when this is called. */
static sexpr *readlist(IC *ic) {
char *token = gettoken(ic->r);
if(token == NULL) return ic->eof;
if(!strcmp(token, ")")) return ic->g_nil;
if(!strcmp(token, ".")) {
sexpr *tmp = readobj(ic);
token = gettoken(ic->r);
if(token == NULL) return ic->eof;
if(strcmp(token, ")")) return ic->g_nil;
return tmp;
}
putback_token(ic->r, token);
sexpr *first = readobj(ic); /* Must force evaluation order */
protect_ptr(ic->g, (void **) &first);
sexpr *rest = readlist(ic);
protect_ptr(ic->g, (void **) &rest);
sexpr *ret = cons(ic, first, rest);
unprotect_ptr(ic->g);
unprotect_ptr(ic->g);
return ret;
}
mesh::mesh(std::string filepath, int material_index)
{
xmin = ymin = zmin = std::numeric_limits<double>::infinity();
xmax = ymax = zmax = -std::numeric_limits<double>::infinity();
readobj(filepath);
this->mtl_idx = material_index;
std::vector<face*> prims;
for(int i=0; i<faces.size(); i++)
{
prims.push_back(&faces[i]);
}
this->hierarchy.build(prims, xmin, xmax, ymin, ymax, zmin, zmax);
}
/*
* process symbols in a file
*/
void
dofile(Biobuf *bp)
{
int obj;
obj = objtype(bp, 0);
if (obj < 0)
execsyms(Bfildes(bp));
else
if (readobj(bp, obj)) {
nsym = 0;
objtraverse(psym, 0);
printsyms(symptr, nsym);
}
}
void
readobj( /* read in an object file or stream */
char *inpspec
)
{
OBJECT lastobj;
FILE *infp;
char buf[2048];
int c;
lastobj = nobjects;
if (inpspec == NULL) {
infp = stdin;
inpspec = "standard input";
} else if (inpspec[0] == '!') {
if ((infp = popen(inpspec+1, "r")) == NULL) {
sprintf(errmsg, "cannot execute \"%s\"", inpspec);
error(SYSTEM, errmsg);
}
} else if ((infp = fopen(inpspec, "r")) == NULL) {
sprintf(errmsg, "cannot open scene file \"%s\"", inpspec);
error(SYSTEM, errmsg);
}
while ((c = getc(infp)) != EOF) {
if (isspace(c))
continue;
if (c == '#') { /* comment */
fgets(buf, sizeof(buf), infp);
} else if (c == '!') { /* command */
ungetc(c, infp);
fgetline(buf, sizeof(buf), infp);
readobj(buf);
} else { /* object */
ungetc(c, infp);
getobject(inpspec, infp);
}
}
if (inpspec[0] == '!')
pclose(infp);
else if (infp != stdin)
fclose(infp);
if (nobjects == lastobj) {
sprintf(errmsg, "(%s): empty file", inpspec);
error(WARNING, errmsg);
}
}
remake()
{
char *tmpfile;
if (call("pi", stdin, stdout, dotpfile, NIL) == 0) {
if (strcmp(objname, "obj") != 0) {
call("mv", stdin, stdout, "obj", objname, NIL);
}
tmpfile = mktemp(strdup("/tmp/pdxXXXX"));
setout(tmpfile);
status();
unsetout();
bpfree();
objfree();
initstart();
readobj(objname);
setinput(tmpfile);
unlink(tmpfile);
} else {
puts("pi unsuccessful");
}
}
int
main( /* compile a .OBJ file into a mesh */
int argc,
char *argv[]
)
{
int nmatf = 0;
char pathnames[12800];
char *pns = pathnames;
char *matinp[128];
char *cp;
int i, j;
progname = argv[0];
ofun[OBJ_FACE].funp = o_face;
for (i = 1; i < argc && argv[i][0] == '-'; i++)
switch (argv[i][1]) {
case 'n': /* set limit */
objlim = atoi(argv[++i]);
break;
case 'r': /* resolution limit */
resolu = atoi(argv[++i]);
break;
case 'a': /* material file */
matinp[nmatf++] = argv[++i];
break;
case 'l': /* library material */
cp = getpath(argv[++i], getrlibpath(), R_OK);
if (cp == NULL) {
sprintf(errmsg,
"cannot find library material: '%s'",
argv[i]);
error(USER, errmsg);
}
matinp[nmatf++] = strcpy(pns, cp);
while (*pns++)
;
break;
case 'w': /* supress warnings */
nowarn = 1;
break;
default:
sprintf(errmsg, "unknown option: '%s'", argv[i]);
error(USER, errmsg);
break;
}
if (i < argc-2)
error(USER, "too many file arguments");
/* initialize mesh */
cvinit(i==argc-2 ? argv[i+1] : "<stdout>");
/* load material input */
for (j = 0; j < nmatf; j++)
readobj(matinp[j]);
/* read .OBJ file into triangles */
if (i == argc)
wfreadobj(NULL);
else
wfreadobj(argv[i]);
cvmeshbounds(); /* set octree boundaries */
if (i == argc-2) /* open output file */
if (freopen(argv[i+1], "w", stdout) == NULL)
error(SYSTEM, "cannot open output file");
SET_FILE_BINARY(stdout);
newheader("RADIANCE", stdout); /* new binary file header */
printargs(i<argc ? i+1 : argc, argv, stdout);
fputformat(MESHFMT, stdout);
fputc('\n', stdout);
mincusize = ourmesh->mcube.cusize / resolu - FTINY;
for (i = 0; i < nobjects; i++) /* add triangles to octree */
if (objptr(i)->otype == OBJ_FACE)
addface(&ourmesh->mcube, i);
/* optimize octree */
ourmesh->mcube.cutree = combine(ourmesh->mcube.cutree);
if (ourmesh->mcube.cutree == EMPTY)
error(WARNING, "mesh is empty");
cvmesh(); /* convert mesh and leaf nodes */
writemesh(ourmesh, stdout); /* write mesh to output */
/* printmeshstats(ourmesh, stderr); */
quit(0);
return 0; /* pro forma return */
}
int
main( /* convert object files to an octree */
int argc,
char *argv[]
)
{
FVECT bbmin, bbmax;
char *infile = NULL;
int inpfrozen = 0;
int outflags = IO_ALL;
OBJECT startobj;
int i;
progname = argv[0] = fixargv0(argv[0]);
ot_initotypes();
for (i = 1; i < argc && argv[i][0] == '-'; i++)
switch (argv[i][1]) {
case '\0': /* scene from stdin */
goto breakopt;
case 'i': /* input octree */
infile = argv[++i];
break;
case 'b': /* bounding cube */
thescene.cuorg[0] = atof(argv[++i]) - OMARGIN;
thescene.cuorg[1] = atof(argv[++i]) - OMARGIN;
thescene.cuorg[2] = atof(argv[++i]) - OMARGIN;
thescene.cusize = atof(argv[++i]) + 2*OMARGIN;
break;
case 'n': /* set limit */
objlim = atoi(argv[++i]);
break;
case 'r': /* resolution limit */
resolu = atoi(argv[++i]);
break;
case 'f': /* freeze octree */
outflags &= ~IO_FILES;
break;
case 'w': /* supress warnings */
nowarn = 1;
break;
default:
sprintf(errmsg, "unknown option: '%s'", argv[i]);
error(USER, errmsg);
break;
}
breakopt:
SET_FILE_BINARY(stdout);
if (infile != NULL) { /* get old octree & objects */
if (thescene.cusize > FTINY)
error(USER, "only one of '-b' or '-i'");
nfiles = readoct(infile, IO_ALL, &thescene, ofname);
if (nfiles == 0)
inpfrozen++;
} else
newheader("RADIANCE", stdout); /* new binary file header */
printargs(argc, argv, stdout);
fputformat(OCTFMT, stdout);
printf("\n");
startobj = nobjects; /* previous objects already converted */
for ( ; i < argc; i++) /* read new scene descriptions */
if (!strcmp(argv[i], "-")) { /* from stdin */
readobj(NULL);
outflags &= ~IO_FILES;
} else { /* from file */
if (nfiles >= MAXOBJFIL)
error(INTERNAL, "too many scene files");
readobj(ofname[nfiles++] = argv[i]);
}
ofname[nfiles] = NULL;
if (inpfrozen && outflags & IO_FILES) {
error(WARNING, "frozen octree");
outflags &= ~IO_FILES;
}
/* find bounding box */
bbmin[0] = bbmin[1] = bbmin[2] = FHUGE;
bbmax[0] = bbmax[1] = bbmax[2] = -FHUGE;
for (i = startobj; i < nobjects; i++)
add2bbox(objptr(i), bbmin, bbmax);
/* set/check cube */
if (thescene.cusize == 0.0) {
if (bbmin[0] <= bbmax[0]) {
for (i = 0; i < 3; i++) {
bbmin[i] -= OMARGIN;
bbmax[i] += OMARGIN;
}
for (i = 0; i < 3; i++)
if (bbmax[i] - bbmin[i] > thescene.cusize)
thescene.cusize = bbmax[i] - bbmin[i];
for (i = 0; i < 3; i++)
thescene.cuorg[i] =
(bbmax[i]+bbmin[i]-thescene.cusize)*.5;
}
} else {
for (i = 0; i < 3; i++)
if (bbmin[i] < thescene.cuorg[i] ||
bbmax[i] > thescene.cuorg[i] + thescene.cusize)
error(USER, "boundary does not encompass scene");
}
mincusize = thescene.cusize / resolu - FTINY;
for (i = startobj; i < nobjects; i++) /* add new objects */
addobject(&thescene, i);
thescene.cutree = combine(thescene.cutree); /* optimize */
writeoct(outflags, &thescene, ofname); /* write structures to stdout */
quit(0);
return 0; /* pro forma return */
}
int main (int argc, char* argv [])
{
#define check(ol, al) if (argv [i][ol] || \
badarg(argc - i - 1,argv + i + 1, al)) \
goto badopt
#define check_bool(olen, var) switch (argv [i][olen]) { \
case '\0': var = !var; break; \
case 'y': case 'Y': case 't': case 'T': \
case '+': case '1': var = 1; break; \
case 'n': case 'N': case 'f': case 'F': \
case '-': case '0': var = 0; break; \
default: goto badopt; \
}
int loadflags = IO_CHECK | IO_SCENE | IO_TREE | IO_BOUNDS, rval, i, j, n;
char **portLp = photonPortList, **sensLp = photonSensorList,
**amblp = NULL;
struct stat pmstat;
/* Global program name */
progname = fixargv0(argv [0]);
/* Initialize object types */
initotypes();
/* Parse options */
for (i = 1; i < argc; i++) {
/* Eggs-pand arguments */
while ((rval = expandarg(&argc, &argv, i)))
if (rval < 0) {
sprintf(errmsg, "cannot eggs-pand '%s'", argv [i]);
error(SYSTEM, errmsg);
}
if (argv[i] == NULL)
break;
if (!strcmp(argv [i], "-version")) {
puts(VersionID);
quit(0);
}
if (!strcmp(argv [i], "-defaults") || !strcmp(argv [i], "-help")) {
printdefaults();
quit(0);
}
/* Get octree */
if (i == argc - 1) {
octname = argv [i];
break;
}
switch (argv [i][1]) {
case 'a': /* Ambient */
switch (argv [i][2]) {
case 'i': /* Ambient include */
case 'I':
check(3, "s");
if (ambincl != 1) {
ambincl = 1;
amblp = amblist;
}
if (argv [i][2] == 'I') {
/* Add modifiers from file */
rval = wordfile(amblp, AMBLLEN - (amblp - amblist),
getpath(argv [++i],
getrlibpath(), R_OK));
if (rval < 0) {
sprintf(errmsg,
"cannot open ambient include file \"%s\"",
argv [i]);
error(SYSTEM, errmsg);
}
amblp += rval;
}
else {
/* Add modifier from next arg */
*amblp++ = savqstr(argv [++i]);
*amblp = NULL;
}
break;
case 'e': /* Ambient exclude */
case 'E':
check(3, "s");
if (ambincl != 0) {
ambincl = 0;
amblp = amblist;
}
if (argv [i][2] == 'E') {
/* Add modifiers from file */
rval = wordfile(amblp, AMBLLEN - (amblp - amblist),
getpath(argv [++i],
getrlibpath(), R_OK));
if (rval < 0) {
sprintf(errmsg,
"cannot open ambient exclude file \"%s\"",
argv [i]);
error(SYSTEM, errmsg);
}
amblp += rval;
}
else {
/* Add modifier from next arg */
*amblp++ = savqstr(argv [++i]);
*amblp = NULL;
}
break;
case 'p': /* Pmap-specific */
switch (argv [i][3]) {
case 'g': /* Global photon map */
check(4, "ss");
globalPmapParams.fileName = argv [++i];
globalPmapParams.distribTarget =
parseMultiplier(argv [++i]);
if (!globalPmapParams.distribTarget)
goto badopt;
globalPmapParams.minGather =
globalPmapParams.maxGather = 0;
break;
case 'p': /* Precomputed global photon map */
check(4, "ssi");
preCompPmapParams.fileName = argv [++i];
preCompPmapParams.distribTarget =
parseMultiplier(argv [++i]);
if (!preCompPmapParams.distribTarget)
goto badopt;
preCompPmapParams.minGather =
preCompPmapParams.maxGather = atoi(argv [++i]);
if (!preCompPmapParams.maxGather)
goto badopt;
break;
case 'c': /* Caustic photon map */
check(4, "ss");
causticPmapParams.fileName = argv [++i];
causticPmapParams.distribTarget =
parseMultiplier(argv [++i]);
if (!causticPmapParams.distribTarget)
goto badopt;
break;
case 'v': /* Volume photon map */
check(4, "ss");
volumePmapParams.fileName = argv [++i];
volumePmapParams.distribTarget =
parseMultiplier(argv [++i]);
if (!volumePmapParams.distribTarget)
goto badopt;
break;
case 'd': /* Direct photon map */
check(4, "ss");
directPmapParams.fileName = argv [++i];
directPmapParams.distribTarget =
parseMultiplier(argv [++i]);
if (!directPmapParams.distribTarget)
goto badopt;
break;
case 'C': /* Contribution photon map */
check(4, "ss");
contribPmapParams.fileName = argv [++i];
contribPmapParams.distribTarget =
parseMultiplier(argv [++i]);
if (!contribPmapParams.distribTarget)
goto badopt;
break;
case 'D': /* Predistribution factor */
check(4, "f");
preDistrib = atof(argv [++i]);
if (preDistrib <= 0)
error(USER, "predistrib factor must be > 0");
break;
case 'M': /* Max predistribution passes */
check(4, "i");
maxPreDistrib = atoi(argv [++i]);
if (maxPreDistrib <= 0)
error(USER, "max predistrib passes must be > 0");
break;
#if 1
/* Kept for backwards compat, to be phased out by -lr */
case 'm': /* Max photon bounces */
check(4, "i");
photonMaxBounce = atol(argv [++i]);
if (photonMaxBounce <= 0)
error(USER, "max photon bounces must be > 0");
break;
#endif
#ifdef PMAP_EKSPERTZ
case 'i': /* Add region of interest */
check(4, "ffffff");
n = pmapNumROI;
pmapROI = realloc(pmapROI,
++pmapNumROI * sizeof(PhotonMapROI));
if (!pmapROI)
error(SYSTEM, "failed to allocate ROI");
pmapROI [n].min [0] = atof(argv [++i]);
pmapROI [n].min [1] = atof(argv [++i]);
pmapROI [n].min [2] = atof(argv [++i]);
pmapROI [n].max [0] = atof(argv [++i]);
pmapROI [n].max [1] = atof(argv [++i]);
pmapROI [n].max [2] = atof(argv [++i]);
for (j = 0; j < 3; j++)
if (pmapROI [n].min [j] >= pmapROI [n].max [j])
error(USER, "invalid region of interest "
"(swapped min/max?)");
break;
#endif
case 'P': /* Global photon precomp ratio */
check(4, "f");
finalGather = atof(argv [++i]);
if (finalGather <= 0 || finalGather > 1)
error(USER, "global photon precomputation ratio "
"must be in range ]0, 1]");
break;
case 'o': /* Photon port */
case 'O':
check(4, "s");
if (argv [i][3] == 'O') {
/* Add port modifiers from file */
rval = wordfile(portLp,
MAXSET - (portLp - photonPortList),
getpath(argv [++i],
getrlibpath(), R_OK));
if (rval < 0) {
sprintf(errmsg,
"cannot open photon port file %s",
argv [i]);
error(SYSTEM, errmsg);
}
portLp += rval;
}
else {
/* Add port modifier from next arg, mark end with
* NULL */
*portLp++ = savqstr(argv [++i]);
*portLp = NULL;
}
break;
case 'r': /* Random seed */
check(4, "i");
randSeed = atoi(argv [++i]);
break;
case 's': /* Antimatter sensor */
case 'S':
check(4, "s");
if (argv[i][3] == 'S') {
/* Add sensor modifiers from file */
rval = wordfile(sensLp,
MAXSET - (sensLp - photonSensorList),
getpath(argv [++i],
getrlibpath(), R_OK));
if (rval < 0) {
sprintf(errmsg,
"cannot open antimatter sensor file %s",
argv [i]);
error(SYSTEM, errmsg);
}
sensLp += rval;
}
else {
/* Append modifier to sensor list, mark end with
* NULL */
*sensLp++ = savqstr(argv [++i]);
*sensLp = NULL;
}
break;
default: goto badopt;
}
break;
default: goto badopt;
}
break;
case 'b': /* Back face visibility */
if (argv [i][2] == 'v') {
check_bool(3, backvis);
}
else goto badopt;
break;
case 'd': /* Direct */
switch (argv [i][2]) {
case 'p': /* PDF samples */
check(3, "f");
pdfSamples = atof(argv [++i]);
break;
case 's': /* Source partition size ratio */
check(3, "f");
srcsizerat = atof(argv [++i]);
break;
default: goto badopt;
}
break;
case 'e': /* Diagnostics file */
check(2, "s");
diagFile = argv [++i];
break;
case 'f': /* Force overwrite */
if (argv [i][2] == 'o') {
check_bool(3, clobber);
}
else goto badopt;
break;
#ifdef PMAP_EKSPERTZ
case 'l': /* Limits */
switch (argv [i][2]) {
case 'd': /* Limit photon path distance */
check(3, "f");
photonMaxDist = atof(argv [++i]);
if (photonMaxDist <= 0)
error(USER, "max photon distance must be > 0");
break;
case 'r': /* Limit photon bounces */
check(3, "i");
photonMaxBounce = atol(argv [++i]);
if (photonMaxBounce <= 0)
error(USER, "max photon bounces must be > 0");
break;
default: goto badopt;
}
break;
#endif
case 'm': /* Medium */
switch (argv[i][2]) {
case 'e': /* Eggs-tinction coefficient */
check(3, "fff");
setcolor(cextinction, atof(argv [i + 1]),
atof(argv [i + 2]), atof(argv [i + 3]));
i += 3;
break;
case 'a': /* Albedo */
check(3, "fff");
setcolor(salbedo, atof(argv [i + 1]),
atof(argv [i + 2]), atof(argv [i + 3]));
i += 3;
break;
case 'g': /* Scattering eccentricity */
check(3, "f");
seccg = atof(argv [++i]);
break;
default: goto badopt;
}
break;
#if NIX
case 'n': /* Num parallel processes (NIX only) */
check(2, "i");
nproc = atoi(argv [++i]);
if (nproc > PMAP_MAXPROC) {
nproc = PMAP_MAXPROC;
sprintf(errmsg, "too many parallel processes, clamping to "
"%d\n", nproc);
error(WARNING, errmsg);
}
break;
#endif
case 't': /* Timer */
check(2, "i");
photonRepTime = atoi(argv [++i]);
break;
case 'v': /* Verbosity */
check_bool(2, verbose);
break;
#ifdef EVALDRC_HACK
case 'A': /* Angular source file */
check(2,"s");
angsrcfile = argv[++i];
break;
#endif
default: goto badopt;
}
}
/* Open diagnostics file */
if (diagFile) {
if (!freopen(diagFile, "a", stderr)) quit(2);
fprintf(stderr, "**************\n*** PID %5d: ", getpid());
printargs(argc, argv, stderr);
putc('\n', stderr);
fflush(stderr);
}
#ifdef NICE
/* Lower priority */
nice(NICE);
#endif
if (octname == NULL)
error(USER, "missing octree argument");
/* Allocate photon maps and set parameters */
for (i = 0; i < NUM_PMAP_TYPES; i++) {
setPmapParam(photonMaps + i, pmapParams + i);
/* Don't overwrite existing photon map unless clobbering enabled */
if (photonMaps [i] && !stat(photonMaps [i] -> fileName, &pmstat) &&
!clobber) {
sprintf(errmsg, "photon map file %s exists, not overwritten",
photonMaps [i] -> fileName);
error(USER, errmsg);
}
}
for (i = 0; i < NUM_PMAP_TYPES && !photonMaps [i]; i++);
if (i >= NUM_PMAP_TYPES)
error(USER, "no photon maps specified");
readoct(octname, loadflags, &thescene, NULL);
#ifdef EVALDRC_HACK
if (angsrcfile)
readobj(angsrcfile); /* load angular sources */
#endif
nsceneobjs = nobjects;
/* Get sources */
marksources();
/* Do forward pass and build photon maps */
if (contribPmap)
/* Just build contrib pmap, ignore others */
distribPhotonContrib(contribPmap, nproc);
else
distribPhotons(photonMaps, nproc);
/* Save photon maps; no idea why GCC needs an explicit cast here... */
savePmaps((const PhotonMap**)photonMaps, argc, argv);
cleanUpPmaps(photonMaps);
quit(0);
badopt:
sprintf(errmsg, "command line error at '%s'", argv[i]);
error(USER, errmsg);
#undef check
#undef check_bool
return 0;
}
int main(int argc, char *argv[]) {
// Initialize randomness
srand(time(NULL));
// 7 parameters are required.
if (argc != 13) {
fprintf(stderr, "Usage: %s obj-file sx sy sz tx ty tz rx ry rz focal-dist hiding\n", argv[0]);
return 0;
}
unsigned int i, j;
double sx = atof( argv[2] );
double sy = atof( argv[3] );
double sz = atof( argv[4] );
double tx = atof( argv[5] );
double ty = atof( argv[6] );
double tz = atof( argv[7] );
double rx = atof( argv[8] );
double ry = atof( argv[9] );
double rz = atof( argv[10] );
double fd = atof( argv[11] );
int hiding = atoi( argv[12] );
matrix_double scale = scale_by(sx, sy, sz);
matrix_double tras = traslate(tx, ty, tz);
matrix_double rot = rotate(rx, ry, rz);
matrix_double proj = projection(fd);
file_data vnf = readobj(argv[1]);
// int p;
// for (p = 0; p < vnf.vertices.num_elems; p++) {
// point3d t = (vnf.vertices.data)[p];
// fprintf(stderr, "(%f,%f,%f)\n", t.x, t.y, t.z);
// }
// Join all the transformations in a single matrix
// Operation order: Scaling, rotation, traslation and projection
matrix_double t1 = product(proj, tras);
matrix_double t2 = product(t1, rot);
matrix_double t3 = product(t2, scale);
apply_matrix(t3, vnf.vertices);
dispose_matrix(&t3);
dispose_matrix(&t2);
dispose_matrix(&t1);
dispose_matrix(&scale);
dispose_matrix(&tras);
dispose_matrix(&rot);
dispose_matrix(&proj);
// Projection sets w = z, so divide everything by w.
for (i = 0; i < vnf.vertices.num_elems; i++) {
point3d tmp = (vnf.vertices.data)[i];
tmp.x /= tmp.w;
tmp.y /= tmp.w;
tmp.z /= tmp.w;
(vnf.vertices.data)[i] = tmp;
}
// The camera normal (taking advantage of perspective projection)
vector camera_normal = new_vector( new_point3d(0.0, 0.0, 0.0, 1.0), new_point3d(0.0, 0.0, 1.0, 1.0) );
// The z-buffer
double **zbuf = calloc(HEIGHT, sizeof *zbuf);
for (i = 0; i < HEIGHT; i++) {
zbuf[i] = calloc(WIDTH, sizeof **zbuf);
for (j = 0; j < WIDTH; j++)
zbuf[i][j] = DBL_MAX;
}
color c = new_color( 255, 255, 255 );
point center = { WIDTH >> 1, HEIGHT >> 1 };
int invertX = 0, invertY = 1;
raster tmp = new_raster(WIDTH, HEIGHT, 3);
for (i = 0; i < vnf.faces.num_elems; i++) {
point3d v1 = (vnf.vertices.data)[((vnf.faces.data)[i].v1) - 1];
point3d v2 = (vnf.vertices.data)[((vnf.faces.data)[i].v2) - 1];
point3d v3 = (vnf.vertices.data)[((vnf.faces.data)[i].v3) - 1];
point pt[3] = { new_point(v1.x, v1.y), new_point(v2.x, v2.y), new_point(v3.x, v3.y) };
for (j = 0; j < 3; j++)
pt[j] = raster_translate(pt[j], center, invertX, invertY);
// Hiding faces using face normals
if (hiding == 1) {
vector va = new_vector( v1, v2 );
vector vb = new_vector( v1, v3 );
vector vn = vector_crossproduct( va, vb );
if ( abs(vector_angle(vn, camera_normal)) < 90.0 ) continue;
}
// Drawing the face
for (j = 0; j < 3; j++) {
int curr = j;
int next = (j+1) % 3;
point ps = pt[curr];
point pe = pt[next];
// Use z-buffering if allowed
// if (hiding == 2)
// put_line_z(tmp, new_line( ps, pe ), c, bresenham, zbuf, vertices[3][curr], vertices[3][next]);
// else
put_line(tmp, new_line( ps, pe ), c, bresenham);
}
// Filling the face using a random, eye-pleasing colour
color cr = { ((rand() % 255) + 255) >> 1, ((rand() % 255) + 255) >> 1, ((rand() % 255) + 255) >> 1 };
// if (hiding == 2)
// fill_face_z(tmp, pt[0], pt[1], pt[2], cr, zbuf, vertices[3][j], vertices[3][(j+1) % 3]);
// elseelse
fill_face(tmp, pt[0], pt[1], pt[2], cr);
}
raster_out(tmp);
dispose_raster(tmp);
for (i = 0; i < HEIGHT; i++) free(zbuf[i]);
free(zbuf);
free(vnf.vertices.data);
free(vnf.faces.data);
return 0;
}
mesh::mesh(std::string filepath)
{
readobj(filepath);
this->rad = xmax > ymax ? xmax : ymax;
}
int
readoct( /* read in octree file or stream */
char *inpspec,
int load,
CUBE *scene,
char *ofn[]
)
{
char sbuf[512];
int nf;
int i;
long m;
if (inpspec == NULL) {
infn = "standard input";
infp = stdin;
} else if (inpspec[0] == '!') {
infn = inpspec;
if ((infp = popen(inpspec+1, "r")) == NULL) {
sprintf(errmsg, "cannot execute \"%s\"", inpspec);
error(SYSTEM, errmsg);
}
} else {
infn = inpspec;
if ((infp = fopen(inpspec, "r")) == NULL) {
sprintf(errmsg, "cannot open octree file \"%s\"",
inpspec);
error(SYSTEM, errmsg);
}
}
SET_FILE_BINARY(infp);
/* get header */
if (checkheader(infp, OCTFMT, load&IO_INFO ? stdout : (FILE *)NULL) < 0)
octerror(USER, "not an octree");
/* check format */
if ((objsize = ogetint(2)-OCTMAGIC) <= 0 ||
objsize > MAXOBJSIZ || objsize > sizeof(long))
octerror(USER, "incompatible octree format");
/* get boundaries */
if (load & IO_BOUNDS) {
for (i = 0; i < 3; i++)
scene->cuorg[i] = atof(ogetstr(sbuf));
scene->cusize = atof(ogetstr(sbuf));
} else {
for (i = 0; i < 4; i++)
ogetstr(sbuf);
}
objorig = nobjects; /* set object offset */
nf = 0; /* get object files */
while (*ogetstr(sbuf)) {
if (load & IO_SCENE)
readobj(sbuf);
if (load & IO_FILES)
ofn[nf] = savqstr(sbuf);
nf++;
}
if (load & IO_FILES)
ofn[nf] = NULL;
/* get number of objects */
fnobjects = m = ogetint(objsize);
if (fnobjects != m)
octerror(USER, "too many objects");
if (load & IO_TREE) /* get the octree */
scene->cutree = gettree();
else if (load & IO_SCENE && nf == 0)
skiptree();
if (load & IO_SCENE) { /* get the scene */
if (nf == 0) {
/* load binary scene data */
readscene(infp, objsize);
} else { /* consistency checks */
/* check object count */
if (nobjects != objorig+fnobjects)
octerror(USER, "bad object count; octree stale?");
/* check for non-surfaces */
if (nonsurfintree(scene->cutree))
octerror(USER, "modifier in tree; octree stale?");
}
}
/* close the input */
if (infn[0] == '!')
pclose(infp);
else
fclose(infp);
return(nf);
}
