home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / modelers / geomview / source.lha / Geomview / src / lib / shade / appearance.c next >
Encoding:
C/C++ Source or Header  |  1993-10-16  |  24.2 KB  |  1,023 lines
  1. /* Copyright (c) 1992 The Geometry Center; University of Minnesota
  2.    1300 South Second Street;  Minneapolis, MN  55454, USA;
  3.    
  4. This file is part of geomview/OOGL. geomview/OOGL is free software;
  5. you can redistribute it and/or modify it only under the terms given in
  6. the file COPYING, which you should have received along with this file.
  7. This and other related software may be obtained via anonymous ftp from
  8. geom.umn.edu; email: software@geom.umn.edu. */
  9. static char *copyright = "Copyright (C) 1992 The Geometry Center";
  10.  
  11. /* Authors: Charlie Gunn, Stuart Levy, Tamara Munzner, Mark Phillips */
  12.  
  13. #include "appearance.h"
  14.  
  15. #define MAXSHININESS 1024.0
  16.  
  17. extern LmLighting * _LmSet(LmLighting *, int attr1, va_list *); /* Forward */
  18. Appearance *ApLoad(Appearance *into, char *fname);
  19. Material * _MtSet(Material *, int attr1, va_list *);    /* Forward */
  20.  
  21. Appearance *
  22. _ApSet(Appearance *ap, int attr1, register va_list *alist)
  23. {
  24.     long mask;
  25.     Color *co;
  26.     int attr;
  27.     char **ablock = NULL;
  28.  
  29. #define NEXT(type) OOGL_VA_ARG(type,alist,ablock)
  30.     
  31.     if (ap == NULL) {
  32.         /*
  33.          * New Appearance created here.
  34.          */
  35.     ap = OOGLNewE(Appearance, "ApCreate Appearance");
  36.     ApDefault(ap);
  37.     }
  38.  
  39.     for ( attr = attr1; attr != AP_END; attr = NEXT(int)) {
  40.     switch (attr) { /* parse argument list */
  41.       case AP_ABLOCK:
  42.         ablock = NEXT(char **);
  43.         break;
  44.       case AP_DO:
  45.         mask = NEXT(int);
  46.         ap->flag |= mask;
  47.         ap->valid |= mask;
  48.         break;
  49.       case AP_DONT:
  50.         mask = NEXT(int);
  51.         ap->flag &= ~mask;
  52.         ap->valid |= mask;
  53.         break;
  54.       case AP_INVALID:
  55.         ap->valid &= ~NEXT(int);
  56.         break;
  57.       case AP_OVERRIDE:
  58.         ap->override |= NEXT(int);
  59.         break;
  60.       case AP_NOOVERRIDE:
  61.         ap->override &= ~NEXT(int);
  62.         break;
  63.       case AP_MAT:
  64.         ap->mat = NEXT(Material*);
  65.         break;
  66.       case AP_MtSet:
  67.         ap->mat = ablock ? MtSet(ap->mat, MT_ABLOCK, ablock)
  68.           : _MtSet(ap->mat, va_arg(*alist, int), alist);
  69.         break;
  70.       case AP_LGT:
  71.         ap->lighting = NEXT(LmLighting*);
  72.         break;
  73.       case AP_LmSet:
  74.         if (!ap->lighting) ap->lighting = LmCreate(LM_END);
  75.         ap->lighting = ablock ? LmSet(ap->lighting, LM_ABLOCK, ablock)
  76.           : _LmSet(ap->lighting, va_arg(*alist, int), alist);
  77.         break;
  78.       case AP_NORMSCALE:
  79.         ap->nscale = NEXT(double);
  80.         ap->valid |= APF_NORMSCALE;
  81.         break;
  82.       case AP_LINEWIDTH:
  83.         ap->linewidth = NEXT(int);
  84.         ap->valid |= APF_LINEWIDTH;
  85.         break;
  86.       case AP_SHADING:
  87.         /* should be APF_{CONSTANT,FLAT,SMOOTH} */
  88.         ap->shading = NEXT(int);
  89.         ap->valid |= APF_SHADING;
  90.         break;
  91.       default:
  92.         OOGLError (0, "_ApSet: undefined option: %d\n", attr);
  93.         return NULL;
  94.         break; 
  95.     }
  96.     }
  97.     return ap;
  98.  
  99. #undef NEXT
  100. }
  101.  
  102.  
  103. Appearance *
  104. ApCreate(int a1, ...)
  105. {
  106.     va_list alist;
  107.     Appearance *ap;
  108.  
  109.     va_start(alist,a1);
  110.     ap = _ApSet(NULL, a1, &alist);
  111.     va_end(alist);
  112.     return ap;
  113. }
  114.  
  115.  
  116. Appearance *
  117. ApSet(Appearance *ap, int a1, ... )
  118. {
  119.     va_list alist;
  120.     va_start(alist,a1);
  121.     ap = _ApSet(ap, a1, &alist);
  122.     va_end(alist);
  123.     return ap;
  124. }
  125.  
  126. int
  127. ApGet(Appearance *ap, int attr, void *value)
  128. {
  129.     if (!ap) return -1;
  130.  
  131.     switch (attr) {
  132.       case AP_DO:
  133.       case AP_DONT:    *(int *) value =  ap->flag; break;
  134.       case AP_OVERRIDE:
  135.       case AP_NOOVERRIDE: *(int *) value = ap->override; break;
  136.       case AP_VALID:
  137.       case AP_INVALID:    *(int *) value = ap->valid; break;
  138.       case AP_MAT:    *(Material **) value = ap->mat; break;
  139.       case AP_LGT:    *(LmLighting **) value = ap->lighting; break;
  140.       case AP_NORMSCALE: *(double *) value = ap->nscale; break;
  141.       case AP_LINEWIDTH: *(int *) value = ap->linewidth; break;
  142.       case AP_SHADING:    *(int *)value = ap->shading; break;
  143.       default:
  144.     OOGLError (0, "ApGet: undefined option: %d\n", attr);
  145.     return -1;
  146.     break; 
  147.     }
  148.     return attr;
  149. }
  150.  
  151. void
  152. ApDelete(Appearance *ap)
  153. {
  154.     if(ap == NULL || RefDecr((Ref *)ap) > 0)
  155.     return;
  156.     if (ap->mat) MtDelete(ap->mat);
  157.     if (ap->lighting) LmDelete(ap->lighting);
  158.     OOGLFree(ap);
  159. }
  160.  
  161. /*
  162.  * Copies just the Appearance part, not its Material and LmLighting children.
  163.  * Pointers to the latter are retained BUT their reference counts are NOT
  164.  * incremented.  The caller MUST either RefIncr() or reassign mat and lighting.
  165.  */
  166. Appearance *
  167. ApCopyShallow( Appearance *ap, register Appearance *into )
  168. {
  169.     if(ap == NULL)
  170.     return NULL;
  171.     if(into == NULL) {
  172.     into = OOGLNewE(Appearance, "ApCopy: Appearance");
  173.     *into = *ap;
  174.     into->mat = NULL;
  175.     into->backmat = NULL;
  176.     into->lighting = NULL;
  177.     RefInit((Ref *)into, APMAGIC);
  178.     } else {
  179.     into->flag = ap->flag;
  180.     into->valid = ap->valid;
  181.     into->override = ap->override;
  182.     into->nscale = ap->nscale;
  183.     into->linewidth = ap->linewidth;
  184.     into->shading = ap->shading;
  185.     }
  186.     return into;
  187. }
  188.     
  189. Appearance *
  190. ApCopy( Appearance *ap, register Appearance *into )
  191. {
  192.     if (ap == NULL) return into;
  193.     into = ApCopyShallow( ap, into );
  194.     if(ap->mat) into->mat = MtCopy(ap->mat, into->mat);
  195.     if(ap->backmat) into->backmat = MtCopy(ap->backmat, into->backmat);
  196.     if(ap->lighting) into->lighting = LmCopy(ap->lighting, into->lighting);
  197.     return into;
  198. }
  199.  
  200. /*
  201.  * Merges appearance properties of src into dst.
  202.  * If "inplace" is true, data are modified in place.
  203.  * Otherwise if any modifications are needed to dst, a copy is made & returned.
  204.  * If no modifications are necessary, the returned Appearance's reference
  205.  * count is still incremented.
  206.  * Thus, in all cases, the caller should ApDelete() the returned value
  207.  * when finished with it.
  208.  */
  209. Appearance *
  210. ApMerge( register Appearance *src, register Appearance *dst, int mergeflags )
  211. {
  212.     int mask;
  213.     Material *mt, *oldmt, *bmt, *oldbmt;
  214.     LmLighting *lts, *oldlts;
  215.  
  216.  
  217.     if(dst == NULL)
  218.     return ApCopy(src, NULL);
  219.  
  220.     if(src == NULL) {
  221.     RefIncr((Ref *)dst);
  222.     return dst;
  223.     }
  224.     /* Mask of fields to copy to dst */
  225.     mask = (mergeflags & APF_OVEROVERRIDE) ? src->valid :
  226.                 src->valid &~ ( dst->override &~ src->override);
  227.  
  228.     mt = MtMerge(src->mat, dst->mat, mergeflags);
  229.     bmt = MtMerge(src->backmat, dst->backmat, mergeflags);
  230.     lts = LmMerge(src->lighting, dst->lighting, mergeflags);
  231.     if((mergeflags & APF_INPLACE)
  232.          || (mask == 0 && mt == dst->mat &&
  233.             lts == dst->lighting && bmt == dst->backmat)) {
  234.     /*
  235.      * No changes, or we're asked to merge in place.  Bump ref count.
  236.      */
  237.     RefIncr((Ref *)dst);
  238.     } else {
  239.     /*
  240.      * Another special case: Copy appearance, don't copy the items already
  241.      * copied by {Mt,Lm}Merge.  We're about to overwrite these values, so
  242.      * toss the old ones.  Pretty kludgy, but what can we do?
  243.      */
  244.     dst = ApCopyShallow(dst, NULL);
  245.     }
  246.     if(mt != dst->mat) MtDelete(dst->mat);
  247.     if(bmt != dst->backmat) MtDelete(dst->backmat);
  248.     if(lts != dst->lighting) LmDelete(dst->lighting);
  249.  
  250.     dst->mat = mt;
  251.     dst->backmat = bmt;
  252.     dst->lighting = lts;
  253.     if(mask) {
  254.     /* Merge together appearance-specific data */
  255.     dst->flag = (src->flag & mask) | (dst->flag & ~mask);
  256.     dst->valid = (src->valid & mask) | (dst->valid & ~mask);
  257.     dst->override = (src->override & mask) | (dst->override & ~mask);
  258.     if(mask & APF_NORMSCALE) dst->nscale = src->nscale;
  259.     if(mask & APF_LINEWIDTH) dst->linewidth = src->linewidth;
  260.     if(mask & APF_SHADING) dst->shading = src->shading;
  261.     }
  262.     return dst;
  263. }
  264.  
  265. static struct {
  266.     char *word;
  267.     unsigned short amask;
  268.     unsigned short aval;
  269. } ap_kw[] = {
  270.     { "appearance",    0,        1 },
  271.     { "face",    APF_FACEDRAW,    0 },
  272.     { "edge",    APF_EDGEDRAW,    0 },
  273.     { "vect",    APF_VECTDRAW,    0 },
  274.     { "transparent", APF_TRANSP,    0 },
  275.     { "evert",    APF_EVERT,    0 },
  276.     { "shading",    APF_SHADING,    2 },
  277.     { "smooth",    APF_SHADING,    AP_SHADING + APF_SMOOTH },
  278.     { "flat",    APF_SHADING,    AP_SHADING + APF_FLAT },
  279.     { "constant",    APF_SHADING,    AP_SHADING + APF_CONSTANT },
  280.     { "csmooth",    APF_SHADING,    AP_SHADING + APF_CSMOOTH },
  281.     { "normal",    APF_NORMALDRAW,    0 },
  282.     { "normscale",    APF_NORMSCALE,  3 },
  283.     { "linewidth",    APF_LINEWIDTH,    4 },
  284.     { "material",    0,        5 },
  285.     { "backmaterial", 0,        7 },
  286.     { "light",    0,        6 },
  287.     { "lighting",    0,        6 },
  288. };
  289.  
  290. Appearance *
  291. ApFLoad( Appearance *into, FILE *stream, char *fname )
  292. {
  293.     register Appearance *ap;
  294.     char *w;
  295.     int i;
  296.     int any = 0;
  297.     int brack = 0;
  298.     int over, not, value;
  299.     int mask, flagmask;
  300.     int more;
  301.     int mine = 1;    /* Questionable -- we'll report all errors */
  302.  
  303.     ap = into;
  304.  
  305.     over = not = 0;  value = ~0;
  306.     more = 0;
  307.     do {
  308.     (void) fnextc(stream, 0);
  309.  
  310.     switch(i = fgetc(stream)) {
  311.     case '<': ap = ApLoad(ap, fdelimtok("{}()", stream, 0)); break;
  312.     case EOF: brack = 0; break;
  313.     case '{': brack++; break;
  314.     case '}': if(brack-- <= 0) { ungetc(i, stream); } break;
  315.     case '+': value = ~0; break;
  316.     case '-': value = 0; break;
  317.     case '!': not = 1; break;
  318.     case '*': over = 1; break;
  319.  
  320.     default:
  321.         more = 0;
  322.         ungetc(i, stream);
  323.         w = fdelimtok("{}()", stream, 0);
  324.         if(w == NULL)
  325.         break;
  326.         for(i = sizeof(ap_kw)/sizeof(ap_kw[0]); --i >= 0; )
  327.         if(!strcmp(ap_kw[i].word, w))
  328.             break;
  329.         
  330.         if(i < 0) {
  331.         if(mine)
  332.             OOGLError(1,
  333.             "ApFLoad: file %s: unknown appearance keyword %s", 
  334.             fname, w);
  335.         return NULL;
  336.         }
  337.         if(ap == NULL)
  338.         ap = ApCreate(AP_END);
  339.  
  340.         mask = flagmask = ap_kw[i].amask;
  341.         if(not) {
  342.         switch(ap_kw[i].aval) {
  343.             case 5: MtDelete(ap->mat); ap->mat = NULL; break;
  344.             case 6: LmDelete(ap->lighting); ap->lighting = NULL; break;
  345.         }
  346.         ap->flag &= ~mask;
  347.         if(!over) ap->valid &= ~mask;
  348.         ap->override &= ~mask;
  349.         } else {
  350.         switch(ap_kw[i].aval) {
  351.         case 0: break;
  352.         case 1: mine = more = 1; break;
  353.         case 2: fgetni(stream, 1, &ap->shading, 0); break;
  354.         case 3:
  355.             if(fgetnf(stream, 1, &ap->nscale, 0) <= 0)
  356.             OOGLError(1,"ApFLoad: %s: \"normscale\": value expected",
  357.                 fname);
  358.             break;
  359.         case 4:
  360.             if(fgetni(stream, 1, &ap->linewidth, 0) <= 0)
  361.             OOGLSyntax(stream, "%s \"linewidth\": value expected",
  362.                 fname);
  363.             break;
  364.         case 5:
  365.             if((ap->mat = MtFLoad(ap->mat, stream, fname)) == NULL)
  366.             OOGLSyntax(stream,"Can't read material in %s",
  367.                 fname);
  368.             break;
  369.         case 7:
  370.             if((ap->backmat = MtFLoad(ap->backmat, stream, fname)) == NULL)
  371.             OOGLError(1,"Can't read backmaterial, file %s",
  372.                 fname);
  373.             break;
  374.         case 6:
  375.             ap->lighting = LmFLoad(ap->lighting, stream, fname);
  376.             if(ap->lighting == NULL)
  377.             OOGLError(1,"Can't read lighting, file %s",
  378.                 fname);
  379.             break;
  380.         default:
  381.             if(ap_kw[i].aval >= AP_SHADING)
  382.             ap->shading = ap_kw[i].aval - AP_SHADING;
  383.         }
  384.         if(value) ap->flag |= flagmask;
  385.         else ap->flag &= ~flagmask;
  386.         ap->valid |= mask;
  387.         if(over) ap->override |= mask;
  388.         }
  389.         /* Reset for next keyword */
  390.         over = not = 0;  value = ~0;
  391.  
  392.     }
  393.     } while(brack > 0 || more);
  394.     return ap;
  395. }
  396.  
  397. Appearance *
  398. ApLoad(Appearance *into, char *fname)
  399. {
  400.     FILE *f = fopen(fname, "r");
  401.     Appearance *a;
  402.  
  403.     if(f == NULL) {
  404.     OOGLError(0, "ApLoad: can't open %s: %s", fname, sperror());
  405.     return NULL;
  406.     }
  407.     a = ApFLoad(into, f, fname);
  408.     fclose(f);
  409.     return a;
  410. }
  411.  
  412.  
  413. void ApFSave( Appearance *ap, Handle *aphandle, FILE *f, char *fname )
  414. {
  415.     int valid;
  416.     int mask;
  417.     register int i;
  418.  
  419.     if(ap == NULL)
  420.     return;
  421.  
  422.     valid = ap->valid;
  423.     fprintf(f, "appearance {\n");
  424.  
  425.     for(i = 0; i < sizeof(ap_kw)/sizeof(ap_kw[0]); i++) {
  426.     mask = ap_kw[i].amask;
  427.     if((valid & mask) == 0)
  428.         continue;
  429.     Apsavepfx(valid, ap->override, mask, "", f);
  430.     if(ap_kw[i].aval == 0) {
  431.         if((mask & ap->flag) == 0)
  432.         fputc('-', f);
  433.         fputs(ap_kw[i].word, f);
  434.     }
  435.     valid &= ~mask;
  436.     switch(mask) {
  437.     case APF_SHADING:
  438.         fputs(" shading ", f);
  439.         switch(ap->shading) {
  440.         case APF_SMOOTH:    fputs("smooth", f);    break;
  441.         case APF_FLAT:    fputs("flat", f);    break;
  442.         case APF_CONSTANT:    fputs("constant", f);    break;
  443.         case APF_CSMOOTH:   fputs("csmooth", f);    break;
  444.         default:        fprintf(f, "%d", ap->shading); break;
  445.         }
  446.         break;
  447.     case APF_NORMSCALE:
  448.         fprintf(f, "  normscale %g", ap->nscale);
  449.         break;
  450.     case APF_LINEWIDTH:
  451.         fprintf(f, "  linewidth %d ", ap->linewidth);
  452.         break;
  453.     }
  454.     fputc('\n', f);
  455.     }
  456.  
  457.     if(ap->mat) {
  458.     fprintf(f, "  material {\n");
  459.     MtFSave(ap->mat, f);
  460.     fprintf(f, "  }\n");
  461.     }
  462.     if(ap->backmat) {
  463.     fprintf(f, "  backmaterial {\n");
  464.     MtFSave(ap->backmat, f);
  465.     fprintf(f, "  }\n");
  466.     }
  467.     if(ap->lighting) {
  468.     fprintf(f, "  lighting {\n");
  469.     LmFSave(ap->lighting, f, fname);
  470.     fprintf(f, "  }\n");
  471.     }
  472.     fprintf(f, "}\n");
  473.     return;
  474. }
  475.  
  476. ApSave(Appearance *ap, char *fname)
  477. {
  478.     FILE *f = fname == NULL ? stdout : fopen(fname, "w");
  479.  
  480.     if(f) {
  481.     ApFSave(ap, NULL, f, fname);
  482.     if(fname != NULL)
  483.         fclose(f);
  484.     }
  485. }
  486.  
  487. Material *
  488. _MtSet(Material *mat, int attr1, va_list *alist)
  489. {
  490.     Color *co;
  491.     long mask;
  492.     int attr;
  493.     char **ablock = NULL;
  494.  
  495. #define NEXT(type) OOGL_VA_ARG(type,alist,ablock)
  496.     
  497.     if (mat == NULL) {
  498.         /*
  499.          * New Material created here.
  500.          */
  501.     mat = OOGLNewE(Material, "new Material"); 
  502.     MtDefault(mat);
  503.     }
  504.  
  505.     for(attr = attr1; attr != MT_END; attr = NEXT(int)) {
  506.       switch (attr) { /* parse argument list */
  507.       case MT_ABLOCK:
  508.     ablock = NEXT(char**);
  509.     break;
  510.       case MT_AMBIENT:
  511.     co = NEXT(Color *);
  512.     CoCopy(co, &mat->ambient);
  513.     mat->valid |= MTF_AMBIENT;
  514.     break;
  515.       case MT_DIFFUSE:
  516.     co = NEXT(Color *);
  517.     CoCopy(co, &mat->diffuse);
  518.     mat->valid |= MTF_DIFFUSE;
  519.     break;
  520.       case MT_SPECULAR:
  521.     co = NEXT(Color *);
  522.     CoCopy(co, &mat->specular);
  523.     mat->valid |= MTF_SPECULAR;
  524.     break;
  525.       case MT_EMISSION:
  526.     co = NEXT(Color *);
  527.     CoCopy(co, &mat->emission);
  528.     mat->valid |= MTF_EMISSION;
  529.     break;
  530.       case MT_ALPHA: 
  531.     mat->alpha = NEXT(double);
  532.     mat->valid |= MTF_ALPHA;
  533.     break;
  534.       case MT_Ka: 
  535.     mat->ka = NEXT(double);
  536.     mat->valid |= MTF_Ka;
  537.     break;
  538.       case MT_Kd: 
  539.     mat->kd = NEXT(double);
  540.     mat->valid |= MTF_Kd;
  541.     break;
  542.       case MT_Ks: 
  543.     mat->ks = NEXT(double);
  544.     mat->valid |= MTF_Ks;
  545.     break;
  546.       case MT_SHININESS: 
  547.     mat->shininess = NEXT(double);
  548.     mat->valid |= MTF_SHININESS;
  549.     break;
  550.       case MT_EDGECOLOR:
  551.     CoCopy(NEXT(Color *), &mat->edgecolor);
  552.     mat->valid |= MTF_EDGECOLOR;
  553.     break;
  554.       case MT_NORMALCOLOR:
  555.     CoCopy(NEXT(Color *), &mat->normalcolor);
  556.     mat->valid |= MTF_NORMALCOLOR;
  557.     break;
  558.       case MT_INVALID:
  559.     mat->valid &= ~NEXT(int);
  560.     break;
  561.       case MT_OVERRIDE:
  562.     mat->override |= NEXT(int);
  563.     break;
  564.       case MT_NOOVERRIDE:
  565.     mat->override &= ~NEXT(int);
  566.     break;
  567.       default:
  568.     OOGLError (0, "_MtSet: undefined option: %d\n", attr);
  569.     return NULL;
  570.     break; 
  571.       }
  572.     }
  573.  
  574.     return mat;
  575.  
  576. #undef NEXT
  577. }
  578.  
  579. Material *
  580. MtCreate(int a1, ... )
  581. {
  582.     va_list alist;
  583.     Material *mat;
  584.  
  585.     va_start(alist,a1);
  586.     mat = _MtSet(NULL, a1, &alist);
  587.     va_end(alist);
  588.     return mat;
  589. }
  590.  
  591. Material *
  592. MtSet(Material *mat, int attr, ... )
  593. {
  594.     va_list alist;
  595.     
  596.     va_start(alist,attr);
  597.     mat = _MtSet(mat,attr,&alist);
  598.     va_end(alist);
  599.     return mat;
  600. }
  601.  
  602. int
  603. MtGet(register Material *mat, int attr, void * value)
  604. {
  605.     if (mat == NULL)
  606.     return -1;
  607.  
  608.     switch (attr) {
  609.       case MT_AMBIENT:
  610.     *(Color *) value = mat->ambient;
  611.     break;
  612.       case MT_DIFFUSE:
  613.     *(Color *) value = mat->diffuse;
  614.     break;
  615.       case MT_SPECULAR:
  616.     *(Color *) value = mat->specular;
  617.     break;
  618.       case MT_EMISSION:
  619.     *(Color *) value = mat->emission;
  620.     break;
  621.       case MT_ALPHA: 
  622.     *(double *) value = mat->alpha;
  623.     break;
  624.       case MT_Ka: 
  625.     *(double *) value = mat->ka;
  626.     break;
  627.       case MT_Kd: 
  628.     *(double *) value = mat->kd;
  629.     break;
  630.       case MT_Ks: 
  631.     *(double *) value = mat->ks;
  632.     break;
  633.       case MT_SHININESS: 
  634.     *(double *) value = mat->shininess;
  635.     break;
  636.       case MT_EDGECOLOR:
  637.     *(Color *)value = mat->edgecolor;
  638.     break;
  639.       case MT_NORMALCOLOR:
  640.     *(Color *)value = mat->normalcolor;
  641.     break;
  642.       case MT_OVERRIDE:
  643.       case MT_NOOVERRIDE:
  644.     *(int *) value = mat->override;
  645.     break;
  646.       case MT_VALID:
  647.       case MT_INVALID:
  648.     *(int *) value = mat->valid;
  649.     break;
  650.       default:
  651.     OOGLError (0, "MtGet: undefined option: %d\n", attr);
  652.     return -1;    
  653.     break; 
  654.     }
  655.     
  656.     return 1;
  657. }
  658.  
  659. void
  660. MtDelete(Material *mat)
  661. {
  662.     if(mat && RefDecr((Ref *)mat) <= 0) {
  663.     mat->magic = -1;
  664.     OOGLFree(mat);
  665.     }
  666. }
  667.  
  668. Material *
  669. MtDefault( Material *mat )
  670. {
  671.   bzero(mat, sizeof(Material));
  672.   RefInit((Ref *)mat, MATMAGIC);
  673.   mat->valid = mat->override = 0;
  674.   mat->alpha = 1.0;
  675.   mat->Private = 0;
  676.   mat->changed = 1;
  677. }
  678.  
  679.  
  680. Material *
  681. MtCopy( Material *src, Material *dst )
  682. {
  683.   if (!src) return NULL;
  684.     if(dst == NULL)
  685.       dst = OOGLNewE(Material, "MtCopy: Material");
  686.     *dst = *src;    
  687.     dst->Private = 0;
  688.     RefInit((Ref *)dst, MATMAGIC);
  689.     dst->changed = 1;
  690.     return dst;
  691. }
  692.  
  693. #define max(a,b) (a)>(b)?(a):(b)
  694.  
  695. static
  696. norm( color, coeff )
  697.     Color *color;
  698.     float *coeff;
  699. {
  700.     *coeff = max(color->r, color->g);
  701.     *coeff = max(color->b, *coeff);
  702.  
  703.     if( *coeff != 0.0 ) {
  704.     color->r /= *coeff;
  705.     color->g /= *coeff;
  706.     color->b /= *coeff;
  707.     }
  708. }
  709.  
  710. Material *
  711. MtLoad(mat, name)
  712.     Material *mat;
  713.     char *name;
  714. {
  715.     FILE *f = fopen(name,"r");
  716.  
  717.     if(f == NULL) {
  718.     OOGLError(0, "MtLoad: can't open %s: %s", name, sperror());
  719.     return NULL;
  720.     }
  721.     mat = MtFLoad(mat, f, name);
  722.     fclose(f);
  723.     return mat;
  724. }
  725.  
  726. /*
  727.  * Load Material from file.
  728.  * Syntax:
  729.  *    < "filename_containing_material"    [or]
  730.  *    {   keyword  value   keyword  value   ...  }
  731.  *
  732.  *   Each keyword may be prefixed by "*", indicating that its value should
  733.  *   override corresponding settings in child objects.  [By default,
  734.  *   children's appearance values supercede those of their parents.]
  735.  *
  736.  *  Note: don't overwrite ka, kd, ks if they're already set when we read in 
  737.  *        the corresponding color.
  738.  */
  739. static char *mt_kw[] = {
  740.   "shininess",    "ka",        "kd",        "ks",        "alpha",
  741.   "emission",    "ambient",    "diffuse",    "specular",
  742.   "edgecolor",    "normalcolor",    "material"
  743. };
  744. static unsigned short mt_flags[] = {
  745.   MTF_SHININESS,  MTF_Ka,    MTF_Kd,        MTF_Ks,        MTF_ALPHA,
  746.   MTF_EMISSION,   MTF_AMBIENT, MTF_DIFFUSE, MTF_SPECULAR,
  747.   MTF_EDGECOLOR, MTF_NORMALCOLOR, 0
  748. };
  749. static char mt_args[] = { 1,1,1,1,1,  3,3,3,3,3,3, 0 };
  750.  
  751. Material *
  752. MtFLoad(mat, f, fname)
  753.     Material *mat;
  754.     FILE *f;
  755.     char *fname;    /* Used for error msgs, may be NULL */
  756. {
  757.     char *w;
  758.     register int i;
  759.     float v[3];
  760.     int brack = 0;
  761.     int over, not;
  762.     int got;
  763.     Material m;
  764.  
  765.     MtDefault(&m);
  766.  
  767.     over = not = 0;
  768.     for(;;) {
  769.     switch(fnextc(f, 0)) {
  770.     case '<':
  771.         fgetc(f);
  772.         if(MtLoad(&m, fdelimtok("{}()", f, 0)) == NULL) return NULL;
  773.         if(!brack) goto done;
  774.         break;
  775.     case '{': brack++; fgetc(f); break;
  776.     case '}': if(brack) { fgetc(f); } goto done;
  777.     case '*': over = 1; fgetc(f); break;        /* 'override' prefix */
  778.     case '!': not = 1; fgetc(f); break;
  779.     default:
  780.         w = fdelimtok("{}()", f, 0);
  781.         if(w == NULL)
  782.         return MtCopy(&m, mat);
  783.         /* break;    */                /* done */
  784.  
  785.         for(i = sizeof(mt_kw)/sizeof(mt_kw[0]); --i >= 0; )
  786.         if(!strcmp(w, mt_kw[i]))
  787.             break;
  788.  
  789.         if( i < 0) {
  790.         OOGLError(1, "MtFLoad: %s: unknown material keyword %s",fname,w);
  791.         return NULL;
  792.         } else if( !not && (got=fgetnf(f, mt_args[i], v, 0)) != mt_args[i] ) {
  793.         OOGLError(1, "MtFLoad: %s: \"%s\" expects %d values, got %d",
  794.             fname, w, mt_args[i], got);
  795.         return NULL;
  796.         }
  797.  
  798.         if(not) {
  799.         if(!over) m.valid &= ~mt_flags[i];
  800.         m.override &= ~mt_flags[i];
  801.         } else {
  802.         switch(i) {
  803.         case 0: m.shininess = v[0]; break;
  804.         case 1: m.ka = v[0]; break;
  805.         case 2: m.kd = v[0]; break;
  806.         case 3: m.ks = v[0]; break;
  807.         case 4: m.alpha = v[0]; break;
  808.         case 5: m.emission = *(Color *)v; break;
  809.         case 6: m.ambient = *(Color *)v; break;
  810.         case 7: m.diffuse = *(Color *)v; break;
  811.         case 8: m.specular = *(Color *)v; break;
  812.         case 9: m.edgecolor = *(Color *)v; break;
  813.         case 10: m.normalcolor = *(Color *)v; break;
  814.         }
  815.         m.valid |= mt_flags[i];
  816.         if(over) m.override |= mt_flags[i];
  817.         }
  818.         over = not = 0;
  819.     }
  820.     }
  821.   done:
  822.     return MtCopy(&m, mat);
  823. }
  824.  
  825. /*
  826.  * MtMerge(src, dst, mergeflags)
  827.  * Merge Material values:  src into dst, controlled by flag.
  828.  * If "inplace" is true, changes are made in dst itself; otherwise,
  829.  * the dst material is copied if any changes need be made to it.
  830.  * The returned Material's reference count is incremented as appropriate;
  831.  * thus the caller should MtDelete() the returned Material when done.
  832.  */
  833. Material *
  834. MtMerge(Material *src, Material *dst, int mergeflags)
  835. {
  836.     register int mask;
  837.  
  838.     if(dst == NULL)
  839.     return MtCopy(src, NULL);
  840.  
  841.     /* Fields to merge in */
  842.     mask = src ?
  843.     (mergeflags & APF_OVEROVERRIDE) ?
  844.         src->valid : src->valid & ~(dst->override &~ src->override)
  845.     : 0;
  846.  
  847.     if(mergeflags & APF_INPLACE)
  848.     RefIncr((Ref *)dst);
  849.     else
  850.     dst = MtCopy(dst, NULL);
  851.  
  852.     if(mask == 0)            /* No changes to dst */
  853.     return dst;
  854.  
  855.     dst->changed |= src->changed;
  856.     dst->valid = (src->valid & mask) | (dst->valid & ~mask);
  857.     dst->override = (src->override & mask) | (dst->override & ~mask);
  858.     if(mask & MTF_EMISSION) dst->emission = src->emission;
  859.     if(mask & MTF_AMBIENT) dst->ambient = src->ambient;
  860.     if(mask & MTF_DIFFUSE) dst->diffuse = src->diffuse;
  861.     if(mask & MTF_SPECULAR) dst->specular = src->specular;
  862.     if(mask & MTF_Ka) dst->ka = src->ka;
  863.     if(mask & MTF_Kd) dst->kd = src->kd;
  864.     if(mask & MTF_Ks) dst->ks = src->ks;
  865.     if(mask & MTF_ALPHA) dst->alpha = src->alpha;
  866.     if(mask & MTF_SHININESS) dst->shininess = src->shininess;
  867.     if(mask & MTF_EDGECOLOR) dst->edgecolor = src->edgecolor;
  868.     if(mask & MTF_NORMALCOLOR) dst->normalcolor = src->normalcolor;
  869.     return dst;
  870. }
  871.  
  872. int
  873. MtSave(mat,name)
  874.     Material *mat;
  875.     char *name;
  876. {
  877.     FILE *f;
  878.     int ok;
  879.  
  880.     f = fopen(name,"w");
  881.     if(!f) {
  882.     perror(name);
  883.     return -1;
  884.     }
  885.     ok = MtFSave(mat, f);
  886.     fclose(f);
  887.     return ok;
  888. }
  889.  
  890. int
  891. Apsavepfx(valid, override, mask, keyword, f)
  892.     int valid, override, mask;
  893.     FILE *f;
  894. {
  895.     if((valid & mask) == 0)
  896.     return 0;
  897.     fputc('\t', f);
  898.     if(override & mask)
  899.     fputc('*', f);
  900.     fprintf(f, "%s ", keyword);
  901.     return 1;
  902. }
  903.  
  904.  
  905. int
  906. MtFSave(mat,f)
  907.     register Material *mat;
  908.     FILE *f;
  909. {
  910.     register int i;
  911.     float v;
  912.     Color *c;
  913.  
  914.     for(i = 0; i < sizeof(mt_kw)/sizeof(mt_kw[0]); i++) {
  915.     if(Apsavepfx(mat->valid, mat->override, mt_flags[i], mt_kw[i], f)) {
  916.       switch(mt_flags[i]) {
  917.         case MTF_Ka: v = mat->ka; goto pfloat;
  918.         case MTF_Kd: v = mat->kd; goto pfloat;
  919.         case MTF_Ks: v = mat->ks; goto pfloat;
  920.         case MTF_SHININESS: v = mat->shininess; goto pfloat;
  921.         case MTF_ALPHA: v = mat->alpha; goto pfloat;
  922.       pfloat:
  923.         fprintf(f, "%f\n", v);
  924.         break;
  925.  
  926.         case MTF_DIFFUSE: c = &mat->diffuse; goto pcolor;
  927.         case MTF_AMBIENT: c = &mat->ambient; goto pcolor;
  928.         case MTF_EMISSION: c = &mat->emission; goto pcolor;
  929.         case MTF_SPECULAR: c = &mat->specular; goto pcolor;
  930.         case MTF_EDGECOLOR: c = &mat->edgecolor; goto pcolor;
  931.         case MTF_NORMALCOLOR: c = &mat->normalcolor; goto pcolor;
  932.       pcolor:
  933.         fprintf(f, "%f %f %f\n", c->r, c->g, c->b);
  934.         break;
  935.       }
  936.     }
  937.     }
  938.     return ferror(f);
  939. }
  940.  
  941. void
  942. MtPrint(mat)
  943.     Material *mat;
  944. {
  945.     MtFSave(mat,stdout);
  946. }
  947.  
  948.  
  949. Material *
  950. MtPlastic( 
  951.     float Ka, float Kd, float Ks, float roughness,
  952.     Color *Ca, Color *Cd, Color *Cs )
  953. {
  954.     Material *mat;
  955.     static Color black = { 0.0, 0.0, 0.0 };
  956.     mat = MtCreate( MT_END );
  957.     mat->shininess = roughness < 1.0/MAXSHININESS ? 1.0/roughness : MAXSHININESS;
  958.     mat->ka = Ka;
  959.     mat->kd = Kd;
  960.     mat->ks = Ks;
  961.     mat->emission = black;
  962.     if (Ca) mat->ambient = *Ca;
  963.     if (Cd) mat->diffuse = *Cd;
  964.     if (Cs) mat->specular = *Cs;
  965.     return mat;
  966. }
  967.  
  968. Appearance *
  969. ApDefault(Appearance *ap)
  970. {
  971.   ap->valid = ap->override = 0;
  972.   bzero(ap, sizeof(Appearance));
  973.   RefInit((Ref *)ap, APMAGIC);
  974.   ap->mat = NULL;
  975.   ap->lighting = NULL;
  976.   return ap;
  977. }
  978.  
  979. void ApUseOverrides(Appearance *ap, int use_overrides)
  980. {
  981.   Material *mat;
  982.   if(ap == NULL) return;
  983.   ap->override = ap->valid & use_overrides;
  984.   if((mat = ap->mat) != NULL) {
  985.     mat->override = mat->valid & use_overrides;
  986.     mat->changed = 1;
  987.   }
  988.   if((mat = ap->backmat) != NULL) {
  989.     mat->override = mat->valid & use_overrides;
  990.     mat->changed = 1;
  991.   }
  992.   if(ap->lighting) {
  993.     ap->lighting->override = ap->lighting->valid & use_overrides;
  994.     ap->lighting->changed = 1;
  995.   }
  996. }
  997.  
  998. /*
  999.  * We assume dst is a child of src in the inheritance tree.
  1000.  * Erase all settings in dst that are defined in src,
  1001.  * so that src's settings can propagate to (the children of) dst.
  1002.  */
  1003. void ApLetPropagate(register Appearance *src, register Appearance *dst)
  1004. {
  1005.   if(src == NULL || dst == NULL) return;
  1006.   dst->valid &= ~src->valid;
  1007.   dst->override &= ~src->valid;
  1008.   if(dst->mat && src->mat) {
  1009.     dst->mat->valid &= ~src->mat->valid;
  1010.     dst->mat->override &= ~src->mat->valid;
  1011.     dst->mat->changed = 1;
  1012.   }
  1013.   if(dst->backmat && src->backmat) {
  1014.     dst->backmat->valid &= ~src->backmat->valid;
  1015.     dst->backmat->override &= ~src->backmat->valid;
  1016.     dst->backmat->changed = 1;
  1017.   }
  1018.   if(dst->lighting && src->lighting) {
  1019.     dst->lighting->valid &= ~src->lighting->valid;
  1020.     dst->lighting->override &= ~src->lighting->valid;
  1021.   }
  1022. }
  1023.