# 1 "QvTraverse.cpp" # 1 "QvElement.h" 1 # 1 "QvBasic.h" 1 # 1 "/usr/include/sys/types.h" 1 3 4 # 1 "/usr/include/sys/cdefs.h" 1 3 4 # 121 "/usr/include/sys/cdefs.h" 3 4 # 67 "/usr/include/sys/types.h" 2 3 4 # 1 "/usr/include/machine/types.h" 1 3 4 # 1 "/usr/include/ppc/types.h" 1 3 4 typedef signed char int8_t; typedef unsigned char u_int8_t; typedef short int16_t; typedef unsigned short u_int16_t; typedef int int32_t; typedef unsigned int u_int32_t; typedef long long int64_t; typedef unsigned long long u_int64_t; typedef int32_t register_t; typedef int *intptr_t; typedef unsigned long *uintptr_t; # 30 "/usr/include/machine/types.h" 2 3 4 # 70 "/usr/include/sys/types.h" 2 3 4 # 1 "/usr/include/machine/ansi.h" 1 3 4 # 1 "/usr/include/ppc/ansi.h" 1 3 4 # 34 "/usr/include/machine/ansi.h" 2 3 4 # 72 "/usr/include/sys/types.h" 2 3 4 # 1 "/usr/include/machine/endian.h" 1 3 4 # 1 "/usr/include/ppc/endian.h" 1 3 4 extern "C" { unsigned long htonl (unsigned long) ; unsigned short htons (unsigned short) ; unsigned long ntohl (unsigned long) ; unsigned short ntohs (unsigned short) ; } # 116 "/usr/include/ppc/endian.h" 3 4 # 30 "/usr/include/machine/endian.h" 2 3 4 # 73 "/usr/include/sys/types.h" 2 3 4 typedef unsigned char u_char; typedef unsigned short u_short; typedef unsigned int u_int; typedef unsigned long u_long; typedef unsigned short ushort; typedef unsigned int uint; typedef u_int64_t u_quad_t; typedef int64_t quad_t; typedef quad_t * qaddr_t; typedef char * caddr_t; typedef int32_t daddr_t; typedef int32_t dev_t; typedef u_int32_t fixpt_t; typedef u_int32_t gid_t; typedef u_int32_t ino_t; typedef long key_t; typedef u_int16_t mode_t; typedef u_int16_t nlink_t; typedef quad_t off_t; typedef int32_t pid_t; typedef quad_t rlim_t; typedef int32_t segsz_t; typedef int32_t swblk_t; typedef u_int32_t uid_t; typedef unsigned long clock_t; typedef long unsigned int size_t; typedef int ssize_t; typedef long time_t; typedef int32_t fd_mask; typedef struct fd_set { fd_mask fds_bits[((( 256 ) + (( (sizeof(fd_mask) * 8 ) ) - 1)) / ( (sizeof(fd_mask) * 8 ) )) ]; } fd_set; # 174 "/usr/include/sys/types.h" 3 4 struct _pthread_handler_rec { void (*routine)(void *); void *arg; struct _pthread_handler_rec *next; }; typedef struct _opaque_pthread_t { long sig; struct _pthread_handler_rec *cleanup_stack; char opaque[596 ];} *pthread_t; typedef struct _opaque_pthread_attr_t { long sig; char opaque[36 ]; } pthread_attr_t; typedef struct _opaque_pthread_mutexattr_t { long sig; char opaque[8 ]; } pthread_mutexattr_t; typedef struct _opaque_pthread_mutex_t { long sig; char opaque[40 ]; } pthread_mutex_t; typedef struct _opaque_pthread_condattr_t { long sig; char opaque[4 ]; } pthread_condattr_t; typedef struct _opaque_pthread_cond_t { long sig; char opaque[24 ]; } pthread_cond_t; typedef struct { long sig; char opaque[4 ]; } pthread_once_t; typedef unsigned long pthread_key_t; # 10 "QvBasic.h" 2 # 1 "/usr/include/libc.h" 1 3 4 # 1 "/usr/include/stdio.h" 1 3 4 typedef off_t fpos_t; struct __sbuf { unsigned char *_base; int _size; }; typedef struct __sFILE { unsigned char *_p; int _r; int _w; short _flags; short _file; struct __sbuf _bf; int _lbfsize; void *_cookie; int (*_close) (void *) ; int (*_read) (void *, char *, int) ; fpos_t (*_seek) (void *, fpos_t, int) ; int (*_write) (void *, const char *, int) ; struct __sbuf _ub; unsigned char *_up; int _ur; unsigned char _ubuf[3]; unsigned char _nbuf[1]; struct __sbuf _lb; int _blksize; fpos_t _offset; } FILE; extern "C" { extern FILE __sF[]; } extern "C" { void clearerr (FILE *) ; int fclose (FILE *) ; int feof (FILE *) ; int ferror (FILE *) ; int fflush (FILE *) ; int fgetc (FILE *) ; int fgetpos (FILE *, fpos_t *) ; char *fgets (char *, size_t, FILE *) ; FILE *fopen (const char *, const char *) ; int fprintf (FILE *, const char *, ...) ; int fputc (int, FILE *) ; int fputs (const char *, FILE *) ; size_t fread (void *, size_t, size_t, FILE *) ; FILE *freopen (const char *, const char *, FILE *) ; int fscanf (FILE *, const char *, ...) ; int fseek (FILE *, long, int) ; int fsetpos (FILE *, const fpos_t *) ; long ftell (FILE *) ; size_t fwrite (const void *, size_t, size_t, FILE *) ; int getc (FILE *) ; int getchar (void) ; char *gets (char *) ; extern int sys_nerr; extern const char * const sys_errlist[]; void perror (const char *) ; int printf (const char *, ...) ; int putc (int, FILE *) ; int putchar (int) ; int puts (const char *) ; int remove (const char *) ; int rename (const char *, const char *) ; void rewind (FILE *) ; int scanf (const char *, ...) ; void setbuf (FILE *, char *) ; int setvbuf (FILE *, char *, int, size_t) ; int sprintf (char *, const char *, ...) ; int sscanf (const char *, const char *, ...) ; FILE *tmpfile (void) ; char *tmpnam (char *) ; int ungetc (int, FILE *) ; int vfprintf (FILE *, const char *, char * ) ; int vprintf (const char *, char * ) ; int vsprintf (char *, const char *, char * ) ; } extern "C" { char *ctermid (char *) ; FILE *fdopen (int, const char *) ; int fileno (FILE *) ; } extern "C" { char *fgetln (FILE *, size_t *) ; int fpurge (FILE *) ; int fseeko (FILE *, fpos_t, int) ; fpos_t ftello (FILE *) ; int getw (FILE *) ; int pclose (FILE *) ; FILE *popen (const char *, const char *) ; int putw (int, FILE *) ; void setbuffer (FILE *, char *, int) ; int setlinebuf (FILE *) ; char *tempnam (const char *, const char *) ; int snprintf (char *, size_t, const char *, ...) ; int vsnprintf (char *, size_t, const char *, char * ) ; int vscanf (const char *, char * ) ; int vsscanf (const char *, const char *, char * ) ; FILE *zopen (const char *, const char *, int) ; } extern "C" { FILE *funopen (const void *, int (*)(void *, char *, int), int (*)(void *, const char *, int), fpos_t (*)(void *, fpos_t, int), int (*)(void *)) ; } extern "C" { int __srget (FILE *) ; int __svfscanf (FILE *, const char *, char * ) ; int __swbuf (int, FILE *) ; } static inline int __sputc(int _c, FILE *_p) { if (--_p->_w >= 0 || (_p->_w >= _p->_lbfsize && (char)_c != '\n')) return (*_p->_p++ = _c); else return (__swbuf(_c, _p)); } # 379 "/usr/include/stdio.h" 3 4 # 29 "/usr/include/libc.h" 2 3 4 # 1 "/usr/include/standards.h" 1 3 4 # 30 "/usr/include/libc.h" 2 3 4 # 1 "/usr/include/unistd.h" 1 3 4 # 1 "/usr/include/sys/unistd.h" 1 3 4 # 72 "/usr/include/unistd.h" 2 3 4 extern "C" { void _exit (int) ; int access (const char *, int) ; unsigned int alarm (unsigned int) ; int chdir (const char *) ; int chown (const char *, uid_t, gid_t) ; int close (int) ; size_t confstr (int, char *, size_t) ; int dup (int) ; int dup2 (int, int) ; int execl (const char *, const char *, ...) ; int execle (const char *, const char *, ...) ; int execlp (const char *, const char *, ...) ; int execv (const char *, char * const *) ; int execve (const char *, char * const *, char * const *) ; int execvp (const char *, char * const *) ; pid_t fork (void) ; long fpathconf (int, int) ; char *getcwd (char *, size_t) ; gid_t getegid (void) ; uid_t geteuid (void) ; gid_t getgid (void) ; int getgroups (int, gid_t []) ; char *getlogin (void) ; pid_t getpgrp (void) ; pid_t getpid (void) ; pid_t getppid (void) ; uid_t getuid (void) ; int isatty (int) ; int link (const char *, const char *) ; off_t lseek (int, off_t, int) ; long pathconf (const char *, int) ; int pause (void) ; int pipe (int *) ; ssize_t read (int, void *, size_t) ; int rmdir (const char *) ; int setgid (gid_t) ; int setpgid (pid_t, pid_t) ; pid_t setsid (void) ; int setuid (uid_t) ; unsigned int sleep (unsigned int) ; long sysconf (int) ; pid_t tcgetpgrp (int) ; int tcsetpgrp (int, pid_t) ; char *ttyname (int) ; int unlink (const char *) ; ssize_t write (int, const void *, size_t) ; extern char *optarg; extern int optind, opterr, optopt, optreset; int getopt (int, char * const [], const char *) ; struct timeval; int acct (const char *) ; int async_daemon (void) ; char *brk (const char *) ; int chroot (const char *) ; char *crypt (const char *, const char *) ; int des_cipher (const char *, char *, long, int) ; int des_setkey (const char *key) ; int encrypt (char *, int) ; void endusershell (void) ; int exect (const char *, char * const *, char * const *) ; int fchdir (int) ; int fchown (int, int, int) ; int fsync (int) ; int ftruncate (int, off_t) ; int getdtablesize (void) ; int getgrouplist (const char *, int, int *, int *) ; long gethostid (void) ; int gethostname (char *, int) ; mode_t getmode (const void *, mode_t) ; int getpagesize (void) ; char *getpass (const char *) ; char *getusershell (void) ; char *getwd (char *) ; int initgroups (const char *, int) ; int iruserok (unsigned long, int, const char *, const char *) ; int mknod (const char *, mode_t, dev_t) ; int mkstemp (char *) ; char *mktemp (char *) ; int nfssvc (int, void *) ; int nice (int) ; # 1 "/usr/include/signal.h" 1 3 4 # 1 "/usr/include/sys/signal.h" 1 3 4 # 1 "/usr/include/machine/signal.h" 1 3 4 # 1 "/usr/include/ppc/signal.h" 1 3 4 typedef int sig_atomic_t; typedef enum { REGS_SAVED_NONE, REGS_SAVED_CALLER, REGS_SAVED_ALL } regs_saved_t; struct sigcontext { int sc_onstack; int sc_mask; int sc_ir; int sc_psw; int sc_sp; void *sc_regs; }; # 27 "/usr/include/machine/signal.h" 2 3 4 # 70 "/usr/include/sys/signal.h" 2 3 4 typedef unsigned int sigset_t; struct sigaction { void (*sa_handler)(int); sigset_t sa_mask; int sa_flags; }; typedef void (*sig_t) (int) ; struct sigaltstack { char *ss_sp; int ss_size; int ss_flags; }; struct sigvec { void (*sv_handler)(); int sv_mask; int sv_flags; }; struct sigstack { char *ss_sp; int ss_onstack; }; # 213 "/usr/include/sys/signal.h" 3 4 extern "C" { void (*signal (int, void (*) (int) ) ) (int) ; } # 62 "/usr/include/signal.h" 2 3 4 extern const char * const sys_signame[32 ]; extern const char * const sys_siglist[32 ]; extern "C" { int raise (int) ; int kill (pid_t, int) ; int sigaction (int, const struct sigaction *, struct sigaction *) ; int sigaddset (sigset_t *, int) ; int sigdelset (sigset_t *, int) ; int sigemptyset (sigset_t *) ; int sigfillset (sigset_t *) ; int sigismember (const sigset_t *, int) ; int sigpending (sigset_t *) ; int sigprocmask (int, const sigset_t *, sigset_t *) ; int sigsuspend (const sigset_t *) ; int killpg (pid_t, int) ; int sigblock (int) ; int siginterrupt (int, int) ; int sigpause (int) ; int sigreturn (struct sigcontext *) ; int sigsetmask (int) ; int sigvec (int, struct sigvec *, struct sigvec *) ; void psignal (unsigned int, const char *) ; } # 176 "/usr/include/unistd.h" 2 3 4 int profil (char *, int, int, int) ; int rcmd (char **, int, const char *, const char *, const char *, int *) ; char *re_comp (const char *) ; int re_exec (const char *) ; int readlink (const char *, char *, int) ; int reboot (int) ; int revoke (const char *) ; int rresvport (int *) ; int ruserok (const char *, int, const char *, const char *) ; char *sbrk (int) ; int select (int, fd_set *, fd_set *, fd_set *, struct timeval *) ; int setegid (gid_t) ; int seteuid (uid_t) ; int setgroups (int, const gid_t *) ; void sethostid (long) ; int sethostname (const char *, int) ; int setkey (const char *) ; int setlogin (const char *) ; void *setmode (const char *) ; int setpgrp (pid_t pid, pid_t pgrp) ; int setregid (gid_t, gid_t) ; int setreuid (uid_t, uid_t) ; int setrgid (gid_t) ; int setruid (uid_t) ; void setusershell (void) ; int swapon (const char *) ; int symlink (const char *, const char *) ; void sync (void) ; int syscall (int, ...) ; int truncate (const char *, off_t) ; int ttyslot (void) ; unsigned int ualarm (unsigned int, unsigned int) ; int unwhiteout (const char *) ; void usleep (unsigned int) ; void *valloc (size_t) ; pid_t vfork (void) ; extern char *suboptarg; int getsubopt (char **, char * const *, char **) ; int getattrlist (const char*,void*,void*,size_t,unsigned long) ; int setattrlist (const char*,void*,void*,size_t,unsigned long) ; int exchangedata (const char*,const char*,unsigned long) ; int checkuseraccess (const char*,uid_t,gid_t*,int,int,unsigned long) ; int getdirentriesattr (int,void*,void*,size_t,unsigned long*,unsigned long*,unsigned long*,unsigned long) ; int searchfs (const char*,void*,void*,unsigned long,unsigned long,void*) ; int fsctl (const char *,unsigned long,void*,unsigned long) ; } # 31 "/usr/include/libc.h" 2 3 4 # 1 "/usr/include/string.h" 1 3 4 extern "C" { void *memchr (const void *, int, size_t) ; int memcmp (const void *, const void *, size_t) ; void *memcpy (void *, const void *, size_t) ; void *memmove (void *, const void *, size_t) ; void *memset (void *, int, size_t) ; char *strcat (char *, const char *) ; char *strchr (const char *, int) ; int strcmp (const char *, const char *) ; int strcoll (const char *, const char *) ; char *strcpy (char *, const char *) ; size_t strcspn (const char *, const char *) ; char *strerror (int) ; size_t strlen (const char *) ; char *strncat (char *, const char *, size_t) ; int strncmp (const char *, const char *, size_t) ; char *strncpy (char *, const char *, size_t) ; char *strpbrk (const char *, const char *) ; char *strrchr (const char *, int) ; size_t strspn (const char *, const char *) ; char *strstr (const char *, const char *) ; char *strtok (char *, const char *) ; size_t strxfrm (char *, const char *, size_t) ; int bcmp (const void *, const void *, size_t) ; void bcopy (const void *, void *, size_t) ; void bzero (void *, size_t) ; int ffs (int) ; char *index (const char *, int) ; void *memccpy (void *, const void *, int, size_t) ; char *rindex (const char *, int) ; int strcasecmp (const char *, const char *) ; char *strdup (const char *) ; void strmode (int, char *) ; int strncasecmp (const char *, const char *, size_t) ; char *strsep (char **, const char *) ; void swab (const void *, void *, size_t) ; } # 37 "/usr/include/libc.h" 2 3 4 # 1 "/usr/include/stdlib.h" 1 3 4 typedef __wchar_t rune_t; typedef __wchar_t wchar_t; typedef struct { int quot; int rem; } div_t; typedef struct { long quot; long rem; } ldiv_t; extern int __mb_cur_max; extern "C" { void abort (void) ; int abs (int) ; int atexit (void (*)(void)) ; double atof (const char *) ; int atoi (const char *) ; long atol (const char *) ; void *bsearch (const void *, const void *, size_t, size_t, int (*)(const void *, const void *)) ; void *calloc (size_t, size_t) ; div_t div (int, int) ; void exit (int) ; void free (void *) ; char *getenv (const char *) ; long labs (long) ; ldiv_t ldiv (long, long) ; void *malloc (size_t) ; void qsort (void *, size_t, size_t, int (*)(const void *, const void *)) ; int rand (void) ; void *realloc (void *, size_t) ; void srand (unsigned) ; double strtod (const char *, char **) ; long strtol (const char *, char **, int) ; unsigned long strtoul (const char *, char **, int) ; int system (const char *) ; int mblen (const char *, size_t) ; size_t mbstowcs (wchar_t *, const char *, size_t) ; int wctomb (char *, wchar_t) ; int mbtowc (wchar_t *, const char *, size_t) ; size_t wcstombs (char *, const wchar_t *, size_t) ; int putenv (const char *) ; int setenv (const char *, const char *, int) ; void *alloca (size_t) ; char *getbsize (int *, long *) ; char *cgetcap (char *, char *, int) ; int cgetclose (void) ; int cgetent (char **, char **, char *) ; int cgetfirst (char **, char **) ; int cgetmatch (char *, char *) ; int cgetnext (char **, char **) ; int cgetnum (char *, char *, long *) ; int cgetset (char *) ; int cgetstr (char *, char *, char **) ; int cgetustr (char *, char *, char **) ; int daemon (int, int) ; char *devname (int, int) ; int getloadavg (double [], int) ; char *group_from_gid (unsigned long, int) ; int heapsort (void *, size_t, size_t, int (*)(const void *, const void *)) ; char *initstate (unsigned long, char *, long) ; int mergesort (void *, size_t, size_t, int (*)(const void *, const void *)) ; int radixsort (const unsigned char **, int, const unsigned char *, unsigned) ; int sradixsort (const unsigned char **, int, const unsigned char *, unsigned) ; long random (void) ; char *realpath (const char *, char resolved_path[]) ; char *setstate (char *) ; void srandom (unsigned long) ; char *user_from_uid (unsigned long, int) ; long long strtoq (const char *, char **, int) ; unsigned long long strtouq (const char *, char **, int) ; void unsetenv (const char *) ; } # 38 "/usr/include/libc.h" 2 3 4 # 1 "/usr/include/time.h" 1 3 4 struct tm { int tm_sec; int tm_min; int tm_hour; int tm_mday; int tm_mon; int tm_year; int tm_wday; int tm_yday; int tm_isdst; long tm_gmtoff; char *tm_zone; }; # 1 "/usr/include/gcc/darwin/2.95.2/g++/../machine/limits.h" 1 3 # 1 "/usr/include/ppc/limits.h" 1 3 4 # 3 "/usr/include/gcc/darwin/2.95.2/g++/../machine/limits.h" 2 3 # 100 "/usr/include/time.h" 2 3 4 extern "C" { char *asctime (const struct tm *) ; clock_t clock (void) ; char *ctime (const time_t *) ; double difftime (time_t, time_t) ; struct tm *gmtime (const time_t *) ; struct tm *localtime (const time_t *) ; time_t mktime (struct tm *) ; size_t strftime (char *, size_t, const char *, const struct tm *) ; time_t time (time_t *) ; void tzset (void) ; char *timezone (int, int) ; void tzsetwall (void) ; } # 39 "/usr/include/libc.h" 2 3 4 # 1 "/usr/include/gcc/darwin/2.95.2/g++/../stdarg.h" 1 3 # 1 "/usr/include/gcc/darwin/2.95.2/g++/../va-ppc.h" 1 3 typedef char *__gnuc_va_list; # 43 "/usr/include/gcc/darwin/2.95.2/g++/../va-ppc.h" 3 void va_end (__gnuc_va_list); # 352 "/usr/include/gcc/darwin/2.95.2/g++/../va-ppc.h" 3 # 42 "/usr/include/gcc/darwin/2.95.2/g++/../stdarg.h" 2 3 # 131 "/usr/include/gcc/darwin/2.95.2/g++/../stdarg.h" 3 # 175 "/usr/include/gcc/darwin/2.95.2/g++/../stdarg.h" 3 typedef __gnuc_va_list va_list; # 40 "/usr/include/libc.h" 2 3 4 # 1 "/usr/include/sys/mount.h" 1 3 4 # 1 "/usr/include/sys/ucred.h" 1 3 4 # 1 "/usr/include/sys/param.h" 1 3 4 # 1 "/usr/include/sys/syslimits.h" 1 3 4 # 88 "/usr/include/sys/param.h" 2 3 4 # 1 "/usr/include/machine/param.h" 1 3 4 # 1 "/usr/include/ppc/param.h" 1 3 4 # 30 "/usr/include/machine/param.h" 2 3 4 # 102 "/usr/include/sys/param.h" 2 3 4 # 1 "/usr/include/gcc/darwin/2.95.2/g++/../machine/limits.h" 1 3 # 10 "/usr/include/gcc/darwin/2.95.2/g++/../machine/limits.h" 3 # 108 "/usr/include/gcc/darwin/2.95.2/g++/../machine/limits.h" 3 # 103 "/usr/include/sys/param.h" 2 3 4 # 61 "/usr/include/sys/ucred.h" 2 3 4 struct ucred { u_long cr_ref; uid_t cr_uid; short cr_ngroups; gid_t cr_groups[16 ]; }; # 88 "/usr/include/sys/ucred.h" 3 4 # 62 "/usr/include/sys/mount.h" 2 3 4 # 1 "/usr/include/sys/queue.h" 1 3 4 # 184 "/usr/include/sys/queue.h" 3 4 # 260 "/usr/include/sys/queue.h" 3 4 # 378 "/usr/include/sys/queue.h" 3 4 # 395 "/usr/include/sys/queue.h" 3 4 # 453 "/usr/include/sys/queue.h" 3 4 # 463 "/usr/include/sys/queue.h" 3 4 # 473 "/usr/include/sys/queue.h" 3 4 # 483 "/usr/include/sys/queue.h" 3 4 # 502 "/usr/include/sys/queue.h" 3 4 # 548 "/usr/include/sys/queue.h" 3 4 # 64 "/usr/include/sys/mount.h" 2 3 4 # 1 "/usr/include/sys/lock.h" 1 3 4 # 74 "/usr/include/sys/lock.h" 3 4 # 1 "/usr/include/mach/boolean.h" 1 3 4 # 1 "/usr/include/mach/machine/boolean.h" 1 3 4 # 1 "/usr/include/mach/ppc/boolean.h" 1 3 4 typedef int boolean_t; # 27 "/usr/include/mach/machine/boolean.h" 2 3 4 # 127 "/usr/include/mach/boolean.h" 2 3 4 # 79 "/usr/include/sys/lock.h" 2 3 4 struct slock{ volatile unsigned int lock_data[10]; }; typedef struct slock simple_lock_data_t; typedef struct slock *simple_lock_t; struct lock__bsd__ { simple_lock_data_t lk_interlock; u_int lk_flags; int lk_sharecount; int lk_waitcount; short lk_exclusivecount; short lk_prio; char *lk_wmesg; int lk_timo; pid_t lk_lockholder; void *lk_lockthread; }; struct proc; void lockinit (struct lock__bsd__ *, int prio, char *wmesg, int timo, int flags) ; int lockmgr (struct lock__bsd__ *, u_int flags, simple_lock_t, struct proc *p) ; int lockstatus (struct lock__bsd__ *) ; # 65 "/usr/include/sys/mount.h" 2 3 4 # 1 "/usr/include/net/radix.h" 1 3 4 struct radix_node { struct radix_mask *rn_mklist; struct radix_node *rn_p; short rn_b; char rn_bmask; u_char rn_flags; union { struct { caddr_t rn_Key; caddr_t rn_Mask; struct radix_node *rn_Dupedkey; } rn_leaf; struct { int rn_Off; struct radix_node *rn_L; struct radix_node *rn_R; } rn_node; } rn_u; }; struct radix_mask { short rm_b; char rm_unused; u_char rm_flags; struct radix_mask *rm_mklist; union { caddr_t rmu_mask; struct radix_node *rmu_leaf; } rm_rmu; int rm_refs; }; typedef int walktree_f_t (struct radix_node *, void *) ; struct radix_node_head { struct radix_node *rnh_treetop; int rnh_addrsize; int rnh_pktsize; struct radix_node *(*rnh_addaddr) (void *v, void *mask, struct radix_node_head *head, struct radix_node nodes[]) ; struct radix_node *(*rnh_addpkt) (void *v, void *mask, struct radix_node_head *head, struct radix_node nodes[]) ; struct radix_node *(*rnh_deladdr) (void *v, void *mask, struct radix_node_head *head) ; struct radix_node *(*rnh_delpkt) (void *v, void *mask, struct radix_node_head *head) ; struct radix_node *(*rnh_matchaddr) (void *v, struct radix_node_head *head) ; struct radix_node *(*rnh_lookup) (void *v, void *mask, struct radix_node_head *head) ; struct radix_node *(*rnh_matchpkt) (void *v, struct radix_node_head *head) ; int (*rnh_walktree) (struct radix_node_head *head, walktree_f_t *f, void *w) ; int (*rnh_walktree_from) (struct radix_node_head *head, void *a, void *m, walktree_f_t *f, void *w) ; void (*rnh_close) (struct radix_node *rn, struct radix_node_head *head) ; struct radix_node rnh_nodes[3]; }; void rn_init (void) ; int rn_inithead (void **, int) ; int rn_refines (void *, void *) ; struct radix_node *rn_addmask (void *, int, int) , *rn_addroute (void *, void *, struct radix_node_head *, struct radix_node [2]) , *rn_delete (void *, void *, struct radix_node_head *) , *rn_lookup (void *v_arg, void *m_arg, struct radix_node_head *head) , *rn_match (void *, struct radix_node_head *) ; # 66 "/usr/include/sys/mount.h" 2 3 4 # 1 "/usr/include/sys/socket.h" 1 3 4 struct linger { int l_onoff; int l_linger; }; struct sockaddr { u_char sa_len; u_char sa_family; char sa_data[14]; }; struct sockproto { u_short sp_family; u_short sp_protocol; }; struct sockaddr_storage { u_char ss_len; u_char ss_family; char _ss_pad1[((sizeof(int64_t)) - sizeof(u_char) * 2) ]; int64_t _ss_align; char _ss_pad2[(128 - sizeof(u_char) * 2 - ((sizeof(int64_t)) - sizeof(u_char) * 2) - (sizeof(int64_t)) ) ]; }; # 295 "/usr/include/sys/socket.h" 3 4 struct msghdr { caddr_t msg_name; u_int msg_namelen; struct iovec *msg_iov; u_int msg_iovlen; caddr_t msg_control; u_int msg_controllen; int msg_flags; }; struct cmsghdr { u_int cmsg_len; int cmsg_level; int cmsg_type; }; struct osockaddr { u_short sa_family; char sa_data[14]; }; struct omsghdr { caddr_t msg_name; int msg_namelen; struct iovec *msg_iov; int msg_iovlen; caddr_t msg_accrights; int msg_accrightslen; }; # 427 "/usr/include/sys/socket.h" 3 4 extern "C" { int accept (int, struct sockaddr *, int *) ; int bind (int, const struct sockaddr *, int) ; int connect (int, const struct sockaddr *, int) ; int getpeername (int, struct sockaddr *, int *) ; int getsockname (int, struct sockaddr *, int *) ; int getsockopt (int, int, int, void *, int *) ; int listen (int, int) ; ssize_t recv (int, void *, size_t, int) ; ssize_t recvfrom (int, void *, size_t, int, struct sockaddr *, int *) ; ssize_t recvmsg (int, struct msghdr *, int) ; ssize_t send (int, const void *, size_t, int) ; ssize_t sendto (int, const void *, size_t, int, const struct sockaddr *, int) ; ssize_t sendmsg (int, const struct msghdr *, int) ; int setsockopt (int, int, int, const void *, int) ; int shutdown (int, int) ; int socket (int, int, int) ; int socketpair (int, int, int, int *) ; } # 67 "/usr/include/sys/mount.h" 2 3 4 typedef struct fsid { int32_t val[2]; } fsid_t; struct fid { u_short fid_len; u_short fid_reserved; char fid_data[16 ]; }; struct statfs { short f_otype; short f_oflags; long f_bsize; long f_iosize; long f_blocks; long f_bfree; long f_bavail; long f_files; long f_ffree; fsid_t f_fsid; uid_t f_owner; short f_reserved1; short f_type; long f_flags; long f_reserved2[2]; char f_fstypename[15 ]; char f_mntonname[90 ]; char f_mntfromname[90 ]; char f_reserved3; long f_reserved4[4]; }; struct vnodelst { struct vnode *lh_first; } ; struct mount { struct { struct mount *cqe_next; struct mount *cqe_prev; } mnt_list; struct vfsops *mnt_op; struct vfsconf *mnt_vfc; struct vnode *mnt_vnodecovered; struct vnodelst mnt_vnodelist; struct lock__bsd__ mnt_lock; int mnt_flag; int mnt_kern_flag; int mnt_maxsymlinklen; struct statfs mnt_stat; qaddr_t mnt_data; }; struct fhandle { fsid_t fh_fsid; struct fid fh_fid; }; typedef struct fhandle fhandle_t; struct export_args { int ex_flags; uid_t ex_root; struct ucred ex_anon; struct sockaddr *ex_addr; int ex_addrlen; struct sockaddr *ex_mask; int ex_masklen; }; struct vfsconf { struct vfsops *vfc_vfsops; char vfc_name[15 ]; int vfc_typenum; int vfc_refcount; int vfc_flags; int (*vfc_mountroot)(void); struct vfsconf *vfc_next; }; # 361 "/usr/include/sys/mount.h" 3 4 extern "C" { int fstatfs (int, struct statfs *) ; int getfh (const char *, fhandle_t *) ; int getfsstat (struct statfs *, long, int) ; int getmntinfo (struct statfs **, int) ; int mount (const char *, const char *, int, void *) ; int statfs (const char *, struct statfs *) ; int unmount (const char *, int) ; } # 43 "/usr/include/libc.h" 2 3 4 # 1 "/usr/include/sys/wait.h" 1 3 4 union wait { int w_status; struct { unsigned int w_Filler:16, w_Retcode:8, w_Coredump:1, w_Termsig:7; } w_T; struct { unsigned int w_Filler:16, w_Stopsig:8, w_Stopval:8; } w_S; }; extern "C" { struct rusage; pid_t wait (int *) ; pid_t waitpid (pid_t, int *, int) ; pid_t wait3 (int *, int, struct rusage *) ; pid_t wait4 (pid_t, int *, int, struct rusage *) ; } # 45 "/usr/include/libc.h" 2 3 4 # 1 "/usr/include/sys/time.h" 1 3 4 struct timeval { int32_t tv_sec; int32_t tv_usec; }; struct timespec { time_t tv_sec; int32_t tv_nsec; }; struct timezone { int tz_minuteswest; int tz_dsttime; }; # 121 "/usr/include/sys/time.h" 3 4 # 130 "/usr/include/sys/time.h" 3 4 struct itimerval { struct timeval it_interval; struct timeval it_value; }; struct clockinfo { int hz; int tick; int tickadj; int stathz; int profhz; }; extern "C" { int adjtime (const struct timeval *, struct timeval *) ; int getitimer (int, struct itimerval *) ; int gettimeofday (struct timeval *, struct timezone *) ; int setitimer (int, const struct itimerval *, struct itimerval *) ; int settimeofday (const struct timeval *, const struct timezone *) ; int utimes (const char *, const struct timeval *) ; } # 46 "/usr/include/libc.h" 2 3 4 # 1 "/usr/include/sys/times.h" 1 3 4 struct tms { clock_t tms_utime; clock_t tms_stime; clock_t tms_cutime; clock_t tms_cstime; }; extern "C" { clock_t times (struct tms *) ; } # 47 "/usr/include/libc.h" 2 3 4 # 1 "/usr/include/sys/resource.h" 1 3 4 struct rusage { struct timeval ru_utime; struct timeval ru_stime; long ru_maxrss; long ru_ixrss; long ru_idrss; long ru_isrss; long ru_minflt; long ru_majflt; long ru_nswap; long ru_inblock; long ru_oublock; long ru_msgsnd; long ru_msgrcv; long ru_nsignals; long ru_nvcsw; long ru_nivcsw; }; struct orlimit { int32_t rlim_cur; int32_t rlim_max; }; struct rlimit { rlim_t rlim_cur; rlim_t rlim_max; }; struct loadavg { fixpt_t ldavg[3]; long fscale; }; extern "C" { int getpriority (int, int) ; int getrlimit (int, struct rlimit *) ; int getrusage (int, struct rusage *) ; int setpriority (int, int, int) ; int setrlimit (int, const struct rlimit *) ; } # 48 "/usr/include/libc.h" 2 3 4 # 1 "/usr/include/sys/stat.h" 1 3 4 struct ostat { u_int16_t st_dev; ino_t st_ino; mode_t st_mode; nlink_t st_nlink; u_int16_t st_uid; u_int16_t st_gid; u_int16_t st_rdev; int32_t st_size; struct timespec st_atimespec; struct timespec st_mtimespec; struct timespec st_ctimespec; int32_t st_blksize; int32_t st_blocks; u_int32_t st_flags; u_int32_t st_gen; }; struct stat { dev_t st_dev; ino_t st_ino; mode_t st_mode; nlink_t st_nlink; uid_t st_uid; gid_t st_gid; dev_t st_rdev; struct timespec st_atimespec; struct timespec st_mtimespec; struct timespec st_ctimespec; off_t st_size; int64_t st_blocks; u_int32_t st_blksize; u_int32_t st_flags; u_int32_t st_gen; int32_t st_lspare; int64_t st_qspare[2]; }; extern "C" { int chmod (const char *, mode_t) ; int fstat (int, struct stat *) ; int mkdir (const char *, mode_t) ; int mkfifo (const char *, mode_t) ; int stat (const char *, struct stat *) ; mode_t umask (mode_t) ; int chflags (const char *, u_long) ; int fchflags (int, u_long) ; int fchmod (int, mode_t) ; int lstat (const char *, struct stat *) ; } # 52 "/usr/include/libc.h" 2 3 4 # 1 "/usr/include/sys/file.h" 1 3 4 # 1 "/usr/include/sys/fcntl.h" 1 3 4 # 131 "/usr/include/sys/fcntl.h" 3 4 struct flock { off_t l_start; off_t l_len; pid_t l_pid; short l_type; short l_whence; }; struct radvisory { off_t ra_offset; int ra_count; }; typedef struct fstore { u_int32_t fst_flags; int fst_posmode; off_t fst_offset; off_t fst_length; off_t fst_bytesalloc; } fstore_t; typedef struct fbootstraptransfer { off_t fbt_offset; size_t fbt_length; void *fbt_buffer; } fbootstraptransfer_t; struct log2phys { u_int32_t l2p_flags; off_t l2p_contigbytes; off_t l2p_devoffset; }; extern "C" { int open (const char *, int, ...) ; int creat (const char *, mode_t) ; int fcntl (int, int, ...) ; int flock (int, int) ; } # 61 "/usr/include/sys/file.h" 2 3 4 # 112 "/usr/include/sys/file.h" 3 4 # 53 "/usr/include/libc.h" 2 3 4 # 1 "/usr/include/sys/ioctl.h" 1 3 4 # 1 "/usr/include/sys/ttycom.h" 1 3 4 # 1 "/usr/include/sys/ioccom.h" 1 3 4 # 66 "/usr/include/sys/ttycom.h" 2 3 4 struct winsize { unsigned short ws_row; unsigned short ws_col; unsigned short ws_xpixel; unsigned short ws_ypixel; }; # 66 "/usr/include/sys/ioctl.h" 2 3 4 struct ttysize { unsigned short ts_lines; unsigned short ts_cols; unsigned short ts_xxx; unsigned short ts_yyy; }; # 1 "/usr/include/sys/filio.h" 1 3 4 # 84 "/usr/include/sys/ioctl.h" 2 3 4 # 1 "/usr/include/sys/sockio.h" 1 3 4 # 85 "/usr/include/sys/ioctl.h" 2 3 4 extern "C" { int ioctl (int, unsigned long, ...) ; } # 55 "/usr/include/libc.h" 2 3 4 # 1 "/usr/include/netinet/in.h" 1 3 4 struct in_addr { u_int32_t s_addr; }; struct sockaddr_in { u_char sin_len; u_char sin_family; u_short sin_port; struct in_addr sin_addr; char sin_zero[8]; }; struct ip_opts { struct in_addr ip_dst; char ip_opts[40]; }; struct ip_mreq { struct in_addr imr_multiaddr; struct in_addr imr_interface; }; # 456 "/usr/include/netinet/in.h" 3 4 # 499 "/usr/include/netinet/in.h" 3 4 # 1 "/usr/include/netinet6/in6.h" 1 3 4 struct in6_addr { union { u_int8_t __u6_addr8[16]; u_int16_t __u6_addr16[8]; u_int32_t __u6_addr32[4]; } __u6_addr; }; struct sockaddr_in6 { u_int8_t sin6_len; u_int8_t sin6_family; u_int16_t sin6_port; u_int32_t sin6_flowinfo; struct in6_addr sin6_addr; u_int32_t sin6_scope_id; }; # 166 "/usr/include/netinet6/in6.h" 3 4 # 199 "/usr/include/netinet6/in6.h" 3 4 # 335 "/usr/include/netinet6/in6.h" 3 4 struct route_in6 { struct rtentry *ro_rt; struct sockaddr_in6 ro_dst; }; struct ipv6_mreq { struct in6_addr ipv6mr_multiaddr; u_int ipv6mr_interface; }; struct in6_pktinfo { struct in6_addr ipi6_addr; u_int ipi6_ifindex; }; # 530 "/usr/include/netinet6/in6.h" 3 4 # 611 "/usr/include/netinet6/in6.h" 3 4 # 640 "/usr/include/netinet6/in6.h" 3 4 # 666 "/usr/include/netinet6/in6.h" 3 4 extern "C" { struct cmsghdr; extern int inet6_option_space (int) ; extern int inet6_option_init (void *, struct cmsghdr **, int) ; extern int inet6_option_append (struct cmsghdr *, const u_int8_t *, int, int) ; extern u_int8_t *inet6_option_alloc (struct cmsghdr *, int, int, int) ; extern int inet6_option_next (const struct cmsghdr *, u_int8_t **) ; extern int inet6_option_find (const struct cmsghdr *, u_int8_t **, int) ; extern size_t inet6_rthdr_space (int, int) ; extern struct cmsghdr *inet6_rthdr_init (void *, int) ; extern int inet6_rthdr_add (struct cmsghdr *, const struct in6_addr *, unsigned int) ; extern int inet6_rthdr_lasthop (struct cmsghdr *, unsigned int) ; extern int inet6_rthdr_segments (const struct cmsghdr *) ; extern struct in6_addr *inet6_rthdr_getaddr (struct cmsghdr *, int) ; extern int inet6_rthdr_getflags (const struct cmsghdr *, int) ; extern int inet6_opt_init (void *, size_t) ; extern int inet6_opt_append (void *, size_t, int, u_int8_t, size_t, u_int8_t, void **) ; extern int inet6_opt_finish (void *, size_t, int) ; extern int inet6_opt_set_val (void *, size_t, void *, int) ; extern int inet6_opt_next (void *, size_t, int, u_int8_t *, size_t *, void **) ; extern int inet6_opt_find (void *, size_t, int, u_int8_t, size_t *, void **) ; extern int inet6_opt_get_val (void *, size_t, void *, int) ; extern size_t inet6_rth_space (int, int) ; extern void *inet6_rth_init (void *, int, int, int) ; extern int inet6_rth_add (void *, const struct in6_addr *) ; extern int inet6_rth_reverse (const void *, void *) ; extern int inet6_rth_segments (const void *) ; extern struct in6_addr *inet6_rth_getaddr (const void *, int) ; } # 502 "/usr/include/netinet/in.h" 2 3 4 # 514 "/usr/include/netinet/in.h" 3 4 # 56 "/usr/include/libc.h" 2 3 4 # 1 "/usr/include/arpa/inet.h" 1 3 4 extern "C" { unsigned long inet_addr (const char *) ; int inet_aton (const char *, struct in_addr *) ; unsigned long inet_lnaof (struct in_addr) ; struct in_addr inet_makeaddr (u_long , u_long) ; unsigned long inet_netof (struct in_addr) ; unsigned long inet_network (const char *) ; char *inet_ntoa (struct in_addr) ; } # 57 "/usr/include/libc.h" 2 3 4 # 1 "/usr/include/mach/machine/vm_types.h" 1 3 4 # 1 "/usr/include/mach/ppc/vm_types.h" 1 3 4 typedef unsigned int natural_t; typedef int integer_t; typedef natural_t vm_offset_t; typedef natural_t vm_size_t; typedef unsigned long long vm_double_size_t; typedef unsigned int space_t; # 27 "/usr/include/mach/machine/vm_types.h" 2 3 4 # 58 "/usr/include/libc.h" 2 3 4 # 1 "/usr/include/mach/kern_return.h" 1 3 4 # 1 "/usr/include/mach/machine/kern_return.h" 1 3 4 # 1 "/usr/include/mach/ppc/kern_return.h" 1 3 4 typedef int kern_return_t; # 27 "/usr/include/mach/machine/kern_return.h" 2 3 4 # 64 "/usr/include/mach/kern_return.h" 2 3 4 # 60 "/usr/include/libc.h" 2 3 4 struct qelem { struct qelem *q_forw; struct qelem *q_back; char *q_data; }; extern kern_return_t map_fd(int fd, vm_offset_t offset, vm_offset_t *addr, boolean_t find_space, vm_size_t numbytes); # 12 "QvBasic.h" 2 typedef int QvBool; # 4 "QvElement.h" 2 class QvNode; class QvElement { public: enum NodeType { Unknown, OrthographicCamera, PerspectiveCamera, DirectionalLight, PointLight, SpotLight, NoOpTransform, MatrixTransform, Rotation, Scale, Transform, Translation, NumNodeTypes, }; static const char *nodeTypeNames[NumNodeTypes]; int depth; QvElement *next; QvNode *data; NodeType type; QvElement(); virtual ~QvElement(); virtual void print(); }; # 1 "QvTraverse.cpp" 2 # 1 "QvNodes.h" 1 # 1 "QvCone.h" 1 # 1 "QvSFBitMask.h" 1 # 1 "QvSFEnum.h" 1 # 1 "QvString.h" 1 class QvString { public: QvString() { string = staticStorage; string[0] = '\0'; } QvString(const char *str) { string = staticStorage; *this = str; } QvString(const QvString &str) { string = staticStorage; *this = str.string; } ~QvString(); u_long hash() { return QvString::hash(string); } int getLength() const { return strlen(string); } void makeEmpty(QvBool freeOld = 1 ); const char * getString() const { return string; } QvString & operator =(const char *str); QvString & operator =(const QvString &str) { return (*this = str.string); } QvString & operator +=(const char *str); int operator !() const { return (string[0] == '\0'); } friend int operator ==(const QvString &str, const char *s); friend int operator ==(const char *s, const QvString &str) { return (str == s); } friend int operator ==(const QvString &str1, const QvString &str2) { return (str1 == str2.string); } friend int operator !=(const QvString &str, const char *s); friend int operator !=(const char *s, const QvString &str) { return (str != s); } friend int operator !=(const QvString &str1, const QvString &str2) { return (str1 != str2.string); } static u_long hash(const char *s); private: char *string; int storageSize; char staticStorage[32 ]; void expand(int bySize); }; class QvNameEntry { public: QvBool isEmpty() const { return (string[0] == '\0'); } QvBool isEqual(const char *s) const { return (string[0] == s[0] && ! strcmp(string, s)); } private: static int nameTableSize; static QvNameEntry **nameTable; static struct QvNameChunk *chunk; const char *string; u_long hashValue; QvNameEntry *next; static void initClass(); QvNameEntry(const char *s, u_long h, QvNameEntry *n) { string = s; hashValue = h; next = n; } static const QvNameEntry * insert(const char *s); friend class QvName; }; class QvName { public: QvName(); QvName(const char *s) { entry = QvNameEntry::insert(s); } QvName(const QvString &s) { entry = QvNameEntry::insert(s.getString()); } QvName(const QvName &n) { entry = n.entry; } ~QvName() {} const char *getString() const { return entry->string; } int getLength() const { return strlen(entry->string); } static QvBool isIdentStartChar(char c); static QvBool isIdentChar(char c); static QvBool isNodeNameStartChar(char c); static QvBool isNodeNameChar(char c); int operator !() const { return entry->isEmpty(); } friend int operator ==(const QvName &n, const char *s) { return n.entry->isEqual(s); } friend int operator ==(const char *s, const QvName &n) { return n.entry->isEqual(s); } friend int operator ==(const QvName &n1, const QvName &n2) { return n1.entry == n2.entry; } friend int operator !=(const QvName &n, const char *s) { return ! n.entry->isEqual(s); } friend int operator !=(const char *s, const QvName &n) { return ! n.entry->isEqual(s); } friend int operator !=(const QvName &n1, const QvName &n2) { return n1.entry != n2.entry; } private: const QvNameEntry *entry; }; # 4 "QvSFEnum.h" 2 # 1 "QvSubField.h" 1 # 1 "QvField.h" 1 class QvInput; class QvNode; class QvField { public: virtual ~QvField(); void setIgnored(QvBool ig) { flags.ignored = ig; } QvBool isIgnored() const { return flags.ignored; } QvBool isDefault() const { return flags.hasDefault; } QvNode * getContainer() const { return container; } void setDefault(QvBool def) { flags.hasDefault = def; } void setContainer(QvNode *cont); QvBool read(QvInput *in, const QvName &name); QvField() { flags.hasDefault = 1 ; flags.ignored = 0 ; } public: private: struct { unsigned int hasDefault : 1; unsigned int ignored : 1; } flags; QvNode *container; static QvField * createInstanceFromName(const QvName &className); virtual QvBool readValue(QvInput *in) = 0; friend class QvFieldData; }; class QvSField : public QvField { public: virtual ~QvSField(); protected: QvSField(); private: virtual QvBool readValue(QvInput *in) = 0; }; class QvMField : public QvField { public: int num; int maxNum; virtual ~QvMField(); protected: QvMField(); virtual void makeRoom(int newNum); private: virtual void allocValues(int num) = 0; virtual QvBool readValue(QvInput *in); virtual QvBool read1Value(QvInput *in, int index) = 0; }; # 4 "QvSubField.h" 2 # 1 "QvInput.h" 1 # 1 "QvDict.h" 1 # 1 "QvPList.h" 1 class QvPList { public: QvPList(); ~QvPList(); void append(void * ptr) { if (nPtrs + 1 > ptrsSize) expand(nPtrs + 1); ptrs[nPtrs++] = ptr; } int find(const void *ptr) const; void remove(int which); int getLength() const { return (int) nPtrs; } void truncate(int start) { nPtrs = start; } void *& operator [](int i) const { return ptrs[i]; } private: void ** ptrs; int nPtrs; int ptrsSize; void setSize(int size) { if (size > ptrsSize) expand(size); nPtrs = size; } void expand(int size); }; # 6 "QvDict.h" 2 class QvDictEntry { private: u_long key; void * value; QvDictEntry * next; QvDictEntry(u_long k, void *v) { key = k; value = v; }; friend class QvDict; }; class QvDict { public: QvDict( int entries = 251 ); ~QvDict(); void clear(); QvBool enter(u_long key, void *value); QvBool find(u_long key, void *&value) const; QvBool remove(u_long key); private: int tableSize; QvDictEntry * *buckets; QvDictEntry *& findEntry(u_long key) const; }; # 4 "QvInput.h" 2 class QvNode; class QvDB; class QvInput { public: QvInput(); ~QvInput(); static float isASCIIHeader(const char *string); void setFilePointer(FILE *newFP); FILE * getCurFile() const { return fp; } float getVersion(); QvBool get(char &c); QvBool read(char &c); QvBool read(QvString &s); QvBool read(QvName &n, QvBool validIdent = 0 ); QvBool read(int &i); QvBool read(unsigned int &i); QvBool read(short &s); QvBool read(unsigned short &s); QvBool read(long &l); QvBool read(unsigned long &l); QvBool read(float &f); QvBool read(double &d); QvBool eof() const; void getLocationString(QvString &string) const; void putBack(char c); void putBack(const char *string); void addReference(const QvName &name, QvNode *node); QvNode * findReference(const QvName &name) const; private: FILE *fp; int lineNum; float version; QvBool readHeader; QvBool headerOk; QvDict refDict; QvString backBuf; int backBufIndex; QvBool checkHeader(); QvBool skipWhiteSpace(); QvBool readInteger(long &l); QvBool readUnsignedInteger(unsigned long &l); QvBool readReal(double &d); QvBool readUnsignedIntegerString(char *str); int readDigits(char *string); int readHexDigits(char *string); int readChar(char *string, char charToRead); friend class QvNode; friend class QvDB; }; # 5 "QvSubField.h" 2 # 71 "QvSubField.h" # 5 "QvSFEnum.h" 2 class QvSFEnum : public QvSField { public: int value; public: QvSFEnum (); virtual ~ QvSFEnum (); virtual QvBool readValue(QvInput *in) ; void setEnums(int num, const int vals[], const QvName names[]) { numEnums = num; enumValues = vals; enumNames = names; } int numEnums; const int *enumValues; const QvName *enumNames; QvBool findEnumValue(const QvName &name, int &val) const; }; # 37 "QvSFEnum.h" # 4 "QvSFBitMask.h" 2 class QvSFBitMask : public QvSFEnum { public: public: QvSFBitMask (); virtual ~ QvSFBitMask (); virtual QvBool readValue(QvInput *in) ; }; # 4 "QvCone.h" 2 # 1 "QvSFFloat.h" 1 class QvSFFloat : public QvSField { public: float value; public: QvSFFloat (); virtual ~ QvSFFloat (); virtual QvBool readValue(QvInput *in) ; }; # 5 "QvCone.h" 2 # 1 "QvSubNode.h" 1 # 1 "QvFieldData.h" 1 class QvField; class QvInput; class QvNode; class QvFieldData { public: QvFieldData() {} ~QvFieldData(); void addField(QvNode *defObject, const char *fieldName, const QvField *field); int getNumFields() const { return fields.getLength(); } const QvName & getFieldName(int index) const; QvField * getField(const QvNode *object, int index) const; void addEnumValue(const char *typeName, const char *valName, int val); void getEnumData(const char *typeName, int &num, const int *&vals, const QvName *&names); QvBool read(QvInput *in, QvNode *object, QvBool errorOnUnknownField = 1 ) const; QvBool read(QvInput *in, QvNode *object, const QvName &fieldName, QvBool &foundName) const; QvBool readFieldTypes(QvInput *in, QvNode *object); private: QvPList fields; QvPList enums; }; # 4 "QvSubNode.h" 2 # 1 "QvNode.h" 1 class QvChildList; class QvDict; class QvFieldData; class QvInput; class QvNodeList; class QvState; class QvNode { public: enum Stage { FIRST_INSTANCE, PROTO_INSTANCE, OTHER_INSTANCE, }; QvFieldData *fieldData; QvChildList *children; QvBool isBuiltIn; QvName *objName; QvNode(); virtual ~QvNode(); const QvName & getName() const; void setName(const QvName &name); static void init(); static QvBool read(QvInput *in, QvNode *&node); virtual QvFieldData *getFieldData() = 0; virtual void traverse(QvState *state) = 0; protected: virtual QvBool readInstance(QvInput *in); private: static QvDict *nameDict; static void addName(QvNode *, const char *); static void removeName(QvNode *, const char *); static QvNode * readReference(QvInput *in); static QvBool readNode(QvInput *in, QvName &className,QvNode *&node); static QvBool readNodeInstance(QvInput *in, const QvName &className, const QvName &refName, QvNode *&node); static QvNode * createInstance(QvInput *in, const QvName &className); static QvNode * createInstanceFromName(const QvName &className); static void flushInput(QvInput *in); }; # 5 "QvSubNode.h" 2 # 16 "QvSubNode.h" # 6 "QvCone.h" 2 class QvCone : public QvNode { public: QvCone :: QvCone (); virtual ~ QvCone (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; public: enum Part { SIDES = 0x01, BOTTOM = 0x02, ALL = 0x03 }; QvSFBitMask parts; QvSFFloat bottomRadius; QvSFFloat height; }; # 4 "QvNodes.h" 2 # 1 "QvCoordinate3.h" 1 # 1 "QvMFVec3f.h" 1 class QvMFVec3f : public QvMField { public: float *values; public: QvMFVec3f (); virtual ~ QvMFVec3f (); virtual QvBool read1Value(QvInput *in, int index); void allocValues(int newNum) ; }; # 4 "QvCoordinate3.h" 2 class QvCoordinate3 : public QvNode { public: QvCoordinate3 :: QvCoordinate3 (); virtual ~ QvCoordinate3 (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; public: QvMFVec3f point; }; # 5 "QvNodes.h" 2 # 1 "QvCube.h" 1 class QvCube : public QvNode { public: QvCube :: QvCube (); virtual ~ QvCube (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; public: QvSFFloat width; QvSFFloat height; QvSFFloat depth; }; # 6 "QvNodes.h" 2 # 1 "QvCylinder.h" 1 class QvCylinder : public QvNode { public: QvCylinder :: QvCylinder (); virtual ~ QvCylinder (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; public: enum Part { SIDES = 0x01, TOP = 0x02, BOTTOM = 0x04, ALL = 0x07, }; QvSFBitMask parts; QvSFFloat radius; QvSFFloat height; }; # 7 "QvNodes.h" 2 # 1 "QvDirectionalLight.h" 1 # 1 "QvSFBool.h" 1 class QvSFBool : public QvSField { public: QvBool value; public: QvSFBool (); virtual ~ QvSFBool (); virtual QvBool readValue(QvInput *in) ; }; # 4 "QvDirectionalLight.h" 2 # 1 "QvSFColor.h" 1 class QvSFColor : public QvSField { public: float value[3]; public: QvSFColor (); virtual ~ QvSFColor (); virtual QvBool readValue(QvInput *in) ; }; # 5 "QvDirectionalLight.h" 2 # 1 "QvSFVec3f.h" 1 class QvSFVec3f : public QvSField { public: float value[3]; public: QvSFVec3f (); virtual ~ QvSFVec3f (); virtual QvBool readValue(QvInput *in) ; }; # 7 "QvDirectionalLight.h" 2 class QvDirectionalLight : public QvNode { public: QvDirectionalLight :: QvDirectionalLight (); virtual ~ QvDirectionalLight (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; public: QvSFBool on; QvSFFloat intensity; QvSFColor color; QvSFVec3f direction; }; # 8 "QvNodes.h" 2 # 1 "QvGroup.h" 1 class QvChildList; class QvGroup : public QvNode { public: QvGroup :: QvGroup (); virtual ~ QvGroup (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; public: QvNode * getChild(int index) const; int getNumChildren() const; virtual QvChildList *getChildren() const; virtual QvBool readInstance(QvInput *in); virtual QvBool readChildren(QvInput *in); }; # 9 "QvNodes.h" 2 # 1 "QvIndexedFaceSet.h" 1 # 1 "QvMFLong.h" 1 class QvMFLong : public QvMField { public: long *values; public: QvMFLong (); virtual ~ QvMFLong (); virtual QvBool read1Value(QvInput *in, int index); void allocValues(int newNum) ; }; # 4 "QvIndexedFaceSet.h" 2 class QvIndexedFaceSet : public QvNode { public: QvIndexedFaceSet :: QvIndexedFaceSet (); virtual ~ QvIndexedFaceSet (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; public: QvMFLong coordIndex; QvMFLong materialIndex; QvMFLong normalIndex; QvMFLong textureCoordIndex; }; # 10 "QvNodes.h" 2 # 1 "QvIndexedLineSet.h" 1 class QvIndexedLineSet : public QvNode { public: QvIndexedLineSet :: QvIndexedLineSet (); virtual ~ QvIndexedLineSet (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; public: QvMFLong coordIndex; QvMFLong materialIndex; QvMFLong normalIndex; QvMFLong textureCoordIndex; }; # 11 "QvNodes.h" 2 # 1 "QvInfo.h" 1 # 1 "QvSFString.h" 1 class QvSFString : public QvSField { public: QvString value; public: QvSFString (); virtual ~ QvSFString (); virtual QvBool readValue(QvInput *in) ; }; # 4 "QvInfo.h" 2 class QvInfo : public QvNode { public: QvInfo :: QvInfo (); virtual ~ QvInfo (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; public: QvSFString string; }; # 12 "QvNodes.h" 2 # 1 "QvLevelOfDetail.h" 1 # 1 "QvMFFloat.h" 1 class QvMFFloat : public QvMField { public: float *values; public: QvMFFloat (); virtual ~ QvMFFloat (); virtual QvBool read1Value(QvInput *in, int index); void allocValues(int newNum) ; }; # 4 "QvLevelOfDetail.h" 2 class QvLevelOfDetail : public QvGroup { public: QvLevelOfDetail :: QvLevelOfDetail (); virtual ~ QvLevelOfDetail (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; public: QvMFFloat screenArea; }; # 13 "QvNodes.h" 2 # 1 "QvMaterial.h" 1 # 1 "QvMFColor.h" 1 class QvMFColor : public QvMField { public: float *values; public: QvMFColor (); virtual ~ QvMFColor (); virtual QvBool read1Value(QvInput *in, int index); void allocValues(int newNum) ; }; # 4 "QvMaterial.h" 2 class QvMaterial : public QvNode { public: QvMaterial :: QvMaterial (); virtual ~ QvMaterial (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; public: QvMFColor ambientColor; QvMFColor diffuseColor; QvMFColor specularColor; QvMFColor emissiveColor; QvMFFloat shininess; QvMFFloat transparency; }; # 14 "QvNodes.h" 2 # 1 "QvMaterialBinding.h" 1 class QvMaterialBinding : public QvNode { public: QvMaterialBinding :: QvMaterialBinding (); virtual ~ QvMaterialBinding (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; public: enum Binding { DEFAULT, NONE, OVERALL, PER_PART, PER_PART_INDEXED, PER_FACE, PER_FACE_INDEXED, PER_VERTEX, PER_VERTEX_INDEXED, }; QvSFEnum value; }; # 15 "QvNodes.h" 2 # 1 "QvMatrixTransform.h" 1 # 1 "QvSFMatrix.h" 1 class QvSFMatrix : public QvSField { public: float value[4][4]; public: QvSFMatrix (); virtual ~ QvSFMatrix (); virtual QvBool readValue(QvInput *in) ; }; # 4 "QvMatrixTransform.h" 2 class QvMatrixTransform : public QvNode { public: QvMatrixTransform :: QvMatrixTransform (); virtual ~ QvMatrixTransform (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; public: QvSFMatrix matrix; }; # 16 "QvNodes.h" 2 # 1 "QvNormal.h" 1 class QvNormal : public QvNode { public: QvNormal :: QvNormal (); virtual ~ QvNormal (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; public: QvMFVec3f vector; }; # 17 "QvNodes.h" 2 # 1 "QvNormalBinding.h" 1 class QvNormalBinding : public QvNode { public: QvNormalBinding :: QvNormalBinding (); virtual ~ QvNormalBinding (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; public: enum Binding { DEFAULT, NONE, OVERALL, PER_PART, PER_PART_INDEXED, PER_FACE, PER_FACE_INDEXED, PER_VERTEX, PER_VERTEX_INDEXED, }; QvSFEnum value; }; # 18 "QvNodes.h" 2 # 1 "QvOrthographicCamera.h" 1 # 1 "QvSFRotation.h" 1 class QvSFRotation : public QvSField { public: float axis[3]; float angle; public: QvSFRotation (); virtual ~ QvSFRotation (); virtual QvBool readValue(QvInput *in) ; }; # 5 "QvOrthographicCamera.h" 2 class QvOrthographicCamera : public QvNode { public: QvOrthographicCamera :: QvOrthographicCamera (); virtual ~ QvOrthographicCamera (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; public: QvSFVec3f position; QvSFRotation orientation; QvSFFloat focalDistance; QvSFFloat height; }; # 19 "QvNodes.h" 2 # 1 "QvPerspectiveCamera.h" 1 class QvPerspectiveCamera : public QvNode { public: QvPerspectiveCamera :: QvPerspectiveCamera (); virtual ~ QvPerspectiveCamera (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; public: QvSFVec3f position; QvSFRotation orientation; QvSFFloat focalDistance; QvSFFloat heightAngle; }; # 20 "QvNodes.h" 2 # 1 "QvPointLight.h" 1 class QvPointLight : public QvNode { public: QvPointLight :: QvPointLight (); virtual ~ QvPointLight (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; public: QvSFBool on; QvSFFloat intensity; QvSFColor color; QvSFVec3f location; }; # 21 "QvNodes.h" 2 # 1 "QvPointSet.h" 1 # 1 "QvSFLong.h" 1 class QvSFLong : public QvSField { public: long value; public: QvSFLong (); virtual ~ QvSFLong (); virtual QvBool readValue(QvInput *in) ; }; # 4 "QvPointSet.h" 2 class QvPointSet : public QvNode { public: QvPointSet :: QvPointSet (); virtual ~ QvPointSet (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; public: QvSFLong startIndex; QvSFLong numPoints; }; # 22 "QvNodes.h" 2 # 1 "QvRotation.h" 1 class QvRotation : public QvNode { public: QvRotation :: QvRotation (); virtual ~ QvRotation (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; public: QvSFRotation rotation; }; # 23 "QvNodes.h" 2 # 1 "QvScale.h" 1 class QvScale : public QvNode { public: QvScale :: QvScale (); virtual ~ QvScale (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; public: QvSFVec3f scaleFactor; }; # 24 "QvNodes.h" 2 # 1 "QvSeparator.h" 1 class QvSeparator : public QvGroup { public: QvSeparator :: QvSeparator (); virtual ~ QvSeparator (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; public: enum CullEnabled { OFF, ON, AUTO, }; QvSFEnum renderCulling; }; # 25 "QvNodes.h" 2 # 1 "QvShapeHints.h" 1 class QvShapeHints : public QvNode { public: QvShapeHints :: QvShapeHints (); virtual ~ QvShapeHints (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; public: enum VertexOrdering { UNKNOWN_ORDERING, CLOCKWISE, COUNTERCLOCKWISE, }; enum ShapeType { UNKNOWN_SHAPE_TYPE, SOLID, }; enum FaceType { UNKNOWN_FACE_TYPE, CONVEX, }; QvSFEnum vertexOrdering; QvSFEnum shapeType; QvSFEnum faceType; QvSFFloat creaseAngle; }; # 26 "QvNodes.h" 2 # 1 "QvSphere.h" 1 class QvSphere : public QvNode { public: QvSphere :: QvSphere (); virtual ~ QvSphere (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; public: QvSFFloat radius; }; # 27 "QvNodes.h" 2 # 1 "QvSpotLight.h" 1 class QvSpotLight : public QvNode { public: QvSpotLight :: QvSpotLight (); virtual ~ QvSpotLight (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; public: QvSFBool on; QvSFFloat intensity; QvSFColor color; QvSFVec3f location; QvSFVec3f direction; QvSFFloat dropOffRate; QvSFFloat cutOffAngle; }; # 28 "QvNodes.h" 2 # 1 "QvSwitch.h" 1 class QvSwitch : public QvGroup { public: QvSwitch :: QvSwitch (); virtual ~ QvSwitch (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; public: QvSFLong whichChild; }; # 29 "QvNodes.h" 2 # 1 "QvTexture2.h" 1 # 1 "QvSFImage.h" 1 class QvSFImage : public QvSField { public: short size[2]; int numComponents; unsigned char * bytes; public: QvSFImage (); virtual ~ QvSFImage (); virtual QvBool readValue(QvInput *in) ; }; # 5 "QvTexture2.h" 2 class QvTexture2 : public QvNode { public: QvTexture2 :: QvTexture2 (); virtual ~ QvTexture2 (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; public: enum Wrap { REPEAT, CLAMP, }; QvSFString filename; QvSFImage image; QvSFEnum wrapS; QvSFEnum wrapT; virtual QvBool readInstance(QvInput *in); QvBool readImage(); }; # 30 "QvNodes.h" 2 # 1 "QvTexture2Transform.h" 1 # 1 "QvSFVec2f.h" 1 class QvSFVec2f : public QvSField { public: float value[2]; public: QvSFVec2f (); virtual ~ QvSFVec2f (); virtual QvBool readValue(QvInput *in) ; }; # 5 "QvTexture2Transform.h" 2 class QvTexture2Transform : public QvNode { public: QvTexture2Transform :: QvTexture2Transform (); virtual ~ QvTexture2Transform (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; public: QvSFVec2f translation; QvSFFloat rotation; QvSFVec2f scaleFactor; QvSFVec2f center; }; # 31 "QvNodes.h" 2 # 1 "QvTextureCoordinate2.h" 1 # 1 "QvMFVec2f.h" 1 class QvMFVec2f : public QvMField { public: float *values; public: QvMFVec2f (); virtual ~ QvMFVec2f (); virtual QvBool read1Value(QvInput *in, int index); void allocValues(int newNum) ; }; # 4 "QvTextureCoordinate2.h" 2 class QvTextureCoordinate2 : public QvNode { public: QvTextureCoordinate2 :: QvTextureCoordinate2 (); virtual ~ QvTextureCoordinate2 (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; public: QvMFVec2f point; }; # 32 "QvNodes.h" 2 # 1 "QvTransform.h" 1 class QvTransform : public QvNode { public: QvTransform :: QvTransform (); virtual ~ QvTransform (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; public: QvSFVec3f translation; QvSFRotation rotation; QvSFVec3f scaleFactor; QvSFRotation scaleOrientation; QvSFVec3f center; }; # 33 "QvNodes.h" 2 # 1 "QvTransformSeparator.h" 1 class QvTransformSeparator : public QvGroup { public: QvTransformSeparator :: QvTransformSeparator (); virtual ~ QvTransformSeparator (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; }; # 34 "QvNodes.h" 2 # 1 "QvTranslation.h" 1 class QvTranslation : public QvNode { public: QvTranslation :: QvTranslation (); virtual ~ QvTranslation (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; public: QvSFVec3f translation; }; # 35 "QvNodes.h" 2 # 1 "QvWWWAnchor.h" 1 class QvWWWAnchor : public QvGroup { public: QvWWWAnchor :: QvWWWAnchor (); virtual ~ QvWWWAnchor (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; public: enum Map { NONE, POINT, }; QvSFString name; QvSFEnum map; }; # 36 "QvNodes.h" 2 # 1 "QvWWWInline.h" 1 class QvWWWInline : public QvGroup { public: QvWWWInline :: QvWWWInline (); virtual ~ QvWWWInline (); virtual void traverse(QvState *state); private: static QvBool firstInstance; static QvFieldData *fieldData; virtual QvFieldData *getFieldData() { return fieldData; } ; public: QvSFString name; QvSFVec3f bboxSize; QvSFVec3f bboxCenter; }; # 37 "QvNodes.h" 2 # 2 "QvTraverse.cpp" 2 # 1 "QvState.h" 1 # 1 "../BspLib/VrmlFile.h" 1 # 1 "../BspLib/BspLibDefs.h" 1 # 1 "/usr/include/ctype.h" 1 3 4 # 1 "/usr/include/runetype.h" 1 3 4 typedef struct { rune_t min; rune_t max; rune_t map; unsigned long *types; } _RuneEntry; typedef struct { int nranges; _RuneEntry *ranges; } _RuneRange; typedef struct { char magic[8]; char encoding[32]; rune_t (*sgetrune) (const char *, unsigned int, char const **) ; int (*sputrune) (rune_t, char *, unsigned int, char **) ; rune_t invalid_rune; unsigned long runetype[(1 <<8 ) ]; rune_t maplower[(1 <<8 ) ]; rune_t mapupper[(1 <<8 ) ]; _RuneRange runetype_ext; _RuneRange maplower_ext; _RuneRange mapupper_ext; void *variable; int variable_len; } _RuneLocale; extern _RuneLocale _DefaultRuneLocale; extern _RuneLocale *_CurrentRuneLocale; # 68 "/usr/include/ctype.h" 2 3 4 extern "C" { unsigned long ___runetype (__wchar_t ) ; __wchar_t ___tolower (__wchar_t ) ; __wchar_t ___toupper (__wchar_t ) ; } static inline int __istype(__wchar_t c, unsigned long f) { return((((c & (~((1 <<8 ) - 1)) ) ? ___runetype(c) : _CurrentRuneLocale->runetype[c]) & f) ? 1 : 0); } static inline int __isctype(__wchar_t c, unsigned long f) { return((((c & (~((1 <<8 ) - 1)) ) ? 0 : _DefaultRuneLocale.runetype[c]) & f) ? 1 : 0); } static inline __wchar_t toupper(__wchar_t c) { return((c & (~((1 <<8 ) - 1)) ) ? ___toupper(c) : _CurrentRuneLocale->mapupper[c]); } static inline __wchar_t tolower(__wchar_t c) { return((c & (~((1 <<8 ) - 1)) ) ? ___tolower(c) : _CurrentRuneLocale->maplower[c]); } # 166 "/usr/include/ctype.h" 3 4 # 13 "../BspLib/BspLibDefs.h" 2 # 1 "/usr/include/errno.h" 1 3 4 # 1 "/usr/include/sys/errno.h" 1 3 4 extern "C" { extern int * __error (void) ; } # 22 "/usr/include/errno.h" 2 3 4 # 14 "../BspLib/BspLibDefs.h" 2 # 1 "/usr/include/limits.h" 1 3 4 # 1 "/usr/include/gcc/darwin/2.95.2/g++/../machine/limits.h" 1 3 # 10 "/usr/include/gcc/darwin/2.95.2/g++/../machine/limits.h" 3 # 108 "/usr/include/gcc/darwin/2.95.2/g++/../machine/limits.h" 3 # 62 "/usr/include/limits.h" 2 3 4 # 15 "../BspLib/BspLibDefs.h" 2 # 1 "/usr/include/math.h" 1 3 4 extern int signgam; enum fdversion {fdlibm_ieee = -1, fdlibm_svid, fdlibm_xopen, fdlibm_posix}; extern enum fdversion _fdlib_version ; # 91 "/usr/include/math.h" 3 4 extern "C" { extern double acos (double) ; extern double asin (double) ; extern double atan (double) ; extern double atan2 (double, double) ; extern double cos (double) ; extern double sin (double) ; extern double tan (double) ; extern double cosh (double) ; extern double sinh (double) ; extern double tanh (double) ; extern double exp (double) ; extern double frexp (double, int *) ; extern double ldexp (double, int) ; extern double log (double) ; extern double log10 (double) ; extern double modf (double, double *) ; extern double pow (double, double) ; extern double sqrt (double) ; extern double ceil (double) ; extern double fabs (double) ; extern double floor (double) ; extern double fmod (double, double) ; extern double erf (double) ; extern double erfc (double) ; extern double gamma (double) ; extern double hypot (double, double) ; extern int isinf (double) ; extern int isnan (double) ; extern int finite (double) ; extern double j0 (double) ; extern double j1 (double) ; extern double jn (int, double) ; extern double lgamma (double) ; extern double y0 (double) ; extern double y1 (double) ; extern double yn (int, double) ; extern double acosh (double) ; extern double asinh (double) ; extern double atanh (double) ; extern double cbrt (double) ; extern double logb (double) ; extern double nextafter (double, double) ; extern double remainder (double, double) ; extern double scalb (double, int) ; extern double significand (double) ; extern double copysign (double, double) ; extern int ilogb (double) ; extern double rint (double) ; extern double scalbn (double, int) ; extern double cabs(); extern double drem (double, double) ; extern double expm1 (double) ; extern double log1p (double) ; } # 16 "../BspLib/BspLibDefs.h" 2 typedef unsigned char byte; typedef unsigned short word; typedef unsigned long dword; typedef long fixed_t; typedef float float_t; typedef double hprec_t; namespace BspLib { struct ColorRGB { byte R; byte G; byte B; }; struct ColorRGBA { byte R; byte G; byte B; byte A; }; struct ColorRGBf { float R; float G; float B; }; struct ColorRGBAf { float R; float G; float B; float A; }; class EpsAreas { public: static double eps_scalarproduct; static double eps_vanishcomponent; static double eps_vanishdenominator; static double eps_planethickness; static double eps_pointonline; static double eps_pointonlineseg; static double eps_vertexmergearea; }; } # 12 "../BspLib/VrmlFile.h" 2 # 1 "../BspLib/BoundingBox.h" 1 # 1 "../BspLib/BspObject.h" 1 # 1 "../BspLib/SystemIO.h" 1 namespace BspLib { class SystemIO { public: enum { SYSTEM_IO_OK = 0x0000, SYSTEM_IO_ERROR = 0x0001, END_OF_FILE = 0x0002, FILE_NOT_FOUND = 0x0003, FILE_READ_ERROR = 0x0004, FILE_WRITE_ERROR = 0x0005, FILE_CLOSED = 0x0006, FILE_ALREADY_OPEN = 0x0007, }; enum { CRITERR_ALLOW_RET = 0x0001, }; enum { CHECK_ERRORS = 0x0001, }; public: static void InfoMessage( char *message ); static void ErrorMessage( char *message ); static void HandleCriticalError( int flags = 0 ); static void SetProgramName( const char *name ); static void SetInfoMessageCallback( void (*callb)(char*) ); static void SetErrorMessageCallback( void (*callb)(char*) ); static void SetCriticalErrorCallback( int (*callb)(int) ); public: static const char version_str[]; private: static const char *program_name; static void (*infomessage_callback)(char*); static void (*errormessage_callback)(char*); static int (*criticalerror_callback)(int); protected: class FilePtr { public: FilePtr( const char *fname, const char *mode ) { fp = fopen( fname, mode ); } ~FilePtr() { if ( fp ) fclose( fp ); } operator FILE*() { return fp; } protected: FILE *fp; }; class FileAccess : public FilePtr { public: FileAccess( const char *fname, const char *mode, int flags = CHECK_ERRORS ); ~FileAccess(); int ReOpen( const char *fname, const char *mode, int flags = CHECK_ERRORS ); int Close(); int Read( void *buffer, size_t size, size_t count, int flags = 0 ); int Write( void *buffer, size_t size, size_t count, int flags = 0 ); char *ReadLine( char *line, int maxlen, int flags = 0 ); char *WriteLine( char *line, int flags = 0 ); int Status() { return status; } char *getFileName() { return filename; } private: void IOError( int errorcode ); private: char *filename; int status; }; class StrScratch { public: StrScratch() { line = new char[ 1024 ]; } ~StrScratch() { delete line; } operator char*() { return line; } private: char *line; }; }; class String { public: String() { data = 0 ; } String( const char *src ); ~String() { delete data; } String( const String& copyobj ); String& operator =( const String& copyobj ); operator char*() { return data; } int IsNULL() const { return ( data == 0 ); } int IsEmpty() const { return data ? ( *data == '\0' ) : 1 ; } int getLength() const { return data ? strlen( data ) : 0; } private: char *data; }; } # 13 "../BspLib/BspObject.h" 2 # 1 "../BspLib/Chunk.h" 1 namespace BspLib { template class Chunk; template class ChunkRep : public virtual SystemIO { friend class Chunk; enum { E_INVALIDINDX }; void Error( int err ) const; private: ChunkRep( int chunksize = 0 ); ~ChunkRep(); int AddElement( const T& element ); T& FetchElement( int index ); int getNumElements() const; private: int ref_count; int numelements; int maxnumelements; T* elements; ChunkRep* next; static const int CHUNK_SIZE; }; template ChunkRep::ChunkRep( int chunksize ) : ref_count( 0 ) { int challocsize = chunksize > 0 ? chunksize : CHUNK_SIZE; elements = new T[ challocsize ]; maxnumelements = challocsize; numelements = 0; next = 0 ; } template ChunkRep::~ChunkRep() { delete[] elements; delete next; } template void ChunkRep::Error( int err ) const { { StrScratch message; sprintf( message, "***ERROR*** in object of a class of template Chunk" ); switch ( err ) { case E_INVALIDINDX: sprintf( message + strlen( message ), ": [Invalid index]" ); break; } ErrorMessage( message ); } HandleCriticalError(); } template T& ChunkRep::FetchElement( int index ) { # 133 "../BspLib/Chunk.h" if ( index >= numelements ) Error( E_INVALIDINDX ); return elements[ index ]; } template int ChunkRep::AddElement( const T& element ) { # 185 "../BspLib/Chunk.h" if ( numelements == maxnumelements ) { maxnumelements *= 2; T *temp = new T[ maxnumelements ]; for ( int i = 0; i < numelements; i++ ) temp[ i ] = elements[ i ]; delete[] elements; elements = temp; } elements[ numelements ] = element; return numelements++; } template int ChunkRep::getNumElements() const { int num = 0; for ( const ChunkRep *vlist = this; vlist; vlist = vlist->next ) num += vlist->numelements; return num; } template class Chunk { public: Chunk( int chunksize = 0 ) { rep = new ChunkRep( chunksize ); rep->ref_count = 1; } ~Chunk() { if ( --rep->ref_count == 0 ) delete rep; } Chunk( const Chunk& copyobj ); Chunk& operator =( const Chunk& copyobj ); T& operator []( int index ) { return rep->FetchElement( index ); } T& FetchElement( int index ) { return rep->FetchElement( index ); } int AddElement( const T& element ) { return rep->AddElement( element ); } int getNumElements() const { return rep->getNumElements(); } private: ChunkRep* rep; }; template Chunk::Chunk( const Chunk& copyobj ) { rep = copyobj.rep; rep->ref_count++; } template Chunk& Chunk::operator =( const Chunk& copyobj ) { if ( ©obj != this ) { if ( --rep->ref_count == 0 ) { delete rep; } rep = copyobj.rep; rep->ref_count++; } return *this; } } # 14 "../BspLib/BspObject.h" 2 # 1 "../BspLib/Face.h" 1 # 1 "../BspLib/Material.h" 1 namespace BspLib { class Material { public: Material() { } ~Material() { } ColorRGBA getAmbientColor() { return ambientcolor; } ColorRGBA getDiffuseColor() { return diffusecolor; } ColorRGBA getSpecularColor() { return specularcolor; } ColorRGBA getEmissiveColor() { return emissivecolor; } void setAmbientColor( ColorRGBA col ) { ambientcolor = col; ambientcolor.A = 255; } void setDiffuseColor( ColorRGBA col ) { diffusecolor = col; diffusecolor.A = 255; } void setSpecularColor( ColorRGBA col ) { specularcolor = col; specularcolor.A = 255; } void setEmissiveColor( ColorRGBA col ) { emissivecolor = col; emissivecolor.A = 255; } float getShininess() { return shininess; } float getTransparency() { return transparency; } void setShininess( float s ) { shininess = s; } void setTransparency( float t ) { transparency = t; } private: ColorRGBA ambientcolor; ColorRGBA diffusecolor; ColorRGBA specularcolor; ColorRGBA emissivecolor; float shininess; float transparency; }; } # 14 "../BspLib/Face.h" 2 # 1 "../BspLib/Plane.h" 1 # 1 "../BspLib/Vertex.h" 1 namespace BspLib { class Vertex3 { friend class Vector3; friend class LineSeg3; friend int operator ==( const Vertex3 v1, const Vertex3 v2 ); friend int operator !=( const Vertex3 v1, const Vertex3 v2 ); friend Vector3 operator -( const Vertex3 v1, const Vertex3 v2 ); friend Vertex3 operator +( const Vertex3 v1, const Vector3 v2 ); friend Vertex3 operator +( const Vector3 v1, const Vertex3 v2 ); friend Vertex3 operator -( const Vertex3 v1, const Vector3 v2 ); public: Vertex3( hprec_t x = 0, hprec_t y = 0, hprec_t z = 0, hprec_t w = 1.0 ); ~Vertex3() { } Vertex3& operator +=( const Vector3 v ); Vertex3& operator -=( const Vector3 v ); int IsInVicinity( const Vertex3& vertex ) const; void ChangeAxes( const char *xchangecmd, const Vertex3& ads ); hprec_t getX() const { return X; } hprec_t getY() const { return Y; } hprec_t getZ() const { return Z; } hprec_t getW() const { return W; } void setX( hprec_t x ) { X = x; } void setY( hprec_t y ) { Y = y; } void setZ( hprec_t z ) { Z = z; } void setW( hprec_t w ) { W = w; } private: void ChangeAxis( const char xchar, const hprec_t src ); protected: hprec_t X; hprec_t Y; hprec_t Z; hprec_t W; }; class Vector3 : public Vertex3 { friend class LineSeg3; friend Vector3 operator -( const Vertex3 v1, const Vertex3 v2 ); friend Vertex3 operator +( const Vertex3 v1, const Vector3 v2 ); friend Vertex3 operator +( const Vector3 v1, const Vertex3 v2 ); friend Vertex3 operator -( const Vertex3 v1, const Vector3 v2 ); friend Vector3 operator +( const Vector3 v1, const Vector3 v2 ); friend Vector3 operator -( const Vector3 v1, const Vector3 v2 ); friend Vector3 operator *( const Vector3 v1, double t ); friend Vector3 operator *( double t, const Vector3 v1 ); public: Vector3( hprec_t x = 0, hprec_t y = 0, hprec_t z = 0, hprec_t w = 1.0 ) : Vertex3( x, y, z, w ) { } Vector3( const Vertex3& v1, const Vertex3& v2 ) : Vertex3( v2.X - v1.X, v2.Y - v1.Y, v2.Z - v1.Z ) { } Vector3( const Vector3& v1, const Vector3& v2 ); Vector3( const Vertex3& vtx ) { *(Vertex3*)this = vtx; } ~Vector3() { } Vector3& operator +=( const Vector3 v ); Vector3& operator -=( const Vector3 v ); Vector3& operator *=( double t ); int Normalize(); int Homogenize(); int IsNullVector() const; hprec_t VecLength() const; hprec_t DotProduct( const Vector3& vect ) const; void CrossProduct( const Vector3& vect1, const Vector3& vect2 ); void CreateDirVec( const Vertex3& vertex1, const Vertex3& vertex2 ); }; class Vertex2 { friend class Vector2; friend class LineSeg2; friend int operator ==( const Vertex2 v1, const Vertex2 v2 ); friend int operator !=( const Vertex2 v1, const Vertex2 v2 ); friend Vector2 operator -( const Vertex2 v1, const Vertex2 v2 ); friend Vertex2 operator +( const Vertex2 v1, const Vector2 v2 ); friend Vertex2 operator +( const Vector2 v1, const Vertex2 v2 ); friend Vertex2 operator -( const Vertex2 v1, const Vector2 v2 ); public: Vertex2( hprec_t x = 0, hprec_t y = 0, hprec_t w = 1.0 ) { X = x; Y = y; W = w; } Vertex2( const Vector2& vect ); ~Vertex2() { } Vertex2& operator +=( const Vector2 v ); Vertex2& operator -=( const Vector2 v ); int IsInVicinity( const Vertex2& vertex ) const; void InitFromVertex3( const Vertex3& vertex ); hprec_t getX() const { return X; } hprec_t getY() const { return Y; } hprec_t getW() const { return W; } void setX( hprec_t x ) { X = x; } void setY( hprec_t y ) { Y = y; } void setW( hprec_t w ) { W = w; } protected: hprec_t X; hprec_t Y; hprec_t W; }; class Vector2 : public Vertex2 { friend class LineSeg2; friend Vector2 operator -( const Vertex2 v1, const Vertex2 v2 ); friend Vertex2 operator +( const Vertex2 v1, const Vector2 v2 ); friend Vertex2 operator +( const Vector2 v1, const Vertex2 v2 ); friend Vertex2 operator -( const Vertex2 v1, const Vector2 v2 ); friend Vector2 operator +( const Vector2 v1, const Vector2 v2 ); friend Vector2 operator -( const Vector2 v1, const Vector2 v2 ); friend Vector2 operator *( const Vector2 v1, double t ); friend Vector2 operator *( double t, const Vector2 v1 ); public: Vector2( hprec_t x = 0, hprec_t y = 0, hprec_t w = 1.0 ) : Vertex2( x, y, w ) { } Vector2( const Vertex2& v1, const Vertex2& v2 ) : Vertex2( v2.X - v1.X, v2.Y - v1.Y ) { } Vector2( const Vertex2& vtx ) { *(Vertex2*)this = vtx; } ~Vector2() { } Vector2& operator +=( const Vector2 v ); Vector2& operator -=( const Vector2 v ); Vector2& operator *=( double t ); int Normalize(); int Homogenize(); int IsNullVector() const; hprec_t VecLength() const; hprec_t DotProduct( const Vector2& vect ) const; void CreateDirVec( const Vertex2& vertex, const Vertex2& dirvec ); }; } # 1 "../BspLib/Vector.h" 1 # 1 "../BspLib/Vector3.h" 1 # 1 "../BspLib/Vertex3.h" 1 namespace BspLib { inline Vertex3::Vertex3( hprec_t x, hprec_t y, hprec_t z, hprec_t w ) { X = x; Y = y; Z = z; W = w; } inline int operator ==( const Vertex3 v1, const Vertex3 v2 ) { return ( ( v1.X == v2.X ) && ( v1.Y == v2.Y ) && ( v1.Z == v2.Z ) && ( v1.W == v2.W ) ); } inline int operator !=( const Vertex3 v1, const Vertex3 v2 ) { return ( ( v1.X != v2.X ) || ( v1.Y != v2.Y ) || ( v1.Z != v2.Z ) || ( v1.W != v2.W ) ); } inline Vertex3& Vertex3::operator +=( const Vector3 v ) { X += v.X; Y += v.Y; Z += v.Z; return *this; } inline Vertex3& Vertex3::operator -=( const Vector3 v ) { X -= v.X; Y -= v.Y; Z -= v.Z; return *this; } inline int Vertex3::IsInVicinity( const Vertex3& vertex ) const { return ( ( fabs( X - vertex.X ) < EpsAreas::eps_vertexmergearea ) && ( fabs( Y - vertex.Y ) < EpsAreas::eps_vertexmergearea ) && ( fabs( Z - vertex.Z ) < EpsAreas::eps_vertexmergearea ) ); } } # 13 "../BspLib/Vector3.h" 2 namespace BspLib { inline Vector3 operator *( const Vector3 v1, double t ) { return Vector3( v1.X * t, v1.Y * t, v1.Z * t, 1.0 ); } inline Vector3 operator *( double t, const Vector3 v1 ) { return Vector3( v1.X * t, v1.Y * t, v1.Z * t, 1.0 ); } inline Vector3::Vector3( const Vector3& v1, const Vector3& v2 ) { CrossProduct( v1, v2 ); } inline Vector3& Vector3::operator +=( const Vector3 v ) { X += v.X; Y += v.Y; Z += v.Z; return *this; } inline Vector3& Vector3::operator -=( const Vector3 v ) { X -= v.X; Y -= v.Y; Z -= v.Z; return *this; } inline Vector3& Vector3::operator *=( double t ) { X *= t; Y *= t; Z *= t; return *this; } inline int Vector3::Normalize() { if ( IsNullVector() ) return 0 ; double oonorm = 1 / VecLength(); X = X * oonorm; Y = Y * oonorm; Z = Z * oonorm; W = 1.0; return 1 ; } inline int Vector3::Homogenize() { if ( fabs( W ) < EpsAreas::eps_vanishdenominator ) return 0 ; double oow = 1 / W; X = X * oow; Y = Y * oow; Z = Z * oow; W = 1.0; return 1 ; } inline int Vector3::IsNullVector() const { return ( ( fabs( X ) < EpsAreas::eps_vanishcomponent ) && ( fabs( Y ) < EpsAreas::eps_vanishcomponent ) && ( fabs( Z ) < EpsAreas::eps_vanishcomponent ) ); } inline hprec_t Vector3::VecLength() const { return sqrt( X * X + Y * Y + Z * Z ); } inline hprec_t Vector3::DotProduct( const Vector3& vect ) const { return ( vect.X * X ) + ( vect.Y * Y ) + ( vect.Z * Z ); } inline void Vector3::CrossProduct( const Vector3& vect1, const Vector3& vect2 ) { X = ( vect1.Y * vect2.Z ) - ( vect1.Z * vect2.Y ); Y = ( vect1.Z * vect2.X ) - ( vect1.X * vect2.Z ); Z = ( vect1.X * vect2.Y ) - ( vect1.Y * vect2.X ); W = 1.0; } inline void Vector3::CreateDirVec( const Vertex3& vertex1, const Vertex3& vertex2 ) { X = vertex2.X - vertex1.X; Y = vertex2.Y - vertex1.Y; Z = vertex2.Z - vertex1.Z; W = 1.0; } } # 12 "../BspLib/Vector.h" 2 # 1 "../BspLib/Vector2.h" 1 # 1 "../BspLib/Vertex2.h" 1 namespace BspLib { inline Vertex2::Vertex2( const Vector2& vect ) { X = vect.X; Y = vect.Y; W = vect.W; } inline int operator ==( const Vertex2 v1, const Vertex2 v2 ) { return ( ( v1.X == v2.X ) && ( v1.Y == v2.Y ) && ( v1.W == v2.W ) ); } inline int operator !=( const Vertex2 v1, const Vertex2 v2 ) { return ( ( v1.X != v2.X ) || ( v1.Y != v2.Y ) || ( v1.W != v2.W ) ); } inline Vertex2& Vertex2::operator +=( const Vector2 v ) { X += v.X; Y += v.Y; return *this; } inline Vertex2& Vertex2::operator -=( const Vector2 v ) { X -= v.X; Y -= v.Y; return *this; } inline int Vertex2::IsInVicinity( const Vertex2& vertex ) const { return ( ( fabs( X - vertex.X ) < EpsAreas::eps_vertexmergearea ) && ( fabs( Y - vertex.Y ) < EpsAreas::eps_vertexmergearea ) ); } inline void Vertex2::InitFromVertex3( const Vertex3& vertex ) { X = vertex.getX(); Y = vertex.getY(); W = vertex.getZ(); } } # 13 "../BspLib/Vector2.h" 2 namespace BspLib { inline Vector2 operator *( const Vector2 v1, double t ) { return Vector2( v1.X * t, v1.Y * t, 1.0 ); } inline Vector2 operator *( double t, const Vector2 v1 ) { return Vector2( v1.X * t, v1.Y * t, 1.0 ); } inline Vector2& Vector2::operator +=( const Vector2 v ) { X += v.X; Y += v.Y; return *this; } inline Vector2& Vector2::operator -=( const Vector2 v ) { X -= v.X; Y -= v.Y; return *this; } inline Vector2& Vector2::operator *=( double t ) { X *= t; Y *= t; return *this; } inline int Vector2::Normalize() { if ( IsNullVector() ) return 0 ; double oonorm = 1 / VecLength(); X = X * oonorm; Y = Y * oonorm; W = 1.0; return 1 ; } inline int Vector2::Homogenize() { if ( fabs( W ) < EpsAreas::eps_vanishdenominator ) return 0 ; double oow = 1 / W; X = X * oow; Y = Y * oow; W = 1.0; return 1 ; } inline int Vector2::IsNullVector() const { return ( ( fabs( X ) < EpsAreas::eps_vanishcomponent ) && ( fabs( Y ) < EpsAreas::eps_vanishcomponent ) ); } inline hprec_t Vector2::VecLength() const { return sqrt( X * X + Y * Y ); } inline hprec_t Vector2::DotProduct( const Vector2& vect ) const { return ( vect.X * X ) + ( vect.Y * Y ); } inline void Vector2::CreateDirVec( const Vertex2& vertex1, const Vertex2& vertex2 ) { X = vertex2.X - vertex1.X; Y = vertex2.Y - vertex1.Y; W = 1.0; } } # 13 "../BspLib/Vector.h" 2 namespace BspLib { inline Vertex3 operator +( const Vertex3 v1, const Vector3 v2 ) { return Vertex3( v1.X + v2.X, v1.Y + v2.Y, v1.Z + v2.Z, 1.0 ); } inline Vertex3 operator +( const Vector3 v1, const Vertex3 v2 ) { return Vertex3( v1.X + v2.X, v1.Y + v2.Y, v1.Z + v2.Z, 1.0 ); } inline Vector3 operator -( const Vertex3 v1, const Vertex3 v2 ) { return Vector3( v1.X - v2.X, v1.Y - v2.Y, v1.Z - v2.Z, 1.0 ); } inline Vertex3 operator -( const Vertex3 v1, const Vector3 v2 ) { return Vertex3( v1.X - v2.X, v1.Y - v2.Y, v1.Z - v2.Z, 1.0 ); } inline Vector3 operator +( const Vector3 v1, const Vector3 v2 ) { return Vector3( v1.X + v2.X, v1.Y + v2.Y, v1.Z + v2.Z, 1.0 ); } inline Vector3 operator -( const Vector3 v1, const Vector3 v2 ) { return Vector3( v1.X - v2.X, v1.Y - v2.Y, v1.Z - v2.Z, 1.0 ); } inline Vertex2 operator +( const Vertex2 v1, const Vector2 v2 ) { return Vertex2( v1.X + v2.X, v1.Y + v2.Y, 1.0 ); } inline Vertex2 operator +( const Vector2 v1, const Vertex2 v2 ) { return Vertex2( v1.X + v2.X, v1.Y + v2.Y, 1.0 ); } inline Vector2 operator -( const Vertex2 v1, const Vertex2 v2 ) { return Vector2( v1.X - v2.X, v1.Y - v2.Y, 1.0 ); } inline Vertex2 operator -( const Vertex2 v1, const Vector2 v2 ) { return Vertex2( v1.X - v2.X, v1.Y - v2.Y, 1.0 ); } inline Vector2 operator +( const Vector2 v1, const Vector2 v2 ) { return Vector2( v1.X + v2.X, v1.Y + v2.Y, 1.0 ); } inline Vector2 operator -( const Vector2 v1, const Vector2 v2 ) { return Vector2( v1.X - v2.X, v1.Y - v2.Y, 1.0 ); } } # 199 "../BspLib/Vertex.h" 2 # 1 "../BspLib/LineSeg2.h" 1 namespace BspLib { class LineSeg2 { public: LineSeg2( const Vertex2& basevtx, const Vector2& dirvec ); ~LineSeg2() { } int PointOnLineSeg( const Vertex2& vertex ) const; private: Vertex2 m_basevtx; Vector2 m_dirvec; }; inline LineSeg2::LineSeg2( const Vertex2& basevtx, const Vector2& dirvec ) { m_basevtx = basevtx; m_dirvec = dirvec; } } # 200 "../BspLib/Vertex.h" 2 # 1 "../BspLib/LineSeg3.h" 1 namespace BspLib { class LineSeg3 { public: LineSeg3( const Vertex3& basevtx, const Vector3& dirvec ); ~LineSeg3() { } int PointOnLineSeg( const Vertex3& vertex ) const; private: Vertex3 m_basevtx; Vector3 m_dirvec; }; inline LineSeg3::LineSeg3( const Vertex3& basevtx, const Vector3& dirvec ) { m_basevtx = basevtx; m_dirvec = dirvec; } } # 201 "../BspLib/Vertex.h" 2 # 1 "../BspLib/VertexChunk.h" 1 namespace BspLib { class VertexChunkRep : public virtual SystemIO { friend class VertexChunk; private: VertexChunkRep( int chunksize = 0 ); ~VertexChunkRep(); Vertex3& FetchVertex( int index ); int AddVertex( Vertex3 vertex ); int FindVertex( const Vertex3& vertex ); int FindCloseVertex( const Vertex3& vertex, int skip = -1 ); int CheckVertices( int verbose ); int getNumElements() const; private: void ChangeAxis( char xchar, hprec_t src ); int VerticesEqual( Vertex3 v1, Vertex3 v2 ); private: int ref_count; int numvertices; int maxnumvertices; Vertex3* vertices; VertexChunkRep* next; int nummultvertices; static int eliminatedoublets; static const int CHUNK_SIZE; }; inline VertexChunkRep::VertexChunkRep( int chunksize ) : ref_count( 0 ) { int challocsize = chunksize > 0 ? chunksize : CHUNK_SIZE; vertices = new Vertex3[ challocsize ]; maxnumvertices = challocsize; numvertices = 0; next = 0 ; } inline VertexChunkRep::~VertexChunkRep() { delete next; delete[] vertices; } inline int VertexChunkRep::VerticesEqual( Vertex3 v1, Vertex3 v2 ) { return ( v1 == v2 ); } class VertexChunk { public: VertexChunk( int chunksize = 0 ) { rep = new VertexChunkRep( chunksize ); rep->ref_count = 1; } ~VertexChunk() { if ( --rep->ref_count == 0 ) delete rep; } VertexChunk( const VertexChunk& copyobj ); VertexChunk& operator =( const VertexChunk& copyobj ); Vertex3& operator []( int index ) { return rep->FetchVertex( index ); } Vertex3& FetchVertex( int index ) { return rep->FetchVertex( index ); } int AddVertex( const Vertex3 vertex ) { return rep->AddVertex( vertex ); } int FindVertex( const Vertex3& vertex ) { return rep->FindVertex( vertex ); } int FindCloseVertex( Vertex3 vertex, int skip = -1 ) { return rep->FindCloseVertex( vertex, skip ); } int CheckVertices( int verbose ) { return rep->CheckVertices( verbose ); } int getNumElements() const { return rep->getNumElements(); } private: VertexChunkRep* rep; }; inline VertexChunk::VertexChunk( const VertexChunk& copyobj ) { rep = copyobj.rep; rep->ref_count++; } inline VertexChunk& VertexChunk::operator =( const VertexChunk& copyobj ) { if ( ©obj != this ) { if ( --rep->ref_count == 0 ) { delete rep; } rep = copyobj.rep; rep->ref_count++; } return *this; } } # 202 "../BspLib/Vertex.h" 2 # 13 "../BspLib/Plane.h" 2 namespace BspLib { class Plane { enum { NORMAL_VALID = 0x0001, OFFSET_VALID = 0x0002, PLANE_VALID = NORMAL_VALID | OFFSET_VALID, }; public: Plane() : m_valid( 0 ) { } Plane( const Vector3& pnormal ); Plane( const Vector3& pnormal, double poffset ); Plane( const Vertex3& v1, const Vertex3& v2, const Vertex3& v3 ); ~Plane() { } int InitPlane( const Vertex3& v1, const Vertex3& v2, const Vertex3& v3 ); int CalcPlaneOffset( const Vertex3& vtx ); Vector3 getPlaneNormal() const { return m_normal; } void setPlaneNormal( const Vector3& pnormal ) { m_normal = pnormal; } double getPlaneOffset() const { return m_offset; } void setPlaneOffset( double poffset ) { m_offset = poffset; } int NormalValid() const { return ( ( m_valid & NORMAL_VALID ) == NORMAL_VALID ); } int PlaneValid() const { return ( ( m_valid & PLANE_VALID ) == PLANE_VALID ); } void ApplyScaleFactor( double sfac ); void EliminateDirectionality(); int PointContained( const Vertex3& point ) const; int PointInPositiveHalfspace( const Vertex3& point ) const; int PointInNegativeHalfspace( const Vertex3& point ) const; private: Vector3 m_normal; double m_offset; int m_valid; }; inline Plane::Plane( const Vector3& pnormal ) { m_normal = pnormal; m_offset = 0.0; m_valid = NORMAL_VALID; } inline Plane::Plane( const Vector3& pnormal, double poffset ) { m_normal = pnormal; m_offset = poffset; m_valid = PLANE_VALID; } inline Plane::Plane( const Vertex3& v1, const Vertex3& v2, const Vertex3& v3 ) { m_normal.CrossProduct( v3 - v1, v2 - v1 ); m_valid = m_normal.Normalize() ? PLANE_VALID : 0; m_offset = m_normal.DotProduct( v1 ); } inline int Plane::InitPlane( const Vertex3& v1, const Vertex3& v2, const Vertex3& v3 ) { *this = Plane( v1, v2, v3 ); return m_valid; } inline int Plane::CalcPlaneOffset( const Vertex3& vtx ) { m_offset = m_normal.DotProduct( vtx ); return ( m_valid |= OFFSET_VALID ); } inline void Plane::ApplyScaleFactor( double sfac ) { m_offset *= sfac; } inline void Plane::EliminateDirectionality() { if ( m_offset < 0.0 ) { m_normal *= -1.0; m_offset = -m_offset; } } inline int Plane::PointContained( const Vertex3& point ) const { return ( fabs( m_normal.DotProduct( point ) - m_offset ) < EpsAreas::eps_planethickness ); } inline int Plane::PointInPositiveHalfspace( const Vertex3& point ) const { return ( m_normal.DotProduct( point ) - m_offset >= EpsAreas::eps_planethickness ); } inline int Plane::PointInNegativeHalfspace( const Vertex3& point ) const { return ( m_normal.DotProduct( point ) - m_offset <= - EpsAreas::eps_planethickness ); } } # 15 "../BspLib/Face.h" 2 # 1 "../BspLib/Texture.h" 1 namespace BspLib { class Texture : public virtual SystemIO { public: Texture( int w = -1, int h = -1, char *tname = 0 , char *fname = 0 ); ~Texture() { } int getWidth() const { return m_width; } int getHeight() const { return m_height; } const char* getName() const { return m_name; } const char* getFile() const { return m_file; } void setWidth( int w ) { m_width = w; } void setHeight( int h ) { m_height = h; } void setName( const char *tname ); void setFile( const char *fname ); void WriteInfo( FILE *fp ); private: int m_width; int m_height; char m_name[ 31 + 1 ]; char m_file[ 1024 + 1 ]; }; typedef Chunk TextureChunk; } # 17 "../BspLib/Face.h" 2 # 1 "../BspLib/TriMapping.h" 1 namespace BspLib { class TriMapping : public virtual SystemIO { void Error() const; public: TriMapping() { } ~TriMapping() { } Vertex2& getMapXY( int indx ) { if ( indx > 2 ) Error(); return map_xy[ indx ]; } Vertex2& getMapUV( int indx ) { if ( indx > 2 ) Error(); return map_uv[ indx ]; } private: Vertex2 map_xy[ 3 ]; Vertex2 map_uv[ 3 ]; }; } # 18 "../BspLib/Face.h" 2 namespace BspLib { class Face : public virtual SystemIO { void Error() const; public: enum ShadingType { no_shad = 0x1000, flat_shad = 0x1001, gouraud_shad = 0x1002, afftex_shad = 0x2003, ipol1tex_shad = 0x2004, ipol2tex_shad = 0x2005, persptex_shad = 0x2006, material_shad = 0x1007, texmat_shad = 0x3008, num_shading_types = 9, base_mask = 0x00ff, color_mask = 0x1000, texmap_mask = 0x2000, }; enum ColorModel { no_col, indexed_col, rgb_col, material_col, num_color_models }; public: Face(); ~Face() { delete faceplane; delete facematerial; delete facemapping; delete texturename; } Face( const Face& copyobj ); Face& operator =( const Face& copyobj ); int getId() const { return faceid; } void setId( int id ) { faceid = id; } Material getMaterial() const { if ( facematerial == 0 ) Error(); return *facematerial; } Plane getPlane() const { if ( faceplane == 0 ) Error(); return *faceplane; } Vector3 getPlaneNormal() const; void setPlaneNormal( const Vector3& normal ); int getShadingType() const { return shadingtype; } void setShadingType( int type ); int getColorType() const { return colortype; } void getColorIndex( dword& col ) const { col = facecolor_indx; } void getColorRGBA( ColorRGBA& col ) const { col = facecolor_rgba; } void getColorChannels( float& r, float& g, float& b ) const; const char *getTextureName() { return texturename; } void setFaceColor( dword col ); void setFaceColor( ColorRGBA col ); void setTextureName( const char *tname ); int NormalValid() const { return faceplane ? faceplane->NormalValid() : 0 ; } int PlaneValid() const { return faceplane ? faceplane->PlaneValid() : 0 ; } int MaterialAttached() const { return ( facematerial != 0 ); } int MappingAttached() const { return ( facemapping != 0 ); } int FaceTexMapped() const { return ( ( shadingtype & texmap_mask ) != 0 ); } void CalcPlane( const Vertex3& vertex1, const Vertex3& vertex2, const Vertex3& vertex3 ); void AttachNormal( const Vector3& normal ); void AttachPlane( Plane *plane ); void AttachMaterial( Material *mat ); int ConvertColorIndexToRGB( char *palette, int changemode ); Vertex2& MapXY( int indx ); Vertex2& MapUV( int indx ); void WriteFaceInfo( FILE *fp ) const; void WriteNormalInfo( FILE *fp ) const; void WriteMappingInfo( FILE *fp ) const; public: static int GetTypeIndex( const char *type ); static int GetColorModelIndex( const char *type ); public: static const char* material_strings[]; private: static const char* prop_strings[]; static const int prop_ids[]; static const char* color_strings[]; static const int color_ids[]; private: int faceid; Plane* faceplane; int shadingtype; int colortype; dword facecolor_indx; ColorRGBA facecolor_rgba; Material* facematerial; TriMapping* facemapping; char* texturename; }; typedef Chunk FaceChunk; inline Face::Face() { faceid = -1; shadingtype = -1; colortype = -1; faceplane = 0 ; facematerial = 0 ; facemapping = 0 ; texturename = 0 ; } inline Vector3 Face::getPlaneNormal() const { if ( ( faceplane == 0 ) || !faceplane->NormalValid() ) Error(); ; return faceplane->getPlaneNormal(); } inline void Face::setPlaneNormal( const Vector3& normal ) { if ( ( faceplane == 0 ) || !faceplane->NormalValid() ) Error(); ; faceplane->setPlaneNormal( normal ); } inline void Face::setShadingType( int type ) { if ( ( type & base_mask ) >= num_shading_types ) Error(); ; shadingtype = type; } inline void Face::setFaceColor( dword col ) { facecolor_indx = col; colortype = indexed_col; } inline void Face::setFaceColor( ColorRGBA col ) { facecolor_rgba = col; colortype = rgb_col; } inline void Face::getColorChannels( float& r, float& g, float& b ) const { r = facecolor_rgba.R / 255.0f; g = facecolor_rgba.G / 255.0f; b = facecolor_rgba.B / 255.0f; } inline Vertex2& Face::MapXY( int indx ) { if ( facemapping == 0 ) facemapping = new TriMapping; return facemapping->getMapXY( indx ); } inline Vertex2& Face::MapUV( int indx ) { if ( facemapping == 0 ) facemapping = new TriMapping; return facemapping->getMapUV( indx ); } } # 15 "../BspLib/BspObject.h" 2 # 1 "../BspLib/Mapping.h" 1 namespace BspLib { class Mapping : public virtual SystemIO { void Error( int vertindx ); public: Mapping() { numvertexindxs = 0; } ~Mapping() { } void InsertFaceVertex( int vindx ) { facevertexindxs[ numvertexindxs++ ] = vindx; } void SetCorrespondence( int vindx, Vertex2 vertex ); Vertex2 FetchMapPoint( int vertindx ); int getNumVertices() { return numvertexindxs; } void setNumVertices( int num ) { numvertexindxs = num; } void setMappingCoordinates( int k, const Vertex2& vertex); void WriteMappingInfo( FILE *fp ) const; private: int numvertexindxs; int facevertexindxs[ 32 ]; Vertex2 mappingcoordinates[ 32 ]; }; typedef Chunk MappingChunk; inline void Mapping::setMappingCoordinates( int k, const Vertex2& vertex) { if ( k < 32 ) mappingcoordinates[ k ] = vertex; else Error( k ); } inline void Mapping::SetCorrespondence( int vindx, Vertex2 vertex ) { if ( numvertexindxs < 32 ) { facevertexindxs[ numvertexindxs ] = vindx; mappingcoordinates[ numvertexindxs ] = vertex; numvertexindxs++; } else { Error( numvertexindxs ); } } inline Vertex2 Mapping::FetchMapPoint( int vertindx ) { for ( int i = 0; i < numvertexindxs; i++ ) if ( facevertexindxs[ i ] == vertindx ) return mappingcoordinates[ i ]; Error( vertindx ); return Vertex2( 0, 0 ); } } # 16 "../BspLib/BspObject.h" 2 # 1 "../BspLib/PolygonList.h" 1 # 1 "../BspLib/Polygon.h" 1 namespace BspLib { class BoundingBox; class VIndx { public: VIndx( int indx = -1, VIndx *next = 0 ) { vertindx = indx; nextvertindx = next; } ~VIndx() { delete nextvertindx; } int getIndx() const { return vertindx; } void setIndx( int indx ) { vertindx = indx; } VIndx* getNext() const { return nextvertindx; } void setNext( VIndx *next ) { nextvertindx = next; } private: int vertindx; VIndx* nextvertindx; }; class BSPNode; class BspObject; class Polygon : public virtual SystemIO { friend class PolygonListRep; void Error() const; enum { POLY_IN_FRONT_SUBSPACE, POLY_IN_BACK_SUBSPACE, POLY_STRADDLES_SPLITTER, POLY_IN_SAME_PLANE, }; enum { FRONT_SUBSPACE = 1, BACK_SUBSPACE = -1 }; public: enum { SPLITTERCRIT_FIRST_POLY = 0x0000, SPLITTERCRIT_SAMPLE_FIRST_N = 0x0101, SPLITTERCRIT_SAMPLE_ALL = 0x0002, SPLITTERCRIT_RANDOM_SAMPLE = 0x0103, SPLITTERCRITMASK_SAMPLESIZ = 0x0100, }; enum { MESSAGE_SPLITTING_POLYGON = 0x0001, MESSAGE_STARTVERTEX_IN_SPLITTER_PLANE = 0x0002, MESSAGE_VERTEX_IN_SPLITTER_PLANE = 0x0004, MESSAGE_NEW_SPLITVERTEX = 0x0008, MESSAGE_REUSING_SPLITVERTEX = 0x0010, MESSAGE_TRACEVERTEX_INSERTED = 0x0020, MESSAGE_SPLITTING_QUADRILATERAL = 0x0040, MESSAGE_INVOCATION = 0x0080, MESSAGE_CHECKING_POLYGON_PLANES = 0x0100, MESSAGEMASK_DISPLAY_ALL = 0xffff }; public: Polygon( BspObject *bobj, int pno = 0, int fno = 0, Polygon *next = 0 , int num = 1 ); ~Polygon() { delete vertindxs; delete nextpolygon; } Polygon* NewPolygon(); Polygon* InsertPolygon( Polygon *poly ); Polygon* DeleteHead(); Polygon* FindPolygon( int id ); int SumVertexNumsEntireList(); void PrependNewVIndx( int indx ); void AppendNewVIndx( int indx = -1 ); void AppendVIndx( VIndx *vindx ); VIndx* UnlinkLastVIndx(); void CalcPlaneNormals(); void CheckEdges(); Polygon* CheckPlanesAndMappings(); void CalcBoundingBox( BoundingBox* &boundingbox ); int CheckIntersection( Polygon *testpoly ); int NormalDirectionSimilar( Polygon *testpoly ); void SplitPolygon( Polygon *poly, Polygon* &frontsubspace, Polygon* &backsubspace ); BSPNode* PartitionSpace(); void CorrectBase( BspObject *newbaseobj, int vertexindxbase, int faceidbase, int polygonidbase ); void CorrectBaseByTable( BspObject *newbaseobj, int *vtxindxmap, int faceidbase, int polygonidbase ); int getId() const { return polygonno; } void setId( int pno ) { polygonno = pno; } int getFaceId() const { return faceno; } void setFaceId( int fno ) { faceno = fno; } int getNumPolygons() const { return numpolygons; } void setNumPolygons( int len ) { numpolygons = len; } Polygon* getNext() const { return nextpolygon; } void setNext( Polygon *next ) { nextpolygon = next; } int getNumVertices() const { return numvertindxs; } VIndx* getVList() const { return vertindxs; } BspObject* getBaseObject() const { return baseobject; } VertexChunk& getVertexList(); FaceChunk& getFaceList(); int HasArea() const; int getFirstVertexIndx() const; int getSecondVertexIndx() const; int getThirdVertexIndx() const; Vertex3 getFirstVertex() const; Vertex3 getSecondVertex() const; Vertex3 getThirdVertex() const; Plane getPlane() const { return ((Polygon *const)this)->getFaceList()[ faceno ].getPlane(); } Vector3 getPlaneNormal() const { return ((Polygon *const)this)->getFaceList()[ faceno ].getPlaneNormal(); } void FillVertexIndexArray( dword *arr ) const; void WriteVertexList( FILE *fp, int cr ) const; void WritePolyList( FILE *fp ) const; int CalcSplitterTestProbability(); public: static int getSplitterSelection() { return splitter_crit; } static void setSplitterSelection( int criterion ) { splitter_crit = criterion; } static int getSampleSize() { return sample_size; } static void setSampleSize( int siz ) { sample_size = siz; } static int getTriangulationFlag() { return triangulate_all; } static void setTriangulationFlag( int flag ) { triangulate_all = flag; } static int getNormalizeVectorsFlag() { return normalize_vectors; } static void setNormalizeVectorsFlag( int flag ) { normalize_vectors = flag; } static int getDisplayMessagesFlag() { return display_messages; } static void setDisplayMessagesFlag( int flag ) { display_messages = flag; } static void ResetCallCount() { partition_callcount = 0; } private: static int splitter_crit; static int sample_size; static int triangulate_all; static int normalize_vectors; static int display_messages; static int partition_callcount; static int test_probability; static char str_scratchpad[]; private: int polygonno; int faceno; int numpolygons; int numvertindxs; VIndx* vertindxs; VIndx* vindxinsertpos; BspObject* baseobject; Polygon* nextpolygon; }; inline int Polygon::HasArea() const { return ( vertindxs && vertindxs->getNext() && vertindxs->getNext()->getNext() ); } inline int Polygon::getFirstVertexIndx() const { if ( vertindxs == 0 ) Error(); ; return vertindxs->getIndx(); } inline Vertex3 Polygon::getFirstVertex() const { if ( vertindxs == 0 ) Error(); ; return ((Polygon *const)this)->getVertexList()[ vertindxs->getIndx() ]; } inline int Polygon::getSecondVertexIndx() const { if ( ( vertindxs == 0 ) || ( vertindxs->getNext() == 0 ) ) Error(); ; return vertindxs->getNext()->getIndx(); } inline Vertex3 Polygon::getSecondVertex() const { if ( ( vertindxs == 0 ) || ( vertindxs->getNext() == 0 ) ) Error(); ; return ((Polygon *const)this)->getVertexList()[ vertindxs->getNext()->getIndx() ]; } inline int Polygon::getThirdVertexIndx() const { if ( ( vertindxs == 0 ) || ( vertindxs->getNext() == 0 ) || ( vertindxs->getNext()->getNext() == 0 ) ) Error(); ; return vertindxs->getNext()->getNext()->getIndx(); } inline Vertex3 Polygon::getThirdVertex() const { if ( ( vertindxs == 0 ) || ( vertindxs->getNext() == 0 ) || ( vertindxs->getNext()->getNext() == 0 ) ) Error(); ; return ((Polygon *const)this)->getVertexList()[ vertindxs->getNext()->getNext()->getIndx() ]; } } # 13 "../BspLib/PolygonList.h" 2 namespace BspLib { class BSPNode; class BspObject; class PolygonListRep : public virtual SystemIO { friend class PolygonList; enum { E_NEWVINDX, E_APPENDVINDX, E_GETNUMVERTXS }; void Error( int err ) const; private: PolygonListRep( BspObject *bobj ); ~PolygonListRep() { delete list; } void MergeLists( PolygonListRep *mergelist ); Polygon* InitList( Polygon *listhead ); void InvalidateList() { list = 0 ; numpolygons = 0; } Polygon* FetchHead() { return list; } Polygon* UnlinkHead(); Polygon* DeleteHead(); Polygon* FindPolygon( int id ) { return list ? list->FindPolygon( id ) : 0 ; } Polygon* NewPolygon(); Polygon* InsertPolygon( Polygon *poly ); void PrependNewVIndx( int indx = -1 ) { if ( list == 0 ) Error( E_NEWVINDX ); list->PrependNewVIndx( indx ); } void AppendNewVIndx( int indx = -1 ) { if ( list == 0 ) Error( E_NEWVINDX ); list->AppendNewVIndx( indx ); } void AppendVIndx( VIndx *vindx ) { if ( list == 0 ) Error( E_APPENDVINDX ); list->AppendVIndx( vindx ); } Polygon* CalcPlaneNormals(); Polygon* CheckPolygonPlanes(); BSPNode* PartitionSpace(); void WritePolyList( FILE *fp, int no ) const; int getNumElements() const { return numpolygons; } int getNumVertices() const { if( list == 0 ) Error( E_GETNUMVERTXS ); return list->getNumVertices(); } private: int ref_count; int numpolygons; BspObject* baseobject; Polygon* list; }; inline PolygonListRep::PolygonListRep( BspObject *bobj ) : ref_count( 0 ) { baseobject = bobj; list = 0 ; numpolygons = 0; } class PolygonList { public: PolygonList( BspObject *bobj ) { rep = new PolygonListRep( bobj ); rep->ref_count = 1; } ~PolygonList() { if ( --rep->ref_count == 0 ) delete rep; } PolygonList( const PolygonList& copyobj ); PolygonList& operator =( const PolygonList& copyobj ); void MergeLists( PolygonList *mergelist ) { if ( mergelist ) rep->MergeLists( mergelist->rep ); } Polygon* InitList( Polygon *listhead ) { return rep->InitList( listhead ); } void InvalidateList() { rep->InvalidateList(); } Polygon* FetchHead() { return rep->FetchHead(); } Polygon* UnlinkHead() { return rep->UnlinkHead(); } Polygon* DeleteHead() { return rep->DeleteHead(); } Polygon* FindPolygon( int id ) { return rep->FindPolygon( id ); } Polygon* NewPolygon() { return rep->NewPolygon(); } Polygon* InsertPolygon( Polygon *poly ) { return rep->InsertPolygon( poly ); } void PrependNewVIndx( int indx = -1 ) { rep->PrependNewVIndx( indx ); } void AppendNewVIndx( int indx = -1 ) { rep->AppendNewVIndx( indx ); } void AppendVIndx( VIndx *vindx ) { rep->AppendVIndx( vindx ); } Polygon* CalcPlaneNormals() { return rep->CalcPlaneNormals(); } Polygon* CheckPolygonPlanes() { return rep->CheckPolygonPlanes(); } BSPNode* PartitionSpace() { return rep->PartitionSpace(); } void WritePolyList( FILE *fp, int no ) const { rep->WritePolyList( fp, no ); } int getNumElements() const { return rep->getNumElements(); } int getNumVertices() const { return rep->getNumVertices(); } private: PolygonListRep* rep; }; inline PolygonList::PolygonList( const PolygonList& copyobj ) { rep = copyobj.rep; rep->ref_count++; } inline PolygonList& PolygonList::operator =( const PolygonList& copyobj ) { if ( ©obj != this ) { if ( --rep->ref_count == 0 ) { delete rep; } rep = copyobj.rep; rep->ref_count++; } return *this; } } # 17 "../BspLib/BspObject.h" 2 # 1 "../BspLib/BSPTree.h" 1 # 1 "../BspLib/BspNode.h" 1 namespace BspLib { class BoundingBox; class BspObject; class BSPNode { public: enum { OUTPUT_OLD_STYLE, OUTPUT_KEY_VALUE_STYLE }; public: BSPNode( BSPNode *front = 0 , BSPNode *back = 0 , Polygon *poly = 0 , Polygon *backpoly = 0 , Plane *sep = 0 , BoundingBox *box = 0 , int num = -1 ); ~BSPNode(); public: void NumberBSPNodes( int& curno ); void SumVertexNums( int& vtxnum ); void CorrectPolygonBases( BspObject *newbaseobj, int vertexindxbase, int faceidbase, int polygonidbase ); void CorrectPolygonBasesByTable( BspObject *newbaseobj, int *vtxindxmap, int faceidbase, int polygonidbase ); void WriteBSPTree( FILE *fp ); void CheckEdges(); void FetchFacePolygons( int facno, PolygonList& facepolylist ); Polygon* FetchBSPPolygon( int polyno ); void CalcBoundingBoxes(); void CalcSeparatorPlanes(); int getNodeNumber() const { return nodenumber; } Polygon* getPolygon() { return polygon; } Polygon* getBackPolygon() { return backpolygon; } BSPNode* getFrontSubtree() const { return frontsubtree; } BSPNode* getBackSubtree() const { return backsubtree; } Plane* getSeparatorPlane() { return separatorplane; } void setSeparatorPlane( Plane *sep ) { separatorplane = sep; } BoundingBox*getBoundingBox() { return boundingbox; } void setBoundingBox( BoundingBox *box ) { boundingbox = box; } private: void GrowBoundingBox( BSPNode *othernode ); public: static int getOutputFormat() { return outputformat; } static void setOutputFormat( int format ) { outputformat = format; } private: static int outputformat; private: int nodenumber; Polygon* polygon; Polygon* backpolygon; Plane* separatorplane; BoundingBox*boundingbox; BSPNode* frontsubtree; BSPNode* backsubtree; }; class BSPNodeFlat { public: BSPNodeFlat( int front = 0, int back = 0, Polygon *poly = 0 , int clist = 0, int blist = 0, Plane *sep = 0 , BoundingBox *box = 0 , int num = -1 ); ~BSPNodeFlat() { } public: void InitNode( int front, int back, Polygon *poly, int clist, int blist, Plane *sep = 0 , BoundingBox *box = 0 , int num = -1 ); void ApplyScaleFactor( double sfac ); int getNodeNumber() const { return nodenumber; } Polygon* getPolygon() { return polygon; } int getContainedList() const { return containedlistindx; } int getBackList() const { return backlistindx; } int getFrontSubTree() const { return frontsubtreeindx; } int getBackSubTree() const { return backsubtreeindx; } Plane* getSeparatorPlane() { return separatorplane; } void setSeparatorPlane( Plane *sep ) { separatorplane = sep; } BoundingBox*getBoundingBox() { return boundingbox; } void setBoundingBox( BoundingBox *box ) { boundingbox = box; } private: int nodenumber; Polygon* polygon; Plane* separatorplane; BoundingBox*boundingbox; int containedlistindx; int backlistindx; int frontsubtreeindx; int backsubtreeindx; }; } # 13 "../BspLib/BSPTree.h" 2 namespace BspLib { class BSPTreeRep { friend class BSPTree; private: BSPTreeRep() : ref_count( 0 ) { root = 0 ; } ~BSPTreeRep() { delete root; } BSPNode* InitTree( BSPNode *rootnode ); BSPNode* getRoot() { return root; } void InvalidateTree(); int TreeEmpty() const { return ( root == 0 ); } private: int ref_count; BSPNode* root; }; inline BSPNode *BSPTreeRep::InitTree( BSPNode *rootnode ) { delete root; return ( root = rootnode ); } inline void BSPTreeRep::InvalidateTree() { root = 0 ; } class BSPTree { public: BSPTree() { rep = new BSPTreeRep; rep->ref_count = 1; } ~BSPTree() { if ( --rep->ref_count == 0 ) delete rep; } BSPTree( const BSPTree& copyobj ); BSPTree& operator =( const BSPTree& copyobj ); BSPNode* operator->() { return rep->getRoot(); } BSPNode* InitTree( BSPNode *rootnode ) { return rep->InitTree( rootnode ); } BSPNode* getRoot() { return rep->getRoot(); } void InvalidateTree() { rep->InvalidateTree(); } int TreeEmpty() const { return rep->TreeEmpty(); } private: BSPTreeRep* rep; }; inline BSPTree::BSPTree( const BSPTree& copyobj ) { rep = copyobj.rep; rep->ref_count++; } inline BSPTree& BSPTree::operator =( const BSPTree& copyobj ) { if ( ©obj != this ) { if ( --rep->ref_count == 0 ) { delete rep; } rep = copyobj.rep; rep->ref_count++; } return *this; } class BSPTreeFlatRep { friend class BSPTreeFlat; private: BSPTreeFlatRep() : ref_count( 0 ) { root = 0 ; numnodes = 0; nodestorage = 0; } ~BSPTreeFlatRep() { delete[] root; } BSPNodeFlat* AppendNode( int front, int back, Polygon *poly, int clist, int blist ); BSPNodeFlat* FetchNodePerId( int id ); BSPNode* BuildBSPTree( int nodenum ); BSPNodeFlat* getRoot() { return root; } int TreeEmpty() const { return ( root == 0 ); } int getNumNodes() const { return numnodes; } void ApplyScaleFactor( double sfac ); void DestroyTree() { delete[] root; root = 0 ; numnodes = 0; nodestorage = 0; } private: int ref_count; int numnodes; int nodestorage; BSPNodeFlat* root; }; class BSPTreeFlat { public: BSPTreeFlat() { rep = new BSPTreeFlatRep; rep->ref_count = 1; } ~BSPTreeFlat() { if ( --rep->ref_count == 0 ) delete rep; } BSPTreeFlat( const BSPTreeFlat& copyobj ); BSPTreeFlat& operator =( const BSPTreeFlat& copyobj ); BSPNodeFlat* AppendNode( int front, int back, Polygon *poly, int clist, int blist ) { return rep->AppendNode( front, back, poly, clist, blist ); } BSPNodeFlat* FetchNodePerId( int id ) { return rep->FetchNodePerId( id ); } BSPNode* BuildBSPTree( int nodenum ) { return rep->BuildBSPTree( nodenum ); } BSPNodeFlat* getRoot() { return rep->getRoot(); } int TreeEmpty() const { return rep->TreeEmpty(); } int getNumNodes() const { return rep->getNumNodes(); } void ApplyScaleFactor( double sfac ) { rep->ApplyScaleFactor( sfac ); } void DestroyTree() { rep->DestroyTree(); } private: BSPTreeFlatRep* rep; }; inline BSPTreeFlat::BSPTreeFlat( const BSPTreeFlat& copyobj ) { rep = copyobj.rep; rep->ref_count++; } inline BSPTreeFlat& BSPTreeFlat::operator =( const BSPTreeFlat& copyobj ) { if ( ©obj != this ) { if ( --rep->ref_count == 0 ) { delete rep; } rep = copyobj.rep; rep->ref_count++; } return *this; } } # 18 "../BspLib/BspObject.h" 2 # 1 "../BspLib/Transform3.h" 1 namespace BspLib { class Transform3 { friend Transform3 operator *( const Transform3& trafo1, const Transform3& trafo2 ); public: Transform3(); Transform3( const float trafo[4][4] ); Transform3( const double trafo[4][4] ); ~Transform3() { } Vector3 TransformVector3( const Vector3& vec ) const; Transform3& Concat( const Transform3& cattrafo ); Transform3& ConcatR( const Transform3& cattrafo ); Transform3& LoadIdentity(); Transform3& LoadRotation( double angle, double x, double y, double z ); Transform3& LoadScale( double x, double y, double z ); Transform3& LoadTranslation( double x, double y, double z ); Transform3& Rotate( double angle, double x, double y, double z ); Transform3& Scale( double x, double y, double z ); Transform3& Translate( double x, double y, double z ); Transform3& RotateR( double angle, double x, double y, double z ); Transform3& ScaleR( double x, double y, double z ); Transform3& TranslateR( double x, double y, double z ); Vector3 FetchTranslation() const; Vector3 ExtractTranslation(); private: double m_matrix[4][4]; }; inline Transform3& Transform3::LoadIdentity() { memset( m_matrix, 0, sizeof( m_matrix ) ); m_matrix[ 0 ][ 0 ] = 1.0; m_matrix[ 1 ][ 1 ] = 1.0; m_matrix[ 2 ][ 2 ] = 1.0; m_matrix[ 3 ][ 3 ] = 1.0; return *this; } inline Transform3::Transform3() { } inline Transform3::Transform3( const double trafo[4][4] ) { memcpy( m_matrix, trafo, sizeof( m_matrix ) ); } inline Transform3::Transform3( const float trafo[4][4] ) { for ( int i = 0; i < 16; i++ ) ((double *)m_matrix)[ i ] = (double) ((float *)trafo)[ i ]; } } # 20 "../BspLib/BspObject.h" 2 namespace BspLib { class BoundingBox; class BspObjectInfo { friend class BspObject; private: BspObjectInfo(); ~BspObjectInfo() { } public: int getNumVertices() const { return numvertices; } int getNumPolygons() const { return numpolygons; } int getNumFaces() const { return numfaces; } int getInputVertices() const { return numvertices_in; } int getInputPolygons() const { return numpolygons_in; } int getInputFaces() const { return numfaces_in; } int getBspPolygons() const { return numbsppolygons; } int getPreBspPolygons() const { return numpolygons_before_bsp; } int getNumTextures() const { return numtextures; } int getNumMappings() const { return numcorrespondences; } int getNumNormals() const { return numnormals; } int getNumTexturedFaces() const { return numtexmappedfaces; } int getNumTraceVertices() const { return numtracevertices; } int getNumMultiVertices() const { return nummultvertices; } int getNumSplitQuads() const { return numsplitquadrilaterals; } protected: int numvertices; int numpolygons; int numfaces; int numtextures; int numcorrespondences; int numnormals; int numtexmappedfaces; int numvertices_in; int numpolygons_in; int numfaces_in; int numbsppolygons; int numpolygons_before_bsp; int numtracevertices; int nummultvertices; int numsplitquadrilaterals; }; class BspObject : public BspObjectInfo, public virtual SystemIO { friend class BoundingBox; friend class BspObjectListRep; friend class Face; friend class ObjectBSPNode; friend class Polygon; friend class VrmlFile; public: BspObject(); ~BspObject() { delete objectname; delete next; } BspObject( const BspObject& copyobj ); BspObject& operator =( const BspObject& copyobj ); void MergeObjects( BspObject *mergeobj ); void CollapseObjectList(); BoundingBox* BuildBoundingBoxList(); BSPNode* BuildBSPTree(); BSPNode* BuildBSPTreeFromFlat(); int BspTreeAvailable(); int BSPTreeAvailable(); int BSPTreeFlatAvailable(); void CalcBoundingBoxes(); void CalcSeparatorPlanes(); void CheckEdges(); void CheckPolygonPlanes(); void CheckVertices( int verbose ); void CalcPlaneNormals(); void CheckParsedData(); void UpdateAttributeNumbers(); int ConvertColorIndexesToRGB( char *palette, int changemode ); void CalcBoundingBox( Vertex3& minvertex, Vertex3& maxvertex ); void DisplayStatistics(); virtual int WriteVertexList( FileAccess& fp ) { return 0 ; } virtual int WritePolygonList( FileAccess& fp ) { return 0 ; } virtual int WriteFaceList( FileAccess& fp ) { return 0 ; } virtual int WriteFaceProperties( FileAccess& fp ) { return 0 ; } virtual int WriteTextureList( FileAccess& fp ) { return 0 ; } virtual int WriteMappingList( FileAccess& fp ) { return 0 ; } virtual int WriteNormals( FileAccess& fp ) { return 0 ; } virtual int WriteBSPTree( FileAccess& fp ) { return 0 ; } VertexChunk& getVertexList() { return vertexlist; } PolygonList& getPolygonList() { return polygonlist; } FaceChunk& getFaceList() { return facelist; } TextureChunk& getTextureList() { return texturelist; } MappingChunk& getMappingList() { return mappinglist; } BSPTree& getBSPTree() { return bsptree; } BSPTreeFlat& getBSPTreeFlat() { return bsptreeflat; } char* getObjectName() const { return objectname; } void setObjectName( char *name ); Vertex3 getCenterInWorldSpace() const { return objecttrafo.FetchTranslation(); } Transform3 getObjectTransformation() const { return objecttrafo; } void setObjectTransformation( const Transform3& ot ) { objecttrafo = ot; } void ApplyScale( double scalefac ); void ApplyCenter(); void ApplyTransformation(); BspObject* getNext() const { return next; } private: void InconsistencyError( const char *err ); public: static int getEliminateDoubletsOnMergeFlag() { return check_vertex_doublets_on_merge; } static void setEliminateDoubletsOnMergeFlag( int flag ) { check_vertex_doublets_on_merge = flag; } private: static int check_vertex_doublets_on_merge; protected: VertexChunk vertexlist; PolygonList polygonlist; FaceChunk facelist; TextureChunk texturelist; MappingChunk mappinglist; BSPTree bsptree; BSPTreeFlat bsptreeflat; Transform3 objecttrafo; char* objectname; BspObject* next; }; inline BspObject::BspObject( const BspObject& copyobj ) : BspObjectInfo( copyobj ), vertexlist( copyobj.vertexlist ), polygonlist( copyobj.polygonlist ), facelist( copyobj.facelist ), texturelist( copyobj.texturelist ), mappinglist( copyobj.mappinglist ), bsptree( copyobj.bsptree ), bsptreeflat( copyobj.bsptreeflat ), objecttrafo( copyobj.objecttrafo ) { objectname = 0 ; setObjectName( copyobj.objectname ); next = 0 ; } inline BspObject& BspObject::operator =( const BspObject& copyobj ) { if ( ©obj != this ) { *(BspObjectInfo *)this = copyobj; vertexlist = copyobj.vertexlist; polygonlist = copyobj.polygonlist; facelist = copyobj.facelist; texturelist = copyobj.texturelist; mappinglist = copyobj.mappinglist; bsptree = copyobj.bsptree; bsptreeflat = copyobj.bsptreeflat; objecttrafo = copyobj.objecttrafo; setObjectName( copyobj.objectname ); next = 0 ; } return *this; } } # 13 "../BspLib/BoundingBox.h" 2 namespace BspLib { class BoundingBox { friend class ObjectBSPNode; public: BoundingBox() { containedobject = 0 ; nextbox = 0 ; } BoundingBox( BspObject *cobj, BoundingBox *next = 0 ); BoundingBox( const Vertex3& minvert, const Vertex3& maxvert, BoundingBox *next = 0 ); ~BoundingBox() { delete nextbox; } void ApplyScaleFactor( double sfac ); void GrowBoundingBox( BoundingBox *otherbox ); void BoundingBoxListUnion( BoundingBox& unionbox ); ObjectBSPNode* PartitionSpace(); Vertex3 getMinVertex() const { return minvertex; } Vertex3 getMaxVertex() const { return maxvertex; } BspObject* getContainedObject() const { return containedobject; } BoundingBox* getNext() const { return nextbox; } private: Vertex3 minvertex; Vertex3 maxvertex; BspObject* containedobject; BoundingBox* nextbox; }; inline BoundingBox::BoundingBox( BspObject *cobj, BoundingBox *next ) { if ( ( containedobject = cobj ) != 0 ) { cobj->CalcBoundingBox( minvertex, maxvertex ); } nextbox = next; } inline BoundingBox::BoundingBox( const Vertex3& minvert, const Vertex3& maxvert, BoundingBox *next ) { minvertex = minvert; maxvertex = maxvert; containedobject = 0 ; nextbox = next; } } # 13 "../BspLib/VrmlFile.h" 2 # 1 "../BspLib/InputData3D.h" 1 # 1 "../BspLib/BspObjectList.h" 1 # 1 "../BspLib/ObjectBSPTree.h" 1 # 1 "../BspLib/ObjectBSPNode.h" 1 namespace BspLib { class ObjectBSPNode { public: ObjectBSPNode( ObjectBSPNode *front = 0 , ObjectBSPNode *back = 0 , Plane *sep = 0 , BoundingBox *bbox = 0 , int id = -1 ); ~ObjectBSPNode() { delete separatorplane; delete boundingbox; delete frontsubtree; delete backsubtree; } void NumberBSPNodes( int& curno ); void WriteBSPTree( FILE *fp ) const; BspObject* CreateObjectList(); BspObject* CreateMergedBSPTree(); void DeleteNodeBspObjects(); int getNodeNumber() const { return nodenumber; } Plane* getSeparatorPlane() const { return separatorplane; } BoundingBox* getBoundingBox() const { return boundingbox; } ObjectBSPNode* getFrontSubtree() const { return frontsubtree; } ObjectBSPNode* getBackSubtree() const { return backsubtree; } private: void MergeTreeNodeObjects( BspObject *newobject ); BSPNode* CreateUnifiedBSPTree(); private: int nodenumber; Plane* separatorplane; BoundingBox* boundingbox; ObjectBSPNode* frontsubtree; ObjectBSPNode* backsubtree; }; inline ObjectBSPNode::ObjectBSPNode( ObjectBSPNode *front, ObjectBSPNode *back, Plane *sep, BoundingBox *bbox, int id ) { frontsubtree = front; backsubtree = back; separatorplane = sep; boundingbox = bbox; nodenumber = id; } } # 13 "../BspLib/ObjectBSPTree.h" 2 namespace BspLib { class ObjectBSPTreeRep { friend class ObjectBSPTree; private: ObjectBSPTreeRep() : ref_count( 0 ) { root = 0 ; } ~ObjectBSPTreeRep() { delete root; } void KillTree() { delete root; root = 0 ; } ObjectBSPNode* InitTree( ObjectBSPNode *rootnode ); ObjectBSPNode* getRoot() { return root; } int TreeEmpty() const { return ( root == 0 ); } private: int ref_count; ObjectBSPNode* root; }; inline ObjectBSPNode *ObjectBSPTreeRep::InitTree( ObjectBSPNode *rootnode ) { delete root; return ( root = rootnode ); } class ObjectBSPTree { public: ObjectBSPTree() { rep = new ObjectBSPTreeRep; rep->ref_count = 1; } ~ObjectBSPTree() { if ( --rep->ref_count == 0 ) delete rep; } ObjectBSPTree( const ObjectBSPTree& copyobj ); ObjectBSPTree& operator =( const ObjectBSPTree& copyobj ); ObjectBSPNode* operator->() { return rep->getRoot(); } void KillTree() { rep->KillTree(); } ObjectBSPNode* InitTree( ObjectBSPNode *rootnode ) { return rep->InitTree( rootnode ); } ObjectBSPNode* getRoot() { return rep->getRoot(); } int TreeEmpty() const { return rep->TreeEmpty(); } private: ObjectBSPTreeRep* rep; }; inline ObjectBSPTree::ObjectBSPTree( const ObjectBSPTree& copyobj ) { rep = copyobj.rep; rep->ref_count++; } inline ObjectBSPTree& ObjectBSPTree::operator =( const ObjectBSPTree& copyobj ) { if ( ©obj != this ) { if ( --rep->ref_count == 0 ) { delete rep; } rep = copyobj.rep; rep->ref_count++; } return *this; } } # 14 "../BspLib/BspObjectList.h" 2 namespace BspLib { class BspObjectListRep { friend class BspObjectList; public: BspObjectListRep() : ref_count( 0 ) { list = 0 ; } ~BspObjectListRep() { delete list; } BspObject* CreateNewObject(); BspObject* InsertObject( BspObject *obj ); BoundingBox* BuildBoundingBoxList(); int CountListObjects(); int PrepareObjectBSPTree( ObjectBSPTree& objbsptree ); int MergeObjectBSPTree( ObjectBSPTree& objbsptree ); int CollapseObjectList(); int ProcessObjects( int flags ); int BspTreeAvailable() { return list ? list->BspTreeAvailable() : 0 ; } int BSPTreeAvailable() { return list ? list->BSPTreeAvailable() : 0 ; } int BSPTreeFlatAvailable() { return list ? list->BSPTreeFlatAvailable() : 0 ; } BspObject* getListHead() const { return list; } private: int ref_count; BspObject* list; }; class BspObjectList { public: enum { CHECK_PLANES = 0x0001, BUILD_BSP = 0x0002, CHECK_VERTICES = 0x0004, CHECK_EDGES = 0x0008, BUILD_BSP_WITH_CHECKS = 0x000F, DISPLAY_STATS = 0x0010, BUILD_FROM_FLAT = 0x0020, MERGE_VERTICES = 0x0040, CULL_NULL_EDGES = 0x0080, ELIMINATE_T_VERTICES = 0x0100, MERGE_FACES = 0x0200, CALC_PLANE_NORMALS = 0x0400, CALC_BOUNDING_BOXES = 0x0800, CALC_SEPARATOR_PLANES = 0x1000, APPLY_TRANSFORMATIONS = 0x2000, }; public: BspObjectList() { rep = new BspObjectListRep(); rep->ref_count = 1; } ~BspObjectList() { if ( --rep->ref_count == 0 ) delete rep; } BspObjectList( const BspObjectList& copyobj ); BspObjectList& operator =( const BspObjectList& copyobj ); BspObject* CreateNewObject() { return rep->CreateNewObject(); } BspObject* InsertObject( BspObject *obj ) { return rep->InsertObject( obj ); } BoundingBox* BuildBoundingBoxList() { return rep->BuildBoundingBoxList(); } int CountListObjects() { return rep->CountListObjects(); } int PrepareObjectBSPTree( ObjectBSPTree& objbsptree ) { return rep->PrepareObjectBSPTree( objbsptree ); } int MergeObjectBSPTree( ObjectBSPTree& objbsptree ) { return rep->MergeObjectBSPTree( objbsptree ); } int CollapseObjectList() { return rep->CollapseObjectList(); } int ProcessObjects( int flags ) { return rep->ProcessObjects( flags ); } int BspTreeAvailable() { return rep->BspTreeAvailable(); } int BSPTreeAvailable() { return rep->BSPTreeAvailable(); } int BSPTreeFlatAvailable() { return rep->BSPTreeFlatAvailable(); } BspObject* getListHead() { return rep->getListHead(); } private: BspObjectListRep *rep; }; inline BspObjectList::BspObjectList( const BspObjectList& copyobj ) { rep = copyobj.rep; rep->ref_count++; } inline BspObjectList& BspObjectList::operator =( const BspObjectList& copyobj ) { if ( ©obj != this ) { if ( --rep->ref_count == 0 ) { delete rep; } rep = copyobj.rep; rep->ref_count++; } return *this; } } # 13 "../BspLib/InputData3D.h" 2 # 1 "../BspLib/IOData3D.h" 1 namespace BspLib { class IOData3D : public virtual SystemIO { public: enum { DONT_CREATE_OBJECT = 0x0000, UNKNOWN_FORMAT = 0x0001, AOD_FORMAT_1_1 = 0x0002, VRML_FORMAT_1_0 = 0x0003, BSP_FORMAT_1_1 = 0x0004, _3DX_FORMAT_1_0 = 0x0005, }; protected: enum { NO_CHECKS = 0x0000, CHECK_FILENAME = 0x0001, ALL_CHECKS = 0x0001 }; public: IOData3D( BspObjectList objectlist, const String& filename, int checkflags = ALL_CHECKS ); ~IOData3D() { } BspObjectList getObjectList() const { return m_objectlist; } String getFileName() const { return m_filename; } void setFileName( const String& filename ) { m_filename = filename; } protected: BspObjectList m_objectlist; String m_filename; protected: static const char AOD_SIGNATURE_1_1[]; static const char VRML_SIGNATURE_1_0[]; static const char BSP_SIGNATURE_1_1[]; static const char _3DX_SIGNATURE_1_0[]; static const int TEXTLINE_MAX; static char line[]; }; } # 14 "../BspLib/InputData3D.h" 2 namespace BspLib { class InputData3D : public IOData3D { public: enum { CONVERT_COLINDXS_TO_RGB = 0x0001, FILTER_SCALE_FACTORS = 0x0002, FILTER_AXES_DIR_SWITCH = 0x0004, FILTER_AXES_EXCHANGE = 0x0008, DO_AXES_EXCHANGE = FILTER_AXES_DIR_SWITCH | FILTER_AXES_EXCHANGE, FORCE_MAXIMUM_EXTENT = 0x0010, ALLOW_N_GONS = 0x0020, }; public: InputData3D( BspObjectList objectlist, const char *filename, int format = UNKNOWN_FORMAT ); virtual ~InputData3D(); virtual int ParseObjectData(); int getObjectFormat() const { return m_objectformat; } InputData3D* getRealObject() const { return m_data; } int InputDataValid() const { return m_inputok; } static int EnableRGBConversion( int enable ); static int EnableScaleFactors( int enable ); static int EnableAxesChange( int enable ); static int EnableMaximumExtent( int enable, double extent ); static int EnableAllowNGons( int enable ); static int getRGBConversionFlag() { return ( ( PostProcessingFlags & CONVERT_COLINDXS_TO_RGB ) == CONVERT_COLINDXS_TO_RGB ); } static int getScaleFactorsFlag() { return ( ( PostProcessingFlags & FILTER_SCALE_FACTORS ) == FILTER_SCALE_FACTORS ); } static int getAxesChangeFlag() { return ( ( PostProcessingFlags & DO_AXES_EXCHANGE ) == DO_AXES_EXCHANGE ); } static int getEnforceExtentsFlag() { return ( ( PostProcessingFlags & FORCE_MAXIMUM_EXTENT ) == FORCE_MAXIMUM_EXTENT ); } static double getMaxExtents() { return MaximumExtentToForce; } static int getAllowNGonFlag() { return ( ( PostProcessingFlags & ALLOW_N_GONS ) == ALLOW_N_GONS ); } private: int ReadFileSignature(); protected: static dword PostProcessingFlags; static double MaximumExtentToForce; static const char parser_err_str[]; protected: int m_objectformat; int m_inputok; private: InputData3D* m_data; }; } # 14 "../BspLib/VrmlFile.h" 2 namespace BspLib { class BspObjectList; class VrmlFile : public InputData3D { friend class BRep; public: VrmlFile( BspObjectList objectlist, const char *filename ); ~VrmlFile(); int ParseObjectData(); int WriteOutputFile(); private: void ApplySceneTransformations(); void EnforceSceneExtents( BoundingBox& unionbox ); private: BoundingBox* m_bboxlist; }; } # 7 "QvState.h" 2 class QvState { public: enum StackIndex { CameraIndex, Coordinate3Index, LightIndex, MaterialBindingIndex, MaterialIndex, NormalBindingIndex, NormalIndex, ShapeHintsIndex, Texture2Index, Texture2TransformationIndex, TextureCoordinate2Index, TransformationIndex, NumStacks, }; static const char *stackNames[NumStacks]; int depth; QvElement **stacks; BspLib ::VrmlFile *vrmlfile_base; QvState( BspLib ::VrmlFile *base ); QvState(); ~QvState(); void addElement(StackIndex stackIndex, QvElement *elt); QvElement * getTopElement(StackIndex stackIndex) { return stacks[stackIndex]; } void push(); void pop(); void popElement(StackIndex stackIndex); void print(); }; # 3 "QvTraverse.cpp" 2 static int indent = 0; static void announce(const char *className) { for (int i = 0; i < indent; i++) printf("\t"); printf("Traversing a %s\n", className); } void QvGroup::traverse(QvState *state) { announce("QvGroup" ) ; indent++; for (int i = 0; i < getNumChildren(); i++) getChild(i)->traverse(state); indent--; } void QvLevelOfDetail::traverse(QvState *state) { announce("QvLevelOfDetail" ) ; indent++; if (getNumChildren() > 0) getChild(0)->traverse(state); indent--; } void QvSeparator::traverse(QvState *state) { announce("QvSeparator" ) ; state->push(); indent++; for (int i = 0; i < getNumChildren(); i++) getChild(i)->traverse(state); indent--; state->pop(); } void QvSwitch::traverse(QvState *state) { announce("QvSwitch" ) ; indent++; int which = whichChild.value; if (which == (-1) ) ; else if (which == (-3) ) for (int i = 0; i < getNumChildren(); i++) getChild(i)->traverse(state); else if (which < getNumChildren()) getChild(which)->traverse(state); indent--; } void QvTransformSeparator::traverse(QvState *state) { announce("QvTransformSeparator" ) ; QvElement *markerElt = new QvElement; markerElt->data = this; markerElt->type = QvElement::NoOpTransform; state->addElement(QvState::TransformationIndex, markerElt); indent++; for (int i = 0; i < getNumChildren(); i++) getChild(i)->traverse(state); indent--; while (state->getTopElement(QvState::TransformationIndex) != markerElt) state->popElement(QvState::TransformationIndex); } # 139 "QvTraverse.cpp" # 150 "QvTraverse.cpp" void QvCoordinate3::traverse(QvState *state) { announce("QvCoordinate3" ) ; QvElement *elt = new QvElement; elt->data = this; state->addElement(QvState::Coordinate3Index, elt); printf( "---------------------------------------\n" ); } void QvMaterial ::traverse(QvState *state) { announce("QvMaterial" ) ; QvElement *elt = new QvElement; elt->data = this; state->addElement(QvState:: MaterialIndex , elt); } void QvMaterialBinding ::traverse(QvState *state) { announce("QvMaterialBinding" ) ; QvElement *elt = new QvElement; elt->data = this; state->addElement(QvState:: MaterialBindingIndex , elt); } void QvNormal ::traverse(QvState *state) { announce("QvNormal" ) ; QvElement *elt = new QvElement; elt->data = this; state->addElement(QvState:: NormalIndex , elt); } void QvNormalBinding ::traverse(QvState *state) { announce("QvNormalBinding" ) ; QvElement *elt = new QvElement; elt->data = this; state->addElement(QvState:: NormalBindingIndex , elt); } void QvShapeHints ::traverse(QvState *state) { announce("QvShapeHints" ) ; QvElement *elt = new QvElement; elt->data = this; state->addElement(QvState:: ShapeHintsIndex , elt); } void QvTextureCoordinate2 ::traverse(QvState *state) { announce("QvTextureCoordinate2" ) ; QvElement *elt = new QvElement; elt->data = this; state->addElement(QvState:: TextureCoordinate2Index , elt); } void QvTexture2 ::traverse(QvState *state) { announce("QvTexture2" ) ; QvElement *elt = new QvElement; elt->data = this; state->addElement(QvState:: Texture2Index , elt); } void QvTexture2Transform ::traverse(QvState *state) { announce("QvTexture2Transform" ) ; QvElement *elt = new QvElement; elt->data = this; state->addElement(QvState:: Texture2TransformationIndex , elt); } void QvDirectionalLight ::traverse(QvState *state) { announce("QvDirectionalLight" ) ; QvElement *elt = new QvElement; elt->data = this; elt->type = QvElement:: DirectionalLight ; state->addElement(QvState:: LightIndex , elt); } void QvPointLight ::traverse(QvState *state) { announce("QvPointLight" ) ; QvElement *elt = new QvElement; elt->data = this; elt->type = QvElement:: PointLight ; state->addElement(QvState:: LightIndex , elt); } void QvSpotLight ::traverse(QvState *state) { announce("QvSpotLight" ) ; QvElement *elt = new QvElement; elt->data = this; elt->type = QvElement:: SpotLight ; state->addElement(QvState:: LightIndex , elt); } void QvOrthographicCamera ::traverse(QvState *state) { announce("QvOrthographicCamera" ) ; QvElement *elt = new QvElement; elt->data = this; elt->type = QvElement:: OrthographicCamera ; state->addElement(QvState:: CameraIndex , elt); } void QvPerspectiveCamera ::traverse(QvState *state) { announce("QvPerspectiveCamera" ) ; QvElement *elt = new QvElement; elt->data = this; elt->type = QvElement:: PerspectiveCamera ; state->addElement(QvState:: CameraIndex , elt); } void QvTransform ::traverse(QvState *state) { announce("QvTransform" ) ; QvElement *elt = new QvElement; elt->data = this; elt->type = QvElement:: Transform ; state->addElement(QvState:: TransformationIndex , elt); } void QvRotation ::traverse(QvState *state) { announce("QvRotation" ) ; QvElement *elt = new QvElement; elt->data = this; elt->type = QvElement:: Rotation ; state->addElement(QvState:: TransformationIndex , elt); } void QvMatrixTransform ::traverse(QvState *state) { announce("QvMatrixTransform" ) ; QvElement *elt = new QvElement; elt->data = this; elt->type = QvElement:: MatrixTransform ; state->addElement(QvState:: TransformationIndex , elt); } void QvTranslation ::traverse(QvState *state) { announce("QvTranslation" ) ; QvElement *elt = new QvElement; elt->data = this; elt->type = QvElement:: Translation ; state->addElement(QvState:: TransformationIndex , elt); } void QvScale ::traverse(QvState *state) { announce("QvScale" ) ; QvElement *elt = new QvElement; elt->data = this; elt->type = QvElement:: Scale ; state->addElement(QvState:: TransformationIndex , elt); } static void printProperties(QvState *state) { printf("--------------------------------------------------------------\n"); state->print(); printf("--------------------------------------------------------------\n"); } # 1 "../BspLib/BRep.h" 1 # 1 "../BspLib/Transform2.h" 1 namespace BspLib { class Transform2 { friend Transform2 operator *( const Transform2& trafo1, const Transform2& trafo2 ); public: Transform2(); Transform2( const float trafo[3][3] ); Transform2( const double trafo[3][3] ); ~Transform2() { } Vector2 TransformVector2( const Vector2& vec ) const; double Determinant(); int Inverse( Transform2& inverse ); Transform2& Concat( const Transform2& cattrafo ); Transform2& ConcatR( const Transform2& cattrafo ); Transform2& LoadIdentity(); Transform2& LoadRotation( double angle ); Transform2& LoadScale( double x, double y ); Transform2& LoadTranslation( double x, double y ); Transform2& Rotate( double angle ); Transform2& Scale( double x, double y ); Transform2& Translate( double x, double y ); Transform2& RotateR( double angle ); Transform2& ScaleR( double x, double y ); Transform2& TranslateR( double x, double y ); Vector2 FetchTranslation() const; Vector2 ExtractTranslation(); double * LinMatrixAccess() { return (double *) m_matrix; } private: double m_matrix[3][3]; }; inline Transform2& Transform2::LoadIdentity() { memset( m_matrix, 0, sizeof( m_matrix ) ); m_matrix[ 0 ][ 0 ] = 1.0; m_matrix[ 1 ][ 1 ] = 1.0; m_matrix[ 2 ][ 2 ] = 1.0; return *this; } inline Transform2::Transform2() { } inline Transform2::Transform2( const double trafo[3][3] ) { memcpy( m_matrix, trafo, sizeof( m_matrix ) ); } inline Transform2::Transform2( const float trafo[3][3] ) { for ( int i = 0; i < 9; i++ ) ((double *)m_matrix)[ i ] = (double) ((float *)trafo)[ i ]; } } # 16 "../BspLib/BRep.h" 2 namespace BspLib { class BRep : public virtual SystemIO { public: BRep( QvState *state ); ~BRep() { } void BuildFromSpherePrimitive( const QvSphere& spherenode ); void BuildFromConePrimitive( const QvCone& spherenode ); void BuildFromCubePrimitive( const QvCube& spherenode ); void BuildFromCylinderPrimitive( const QvCylinder& spherenode ); void BuildFromIndexedFaceSet( const QvIndexedFaceSet& faceset ); public: static int getTriangulation() { return do_triangulation; } static void setTriangulation( int tri ) { do_triangulation = tri; } static int getTessellation() { return tessellation_slices; } static void setTessellation( int tes ) { tessellation_slices = tes; } static int getMaterialFlag() { return use_material_spec; } static void setMaterialFlag( int mfl ) { use_material_spec = mfl; } static int getMirrorTextureVFlag() { return mirror_v_axis; } static void setMirrorTextureVFlag( int mtv ) { mirror_v_axis = mtv; } private: float* FetchCoordinate3State( int &num ); float* FetchTextureCoordinate2State( int &num ); float* FetchNormalState( int &num ); void FetchTransformationState( Transform3& trafo ); void FetchTextureTransformationState( Transform2& trafo ); int FetchMaterialState( Material& mat, int indx ); void FetchMaterialBindingState( int& binding ); void FetchNormalBindingState( int& binding ); void FetchShapeHintsState(); Texture* CheckTexture2State(); void CreateIndexedFace( Texture *texture, int curindex, int numtexindexs, long *texindexs, int v1, int v2, int v3 ); void PostProcessObject(); private: static int shapehint_vertexOrdering; static int shapehint_shapeType; static int shapehint_faceType; static float shapehint_creaseAngle; static int use_material_spec; static int mirror_v_axis; static int do_triangulation; static int tessellation_slices; private: QvState* m_state; BspObject* m_baseobject; }; } # 239 "QvTraverse.cpp" 2 void QvSphere::traverse(QvState *state) { announce("QvSphere" ) ; BspLib ::BRep brep( state ); brep.BuildFromSpherePrimitive( *this ); } void QvCone::traverse(QvState *state) { announce("QvCone" ) ; BspLib ::BRep brep( state ); brep.BuildFromConePrimitive( *this ); } void QvCube::traverse(QvState *state) { announce("QvCube" ) ; BspLib ::BRep brep( state ); brep.BuildFromCubePrimitive( *this ); } void QvCylinder::traverse(QvState *state) { announce("QvCylinder" ) ; BspLib ::BRep brep( state ); brep.BuildFromCylinderPrimitive( *this ); } void QvIndexedFaceSet::traverse(QvState *state) { announce("QvIndexedFaceSet" ) ; BspLib ::BRep brep( state ); brep.BuildFromIndexedFaceSet( *this ); } void QvIndexedLineSet ::traverse(QvState *state) { announce("QvIndexedLineSet" ) ; printProperties(state); } void QvPointSet ::traverse(QvState *state) { announce("QvPointSet" ) ; printProperties(state); } void QvWWWAnchor ::traverse(QvState *) { announce("QvWWWAnchor" ) ; } void QvWWWInline ::traverse(QvState *) { announce("QvWWWInline" ) ; } void QvInfo ::traverse(QvState *) { announce("QvInfo" ) ; } void QvUnknownNode ::traverse(QvState *) { announce("QvUnknownNode" ) ; }