HDK: GR/GR_DisplayOption.h Source File

00001 /*
00002  * PROPRIETARY INFORMATION.  This software is proprietary to
00003  * Side Effects Software Inc., and is not to be reproduced,
00004  * transmitted, or disclosed in any way without written permission.
00005  *
00006  * Produced by:
00007  *      Dale Ducharme   
00008  *      Side Effects Software Inc.
00009  *      477 Richmond St. West
00010  *      Toronto, Ontario,  M5V 2M5 
00011  *      Canada
00012  *      416-504-9876
00013  *
00014  * NAME:        GR_DisplayOption.h
00015  *
00016  * COMMENTS:    Drawing options for the render library.  Authored by Mark.
00017  *
00018  */
00019 
00020 
00021 #ifndef __GR_DisplayOption_h__
00022 #define __GR_DisplayOption_h__
00023 
00024 #include "GR_API.h"
00025 #include <string.h>
00026 #include <UT/UT_Defines.h>
00027 #include <UT/UT_SymbolTable.h>
00028 #include <UT/UT_Color.h>
00029 #include <UT/UT_RefArray.h>
00030 #include <GEO/GEO_Point.h>
00031 #include <GEO/GEO_Primitive.h>
00032 #include <GB/GB_Group.h>
00033 #include "GR_Defines.h"
00034 #include "GR_CommonDispOption.h"
00035 
00036 class UT_Matrix4;
00037 
00038 #define COMMON_FLAG_ACCESSORS(METHOD) \
00039     bool        METHOD() const { return myCommonOptions->METHOD(); } \
00040     void        METHOD(bool onoff) { myCommonOptions->METHOD(onoff); }
00041 #define COMMON_OPTION_ACCESSORS(METHOD, TYPE) \
00042     TYPE        METHOD() const { return myCommonOptions->METHOD(); } \
00043     void        METHOD(TYPE val) { myCommonOptions->METHOD(val); }
00044 #define COMMON_OPTION_PREFIXED_ACCESSORS(METHOD, TYPE) \
00045     TYPE        get##METHOD() const { return myCommonOptions->get##METHOD(); } \
00046     void        set##METHOD(TYPE val) { myCommonOptions->set##METHOD(val); }
00047 
00048 class GR_UserOption;
00049 
00050 class GR_API GR_DisplayOption
00051 {
00052 public:
00053     GR_DisplayOption(GR_CommonDispOption *common_options = 0);
00054     ~GR_DisplayOption();
00055     GR_DisplayOption(const GR_DisplayOption &s);
00056 
00057     GR_DisplayOption    &operator=(const GR_DisplayOption &opt);
00058 
00059     // Copy all but the common display options from the given GR_DisplayOption
00060     // object.
00061     void                 copyNonCommon(const GR_DisplayOption &opt);
00062 
00063     // Copy the user options (not done by copyNonCommon).
00064     void                 copyUserOptions(const GR_DisplayOption &opt);
00065 
00066     // Refresh the version key for all of the enabled user options from the
00067     // global option table.
00068     void                 refreshUserOptionVersions();
00069 
00070     // Return whether or not the specified object has the same set of enabled
00071     // user options.  Version keys are ignored.
00072     bool                 userOptionStatesEqual(
00073                                     const GR_DisplayOption &opt) const;
00074 
00075     // Set the enabled user options to match the specified object.  Note that
00076     // version keys are also copied.  However, this is irrelevant as version
00077     // keys only matter while drawing and will have been refreshed in that
00078     // case anyway.
00079     void                 matchUserOptionStates(const GR_DisplayOption &opt);
00080 
00081     //  The following method is used to check if the options controlling the
00082     //  geometry have changed.  For example, if the field guide is different
00083     //  for both of these, it doesn't matter.  If compare_common is false, the
00084     //  common display options won't be compared.
00085     bool         gdpOptionsEqual(const GR_DisplayOption &opt,
00086                                  bool compare_common = true) const;
00087 
00088     // Class I/O methods.  Return true if successful, false if not.
00089     bool         save(ostream &, int indent=0) const;
00090     bool         load(UT_IStream &);
00091 
00092     const char  *className() const;
00093 
00094     // Set the shading mode.  The draw mode is either wireframe or shaded,
00095     // but the shading mode can be hiddenwire, flag shaded, wire over gouraud,
00096     // etc.  Changing the shading mode will change the drawing mode as well as
00097     // other flags in this class.
00098     void         shadingMode(GR_ShadingMode shading_mode);
00099 
00100     // Find which shading mode we're currently using.
00101     GR_ShadingMode shadingMode() const;
00102 
00103     // Utility methods to convert a GR_ShadingMode to/from a token.  The parse
00104     // method returns -1 on a failure.
00105     static void saveShadingMode(ostream &os, GR_ShadingMode mode);
00106     static int  parseShadingMode(const char *token);
00107 
00108     // "Get" methods.
00109     bool        drawPointMarkers() const { return myFlags.drawPointMarkers;    }
00110     bool        drawPointNums   () const { return myFlags.drawPointNums;       }
00111     bool        drawPointNmls   () const { return myFlags.drawPointNmls;       }
00112     bool        drawPointTxtNums() const { return myFlags.drawPointTxtNums;    }
00113     bool        drawPointPos    () const { return myFlags.drawPointPos;        }
00114     bool        drawVertexNums  () const { return myFlags.drawVertexNums;      }
00115     bool        drawVertexTxtNums() const { return myFlags.drawVertexTxtNums;  }
00116     bool        drawVertexGrips() const  { return myFlags.drawVertexGrips;     }
00117     bool        drawPrimNums    () const { return myFlags.drawPrimNums;        }
00118     bool        drawPrimNmls    () const { return myFlags.drawPrimNmls;        }
00119     bool        drawPrimHulls   () const { return myFlags.drawPrimHulls;       }
00120     bool        drawPrimBreakpoints() const{return myFlags.drawPrimBreakpoints;}
00121     bool        drawProfiles    () const { return myFlags.drawProfiles;        }
00122     bool        drawProfNums    () const { return myFlags.drawProfNums;        }
00123     bool        drawFaded       () const { return myFlags.drawFaded;           }
00124     bool        boundBox        () const { return myFlags.boundBox;            }
00125     bool        wireHiddenLine  () const { return myFlags.wireHiddenLine;      }
00126     bool        flatShaded      () const { return myFlags.flatShaded;          }
00127     bool        wireOverShaded  () const { return myFlags.wireOverShaded;      }
00128     bool        vexShaded       () const { return myFlags.vexShaded;           }
00129     bool        appliesToSelection() const { return myFlags.appliesToSelection;}
00130     bool        hlGhostFill     () const { return myFlags.hlGhostFill;         }
00131     int         drawMode        () const { return myFlags.drawMode;            }
00132     bool        uvFillBackFaces () const { return myFlags.uvFillBackFaces;     }
00133 
00134     // "Set" methods.
00135     void        drawPointMarkers(bool onoff) { myFlags.drawPointMarkers =onoff;}
00136     void        drawPointNums(bool onoff)    { myFlags.drawPointNums    =onoff;}
00137     void        drawPointNmls(bool onoff)    { myFlags.drawPointNmls    =onoff;}
00138     void        drawPointTxtNums(bool onoff) { myFlags.drawPointTxtNums =onoff;}
00139     void        drawPointPos(bool onoff)     { myFlags.drawPointPos     =onoff;}
00140     void        drawVertexNums(bool onoff)   { myFlags.drawVertexNums   =onoff;}
00141     void        drawVertexTxtNums(bool onoff){ myFlags.drawVertexTxtNums=onoff;}
00142     void        drawVertexGrips(bool onoff)  { myFlags.drawVertexGrips  =onoff;}
00143     void        drawPrimNums    (bool onoff) { myFlags.drawPrimNums     =onoff;}
00144     void        drawPrimNmls    (bool onoff) { myFlags.drawPrimNmls     =onoff;}
00145     void        drawPrimHulls   (bool onoff) { myFlags.drawPrimHulls    =onoff;}
00146     void        drawPrimBreakpoints (bool onoff)
00147                                         { myFlags.drawPrimBreakpoints = onoff;}
00148     void        drawProfiles    (bool onoff) { myFlags.drawProfiles     =onoff;}
00149     void        drawProfNums    (bool onoff) { myFlags.drawProfNums     =onoff;}
00150     void        drawFaded       (bool onoff) { myFlags.drawFaded        =onoff;}
00151     void        boundBox        (bool onoff) { myFlags.boundBox         =onoff;}
00152     void        wireHiddenLine  (bool onoff) { myFlags.wireHiddenLine   =onoff;}
00153     void        flatShaded      (bool onoff) { myFlags.flatShaded       =onoff;}
00154     void        wireOverShaded  (bool onoff) { myFlags.wireOverShaded   =onoff;}
00155     void        vexShaded       (bool onoff) { myFlags.vexShaded        =onoff;}
00156     void        appliesToSelection(bool onoff)
00157                                         { myFlags.appliesToSelection = onoff; }
00158     void        hlGhostFill     (bool onoff) { myFlags.hlGhostFill      =onoff;}
00159     void        drawMode        (int mode)   { myFlags.drawMode         =mode;}
00160     void        uvFillBackFaces (bool onoff) { myFlags.uvFillBackFaces  =onoff;}
00161 
00162     // Convenience methods to access the common options:
00163     const UT_Color      &regAuxColor()      const
00164                                 { return myCommonOptions->regAuxColor(); }
00165           UT_Color      &regAuxColor()
00166                                 { return myCommonOptions->regAuxColor(); }
00167     const UT_Color      &selAuxColor()      const
00168                                 { return myCommonOptions->selAuxColor(); }
00169           UT_Color      &selAuxColor()
00170                                 { return myCommonOptions->selAuxColor(); }
00171     const UT_Color      &primInfoColor()    const
00172                                 { return myCommonOptions->primInfoColor(); }
00173           UT_Color      &primInfoColor()
00174                                 { return myCommonOptions->primInfoColor(); }
00175     const UT_Color      &selPrimInfoColor() const
00176                                 { return myCommonOptions->selPrimInfoColor();}
00177           UT_Color      &selPrimInfoColor()
00178                                 { return myCommonOptions->selPrimInfoColor();}
00179     const UT_Color      &selPrimColor()     const
00180                                 { return myCommonOptions->selPrimColor(); }
00181           UT_Color      &selPrimColor()
00182                                 { return myCommonOptions->selPrimColor(); }
00183     const UT_Color      &auxSelPrimColor1() const
00184                                 { return myCommonOptions->auxSelPrimColor1();}
00185           UT_Color      &auxSelPrimColor1()
00186                                 { return myCommonOptions->auxSelPrimColor1();}
00187     const UT_Color      &auxSelPrimColor2() const
00188                                 { return myCommonOptions->auxSelPrimColor2();}
00189           UT_Color      &auxSelPrimColor2()
00190                                 { return myCommonOptions->auxSelPrimColor2();}
00191     const UT_Color      &primClosureColor() const
00192                                 { return myCommonOptions->primClosureColor();}
00193           UT_Color      &primClosureColor()
00194                                 { return myCommonOptions->primClosureColor();}
00195     const UT_Color      &pointColor()       const
00196                                 { return myCommonOptions->pointColor(); }
00197           UT_Color      &pointColor()
00198                                 { return myCommonOptions->pointColor(); }
00199     const UT_Color      &selPointColor()    const
00200                                 { return myCommonOptions->selPointColor(); }
00201           UT_Color      &selPointColor()
00202                                 { return myCommonOptions->selPointColor(); }
00203     const UT_Color      &auxSelPointColor1() const
00204                                 { return myCommonOptions->auxSelPointColor1();}
00205           UT_Color      &auxSelPointColor1()
00206                                 { return myCommonOptions->auxSelPointColor1();}
00207     const UT_Color      &auxSelPointColor2() const
00208                                 { return myCommonOptions->auxSelPointColor2();}
00209           UT_Color      &auxSelPointColor2()
00210                                 { return myCommonOptions->auxSelPointColor2();}
00211     const UT_Color      &pointClosureColor() const
00212                                 { return myCommonOptions->pointClosureColor();}
00213           UT_Color      &pointClosureColor()
00214                                 { return myCommonOptions->pointClosureColor();}
00215     const UT_Color      &guide1Color() const
00216                                 { return myCommonOptions->guide1Color();}
00217           UT_Color      &guide1Color()
00218                                 { return myCommonOptions->guide1Color();}
00219     const UT_Color      &guide2Color() const
00220                                 { return myCommonOptions->guide2Color();}
00221           UT_Color      &guide2Color()
00222                                 { return myCommonOptions->guide2Color();}
00223     const UT_Color      &guideSelColor() const
00224                                 { return myCommonOptions->guideSelColor();}
00225     const UT_Color      &templateColor()            const
00226                                 { return myCommonOptions->templateColor(); }
00227           UT_Color      &templateColor()
00228                                 { return myCommonOptions->templateColor(); }
00229     const UT_Color      &backgndColor()     const
00230                                 { return myCommonOptions->backgndColor(); }
00231           UT_Color      &backgndColor()
00232                                 { return myCommonOptions->backgndColor(); }
00233     const UT_Color      &wireColor()        const
00234                                 { return myCommonOptions->wireColor(); }
00235           UT_Color      &wireColor()
00236                                 { return myCommonOptions->wireColor(); }
00237     const UT_Color      &axesColor()        const
00238                                 { return myCommonOptions->axesColor(); }
00239           UT_Color      &axesColor()
00240                                 { return myCommonOptions->axesColor(); }
00241     const UT_Color      &xAxesColor()       const
00242                                 { return myCommonOptions->xAxesColor(); }
00243           UT_Color      &xAxesColor()
00244                                 { return myCommonOptions->xAxesColor(); }
00245     const UT_Color      &yAxesColor()       const
00246                                 { return myCommonOptions->yAxesColor(); }
00247           UT_Color      &yAxesColor()
00248                                 { return myCommonOptions->yAxesColor(); }
00249     const UT_Color      &zAxesColor()       const
00250                                 { return myCommonOptions->zAxesColor(); }
00251           UT_Color      &zAxesColor()
00252                                 { return myCommonOptions->zAxesColor(); }
00253     const UT_Color      &ghostFillColor()
00254                                 { return myCommonOptions->ghostFillColor(); }
00255     const UT_Color      &uvBackFaceFillColor() const
00256                         { return myCommonOptions->uvBackFaceFillColor(); }
00257     const UT_Color      &uvSelBackFaceFillColor() const
00258                         { return myCommonOptions->uvSelBackFaceFillColor(); }
00259 
00260     // Common option accessor methods:
00261     COMMON_FLAG_ACCESSORS( drawTexture )
00262     COMMON_FLAG_ACCESSORS( drawTransparent )
00263     COMMON_FLAG_ACCESSORS( drawTexturedSpots )
00264     COMMON_FLAG_ACCESSORS( drawShadows )
00265     COMMON_FLAG_ACCESSORS( drawTransparentMaps )
00266     COMMON_FLAG_ACCESSORS( removeBackface )
00267     COMMON_FLAG_ACCESSORS( simpleDraw )
00268     COMMON_FLAG_ACCESSORS( fillSelection )
00269     COMMON_FLAG_ACCESSORS( antiAliased )
00270     COMMON_FLAG_ACCESSORS( solidOnly )
00271     COMMON_FLAG_ACCESSORS( drawSpherePoly )
00272     COMMON_FLAG_ACCESSORS( drawPartSprite )
00273     COMMON_FLAG_ACCESSORS( sortPartSprite )
00274     COMMON_FLAG_ACCESSORS( drawPartTails )
00275     COMMON_FLAG_ACCESSORS( snapToSelected )
00276     COMMON_FLAG_ACCESSORS( showTempSelections )
00277     COMMON_FLAG_ACCESSORS( uvPickBackFaces )
00278     COMMON_FLAG_ACCESSORS( uvPickFrontFaces )
00279     COMMON_FLAG_ACCESSORS( drawPartOrigin )
00280     COMMON_FLAG_ACCESSORS( drawOnlyHulls )
00281 
00282     COMMON_FLAG_ACCESSORS( shadeOpenCurves )
00283 
00284     COMMON_FLAG_ACCESSORS( alphaPass )
00285     COMMON_OPTION_PREFIXED_ACCESSORS( HighQualityPass, GR_HighQualityPass )
00286 
00287     COMMON_FLAG_ACCESSORS( drawThickSelectedNormals )
00288     COMMON_FLAG_ACCESSORS( drawThickSelectedUVGrips )
00289 
00290     COMMON_FLAG_ACCESSORS( drawAuxColors )
00291 
00292     COMMON_FLAG_ACCESSORS( shadingOpenCurves )
00293 
00294     COMMON_FLAG_ACCESSORS( displayAsSubdiv )
00295 
00296     COMMON_FLAG_ACCESSORS( overrideColorAttrib )
00297 
00298     COMMON_OPTION_ACCESSORS( primMask, unsigned )
00299     COMMON_OPTION_ACCESSORS( pickMask, unsigned )
00300     COMMON_OPTION_ACCESSORS( normalScale, float )
00301     COMMON_OPTION_ACCESSORS( uvGripScale, float )
00302     COMMON_OPTION_ACCESSORS( LOD, float )
00303     COMMON_OPTION_ACCESSORS( hlOffsetVariable, float )
00304     COMMON_OPTION_ACCESSORS( hlOffsetConstant, float )
00305     COMMON_OPTION_ACCESSORS( wireWidth, float )
00306     COMMON_OPTION_ACCESSORS( shadowOffsetVariable, float )
00307     COMMON_OPTION_ACCESSORS( shadowOffsetConstant, float )
00308 
00309     COMMON_FLAG_ACCESSORS( forceWireColor )
00310 
00311     COMMON_OPTION_ACCESSORS( selectionListInst, int )
00312 
00313     // Common options "Get" methods:
00314     unsigned     cullOf()            const
00315                             { return myCommonOptions->cullOf(); }
00316     unsigned     cullDraw()          const
00317                             { return myCommonOptions->cullDraw(); }
00318     float        pointSize()         const
00319                             { return myCommonOptions->pointSize(); }
00320 
00321     const char  *colorAttrib() const { return myCommonOptions->colorAttrib(); }
00322     int          colorType() const { return myCommonOptions->colorType(); }
00323 
00324 
00325     // Common options "Set" methods:
00326     void         cullOf(int o)
00327                                 { myCommonOptions->cullOf(o); }
00328     void         cullDraw(int d)
00329                                 { myCommonOptions->cullDraw(d); }
00330 
00331     void         setColors(const GR_DisplayOption &opt)
00332                                 { myCommonOptions->setColors(
00333                                                     *opt.myCommonOptions); }
00334     const UT_Color      &crtAuxColor()      const
00335                                 { return myCommonOptions->crtAuxColor(); }
00336     const UT_Color      &crtAuxColor()                  // yes, return a const
00337                                 { return myCommonOptions->crtAuxColor(); }
00338     void         useRegularAuxColor()
00339                                 { myCommonOptions->useRegularAuxColor(); }
00340     void         useSelectedAuxColor()
00341                                 { myCommonOptions->useSelectedAuxColor(); }
00342     void         setColorAttrib(const char *name)
00343                                 { myCommonOptions->setColorAttrib(name); }
00344     void         setColorType(int type)
00345                                 { myCommonOptions->setColorType(type); }
00346 
00347     void         enableUserOption(const char *name, bool onoff);
00348     bool         getUserOptionState(const char *name);
00349     void         disableAllUserOptions();
00350 
00351     // This method is called when user options are being destroyed.  We need
00352     // to take the option_id since there is no way at that time for us to map
00353     // an option name to the id.
00354     void         removeUserOption(int option_id);
00355 
00356     // Methods to query the enabled user options.
00357     int          getNumUserOptions() const { return myUserOptions.entries(); }
00358     const GR_UserOption *getUserOption(int i) const;
00359     const GR_UserOption *getOption(const char *name) const;
00360 
00361 private:
00362     GR_CommonDispOption *myCommonOptions;
00363     bool                 myOwnCommonOptionsFlag;
00364 
00365     //
00366     // A simple class to store the unique id and version of a GR_UserOption.
00367     // This needs to be here or else the UT_RefArray template won't be able
00368     // to compile on Windows.
00369     //
00370     class gr_UserOptionRef
00371     {
00372     public:
00373         gr_UserOptionRef(): myId(-1), myVersion(-1) {}
00374         gr_UserOptionRef( int id, int version )
00375             : myId(id), myVersion(version) {}
00376 
00377         int              operator==(const gr_UserOptionRef &opt)
00378                      { return myId == opt.myId && myVersion == opt.myVersion; }
00379         static int       compareID(const gr_UserOptionRef *r1,
00380                                const gr_UserOptionRef *r2)
00381                      {
00382                          return r1->myId - r2->myId;
00383                      }
00384 
00385         int              myId;
00386         int              myVersion;
00387     };
00388 
00389     // This array consists only of references to the enabled user options, and
00390     // is stored sorted by option id for performance reasons.
00391     UT_RefArray<gr_UserOptionRef>       myUserOptions;
00392 
00393     struct grDrawFlags
00394     {
00395     unsigned     drawPointMarkers :1,   // draw points 
00396                  drawPointNums    :1,   // draw point numbers
00397                  drawPointNmls    :1,   // draw point normals
00398                  drawPointTxtNums :1,   // draw point texture numbers
00399                  drawPointPos     :1,   // draw point positions 
00400 
00401                  drawVertexNums   :1,   // draw vertex numbers
00402                  drawVertexTxtNums:1,   // draw vertex texture numbers
00403                  drawVertexGrips  :1,   // draw vertex grips               
00404 
00405 // TODO: ADD THIS: drawPrimitives       :1,     // draw primitives
00406                  drawPrimNums     :1,   // draw primitive numbers
00407                  drawPrimNmls     :1,   // draw primitive normals
00408                  drawPrimHulls    :1,   // draw Spline prim hulls
00409                  drawPrimBreakpoints:1, // draw primitive break points
00410 
00411                  drawProfiles     :1,   // draw profiles
00412                  drawProfNums     :1,   // draw profile numbers
00413                  drawFaded        :1,   // draw with a faded look?
00414 
00415                  wireHiddenLine   :1,   // remove hidden lines
00416                  flatShaded       :1,   // flat/gouraud shading
00417                  wireOverShaded   :1,   // draw wireframe over shaded
00418                  boundBox         :1,   // draw bounding box
00419                  vexShaded        :1,   // draw shaded, but lit by VEX shaders
00420                  hlGhostFill      :1,   // hidden line ghost fill
00421                  appliesToSelection:1,  // use for selected or non-selected?
00422 
00423 // TODO: Make drawMode into a drawShaded flag.  Move the DM defines for
00424 //       shaded modes here, and add methods to update the flags to match
00425 //       one of these shaded modes.
00426                  drawMode         :2,   // GR_DRAW_WIREFRAME or GR_DRAW_SHADED
00427                  uvFillBackFaces  :1;
00428     };
00429     grDrawFlags myFlags;
00430 };
00431 
00432 #undef COMMON_FLAG_ACCESSORS
00433 #undef COMMON_OPTION_ACCESSORS
00434 #undef COMMON_OPTION_PREFIXED_ACCESSORS
00435 
00436 #endif