Main Page | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Class Members | File Members

BOpcodeHandler.h

Go to the documentation of this file.
00001 //
00002 // Copyright (c) 2000 by Tech Soft America, LLC.
00003 // The information contained herein is confidential and proprietary to
00004 // Tech Soft America, LLC., and considered a trade secret as defined under
00005 // civil and criminal statutes.  Tech Soft America shall pursue its civil
00006 // and criminal remedies in the event of unauthorized use or misappropriation
00007 // of its trade secrets.  Use of this information by anyone other than
00008 // authorized employees of Tech Soft America, LLC. is granted only under a
00009 // written non-disclosure agreement, expressly prescribing the scope and
00010 // manner of such use.
00011 //
00012 //
00013 //  Copyright (c) 1996-2005 by Autodesk, Inc.
00014 //
00015 //  By using this code, you are agreeing to the terms and conditions of
00016 //  the License Agreement included in the documentation for this code.
00017 //
00018 //  AUTODESK MAKES NO WARRANTIES, EXPRESS OR IMPLIED,
00019 //  AS TO THE CORRECTNESS OF THIS CODE OR ANY DERIVATIVE
00020 //  WORKS WHICH INCORPORATE IT.
00021 //
00022 //  AUTODESK PROVIDES THE CODE ON AN "AS-IS" BASIS
00023 //  AND EXPLICITLY DISCLAIMS ANY LIABILITY, INCLUDING
00024 //  CONSEQUENTIAL AND INCIDENTAL DAMAGES FOR ERRORS,
00025 //  OMISSIONS, AND OTHER PROBLEMS IN THE CODE.
00026 //
00027 //  Use, duplication, or disclosure by the U.S. Government is subject to
00028 //  restrictions set forth in FAR 52.227-19 (Commercial Computer Software
00029 //  Restricted Rights) and DFAR 252.227-7013(c)(1)(ii) (Rights in Technical
00030 //  Data and Computer Software), as applicable.
00031 //
00032 //
00033 // $Header: /Components/Internal/DWF Toolkit/v7.0.1/develop/global/src/dwf/w3dtk/BOpcodeHandler.h 3     5/10/05 12:59a Evansg $
00034 //
00035 
00036 #ifndef BOPCODE_HANDLER
00037 #define BOPCODE_HANDLER
00038 
00039 
00040 
00041 #include "dwf/Toolkit.h"
00042 #include "dwf/w3dtk/BStreamFileToolkit.h"
00043 #include "dwf/w3dtk/W3DOpcodeHandler.h"
00044 
00045 
00047 
00050 
00051 
00071 class BBINFILETK_API BBaseOpcodeHandler : public BControlledMemoryObject
00072                                         , public W3DOpcodeHandler
00073 {
00074     protected:
00075         int             m_stage;        
00076         int             m_progress;     
00077         unsigned char   m_opcode;       
00078 
00079         int             m_debug_length;   
00080         int             m_debug_allocated;
00081         char *          m_debug_string;   
00084     public:
00090         BBaseOpcodeHandler (unsigned char op)
00091             : m_stage (0), m_progress (0), m_opcode (op),
00092               m_debug_length (0), m_debug_allocated (0), m_debug_string (0) {}
00093         virtual ~BBaseOpcodeHandler();
00094 
00095 
00099         virtual void serialize( const void* pTag = NULL )
00100             throw( DWFException );
00101 
00109         virtual TK_Status   Read (BStreamFileToolkit & tk) alter = 0;
00110 
00118         virtual TK_Status   Write (BStreamFileToolkit & tk) alter = 0;
00119 
00127         virtual TK_Status   Execute (BStreamFileToolkit & tk) alter;
00128 
00138         virtual TK_Status   Interpret (BStreamFileToolkit & tk, ID_Key key, int variant = 0) alter;
00139 
00149         virtual TK_Status   Interpret (BStreamFileToolkit & tk, ID_Key key, char const * special) alter;
00150 
00156         virtual void        Reset (void) alter;
00157 
00162         virtual bool        Match_Instance (BStreamFileToolkit const & tk, Recorded_Instance alter * instance) alter;
00163 
00164 
00166         unsigned char       Opcode (void) const { return m_opcode; }
00167 
00172         int                 Pass (BStreamFileToolkit & tk) const { return tk.pass(); }
00173 
00178         TK_Status           Tag (BStreamFileToolkit & tk, int variant= -1) const   { return tk.tag(variant); }
00179 
00183         bool                Tagging (BStreamFileToolkit & tk) const   { return tk.GetWriteFlags(TK_Force_Tags) != 0; }
00184 
00191         virtual TK_Status   Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const   { *handler = 0; return tk.Error(); }
00192 
00197         void            SetDebug (char const * segment) alter;
00198 
00203         void            SetDebug (int length) alter;
00204 
00208         char const *    GetDebug (void) const                           { return m_debug_string; }
00213         char alter *    GetDebug (void) alter               { return m_debug_string; }
00214 
00218         void            LogDebug (BStreamFileToolkit & tk) alter;
00219 
00220     protected:
00221         // various means of pulling data from the toolkit buffer
00222         // Note: format conversion is safe to do in output buffer
00223 
00225         TK_Status   GetData (BStreamFileToolkit & tk, char * b, int n) alter    { return tk.read (b, n); }
00226 
00228         TK_Status   GetData (BStreamFileToolkit & tk, short * s, int n) alter   {
00229             TK_Status   status;
00230             if ((status = GetData (tk, (char *)s, n * (int)sizeof (short))) == TK_Normal)
00231                 fix (s, n);
00232             return status;
00233         }
00234 
00236         TK_Status   GetData (BStreamFileToolkit & tk, int * i,   int n) alter   {
00237             TK_Status   status;
00238             if ((status = GetData (tk, (char *)i, n * (int)sizeof (int))) == TK_Normal)
00239                 fix (i, n);
00240             return status;
00241         }
00242 
00244         TK_Status   GetData (BStreamFileToolkit & tk, float * f, int n) alter   {
00245             TK_Status   status;
00246             if ((status = GetData (tk, (char *)f, n * (int)sizeof (float))) == TK_Normal)
00247                 fix_in (f, n);
00248             return status;
00249         }
00250 
00252         TK_Status   GetData (BStreamFileToolkit & tk, unsigned char * b, int n) alter   { return GetData (tk, (char *)b,  n); }
00253 
00255         TK_Status   GetData (BStreamFileToolkit & tk, unsigned short * s, int n) alter  { return GetData (tk, (short *)s, n); }
00256 
00258         TK_Status   GetData (BStreamFileToolkit & tk, unsigned int * i, int n) alter    { return GetData (tk, (int *)i,   n); }
00259 
00261         TK_Status   GetData (BStreamFileToolkit & tk, char & c) alter                   { return GetData (tk, &c, 1); }
00262 
00264         TK_Status   GetData (BStreamFileToolkit & tk, short & s) alter                  { return GetData (tk, &s, 1); }
00265 
00267         TK_Status   GetData (BStreamFileToolkit & tk, int & i) alter                    { return GetData (tk, &i, 1); }
00268 
00270         TK_Status   GetData (BStreamFileToolkit & tk, unsigned char & b) alter          { return GetData (tk, &b, 1); }
00271 
00273         TK_Status   GetData (BStreamFileToolkit & tk, unsigned short & s) alter         { return GetData (tk, &s, 1); }
00274 
00276         TK_Status   GetData (BStreamFileToolkit & tk, unsigned int & i) alter           { return GetData (tk, &i, 1); }
00277 
00279         TK_Status   GetData (BStreamFileToolkit & tk, float & f) alter                  { return GetData (tk, &f, 1); }
00280 
00282         TK_Status   LookatData (BStreamFileToolkit & tk, unsigned char & b) alter       { return tk.lookat ((char &)b); }
00283 
00284         // various means of putting data into the toolkit buffer
00285         // Note: format conversion is NOT safe in input buffer -- use temps
00286 
00288         TK_Status   PutData (BStreamFileToolkit & tk, char const * b, int n) alter    { return tk.write (b, n); }
00289 
00291         TK_Status   PutData (BStreamFileToolkit & tk, short const * s, int n) alter    {
00292                             #ifdef STREAM_BIGENDIAN
00293                                 short *     buffer = new short [n];
00294                                 short *     tmp = buffer;
00295                                 TK_Status   status;
00296                                 int         i;
00297                                 for (i=0; i<n; ++i)
00298                                     *tmp++ = flip (*s++);
00299                                 status = PutData (tk, (char *)buffer, n * (int)sizeof (short));
00300                                 delete [] buffer;
00301                                 if (status != TK_Normal)
00302                                     return status;
00303                                 return TK_Normal;
00304                             #else
00305                                 return PutData (tk, (char *)s, n * (int)sizeof (short));
00306                             #endif
00307                         }
00308 
00310         TK_Status   PutData (BStreamFileToolkit & tk, int const * i, int n) alter    {
00311                             #ifdef STREAM_BIGENDIAN
00312                                 int *       buffer = new int [n];
00313                                 int *       tmp = buffer;
00314                                 TK_Status   status;
00315                                 int         j;
00316                                 for (j=0; j<n; ++j)
00317                                     *tmp++ = flip (*i++);
00318                                 status = PutData (tk, (char *)buffer, n * (int)sizeof (int));
00319                                 delete [] buffer;
00320                                 if (status != TK_Normal)
00321                                     return status;
00322                                 return TK_Normal;
00323                             #else
00324                                 return PutData (tk, (char *)i, n * (int)sizeof (int));
00325                             #endif
00326                         }
00327 
00329         TK_Status   PutData (BStreamFileToolkit & tk, float const * f, int n) alter    {
00330                             #if defined(NON_IEEE) || defined(STREAM_BIGENDIAN)
00331                                 float *     buffer = new float [n];
00332                                 float *     tmp = buffer;
00333                                 TK_Status   status;
00334                                 int         i;
00335                                 for (i=0; i<n; ++i) {
00336                                     *tmp = *f++;
00337                                     fix_out (tmp++, 1);
00338                                 }
00339                                 status = PutData (tk, (char *)buffer, n * (int)sizeof (float));
00340                                 delete [] buffer;
00341                                 if (status != TK_Normal)
00342                                     return status;
00343                                 return TK_Normal;
00344                             #else
00345                                 return PutData (tk, (char *)f, n * (int)sizeof (float));
00346                             #endif
00347                         }
00348 
00350         TK_Status   PutData (BStreamFileToolkit & tk, unsigned char const * b, int n) alter    { return PutData (tk, (char const *)b,  n); }
00351 
00353         TK_Status   PutData (BStreamFileToolkit & tk, unsigned short const * s, int n) alter   { return PutData (tk, (short const *)s, n); }
00354 
00356         TK_Status   PutData (BStreamFileToolkit & tk, unsigned int const * i, int n) alter     { return PutData (tk, (int const *)i,   n); }
00357 
00359         TK_Status   PutData (BStreamFileToolkit & tk, char const & c) alter                    { return PutData (tk, &c, 1); }
00360 
00362         TK_Status   PutData (BStreamFileToolkit & tk, short const & s) alter                   { return PutData (tk, &s, 1); }
00363 
00365         TK_Status   PutData (BStreamFileToolkit & tk, int const & i) alter                     { return PutData (tk, &i, 1); }
00366 
00368         TK_Status   PutData (BStreamFileToolkit & tk, unsigned char const & b) alter           { return PutData (tk, &b, 1); }
00369 
00371         TK_Status   PutData (BStreamFileToolkit & tk, unsigned short const & s) alter          { return PutData (tk, &s, 1); }
00372 
00374         TK_Status   PutData (BStreamFileToolkit & tk, unsigned int const & i) alter            { return PutData (tk, &i, 1); }
00375 
00377         TK_Status   PutData (BStreamFileToolkit & tk, float const & f) alter                   { return PutData (tk, &f, 1); }
00378 
00380         TK_Status   PutOpcode (BStreamFileToolkit & tk, int adjust = 1) alter {
00381                         TK_Status       status;
00382                         unsigned int    sequence;
00383 
00384                         if ((status = PutData (tk, Opcode ())) != TK_Normal)
00385                             return status;
00386 
00387                         tk.adjust_written (adjust);
00388 
00389                         sequence = tk.NextOpcodeSequence();
00390                         if (tk.GetLogging())
00391                             log_opcode (tk, sequence, Opcode());
00392 
00393                         return status;
00394                     }
00395 
00396         /* note -- fix for int types will work during read OR write phase, but floats need separate
00397            routines for native->IEEE and IEEE->native
00398         */
00400         short       flip (short s) {
00401                         return ((s >> 8) & 0x00FF) | (s << 8);
00402                     }
00404         int         flip (int i) {
00405                         return ((i >> 24) & 0x000000FF) | ((i >> 8) & 0x0000FF00) |
00406                                ((i <<  8) & 0x00FF0000) |  (i << 24);
00407                     }
00408 
00409 #ifndef UNREFERENCED
00410   #define UNREFERENCED(x) (void)(x)
00411 #endif
00412 
00414         void        fix (int * i, int n) {
00415                         #ifdef STREAM_BIGENDIAN
00416                         while (n--){
00417                                 *i = flip (*i);
00418                                 i++;
00419                         }
00420                         #else
00421                         UNREFERENCED(i);
00422                         UNREFERENCED(n);
00423                         #endif
00424 
00425                     }
00427         void        fix (short * s, int n) {
00428                         #ifdef STREAM_BIGENDIAN
00429                             while (n--){
00430                                 *s = flip (*s);
00431                                 s++;
00432                                 }
00433                         #else
00434                         UNREFERENCED(s);
00435                         UNREFERENCED(n);
00436                         #endif
00437                     }
00438 
00440         void        fix_in (float * f, int n) {
00441                         #ifdef NON_IEEE
00442                             // need to re-interpret from IEEE to native format
00443                         #endif
00444 
00445                         #ifdef STREAM_BIGENDIAN
00446                         int * i = (int*) f;
00447                         while (n--){
00448                                 *i = flip (*i);
00449 
00450                                 i++;
00451                         }
00452                         #else
00453                         UNREFERENCED(f);
00454                         UNREFERENCED(n);
00455                         #endif
00456                     }
00458         void        fix_out (float * f, int n) {
00459                         #ifdef NON_IEEE
00460                             // need to re-interpret from native format to IEEE
00461                         #endif
00462 
00463                         #ifdef STREAM_BIGENDIAN
00464                         int * i = (int*) f;
00465                         while (n--){
00466                                 *i = flip (*i);
00467                                 i++;
00468                         }
00469                         #else
00470                         UNREFERENCED(f);
00471                         UNREFERENCED(n);
00472                         #endif
00473                     }
00474 
00476         void        log_opcode (BStreamFileToolkit & tk, unsigned int sequence, unsigned char opcode) alter;
00477 
00478 
00479         /* common conversions
00480            these two are for converting between floats [0.0,1.0] and unsigned chars [0,255]
00481         */
00483         void        floats_to_bytes (float const * in, unsigned char alter * out, int count) const {
00484                             while (count-- > 0)
00485                                 *out++ = char (*in++ * 255.999f);
00486                         }
00488         void        bytes_to_floats (unsigned char const * in, float alter * out, int count) const {
00489                             while (count-- > 0)
00490                                 *out++ = float (*in++) * (1.0f/255.0f);
00491                         }
00492 
00493         // access to toolkit utility functions
00495         void        add_segment (BStreamFileToolkit & tk, ID_Key key) alter     { tk.add_segment (key); }
00497         ID_Key      remove_segment (BStreamFileToolkit & tk) alter              { return tk.remove_segment(); }
00499         void        set_last_key (BStreamFileToolkit & tk, ID_Key key) alter    { tk.set_last_key (key); }
00501         ID_Key      last_key (BStreamFileToolkit & tk) const {
00502             if( tk.m_last_keys_used == 1 )
00503                 return tk.m_last_keys[0];
00504             else
00505                 return -1;
00506         }
00508         void        adjust_written (BStreamFileToolkit & tk, int count) alter   { tk.adjust_written (count); }
00510         void        increase_nesting (BStreamFileToolkit & tk, int amount=1) alter  { tk.increase_nesting (amount); }
00512         void        decrease_nesting (BStreamFileToolkit & tk, int amount=1) alter  { tk.decrease_nesting (amount); }
00513 
00517         void        Revisit (BStreamFileToolkit & tk, float priority=0.0f, int variant=0) const  { tk.revisit (Opcode(), priority, variant); }
00518 
00522         BBaseOpcodeHandler alter *  Opcode_Handler (BStreamFileToolkit & tk, unsigned char op) const
00523                                         { return tk.opcode_handler (op); }
00524 
00526         void        Record_Instance (BStreamFileToolkit & tk, ID_Key key, int variant,
00527                                      int val1, int val2, int val3) const {
00528                             tk.record_instance (key, variant, this, val1, val2, val3);
00529                         }
00531         bool        Find_Instance (BStreamFileToolkit & tk, int val1, int val2, int val3) alter {
00532                             return tk.find_instance (this, val1, val2, val3);
00533                         }
00534 
00536         void        Remember_Segment (BStreamFileToolkit & tk, ID_Key key) const  { tk.remember_segment(key); }
00538         bool        Find_Segment (BStreamFileToolkit & tk, ID_Key key) const      { return tk.find_segment(key); }
00539 
00541         bool        validate_count (int count, int limit = 1<<24) const { return 0 <= count && count <= limit; }
00542 };
00543 
00545 #define IMPLEMENT_CLONE(class_name)                                                                         \
00546             TK_Status class_name::Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **newhandler) const {  \
00547                 *newhandler = new class_name;                                                               \
00548                 if (*newhandler != null)                                                                    \
00549                 return TK_Normal;                                                                       \
00550                 else                                                                                        \
00551                 return tk.Error ("memory allocation in" #class_name "::clone failed");                  \
00552             }                                                                                              //
00553 
00554 #define IMPLEMENT_CLONE_OPCODE(class_name)                                                                  \
00555             TK_Status class_name::Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **newhandler) const {  \
00556                 *newhandler = new class_name (Opcode());                                                    \
00557                 if (*newhandler != null)                                                                    \
00558                 return TK_Normal;                                                                       \
00559                 else                                                                                        \
00560                 return tk.Error ("memory allocation in" #class_name "::clone failed");                  \
00561             }                                                                                              //
00562 
00563 
00564 
00566 
00570 // Note: the trailing ////s have been used internally as a visual indicator of the completeness
00571 // of the implementation of an opcode (gaps in the pattern would indicate work remaining somewhere).
00572 // Usually // for a reserved code, /// for partial implementation, //// when done.
00573 
00574 // Additions need to be reflected in the 'opcode_string' table in BOpcode_Handler.cpp
00575 enum TKE_Object_Types {
00576     TKE_Termination                 = '\x00',       
00577     TKE_Pause                       = '\x01',       
00578 
00579     TKE_Comment                     = ';',          
00580 
00581     TKE_Font                        = 'f',          
00582     TKE_Texture                     = 't',          
00583 
00584     TKE_Open_Segment                = '(',          
00585     TKE_Close_Segment               = ')',          
00586     TKE_Reopen_Segment              = 's',          
00587     TKE_Include_Segment             = '<',          
00588     TKE_Style_Segment               = '{',          
00589 
00590     TKE_Renumber_Key_Global         = 'K',          
00591     TKE_Renumber_Key_Local          = 'k',          
00592     TKE_Tag                         = 'q',          
00593 
00594     TKE_Bounding                    = 'b',          
00595     TKE_Bounding_Info               = 'B',          
00596     TKE_Callback                    = '\x07',       
00597     TKE_Camera                      = '>',          
00598     TKE_Color                       = '"',          
00599     TKE_Color_By_Index              = '\x08',       
00600     TKE_Color_By_Index_16           = '\x09',       
00601     TKE_Color_By_FIndex             = '\x0A',       
00602     TKE_Color_RGB                   = '~',          
00603     TKE_Color_By_Value              = '\x0B',       
00604     TKE_Color_Map                   = '\x0C',       
00605     TKE_Edge_Pattern                = '\x0D',       
00606     TKE_Edge_Weight                 = '\x0E',       
00607     TKE_Face_Pattern                = 'P',          
00608     TKE_Handedness                  = 'h',          
00609     TKE_Heuristics                  = 'H',          
00610     TKE_Line_Pattern                = '-',          
00611     TKE_Line_Weight                 = '=',          
00612     TKE_Marker_Size                 = '+',          
00613     TKE_Marker_Symbol               = '@',          
00614     TKE_Modelling_Matrix            = '%',          
00615     TKE_LOD                         = '\x19',       
00616     TKE_Rendering_Options           = 'R',          
00617     TKE_Selectability               = '!',          
00618     TKE_Text_Alignment              = '*',          
00619     TKE_Text_Font                   = 'F',          
00620     TKE_Text_Path                   = '|',          
00621     TKE_Text_Spacing                = ' ',          
00622     TKE_Texture_Matrix              = '$',          
00623     TKE_Unicode_Options             = '\x16',       
00624     TKE_User_Index                  = 'n',          
00625     TKE_User_Options                = 'U',          
00626     TKE_User_Value                  = 'v',          
00627     TKE_Visibility                  = 'V',          
00628     TKE_Window                      = 'W',          
00629     TKE_Window_Frame                = '#',          
00630     TKE_Window_Pattern              = 'p',          
00631 
00632     TKE_Area_Light                  = 'a',          
00633     TKE_Circle                      = 'C',          
00634     TKE_Circular_Arc                = 'c',          
00635     TKE_Circular_Chord              = '\\',         
00636     TKE_Circular_Wedge              = 'w',          
00637     TKE_Cutting_Plane               = '/',          
00638     TKE_Cylinder                    = 'Y',          
00639     TKE_Distant_Light               = 'd',          
00640     TKE_Ellipse                     = 'E',          
00641     TKE_Elliptical_Arc              = 'e',          
00642     TKE_Grid                        = 'g',          
00643     TKE_Image                       = 'i',          
00644     TKE_Line                        = 'l',          
00645     TKE_Local_Light                 = '.',          
00646     TKE_Marker                      = 'X',          
00647     TKE_Mesh                        = 'M',          
00648     TKE_NURBS_Curve                 = 'N',          
00649     TKE_NURBS_Surface               = 'A',          
00650     TKE_PolyCylinder                = 'Q',          
00651     TKE_Polygon                     = 'G',          
00652     TKE_Polyline                    = 'L',          
00653     TKE_PolyPolyline                = '\x10',       
00654     TKE_Shell                       = 'S',          
00655     TKE_Spot_Light                  = '^',          
00656     TKE_Text                        = 'T',          
00657     TKE_Text_With_Encoding          = 'x',          
00658 
00659     TKE_Start_User_Data             = '[',          
00660     TKE_Stop_User_Data              = ']',          
00661     TKE_XML                         = '\x18',       
00662     TKE_External_Reference          = '\x12',       
00663     TKE_URL                         = '\x15',       
00664 
00665     TKE_Start_Compression           = 'Z',          
00666     TKE_Stop_Compression            = 'z',          
00667 
00668     TKE_Repeat_Object               = '&',          
00669     TKE_View                        = '}',          
00670     TKE_Clip_Rectangle              = 'o',          
00671     TKE_Clip_Region                 = 'O',          
00672 
00673     TKE_File_Info                   = 'I',          
00674     TKE_Dictionary                  = 'D',          
00675 
00676     TKE_Tag_Implicit                = TKE_Tag,      //-- obsolete.  this alias provided for source compatibility with old code
00677     TKE_Streaming_Mode              = ',',          //-- obsolete.  probably no files ever generated with this
00678 
00679     TKE_Extended_Code               = '\xFF',       
00680 
00681 //
00682 //
00683 // W3D Extensions
00684 //
00685 //
00686 
00687     W3DE_Image                      = 0xE0
00688 };
00689 
00690 
00692 
00693 
00699 class BBINFILETK_API TK_Default : public BBaseOpcodeHandler {
00700     public:
00702         TK_Default () : BBaseOpcodeHandler (0) {}
00703 
00704         TK_Status   Read (BStreamFileToolkit & tk) alter;
00705         TK_Status   Write (BStreamFileToolkit & tk) alter;
00706 
00707 private:
00708     TK_Default(const TK_Default&);
00709     TK_Default& operator=(const TK_Default&);
00710 };
00711 
00717 class BBINFILETK_API TK_Unavailable : public BBaseOpcodeHandler {
00718     public:
00720         TK_Unavailable (char opcode) : BBaseOpcodeHandler (opcode) {}
00721 
00722         TK_Status   Read (BStreamFileToolkit & tk) alter;
00723         TK_Status   Write (BStreamFileToolkit & tk) alter;
00724 
00725 private:
00726     TK_Unavailable(const TK_Unavailable&);
00727     TK_Unavailable& operator=(const TK_Unavailable&);
00728 };
00729 
00732 
00738 class BBINFILETK_API TK_Header : public BBaseOpcodeHandler {
00739     protected:
00741         BBaseOpcodeHandler *    m_current_object;
00742 
00743     public:
00745         TK_Header () : BBaseOpcodeHandler (0), m_current_object (0) {}
00746         ~TK_Header();
00747 
00748         TK_Status   Read (BStreamFileToolkit & tk) alter;
00749         TK_Status   Write (BStreamFileToolkit & tk) alter;
00750         void        Reset (void) alter;
00751 
00752 private:
00753     TK_Header(const TK_Header&);
00754     TK_Header& operator=(const TK_Header&);
00755 };
00756 
00757 
00759 
00765 class BBINFILETK_API TK_File_Info : public BBaseOpcodeHandler {
00766     protected:
00768         int             m_flags;
00769 
00770     public:
00772         TK_File_Info () : BBaseOpcodeHandler (TKE_File_Info), m_flags (0) {}
00773 
00774         TK_Status   Read (BStreamFileToolkit & tk) alter;
00775         TK_Status   Write (BStreamFileToolkit & tk) alter;
00776         TK_Status   Execute (BStreamFileToolkit & tk) alter;
00777         TK_Status   Interpret (BStreamFileToolkit & tk, ID_Key key, int variant) alter;
00778         TK_Status   Interpret (BStreamFileToolkit & tk, ID_Key key, char const * special) alter
00779                                 { return BBaseOpcodeHandler::Interpret(tk, key, special); }
00780 
00782         void            SetFlags (int f) alter                  { m_flags = f;      }
00784         int             GetFlags (void) alter                   { return m_flags;   }
00785 
00786 private:
00787     TK_File_Info(const TK_File_Info&);
00788     TK_File_Info& operator=(const TK_File_Info&);
00789 };
00790 
00791 
00793 
00801 class BBINFILETK_API TK_Comment : public BBaseOpcodeHandler {
00802     private:
00803         TK_Comment(const TK_Comment&);
00804         TK_Comment& operator=(const TK_Comment&);
00805 
00806     protected:
00808         int             m_length;
00810         char *          m_comment;
00811 
00813         void    set_comment (char const * comment) alter;
00815         void    set_comment (int length) alter;
00816 
00817     public:
00819         TK_Comment (char const * comment = 0);
00820         ~TK_Comment();
00821 
00822         TK_Status   Read (BStreamFileToolkit & tk) alter;
00823         TK_Status   Write (BStreamFileToolkit & tk) alter;
00824         TK_Status   Execute (BStreamFileToolkit & tk) alter;
00827         TK_Status   Interpret (BStreamFileToolkit & , ID_Key , int ) { return TK_Normal; }
00828         void        Reset (void) alter;
00829 
00834         void            SetComment (char const * comment) alter { set_comment (comment); }
00839         void            SetComment (int length) alter           { set_comment (length);  }
00843         char const *    GetComment (void) const                 { return m_comment; }
00848         char alter *    GetComment (void) alter                 { return m_comment; }
00849 };
00850 
00851 
00853 
00861 class BBINFILETK_API TK_Terminator : public BBaseOpcodeHandler {
00862     private:
00863         TK_Terminator(const TK_Terminator&);
00864         TK_Terminator& operator=(const TK_Terminator&);
00865 
00866     public:
00868         TK_Terminator (char opcode) : BBaseOpcodeHandler (opcode) {}
00869 
00870         TK_Status   Read (BStreamFileToolkit & tk) alter;
00871         TK_Status   Write (BStreamFileToolkit & tk) alter;
00872         TK_Status   Execute (BStreamFileToolkit & tk) alter;
00873 };
00874 
00875 
00877 
00884 class BBINFILETK_API TK_Compression : public BBaseOpcodeHandler {
00885     private:
00886         TK_Compression(const TK_Compression&);
00887         TK_Compression& operator=(const TK_Compression&);
00888 
00889     public:
00891         TK_Compression (char opcode) : BBaseOpcodeHandler (opcode) {}
00892 
00893         TK_Status   Read (BStreamFileToolkit & tk) alter;
00894         TK_Status   Write (BStreamFileToolkit & tk) alter;
00895         TK_Status   Execute (BStreamFileToolkit & tk) alter;
00896         TK_Status   Interpret (BStreamFileToolkit & tk, ID_Key key, int variant) alter;
00897         TK_Status   Interpret (BStreamFileToolkit & tk, ID_Key key, char const * special) alter
00898                                 { return BBaseOpcodeHandler::Interpret(tk, key, special); }
00899 };
00900 
00902 
00904 
00914 class BBINFILETK_API TK_Open_Segment : public BBaseOpcodeHandler {
00915     private:
00916         TK_Open_Segment(const TK_Open_Segment&);
00917         TK_Open_Segment& operator=(const TK_Open_Segment&);
00918 
00919     protected:
00920         int             m_length;   
00921         int             m_allocated;
00922         char *          m_string;   
00924 
00925         void    set_segment (char const * segment) alter;
00927         void    set_segment (int length) alter;
00928 
00929     public:
00931         TK_Open_Segment () : BBaseOpcodeHandler (TKE_Open_Segment), m_length (0), m_allocated (0), m_string (0) {}
00932         ~TK_Open_Segment();
00933 
00934         TK_Status   Read (BStreamFileToolkit & tk) alter;
00935         TK_Status   Write (BStreamFileToolkit & tk) alter;
00936         void        Reset (void) alter;
00937 
00942         void            SetSegment (char const * segment) alter { set_segment (segment); }
00943 
00948         void            SetSegment (int length) alter           { set_segment (length); }
00949 
00953         char const *    GetSegment (void) const                 { return m_string; }
00958         char alter *    GetSegment (void) alter                 { return m_string; }
00959 };
00960 
00961 
00963 
00972 class BBINFILETK_API TK_Close_Segment : public BBaseOpcodeHandler {
00973     private:
00974         TK_Close_Segment(const TK_Close_Segment&);
00975         TK_Close_Segment& operator=(const TK_Close_Segment&);
00976 
00977     public:
00979         TK_Close_Segment () : BBaseOpcodeHandler (TKE_Close_Segment) {}
00980 
00981         TK_Status   Read (BStreamFileToolkit & tk) alter;
00982         TK_Status   Write (BStreamFileToolkit & tk) alter;
00983 };
00984 
00985 
00986 
00988 
01000 class BBINFILETK_API TK_Reopen_Segment : public BBaseOpcodeHandler {
01001     private:
01002         TK_Reopen_Segment(const TK_Reopen_Segment&);
01003         TK_Reopen_Segment& operator=(const TK_Reopen_Segment&);
01004 
01005     protected:
01006         int             m_index;   
01008     public:
01010         TK_Reopen_Segment () : BBaseOpcodeHandler (TKE_Reopen_Segment), m_index (-1) {}
01011 
01012         TK_Status   Read (BStreamFileToolkit & tk) alter;
01013         TK_Status   Write (BStreamFileToolkit & tk) alter;
01014 
01016         void            SetIndex (int i) alter      { m_index = i;      }
01018         int          GetIndex (void) const       { return m_index;   }
01019 };
01020 
01021 
01023 
01031 class BBINFILETK_API TK_Referenced_Segment : public BBaseOpcodeHandler {
01032     private:
01033         TK_Referenced_Segment(const TK_Referenced_Segment&);
01034         TK_Referenced_Segment& operator=(const TK_Referenced_Segment&);
01035 
01036     protected:
01037         int             m_length;               
01038         int             m_allocated;            
01039         char *          m_string;               
01041         ID_Key          m_key;                  
01042         BBaseOpcodeHandler *     m_referee;     
01043         bool            m_follow;               
01044 
01045         void    set_segment (char const * segment) alter;   
01046         void    set_segment (int length) alter;             
01047 
01048     public:
01050         TK_Referenced_Segment (unsigned char opcode);
01051         ~TK_Referenced_Segment();
01052 
01053         TK_Status   Read (BStreamFileToolkit & tk) alter;
01054         TK_Status   Write (BStreamFileToolkit & tk) alter;
01055         void        Reset (void) alter;
01056 
01061         void            SetSegment (char const * segment) alter { set_segment (segment); }
01066         void            SetSegment (int length) alter           { set_segment (length); }
01070         char const *    GetSegment (void) const                 { return m_string; }
01075         char alter *    GetSegment (void) alter                 { return m_string; }
01076 
01078         void            SetFollow (bool f) alter                { m_follow = f;     }
01080         bool            GetFollow (void) alter                  { return m_follow;  }
01081 };
01082 
01083 
01087 enum Instance_Options {
01088     Instance_By_Tristrip    = 0x01
01089 };
01090 
01091 
01093 
01101 class BBINFILETK_API TK_Instance : public BBaseOpcodeHandler {
01102     private:
01103         TK_Instance(const TK_Instance&);
01104         TK_Instance& operator=(const TK_Instance&);
01105 
01106     protected:
01107         int             m_from_index;   
01108         int             m_from_variant; 
01109         int             m_to_index;     
01110         int             m_to_variant;   
01111         int             m_options;      
01112         float           m_matrix[16];   
01113 
01114     public:
01116         TK_Instance (int from_index=0, int from_variant=0, int to_index=0, int to_variant=0,
01117                      int options=0, float const * xform=0);
01118 
01119         TK_Status   Read (BStreamFileToolkit & tk) alter;
01120         TK_Status   Write (BStreamFileToolkit & tk) alter;
01121         void        Reset () alter;
01122 };
01123 
01124 
01126 
01127 
01129 
01132 class BBINFILETK_API TK_LOD : public BBaseOpcodeHandler {
01133     private:
01134         TK_LOD(const TK_LOD&);
01135         TK_LOD& operator=(const TK_LOD&);
01136 
01137     protected:
01138         int *m_num_primitives;              
01139         BBaseOpcodeHandler ***m_primitives; 
01140         int m_highest_level;                
01141         int m_levels_allocated;             
01142         int m_substage;                     
01143         struct vlist_s *m_current_working;  
01144         int m_current_level;            
01145 
01146         TK_Status   ReadOneList (BStreamFileToolkit & tk) alter;  
01147 
01148     public:
01150         TK_LOD () : BBaseOpcodeHandler (TKE_LOD) {
01151             m_num_primitives = 0;
01152             m_primitives = 0;
01153             m_highest_level = 0;
01154             m_levels_allocated = 0;
01155             m_substage = 0;
01156             m_current_working = 0;
01157             m_current_level = 0;
01158         }
01159         ~TK_LOD();
01160 
01161         TK_Status   Read (BStreamFileToolkit & tk) alter;
01162         TK_Status   Write (BStreamFileToolkit & tk) alter;
01163         void        Reset (void) alter;
01164 };
01166 #define TKLOD_ESCAPE 255
01167 
01168 
01170 
01172 
01181 class BBINFILETK_API TK_Renumber : public BBaseOpcodeHandler {
01182     private:
01183         TK_Renumber(const TK_Renumber&);
01184         TK_Renumber& operator=(const TK_Renumber&);
01185 
01186     protected:
01187         ID_Key          m_key; 
01188 
01189     public:
01193         TK_Renumber (unsigned char opcode, ID_Key key = 0) : BBaseOpcodeHandler (opcode), m_key (key) {}
01194 
01195         TK_Status   Read (BStreamFileToolkit & tk) alter;
01196         TK_Status   Write (BStreamFileToolkit & tk) alter;
01197 
01199         void            SetKey (ID_Key k) alter     { m_key = k;    }
01201         ID_Key          GetKey (void) const         { return m_key; }
01202 };
01203 
01204 
01206 
01211 class BBINFILETK_API TK_Tag : public BBaseOpcodeHandler {
01212     private:
01213         TK_Tag(const TK_Tag&);
01214         TK_Tag& operator=(const TK_Tag&);
01215 
01216     protected:
01217 
01218     public:
01220         TK_Tag (unsigned char opcode = TKE_Tag) : BBaseOpcodeHandler (opcode) {}
01221 
01222         TK_Status   Read (BStreamFileToolkit & tk) alter;
01223         TK_Status   Write (BStreamFileToolkit & tk) alter;
01224         TK_Status   Execute (BStreamFileToolkit & tk) alter;
01225         TK_Status   Interpret (BStreamFileToolkit & tk, ID_Key key, int variant=0) alter;
01226         TK_Status   Interpret (BStreamFileToolkit & tk, ID_Key key, char const * special) alter
01227                                 { return BBaseOpcodeHandler::Interpret(tk, key, special); }
01228 };
01229 
01231 
01238 // Note: unlike most opcode handlers, this one does not contain its own data, it is primarily a
01239 // wrapper around the key <-> index translation table in the toolkit.
01240 class BBINFILETK_API TK_Dictionary : public BBaseOpcodeHandler {
01241     private:
01242         TK_Dictionary(const TK_Dictionary&);
01243         TK_Dictionary& operator=(const TK_Dictionary&);
01244 
01245     protected:
01246         unsigned char   m_format;       
01247         int             m_offset;       
01248         int             m_placeholder;  
01249         unsigned char   m_present;      
01250 
01251         Internal_Translator::Index_Key_Pair alter * m_item; 
01252 
01253     public:
01255         TK_Dictionary () : BBaseOpcodeHandler (TKE_Dictionary), m_format (0) {}
01256 
01257         TK_Status   Read (BStreamFileToolkit & tk) alter;
01258         TK_Status   Write (BStreamFileToolkit & tk) alter;
01259         TK_Status   Execute (BStreamFileToolkit & tk) alter;
01260         TK_Status   Interpret (BStreamFileToolkit & tk, ID_Key key, int variant=0) alter;
01261         TK_Status   Interpret (BStreamFileToolkit & tk, ID_Key key, char const * special) alter
01262                                 { return BBaseOpcodeHandler::Interpret(tk, key, special); }
01263         void        Reset (void) alter;
01264 };
01265 
01266 
01268 
01272 enum TKO_Geometry_Bits {
01273     // first byte is common/shared items, plus flag for extended bits
01274     TKO_Geo_Face            = 0x00000001,
01275     TKO_Geo_Edge            = 0x00000002,
01276     TKO_Geo_Line            = 0x00000004,
01277     TKO_Geo_Marker          = 0x00000008,
01278     TKO_Geo_Text            = 0x00000010,
01279     TKO_Geo_Window          = 0x00000020,
01280     TKO_Geo_Image           = 0x00000040,   // not used by color
01281 
01282     TKO_Geo_Extended        = 0x00000080,
01283 
01284     // extras for color
01285     TKO_Geo_Ambient         = 0x00000100,
01286     TKO_Geo_Light           = 0x00000200,
01287     TKO_Geo_Face_Contrast   = 0x00000400,
01288     TKO_Geo_Window_Contrast = 0x00000800,
01289     TKO_Geo_Front           = 0x00001000,
01290     TKO_Geo_Back            = 0x00002000,
01291     TKO_Geo_Vertex          = 0x00004000,
01292 
01293     TKO_Geo_Geom_Colors     = 0x0000701F,
01294     TKO_Geo_Every_Colors    = 0x000073BF,
01295     TKO_Geo_All_Colors      = 0x00007FFF,
01296     TKO_Geo_Extended_Colors = 0x00008000,
01297 
01298     //extras for selectability (light is same as for color)
01299     TKO_Geo_String_Cursor   = 0x00000100,
01300 
01301     TKO_Geo_Geom_Selects    = 0x000043DF,
01302     TKO_Geo_All_Selects     = 0x000043FF,
01303 
01304     // extras for visibility (string cursor same as selectability)
01305     TKO_Geo_Face_Lighting   = 0x00000200,
01306     TKO_Geo_Edge_Lighting   = 0x00000400,
01307     TKO_Geo_Marker_Lighting = 0x00000800,
01308     TKO_Geo_Light_Visibles  = 0x00000E00,
01309 
01310     TKO_Geo_Silhouette_Edge = 0x00001000,
01311     TKO_Geo_Perimeter_Edge  = 0x00002000,
01312     TKO_Geo_Mesh_Quad       = 0x00004000,
01313     TKO_Geo_Hard_Edge       = 0x00008000,
01314     TKO_Geo_Edge_Visibles   = 0x0000F002,
01315     TKO_Geo_Cut_Edge        = 0x00100000,
01316     TKO_Geo_Cut_Face        = 0x00400000,
01317     TKO_Geo_Cut_Geometry    = 0x00500000,
01318 
01319     TKO_Geo_Cutting_Plane   = 0x00010000,
01320     TKO_Geo_Vertex_Vis      = 0x00200000,
01321 
01322     TKO_Geo_Geom_Visibles   = 0x0001FFFF,
01323 
01324     TKO_Geo_Shadow_Emit     = 0x00020000,
01325     TKO_Geo_Shadow_Cast     = 0x00040000,
01326     TKO_Geo_Shadow_Receive  = 0x00080000,
01327     TKO_Geo_Shadow_Visibles = 0x000E0000,
01328 
01329     TKO_Geo_Extended2       = 0x00800000,
01330 
01331     TKO_Geo_All_Visibles    = 0x002FFFFF
01332 };
01333 
01334 
01338 enum TKO_Color_Channels {
01339     TKO_Channel_Diffuse        = 0,
01340     TKO_Channel_Specular        = 1,
01341     TKO_Channel_Mirror          = 2,
01342     TKO_Channel_Transmission    = 3,
01343     TKO_Channel_Emission        = 4,
01344     TKO_Channel_Gloss           = 5,
01345     TKO_Channel_Index           = 6,
01346     TKO_Channel_Extended        = 7,
01347     TKO_Channel_Environment     = 8,
01348     TKO_Channel_Bump            = 9,
01349 
01350     TKO_Channel_Count           = 10
01351 };
01352 
01353 
01355 
01360 class BBINFILETK_API TK_Color : public BBaseOpcodeHandler {
01361     private:
01362         TK_Color(const TK_Color&);
01363         TK_Color& operator=(const TK_Color&);
01364 
01365     protected:
01366         int             m_mask;     
01367         short           m_channels; 
01368 
01372         class BBINFILETK_API channel {
01373             public:
01374                 float   m_rgb[3];      
01375                 char *  m_name;        
01376 
01377                 channel() : m_name (0) {}
01378                 ~channel() { ::delete [] m_name; }
01379                 void    Reset (void) alter  { ::delete [] m_name;  m_name = 0; }    
01380         };
01381 
01382         channel         m_diffuse;      
01383         channel         m_specular;     
01384         channel         m_mirror;       
01385         channel         m_transmission; 
01386         channel         m_emission;     
01387         channel         m_environment;  
01388         channel         m_bump;         
01389         float           m_gloss;        
01390         float           m_index;        
01391 
01393         void    set_channel_rgb (channel alter & c, float r, float g, float b, int channel = -1) alter {
01394                         c.m_rgb[0] = r;     c.m_rgb[1] = g;     c.m_rgb[2] = b;
01395                         if( channel != -1 )
01396                             m_channels |= (1 << channel);
01397                     }
01399         void    set_channel_name (channel alter & c, char const * name, int channel = -1) alter;
01401         void    set_channel_name (channel alter & c, int length, int channel = -1) alter;
01402 
01403     public:
01404         TK_Color ();
01405         ~TK_Color ();
01406 
01407         TK_Status   Read (BStreamFileToolkit & tk) alter;
01408         TK_Status   Write (BStreamFileToolkit & tk) alter;
01409         void        Reset (void) alter;
01410 
01412         void            SetGeometry (int m) alter                       { m_mask = m;                           }
01414         int             GetGeometry (void) const                        { return m_mask;                        }
01416         void            SetChannels (int c) alter                       { m_channels = (short)c;                }
01418         int             GetChannels (void) const                        { return (int)m_channels;               }
01419 
01421         void            SetDiffuse (float r, float g, float b) alter    { set_channel_rgb (m_diffuse, r, g, b); }
01423         void            SetDiffuse (float const * rgb) alter            { SetDiffuse (rgb[0], rgb[1], rgb[2]);  }
01425         void            SetDiffuseName (char const * name) alter        { set_channel_name (m_diffuse, name, TKO_Channel_Diffuse); }
01427         void            SetDiffuseName (int length) alter               { set_channel_name (m_diffuse, length, TKO_Channel_Diffuse); }
01429         float const *   GetDiffuse (void) const                         { return m_diffuse.m_rgb;               }
01431         char const *    GetDiffuseName (void) const                     { return m_diffuse.m_name;              }
01433         char alter *    GetDiffuseName (void) alter                     { return m_diffuse.m_name;              }
01434 
01436         void            SetSpecular (float r, float g, float b) alter   { set_channel_rgb (m_specular, r, g, b);}
01438         void            SetSpecular (float const * rgb) alter           { SetSpecular (rgb[0], rgb[1], rgb[2]); }
01440         void            SetSpecularName (char const * name) alter       { set_channel_name (m_specular, name, TKO_Channel_Specular);  }
01442         void            SetSpecularName (int length) alter              { set_channel_name (m_specular, length, TKO_Channel_Specular);}
01444         float const *   GetSpecular (void) const                        { return m_specular.m_rgb;              }
01446         char const *    GetSpecularName (void) const                    { return m_specular.m_name;             }
01448         char alter *    GetSpecularName (void) alter                    { return m_specular.m_name;             }
01449 
01451         void            SetMirror (float r, float g, float b) alter     { set_channel_rgb (m_mirror, r, g, b);  }
01453         void            SetMirror (float const * rgb) alter             { SetMirror (rgb[0], rgb[1], rgb[2]);   }
01455         void            SetMirrorName (char const * name) alter         { set_channel_name (m_mirror, name, TKO_Channel_Mirror);    }
01457         void            SetMirrorName (int length) alter                { set_channel_name (m_mirror, length, TKO_Channel_Mirror);  }
01459         float const *   GetMirror (void) const                          { return m_mirror.m_rgb;                }
01461         char const *    GetMirrorName (void) const                      { return m_mirror.m_name;               }
01463         char alter *    GetMirrorName (void) alter                      { return m_mirror.m_name;               }
01464 
01466         void            SetTransmission (float r, float g, float b) alter { set_channel_rgb (m_transmission, r, g, b); }
01468         void            SetTransmission (float const * rgb) alter         { SetTransmission (rgb[0], rgb[1], rgb[2]);  }
01470         void            SetTransmissionName (char const * name) alter     { set_channel_name (m_transmission, name, TKO_Channel_Transmission);   }
01472         void            SetTransmissionName (int length) alter            { set_channel_name (m_transmission, length, TKO_Channel_Transmission); }
01474         float const *   GetTransmission (void) const                      { return m_transmission.m_rgb;               }
01476         char const *    GetTransmissionName (void) const                  { return m_transmission.m_name;              }
01478         char alter *    GetTransmissionName (void) alter                  { return m_transmission.m_name;              }
01479 
01481         void            SetEmission (float r, float g, float b) alter   { set_channel_rgb (m_emission, r, g, b);}
01483         void            SetEmission (float const * rgb) alter           { SetEmission (rgb[0], rgb[1], rgb[2]); }
01485         void            SetEmissionName (char const * name) alter       { set_channel_name (m_emission, name, TKO_Channel_Emission);  }
01487         void            SetEmissionName (int length) alter              { set_channel_name (m_emission, length, TKO_Channel_Emission);}
01489         float const *   GetEmission (void) const                        { return m_emission.m_rgb;              }
01491         char const *    GetEmissionName (void) const                    { return m_emission.m_name;             }
01493         char alter *    GetEmissionName (void) alter                    { return m_emission.m_name;             }
01494 
01496         void            SetEnvironmentName (char const * name) alter    { set_channel_name (m_environment, name, TKO_Channel_Environment);   }
01498         void            SetEnvironmentName (int length) alter           { set_channel_name (m_environment, length, TKO_Channel_Environment); }
01500         char const *    GetEnvironmentName (void) const                 { return m_environment.m_name;              }
01502         char alter *    GetEnvironmentName (void) alter                 { return m_environment.m_name;              }
01503 
01505         void            SetBumpName (char const * name) alter           { set_channel_name (m_bump, name, TKO_Channel_Bump);      }
01507         void            SetBumpName (int length) alter                  { set_channel_name (m_bump, length, TKO_Channel_Bump);    }
01509         char const *    GetBumpName (void) const                        { return m_bump.m_name;                 }
01511         char alter *    GetBumpName (void) alter                        { return m_bump.m_name;                 }
01512 
01514         void            SetGloss (float g) alter                        { m_gloss = g; m_channels |= (1<<TKO_Channel_Gloss); }
01516         float           GetGloss (void) const                           { return m_gloss;                       }
01518         void            SetIndex (float i) alter                        { m_index = i; m_channels |= (1<<TKO_Channel_Index); }
01520         float           GetIndex (void) const                           { return m_index;                       }
01521 };
01522 
01523 
01525 
01530 class BBINFILETK_API TK_Color_RGB : public BBaseOpcodeHandler {
01531     private:
01532         TK_Color_RGB(const TK_Color_RGB&);
01533         TK_Color_RGB& operator=(const TK_Color_RGB&);
01534 
01535     protected:
01536         int             m_mask;     
01537         float           m_rgb[3];   
01538 
01539     public:
01541         TK_Color_RGB () : BBaseOpcodeHandler (TKE_Color_RGB), m_mask (0) {}
01542 
01543         TK_Status   Read (BStreamFileToolkit & tk) alter;
01544         TK_Status   Write (BStreamFileToolkit & tk) alter;
01545 
01550         void            SetGeometry (int m) alter                   { m_mask = m;                           }
01555         int             GetGeometry (void) const                    { return m_mask;                        }
01556 
01558         void            SetRGB (float r, float g, float b) alter    { m_rgb[0] = r; m_rgb[1] = g; m_rgb[2] = b; }
01560         void            SetRGB (float const * rgb) alter            { SetRGB (rgb[0], rgb[1], rgb[2]);          }
01562         float const *   GetRGB (void) const                         { return m_rgb;                             }
01563 };
01564 
01565 
01567 
01572 class BBINFILETK_API TK_Color_By_Value : public BBaseOpcodeHandler {
01573     private:
01574         TK_Color_By_Value(const TK_Color_By_Value&);
01575         TK_Color_By_Value& operator=(const TK_Color_By_Value&);
01576 
01577     protected:
01578         int             m_mask;         
01579         float           m_value[3];     
01580         char            m_space;        
01581 
01582     public:
01584         TK_Color_By_Value () : BBaseOpcodeHandler (TKE_Color_By_Value), m_mask (0) {}
01585 
01586         TK_Status   Read (BStreamFileToolkit & tk) alter;
01587         TK_Status   Write (BStreamFileToolkit & tk) alter;
01588 
01593         void            SetGeometry (int m) alter               { m_mask = m;                                   }
01598         int             GetGeometry (void) const                { return m_mask;                                }
01599 
01601         void            SetSpace (int s) alter                  { m_space = (char)s;                            }
01603         int             GetSpace (void) const                   { return (int)m_space;                          }
01604 
01606         void            SetValue (float a, float b, float c) alter  {
01607                                 m_value[0] = a;     m_value[1] = b;     m_value[2] = c;
01608                             }
01610         void            SetValue (float const * triple) alter   { SetValue (triple[0], triple[1], triple[2]);   }
01612         float const *   GetValue (void) const                   { return m_value;                               }
01613 };
01614 
01615 
01617 
01623 class BBINFILETK_API TK_Color_By_Index : public BBaseOpcodeHandler {
01624     private:
01625         TK_Color_By_Index(const TK_Color_By_Index&);
01626         TK_Color_By_Index& operator=(const TK_Color_By_Index&);
01627 
01628     protected:
01629         int             m_mask;     
01630         int             m_index;    
01631 
01632     public:
01634         TK_Color_By_Index (unsigned char opcode) : BBaseOpcodeHandler (opcode), m_mask (0), m_index (-1) {}
01635 
01636         TK_Status   Read (BStreamFileToolkit & tk) alter;
01637         TK_Status   Write (BStreamFileToolkit & tk) alter;
01638 
01643         void            SetGeometry (int m) alter   { m_mask = m;       }
01648         int             GetGeometry (void) const    { return m_mask;    }
01649 
01651         void            SetIndex (int i) alter      { m_index = i;      }
01653         int             GetIndex (void) const       { return m_index;   }
01654 };
01655 
01657 
01662 class BBINFILETK_API TK_Color_By_FIndex : public BBaseOpcodeHandler {
01663     private:
01664         TK_Color_By_FIndex(const TK_Color_By_FIndex&);
01665         TK_Color_By_FIndex& operator=(const TK_Color_By_FIndex&);
01666 
01667     protected:
01668         int             m_mask;     
01669         float           m_index;    
01670 
01671     public:
01673         TK_Color_By_FIndex () : BBaseOpcodeHandler (TKE_Color_By_FIndex), m_mask (0), m_index (-1.0f) {}
01674 
01675         TK_Status   Read (BStreamFileToolkit & tk) alter;
01676         TK_Status   Write (BStreamFileToolkit & tk) alter;
01677 
01682         void            SetGeometry (int m) alter   { m_mask = m;       }
01687         int             GetGeometry (void) const    { return m_mask;    }
01688 
01690         void            SetIndex (float val) alter    { m_index = val;      }
01692         float           GetIndex (void) const       { return m_index;   }
01693 };
01694 
01697 
01702 class BBINFILETK_API TK_Color_Map : public BBaseOpcodeHandler {
01703     private:
01704         TK_Color_Map(const TK_Color_Map&);
01705         TK_Color_Map& operator=(const TK_Color_Map&);
01706 
01707     protected:
01708         int             m_length;           
01709         float           m_values[3*256];    
01710         unsigned char   m_format;           
01711 
01715         enum TKO_Map_Format {
01716             TKO_Map_RGB_Values,     
01717             TKO_Map_Complex_Colors,
01718             TKO_Map_Textures,
01719             TKO_Map_Mixed
01720         };
01721 
01723         void    set_values (int length, float const * values = 0) alter;
01724 
01725     public:
01727         TK_Color_Map ()
01728             : BBaseOpcodeHandler (TKE_Color_Map), m_length (0), m_format (TKO_Map_RGB_Values) {}
01729 
01730         TK_Status   Read (BStreamFileToolkit & tk) alter;
01731         TK_Status   Write (BStreamFileToolkit & tk) alter;
01732 
01734         void            SetFormat (int f) alter                                 { m_format = (unsigned char)f;  }
01736         int             GetFormat (void) const                                  { return (int)m_format;         }
01737 
01742         void            SetValues (int count, float const * values = 0) alter   { set_values (count, values);   }
01744         float const *   GetValues (void) const                                  { return m_values;              }
01746         float alter *   GetValues (void) alter                                  { return m_values;              }
01748         int             GetLength (void) const                                  { return m_length;              }
01749 };
01750 
01752 
01755 
01761 class BBINFILETK_API TK_Callback : public BBaseOpcodeHandler {
01762     private:
01763         TK_Callback(const TK_Callback&);
01764         TK_Callback& operator=(const TK_Callback&);
01765 
01766     protected:
01767         int                     m_length;       
01768         char *                  m_string;       
01771         void    set_callback (char const * callback) alter;  
01772 
01773         void    set_callback (int length) alter;             
01774 
01775     public:
01777         TK_Callback () : BBaseOpcodeHandler (TKE_Callback), m_length (0), m_string (0) {}
01778         ~TK_Callback();
01779 
01780         TK_Status   Read (BStreamFileToolkit & tk) alter;
01781         TK_Status   Write (BStreamFileToolkit & tk) alter;
01782         void        Reset (void) alter;
01783 
01785         void            SetCallback (char const * callback) alter   { set_callback (callback);  }
01787         void            SetCallback (int length) alter              { set_callback (length);    }
01789         char const *    GetCallback (void) const                    { return m_string;          }
01791         char alter *    GetCallback (void) alter                    { return m_string;          }
01792 };
01793 
01795 
01796 
01804 enum TKO_Rendering_Option_Bits {
01805     TKO_Interp_Texture_Faces            = 0x00000001,
01806     TKO_Interp_Texture_Edges            = 0x00000002,
01807     TKO_Interp_Texture_Markers          = 0x00000004,
01808     TKO_Interp_Texture                  = 0x00000007,
01809 
01810     TKO_Interp_Color_Faces              = 0x00000008,
01811     TKO_Interp_Color_Edges              = 0x00000010,
01812     TKO_Interp_Color_Markers            = 0x00000020,
01813     TKO_Interp_Color                    = 0x00000038,
01814 
01815     TKO_Interp_Index_Faces              = 0x00000040,
01816     TKO_Interp_Index_Edges              = 0x00000080,
01817     TKO_Interp_Index                    = 0x000000C0,
01818 
01819     TKO_Interp_Lighting_Faces_Gouraud   = 0x00000100,
01820     TKO_Interp_Lighting_Faces_Phong     = 0x00000200,
01821     TKO_Interp_Lighting_Edges_Gouraud   = 0x00000400,
01822     TKO_Interp_Lighting_Edges_Phong     = 0x00000800,
01823     TKO_Interp_Lighting_Faces           = 0x00000300,
01824     TKO_Interp_Lighting_Edges           = 0x00000C00,
01825     TKO_Interp_Lighting                 = 0x00000F00,
01826 
01827     TKO_Rendo_HSR_Algorithm             = 0x00001000,
01828     TKO_Rendo_THSR_Algorithm            = 0x00002000,
01829     TKO_Rendo_Any_HSR                   = 0x00003000,
01830 
01831     TKO_Rendo_Local_Viewer              = 0x00004000,
01832     TKO_Rendo_Perspective_Correction    = 0x00008000,
01833     TKO_Rendo_Display_Lists             = 0x00010000,
01834 
01835     TKO_Rendo_Debug                     = 0x00020000,
01836 
01837     TKO_Rendo_Technology                = 0x00040000,
01838     TKO_Rendo_Quantization              = 0x00080000,
01839     TKO_Rendo_TQ                        = 0x000C0000,
01840 
01841     TKO_Rendo_Attribute_Lock            = 0x00100000,
01842 
01843     TKO_Rendo_Face_Displacement         = 0x00200000,
01844     TKO_Rendo_Fog                       = 0x00400000,
01845 
01846     TKO_Rendo_Buffer_Options            = 0x00800000,
01847     TKO_Rendo_Hidden_Line_Options       = 0x01000000,
01848 
01849     TKO_Rendo_LOD                       = 0x02000000,
01850     TKO_Rendo_LOD_Options               = 0x04000000,
01851 
01852     TKO_Rendo_NURBS_Curve_Options       = 0x08000000,
01853     TKO_Rendo_NURBS_Surface_Options     = 0x10000000,
01854     TKO_Rendo_NURBS_Options             = 0x18000000,
01855 
01856     TKO_Rendo_Stereo                    = 0x20000000,
01857     TKO_Rendo_Stereo_Separation         = 0x40000000,
01858 
01859 // hpux doesn't like the high bit set as part of the enumerated type
01860 //      TKO_Rendo_Extended              = 0x80000000,
01861 #define TKO_Rendo_Extended                0x80000000
01862 
01863     // extended settings
01864     TKO_Rendo_Tessellation              = 0x00000001,
01865     TKO_Rendo_Transparency_Style        = 0x00000002,
01866     TKO_Rendo_Transparency_Hardware     = 0x00000004,
01867     TKO_Rendo_Cut_Geometry              = 0x00000008,
01868     TKO_Rendo_Depth_Range               = 0x00000010,
01869 
01870     // type for specific fields
01871     TKO_HSR_Hardware                    = 0,
01872     TKO_HSR_SZB                         = 1,
01873     TKO_HSR_Painters                    = 2,
01874     TKO_HSR_Z_Sort_Only                 = 3,
01875     TKO_HSR_Priority                    = 4,
01876     TKO_HSR_Spider_Web                  = 5,
01877     TKO_HSR_Hidden_Line                 = 6,
01878     TKO_HSR_None                        = 7,    // for transparency
01879     TKO_HSR_Fast_Hidden_Line            = 8,
01880     TKO_HSR_Mask                        = 0x0F,
01881     TKO_THSR_Mask                       = 0xF0,
01882 
01883     TKO_Transparency_None               = 0,
01884     TKO_Transparency_Blending           = 1,
01885     TKO_Transparency_Screen_Door        = 2,
01886 
01887     TKO_Cut_Geometry_Level              = 0x01,
01888     TKO_Cut_Geometry_Tolerance          = 0x02,
01889     TKO_Cut_Geometry_Match_Color_On     = 0x04,
01890     TKO_Cut_Geometry_Match_Color_Off    = 0x08,
01891     TKO_Cut_Geometry_Level_Entity       = 0,
01892     TKO_Cut_Geometry_Level_Segment      = 1,
01893     TKO_Cut_Geometry_Level_Segment_Tree = 2,
01894 
01895     TKO_Technology_Standard             = 0x01,
01896     TKO_Technology_Soft_Frame_Buffer    = 0x02,
01897     TKO_Technology_Radiosity            = 0x04,
01898     TKO_Technology_Ray_Trace            = 0x08,
01899     TKO_Technology_Mask                 = 0x0F,
01900 
01901     TKO_Quantization_Threshold          = 0x10,
01902     TKO_Quantization_Dither             = 0x20,
01903     TKO_Quantization_Error_Diffusion    = 0x40,
01904     TKO_Quantization_Mask               = 0xF0,
01905 
01906     TKO_Buffer_Size_Limit               = 0x01,
01907     TKO_Buffer_Retention                = 0x02,
01908     TKO_Buffer_Color_Depth_Match        = 0x04,
01909     TKO_Buffer_Color_Depth_Full         = 0x08,
01910 
01911     TKO_Hidden_Line_Visibility_On           = 0x0001,
01912     TKO_Hidden_Line_Visibility_Off          = 0x0002,
01913     TKO_Hidden_Line_Pattern                 = 0x0004,
01914     TKO_Hidden_Line_Face_Displacement       = 0x0008,
01915     TKO_Hidden_Line_Dim_Factor              = 0x0010,
01916     TKO_Hidden_Line_Render_Faces_On         = 0x0020,
01917     TKO_Hidden_Line_Render_Faces_Off        = 0x0040,
01918     TKO_Hidden_Line_Extended                = 0x0080,
01919     TKO_Hidden_Line_Silhouette_Cleanup_On   = 0x0100,
01920     TKO_Hidden_Line_Silhouette_Cleanup_Off  = 0x0200,
01921     TKO_Hidden_Line_Extended_Mask           = 0xFF00,
01922     TKO_Hidden_Line_Extended2               = 0x8000,
01923 
01924     TKO_LOD_Conserve_Memory             = 0x00000001,
01925     TKO_LOD_Screen_Space                = 0x00000002,
01926     TKO_LOD_Physical                    = 0x00000004,
01927     TKO_LOD_Tolerance_FRU               = 0x00000008,
01928     TKO_LOD_Tolerance_ORU               = 0x00000010,
01929     TKO_LOD_Preprocess                  = 0x00000020,
01930     TKO_LOD_Bounding_Current            = 0x00000040,
01931     TKO_LOD_Bounding_Explicit           = 0x00000080,
01932     TKO_LOD_Ratio                       = 0x00000100,
01933     TKO_LOD_Threshold                   = 0x00000200,
01934     TKO_LOD_Min_Triangle_Count          = 0x00000400,
01935     TKO_LOD_Clamp                       = 0x00000800,
01936     TKO_LOD_Num_Levels                  = 0x00001000,
01937     TKO_LOD_Max_Degree                  = 0x00002000,
01938     TKO_LOD_Tolerance                   = 0x00004000,
01939     TKO_LOD_Usefulness_Heuristic        = 0x00008000,
01940     TKO_LOD_Calculation_Cutoff          = 0x00010000,
01941     TKO_LOD_Fallback                    = 0x00020000,
01942     TKO_LOD_Collapse_Vertices           = 0x00040000,
01943     TKO_LOD_Algorithm                   = 0x00080000,
01944     TKO_LOD_Mode_Segment                = 0x00100000,
01945 
01946     TKO_LOD_Threshold_Tris_Per_Pix_Sq   = 1,
01947     TKO_LOD_Threshold_Tris_Per_CM_Sq    = 2,
01948     TKO_LOD_Threshold_Percent_Area      = 3,
01949 
01950     TKO_LOD_Algorithm_Fast              = 1,
01951     TKO_LOD_Algorithm_Nice              = 2,
01952 
01953     TKO_LOD_Heur_Is_Diagonal            = 0x00,
01954     TKO_LOD_Heur_Is_Per_Triangle        = 0x01,
01955     TKO_LOD_Heur_Is_Ratio               = 0x02,
01956     TKO_LOD_Heur_Is_Volume              = 0x04,
01957     TKO_LOD_Heur_Triangle_Size          = 0x08,
01958 
01959     TKO_LOD_Heur_Diag                   = 0,
01960     TKO_LOD_Heur_Tri_Diag               = 1,
01961     TKO_LOD_Heur_Diag_Ratio             = 2,
01962     TKO_LOD_Heur_Tri_Diag_Ratio         = 3,
01963     TKO_LOD_Heur_Vol                    = 4,
01964     TKO_LOD_Heur_Tri_Vol                = 5,
01965     TKO_LOD_Heur_Vol_Ratio              = 6,
01966     TKO_LOD_Heur_Tri_Vol_Ratio          = 7,
01967 
01968     TKO_LOD_Fallback_None               = 0,
01969     TKO_LOD_Fallback_Bounding           = 1,
01970     TKO_LOD_Fallback_Coarsest           = 2,
01971     TKO_LOD_Fallback_Coarsest_None      = 3,
01972     TKO_LOD_Fallback_Coarsest_Bounding  = 4,
01973 
01974     TKO_NURBS_Curve_Budget              = 0x01,
01975     TKO_NURBS_Curve_Continued_Budget    = 0x02,
01976     TKO_NURBS_Curve_View_Dependent      = 0x04,
01977     TKO_NURBS_Curve_Mask                = 0x0F,
01978 
01979     TKO_NURBS_Surface_Budget            = 0x10,
01980     TKO_NURBS_Surface_Trim_Budget       = 0x20,
01981     TKO_NURBS_Surface_Max_Facet_Width           = 0x40,
01982     TKO_NURBS_Extended              = 0x80,  //indicates that the 2nd byte should be written
01983     TKO_NURBS_Surface_Max_Facet_Angle       = 0x100,
01984     TKO_NURBS_Surface_Max_Facet_Deviation       = 0x200,
01985     TKO_NURBS_Surface_Max_Trim_Curve_Deviation  = 0x400,
01986     TKO_NURBS_Surface_Mask              = 0x7F0,
01987 
01988     TKO_Tessellation_Cylinder           = 0x01
01989 };
01990 
01994 enum TKO_Attribute_Lock_Bits {
01995     TKO_Lock_Callback                   = 0x00000001,
01996     TKO_Lock_Camera                     = 0x00000002,
01997     TKO_Lock_Color                      = 0x00000004,
01998     TKO_Lock_Color_Map                  = 0x00000008,
01999     TKO_Lock_Driver                     = 0x00000010,
02000     TKO_Lock_Driver_Options             = 0x00000020,
02001     TKO_Lock_Edge_Pattern               = 0x00000040,
02002     TKO_Lock_Edge_Weight                = 0x00000080,
02003     TKO_Lock_Face_Pattern               = 0x00000100,
02004     TKO_Lock_Handedness                 = 0x00000200,
02005     TKO_Lock_Heuristics                 = 0x00000400,
02006     TKO_Lock_Line_Pattern               = 0x00000800,
02007     TKO_Lock_Line_Weight                = 0x00001000,
02008     TKO_Lock_Marker_Size                = 0x00002000,
02009     TKO_Lock_Marker_Symbol              = 0x00004000,
02010     TKO_Lock_Metafile                   = 0x00008000,
02011     TKO_Lock_Modelling_Matrix           = 0x00010000,
02012     TKO_Lock_Rendering_Options          = 0x00020000,
02013     TKO_Lock_Selectability              = 0x00040000,
02014     TKO_Lock_Styles                     = 0x00080000,
02015     TKO_Lock_Text_Alignment             = 0x00100000,
02016     TKO_Lock_Text_Font                  = 0x00200000,
02017     TKO_Lock_Text_Path                  = 0x00400000,
02018     TKO_Lock_Text_Spacing               = 0x00800000,
02019     TKO_Lock_User_Options               = 0x01000000,
02020     TKO_Lock_User_Value                 = 0x02000000,
02021     TKO_Lock_Texture_Matrix             = 0x04000000,
02022     TKO_Lock_Visibility                 = 0x08000000,
02023     TKO_Lock_Window                     = 0x10000000,
02024     TKO_Lock_Window_Frame               = 0x20000000,
02025     TKO_Lock_Window_Pattern             = 0x40000000,
02026     TKO_Lock_All                        = 0x7FFFFFFF
02027 
02028 };
02029 
02030 #if 0
02031 class BBINFILETK_API TK_Radiosity_RayTrace_Options : public BBaseOpcodeHandler {
02032     protected:
02033 
02034     public:
02035         TK_Radiosity_RayTrace_Options () : BBaseOpcodeHandler (TKE_Radiosity_RayTrace_Options) {}
02036         ~TK_Radiosity_RayTrace_Options () {}
02037 
02038         TK_Status   Read (BStreamFileToolkit & tk) alter;
02039         TK_Status   Write (BStreamFileToolkit & tk) alter;
02040 };
02041 #endif
02042 
02043 
02045 
02051 class BBINFILETK_API TK_Rendering_Options : public BBaseOpcodeHandler {
02052     private:
02053         TK_Rendering_Options(const TK_Rendering_Options&);
02054         TK_Rendering_Options& operator=(const TK_Rendering_Options&);
02055 
02056     protected:
02057         int             m_mask[2];  
02058         int             m_value[2]; 
02059 
02060         unsigned char   m_hsr;      
02061         unsigned char   m_tq;       
02062         int             m_debug;                
02063         int             m_face_displacement;    
02064 
02065         float           m_fog_limits[2];        
02066 
02067         int             m_lock_mask;            
02068         int             m_lock_value;           
02069         int             m_lock_color_mask;      
02070         int             m_lock_color_value;     
02071         int             m_lock_visibility_mask; 
02072         int             m_lock_visibility_value;
02073 
02074         unsigned char   m_buffer_options_mask;  
02075         unsigned char   m_buffer_options_value; 
02076         int             m_buffer_size_limit;    
02077 
02078         unsigned short  m_hlr_options;          
02079         float           m_hlr_dim_factor;       
02080         float           m_hlr_face_displacement;
02081         int             m_hlr_line_pattern;     
02082 
02083         int             m_lod_options_mask;     
02084         int             m_lod_options_value;    
02085         char            m_lod_algorithm;        
02086         char            m_num_ratios;           
02087         float           m_ratio[8];             
02088         char            m_num_thresholds;       
02089         float           m_threshold[8];         
02090         char            m_threshold_type;       
02091         int             m_min_triangle_count;   
02092         unsigned char   m_clamp;                
02093         unsigned char   m_num_levels;           
02094         int             m_max_degree;           
02095         float           m_tolerance;            
02096         float           m_bounding[6];          
02097         char            m_num_cutoffs;          
02098         float           m_cutoff[8];            
02099         unsigned char   m_heuristic;            
02100         unsigned char   m_fallback;             
02101 
02102         int     m_nurbs_options_mask;   
02103         int     m_nurbs_options_value;  
02104         int             m_curve_budget;         
02105         int             m_curve_continued_budget;
02106         int             m_surface_budget;       
02107         int             m_surface_trim_budget;  
02108     float       m_surface_max_trim_curve_deviation;
02109     float       m_surface_max_facet_angle;
02110     float       m_surface_max_facet_deviation;
02111     float       m_surface_max_facet_width;
02112 
02113         float           m_stereo_separation;    
02114 
02115         unsigned char   m_tessellations;        
02116         char            m_num_cylinder;         
02117         char            m_cylinder[8];          
02118 
02119         unsigned char   m_transparency_options; 
02120 
02121         unsigned char   m_cut_geometry;         
02122         unsigned char   m_cut_geometry_level;   
02123         float           m_cut_geometry_tolerance;
02124 
02125         float           m_depth_range[2];       
02126 
02127 #if 0
02128         TK_Radiosity_RayTrace_Options   *m_rrt; 
02129 #endif
02130 
02131     public:
02133         TK_Rendering_Options () : BBaseOpcodeHandler (TKE_Rendering_Options) /* , m_rrt (0) */
02134                                 { m_mask[0] = m_mask[1] = m_value[0] = m_value[1] = 0; }
02135         ~TK_Rendering_Options ();
02136 
02137         TK_Status   Read (BStreamFileToolkit & tk) alter;
02138         TK_Status   Write (BStreamFileToolkit & tk) alter;
02139         void        Reset (void) alter;
02140 
02142         void            SetMask (int m0, int m1=0) alter    { m_mask[0] = m0; m_mask[1] = m1;   }
02144         int             GetMask (int index=0) const         { return m_mask[index];             }
02145 
02147         void            SetValue (int v0, int v1=0) alter   { m_value[0] = v0; m_value[1] = v1; }
02149         int             GetValue (int index=0) const        { return m_value[index];            }
02150 
02152         void            SetHSR (int h) alter            { m_hsr &= 0xF0; m_hsr |= (unsigned char)h & 0x0F;  }
02154         int             GetHSR (void) const             { return (int)(m_hsr & 0x0F);                       }
02155 
02157         void            SetTransparentHSR (int t) alter { m_hsr &= 0x0F; m_hsr |= (unsigned char)t << 4;    }
02159         int             GetTransparentHSR (void) const  { return (int)(m_hsr >> 4);                         }
02160 
02162         void            SetTransparentStyle (int s) alter { m_transparency_options = (unsigned char)s;      }
02164         int             GetTransparentStyle (void) const  { return (int)m_transparency_options;             }
02165 
02167         void            SetTechnology (int t) alter     { m_tq &= 0xF0; m_tq |= (unsigned char)t & 0x0F;    }
02169         int             GetTechnology (void) const      { return (int)(m_tq & 0x0F);                        }
02170 
02172         void            SetQuantization (int q) alter   { m_tq &= 0x0F; m_tq |= (unsigned char)q << 4;      }
02174         int             GetQuantization (void) const    { return (int)(m_tq >> 4);                          }
02175 
02177         void            SetDebug (int d) alter          { m_debug = d;                                      }
02179         int             GetDebug (void) const           { return m_debug;                                   }
02180 
02182         void            SetFaceDisplacement (int d) alter   { m_face_displacement = d;                      }
02184         int             GetFaceDisplacement (void) const    { return m_face_displacement;                   }
02185 
02187         void            SetFogLimits (float n, float f) alter   { m_fog_limits[0] = n; m_fog_limits[1] = f; }
02189         void            SetFogLimits (float const * l) alter    { SetFogLimits (l[0], l[1]);                }
02191         float const *   GetFogLimits (void) const               { return m_fog_limits;                      }
02192 
02193 
02195         void            SetLockMask (int m) alter               { m_lock_mask = m;                  }
02197         int             GetLockMask (void) const                { return m_lock_mask;               }
02198 
02200         void            SetLockValue (int v) alter              { m_lock_value = v;                 }
02202         int             GetLockValue (void) const               { return m_lock_value;              }
02203 
02208         void            SetColorLockMask (int m) alter          { m_lock_color_mask = m;            }
02213         int             GetColorLockMask (void) const           { return m_lock_color_mask;         }
02214 
02219         void            SetColorLockValue (int v) alter         { m_lock_color_value = v;           }
02224         int             GetColorLockValue (void) const          { return m_lock_color_value;        }
02225 
02230         void            SetVisibilityLockMask (int m) alter     { m_lock_visibility_mask = m;       }
02235         int             GetVisibilityLockMask (void) const      { return m_lock_visibility_mask;    }
02236 
02241         void            SetVisibilityLockValue (int v) alter    { m_lock_visibility_value = v;      }
02246         int             GetVisibilityLockValue (void) const     { return m_lock_visibility_value;   }
02247 
02248 
02250         void            SetBufferOptionsMask (int v) alter      { m_buffer_options_mask = (unsigned char)v;        }
02252         int             GetBufferOptionsMask (void) const       { return m_buffer_options_mask;     }
02254         void            SetBufferOptionsValue (int v) alter     { m_buffer_options_value = (unsigned char) v; }
02256         int             GetBufferOptionsValue (void) const      { return m_buffer_options_value;    }
02258         void            SetBufferSizeLimit (int l) alter        { m_buffer_size_limit = l;          }
02260         int             GetBufferSizeLimit (void) const         { return m_buffer_size_limit;       }
02261 
02262 
02264         void            SetStereoSeparation (float s) alter     { m_stereo_separation = s;          }
02266         float           GetStereoSeparation (void) const        { return m_stereo_separation;       }
02267 
02268 
02270         void            SetHlrOptions (int o) alter             { m_hlr_options = (unsigned short)o;}
02272         int             GetHlrOptions (void) const              { return m_hlr_options;             }
02274         void            SetHlrDimFactor (float d) alter         { m_hlr_dim_factor = d;             }
02276         float           GetHlrDimFactor (void) const            { return m_hlr_dim_factor;          }
02278         void            SetHlrFaceDisplacement (float d) alter  { m_hlr_face_displacement = d;      }
02280         float           GetHlrFaceDisplacement (void) const     { return m_hlr_face_displacement;   }
02282         void            SetHlrLinePattern (int p) alter         { m_hlr_line_pattern = p;           }
02284         int             GetHlrLinePattern (void) const          { return m_hlr_line_pattern;        }
02285 
02286 
02288         void            SetNURBSOptionsMask (int v) alter       { m_nurbs_options_mask = v;        }
02290         int             GetNURBSOptionsMask (void) const        { return m_nurbs_options_mask;     }
02292         void            SetNURBSOptionsValue (int v) alter      { m_nurbs_options_value = v;       }
02294         int             GetNURBSOptionsValue (void) const       { return m_nurbs_options_value;    }
02296         void            SetNURBSCurveBudget (int b) alter       { m_curve_budget = b;               }
02298         int             GetNURBSCurveBudget (void) const        { return m_curve_budget;            }
02300         void            SetNURBSCurveContinuedBudget (int b) alter  { m_curve_continued_budget = b;     }
02302         int             GetNURBSCurveContinuedBudget (void) const   { return m_curve_continued_budget;  }
02304         void            SetNURBSSurfaceBudget (int b) alter     { m_curve_budget = b;               }
02306         int             GetNURBSSurfaceBudget (void) const      { return m_curve_budget;            }
02308         void            SetNURBSSurfaceTrimBudget (int b) alter { m_surface_trim_budget = b;        }
02310         int             GetNURBSSurfaceTrimBudget (void) const  { return m_surface_trim_budget;     }
02311 
02312 
02314         void            SetLodOptionsMask (int v) alter         { m_lod_options_mask = v;           }
02316         int             GetLodOptionsMask (void) const          { return m_lod_options_mask;        }
02318         void            SetLodOptionsValue (int v) alter        { m_lod_options_value = v;          }
02320         int             GetLodOptionsValue (void) const         { return m_lod_options_value;       }
02322         void            SetLodAlgorithm (int v) alter           { m_lod_algorithm = (char)v;        }
02324         int             GetLodAlgorithm (void) const            { return m_lod_algorithm;           }
02326         void            SetLodMinimumTriangleCount (int v) alter    { m_min_triangle_count = v;     }
02328         int             GetLodMinimumTriangleCount (void) const     { return m_min_triangle_count;  }
02330         void            SetLodNumLevels (int v) alter           { m_num_levels = (unsigned char)v;  }
02332         int             GetLodNumLevels (void) const            { return m_num_levels;              }
02334         void            SetLodClamp (int v) alter               { m_clamp = (unsigned char)v;       }
02336         int             GetLodClamp (void) const                { return m_clamp;                   }
02338         void            SetLodMaxDegree (int v) alter           { m_max_degree = v;                 }
02340         int             GetLodMaxDegree (void) const            { return m_max_degree;              }
02342         void            SetLodTolerance (float v) alter         { m_tolerance = v;                  }
02344         float           GetLodTolerance (void) const            { return m_tolerance;               }
02346         void            SetLodFallback (int v) alter            { m_fallback = (char)v;             }
02348         int             GetLodFallback (void) const             { return m_fallback;                }
02349 
02351         void            SetLodBounding (float x1, float y1, float z1, float x2, float y2, float z2) alter {
02352                                 m_bounding[0] = x1;  m_bounding[1] = y1;  m_bounding[2] = z1;
02353                                 m_bounding[3] = x2;  m_bounding[4] = y2;  m_bounding[5] = z2;
02354                             }
02356         void            SetLodBounding (float const * s, float const * e) alter {
02357                                 SetLodBounding (s[0], s[1], s[2],  e[0], e[1], e[2]);
02358                             }
02360         void            SetLodBounding (float const * p) alter  { SetLodBounding (&p[0], &p[3]);    }
02362         float const *   GetLodBounding (void) const             { return m_bounding;                }
02363 
02365         void            SetLodRatio (float r) alter             { m_num_ratios = 1; m_ratio[0] = r;    }
02367         void            SetLodRatios (int c, float const * r = 0) alter {
02368                             m_num_ratios = (char)c;
02369                             if (r != 0) {
02370                                 int i;
02371                                 for (i=0; i<c; ++i)
02372                                     m_ratio[i] = r[i];
02373                             }
02374                         }
02376         int             GetLodNumRatios (void) const            { return m_num_ratios;              }
02378         float const *   GetLodRatios (void) const               { return m_ratio;                   }
02380         float alter *   GetLodRatios (void) alter               { return m_ratio;                   }
02381 
02383         void            SetLodThresholdType (int v) alter       { m_threshold_type = (char)v; }
02385         int             GetLodThresholdType (void) const        { return m_threshold_type;          }
02387         void            SetLodThreshold (float r) alter             { m_num_thresholds = 1; m_threshold[0] = r;    }
02389         void            SetLodThresholds (int c, float const * r = 0) alter {
02390                             m_num_thresholds = (char)c;
02391                             if (r != 0) {
02392                                 int i;
02393                                 for (i=0; i<c; ++i)
02394                                     m_threshold[i] = r[i];
02395                             }
02396                         }
02398         int             GetLodNumThresholds (void) const            { return m_num_thresholds;              }
02400         float const *   GetLodThresholds (void) const               { return m_threshold;                  }
02402         float alter *   GetLodThresholds (void) alter               { return m_threshold;                  }
02403 
02405         void            SetLodCutoff (float r) alter             { m_num_cutoffs = 1; m_cutoff[0] = r;    }
02407         void            SetLodCutoffs (int c, float const * r = 0) alter {
02408                             m_num_cutoffs = (char)c;
02409                             if (r != 0) {
02410                                 int i;
02411                                 for (i=0; i<c; ++i)
02412                                     m_cutoff[i] = r[i];
02413                             }
02414                         }
02416         int             GetLodNumCutoffs (void) const           { return m_num_cutoffs;             }
02418         float const *   GetLodCutoffs (void) const              { return m_cutoff;                  }
02420         float alter *   GetLodCutoffs (void) alter              { return m_cutoff;                  }
02421 
02422 
02424         void            SetTessellationMask (int m) alter       { m_tessellations = (unsigned char)m;          }
02426         int             GetTessellationMask (void) const        { return m_tessellations;       }
02428         void            SetCylinderTessellation (int n) alter    { m_num_cylinder = (char)1; m_cylinder[0] = (char)n;    }
02430         void            SetCylinderTessellations (int c, char const * n = 0) alter {
02431                             m_num_cylinder = (char)c;
02432                             if (n != 0) {
02433                                 int i;
02434                                 for (i=0; i<c; ++i)
02435                                     m_cylinder[i] = n[i];
02436                             }
02437                         }
02439         int             GetNumCylinderTessellations (void) const { return m_num_cylinder;            }
02441         char const *    GetCylinderTessellations (void) const    { return m_cylinder;                }
02443         char alter *    GetCylinderTessellations (void) alter    { return m_cylinder;                }
02444 };
02445 
02447 
02451 enum TKO_Heuristic_Bits {
02452     TKO_Heuristic_Hidden_Surfaces       = 0x00000001,
02453     TKO_Heuristic_Backplane_Cull        = 0x00000002,
02454     TKO_Heuristic_Polygon_Handedness    = 0x00000004,
02455     TKO_Heuristic_Quick_Moves           = 0x00000008,
02456     TKO_Heuristic_Partial_Erase         = 0x00000010,
02457     TKO_Heuristic_Memory_Purge          = 0x00000020,
02458     TKO_Heuristic_Related_Select_Limit  = 0x00000040,
02459     TKO_Heuristic_Internal_Select_Limit = 0x00000080,
02460     TKO_Heuristic_Clipping              = 0x00000100,
02461     TKO_Heuristic_Transformations       = 0x00000200,
02462     TKO_Heuristic_Intersecting_Polygons = 0x00000400,
02463     TKO_Heuristic_Polygon_Crossings     = 0x00000800,
02464     TKO_Heuristic_Concave_Polygons      = 0x00001000,
02465     TKO_Heuristic_Incremental_Updates   = 0x00002000,
02466     TKO_Heuristic_Selection_Sorting     = 0x00004000,
02467 
02468     TKO_Heuristic_Extended              = 0x00008000,
02469 
02470     TKO_Heuristic_Culling               = 0x00010000,
02471 
02472     TKO_Heuristic_Extras                = TKO_Heuristic_Polygon_Handedness | TKO_Heuristic_Quick_Moves,
02473 
02474     TKO_Heur_Extra_Left_Handed_Polys    = 0x01,
02475     TKO_Heur_Extra_Quick_Move_Spriting  = 0x02,
02476 
02477     TKO_Heur_View_Frustum_Culling       = 0x01,
02478     TKO_Heur_Obscuration_Culling        = 0x02
02479 };
02480 
02481 
02483 
02489 class BBINFILETK_API TK_Heuristics : public BBaseOpcodeHandler {
02490     private:
02491         TK_Heuristics(const TK_Heuristics&);
02492         TK_Heuristics& operator=(const TK_Heuristics&);
02493 
02494     protected:
02495         int             m_mask;     
02496         int             m_value;    
02497 
02498         int             m_related;  
02499         int             m_internal; 
02500 
02501         unsigned char   m_extras;       
02502         unsigned char   m_culling;      
02503 
02504     public:
02506         TK_Heuristics () : BBaseOpcodeHandler (TKE_Heuristics),
02507                                   m_mask (0), m_value (0) {}
02508         ~TK_Heuristics ();
02509 
02510         TK_Status   Read (BStreamFileToolkit & tk) alter;
02511         TK_Status   Write (BStreamFileToolkit & tk) alter;
02512 
02514         void            SetMask (int m) alter           { m_mask = m;       }
02516         int             GetMask (void) const            { return m_mask;    }
02517 
02519         void            SetValue (int v) alter          { m_value = v;      }
02521         int             GetValue (void) const           { return m_value;   }
02522 
02524         void            SetRelatedSelectionLimit (int r) alter  { m_related = r;      }
02526         int             GetRelatedSelectionLimit (void) const   { return m_related;   }
02527 
02529         void            SetInternalSelectionLimit (int i) alter { m_internal = i;     }
02531         int             GetInternalSelectionLimit (void) const  { return m_internal;  }
02532 
02534         void            SetExtras (int e) alter         { m_extras = (unsigned char)e;  }
02536         int             GetExtras (void) const          { return (int)m_extras;         }
02537 
02539         void            SetCulling (int c) alter        { m_culling = (unsigned char)c; }
02541         int             GetCulling (void) const         { return (int)m_culling;        }
02542 };
02543 
02546 
02551 class BBINFILETK_API TK_Visibility : public BBaseOpcodeHandler {
02552     private:
02553         TK_Visibility(const TK_Visibility&);
02554         TK_Visibility& operator=(const TK_Visibility&);
02555 
02556     protected:
02557         int             m_mask;     
02558         int             m_value;    
02559 
02560     public:
02562         TK_Visibility (void)
02563             : BBaseOpcodeHandler (TKE_Visibility), m_mask (0), m_value (0) {}
02564 
02565         TK_Status   Read (BStreamFileToolkit & tk) alter;
02566         TK_Status   Write (BStreamFileToolkit & tk) alter;
02567 
02572         void            SetGeometry (int m) alter       { m_mask = m;       }
02577         int             GetGeometry (void) const        { return m_mask;    }
02578 
02583         void            SetValue (int m) alter          { m_value = m;       }
02588         int             GetValue (void) const           { return m_value;    }
02589 };
02590 
02593 
02600 class BBINFILETK_API TK_Selectability : public BBaseOpcodeHandler {
02601     private:
02602         TK_Selectability(const TK_Selectability&);
02603         TK_Selectability& operator=(const TK_Selectability&);
02604 
02605     protected:
02606         int             m_mask;         
02607         int             m_down;         
02608         int             m_up;           
02609         int             m_move_down;    
02610         int             m_move_up;      
02611         int             m_invisible;    
02612 
02613     public:
02615         TK_Selectability (void)
02616             : BBaseOpcodeHandler (TKE_Selectability),
02617             m_mask (0), m_down (0), m_up (0), m_move_down (0), m_move_up (0), m_invisible (0) {}
02618 
02619         TK_Status   Read (BStreamFileToolkit & tk) alter;
02620         TK_Status   Write (BStreamFileToolkit & tk) alter;
02621 
02626         void            SetGeometry (int m) alter       { m_mask = m;           }
02631         int             GetGeometry (void) const        { return m_mask;        }
02632 
02637         void            SetDown (int m) alter           { m_down = m;           }
02642         int             GetDown (void) const            { return m_down;        }
02643 
02648         void            SetUp (int m) alter             { m_up = m;             }
02653         int             GetUp (void) const              { return m_up;          }
02654 
02659         void            SetMoveDown (int m) alter       { m_move_down = m;      }
02664         int             GetMoveDown (void) const        { return m_move_down;   }
02665 
02670         void            SetMoveUp (int m) alter         { m_move_up = m;        }
02675         int             GetMoveUp (void) const          { return m_move_up;     }
02676 
02681         void            SetWhenInvisible (int m) alter  { m_invisible = m;      }
02686         int             GetWhenInvisible (void) const   { return m_invisible;   }
02687 };
02688 
02690 
02696 class BBINFILETK_API TK_Matrix : public BBaseOpcodeHandler {
02697     private:
02698         TK_Matrix(const TK_Matrix&);
02699         TK_Matrix& operator=(const TK_Matrix&);
02700 
02701     protected:
02702         float           m_matrix[16];  
02703 
02704     public:
02706         TK_Matrix (unsigned char opcode)
02707             : BBaseOpcodeHandler (opcode) {}
02708 
02709         TK_Status   Read (BStreamFileToolkit & tk) alter;
02710         TK_Status   Write (BStreamFileToolkit & tk) alter;
02711 
02713         void            SetMatrix (float const * m) alter   {
02714                                 int i;  for (i=0; i<16; i++) m_matrix[i] = m[i];
02715                             }
02717         float const *   GetMatrix (void) const              { return m_matrix;  }
02719         float alter *   GetMatrix (void) alter              { return m_matrix;  }
02720 };
02721 
02722 
02726 enum TKO_Enumerations {
02727     TKO_Line_Pattern_Solid      = 0,
02728     TKO_Line_Pattern_Dash_Dot   = 1,
02729     TKO_Line_Pattern_Dashed     = 2,
02730     TKO_Line_Pattern_Dotted     = 3,
02731     TKO_Line_Pattern_Dash_2Dot  = 4,
02732     TKO_Line_Pattern_Dash_3Dot  = 5,
02733     TKO_Line_Pattern_Long_Dash  = 6,
02734     TKO_Line_Pattern_Center     = 7,
02735     TKO_Line_Pattern_Phantom    = 8,
02736     TKO_Line_Pattern_Find_Dots  = 9,
02737 
02738     TKO_Fill_Pattern_Hash       = 0,
02739     TKO_Fill_Pattern_Vertical   = 1,
02740     TKO_Fill_Pattern_Horizontal = 2,
02741     TKO_Fill_Pattern_Right      = 3,
02742     TKO_Fill_Pattern_Left       = 4,
02743     TKO_Fill_Pattern_Diamond    = 5,
02744     TKO_Fill_Pattern_Dots       = 6,
02745     TKO_Fill_Pattern_Boxes      = 7,
02746     TKO_Fill_Pattern_Solid      = 8,
02747     TKO_Fill_Pattern_Clear      = 9,
02748     TKO_Fill_Pattern_Gradient_N = 10,
02749     TKO_Fill_Pattern_Gradient_NE= 11,
02750     TKO_Fill_Pattern_Gradient_E = 12,
02751     TKO_Fill_Pattern_Gradient_SE= 13,
02752     TKO_Fill_Pattern_Gradient_S = 14,
02753     TKO_Fill_Pattern_Gradient_SW= 15,
02754     TKO_Fill_Pattern_Gradient_W = 16,
02755     TKO_Fill_Pattern_Gradient_NW= 17,
02756 
02757     TKO_Marker_Circle                       = 0,
02758     TKO_Marker_Circle_Dot                   = 1,
02759     TKO_Marker_Circle_Plus                  = 2,
02760     TKO_Marker_Circle_X                     = 3,
02761     TKO_Marker_Circle_Circle                = 4,
02762     TKO_Marker_Circle_Filled                = 5,
02763     TKO_Marker_Dot                          = 6,
02764     TKO_Marker_Plus                         = 7,
02765     TKO_Marker_X                            = 8,
02766     TKO_Marker_Star                         = 9,
02767     TKO_Marker_Box                          = 10,
02768     TKO_Marker_Box_Dot                      = 11,
02769     TKO_Marker_Box_X                        = 12,
02770     TKO_Marker_Box_Filled                   = 13,
02771     TKO_Marker_Diamond                      = 14,
02772     TKO_Marker_Diamond_Dot                  = 15,
02773     TKO_Marker_Diamond_Plus                 = 16,
02774     TKO_Marker_Diamond_Filled               = 17,
02775     TKO_Marker_Triangle_Up                  = 18,
02776     TKO_Marker_Triangle_Up_Vertex           = 19,
02777     TKO_Marker_Triangle_Up_Dot              = 20,
02778     TKO_Marker_Triangle_Up_Filled           = 21,
02779     TKO_Marker_Triangle_Up_Filled_Vertex    = 22,
02780     TKO_Marker_Triangle_Down                = 23,
02781     TKO_Marker_Triangle_Down_Vertex         = 24,
02782     TKO_Marker_Triangle_Down_Dot            = 25,
02783     TKO_Marker_Triangle_Down_Filled         = 26,
02784     TKO_Marker_Triangle_Down_Filled_Vertex  = 27,
02785     TKO_Marker_Triangle_Right               = 28,
02786     TKO_Marker_Triangle_Right_Vertex        = 29,
02787     TKO_Marker_Triangle_Right_Dot           = 30,
02788     TKO_Marker_Triangle_Right_Filled        = 31,
02789     TKO_Marker_Triangle_Right_Filled_Vertex = 32,
02790     TKO_Marker_Triangle_Left                = 33,
02791     TKO_Marker_Triangle_Left_Vertex         = 34,
02792     TKO_Marker_Triangle_Left_Dot            = 35,
02793     TKO_Marker_Triangle_Left_Filled         = 36,
02794     TKO_Marker_Triangle_Left_Filled_Vertex  = 37,
02795     TKO_Marker_Hash                         = 38,
02796     TKO_Marker_Wide_Plus                    = 39,
02797     TKO_Marker_Open_Arrow                   = 40,
02798     TKO_Marker_Closed_Arrow                 = 41,
02799     TKO_Marker_Vertical_Bar                 = 42,
02800     TKO_Marker_Half_Arrow_Left              = 43,
02801     TKO_Marker_Half_Arrow_Right             = 44,
02802     TKO_Marker_Wide_Arrow                   = 45,
02803     TKO_Marker_Double_Arrow                 = 46,
02804     TKO_Marker_Y                            = 47,
02805     TKO_Marker_Z                            = 48,
02806 
02807     TKO_Text_Alignment_Lower_Left       = 0,
02808     TKO_Text_Alignment_Upper_Left       = 1,
02809     TKO_Text_Alignment_Middle_Left      = 2,
02810     TKO_Text_Alignment_Lower_Right      = 3,
02811     TKO_Text_Alignment_Upper_Right      = 4,
02812     TKO_Text_Alignment_Middle_Right     = 5,
02813     TKO_Text_Alignment_Lower_Center     = 6,
02814     TKO_Text_Alignment_Upper_Center     = 7,
02815     TKO_Text_Alignment_Middle_Center    = 8,
02816     TKO_Text_Alignment_Insertion        = 9,
02817 
02818     TKO_Text_Justification_Unspecified  = 0,
02819     TKO_Text_Justification_Left         = 1,
02820     TKO_Text_Justification_Center       = 2,
02821     TKO_Text_Justification_Right        = 3,
02822 
02823     TKO_Window_Frame_Off    = 0,
02824     TKO_Window_Frame_On     = 1,
02825 
02826     TKO_Handedness_Left     = 0,
02827     TKO_Handedness_Right    = 1
02828 };
02829 
02835 class BBINFILETK_API TK_Enumerated : public BBaseOpcodeHandler {
02836     private:
02837         TK_Enumerated(const TK_Enumerated&);
02838         TK_Enumerated& operator=(const TK_Enumerated&);
02839 
02840     protected:
02841         char            m_index;    
02842 
02843     public:
02845         TK_Enumerated (unsigned char opcode)
02846             : BBaseOpcodeHandler (opcode), m_index (0) {}
02847 
02848         TK_Status   Read (BStreamFileToolkit & tk) alter;
02849         TK_Status   Write (BStreamFileToolkit & tk) alter;
02850 
02852         void            SetIndex (int i) alter  { m_index = (char)i;   }
02854         int             GetIndex (void) const   { return (int)m_index;  }
02855 };
02856 
02860 enum TKO_Generic_Size_Units {
02861     TKO_Generic_Size_Object,
02862     TKO_Generic_Size_Screen,
02863     TKO_Generic_Size_Window,
02864     TKO_Generic_Size_Points,
02865     TKO_Generic_Size_Pixels,
02866     TKO_Generic_Size_Unspecified //keep last
02867 };
02868 
02874 class BBINFILETK_API TK_Size : public BBaseOpcodeHandler {
02875     private:
02876         TK_Size(const TK_Size&);
02877         TK_Size& operator=(const TK_Size&);
02878 
02879     protected:
02880         float           m_value;  
02881         unsigned char   m_units;  
02882 
02883     public:
02885         TK_Size (unsigned char opcode)
02886             : BBaseOpcodeHandler (opcode), m_value (0.0f), m_units (TKO_Generic_Size_Unspecified) {}
02887 
02888         TK_Status   Read (BStreamFileToolkit & tk) alter;
02889         TK_Status   Write (BStreamFileToolkit & tk) alter;
02890 
02892         void            SetSize (float value, int units = TKO_Generic_Size_Unspecified) alter {
02893                                 m_value = (value > 0.0f) ? value : 0.0f;
02894                                 m_units = (m_value > 0.0f) ? (unsigned char) units : (unsigned char) TKO_Generic_Size_Unspecified;
02895                             }
02897         float           GetSize (void) const    { return m_value;  }
02899         int             GetUnits (void) const   { return m_units;  }
02900 };
02901 
02906 class BBINFILETK_API TK_Linear_Pattern : public BBaseOpcodeHandler {
02907     private:
02908         TK_Linear_Pattern(const TK_Linear_Pattern&);
02909         TK_Linear_Pattern& operator=(const TK_Linear_Pattern&);
02910 
02911     protected:
02912         unsigned short  m_pattern;  
02913 
02914     public:
02916         TK_Linear_Pattern (unsigned char opcode)
02917             : BBaseOpcodeHandler (opcode), m_pattern (0) {}
02918 
02919         TK_Status   Read (BStreamFileToolkit & tk) alter;
02920         TK_Status   Write (BStreamFileToolkit & tk) alter;
02921 
02923         void            SetPattern (int p) alter    { m_pattern = (unsigned short)p;    }
02925         int             GetPattern (void) const     { return (int)m_pattern;            }
02926 };
02927 
02935 class BBINFILETK_API TK_Streaming : public BBaseOpcodeHandler {
02936     private:
02937         TK_Streaming(const TK_Streaming&);
02938         TK_Streaming& operator=(const TK_Streaming&);
02939 
02940     protected:
02941         bool            m_flag;  
02942 
02943     public:
02945         TK_Streaming () : BBaseOpcodeHandler (TKE_Streaming_Mode) {}
02946 
02947         TK_Status   Read (BStreamFileToolkit & tk) alter;
02948         TK_Status   Write (BStreamFileToolkit & tk) alter;
02949 
02951         void            SetStreaming (bool s) alter { m_flag = s;       }
02953         bool            GetStreaming (void) const   { return m_flag;    }
02954 };
02955 
02958 
02964 class BBINFILETK_API TK_User_Options : public BBaseOpcodeHandler {
02965     private:
02966         TK_User_Options(const TK_User_Options&);
02967         TK_User_Options& operator=(const TK_User_Options&);
02968 
02969     protected:
02970         int                     m_length;       
02971         char *                  m_string;       
02972         BBaseOpcodeHandler *    m_indices;      
02973         BBaseOpcodeHandler *    m_unicode;      
02975         void    set_options (char const * options) alter;       
02976         void    set_options (int length) alter;                 
02977 
02978     public:
02980         TK_User_Options () : BBaseOpcodeHandler (TKE_User_Options), m_length (0), m_string (0),
02981                              m_indices (0), m_unicode (0) {}
02982         ~TK_User_Options();
02983 
02984         TK_Status   Read (BStreamFileToolkit & tk) alter;
02985         TK_Status   Write (BStreamFileToolkit & tk) alter;
02986         void        Reset (void) alter;
02987 
02989         void            SetOptions (char const * options) alter { set_options (options);    }
02991         void            SetOptions (int length) alter           { set_options (length);     }
02993         char const *    GetOptions (void) const                 { return m_string;          }
02995         char alter *    GetOptions (void) alter                 { return m_string;          }
02997         int             GetLength(void) alter                   { return m_length;          }
02998 };
02999 
03002 
03008 class BBINFILETK_API TK_Unicode_Options : public BBaseOpcodeHandler {
03009     private:
03010         TK_Unicode_Options(const TK_Unicode_Options&);
03011         TK_Unicode_Options& operator=(const TK_Unicode_Options&);
03012 
03013     protected:
03014         int                     m_length;       
03015         unsigned short *        m_string;       
03017     public:
03019         TK_Unicode_Options () : BBaseOpcodeHandler (TKE_Unicode_Options), m_length (0), m_string (0) {}
03020         ~TK_Unicode_Options();
03021 
03022         TK_Status   Read (BStreamFileToolkit & tk) alter;
03023         TK_Status   Write (BStreamFileToolkit & tk) alter;
03024         void        Reset (void) alter;
03025 
03027         void                    SetOptions (unsigned short const * options) alter;
03029         void                    SetOptions (int length) alter;
03031         unsigned short const *  GetOptions (void) const                 { return m_string;          }
03033         unsigned short alter *  GetOptions (void) alter                 { return m_string;          }
03035         int                     GetLength(void) alter                   { return m_length;          }
03036 };
03037 
03039 
03045 class BBINFILETK_API TK_User_Index : public BBaseOpcodeHandler {
03046     private:
03047         TK_User_Index(const TK_User_Index&);
03048         TK_User_Index& operator=(const TK_User_Index&);
03049 
03050     protected:
03051         int             m_count;            
03052         int *           m_indices;          
03053         long *          m_values;           
03054 
03055         void    set_indices (int count, int const * indices, long const * values) alter;  
03056         void    set_indices (int count) alter;                                            
03057 
03058     public:
03060         TK_User_Index ()
03061             : BBaseOpcodeHandler (TKE_User_Index), m_count (0), m_indices (0), m_values (0) {}
03062         ~TK_User_Index();
03063 
03064         TK_Status   Read (BStreamFileToolkit & tk) alter;
03065         TK_Status   Write (BStreamFileToolkit & tk) alter;
03066         void        Reset (void) alter;
03067 
03069         void            SetIndices (int count, int const * indices, long const * values) alter
03070                                                         { set_indices (count, indices, values); }
03072         void            SetIndices (int count) alter    { set_indices (count);                  }
03074         int             GetCount (void) const           { return m_count;                       }
03076         int const *     GetIndices (void) const         { return m_indices;                     }
03078         int alter *     GetIndices (void) alter         { return m_indices;                     }
03080         long const *    GetValues (void) const          { return m_values;                      }
03082         long alter *    GetValues (void) alter          { return m_values;                      }
03083 };
03084 
03086 
03091 class BBINFILETK_API TK_User_Value : public BBaseOpcodeHandler {
03092     private:
03093         TK_User_Value(const TK_User_Value&);
03094         TK_User_Value& operator=(const TK_User_Value&);
03095 
03096     protected:
03097         long            m_value;  
03098 
03099     public:
03101         TK_User_Value ()
03102             : BBaseOpcodeHandler (TKE_User_Value), m_value (0) {}
03103 
03104         TK_Status   Read (BStreamFileToolkit & tk) alter;
03105         TK_Status   Write (BStreamFileToolkit & tk) alter;
03106 
03108         void            SetValue (long v) alter     { m_value = v;      }
03110         long            GetValue (void) const       { return m_value;   }
03111 };
03112 
03116 enum TKO_Camera_Projection {
03117     TKO_Camera_Perspective_Bit  = 0x01,
03118     TKO_Camera_Stretched_Bit    = 0x02,
03119     TKO_Camera_Projection_Mask  = 0x03,
03120 
03121     TKO_Camera_Orthographic     = 0x00,
03122     TKO_Camera_Perspective      = 0x01,
03123     TKO_Camera_Stretched        = 0x02,
03124 
03125     TKO_Camera_Oblique_Y        = 0x04,
03126     TKO_Camera_Oblique_X        = 0x08,
03127     TKO_Camera_Oblique_Mask     = 0x0C
03128 };
03129 
03131 
03136 class BBINFILETK_API TK_Camera : public BBaseOpcodeHandler {
03137     private:
03138         TK_Camera(const TK_Camera&);
03139         TK_Camera& operator=(const TK_Camera&);
03140 
03141     protected:
03145         float           m_settings[13];
03146         char            m_projection;   
03147         int             m_length;       
03148         char *          m_name;         
03151         void    set_name (char const * name) alter; 
03152 
03153         void    set_name (int length) alter;        
03154 
03155     public:
03157         TK_Camera (unsigned char opcode = TKE_Camera)
03158             : BBaseOpcodeHandler (opcode), m_length (0), m_name (0) {
03159                 int i;
03160                 int count = (int)(sizeof(m_settings) / sizeof(m_settings[0]));
03161                 for( i = 0 ; i < count ; i++ )
03162                     m_settings[i] = 0;
03163         }
03164         ~TK_Camera();
03165 
03166         TK_Status   Read (BStreamFileToolkit & tk) alter;
03167         TK_Status   Write (BStreamFileToolkit & tk) alter;
03168 
03170         void            SetPosition (float x, float y, float z) alter
03171                                         { m_settings[0] = x;  m_settings[1] = y;  m_settings[2] = z;    }
03173         void            SetPosition (float const * p) alter     { SetPosition (p[0], p[1], p[2]);       }
03175         float const *   GetPosition (void) const                { return &m_settings[0];                }
03176 
03178         void            SetTarget (float x, float y, float z) alter
03179                                         { m_settings[3] = x;  m_settings[4] = y;  m_settings[5] = z;    }
03181         void            SetTarget (float const * t) alter       { SetTarget (t[0], t[1], t[2]);         }
03183         float const *   GetTarget (void) const                  { return &m_settings[3];                }
03184 
03186         void            SetUpVector (float x, float y, float z) alter
03187                                         { m_settings[6] = x;  m_settings[7] = y;  m_settings[8] = z;    }
03189         void            SetUpVector (float const * u) alter     { SetUpVector (u[0], u[1], u[2]);       }
03191         float const *   GetUpVector (void) const                { return &m_settings[6];                }
03192 
03194         void            SetField (float w, float h) alter       { m_settings[9] = w;  m_settings[10] = h; }
03196         void            SetField (float const * f) alter        { SetField (f[0], f[1]);                }
03198         float const *   GetField (void) const                   { return &m_settings[9];                }
03199 
03201         void            SetOblique (float h, float v) alter     { m_settings[11] = h;  m_settings[12] = v; }
03203         void            SetOblique (float const * o) alter      { SetOblique (o[0], o[1]);              }
03205         float const *   GetOblique (void) const                 { return &m_settings[11];               }
03206 
03208         void            SetProjection (int p) alter             { m_projection = (char)p;   }
03210         int             GetProjection (void) const              { return (int)m_projection; }
03211 
03213         void            SetView (char const * name) alter       { set_name (name);          }
03215         void            SetView (int length) alter              { set_name (length);        }
03217         char const *    GetView (void) const                    { return m_name;            }
03219         char alter *    GetView (void) alter                    { return m_name;            }
03220 };
03221 
03223 
03228 class BBINFILETK_API TK_Window : public BBaseOpcodeHandler {
03229     private:
03230         TK_Window(const TK_Window&);
03231         TK_Window& operator=(const TK_Window&);
03232 
03233     protected:
03234         float           m_window[4];  
03235 
03236     public:
03238         TK_Window ()
03239             : BBaseOpcodeHandler (TKE_Window) {}
03240 
03241         TK_Status   Read (BStreamFileToolkit & tk) alter;
03242         TK_Status   Write (BStreamFileToolkit & tk) alter;
03243 
03245         void            SetWindow (float l, float r, float b, float t) alter
03246                                 { m_window[0] = l;  m_window[1] = r;  m_window[2] = b;  m_window[3] = t;    }
03248         void            SetWindow (float const * w) alter      { SetWindow (w[0], w[1], w[2], w[3]);        }
03250         float const *   GetWindow (void) const                 { return m_window;                           }
03251 };
03252 
03253 
03258 enum TKO_Font_Options {
03259     TKO_Font_Names              = 0x0001,   
03260     TKO_Font_Size               = 0x0002,   
03261     TKO_Font_Size_Tolerance     = 0x0004,   
03262     TKO_Font_Transforms         = 0x0008,   
03263     TKO_Font_Rotation           = 0x0010,   
03264     TKO_Font_Slant              = 0x0020,   
03265     TKO_Font_Width_Scale        = 0x0040,   
03266     TKO_Font_Extended           = 0x0080,   
03267     TKO_Font_Extra_Space        = 0x0100,   
03268     TKO_Font_Line_Spacing       = 0x0200,   
03269     TKO_Font_Outline            = 0x0400,   
03270     TKO_Font_Underline          = 0x0800,   
03271     TKO_Font_Strikethrough      = 0x1000,   
03272     TKO_Font_Overline           = 0x2000    
03273 };
03274 
03278 enum TKO_Font_Size_Units {
03279     TKO_Font_Size_Object = 0,
03280     TKO_Font_Size_Screen = 1,
03281     TKO_Font_Size_Window = 2,
03282     TKO_Font_Size_Points = 3,
03283     TKO_Font_Size_Pixels = 4,
03284     TKO_Font_Size_Percent = 5   // used by tolerance
03285 };
03286 
03287 
03293 enum TKO_Font_Transforms {
03294     TKO_Font_Transform_Position_Only = 0,  
03295     TKO_Font_Transform_Full = 1            
03296 };
03297 
03298 
03300 
03307 class BBINFILETK_API TK_Text_Font : public BBaseOpcodeHandler {
03308     private:
03309         TK_Text_Font(const TK_Text_Font&);
03310         TK_Text_Font& operator=(const TK_Text_Font&);
03311 
03312     protected:
03313         int             m_mask;  
03314         int             m_value;  
03315         int             m_names_length; 
03316         char *          m_names;        
03317         float           m_size;         
03318         float           m_tolerance;    
03319         float           m_rotation;     
03320         float           m_slant;        
03321         float           m_width_scale;  
03322         float           m_extra_space;  
03323         float           m_line_spacing; 
03324         unsigned char   m_size_units;   
03325         unsigned char   m_tolerance_units;
03326         unsigned char   m_space_units;  
03327         unsigned char   m_transforms;   
03328 
03329         void    set_names (int length) alter;           
03330         void    set_names (char const * names) alter;   
03331 
03332     public:
03334         TK_Text_Font ()
03335             : BBaseOpcodeHandler (TKE_Text_Font), m_names_length (0), m_names (0) {}
03336         ~TK_Text_Font ();
03337 
03338         TK_Status   Read (BStreamFileToolkit & tk) alter;
03339         TK_Status   Write (BStreamFileToolkit & tk) alter;
03340         void        Reset (void) alter;
03341 
03343         void            SetMask (int m) alter                   { m_mask = m;           }
03345         int             GetMask (void) const                    { return m_mask;        }
03346 
03348         void            SetValue (int v) alter                  { m_value = v;          }
03350         int             GetValue (void) const                   { return m_value;       }
03351 
03353         void            SetNames (char const * names) alter     { set_names (names);    }
03355         void            SetNames (int length) alter             { set_names (length);   }
03357         char const *    GetNames (void) const                   { return m_names;       }
03359         char alter *    GetNames (void) alter                   { return m_names;       }
03360 
03362         void            SetSize (float s) alter                 { m_size = s;                           }
03364         float           GetSize (void) const                    { return m_size;                        }
03365 
03367         void            SetSizeUnits (int u) alter              { m_size_units = (unsigned char)u;      }
03369         int             GetSizeUnits (void) const               { return (int)m_size_units;             }
03370 
03372         void            SetTolerance (float t) alter            { m_tolerance = t;                      }
03374         float           GetTolerance (void) const               { return m_tolerance;                   }
03375 
03377         void            SetToleranceUnits (int u) alter         { m_tolerance_units = (unsigned char)u; }
03379         int             GetToleranceUnits (void) const          { return (int)m_tolerance_units;        }
03380 
03382         void            SetRotation (float r) alter             { m_rotation = r;                       }
03384         float           GetRotation (void) const                { return m_rotation;                    }
03385 
03387         void            SetSlant (float s) alter                { m_slant = s;                          }
03389         float           GetSlant (void) const                   { return m_slant;                       }
03390 
03392         void            SetWidthScale (float s) alter           { m_width_scale = s;                    }
03394         float           GetWidthScale (void) const              { return m_width_scale;                 }
03395 
03397         void            SetExtraSpace (float s) alter           { m_extra_space = s;                    }
03399         float           GetExtraSpace (void) const              { return m_extra_space;                 }
03400 
03402         void            SetExtraSpaceUnits (int u) alter        { m_space_units = (unsigned char)u;     }
03404         int             GetExtraSpaceUnits (void) const         { return (int)m_space_units;            }
03405 
03407         void            SetLineSpacing (float s) alter          { m_line_spacing = s;                   }
03409         float           GetLineSpacing (void) const             { return m_line_spacing;                }
03410 
03412         void            SetTransforms (int t) alter             { m_transforms = (unsigned char)t;      }
03414         int             GetTransforms (void) const              { return (int)m_transforms;             }
03415 };
03416 
03418 
03420 
03432 enum TKO_Bounding_Type_Options {
03433     TKO_Bounding_Type_Cuboid    = 0,
03434     TKO_Bounding_Type_Sphere    = 1
03435 };
03436 
03437 
03438 
03440 
03451 class BBINFILETK_API TK_Bounding : public BBaseOpcodeHandler {
03452     private:
03453         TK_Bounding(const TK_Bounding&);
03454         TK_Bounding& operator=(const TK_Bounding&);
03455 
03456     protected:
03457         float           m_values[6];        
03458         char            m_type;             
03459 
03460     public:
03462         TK_Bounding (unsigned char opcode)
03463             : BBaseOpcodeHandler (opcode) {}
03465         TK_Bounding (unsigned char opcode, float * min, float * max)
03466             : BBaseOpcodeHandler (opcode), m_type (TKO_Bounding_Type_Cuboid) {
03467                 m_values[0] = min[0]; m_values[1] = min[1]; m_values[2] = min[2];
03468                 m_values[3] = max[0]; m_values[4] = max[1]; m_values[5] = max[2];
03469             }
03471         TK_Bounding (unsigned char opcode, float * center, float radius)
03472             : BBaseOpcodeHandler (opcode), m_type (TKO_Bounding_Type_Sphere) {
03473                 m_values[0] = center[0]; m_values[1] = center[1]; m_values[2] = center[2];
03474                 m_values[3] = radius;
03475             }
03476 
03477         TK_Status   Read (BStreamFileToolkit & tk) alter;
03478         TK_Status   Write (BStreamFileToolkit & tk) alter;
03479 };
03480 
03482 
03484 
03486 
03492 class BBINFILETK_API TK_Point : public BBaseOpcodeHandler {
03493     private:
03494         TK_Point(const TK_Point&);
03495         TK_Point& operator=(const TK_Point&);
03496 
03497     protected:
03498         float           m_point[3];  
03500     public:
03502         TK_Point (unsigned char opcode)
03503             : BBaseOpcodeHandler (opcode) {}
03504 
03505         TK_Status   Read (BStreamFileToolkit & tk) alter;
03506         TK_Status   Write (BStreamFileToolkit & tk) alter;
03507 
03509         void            SetPoint (float x, float y, float z) alter  { m_point[0] = x; m_point[1] = y; m_point[2] = z; }
03511         void            SetPoint (float const * p) alter            { SetPoint (p[0], p[1], p[2]);  }
03513         float const *   GetPoint (void) const                       { return m_point;               }
03514 };
03515 
03516 
03517 
03519 
03524 class BBINFILETK_API TK_Line : public BBaseOpcodeHandler {
03525     private:
03526         TK_Line(const TK_Line&);
03527         TK_Line& operator=(const TK_Line&);
03528 
03529     protected:
03531         float           m_points[6];
03532 
03533     public:
03535         TK_Line ()
03536             : BBaseOpcodeHandler (TKE_Line) {}
03537 
03538         TK_Status   Read (BStreamFileToolkit & tk) alter;
03539         TK_Status   Write (BStreamFileToolkit & tk) alter;
03540 
03542         void            SetPoints (float x1, float y1, float z1, float x2, float y2, float z2) alter {
03543                                 m_points[0] = x1;  m_points[1] = y1;  m_points[2] = z1;
03544                                 m_points[3] = x2;  m_points[4] = y2;  m_points[5] = z2;
03545                             }
03547         void            SetPoints (float const * s, float const * e) alter {
03548                                 SetPoints (s[0], s[1], s[2],  e[0], e[1], e[2]);
03549                             }
03551         void            SetPoints (float const * p) alter           { SetPoints (&p[0], &p[3]); }
03553         float const *   GetPoints (void) const                      { return m_points;          }
03554 };
03555 
03556 
03557 
03559 
03566 class BBINFILETK_API TK_Polypoint : public BBaseOpcodeHandler {
03567     private:
03568         TK_Polypoint(const TK_Polypoint&);
03569         TK_Polypoint& operator=(const TK_Polypoint&);
03570 
03571     protected:
03572         int             m_count;    
03573         int             m_allocated;
03574         float *         m_points;   
03577         void    set_points (int count, float const * points = 0) alter      { SetPoints (count, points); }
03578 
03579     public:
03581         TK_Polypoint (unsigned char opcode)
03582             : BBaseOpcodeHandler (opcode), m_count (0), m_allocated (0), m_points (0) {}
03583         ~TK_Polypoint();
03584 
03585         TK_Status   Read (BStreamFileToolkit & tk) alter;
03586         TK_Status   Write (BStreamFileToolkit & tk) alter;
03587         void        Reset (void) alter;
03588 
03591         void            SetPoints (int count, float const * points = 0) alter;
03593         float const *   GetPoints (void) const                                  { return m_points;              }
03595         float alter *   GetPoints (void) alter                                  { return m_points;              }
03597         int             GetCount (void) const                                   { return m_count;               }
03598 };
03599 
03600 
03601 
03602 
03603 #define NC_HAS_WEIGHTS 0x01     
03604 #define NC_HAS_KNOTS   0x02     
03605 #define NC_HAS_START   0x04     
03606 #define NC_HAS_END     0x08     
03607 
03608 
03609 
03614 class BBINFILETK_API TK_NURBS_Curve : public BBaseOpcodeHandler {
03615     private:
03616         TK_NURBS_Curve(const TK_NURBS_Curve&);
03617         TK_NURBS_Curve& operator=(const TK_NURBS_Curve&);
03618 
03619     protected:
03620 
03621         unsigned char m_optionals;  
03622         unsigned char m_degree;     
03623         int m_control_point_count;  
03624         int m_knot_count_implicit;  
03625         float *m_control_points;    
03626         float *m_weights;           
03627         float *m_knots;             
03628         float m_start;              
03629         float m_end;                
03631 
03632         void    set_curve (int degree, int control_count, float const * points = 0,
03633                            float const * weights = 0, float const * knots = 0,
03634                            float start = 0.0f, float end = 1.0f) alter;
03635     public:
03636         TK_NURBS_Curve();
03637         ~TK_NURBS_Curve();
03638 
03639         TK_Status   Read (BStreamFileToolkit & tk) alter;
03640         TK_Status   Write (BStreamFileToolkit & tk) alter;
03641         void        Reset (void) alter;
03642 
03644         void            SetCurve (int degree, int control_count, float const * points = 0,
03645                                   float const * weights = 0, float const * knots = 0,
03646                                   float start = 0.0f, float end = 1.0f) alter {
03647                                 set_curve (degree, control_count, points, weights, knots, start, end);
03648                             }
03649 
03650         int             GetDegree (void) const          { return m_degree;                  } 
03651         int             GetCount (void) const           { return m_control_point_count;     } 
03652         float const *   GetPoints (void) const          { return m_control_points;          } 
03653         float alter *   GetPoints (void) alter          { return m_control_points;          } 
03654         float const *   GetWeights (void) const         { return m_weights;                 } 
03655         float alter *   GetWeights (void) alter         { return m_weights;                 } 
03656         float const *   GetKnots (void) const           { return m_knots;                   } 
03657         float alter *   GetKnots (void) alter           { return m_knots;                   } 
03659         void            SetStart (float s) alter        { m_start = s;                      } 
03660         float           GetStart (void) const           { return m_start;                   } 
03661         void            SetEnd (float e) alter          { m_end = e;                        } 
03662         float           GetEnd (void) const             { return m_end;                     } 
03664         void            SetOptions (int o) alter        { m_optionals = (unsigned char)o;   } 
03665         int             GetOptions (void) const         { return m_optionals;               } 
03666 };
03667 
03668 
03669 
03670 
03671 
03672 #define NS_HAS_WEIGHTS 0x01   
03673 #define NS_HAS_KNOTS   0x02   
03674 #define NS_HAS_TRIMS   0x04   
03675 
03676 #define NS_TRIM_END         0       
03677 #define NS_TRIM_POLY        1       
03678 #define NS_TRIM_CURVE       2       
03679 #define NS_TRIM_COLLECTION  3       
03680 #define NS_TRIM_LAST_KNOWN_TYPE 3   
03681 
03682 #define NS_TRIM_KEEP        0x01 
03683 #define NS_TRIM_HAS_WEIGHTS 0x02 
03684 #define NS_TRIM_HAS_KNOTS   0x04 
03685 
03686 
03687 
03693 class HT_NURBS_Trim : public BBaseOpcodeHandler  {
03694     private:
03695         HT_NURBS_Trim(const HT_NURBS_Trim&);
03696         HT_NURBS_Trim& operator=(const HT_NURBS_Trim&);
03697 
03698     friend class TK_NURBS_Surface;
03699     protected:
03700         //first 5 are relevant to polys and curves
03701         int             m_substage;             
03702         HT_NURBS_Trim * m_next;                 
03703         unsigned char   m_type;                 
03704         int             m_count;                
03705         float *         m_points;               
03706         //next 6 are specific to curves
03707         unsigned char   m_degree;               
03708         unsigned char   m_options;              
03709         float *         m_weights;              
03710         float *         m_knots;                
03711         float           m_start_u;              
03712         float           m_end_u;                
03713         HT_NURBS_Trim * m_list;                 
03714         HT_NURBS_Trim * m_current_trim;         
03716         HT_NURBS_Trim();
03717         TK_Status read_collection(BStreamFileToolkit & tk);  
03718         TK_Status write_collection(BStreamFileToolkit & tk); 
03720     public:
03721         ~HT_NURBS_Trim();
03722         void    SetPoly (int count, float const * points = 0) alter;    
03723         void    SetCurve (int degree, int control_count, float const * points = 0,
03724                           float const * weights = 0, float const * knots = 0, float start_u = 0, float end_u = 1) alter; 
03725         void    SetCollection () alter;                                 
03726         void    SetOptions (int o) alter { m_options = (unsigned char)o; }             
03727         void    SetList (HT_NURBS_Trim *node) alter { m_list = node; }  
03728         void    SetNext (HT_NURBS_Trim *next) { m_next = next; }        
03730         TK_Status   Read (BStreamFileToolkit & tk) alter;
03731         TK_Status   Write (BStreamFileToolkit & tk) alter;
03732 
03734         HT_NURBS_Trim * GetNext (void)              { return m_next;    }
03736         int             GetType (void) const        { return m_type;    }
03738         int             GetCount (void) const       { return m_count;   }
03740         float const *   GetPoints (void) const      { return m_points;  }
03742         float alter *   GetPoints (void) alter      { return m_points;  }
03744         int             GetDegree (void) const      { return m_degree;  }
03746         int             GetOptions (void) const     { return m_options; }
03748         float const *   GetWeights (void) const     { return m_weights; }
03750         float alter *   GetWeights (void) alter     { return m_weights; }
03752         float const *   GetKnots (void) const       { return m_knots;   }
03754         float alter *   GetKnots (void) alter       { return m_knots;   }
03756         HT_NURBS_Trim const *GetList (void) const   { return m_list;    }
03758         HT_NURBS_Trim *GetList (void) alter         { return m_list;    }
03759 
03760 };
03761 
03763 
03768 class BBINFILETK_API TK_NURBS_Surface : public BBaseOpcodeHandler {
03769     private:
03770         TK_NURBS_Surface(const TK_NURBS_Surface&);
03771         TK_NURBS_Surface& operator=(const TK_NURBS_Surface&);
03772 
03773     protected:
03774         unsigned char   m_optionals;        
03775         unsigned char   m_degree[2];        
03776         int             m_size[2];          
03777         float *         m_control_points;   
03778         float *         m_weights;          
03779         float *         m_u_knots;          
03780         float *         m_v_knots;          
03782         HT_NURBS_Trim * m_trims;            
03783         HT_NURBS_Trim * m_current_trim;     
03786     public:
03787         TK_NURBS_Surface();
03788         ~TK_NURBS_Surface();
03789 
03790         TK_Status   Read (BStreamFileToolkit & tk) alter;
03791         TK_Status   Write (BStreamFileToolkit & tk) alter;
03792         void        Reset (void) alter; 
03794         void            SetSurface (int u_degree, int v_degree,  int u_size, int v_size,
03795                                     float const * points = 0,    float const * weights = 0,
03796                                     float const * u_knots = 0,   float const * v_knots = 0) alter;  
03799         int             GetUDegree (void) const         { return m_degree[0];               }
03801         int             GetVDegree (void) const         { return m_degree[1];               }
03803         int             GetUSize (void) const           { return m_size[0];                 }
03805         int             GetVSize (void) const           { return m_size[1];                 }
03807         float const *   GetPoints (void) const          { return m_control_points;          }
03809         float alter *   GetPoints (void) alter          { return m_control_points;          }
03811         float const *   GetWeights (void) const         { return m_weights;                 }
03813         float alter *   GetWeights (void) alter         { return m_weights;                 }
03815         float const *   GetUKnots (void) const          { return m_u_knots;                 }
03817         float alter *   GetUKnots (void) alter          { return m_u_knots;                 }
03819         float const *   GetVKnots (void) const          { return m_v_knots;                 }
03821         float alter *   GetVKnots (void) alter          { return m_v_knots;                 }
03822 
03824         void            SetOptions (int o) alter        { m_optionals = (unsigned char)o;   }
03826         int             GetOptions (void) const         { return m_optionals;               }
03827 
03829         HT_NURBS_Trim * NewTrim (int type = NS_TRIM_END) alter;
03831         HT_NURBS_Trim * GetTrims (void) alter           { return m_trims;                   }
03832 };
03833 
03835 
03840 class BBINFILETK_API TK_Area_Light : public BBaseOpcodeHandler {
03841     private:
03842         TK_Area_Light(const TK_Area_Light&);
03843         TK_Area_Light& operator=(const TK_Area_Light&);
03844 
03845     protected:
03846         int             m_count;    
03847         float *         m_points;   
03848         char            m_options;  
03849 
03851         void    set_points (int count, float const * points = 0) alter;
03852 
03853     public:
03855         TK_Area_Light ()
03856             : BBaseOpcodeHandler (TKE_Area_Light), m_count (0), m_points (0), m_options (0) {}
03857         ~TK_Area_Light();
03858 
03859         TK_Status   Read (BStreamFileToolkit & tk) alter;
03860         TK_Status   Write (BStreamFileToolkit & tk) alter;
03861         void        Reset (void) alter;
03862 
03867         void            SetPoints (int count, float const * points = 0) alter   { set_points (count, points);   }
03869         float const *   GetPoints (void) const                                  { return m_points;              }
03871         float alter *   GetPoints (void) alter                                  { return m_points;              }
03873         int             GetCount (void) const                                   { return m_count;               }
03874 
03876         void            SetOptions (int o) alter                                { m_options = (char)o;          }
03878         int             GetOptions (void) const                                 { return (int)m_options;        }
03879 };
03880 
03881 
03885 enum TKO_Spot_Light_Options {
03886     TKO_Spot_Outer_Degrees      = 0x01,
03887     TKO_Spot_Outer_Field        = 0x02,
03888 
03889     TKO_Spot_Inner_Degrees      = 0x04,
03890     TKO_Spot_Inner_Field        = 0x08,
03891     TKO_Spot_Inner_Percent      = 0x0C,
03892 
03893     TKO_Spot_Outer_Mask         = 0x03,
03894     TKO_Spot_Inner_Mask         = 0x0C,
03895 
03896     TKO_Spot_Camera_Relative    = 0x10,
03897 
03898     TKO_Spot_Concentration      = 0x20
03899 };
03900 
03901 
03903 
03908 class BBINFILETK_API TK_Spot_Light : public BBaseOpcodeHandler {
03909     private:
03910         TK_Spot_Light(const TK_Spot_Light&);
03911         TK_Spot_Light& operator=(const TK_Spot_Light&);
03912 
03913     protected:
03914         float           m_position[3];      
03915         float           m_target[3];        
03916         float           m_outer;            
03917         float           m_inner;            
03918         float           m_concentration;    
03919         char            m_options;          
03920 
03921     public:
03923         TK_Spot_Light ()
03924             : BBaseOpcodeHandler (TKE_Spot_Light), m_options (0) {}
03925 
03926         TK_Status   Read (BStreamFileToolkit & tk) alter;
03927         TK_Status   Write (BStreamFileToolkit & tk) alter;
03928 
03930         void            SetPosition (float x, float y, float z) alter
03931                                         { m_position[0] = x; m_position[1] = y; m_position[2] = z;  }
03933         void            SetPosition (float const * p) alter     { SetPosition (p[0], p[1], p[2]);   }
03935         float const *   GetPosition (void) const                { return m_position;                }
03936 
03938         void            SetTarget (float x, float y, float z) alter
03939                                         { m_target[0] = x; m_target[1] = y; m_target[2] = z;        }
03941         void            SetTarget (float const * t) alter       { SetTarget (t[0], t[1], t[2]);     }
03943         float const *   GetTarget (void) const                  { return m_target;                  }
03944 
03946         void            SetOuter (float o) alter                { m_outer = o;                      }
03948         float           GetOuter (void) const                   { return m_outer;                   }
03949 
03951         void            SetInner (float i) alter                { m_inner = i;                      }
03953         float           GetInner (void) const                   { return m_inner;                   }
03954 
03956         void            SetConcentration (float c) alter        { m_concentration = c;              }
03958         float           GetConcentration (void) const           { return m_concentration;           }
03959 
03961         void            SetOptions (int o) alter                { m_options = (char)o;              }
03963         int             GetOptions (void) const                 { return (int)m_options;            }
03964 };
03965 
03966 
03968 
03973 class BBINFILETK_API TK_Cutting_Plane : public BBaseOpcodeHandler {
03974     private:
03975         TK_Cutting_Plane(const TK_Cutting_Plane&);
03976         TK_Cutting_Plane& operator=(const TK_Cutting_Plane&);
03977 
03978     protected:
03979         float           m_plane[4];     
03980 
03981     public:
03983         TK_Cutting_Plane ()
03984             : BBaseOpcodeHandler (TKE_Cutting_Plane) {}
03985 
03986         TK_Status   Read (BStreamFileToolkit & tk) alter;
03987         TK_Status   Write (BStreamFileToolkit & tk) alter;
03988 
03990         void            SetPlane (float a, float b, float c, float d) alter
03991                                     { m_plane[0] = a;  m_plane[1] = b;  m_plane[2] = c;  m_plane[3] = d;    }
03993         void            SetPlane (float const * p) alter            { SetPlane (p[0], p[1], p[2], p[3]);    }
03995         float const *   GetPlane (void) const                       { return m_plane;                       }
03996 };
03997 
03998 
04000 
04007 class BBINFILETK_API TK_Circle : public BBaseOpcodeHandler {
04008     private:
04009         TK_Circle(const TK_Circle&);
04010         TK_Circle& operator=(const TK_Circle&);
04011 
04012     protected:
04013         float           m_start[3];     
04014         float           m_middle[3];    
04015         float           m_end[3];       
04017     public:
04019         TK_Circle (unsigned char opcode)
04020             : BBaseOpcodeHandler (opcode) {}
04021 
04022         TK_Status   Read (BStreamFileToolkit & tk) alter;
04023         TK_Status   Write (BStreamFileToolkit & tk) alter;
04024 
04026         void            SetStart (float x, float y, float z) alter {
04027                                 m_start[0] = x;     m_start[1] = y;     m_start[2] = z;
04028                             }
04030         void            SetStart (float const * s) alter {
04031                                 m_start[0] = s[0];  m_start[1] = s[1];  m_start[2] = s[2];
04032                             }
04034         void            SetMiddle (float x, float y, float z) alter {
04035                                 m_middle[0] = x;    m_middle[1] = y;    m_middle[2] = z;
04036                             }
04038         void            SetMiddle (float const * m) alter {
04039                                 m_middle[0] = m[0]; m_middle[1] = m[1]; m_middle[2] = m[2];
04040                             }
04042         void            SetEnd (float x, float y, float z) alter {
04043                                 m_end[0] = x;       m_end[1] = y;       m_end[2] = z;
04044                             }
04046         void            SetEnd (float const * e) alter {
04047                                 m_end[0] = e[0];    m_end[1] = e[1];    m_end[2] = e[2];
04048                             }
04050         void            SetPoints (float const * s, float const * m, float const * e) alter {
04051                                 SetStart (s); SetMiddle (m); SetEnd (e);
04052                             }
04054         float const *   GetStart (void) const   { return m_start;   }
04056         float const *   GetMiddle (void) const  { return m_middle;  }
04058         float const *   GetEnd (void) const     { return m_end;     }
04059 };
04060 
04061 
04063 
04070 class BBINFILETK_API TK_Ellipse : public BBaseOpcodeHandler {
04071     private:
04072         TK_Ellipse(const TK_Ellipse&);
04073         TK_Ellipse& operator=(const TK_Ellipse&);
04074 
04075     protected:
04076         float           m_center[3];    
04077         float           m_major[3];     
04078         float           m_minor[3];     
04079         float           m_limits[2];    
04081     public:
04083         TK_Ellipse (unsigned char opcode)
04084             : BBaseOpcodeHandler (opcode) {}
04085 
04086         TK_Status   Read (BStreamFileToolkit & tk) alter;
04087         TK_Status   Write (BStreamFileToolkit & tk) alter;
04088 
04090         void            SetCenter (float x, float y, float z) alter {
04091                                 m_center[0] = x;    m_center[1] = y;    m_center[2] = z;
04092                             }
04094         void            SetCenter (float const * s) alter   { SetCenter (s[0], s[1], s[2]); }
04096         float const *   GetCenter (void) const              { return m_center;              }
04097 
04099         void            SetMajor (float x, float y, float z) alter {
04100                                 m_major[0] = x;     m_major[1] = y;     m_major[2] = z;
04101                             }
04103         void            SetMajor (float const * m) alter    { SetMajor (m[0], m[1], m[2]);  }
04105         float const *   GetMajor (void) const               { return m_major;               }
04106 
04108         void            SetMinor (float x, float y, float z) alter {
04109                                 m_minor[0] = x;     m_minor[1] = y;     m_minor[2] = z;
04110                             }
04112         void            SetMinor (float const * m) alter    { SetMinor (m[0], m[1], m[2]);  }
04114         float const *   GetMinor (void) const               { return m_minor;               }
04115 
04117         void            SetLimits (float s, float e) alter  {
04118                                 m_limits[0] = s;    m_limits[1] = e;
04119                             }
04121         float const *   GetLimits (void) const              { return m_limits;              }
04122 };
04123 
04124 
04126 
04133 class BBINFILETK_API TK_Cylinder : public BBaseOpcodeHandler {
04134     private:
04135         TK_Cylinder(const TK_Cylinder&);
04136         TK_Cylinder& operator=(const TK_Cylinder&);
04137 
04138     protected:
04139         float           m_axis[6];      
04140         float           m_radius;       
04141         unsigned char   m_flags;        
04143     public:
04145         TK_Cylinder ()
04146             : BBaseOpcodeHandler (TKE_Cylinder) {}
04147 
04148         TK_Status   Read (BStreamFileToolkit & tk) alter;
04149         TK_Status   Write (BStreamFileToolkit & tk) alter;
04150 
04152         void            SetAxis (float x1, float y1, float z1, float x2, float y2, float z2) alter {
04153                                 m_axis[0] = x1;     m_axis[1] = y1;     m_axis[2] = z1;
04154                                 m_axis[3] = x2;     m_axis[4] = y2;     m_axis[5] = z2;
04155                             }
04157         void            SetAxis (float const * s, float const * e) alter    { SetAxis (s[0], s[1], s[2], e[0], e[1], e[2]); }
04159         void            SetAxis (float const * a) alter     { SetAxis (&a[0], &a[3]);   }
04161         float const *   GetAxis (void) const                { return m_axis;            }
04163         float const *   GetStart (void) const               { return &m_axis[0];        }
04165         float const *   GetEnd (void) const                 { return &m_axis[3];        }
04166 
04168         void            SetRadius (float r) alter   { m_radius = r;     }
04170         float           GetRadius (void) const      { return m_radius;  }
04171 
04173         void            SetCaps (int f) alter       { m_flags = (unsigned char)f;      }
04175         int             GetCaps (void) const        { return m_flags;   }
04176 
04180         enum Capping_Options {
04181             TKCYL_NONE   = 0,
04182             TKCYL_FIRST  = 1,
04183             TKCYL_SECOND = 2,
04184             TKCYL_BOTH   = 3
04185         };
04186 
04187 };
04188 
04189 
04191 
04198 #include "BPolyhedron.h"
04199 
04200 class BBINFILETK_API TK_PolyCylinder : public TK_Polyhedron {
04201     private:
04202         TK_PolyCylinder(const TK_PolyCylinder&);
04203         TK_PolyCylinder& operator=(const TK_PolyCylinder&);
04204 
04205     protected:
04206         int             m_count;        
04207         float *         m_points;       
04208         int             m_radius_count; 
04209         float *         m_radii;        
04210         unsigned char   m_flags;        
04211         float           m_normals[6];   
04213     public:
04215         TK_PolyCylinder ()
04216             : TK_Polyhedron (TKE_PolyCylinder), m_count (0), m_points (0), m_radius_count (0), m_radii (0) {}
04217         ~TK_PolyCylinder();
04218 
04219         TK_Status   Read (BStreamFileToolkit & tk) alter;
04220         TK_Status   Write (BStreamFileToolkit & tk) alter;
04221         void        Reset (void) alter;
04222 
04226         enum Capping_Options {
04227             TKCYL_NORMAL_FIRST  = 0x04,
04228             TKCYL_NORMAL_SECOND = 0x08,
04229             TKCYL_OPTIONALS     = 0x10
04230         };
04231 
04236         void            SetPoints (int count, float const * points = 0) alter;
04238         float const *   GetPoints (void) const              { return m_points;              }
04240         float alter *   GetPoints (void) alter              { return m_points;              }
04242         int             GetCount (void) const               { return m_count;               }
04243 
04244 
04249         void            SetRadii (int count, float const * radii = 0) alter;
04251         void            SetRadius (float radius) alter      { SetRadii (1, &radius);        }
04253         float const *   GetRadii (void) const               { return m_radii;               }
04255         float alter *   GetRadii (void) alter               { return m_radii;               }
04257         int             GetRadiusCount (void) const         { return m_radius_count;        }
04258 
04259 
04261         void            SetCaps (int f) alter               { m_flags &= ~0x03; m_flags |= f;   }
04263         int             GetCaps (void) const                { return m_flags & 0x03;            }
04264 
04266         void            SetEndNormal (int index, float const * normal = 0) alter {
04267                                 int     mask = 0x40 << index;
04268                                 if (normal == 0)
04269                                     m_flags &= ~mask;
04270                                 else {
04271                                     m_flags |= mask;
04272                                     m_normals[3*index+0] = normal[0];
04273                                     m_normals[3*index+1] = normal[1];
04274                                     m_normals[3*index+2] = normal[2];
04275                                 }
04276                             }
04278         float const *   GetEndNormal (int index) const      {
04279                                 int     mask = 0x40 << index;
04280                                 if (m_flags & mask)
04281                                     return &m_normals[3*index];
04282                                 else
04283                                     return 0;
04284                             }
04285 };
04286 
04287 
04289 
04295 class BBINFILETK_API TK_Grid : public BBaseOpcodeHandler {
04296     private:
04297         TK_Grid(const TK_Grid&);
04298         TK_Grid& operator=(const TK_Grid&);
04299 
04300     protected:
04301         char            m_type;      
04302         float           m_origin[3]; 
04303         float           m_ref1[3];   
04304         float           m_ref2[3];   
04305         int             m_counts[2]; 
04307     public:
04309         TK_Grid ()
04310             : BBaseOpcodeHandler (TKE_Grid) {}
04311 
04312         TK_Status   Read (BStreamFileToolkit & tk) alter;
04313         TK_Status   Write (BStreamFileToolkit & tk) alter;
04314 
04316         void            SetOrigin (float x, float y, float z) alter {
04317                                 m_origin[0] = x;    m_origin[1] = y;    m_origin[2] = z;
04318                             }
04320         void            SetOrigin (float const * o) alter   { SetOrigin (o[0], o[1], o[2]); }
04322         float const *   GetOrigin (void) const              { return m_origin;              }
04323 
04325         void            SetRef1 (float x, float y, float z) alter {
04326                                 m_ref1[0] = x;      m_ref1[1] = y;      m_ref1[2] = z;
04327                             }
04329         void            SetRef1 (float const * r) alter     { SetRef1 (r[0], r[1], r[2]);   }
04331         float const *   GetRef1 (void) const                { return m_ref1;                }
04332 
04334         void            SetRef2 (float x, float y, float z) alter {
04335                                 m_ref2[0] = x;      m_ref2[1] = y;      m_ref2[2] = z;
04336                             }
04338         void            SetRef2 (float const * r) alter     { SetRef2 (r[0], r[1], r[2]);   }
04340         float const *   GetRef2 (void) const                { return m_ref2;                }
04341 
04343         void            SetCounts (int c1, int c2) alter    {
04344                                 m_counts[0] = c1;   m_counts[1] = c2;
04345                             }
04347         int const *     GetCounts (void) const              { return m_counts;              }
04348 
04350         void            SetType (int t)                     { m_type = (char)t;             }
04352         int             GetType (void) const                { return (int)m_type;           }
04353 };
04354 
04356 
04360 enum TKO_Text_Encodings {
04361     TKO_Enc_ISO_Latin_One,
04362     TKO_Enc_ISO_Latin,
04363     TKO_Enc_JEC,
04364     TKO_Enc_EUC,
04365     TKO_Enc_Raw_16,
04366     TKO_Enc_Unicode
04367 };
04368 
04370 
04376 class BBINFILETK_API TK_Text : public BBaseOpcodeHandler {
04377     private:
04378         TK_Text(const TK_Text&);
04379         TK_Text& operator=(const TK_Text&);
04380 
04381     protected:
04382         float           m_position[3];  
04383         unsigned char   m_encoding;     
04384         int             m_length;       
04385         int             m_allocated;    
04386         char *          m_string;       
04388         void    set_string (char const * string) alter;     
04389         void    set_string (int length) alter;              
04390 
04391     public:
04393         TK_Text (unsigned char opcode) : BBaseOpcodeHandler (opcode), m_length (0), m_allocated (0), m_string (0) {
04394                                             m_encoding = TKO_Enc_ISO_Latin_One;
04395                                             m_position[0] = m_position[1] = m_position[2] = 0.0f;
04396                                         }
04397         ~TK_Text();
04398 
04399         TK_Status   Read (BStreamFileToolkit & tk) alter;
04400         TK_Status   Write (BStreamFileToolkit & tk) alter;
04401         void        Reset (void) alter;
04402 
04404         void            SetString (char const * string) alter   { set_string (string);  }
04406         void            SetString (unsigned short const * string) alter;
04408         void            SetString (int length) alter            { set_string (length);  }
04410         char const *    GetString (void) const                  { return m_string;      }
04412         char alter *    GetString (void) alter                  { return m_string;      }
04413 
04415         void            SetPosition (float x, float y, float z) alter
04416                                         { m_position[0] = x;  m_position[1] = y;  m_position[2] = z;    }
04418         void            SetPosition (float const * p) alter     { SetPosition (p[0], p[1], p[2]);       }
04420         float const *   GetPosition (void) const                { return &m_position[0];                }
04421 
04423         void            SetEncoding (int e) alter               { m_encoding = (unsigned char)e;        }
04425         int             GetEncoding (void) const                { return (int)m_encoding;               }
04426 };
04427 
04429 
04431 
04437 enum TKO_Font_Type {
04438     TKO_Font_HOOPS_Stroked      // data represents a HOOPS stroked font definition
04439 };
04440 
04441 
04443 
04449 class BBINFILETK_API TK_Font : public BBaseOpcodeHandler {
04450     private:
04451         TK_Font(const TK_Font&);
04452         TK_Font& operator=(const TK_Font&);
04453 
04454     protected:
04455         char *          m_name;         
04456         char *          m_lookup;       
04457         char *          m_bytes;        
04458         int             m_name_length;  
04459         int             m_lookup_length;
04460         int             m_length;       
04461         unsigned char   m_type;         
04462         unsigned char   m_encoding;     
04464 
04465         void    set_bytes (int size, char const * bytes = 0) alter;
04467         void    set_name (char const * string) alter;
04469         void    set_name (int length) alter;
04471         void    set_lookup (char const * string) alter;
04473         void    set_lookup (int length) alter;
04474 
04475     public:
04477         TK_Font () : BBaseOpcodeHandler (TKE_Font),
04478             m_name (0), m_lookup (0), m_bytes (0), m_name_length (0), m_lookup_length (0), m_length (0),
04479             m_type (0), m_encoding (0) {}
04480         ~TK_Font();
04481 
04482         TK_Status   Read (BStreamFileToolkit & tk) alter;
04483         TK_Status   Write (BStreamFileToolkit & tk) alter;
04484         void        Reset (void) alter;
04485 
04486 
04488         void            SetType (int t) alter                               { m_type = (unsigned char)t;}
04490         int             GetType (void) const                                { return (int)m_type;       }
04491 
04496         void            SetBytes (int size, char const * bytes = 0) alter   { set_bytes (size, bytes);  }
04498         int             GetBytesCount (void) const                          { return m_length;          }
04500         char const *    GetBytes (void) const                               { return m_bytes;           }
04502         char alter *    GetBytes (void) alter                               { return m_bytes;           }
04503 
04505         void            SetName (char const * string) alter                 { set_name (string);        }
04507         void            SetName (int length) alter                          { set_name (length);        }
04509         char const *    GetName (void) const                                { return m_name;            }
04511         char alter *    GetName (void) alter                                { return m_name;            }
04512 
04514         void            SetLookup (char const * string) alter               { set_lookup (string);      }
04516         void            SetLookup (int length) alter                        { set_lookup (length);      }
04518         char const *    GetLookup (void) const                              { return m_lookup;          }
04520         char alter *    GetLookup (void) alter                              { return m_lookup;          }
04521 
04523         void            SetEncoding (int e) alter                       { m_encoding = (unsigned char)e;}
04525         int             GetEncoding (void) const                        { return (int)m_encoding;       }
04526 };
04527 
04529 
04533 enum TKO_Image_Formats {
04534     TKO_Image_Mapped    = 0,
04535     TKO_Image_Mapped_16 = 1,
04536     TKO_Image_RGB       = 2,
04537     TKO_Image_RGBA      = 3,
04538     TKO_Image_BGRA      = 4,
04539 
04540     TKO_Image_Is_Named      = 0x80,
04541     TKO_Image_Invalid       = 0xFF
04542 };
04543 
04547 enum TKO_Compression {
04548     TKO_Compression_None = 0,
04549     TKO_Compression_RLE  = 1,
04550     TKO_Compression_JPEG = 2
04551 };
04552 
04553 #ifndef DOXYGEN_SHOULD_SKIP_THIS
04554 
04555 class BBINFILETK_API TK_Image_Data_Buffer {
04556     protected:
04557         unsigned char *                 m_buffer;       
04558         unsigned int                    m_allocated;    
04559         unsigned int                    m_used;         
04560 
04561     public:
04563         TK_Image_Data_Buffer() : m_buffer (0),  m_allocated (0), m_used (0) {}
04564         ~TK_Image_Data_Buffer();
04565 
04566         void    Resize (unsigned int size) alter;
04567         void    Expand (unsigned int size) alter        { Resize (Size() + size);   }
04568         void    Reset (void) alter;
04569 
04570         unsigned int const &     Size (void) const      { return m_allocated;   }
04571         unsigned int const &     Used (void) const      { return m_used;        }
04572         unsigned int alter &     Used (void) alter      { return m_used;        }
04573         unsigned char const *    Buffer (void) const    { return m_buffer;      }
04574         unsigned char alter *    Buffer (void) alter    { return m_buffer;      }
04575 };
04576 
04577 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
04578 
04579 
04581 
04587 class BBINFILETK_API TK_Image : public BBaseOpcodeHandler {
04588     private:
04589         TK_Image(const TK_Image&);
04590         TK_Image& operator=(const TK_Image&);
04591 
04592     protected:
04593         char *                  m_bytes;        
04594         char *                  m_name;         
04595         float                   m_position[3];  
04596         int                     m_size[2];      
04597         int                     m_name_length;  
04598         unsigned char           m_format;       
04599         unsigned char           m_compression;  
04600         unsigned char           m_bytes_format; 
04601         TK_Image_Data_Buffer    m_work_area;    
04603 
04604         void    set_data (int size, char const * bytes = 0, unsigned char data_format = TKO_Compression_None) alter;
04606         void    set_name (char const * string) alter;
04608         void    set_name (int length) alter;
04609 
04611         TK_Status compress_image (BStreamFileToolkit & tk) alter;
04613         TK_Status decompress_image (BStreamFileToolkit & tk) alter;
04615         TK_Status read_jpeg_header (void) alter;
04616 
04617     public:
04619         TK_Image () : BBaseOpcodeHandler (TKE_Image), m_bytes (0), m_name (0), m_name_length (0),
04620                       m_format (TKO_Image_Invalid), m_compression (TKO_Compression_None) {}
04621         ~TK_Image();
04622 
04623         TK_Status   Read (BStreamFileToolkit & tk) alter;
04624         TK_Status   Write (BStreamFileToolkit & tk) alter;
04625         void        Reset (void) alter;
04626 
04631         void            SetBytes (int size, char const * bytes = 0,
04632                                   unsigned char data_format = TKO_Compression_None) alter
04633                                                                             { set_data (size, bytes, data_format);  }
04635         char const *    GetBytes (void) const                               { return m_bytes;           }
04637         char alter *    GetBytes (void) alter                               { return m_bytes;           }
04638 
04640         void            SetName (char const * string) alter                 { set_name (string);        }
04642         void            SetName (int length) alter                          { set_name (length);        }
04644         char const *    GetName (void) const                                { return m_name;            }
04646         char alter *    GetName (void) alter                                { return m_name;            }
04647 
04649         void            SetPosition (float x, float y, float z) alter
04650                                         { m_position[0] = x;  m_position[1] = y;  m_position[2] = z;    }
04652         void            SetPosition (float const * p) alter     { SetPosition (p[0], p[1], p[2]);       }
04654         float const *   GetPosition (void) const                { return &m_position[0];                }
04655 
04657         void            SetSize (int w, int h) alter            { m_size[0] = w; m_size[1] = h;         }
04659         int const *     GetSize (void) const                    { return m_size;                        }
04660 
04662         void            SetFormat (int f) alter                 { m_format = (unsigned char)f;          }
04664         int             GetFormat (void) const                  { return (int)m_format;                 }
04665 
04667         void            SetCompression (int c) alter            { m_compression = (unsigned char)c;     }
04669         int             GetCompression (void) const             { return (int)m_compression;            }
04670 };
04671 
04672 
04674 
04675 
04679 enum TKO_Texture_Option_Bits {
04680     TKO_Texture_Param_Source    = 0x0001,
04681     TKO_Texture_Tiling          = 0x0002,
04682     TKO_Texture_Interpolation   = 0x0004,
04683     TKO_Texture_Decimation      = 0x0008,
04684     TKO_Texture_Red_Mapping     = 0x0010,
04685     TKO_Texture_Green_Mapping   = 0x0020,
04686     TKO_Texture_Blue_Mapping    = 0x0040,
04687     TKO_Texture_Alpha_Mapping   = 0x0080,
04688     TKO_Texture_Param_Function  = 0x0100,
04689     TKO_Texture_Layout          = 0x0200,
04690     TKO_Texture_Transform       = 0x0400,
04691     TKO_Texture_Value_Scale     = 0x0800,
04692     TKO_Texture_Caching         = 0x1000,
04693     TKO_Texture_Extended        = 0x8000
04694 };
04695 
04699 enum TKO_Texture_Param_Sources {
04700     TKO_Texture_Param_Source_U,
04701     TKO_Texture_Param_Source_UV,
04702     TKO_Texture_Param_Source_UVW,
04703     TKO_Texture_Param_Source_Object,
04704     TKO_Texture_Param_Source_World,
04705     TKO_Texture_Param_Source_Surface_Normal,
04706     TKO_Texture_Param_Source_Reflection_Vector,
04707     TKO_Texture_Param_Source_Natural_UV,
04708     TKO_Texture_Param_Source_Local_Pixels,
04709     TKO_Texture_Param_Source_Outer_Pixels,
04710     TKO_Texture_Param_Source_Local_Window,
04711     TKO_Texture_Param_Source_Outer_Window,
04712     TKO_Texture_Param_Source_Transmission_Vector,
04713     TKO_Texture_Param_Source_Sphere_Map,
04714     TKO_Texture_Param_Source_Cylinder_Map
04715 };
04716 
04717 
04721 enum TKO_Texture_Param_Functions {
04722     TKO_Texture_Param_Function_None,
04723     TKO_Texture_Param_Function_Sphere,
04724     TKO_Texture_Param_Function_Cylinder,
04725     TKO_Texture_Param_Function_Box
04726 };
04727 
04728 
04732 enum TKO_Texture_Layouts {
04733     TKO_Texture_Layout_Rectilinear,
04734     TKO_Texture_Layout_Spherical,
04735     TKO_Texture_Layout_Hemispherical,
04736     TKO_Texture_Layout_Cubic_Faces
04737 };
04738 
04742 enum TKO_Texture_Tilings {
04743     TKO_Texture_Tiling_None,
04744     TKO_Texture_Tiling_Clamp,
04745     TKO_Texture_Tiling_Repeat,
04746     TKO_Texture_Tiling_Mirror
04747 };
04748 
04749 
04753 enum TKO_Texture_Filters {
04754     TKO_Texture_Filter_None,
04755     TKO_Texture_Filter_Bilinear,
04756     TKO_Texture_Filter_Trilinear,
04757     TKO_Texture_Filter_MipMap,
04758     TKO_Texture_Filter_Summed_Areas,
04759     TKO_Texture_Filter_Gaussian,
04760     TKO_Texture_Filter_Stochastic
04761 };
04762 
04763 
04767 enum TKO_Texture_Channel_Mappings {
04768     TKO_Texture_Channel_Mapping_Red,
04769     TKO_Texture_Channel_Mapping_Green,
04770     TKO_Texture_Channel_Mapping_Blue,
04771     TKO_Texture_Channel_Mapping_Alpha,
04772     TKO_Texture_Channel_Mapping_Zero,
04773     TKO_Texture_Channel_Mapping_One,
04774     TKO_Texture_Channel_Mapping_Luminance,
04775     TKO_Texture_Channel_Mapping_None
04776 };
04777 
04778 
04780 
04786 class BBINFILETK_API TK_Texture : public BBaseOpcodeHandler {
04787     private:
04788         TK_Texture(const TK_Texture&);
04789         TK_Texture& operator=(const TK_Texture&);
04790 
04791     protected:
04792         int             m_name_length;      
04793         int             m_image_length;     
04794         char *          m_name;             
04795         char *          m_image;            
04796         short           m_flags;            
04798         char            m_param_source;     
04799         char            m_interpolation;    
04800         char            m_decimation;       
04801         char            m_red_mapping;      
04802         char            m_green_mapping;    
04803         char            m_blue_mapping;     
04804         char            m_alpha_mapping;    
04805         char            m_param_function;   
04806         char            m_layout;           
04807         char            m_tiling;           
04808         float           m_value_scale[2];   
04809         char *          m_transform;        
04811         void    set_name (int length) alter;                    
04812         void    set_name (char const * name) alter;             
04813         void    set_image (int length) alter;                   
04814         void    set_image (char const * image) alter;           
04815         void    set_transform (int length) alter;               
04816         void    set_transform (char const * transform) alter;   
04817 
04818     public:
04820         TK_Texture () : BBaseOpcodeHandler (TKE_Texture),
04821             m_name_length (0), m_image_length (0),
04822             m_name (0), m_image (0),
04823             m_flags(0), m_transform (0) {}
04824         ~TK_Texture();
04825 
04826         TK_Status   Read (BStreamFileToolkit & tk) alter;
04827         TK_Status   Write (BStreamFileToolkit & tk) alter;
04828         void        Reset (void) alter;
04829 
04831         void            SetName (char const * name) alter           { set_name (name);              }
04833         void            SetName (int length) alter                  { set_name (length);            }
04835         char const *    GetName (void) const                        { return m_name;                }
04837         char alter *    GetName (void) alter                        { return m_name;                }
04838 
04840         void            SetImage (char const * image) alter         { set_image (image);            }
04842         void            SetImage (int length) alter                 { set_image (length);           }
04844         char const *    GetImage (void) const                       { return m_image;               }
04846         char alter *    GetImage (void) alter                       { return m_image;               }
04847 
04849         void            SetFlags (int f) alter                      { m_flags = (short)f;           }
04851         int             GetFlags (void) const                       { return (int)m_flags;          }
04852 
04854         void            SetParameterSource (int p) alter            { m_param_source = (char)p;     }
04856         int             GetParameterSource (void) const             { return (int)m_param_source;   }
04857 
04859         void            SetInterpolation (int p) alter              { m_interpolation = (char)p;    }
04861         int             GetInterpolation (void) const               { return (int)m_interpolation;  }
04862 
04864         void            SetDecimation (int p) alter                 { m_decimation = (char)p;       }
04866         int             GetDecimation (void) const                  { return (int)m_decimation;     }
04867 
04869         void            SetRedMapping (int p) alter                 { m_red_mapping = (char)p;      }
04871         int             GetRedMapping (void) const                  { return (int)m_red_mapping;    }
04872 
04874         void            SetGreenMapping (int p) alter               { m_green_mapping = (char)p;    }
04876         int             GetGreenMapping (void) const                { return (int)m_green_mapping;  }
04877 
04879         void            SetBlueMapping (int p) alter                { m_blue_mapping = (char)p;     }
04881         int             GetBlueMapping (void) const                 { return (int)m_blue_mapping;   }
04882 
04884         void            SetAlphaMapping (int p) alter               { m_alpha_mapping = (char)p;    }
04886         int             GetAlphaMapping (void) const                { return (int)m_alpha_mapping;  }
04887 
04889         void            SetParameterFunction (int p) alter          { m_param_function = (char)p;   }
04891         int             GetParameterFunction (void) const           { return (int)m_param_function; }
04892 
04894         void            SetLayout (int p) alter                     { m_layout = (char)p;           }
04896         int             GetLayout (void) const                      { return (int)m_layout;         }
04897 
04899         void            SetTiling (int p) alter                     { m_tiling = (char)p;           }
04901         int             GetTiling (void) const                      { return (int)m_tiling;         }
04902 
04904         void            SetValueScale (float v1, float v2) alter    { m_value_scale[0] = v1; m_value_scale[1] = v2; }
04906         float const *   GetValueScale (void) const                  { return m_value_scale;         }
04907 
04912         void            SetTransform (char const * transform) alter { set_transform (transform);    }
04917         void            SetTransform (int length) alter             { set_transform (length);       }
04919         char const *    GetTransform (void) const                   { return m_transform;           }
04921         char alter *    GetTransform (void) alter                   { return m_transform;           }
04922 };
04923 
04925 
04927 
04932 class BBINFILETK_API TK_Clip_Rectangle : public BBaseOpcodeHandler {
04933     private:
04934         TK_Clip_Rectangle(const TK_Clip_Rectangle&);
04935         TK_Clip_Rectangle& operator=(const TK_Clip_Rectangle&);
04936 
04937     protected:
04938         char            m_options;  
04939         float           m_rect[4];  
04941     public:
04943         TK_Clip_Rectangle ()
04944             : BBaseOpcodeHandler (TKE_Clip_Rectangle), m_options (0) {}
04945 
04946         TK_Status   Read (BStreamFileToolkit & tk) alter;
04947         TK_Status   Write (BStreamFileToolkit & tk) alter;
04948         void        Reset (void) alter;
04949 
04951         void            SetRectangle (float left, float right, float bottom, float top) alter
04952                             { m_rect[0] = left;  m_rect[1] = right;  m_rect[2] = bottom;  m_rect[3] = top; }
04954         void            SetRectangle (float const * rect) alter
04955                             { SetRectangle (rect[0], rect[1], rect[2], rect[3]); }
04957         float const *   GetRectangle (void) const       { return m_rect;            }
04958 
04960         void            SetOptions (int o) alter        { m_options = (char)o;      }
04962         int             GetOptions (void) const         { return (int)m_options;    }
04963 };
04964 
04966 
04970 enum TKO_Clip_Region_Options {
04971     TKO_Clip_Region_Window_Space = 0x01         
04972 };
04973 
04975 
04980 class BBINFILETK_API TK_Clip_Region : public BBaseOpcodeHandler {
04981     private:
04982         TK_Clip_Region(const TK_Clip_Region&);
04983         TK_Clip_Region& operator=(const TK_Clip_Region&);
04984 
04985     protected:
04986         char            m_options;  
04987         int             m_count;    
04988         float *         m_points;   
04990     public:
04992         TK_Clip_Region ()
04993             : BBaseOpcodeHandler (TKE_Clip_Region), m_count (0), m_points (0) {}
04994         ~TK_Clip_Region();
04995 
04996         TK_Status   Read (BStreamFileToolkit & tk) alter;
04997         TK_Status   Write (BStreamFileToolkit & tk) alter;
04998         void        Reset (void) alter;
04999 
05004         void            SetPoints (int count, float const * points = 0) alter;
05006         float const *   GetPoints (void) const                                  { return m_points;              }
05008         float alter *   GetPoints (void) alter                                  { return m_points;              }
05010         int             GetCount (void) const                                   { return m_count;               }
05011 
05013         void            SetOptions (int o) alter        { m_options = (char)o;      }
05015         int             GetOptions (void) const         { return (int)m_options;    }
05016 };
05017 
05018 
05020 
05022 
05038 class BBINFILETK_API TK_User_Data : public BBaseOpcodeHandler {
05039     private:
05040         TK_User_Data(const TK_User_Data&);
05041         TK_User_Data& operator=(const TK_User_Data&);
05042 
05043     protected:
05044         int             m_size;  
05045         char *          m_data;  
05047 
05048         void    set_data (int size, char const * bytes = 0) alter;  
05049 
05050     public:
05052         TK_User_Data ()
05053             : BBaseOpcodeHandler (TKE_Start_User_Data), m_size (0), m_data (0) {}
05054         ~TK_User_Data();
05055 
05056         TK_Status   Read (BStreamFileToolkit & tk) alter;
05057         TK_Status   Write (BStreamFileToolkit & tk) alter;
05058         TK_Status   Execute (BStreamFileToolkit & tk) alter;
05059         void        Reset (void) alter;
05060 
05065         void            SetUserData (int size, char const * bytes = 0) alter    { set_data (size, bytes);   }
05067         char const *    GetUserData (void) const                                { return m_data;            }
05069         char alter *    GetUserData (void) alter                                { return m_data;            }
05071         int             GetSize (void) const                                    { return m_size;            }
05072 };
05073 
05075 
05080 class BBINFILETK_API TK_XML : public BBaseOpcodeHandler {
05081     private:
05082         TK_XML(const TK_XML&);
05083         TK_XML& operator=(const TK_XML&);
05084 
05085     protected:
05086         int             m_size;  
05087         char *          m_data;  
05089     public:
05091         TK_XML (): BBaseOpcodeHandler (TKE_XML), m_size (0), m_data (0) {}
05092         ~TK_XML();
05093 
05094         TK_Status   Read (BStreamFileToolkit & tk) alter;
05095         TK_Status   Write (BStreamFileToolkit & tk) alter;
05096         TK_Status   Execute (BStreamFileToolkit & tk) alter;
05097         void        Reset (void) alter;
05098 
05103         void            SetXML (int size, char const * data = 0) alter;
05107         void            AppendXML (int size, char const * data = 0) alter;
05109         char const *    GetXML (void) const                     { return m_data;            }
05111         char alter *    GetXML (void) alter                     { return m_data;            }
05113         int             GetSize (void) const                    { return m_size;            }
05114 };
05115 
05116 
05117 
05119 
05125 class BBINFILETK_API TK_URL : public BBaseOpcodeHandler {
05126     private:
05127         TK_URL(const TK_URL&);
05128         TK_URL& operator=(const TK_URL&);
05129 
05130     protected:
05131         int             m_length;       
05132         int             m_allocated;    
05133         char *          m_string;       
05135     public:
05137         TK_URL () : BBaseOpcodeHandler (TKE_URL),
05138                                     m_length (0), m_allocated (0), m_string (0) {}
05139         ~TK_URL();
05140 
05141         TK_Status   Read (BStreamFileToolkit & tk) alter;
05142         TK_Status   Write (BStreamFileToolkit & tk) alter;
05143         void        Reset (void) alter;
05144 
05146         void            SetString (char const * string) alter;
05148         void            SetString (int length) alter;
05150         char const *    GetString (void) const                  { return m_string;      }
05152         char alter *    GetString (void) alter                  { return m_string;      }
05153 };
05154 
05155 
05157 
05163 class BBINFILETK_API TK_External_Reference : public BBaseOpcodeHandler {
05164     private:
05165         TK_External_Reference(const TK_External_Reference&);
05166         TK_External_Reference& operator=(const TK_External_Reference&);
05167 
05168     protected:
05169         int             m_length;       
05170         int             m_allocated;    
05171         char *          m_string;       
05173     public:
05174         TK_External_Reference () : BBaseOpcodeHandler (TKE_External_Reference),
05175                                     m_length (0), m_allocated (0), m_string (0) {}
05176         ~TK_External_Reference();
05177 
05178         TK_Status   Read (BStreamFileToolkit & tk) alter;
05179         TK_Status   Write (BStreamFileToolkit & tk) alter;
05180         TK_Status   Execute (BStreamFileToolkit & tk) alter;
05181         void        Reset (void) alter;
05182 
05184         void            SetString (char const * string) alter;
05186         void            SetString (int length) alter;
05188         char const *    GetString (void) const                  { return m_string;      }
05190         char alter *    GetString (void) alter                  { return m_string;      }
05191 };
05192 
05193 
05194 //
05195 //
05196 // W3D Extensions
05197 //
05198 //
05199 
05210 class BBINFILETK_API W3D_Image : public BBaseOpcodeHandler
05211 {
05212     private:
05213         W3D_Image(const W3D_Image&);
05214         W3D_Image& operator=(const W3D_Image&);
05215 
05216     protected:
05217 
05218         char *                  m_name;         
05219         int                     m_name_length;  
05220         int                     m_size[2];
05221         char                    m_bpp;
05222 
05224         void    set_name (char const * string) alter;
05226         void    set_name (int length) alter;
05227 
05228     public:
05230         W3D_Image () : BBaseOpcodeHandler ((unsigned char)W3DE_Image), m_name (0), m_name_length (0), m_bpp(0)
05231         { m_size[0] = m_size[1] = 0; }
05232         ~W3D_Image();
05233 
05234         TK_Status   Read (BStreamFileToolkit & tk) alter;
05235         TK_Status   Write (BStreamFileToolkit & tk) alter;
05236         void        Reset (void) alter;
05237 
05239         void            SetName (char const * string) alter                 { set_name (string);        }
05241         void            SetName (int length) alter                          { set_name (length);        }
05243         char const *    GetName (void) const                                { return m_name;            }
05245         char alter *    GetName (void) alter                                { return m_name;            }
05246 
05247         void            SetSize (int x, int y )                             { m_size[0] = x; m_size[1] = y ;}
05248         int const*      GetSize (void) const                                { return m_size;            }
05249         int alter*      GetSize (void) alter                                { return m_size;            }
05250 
05251         void            SetBitDepth( char bpp )                             { m_bpp = bpp;              }
05252         char const      GetBitDepth (void) const                            { return m_bpp;            }
05253         char alter      GetBitDepth (void) alter                            { return m_bpp;            }
05254 
05255 };
05256 
05257 
05258 #endif //BOPCODE_HANDLER
05259 

Generated on Tue May 17 12:06:00 2005 for Autodesk DWF 3D Toolkit by  doxygen 1.4.1