Introduction

Getting Started

Programming Guides

API Reference

Additional Resources

BOpcodeHandler.h
Go to the documentation of this file.
1 // Copyright (c) Tech Soft 3D, Inc.
2 //
3 // The information contained herein is confidential and proprietary to Tech Soft 3D, Inc.,
4 // and considered a trade secret as defined under civil and criminal statutes.
5 // Tech Soft 3D, Inc. shall pursue its civil and criminal remedies in the event of
6 // unauthorized use or misappropriation of its trade secrets. Use of this information
7 // by anyone other than authorized employees of Tech Soft 3D, Inc. is granted only under
8 // a written non-disclosure agreement, expressly prescribing the scope and manner of such use.
9 
10 #ifndef BOPCODE_HANDLER
11 #define BOPCODE_HANDLER
12 
13 #ifndef BBINFILETK_TOOLKIT
14  #include "BStreamFileToolkit.h"
15 #endif
16 
17 #ifndef POINTER_SIZED_INT
18 #if defined(WIN64) || defined(_M_X64) || defined(_WIN64)
19 # define POINTER_SIZED_INT __int64
20 # define POINTER_SIZED_UINT unsigned __int64
21 #else
22 # define POINTER_SIZED_INT long
23 # define POINTER_SIZED_UINT unsigned long
24 #endif
25 #endif
26 
27 #include "BOpcodeEnums.h"
28 
29 
31 
34 
55 class BBINFILETK_API2 BBaseOpcodeHandler
56 #ifdef HPS_CORE_BUILD
57  : public CMO
58 #else
60 #endif
61 {
62  protected:
63  int m_stage;
64  int m_progress;
65  unsigned char m_opcode;
66  unsigned char m_general_flags;
67  bool m_needs_tag;
69 
72  char * m_debug_string;
74  char * m_ascii_buffer;
75  int m_ascii_size;
76  int m_ascii_length;
77 
78  int m_ascii_stage;
80 
81  unsigned char m_byte;
82  unsigned short m_unsigned_short;
83  int m_int;
84  char m_char;
85 
86  public:
93  : m_stage (0), m_progress (0), m_opcode ((unsigned char)op), m_general_flags(0), m_needs_tag (false),
94  m_collection_part(false), m_debug_length (0), m_debug_allocated (0), m_debug_string (0),
95  m_ascii_buffer (0), m_ascii_size (0), m_ascii_length (0), m_ascii_stage (0), m_ascii_progress(0),
96  m_byte(0), m_unsigned_short(0), m_int(0), m_char('\0')
97  {}
98  virtual ~BBaseOpcodeHandler ();
99 
107  virtual TK_Status Read (BStreamFileToolkit & tk) = 0;
108 
116  virtual TK_Status Write (BStreamFileToolkit & tk) = 0;
117 
125  virtual TK_Status Execute (BStreamFileToolkit & tk);
126 
136  virtual TK_Status Interpret (BStreamFileToolkit & tk, ID_Key key, int variant = 0);
137 
147  virtual TK_Status Interpret (BStreamFileToolkit & tk, ID_Key key, char const * special);
148 
154  virtual void Reset ();
155 
160  virtual bool Match_Instance (BStreamFileToolkit const & tk, Recorded_Instance * instance);
161 
162 
164  unsigned char Opcode () const { return m_opcode; }
165 
167  unsigned char General_Flags () const { return m_general_flags; }
168 
170  void Set_General_Flags (int f) { m_general_flags = (unsigned char)f; }
171 
176  int Pass (BStreamFileToolkit & tk) const { return tk.pass(); }
177 
182  TK_Status Tag (BStreamFileToolkit & tk, int variant= -1) const { return tk.tag(variant); }
183 
187  bool Tagging (BStreamFileToolkit & tk) const {
188  return m_needs_tag || tk.GetWriteFlags(TK_Force_Tags) != 0;
189  }
190 
194  void SetNeedsTag (bool n) { m_needs_tag = n; }
195 
199  bool NeedsTag () const { return m_needs_tag; }
200 
204  void SetCollectionPart(bool n) { m_collection_part = n; }
205 
209  bool IsCollectionPart() const { return m_collection_part; }
210 
217  virtual TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const {
218  *handler = 0;
219  return tk.Error();
220  }
221 
227  virtual bool NeedsContext (BStreamFileToolkit & tk) const { (void)tk; return false; }
228 
233  void SetLoggingString (char const * segment);
234 
239  void SetLoggingString (int length);
240 
244  char const * GetLoggingString () const { return m_debug_string; }
249  char * GetLoggingString () { return m_debug_string; }
250 
254  void LogDebug (BStreamFileToolkit & tk, char const * string = 0);
255 
256  protected:
257  // various means of pulling data from the toolkit buffer
258  // Note: format conversion is safe to do in output buffer
259 
261  static TK_Status GetData (BStreamFileToolkit & tk, char * b, int n) { return tk.read (b, n); }
262 
264  static TK_Status GetData (BStreamFileToolkit & tk, short * s, int n) {
265  TK_Status status;
266  if ((status = GetData (tk, (char *)s, n * (int)sizeof (short))) == TK_Normal)
267  fix (s, n);
268  return status;
269  }
270 
272  static TK_Status GetData (BStreamFileToolkit & tk, int * i, int n) {
273  TK_Status status;
274  if ((status = GetData (tk, (char *)i, n * (int)sizeof (int))) == TK_Normal)
275  fix (i, n);
276  return status;
277  }
278 
280  static TK_Status GetData (BStreamFileToolkit & tk, float * f, int n) {
281  TK_Status status;
282  if ((status = GetData (tk, (char *)f, n * (int)sizeof (float))) == TK_Normal)
283  fix_in (f, n);
284  return status;
285  }
286 
288  static TK_Status GetData (BStreamFileToolkit & tk, double * d, int n) {
289  TK_Status status;
290  if ((status = GetData (tk, (char *)d, n * (int)sizeof (double))) == TK_Normal)
291  fix_in (d, n);
292  return status;
293  }
294 
296  static TK_Status GetData (BStreamFileToolkit & tk, unsigned char * b, int n) { return GetData (tk, (char *)b, n); }
297 
299  static TK_Status GetData (BStreamFileToolkit & tk, unsigned short * s, int n) { return GetData (tk, (short *)s, n); }
300 
302  static TK_Status GetData (BStreamFileToolkit & tk, unsigned int * i, int n) { return GetData (tk, (int *)i, n); }
303 
305  static TK_Status GetData (BStreamFileToolkit & tk, char & c) { return GetData (tk, &c, 1); }
306 
308  static TK_Status GetData (BStreamFileToolkit & tk, short & s) { return GetData (tk, &s, 1); }
309 
311  static TK_Status GetData (BStreamFileToolkit & tk, int & i) { return GetData (tk, &i, 1); }
312 
314  static TK_Status GetData (BStreamFileToolkit & tk, unsigned char & b) { return GetData (tk, &b, 1); }
315 
317  static TK_Status GetData (BStreamFileToolkit & tk, unsigned short & s) { return GetData (tk, &s, 1); }
318 
320  static TK_Status GetData (BStreamFileToolkit & tk, unsigned int & i) { return GetData (tk, &i, 1); }
321 
323  static TK_Status GetData (BStreamFileToolkit & tk, float & f) { return GetData (tk, &f, 1); }
324 
326  static TK_Status GetData (BStreamFileToolkit & tk, double & d) { return GetData (tk, &d, 1); }
327 
328 
331  TK_Status status = TK_Normal;
332 
333  if (tk.GetVersion() >= 1975 &&
334  (status = GetData (tk, m_general_flags)) != TK_Normal)
335  return status;
336 
337  return status;
338  }
339 
340 
341 
342 
344  static TK_Status LookatData (BStreamFileToolkit & tk, unsigned char & b) { return tk.lookat ((char &)b); }
345 
346  // various means of putting data into the toolkit buffer
347  // Note: format conversion is NOT safe in input buffer -- use temps
348 
350  static TK_Status PutData (BStreamFileToolkit & tk, char const * b, int n) { return tk.write (b, n); }
351 
353  static TK_Status PutData (BStreamFileToolkit & tk, short const * s, int n) {
354  #ifdef STREAM_BIGENDIAN
355  short * buffer;
356  short * tmp;
357  TK_Status status;
358  int i;
359  BSTREAM_ALLOC_ARRAY(buffer, n, short);
360  tmp = buffer;
361  for (i=0; i<n; ++i)
362  *tmp++ = flip (*s++);
363  status = PutData (tk, (char const *)buffer, n * (int)sizeof (short));
364  BSTREAM_FREE_ARRAY(buffer, n, short);
365  if (status != TK_Normal)
366  return status;
367  return TK_Normal;
368  #else
369  return PutData (tk, (char const *)s, n * (int)sizeof (short));
370  #endif
371  }
372 
374  static TK_Status PutData (BStreamFileToolkit & tk, int const * i, int n) {
375  #ifdef STREAM_BIGENDIAN
376  int * buffer;
377  int * tmp;
378  TK_Status status;
379  int j;
380  BSTREAM_ALLOC_ARRAY(buffer, n, int);
381  tmp = buffer;
382  for (j=0; j<n; ++j)
383  *tmp++ = flip (*i++);
384  status = PutData (tk, (char const *)buffer, n * (int)sizeof (int));
385  BSTREAM_FREE_ARRAY(buffer, n, int);
386  if (status != TK_Normal)
387  return status;
388  return TK_Normal;
389  #else
390  return PutData (tk, (char const *)i, n * (int)sizeof (int));
391  #endif
392  }
393 
395  static TK_Status PutData (BStreamFileToolkit & tk, float const * f, int n) {
396  #if defined(NON_IEEE) || defined(STREAM_BIGENDIAN)
397  float * buffer;
398  float * tmp;
399  TK_Status status;
400  int i;
401  BSTREAM_ALLOC_ARRAY(buffer, n, float);
402  tmp = buffer;
403  for (i=0; i<n; ++i) {
404  *tmp = *f++;
405  fix_out (tmp++, 1);
406  }
407  status = PutData (tk, (char const *)buffer, n * (int)sizeof (float));
408  BSTREAM_FREE_ARRAY(buffer, n, float);
409  if (status != TK_Normal)
410  return status;
411  return TK_Normal;
412  #else
413  return PutData (tk, (char const *)f, n * (int)sizeof (float));
414  #endif
415  }
416 
418  static TK_Status PutData (BStreamFileToolkit & tk, double const * d, int n) {
419  #if defined(NON_IEEE) || defined(STREAM_BIGENDIAN)
420  double * buffer;
421  double * tmp;
422  TK_Status status;
423  int i;
424  BSTREAM_ALLOC_ARRAY(buffer, n, double);
425  tmp = buffer;
426  for (i=0; i<n; ++i) {
427  *tmp = *d++;
428  fix_out (tmp++, 1);
429  }
430  status = PutData (tk, (char const *)buffer, n * (int)sizeof (double));
431  BSTREAM_FREE_ARRAY(buffer, n, double);
432  if (status != TK_Normal)
433  return status;
434  return TK_Normal;
435  #else
436  return PutData (tk, (char const *)d, n * (int)sizeof (double));
437  #endif
438  }
439 
441  static TK_Status PutData (BStreamFileToolkit & tk, unsigned char const * b, int n) { return PutData (tk, (char const *)b, n); }
442 
444  static TK_Status PutData (BStreamFileToolkit & tk, unsigned short const * s, int n) { return PutData (tk, (short const *)s, n); }
445 
447  static TK_Status PutData (BStreamFileToolkit & tk, unsigned int const * i, int n) { return PutData (tk, (int const *)i, n); }
448 
450  static TK_Status PutData (BStreamFileToolkit & tk, char const & c) { return PutData (tk, &c, 1); }
451 
453  static TK_Status PutData (BStreamFileToolkit & tk, short const & s) { return PutData (tk, &s, 1); }
454 
456  static TK_Status PutData (BStreamFileToolkit & tk, int const & i) { return PutData (tk, &i, 1); }
457 
459  static TK_Status PutData (BStreamFileToolkit & tk, unsigned char const & b) { return PutData (tk, &b, 1); }
460 
462  static TK_Status PutData (BStreamFileToolkit & tk, unsigned short const & s) { return PutData (tk, &s, 1); }
463 
465  static TK_Status PutData (BStreamFileToolkit & tk, unsigned int const & i) { return PutData (tk, &i, 1); }
466 
468  static TK_Status PutData (BStreamFileToolkit & tk, float const & f) { return PutData (tk, &f, 1); }
469 
471  static TK_Status PutData (BStreamFileToolkit & tk, double const & d) { return PutData (tk, &d, 1); }
472 
474  TK_Status PutOpcode (BStreamFileToolkit & tk, int adjust = 1) {
475  TK_Status status;
476  unsigned int sequence;
477 
478  if ((status = PutData (tk, Opcode ())) != TK_Normal)
479  return status;
480 
481  tk.adjust_written (adjust);
482 
483  sequence = tk.NextOpcodeSequence();
484  if (tk.GetLogging())
485  log_opcode (tk, sequence, Opcode());
486 
487  return status;
488  }
489 
492  TK_Status status = TK_Normal;
493 
494  if (tk.GetTargetVersion() >= 1975 &&
495  (status = PutData (tk, General_Flags ())) != TK_Normal)
496  return status;
497 
498  return status;
499  }
500 
501 
502 
503  /* note -- fix for int types will work during read OR write phase, but floats need separate routines for native->IEEE and IEEE->native
504  */
506  static short flip (short s) {
507  return (short)(((s >> 8) & 0x00FF) | (s << 8));
508  }
510  static int flip (int i) {
511  return ((i >> 24) & 0x000000FF) | ((i >> 8) & 0x0000FF00) |
512  ((i << 8) & 0x00FF0000) | (i << 24);
513  }
514 
515  #ifdef STREAM_BIGENDIAN
516  static void flip (double * d) {
518  char b[8];
519  memcpy (b, &d, sizeof(double));
520  Swap (b[0], b[7]);
521  Swap (b[1], b[6]);
522  Swap (b[2], b[5]);
523  Swap (b[3], b[4]);
524  memcpy (&d, b, sizeof(double));
525  }
526  #endif
527 
528 #ifndef DOXYGEN_SHOULD_SKIP_THIS
529  #ifndef UNREFERENCED
530  #define UNREFERENCED(x) (void)(x)
531  #endif
532 #endif
533 
535  static void fix (int * i, int n) {
536  #ifdef STREAM_BIGENDIAN
537  while (n--){
538  *i = flip (*i);
539  i++;
540  }
541  #else
542  UNREFERENCED(i);
543  UNREFERENCED(n);
544  #endif
545  }
547  static void fix (short * s, int n) {
548  #ifdef STREAM_BIGENDIAN
549  while (n--){
550  *s = flip (*s);
551  s++;
552  }
553  #else
554  UNREFERENCED(s);
555  UNREFERENCED(n);
556  #endif
557  }
558 
560  static void fix_in (float * f, int n) {
561  #ifdef NON_IEEE
562  // need to re-interpret from IEEE to native format
563  #endif
564 
565  #ifdef STREAM_BIGENDIAN
566  int * i = (int *) f;
567  while (n--) {
568  *i = flip (*i);
569  i++;
570  }
571  #else
572  UNREFERENCED(f);
573  UNREFERENCED(n);
574  #endif
575  }
577  static void fix_in (double * d, int n) {
578  #ifdef NON_IEEE
579  // need to re-interpret from IEEE to native format
580  #endif
581 
582  #ifdef STREAM_BIGENDIAN
583  while (n--) {
584  flip (d++);
585  }
586  #else
587  UNREFERENCED(d);
588  UNREFERENCED(n);
589  #endif
590  }
592  static void fix_out (float * f, int n) {
593  #ifdef NON_IEEE
594  // need to re-interpret from native format to IEEE
595  #endif
596 
597  #ifdef STREAM_BIGENDIAN
598  int * i = (int*) f;
599  while (n--) {
600  *i = flip (*i);
601  i++;
602  }
603  #else
604  UNREFERENCED(f);
605  UNREFERENCED(n);
606  #endif
607  }
609  static void fix_out (double * d, int n) {
610  #ifdef NON_IEEE
611  // need to re-interpret from native format to IEEE
612  #endif
613 
614  #ifdef STREAM_BIGENDIAN
615  while (n--) {
616  flip (d++);
617  }
618  #else
619  UNREFERENCED(d);
620  UNREFERENCED(n);
621  #endif
622  }
623 
625  void log_opcode (BStreamFileToolkit & tk, unsigned int sequence, unsigned char opcode);
626 
627 
628  /* common conversions
629  these two are for converting between floats [0.0,1.0] and unsigned chars [0,255]
630  */
632  void floats_to_bytes (float const * in, unsigned char * out, int count) const {
633  while (count-- > 0)
634  *out++ = char (*in++ * 255.999f);
635  }
637  void bytes_to_floats (unsigned char const * in, float * out, int count) const {
638  while (count-- > 0)
639  *out++ = float (*in++) * (1.0f/255.0f);
640  }
641 
642  // access to toolkit utility functions
644  void add_segment (BStreamFileToolkit & tk, ID_Key key) { tk.add_segment (key); }
646  ID_Key remove_segment (BStreamFileToolkit & tk) { return tk.remove_segment(); }
648  void set_last_key (BStreamFileToolkit & tk, ID_Key key) { tk.set_last_key (key); }
651  if (tk.m_last_keys_used == 1)
652  return tk.m_last_keys[0];
653  else
654  return -1;
655  }
657  void adjust_written (BStreamFileToolkit & tk, int count) { tk.adjust_written (count); }
659  void increase_nesting (BStreamFileToolkit & tk, int amount=1) { tk.increase_nesting (amount); }
661  void decrease_nesting (BStreamFileToolkit & tk, int amount=1) { tk.decrease_nesting (amount); }
662 
666  void Revisit (BStreamFileToolkit & tk, float priority=0.0f, int variant=0) const { tk.revisit (Opcode(), priority, variant); }
667 
671  BBaseOpcodeHandler * Opcode_Handler (BStreamFileToolkit & tk, unsigned char op) const
672  { return tk.opcode_handler (op); }
673 
675  void Record_Instance (BStreamFileToolkit & tk, ID_Key key, int variant,
676  int val1, int val2, int val3) const {
677  tk.record_instance (key, variant, this, val1, val2, val3);
678  }
680  bool Find_Instance (BStreamFileToolkit & tk, int val1, int val2, int val3) {
681  return tk.find_instance (this, val1, val2, val3);
682  }
683 
685  void Remember_Item (BStreamFileToolkit & tk, ID_Key key) const { tk.remember_item(key); }
687  bool Find_Item (BStreamFileToolkit & tk, ID_Key key) const { return tk.find_item(key); }
688 
690  bool validate_count (int count, int limit = 1<<24) const { return 0 <= count && count <= limit; }
691 
695  static float read_float (char const *cp, char const ** newcpp = 0);
697  static float read_float (char const *cp, char ** newcpp)
698  { return read_float (cp, (char const **)newcpp); }
700  static char * write_float (char * buffer, double f);
701 
702 
703 
705  TK_Status SkipNewlineAndTabs(BStreamFileToolkit & tk, unsigned int* readSize=0);
707  TK_Status ReadAsciiLine(BStreamFileToolkit & tk, unsigned int* readSize=0);
709  TK_Status ReadAsciiWord(BStreamFileToolkit & tk, unsigned int* readSize=0);
711  TK_Status ReadEndOpcode(BStreamFileToolkit & tk);
713  bool RemoveAngularBrackets(char* string);
715  bool RemoveQuotes(char* string);
717  TK_Status Read_Referenced_Segment(BStreamFileToolkit & tk, int &i_progress);
718 
719  //TK_Status GetAsciiData(BStreamFileToolkit & tk, float * rFloats, unsigned int n);
720 
722  TK_Status GetAsciiData(BStreamFileToolkit & tk, int * rInts, unsigned int n);
723  //TK_Status GetAsciiData(BStreamFileToolkit & tk, short * rShorts, unsigned int n);
724 
726  TK_Status GetAsciiData(BStreamFileToolkit & tk, const char * tag, unsigned char& value);
728  TK_Status GetAsciiData(BStreamFileToolkit & tk, const char * tag, char& value);
730  TK_Status GetAsciiData(BStreamFileToolkit & tk, const char * tag, unsigned short& value);
732  TK_Status GetAsciiData(BStreamFileToolkit & tk, const char * tag, short& value);
734  TK_Status GetAsciiData(BStreamFileToolkit & tk, const char * tag, int& value);
736  TK_Status GetAsciiData(BStreamFileToolkit & tk, const char * tag, float& value);
738  TK_Status GetAsciiData(BStreamFileToolkit & tk, const char * tag, float * rFloats, unsigned int n);
740  TK_Status GetAsciiData(BStreamFileToolkit & tk, const char * tag, char * m_string, unsigned int n);
742  TK_Status GetAsciiData(BStreamFileToolkit & tk, const char * tag, unsigned char * m_string, unsigned int n);
744  TK_Status GetAsciiData(BStreamFileToolkit & tk, const char * tag, int * rInts, unsigned int n);
746  TK_Status GetAsciiData(BStreamFileToolkit & tk, const char * tag, short * rShorts, unsigned int n);
748  TK_Status GetAsciiData(BStreamFileToolkit & tk, const char * tag, unsigned short * rShorts, unsigned int n);
750  TK_Status GetAsciiHex(BStreamFileToolkit & tk, const char * tag, unsigned char &value);
752  TK_Status GetAsciiHex(BStreamFileToolkit & tk, const char * tag, int &value);
754  TK_Status GetAsciiHex(BStreamFileToolkit & tk, const char * tag, char &value);
756  TK_Status GetAsciiHex(BStreamFileToolkit & tk, const char * tag, unsigned short &value);
758  TK_Status GetAsciiImageData(BStreamFileToolkit & tk, const char * tag, unsigned char * rValues, unsigned int n);
759 
761  TK_Status PutAsciiOpcode (BStreamFileToolkit & tk, int adjust = 1, bool is_end = false, bool want_newline = true);
762  // TK_Status PutAsciiOpcode (BStreamFileToolkit & tk, int adjust = 1);
763 
765  TK_Status PutAsciiData (BStreamFileToolkit & tk, char const *tag, char const * b, int n);
767  TK_Status PutAsciiData (BStreamFileToolkit & tk, char const *tag, short const * s, int n);
769  TK_Status PutAsciiData (BStreamFileToolkit & tk, char const *tag, int const * i, int n);
771  TK_Status PutAsciiData (BStreamFileToolkit & tk, char const *tag, float const * f, int n);
773  TK_Status PutAsciiData (BStreamFileToolkit & tk, char const *tag, unsigned char const * b, int n);
775  TK_Status PutAsciiData (BStreamFileToolkit & tk, char const *tag, unsigned short const * s, int n);
777  TK_Status PutAsciiData (BStreamFileToolkit & tk, char const *tag, unsigned int const * i, int n);
779  TK_Status PutAsciiData (BStreamFileToolkit & tk, char const *tag, char const & c);
781  TK_Status PutAsciiData (BStreamFileToolkit & tk, char const *tag, short const & s);
783  TK_Status PutAsciiData (BStreamFileToolkit & tk, char const *tag, int const & i);
785  TK_Status PutAsciiFlag (BStreamFileToolkit & tk, char const *tag, int const & i);
787  TK_Status PutAsciiData (BStreamFileToolkit & tk, char const *tag, unsigned char const & b);
789  TK_Status PutAsciiData (BStreamFileToolkit & tk, char const *tag, unsigned short const & s);
791  TK_Status PutAsciiData (BStreamFileToolkit & tk, char const *tag, unsigned int const & i);
793  TK_Status PutAsciiData (BStreamFileToolkit & tk, char const *tag, float const & f);
795  TK_Status PutAsciiMask (BStreamFileToolkit & tk,char const *tag, int const & i);
797  TK_Status PutAsciiHex (BStreamFileToolkit & tk, char const *tag, int const & i);
799  TK_Status PutStartXMLTag (BStreamFileToolkit & tk, char const *tag);
801  TK_Status PutEndXMLTag (BStreamFileToolkit & tk, char const *tag);
802 };
803 
805 #define IMPLEMENT_CLONE(class_name) \
806  TK_Status class_name::Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **newhandler) const { \
807  *newhandler = BSTREAM_NEW(class_name); \
808  if (*newhandler != nullptr) \
809  return TK_Normal; \
810  else \
811  return tk.Error ("memory allocation in" #class_name "::clone failed"); \
812  } //
813 #define IMPLEMENT_CLONE_OPCODE(class_name) \
815  TK_Status class_name::Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **newhandler) const { \
816  *newhandler = BSTREAM_NEW(class_name)(Opcode()); \
817  if (*newhandler != nullptr) \
818  return TK_Normal; \
819  else \
820  return tk.Error ("memory allocation in" #class_name "::clone failed"); \
821 } //
822 
824 
830 class BBINFILETK_API TK_Default : public BBaseOpcodeHandler {
831 
832  protected:
833  char * m_opcode_buffer;
834  int m_buffer_count;
835 
836  public:
838  TK_Default () : BBaseOpcodeHandler (TKE_Pseudo_Handler) {m_opcode_buffer = 0, m_buffer_count = 0;}
839 
841 
843 
844 
845  TK_Status ReadAscii (BStreamFileToolkit & tk);
846  TK_Status WriteAscii (BStreamFileToolkit & tk);
847 
848 };
849 
855 class BBINFILETK_API TK_Unavailable : public BBaseOpcodeHandler {
856  public:
858  TK_Unavailable (char opcode) : BBaseOpcodeHandler (opcode) {}
859 
862 };
863 
866 
872 class BBINFILETK_API TK_Header : public BBaseOpcodeHandler {
873  protected:
876 
877  public:
879  TK_Header () : BBaseOpcodeHandler (TKE_Pseudo_Handler), m_current_object (0) {}
880  ~TK_Header();
881 
884 
885 
886  TK_Status ReadAscii (BStreamFileToolkit & tk);
887  TK_Status WriteAscii (BStreamFileToolkit & tk);
888 
889 
890  void Reset ();
891 };
892 
893 
895 
901 class BBINFILETK_API TK_File_Info : public BBaseOpcodeHandler {
902  protected:
904  int m_flags;
905 
906  public:
908  TK_File_Info () : BBaseOpcodeHandler (TKE_File_Info), m_flags (0) {}
909 
910 
914  TK_Status Interpret (BStreamFileToolkit & tk, ID_Key key, int variant);
915  TK_Status Interpret (BStreamFileToolkit & tk, ID_Key key, char const * special)
916  { return BBaseOpcodeHandler::Interpret(tk, key, special); }
917 
918 
919  TK_Status ReadAscii (BStreamFileToolkit & tk);
920  TK_Status WriteAscii (BStreamFileToolkit & tk);
921 
922 
924  void SetFlags (int f) { m_flags = f; }
926  int GetFlags () { return m_flags; }
927 };
928 
929 
931 
939 class BBINFILETK_API TK_Comment : public BBaseOpcodeHandler {
940  protected:
942  int m_length;
946  char * m_comment;
947 
949  void set_comment (char const * comment);
951  void set_comment (int length);
952 
953  public:
955  TK_Comment (char const * comment = 0);
956  ~TK_Comment();
957 
961 
962  TK_Status ReadAscii (BStreamFileToolkit & tk);
963  TK_Status WriteAscii (BStreamFileToolkit & tk);
964  TK_Status ExecuteAscii (BStreamFileToolkit & tk);
967  TK_Status Interpret (BStreamFileToolkit & tk, ID_Key key, int variant) {
968  (void)tk; (void)key; (void)variant;
969  return TK_Normal;
970  }
971  TK_Status Interpret (BStreamFileToolkit & tk, ID_Key key, char const * special)
972  { return BBaseOpcodeHandler::Interpret(tk, key, special); }
973  void Reset ();
974 
979  void SetComment (char const * comment) { set_comment (comment); }
984  void SetComment (int length) { set_comment (length); }
988  char const * GetComment () const { return m_comment; }
993  char * GetComment () { return m_comment; }
994 };
995 
996 
998 
1006 class BBINFILETK_API TK_Terminator : public BBaseOpcodeHandler {
1007  public:
1009  TK_Terminator (char opcode, bool is_file_terminator = true) : BBaseOpcodeHandler (opcode),
1010  m_terminate_file(is_file_terminator) {}
1011 
1015 
1016 
1017  TK_Status ReadAscii (BStreamFileToolkit & tk);
1018  TK_Status WriteAscii (BStreamFileToolkit & tk);
1019 
1020  protected:
1022  // meant to terminate the file or something else (viz. LOD collection)
1024 };
1025 
1026 
1028 
1035 class BBINFILETK_API TK_Compression : public BBaseOpcodeHandler {
1036  public:
1038  TK_Compression (char opcode) : BBaseOpcodeHandler (opcode) {}
1039 
1042 
1043  TK_Status ReadAscii (BStreamFileToolkit & tk);
1044  TK_Status WriteAscii (BStreamFileToolkit & tk);
1046  TK_Status ExecuteAscii (BStreamFileToolkit & tk);
1047  TK_Status Interpret (BStreamFileToolkit & tk, ID_Key key, int variant);
1048  TK_Status Interpret (BStreamFileToolkit & tk, ID_Key key, char const * special)
1049  { return BBaseOpcodeHandler::Interpret(tk, key, special); }
1050 };
1051 
1053 
1054 
1055 // this should be based off a "data handling" interface class broken out from BBaseOpcodeHandler
1056 class BBINFILETK_API Lock_Masks : public BBaseOpcodeHandler {
1057  public:
1058  int mask;
1059  int value;
1100 
1101 
1102  Lock_Masks () : BBaseOpcodeHandler (0) {}
1104  TK_Status Write (BStreamFileToolkit &) { return TK_Error; } //-V524
1105 
1106  TK_Status Read (BStreamFileToolkit & tk, bool mask_only);
1107  TK_Status Write (BStreamFileToolkit & tk, bool mask_only);
1108 
1109  void init() {
1110  mask = value = 0;
1111  color_mask = color_value = 0;
1112  color_face_mask = color_face_value =
1113  color_edge_mask = color_edge_value =
1114  color_line_mask = color_line_value =
1115  color_marker_mask = color_marker_value =
1116  color_text_mask = color_text_value =
1117  color_window_mask = color_window_value =
1118  color_face_contrast_mask = color_face_contrast_value =
1119  color_window_contrast_mask = color_window_contrast_value =
1120  color_back_mask = color_back_value =
1121  color_vertex_mask = color_vertex_value =
1122  color_edge_contrast_mask = color_edge_contrast_value =
1123  color_line_contrast_mask = color_line_contrast_value =
1124  color_marker_contrast_mask = color_marker_contrast_value =
1125  color_vertex_contrast_mask = color_vertex_contrast_value =
1126  color_text_contrast_mask = color_text_contrast_value = 0;
1127  color_simple_reflection_mask = color_simple_reflection_value = 0;
1128  color_cut_face_mask = color_cut_face_value = 0;
1129  color_cut_edge_mask = color_cut_edge_value = 0;
1130  visibility_mask = visibility_value = 0;
1131  }
1132 
1133  void set_color() {
1134  color_mask = color_value = TKO_Geo_All_Colors;
1135  color_face_mask = color_face_value =
1136  color_edge_mask = color_edge_value =
1137  color_line_mask = color_line_value =
1138  color_marker_mask = color_marker_value =
1139  color_text_mask = color_text_value =
1140  color_window_mask = color_window_value =
1141  color_face_contrast_mask = color_face_contrast_value =
1142  color_window_contrast_mask = color_window_contrast_value =
1143  color_back_mask = color_back_value =
1144  color_vertex_mask = color_vertex_value =
1145  color_edge_contrast_mask = color_edge_contrast_value =
1146  color_line_contrast_mask = color_line_contrast_value =
1147  color_marker_contrast_mask = color_marker_contrast_value =
1148  color_vertex_contrast_mask = color_vertex_contrast_value =
1149  color_text_contrast_mask = color_text_contrast_value =
1150  color_simple_reflection_mask = color_simple_reflection_value =
1151  color_cut_face_mask = color_cut_face_value =
1152  color_cut_edge_mask = color_cut_edge_value =
1154  }
1155 };
1156 
1158 
1160 
1170 class BBINFILETK_API TK_Open_Segment : public BBaseOpcodeHandler {
1171  protected:
1172  int m_length;
1174  char * m_string;
1176  void set_segment (char const * segment);
1179  void set_segment (int length);
1180 
1181  public:
1183  TK_Open_Segment () : BBaseOpcodeHandler (TKE_Open_Segment), m_length (0), m_allocated (0), m_string (0) {}
1184  ~TK_Open_Segment();
1185 
1188  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
1189 
1190  TK_Status ReadAscii (BStreamFileToolkit & tk);
1191  TK_Status WriteAscii (BStreamFileToolkit & tk);
1192  void Reset ();
1193 
1198  void SetSegment (char const * segment) { set_segment (segment); }
1199 
1204  void SetSegment (int length) { set_segment (length); }
1205 
1209  char const * GetSegment () const { return m_string; }
1214  char * GetSegment () { return m_string; }
1215 
1216 };
1217 
1218 
1220 
1229 class BBINFILETK_API TK_Close_Segment : public BBaseOpcodeHandler {
1230  public:
1232  TK_Close_Segment () : BBaseOpcodeHandler (TKE_Close_Segment) {}
1233 
1236  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
1237 
1238  TK_Status ReadAscii (BStreamFileToolkit & tk);
1239  TK_Status WriteAscii (BStreamFileToolkit & tk);
1240 };
1241 
1242 
1243 
1245 
1257 class BBINFILETK_API TK_Reopen_Segment : public BBaseOpcodeHandler {
1258  protected:
1259  int m_index;
1261  public:
1263  TK_Reopen_Segment () : BBaseOpcodeHandler (TKE_Reopen_Segment), m_index (-1) {}
1264 
1267  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
1268 
1269  TK_Status ReadAscii (BStreamFileToolkit & tk);
1270  TK_Status WriteAscii (BStreamFileToolkit & tk);
1271 
1273  void SetIndex (int i) { m_index = i; }
1275  int GetIndex () const { return m_index; }
1276 };
1277 
1278 
1280 
1288 class BBINFILETK_API TK_Referenced_Segment : public BBaseOpcodeHandler {
1289  protected:
1290  int m_length;
1292  char * m_string;
1295  char * m_condition;
1299  unsigned char m_renumbered_scope;
1301  bool m_follow;
1303 
1304  bool m_referee_has_priority;
1305  int m_referee_priority;
1306 
1307  void set_segment (char const * segment);
1308  void set_segment (int length);
1309 
1310  public:
1312  TK_Referenced_Segment (unsigned char opcode);
1314 
1317  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
1318 
1319  TK_Status ReadAscii (BStreamFileToolkit & tk);
1320  TK_Status WriteAscii (BStreamFileToolkit & tk);
1321  void Reset ();
1322 
1327  void SetSegment (char const * segment) { set_segment (segment); }
1332  void SetSegment (int length) { set_segment (length); }
1336  char const * GetSegment () const { return m_string; }
1341  char * GetSegment () { return m_string; }
1342 
1343 
1348  void SetCondition (char const * condition);
1353  void SetCondition (int length);
1357  char const * GetCondition () const { return m_condition; }
1362  char * GetCondition () { return m_condition; }
1363 
1364 
1366  void SetFollow (bool f) { m_follow = f; }
1368  bool GetFollow () { return m_follow; }
1369 
1370 };
1371 
1372 
1374 
1382 class BBINFILETK_API TK_Reference : public BBaseOpcodeHandler {
1383  protected:
1384  int m_index;
1387  char * m_condition;
1392  bool m_follow;
1393 
1394  public:
1396  TK_Reference ();
1397  ~TK_Reference();
1398 
1401  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
1402 
1403  TK_Status ReadAscii (BStreamFileToolkit & tk);
1404  TK_Status WriteAscii (BStreamFileToolkit & tk);
1405  void Reset ();
1406 
1408  void SetIndex (int index) { m_index = index; }
1410  ID_Key GetIndex () { return m_index; }
1411 
1416  void SetCondition (char const * condition);
1421  void SetCondition (int length);
1425  char const * GetCondition () const { return m_condition; }
1430  char * GetCondition () { return m_condition; }
1431 
1432 
1434  void SetFollow (bool f) { m_follow = f; }
1436  bool GetFollow () { return m_follow; }
1437 };
1438 
1440 
1442 
1450 class BBINFILETK_API TK_Instance : public BBaseOpcodeHandler {
1451  protected:
1457  float m_matrix[16];
1458 
1459  public:
1461  TK_Instance (int from_index=0, int from_variant=0, int to_index=0, int to_variant=0,
1462  int options=0, float const xform[]=0);
1463 
1466  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
1467 
1468  TK_Status ReadAscii (BStreamFileToolkit & tk);
1469  TK_Status WriteAscii (BStreamFileToolkit & tk);
1470 
1471  void Reset ();
1472 };
1473 
1475 
1478 class BBINFILETK_API TK_Delete_Object : public BBaseOpcodeHandler {
1479  protected:
1480  int m_index;
1481 
1482  public:
1485 
1488  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
1489 
1490  TK_Status ReadAscii (BStreamFileToolkit & tk);
1491  TK_Status WriteAscii (BStreamFileToolkit & tk);
1492 
1494  void SetIndex (int i) { m_index = i; }
1496  int GetIndex () { return m_index; }
1497 };
1498 
1499 
1501 
1502 
1504 
1507 class BBINFILETK_API TK_LOD : public BBaseOpcodeHandler {
1508  protected:
1514  struct vlist_s *m_current_working;
1516 
1517  TK_Status ReadOneList (BStreamFileToolkit & tk);
1518 
1519  public:
1521  TK_LOD () : BBaseOpcodeHandler (TKE_LOD) {
1522  m_num_primitives = 0;
1523  m_primitives = 0;
1524  m_highest_level = 0;
1525  m_levels_allocated = 0;
1526  m_substage = 0;
1527  m_current_working = 0;
1528  m_current_level = 0;
1529  }
1530  ~TK_LOD();
1531 
1534  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
1535 
1536  TK_Status ReadAscii (BStreamFileToolkit & tk);
1537  TK_Status WriteAscii (BStreamFileToolkit & tk);
1538 
1539  void Reset ();
1540 };
1542 #define TKLOD_ESCAPE 255
1543 
1544 
1546 
1548 
1553 class BBINFILETK_API TK_Geometry_Attributes : public BBaseOpcodeHandler {
1554  protected:
1555 
1556  public:
1558  TK_Geometry_Attributes () : BBaseOpcodeHandler (TKE_Geometry_Attributes) {}
1559 
1562 
1563  TK_Status ReadAscii (BStreamFileToolkit & tk);
1564  TK_Status WriteAscii (BStreamFileToolkit & tk);
1566 };
1567 
1569 
1579 class BBINFILETK_API TK_Renumber : public BBaseOpcodeHandler {
1580  protected:
1582 
1583  public:
1587  TK_Renumber (unsigned char opcode, ID_Key key = 0) : BBaseOpcodeHandler (opcode), m_key (key) {}
1588 
1591  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
1592 
1593  TK_Status ReadAscii (BStreamFileToolkit & tk);
1594  TK_Status WriteAscii (BStreamFileToolkit & tk);
1595 
1596  void SetKey (ID_Key k) { m_key = k; }
1598  ID_Key GetKey () const { return m_key; }
1599 };
1600 
1601 
1603 
1608 class BBINFILETK_API TK_Tag : public BBaseOpcodeHandler {
1609  protected:
1610 
1611  public:
1613  TK_Tag (unsigned char opcode = TKE_Tag) : BBaseOpcodeHandler (opcode) {}
1614 
1617 
1618  TK_Status ReadAscii (BStreamFileToolkit & tk);
1619  TK_Status WriteAscii (BStreamFileToolkit & tk);
1620 
1622  TK_Status Interpret (BStreamFileToolkit & tk, ID_Key key, int variant=0);
1623  TK_Status Interpret (BStreamFileToolkit & tk, ID_Key key, char const * special)
1624  { return BBaseOpcodeHandler::Interpret(tk, key, special); }
1625 };
1626 
1628 
1635 // Note: unlike most opcode handlers, this one does not contain its own data, it is primarily a
1636 // wrapper around the key <-> index translation table in the toolkit.
1637 class BBINFILETK_API TK_Dictionary : public BBaseOpcodeHandler {
1638  protected:
1639  unsigned char m_format;
1641  unsigned char m_present;
1643 
1644  Internal_Translator::Index_Key_Pair * m_item;
1645 
1646  public:
1648  TK_Dictionary () : BBaseOpcodeHandler (TKE_Dictionary), m_format (0) {}
1649 
1652 
1653  TK_Status ReadAscii (BStreamFileToolkit & tk);
1654  TK_Status WriteAscii (BStreamFileToolkit & tk);
1655 
1657  TK_Status Interpret (BStreamFileToolkit & tk, ID_Key key, int variant=0);
1658  TK_Status Interpret (BStreamFileToolkit & tk, ID_Key key, char const * special)
1659  { return BBaseOpcodeHandler::Interpret(tk, key, special); }
1660  void Reset ();
1661 };
1662 
1663 
1665 
1672 class BBINFILETK_API TK_Dictionary_Locater : public BBaseOpcodeHandler {
1673  protected:
1674  int m_size;
1675  int m_offset;
1676 
1677  public:
1679  TK_Dictionary_Locater () : BBaseOpcodeHandler (TKE_Dictionary_Locater), m_offset (0) {}
1680 
1683 
1684  TK_Status ReadAscii (BStreamFileToolkit & tk);
1685  TK_Status WriteAscii (BStreamFileToolkit & tk);
1686 
1688  TK_Status Interpret (BStreamFileToolkit & tk, ID_Key key, int variant=0);
1689  TK_Status Interpret (BStreamFileToolkit & tk, ID_Key key, char const * special)
1690  { return BBaseOpcodeHandler::Interpret(tk, key, special); }
1691  void Reset ();
1692 
1694  void SetSize (int size) { m_size = size; }
1696  int GetSize () const { return m_size; }
1698  void SetOffset (int offset) { m_offset = offset; }
1700  int GetOffset () const { return m_offset; }
1701 };
1702 
1703 
1705 
1706 
1708 
1713 class BBINFILETK_API TK_Color : public BBaseOpcodeHandler {
1714  protected:
1715  int m_mask;
1716  short m_channels;
1717 
1721  class BBINFILETK_API channel {
1722  public:
1723  float m_rgb[3];
1724  char * m_name;
1725 
1726  channel() : m_name (0) {}
1727  ~channel() { Reset(); }
1728  void Reset () {
1729  if (m_name)
1730  BSTREAM_FREE_ARRAY(m_name, (int)(strlen(m_name) + 1), char);
1731  m_name = 0;
1732  }
1733  };
1734 
1742  float m_gloss;
1743  float m_index;
1745 
1747  void set_channel_rgb (channel & c, float r, float g, float b, int which_channel = -1) {
1748  c.m_rgb[0] = r; c.m_rgb[1] = g; c.m_rgb[2] = b;
1749  if (which_channel != -1) {
1750  m_channels |= (1 << which_channel);
1751  if (which_channel > TKO_Channel_Extended)
1752  m_channels |= (1 << TKO_Channel_Extended);
1753  }
1754  }
1756  void set_channel_name (channel & c, char const * name, int which_channel = -1);
1758  void set_channel_name (channel & c, int length, int which_channel = -1);
1759 
1760  public:
1761  TK_Color ();
1762  ~TK_Color ();
1763 
1764  TK_Status Read (BStreamFileToolkit & tk);
1765  TK_Status Write (BStreamFileToolkit & tk);
1766  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
1767 
1768  TK_Status ReadAscii (BStreamFileToolkit & tk);
1769  TK_Status WriteAscii (BStreamFileToolkit & tk);
1770 
1771  void Reset ();
1772 
1774  void SetGeometry (int m) {
1775  m_mask = m & TKO_Geo_All_Colors;
1776  if ((m & TKO_Geo_Extended_Mask) != 0) {
1777  m_mask |= TKO_Geo_Extended;
1778  if ((m & TKO_Geo_Extended_Colors_Mask) != 0) {
1779  m_mask |= TKO_Geo_Extended_Colors;
1780  if ((m & TKO_Geo_Extended2_Mask) != 0)
1781  m_mask |= TKO_Geo_Extended2;
1782  }
1783  }
1784  }
1786  int GetGeometry () const { return m_mask; }
1788  void SetChannels (int c) {
1789  m_channels = (short)c;
1790  if ((c & (((unsigned int)~0) << (TKO_Channel_Extended_Shift))) != 0)
1791  m_channels |= (1 << TKO_Channel_Extended);
1792  }
1794  int GetChannels () const { return (int)m_channels; }
1795 
1797  void SetDiffuse (float r, float g, float b) { set_channel_rgb (m_diffuse, r, g, b, TKO_Channel_Diffuse); }
1799  void SetDiffuse (float const rgb[]) { SetDiffuse (rgb[0], rgb[1], rgb[2]); }
1801  void SetDiffuseName (char const * name) { set_channel_name (m_diffuse, name, TKO_Channel_Diffuse); }
1803  void SetDiffuseName (int length) { set_channel_name (m_diffuse, length, TKO_Channel_Diffuse); }
1805  float const * GetDiffuse () const { return m_diffuse.m_rgb; }
1807  char const * GetDiffuseName () const { return m_diffuse.m_name; }
1809  char * GetDiffuseName () { return m_diffuse.m_name; }
1810 
1812  void SetSpecular (float r, float g, float b) { set_channel_rgb (m_specular, r, g, b, TKO_Channel_Specular);}
1814  void SetSpecular (float const rgb[]) { SetSpecular (rgb[0], rgb[1], rgb[2]); }
1816  void SetSpecularName (char const * name) { set_channel_name (m_specular, name, TKO_Channel_Specular); }
1818  void SetSpecularName (int length) { set_channel_name (m_specular, length, TKO_Channel_Specular);}
1820  float const * GetSpecular () const { return m_specular.m_rgb; }
1822  char const * GetSpecularName () const { return m_specular.m_name; }
1824  char * GetSpecularName () { return m_specular.m_name; }
1825 
1827  void SetMirror (float r, float g, float b) { set_channel_rgb (m_mirror, r, g, b, TKO_Channel_Mirror); }
1829  void SetMirror (float const rgb[]) { SetMirror (rgb[0], rgb[1], rgb[2]); }
1831  void SetMirrorName (char const * name) { set_channel_name (m_mirror, name, TKO_Channel_Mirror); }
1833  void SetMirrorName (int length) { set_channel_name (m_mirror, length, TKO_Channel_Mirror); }
1835  float const * GetMirror () const { return m_mirror.m_rgb; }
1837  char const * GetMirrorName () const { return m_mirror.m_name; }
1839  char * GetMirrorName () { return m_mirror.m_name; }
1840 
1842  void SetTransmission (float r, float g, float b) { set_channel_rgb (m_transmission, r, g, b, TKO_Channel_Transmission); }
1844  void SetTransmission (float const rgb[]) { SetTransmission (rgb[0], rgb[1], rgb[2]); }
1846  void SetTransmissionName (char const * name) { set_channel_name (m_transmission, name, TKO_Channel_Transmission); }
1848  void SetTransmissionName (int length) { set_channel_name (m_transmission, length, TKO_Channel_Transmission); }
1850  float const * GetTransmission () const { return m_transmission.m_rgb; }
1852  char const * GetTransmissionName () const { return m_transmission.m_name; }
1854  char * GetTransmissionName () { return m_transmission.m_name; }
1855 
1857  void SetEmission (float r, float g, float b) { set_channel_rgb (m_emission, r, g, b, TKO_Channel_Emission);}
1859  void SetEmission (float const rgb[]) { SetEmission (rgb[0], rgb[1], rgb[2]); }
1861  void SetEmissionName (char const * name) { set_channel_name (m_emission, name, TKO_Channel_Emission); }
1863  void SetEmissionName (int length) { set_channel_name (m_emission, length, TKO_Channel_Emission);}
1865  float const * GetEmission () const { return m_emission.m_rgb; }
1867  char const * GetEmissionName () const { return m_emission.m_name; }
1869  char * GetEmissionName () { return m_emission.m_name; }
1870 
1872  void SetEnvironmentName (char const * name) { set_channel_name (m_environment, name, TKO_Channel_Environment); }
1874  void SetEnvironmentName (int length) { set_channel_name (m_environment, length, TKO_Channel_Environment); }
1876  char const * GetEnvironmentName () const { return m_environment.m_name; }
1878  char * GetEnvironmentName () { return m_environment.m_name; }
1879 
1881  void SetBumpName (char const * name) { set_channel_name (m_bump, name, TKO_Channel_Bump); }
1883  void SetBumpName (int length) { set_channel_name (m_bump, length, TKO_Channel_Bump); }
1885  char const * GetBumpName () const { return m_bump.m_name; }
1887  char * GetBumpName () { return m_bump.m_name; }
1888 
1890  void SetGloss (float g) { m_gloss = g; m_channels |= (1<<TKO_Channel_Gloss); }
1892  float GetGloss () const { return m_gloss; }
1894  void SetIndex (float i) { m_index = i; m_channels |= (1<<TKO_Channel_Index); }
1896  float GetIndex () const { return m_index; }
1897 };
1898 
1899 
1901 
1906 class BBINFILETK_API TK_Color_RGB : public BBaseOpcodeHandler {
1907  protected:
1908  int m_mask;
1909  float m_rgb[3];
1910 
1911  public:
1913  TK_Color_RGB () : BBaseOpcodeHandler (TKE_Color_RGB), m_mask (0) {}
1914 
1917  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
1918 
1919  TK_Status ReadAscii (BStreamFileToolkit & tk);
1920  TK_Status WriteAscii (BStreamFileToolkit & tk);
1921 
1926  void SetGeometry (int m) {
1927  m_mask = m & TKO_Geo_All_Colors;
1928  if ((m & TKO_Geo_Extended_Mask) != 0) {
1929  m_mask |= TKO_Geo_Extended;
1930  if ((m & TKO_Geo_Extended_Colors_Mask) != 0) {
1931  m_mask |= TKO_Geo_Extended_Colors;
1932  if ((m & TKO_Geo_Extended2_Mask) != 0)
1933  m_mask |= TKO_Geo_Extended2;
1934  }
1935  }
1936  }
1941  int GetGeometry () const { return m_mask; }
1942 
1944  void SetRGB (float r, float g, float b) { m_rgb[0] = r; m_rgb[1] = g; m_rgb[2] = b; }
1946  void SetRGB (float const rgb[]) { SetRGB (rgb[0], rgb[1], rgb[2]); }
1948  float const * GetRGB () const { return m_rgb; }
1949 };
1950 
1951 
1953 
1958 class BBINFILETK_API TK_Color_By_Value : public BBaseOpcodeHandler {
1959  protected:
1960  int m_mask;
1961  float m_value[3];
1962  char m_space;
1963 
1964  public:
1966  TK_Color_By_Value () : BBaseOpcodeHandler (TKE_Color_By_Value), m_mask (0) {}
1967 
1970  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
1971 
1972  TK_Status ReadAscii (BStreamFileToolkit & tk);
1973  TK_Status WriteAscii (BStreamFileToolkit & tk);
1974 
1979  void SetGeometry (int m) {
1980  m_mask = m & TKO_Geo_All_Colors;
1981  if ((m & TKO_Geo_Extended_Mask) != 0) {
1982  m_mask |= TKO_Geo_Extended;
1983  if ((m & TKO_Geo_Extended_Colors_Mask) != 0) {
1984  m_mask |= TKO_Geo_Extended_Colors;
1985  if ((m & TKO_Geo_Extended2_Mask) != 0)
1986  m_mask |= TKO_Geo_Extended2;
1987  }
1988  }
1989  }
1994  int GetGeometry () const { return m_mask; }
1995 
1997  void SetSpace (int s) { m_space = (char)s; }
1999  int GetSpace () const { return (int)m_space; }
2000 
2002  void SetValue (float a, float b, float c) {
2003  m_value[0] = a; m_value[1] = b; m_value[2] = c;
2004  }
2006  void SetValue (float const triple[]) { SetValue (triple[0], triple[1], triple[2]); }
2008  float const * GetValue () const { return m_value; }
2009 };
2010 
2011 
2013 
2019 class BBINFILETK_API TK_Color_By_Index : public BBaseOpcodeHandler {
2020  protected:
2021  int m_mask;
2022  int m_index;
2023 
2024  public:
2026  TK_Color_By_Index (unsigned char opcode) : BBaseOpcodeHandler (opcode), m_mask (0), m_index (-1) {}
2027 
2030  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
2031 
2032  TK_Status ReadAscii (BStreamFileToolkit & tk);
2033  TK_Status WriteAscii (BStreamFileToolkit & tk);
2034 
2039  void SetGeometry (int m) {
2040  m_mask = m & TKO_Geo_All_Colors;
2041  if ((m & TKO_Geo_Extended_Mask) != 0) {
2042  m_mask |= TKO_Geo_Extended;
2043  if ((m & TKO_Geo_Extended_Colors_Mask) != 0) {
2044  m_mask |= TKO_Geo_Extended_Colors;
2045  if ((m & TKO_Geo_Extended2_Mask) != 0)
2046  m_mask |= TKO_Geo_Extended2;
2047  }
2048  }
2049  }
2054  int GetGeometry () const { return m_mask; }
2055 
2057  void SetIndex (int i) { m_index = i; }
2059  int GetIndex () const { return m_index; }
2060 };
2061 
2063 
2068 class BBINFILETK_API TK_Color_By_FIndex : public BBaseOpcodeHandler {
2069  protected:
2070  int m_mask;
2071  float m_index;
2072 
2073  public:
2075  TK_Color_By_FIndex () : BBaseOpcodeHandler (TKE_Color_By_FIndex), m_mask (0), m_index (-1.0f) {}
2076 
2079  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
2080 
2081  TK_Status ReadAscii (BStreamFileToolkit & tk);
2082  TK_Status WriteAscii (BStreamFileToolkit & tk);
2083 
2088  void SetGeometry (int m) {
2089  m_mask = m & TKO_Geo_All_Colors;
2090  if ((m & TKO_Geo_Extended_Mask) != 0) {
2091  m_mask |= TKO_Geo_Extended;
2092  if ((m & TKO_Geo_Extended_Colors_Mask) != 0) {
2093  m_mask |= TKO_Geo_Extended_Colors;
2094  if ((m & TKO_Geo_Extended2_Mask) != 0)
2095  m_mask |= TKO_Geo_Extended2;
2096  }
2097  }
2098  }
2103  int GetGeometry () const { return m_mask; }
2104 
2106  void SetIndex (float val) { m_index = val; }
2108  float GetIndex () const { return m_index; }
2109 };
2110 
2111 
2114 
2119 class BBINFILETK_API TK_Color_Map : public BBaseOpcodeHandler {
2120  protected:
2121  int m_length;
2123  float * m_values;
2125  char * m_string;
2126  unsigned char m_format;
2127 
2129  void set_values (int length, float const values[] = 0);
2130 
2131  public:
2134  : BBaseOpcodeHandler (TKE_Color_Map), m_length (0), m_values_length (0), m_values (0), m_string_length (0), m_string (0), m_format (TKO_Map_RGB_Values) {}
2135  ~TK_Color_Map();
2136 
2139  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
2140 
2141  TK_Status ReadAscii (BStreamFileToolkit & tk);
2142  TK_Status WriteAscii (BStreamFileToolkit & tk);
2143 
2144  void Reset ();
2145 
2147  void SetFormat (int f) { m_format = (unsigned char)f; }
2149  int GetFormat () const { return (int)m_format; }
2150 
2155  void SetValues (int count, float const values[] = 0) { set_values (count, values); }
2157  float const * GetValues () const { return m_values; }
2159  float * GetValues () { return m_values; }
2161  int GetLength () const { return m_length; }
2162 
2167  void SetString (char const * string);
2172  void SetString (int length);
2176  char const * GetString () const { return m_string; }
2181  char * GetString () { return m_string; }
2182 };
2183 
2185 
2187 
2192 class BBINFILETK_API TK_PBR : public BBaseOpcodeHandler {
2193  protected:
2194  int m_options;
2195  char * m_base_color_map;
2196  char * m_normal_map;
2197  char * m_emissive_map;
2198  char * m_metalness_map;
2199  char * m_roughness_map;
2200  char * m_occlusion_map;
2201  float m_base_color_factor[4];
2202  float m_normal_factor;
2203  float m_metalness_factor;
2204  float m_roughness_factor;
2205  float m_occlusion_factor;
2206  float m_alpha_factor;
2207  char m_metalness_map_channel;
2208  char m_roughness_map_channel;
2209  char m_occlusion_map_channel;
2210 
2211 
2212  void set_string (char * & s, int length);
2213  void set_string (char * & s, char const * name);
2214  void reset_string (char * & s) {
2215  if (s)
2216  BSTREAM_FREE_ARRAY(s, (int)(strlen(s) + 1), char);
2217  s = 0;
2218  }
2219 
2220 
2221  public:
2222  TK_PBR ();
2223  ~TK_PBR ();
2224 
2227  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
2228 
2229  TK_Status ReadAscii (BStreamFileToolkit & tk);
2230  TK_Status WriteAscii (BStreamFileToolkit & tk);
2231 
2232  void Reset ();
2233 
2234 
2238  void SetOptions (int m) { m_options = m; }
2242  int GetOptions () const { return m_options; }
2243 
2244 
2245 
2247  void SetBaseColorMap (char const * name) { set_string (m_base_color_map, name); }
2249  void SetBaseColorMap (int length) { set_string (m_base_color_map, length); }
2251  char const * GetBaseColorMap () const { return m_base_color_map; }
2253  char * GetBaseColorMap () { return m_base_color_map; }
2254 
2256  void SetNormalMap (char const * name) { set_string (m_normal_map, name); }
2258  void SetNormalMap (int length) { set_string (m_normal_map, length); }
2260  char const * GetNormalMap () const { return m_normal_map; }
2262  char * GetNormalMap () { return m_normal_map; }
2263 
2265  void SetEmissiveMap (char const * name) { set_string (m_emissive_map, name); }
2267  void SetEmissiveMap (int length) { set_string (m_emissive_map, length); }
2269  char const * GetEmissiveMap () const { return m_emissive_map; }
2271  char * GetEmissiveMap () { return m_emissive_map; }
2272 
2274  void SetMetalnessMap (char const * name) { set_string (m_metalness_map, name); }
2276  void SetMetalnessMap (int length) { set_string (m_metalness_map, length); }
2278  char const * GetMetalnessMap () const { return m_metalness_map; }
2280  char * GetMetalnessMap () { return m_metalness_map; }
2281 
2283  void SetRoughnessMap (char const * name) { set_string (m_roughness_map, name); }
2285  void SetRoughnessMap (int length) { set_string (m_roughness_map, length); }
2287  char const * GetRoughnessMap () const { return m_roughness_map; }
2289  char * GetRoughnessMap () { return m_roughness_map; }
2290 
2292  void SetOcclusionMap (char const * name) { set_string (m_occlusion_map, name); }
2294  void SetOcclusionMap (int length) { set_string (m_occlusion_map, length); }
2296  char const * GetOcclusionMap () const { return m_occlusion_map; }
2298  char * GetOcclusionMap () { return m_occlusion_map; }
2299 
2300 
2302  void SetBaseColorFactor (float r, float g, float b, float a) {
2303  m_base_color_factor[0] = r;
2304  m_base_color_factor[1] = g;
2305  m_base_color_factor[2] = b;
2306  m_base_color_factor[3] = a;
2307 
2308  }
2310  void SetBaseColorFactor (float const rgba[])
2311  { SetBaseColorFactor (rgba[0], rgba[1], rgba[2], rgba[3]); }
2313  float const * GetBaseColorFactor () const { return m_base_color_factor; }
2314 
2316  void SetNormalFactor (float f) { m_normal_factor = f; }
2318  float GetNormalFactor () const { return m_normal_factor; }
2319 
2321  void SetMetalnessFactor (float f) { m_metalness_factor = f; }
2323  float GetMetalnessFactor () const { return m_metalness_factor; }
2324 
2326  void SetRoughnessFactor (float f) { m_roughness_factor = f; }
2328  float GetRoughnessFactor () const { return m_roughness_factor; }
2329 
2331  void SetOcclusionFactor (float f) { m_occlusion_factor = f; }
2333  float GetOcclusionFactor () const { return m_occlusion_factor; }
2334 
2336  void SetAlphaFactor (float f) { m_alpha_factor = f; }
2338  float GetAlphaFactor () const { return m_alpha_factor; }
2339 
2340 
2342  void SetMetalnessMapChannel (int c) { m_metalness_map_channel = (char)c; }
2344  int GetMetalnessMapChannel () const { return m_metalness_map_channel; }
2345 
2347  void SetRoughnessMapChannel (int c) { m_roughness_map_channel = (char)c; }
2349  int GetRoughnessMapChannel () const { return m_roughness_map_channel; }
2350 
2352  void SetOcclusionMapChannel (int c) { m_occlusion_map_channel = (char)c; }
2354  int GetOcclusionMapChannel () const { return m_occlusion_map_channel; }
2355 };
2356 
2357 
2359 
2362 
2368 class BBINFILETK_API TK_Callback : public BBaseOpcodeHandler {
2369  protected:
2370  int m_length;
2371  char * m_string;
2374  void set_callback (char const * callback);
2375 
2376  void set_callback (int length);
2377 
2378  public:
2380  TK_Callback () : BBaseOpcodeHandler (TKE_Callback), m_length (0), m_string (0) {}
2381  ~TK_Callback();
2382 
2385  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
2386 
2387  TK_Status ReadAscii (BStreamFileToolkit & tk);
2388  TK_Status WriteAscii (BStreamFileToolkit & tk);
2389 
2390  void Reset ();
2391 
2393  void SetCallback (char const * callback) { set_callback (callback); }
2395  void SetCallback (int length) { set_callback (length); }
2397  char const * GetCallback () const { return m_string; }
2399  char * GetCallback () { return m_string; }
2400 };
2401 
2403 
2404 
2405 #if 0
2406 class BBINFILETK_API TK_Radiosity_RayTrace_Options : public BBaseOpcodeHandler {
2407  protected:
2408 
2409  public:
2410  TK_Radiosity_RayTrace_Options () : BBaseOpcodeHandler (TKE_Radiosity_RayTrace_Options) {}
2411  ~TK_Radiosity_RayTrace_Options () {}
2412 
2415 
2416  TK_Status ReadAscii (BStreamFileToolkit & tk);
2417  TK_Status WriteAscii (BStreamFileToolkit & tk);
2418 };
2419 #endif
2420 
2421 
2423 
2429 class BBINFILETK_API TK_Rendering_Options : public BBaseOpcodeHandler {
2430  protected:
2431  int m_mask[3];
2432  int m_value[3];
2433 
2434  unsigned char m_hsr;
2435  unsigned char m_tq;
2436  int m_debug;
2439 
2440  float m_fog_limits[2];
2441 
2444 
2445  unsigned char m_buffer_options_mask;
2446  unsigned char m_buffer_options_value;
2448 
2454  float m_hlr_color[3];
2456  unsigned char m_hlr_weight_units;
2458  unsigned char m_hlr_threshold_units;
2459  unsigned char m_hlr_hsr_algorithm;
2460 
2461  unsigned short m_contour_options;
2462  unsigned short m_isoline_options;
2475  unsigned char * m_isoline_weights_unit;
2476 
2477  unsigned short m_tint_options;
2478  float m_tint_color[3];
2479  float m_tint_range[2];
2481 
2486  float m_ratio[8];
2488  float m_threshold[8];
2491  unsigned char m_clamp;
2492  unsigned char m_num_levels;
2494  float m_tolerance;
2495  float m_bounding[6];
2497  float m_cutoff[8];
2498  unsigned char m_heuristic;
2499  unsigned char m_fallback;
2500 
2514 
2517 
2518  unsigned char m_tessellations;
2520  char m_cylinder[8];
2522  char m_sphere[8];
2523 
2524  float m_gooch_color_range[2];
2528  unsigned short m_transparency_options;
2529 
2530  unsigned char m_cut_geometry;
2531  unsigned char m_cut_geometry_level;
2532  unsigned char m_cut_geometry_match;
2538 
2539  unsigned short m_simple_shadow;
2540  unsigned char m_simple_shadow_blur;
2542  float m_simple_shadow_plane[4];
2543  float m_simple_shadow_light[3];
2544  float m_simple_shadow_color[3];
2545  float m_simple_shadow_opacity;
2546 
2547  unsigned short m_shadow_map;
2548  unsigned short m_shadow_map_resolution;
2549  unsigned char m_shadow_map_samples;
2550 
2551  unsigned short m_simple_reflection;
2552  float m_simple_reflection_plane[4];
2559 
2560  float m_depth_range[2];
2561  float m_screen_range[8];
2562  float m_ambient_up_vector[3];
2563  float m_image_scale[2];
2564  unsigned short m_mask_transform;
2565 
2566  unsigned char m_geometry_options;
2567  float m_dihedral;
2568 
2569  float m_image_tint_color[3];
2570  float m_texture_tint_color[3];
2571  unsigned char m_depth_peeling_layers;
2574 
2579  unsigned char m_display_list_level;
2580  unsigned char m_antialias;
2581 
2582  short m_fbe_mask;
2583  short m_fbe_value;
2584 
2585  float m_eye_dome_lighting_back_color[3];
2586 
2588 
2589  int m_extra;
2590 
2591 #if 0
2592  TK_Radiosity_RayTrace_Options *m_rrt;
2593 #endif
2594 
2595  public:
2599 
2602  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
2603 
2604  TK_Status ReadAscii (BStreamFileToolkit & tk);
2605  TK_Status WriteAscii (BStreamFileToolkit & tk);
2606 
2607  void Reset ();
2608 
2610  void SetMask (int m0, int m1=0, int m2=0) {
2611  m_mask[0] = m0;
2612  m_mask[1] = m1;
2613  m_mask[2] = m2;
2614  if (m2 != 0)
2615  m_mask[1] |= TKO_Rendo_Extended;
2616  if (m1 != 0)
2617  m_mask[0] |= TKO_Rendo_Extended;
2618  }
2620  int GetMask (int index=0) const { return m_mask[index]; }
2621 
2623  void SetValue (int v0, int v1=0, int v2=0) { m_value[0] = v0; m_value[1] = v1; m_value[2] = v2; }
2625  int GetValue (int index=0) const { return m_value[index]; }
2626 
2628  void SetHSR (int h) { m_hsr &= 0xF0; m_hsr |= (unsigned char)h & 0x0F; }
2630  int GetHSR () const { return (int)(m_hsr & 0x0F); }
2631 
2633  void SetTransparentHSR (int t) { m_hsr &= 0x0F; m_hsr |= (unsigned char)t << 4; }
2635  int GetTransparentHSR () const { return (int)(m_hsr >> 4); }
2636 
2638  void SetTransparentStyle (int s) { m_transparency_options = (unsigned short)s; }
2640  int GetTransparentStyle () const { return (int)m_transparency_options; }
2641 
2643  void SetTechnology (int t) { m_tq &= 0xF0; m_tq |= (unsigned char)t & 0x0F; }
2645  int GetTechnology () const { return (int)(m_tq & 0x0F); }
2646 
2648  void SetQuantization (int q) { m_tq &= 0x0F; m_tq |= (unsigned char)q << 4; }
2650  int GetQuantization () const { return (int)(m_tq >> 4); }
2651 
2653  void SetDebug (int d) { m_debug = d; }
2655  int GetDebug () const { return m_debug; }
2656 
2658  void SetFaceDisplacement (int d) { m_face_displacement = d; }
2660  int GetFaceDisplacement () const { return m_face_displacement; }
2661 
2663  void SetVertexDisplacement (int d) { m_vertex_displacement = d; }
2665  int GetVertexDisplacement () const { return m_vertex_displacement; }
2666 
2668  void SetGeneralDisplacement (int d) { m_general_displacement = d; }
2670  int GetGeneralDisplacement () const { return m_general_displacement; }
2671 
2673  void SetJoinCutoffAngle (int d) { m_join_cutoff_angle = d; }
2675  int GetJoinCutoffAngle () const { return m_join_cutoff_angle; }
2676 
2678  void SetFogLimits (float n, float f) { m_fog_limits[0] = n; m_fog_limits[1] = f; }
2680  void SetFogLimits (float const l[]) { SetFogLimits (l[0], l[1]); }
2682  float const * GetFogLimits () const { return m_fog_limits; }
2683 
2684 
2686  void SetLockMask (int m) { m_lock.mask = m; }
2688  int GetLockMask () const { return m_lock.mask; }
2689 
2691  void SetLockValue (int v) { m_lock.value = v; }
2693  int GetLockValue () const { return m_lock.value; }
2694 
2699  void SetVisibilityLockMask (int m) { m_lock.visibility_mask = m; }
2704  int GetVisibilityLockMask () const { return m_lock.visibility_mask; }
2705 
2710  void SetVisibilityLockValue (int v) { m_lock.visibility_value = v; }
2715  int GetVisibilityLockValue () const { return m_lock.visibility_value; }
2716 
2717 
2722  void SetColorLockMask (int m) { m_lock.color_mask = m; }
2727  int GetColorLockMask () const { return m_lock.color_mask; }
2728 
2733  void SetColorLockValue (int v) { m_lock.color_value = v; }
2738  int GetColorLockValue () const { return m_lock.color_value; }
2739 
2740 
2745  void SetColorFaceLockMask (int m) { m_lock.color_face_mask = (short)m; }
2750  int GetColorFaceLockMask () const { return m_lock.color_face_mask; }
2751 
2756  void SetColorFaceLockValue (int v) { m_lock.color_face_value = (short)v; }
2761  int GetColorFaceLockValue () const { return m_lock.color_face_value; }
2762 
2763 
2768  void SetColorEdgeLockMask (int m) { m_lock.color_edge_mask = (short)m; }
2773  int GetColorEdgeLockMask () const { return m_lock.color_edge_mask; }
2774 
2779  void SetColorEdgeLockValue (int v) { m_lock.color_edge_value = (short)v; }
2784  int GetColorEdgeLockValue () const { return m_lock.color_edge_value; }
2785 
2786 
2791  void SetColorLineLockMask (int m) { m_lock.color_line_mask = (short)m; }
2796  int GetColorLineLockMask () const { return m_lock.color_line_mask; }
2797 
2802  void SetColorLineLockValue (int v) { m_lock.color_line_value = (short)v; }
2807  int GetColorLineLockValue () const { return m_lock.color_line_value; }
2808 
2809 
2814  void SetColorMarkerLockMask (int m) { m_lock.color_marker_mask = (short)m; }
2819  int GetColorMarkerLockMask () const { return m_lock.color_marker_mask; }
2820 
2825  void SetColorMarkerLockValue (int v) { m_lock.color_marker_value = (short)v; }
2830  int GetColorMarkerLockValue () const { return m_lock.color_marker_value; }
2831 
2832 
2837  void SetColorTextLockMask (int m) { m_lock.color_text_mask = (short)m; }
2842  int GetColorTextLockMask () const { return m_lock.color_text_mask; }
2843 
2848  void SetColorTextLockValue (int v) { m_lock.color_text_value = (short)v; }
2853  int GetColorTextLockValue () const { return m_lock.color_text_value; }
2854 
2855 
2860  void SetColorWindowLockMask (int m) { m_lock.color_window_mask = (short)m; }
2865  int GetColorWindowLockMask () const { return m_lock.color_window_mask; }
2866 
2871  void SetColorWindowLockValue (int v) { m_lock.color_window_value = (short)v; }
2876  int GetColorWindowLockValue () const { return m_lock.color_window_value; }
2877 
2878 
2883  void SetColorFaceContrastLockMask (int m) { m_lock.color_face_contrast_mask = (short)m; }
2888  int GetColorFaceContrastLockMask () const { return m_lock.color_face_contrast_mask; }
2889 
2894  void SetColorFaceContrastLockValue (int v) { m_lock.color_face_contrast_value = (short)v; }
2899  int GetColorFaceContrastLockValue () const { return m_lock.color_face_contrast_value; }
2900 
2901 
2906  void SetColorWindowContrastLockMask (int m) { m_lock.color_window_contrast_mask = (short)m; }
2911  int GetColorWindowContrastLockMask () const { return m_lock.color_window_contrast_mask; }
2912 
2917  void SetColorWindowContrastLockValue (int v) { m_lock.color_window_contrast_value = (short)v; }
2922  int GetColorWindowContrastLockValue () const { return m_lock.color_window_contrast_value; }
2923 
2924 
2929  void SetColorBackLockMask (int m) { m_lock.color_back_mask = (short)m; }
2934  int GetColorBackLockMask () const { return m_lock.color_back_mask; }
2935 
2940  void SetColorBackLockValue (int v) { m_lock.color_back_value = (short)v; }
2945  int GetColorBackLockValue () const { return m_lock.color_back_value; }
2946 
2947 
2952  void SetColorVertexLockMask (int m) { m_lock.color_vertex_mask = (short)m; }
2957  int GetColorVertexLockMask () const { return m_lock.color_vertex_mask; }
2958 
2963  void SetColorVertexLockValue (int v) { m_lock.color_vertex_value = (short)v; }
2968  int GetColorVertexLockValue () const { return m_lock.color_vertex_value; }
2969 
2970 
2975  void SetColorEdgeContrastLockMask (int m) { m_lock.color_edge_contrast_mask = (short)m; }
2980  int GetColorEdgeContrastLockMask () const { return m_lock.color_edge_contrast_mask; }
2981 
2986  void SetColorEdgeContrastLockValue (int v) { m_lock.color_edge_contrast_value = (short)v; }
2991  int GetColorEdgeContrastLockValue () const { return m_lock.color_edge_contrast_value; }
2992 
2993 
2998  void SetColorLineContrastLockMask (int m) { m_lock.color_line_contrast_mask = (short)m; }
3003  int GetColorLineContrastLockMask () const { return m_lock.color_line_contrast_mask; }
3004 
3009  void SetColorLineContrastLockValue (int v) { m_lock.color_line_contrast_value = (short)v; }
3014  int GetColorLineContrastLockValue () const { return m_lock.color_line_contrast_value; }
3015 
3016 
3021  void SetColorMarkerContrastLockMask (int m) { m_lock.color_marker_contrast_mask = (short)m; }
3026  int GetColorMarkerContrastLockMask () const { return m_lock.color_marker_contrast_mask; }
3027 
3032  void SetColorMarkerContrastLockValue (int v) { m_lock.color_marker_contrast_value = (short)v; }
3037  int GetColorMarkerContrastLockValue () const { return m_lock.color_marker_contrast_value; }
3038 
3039 
3044  void SetColorVertexContrastLockMask (int m) { m_lock.color_vertex_contrast_mask = (short)m; }
3049  int GetColorVertexContrastLockMask () const { return m_lock.color_vertex_contrast_mask; }
3050 
3055  void SetColorVertexContrastLockValue (int v) { m_lock.color_vertex_contrast_value = (short)v; }
3060  int GetColorVertexContrastLockValue () const { return m_lock.color_vertex_contrast_value; }
3061 
3062 
3067  void SetColorTextContrastLockMask (int m) { m_lock.color_text_contrast_mask = (short)m; }
3072  int GetColorTextContrastLockMask () const { return m_lock.color_text_contrast_mask; }
3073 
3078  void SetColorTextContrastLockValue (int v) { m_lock.color_text_contrast_value = (short)v; }
3083  int GetColorTextContrastLockValue () const { return m_lock.color_text_contrast_value; }
3084 
3085 
3086 
3087 
3089  void SetForcedLockMask (int m) { m_forced.mask = m; }
3091  int GetForcedLockMask () const { return m_forced.mask; }
3092 
3094  void SetForcedLockValue (int v) { m_forced.value = v; }
3096  int GetForcedLockValue () const { return m_forced.value; }
3097 
3102  void SetVisibilityForcedLockMask (int m) { m_forced.visibility_mask = m; }
3107  int GetVisibilityForcedLockMask () const { return m_forced.visibility_mask; }
3108 
3113  void SetVisibilityForcedLockValue (int v) { m_forced.visibility_value = v; }
3118  int GetVisibilityForcedLockValue () const { return m_forced.visibility_value; }
3119 
3120 
3125  void SetColorForcedLockMask (int m) { m_forced.color_mask = m; }
3130  int GetColorForcedLockMask () const { return m_forced.color_mask; }
3131 
3136  void SetColorForcedLockValue (int v) { m_forced.color_value = v; }
3141  int GetColorForcedLockValue () const { return m_forced.color_value; }
3142 
3143 
3148  void SetColorFaceForcedLockMask (int m) { m_forced.color_face_mask = (short)m; }
3153  int GetColorFaceForcedLockMask () const { return m_forced.color_face_mask; }
3154 
3159  void SetColorFaceForcedLockValue (int v) { m_forced.color_face_value = (short)v; }
3164  int GetColorFaceForcedLockValue () const { return m_forced.color_face_value; }
3165 
3166 
3171  void SetColorEdgeForcedLockMask (int m) { m_forced.color_edge_mask = (short)m; }
3176  int GetColorEdgeForcedLockMask () const { return m_forced.color_edge_mask; }
3177 
3182  void SetColorEdgeForcedLockValue (int v) { m_forced.color_edge_value = (short)v; }
3187  int GetColorEdgeForcedLockValue () const { return m_forced.color_edge_value; }
3188 
3189 
3194  void SetColorLineForcedLockMask (int m) { m_forced.color_line_mask = (short)m; }
3199  int GetColorLineForcedLockMask () const { return m_forced.color_line_mask; }
3200 
3205  void SetColorLineForcedLockValue (int v) { m_forced.color_line_value = (short)v; }
3210  int GetColorLineForcedLockValue () const { return m_forced.color_line_value; }
3211 
3212 
3217  void SetColorMarkerForcedLockMask (int m) { m_forced.color_marker_mask = (short)m; }
3222  int GetColorMarkerForcedLockMask () const { return m_forced.color_marker_mask; }
3223 
3228  void SetColorMarkerForcedLockValue (int v) { m_forced.color_marker_value = (short)v; }
3233  int GetColorMarkerForcedLockValue () const { return m_forced.color_marker_value; }
3234 
3235 
3240  void SetColorTextForcedLockMask (int m) { m_forced.color_text_mask = (short)m; }
3245  int GetColorTextForcedLockMask () const { return m_forced.color_text_mask; }
3246 
3251  void SetColorTextForcedLockValue (int v) { m_forced.color_text_value = (short)v; }
3256  int GetColorTextForcedLockValue () const { return m_forced.color_text_value; }
3257 
3258 
3263  void SetColorWindowForcedLockMask (int m) { m_forced.color_window_mask = (short)m; }
3268  int GetColorWindowForcedLockMask () const { return m_forced.color_window_mask; }
3269 
3274  void SetColorWindowForcedLockValue (int v) { m_forced.color_window_value = (short)v; }
3279  int GetColorWindowForcedLockValue () const { return m_forced.color_window_value; }
3280 
3281 
3286  void SetColorFaceContrastForcedLockMask (int m) { m_forced.color_face_contrast_mask = (short)m; }
3291  int GetColorFaceContrastForcedLockMask () const { return m_forced.color_face_contrast_mask; }
3292 
3297  void SetColorFaceContrastForcedLockValue (int v) { m_forced.color_face_contrast_value = (short)v; }
3302  int GetColorFaceContrastForcedLockValue () const { return m_forced.color_face_contrast_value; }
3303 
3304 
3309  void SetColorWindowContrastForcedLockMask (int m) { m_forced.color_window_contrast_mask = (short)m; }
3314  int GetColorWindowContrastForcedLockMask () const { return m_forced.color_window_contrast_mask; }
3315 
3320  void SetColorWindowContrastForcedLockValue (int v) { m_forced.color_window_contrast_value = (short)v; }
3325  int GetColorWindowContrastForcedLockValue () const { return m_forced.color_window_contrast_value; }
3326 
3327 
3332  void SetColorBackForcedLockMask (int m) { m_forced.color_back_mask = (short)m; }
3337  int GetColorBackForcedLockMask () const { return m_forced.color_back_mask; }
3338 
3343  void SetColorBackForcedLockValue (int v) { m_forced.color_back_value = (short)v; }
3348  int GetColorBackForcedLockValue () const { return m_forced.color_back_value; }
3349 
3350 
3355  void SetColorVertexForcedLockMask (int m) { m_forced.color_vertex_mask = (short)m; }
3360  int GetColorVertexForcedLockMask () const { return m_forced.color_vertex_mask; }
3361 
3366  void SetColorVertexForcedLockValue (int v) { m_forced.color_vertex_value = (short)v; }
3371  int GetColorVertexForcedLockValue () const { return m_forced.color_vertex_value; }
3372 
3373 
3378  void SetColorEdgeContrastForcedLockMask (int m) { m_forced.color_edge_contrast_mask = (short)m; }
3383  int GetColorEdgeContrastForcedLockMask () const { return m_forced.color_edge_contrast_mask; }
3384 
3389  void SetColorEdgeContrastForcedLockValue (int v) { m_forced.color_edge_contrast_value = (short)v; }
3394  int GetColorEdgeContrastForcedLockValue () const { return m_forced.color_edge_contrast_value; }
3395 
3396 
3401  void SetColorLineContrastForcedLockMask (int m) { m_forced.color_line_contrast_mask = (short)m; }
3406  int GetColorLineContrastForcedLockMask () const { return m_forced.color_line_contrast_mask; }
3407 
3412  void SetColorLineContrastForcedLockValue (int v) { m_forced.color_line_contrast_value = (short)v; }
3417  int GetColorLineContrastForcedLockValue () const { return m_forced.color_line_contrast_value; }
3418 
3419 
3424  void SetColorMarkerContrastForcedLockMask (int m) { m_forced.color_marker_contrast_mask = (short)m; }
3429  int GetColorMarkerContrastForcedLockMask () const { return m_forced.color_marker_contrast_mask; }
3430 
3435  void SetColorMarkerContrastForcedLockValue (int v) { m_forced.color_marker_contrast_value = (short)v; }
3440  int GetColorMarkerContrastForcedLockValue () const { return m_forced.color_marker_contrast_value; }
3441 
3442 
3447  void SetColorVertexContrastForcedLockMask (int m) { m_forced.color_vertex_contrast_mask = (short)m; }
3452  int GetColorVertexContrastForcedLockMask () const { return m_forced.color_vertex_contrast_mask; }
3453 
3458  void SetColorVertexContrastForcedLockValue (int v) { m_forced.color_vertex_contrast_value = (short)v; }
3463  int GetColorVertexContrastForcedLockValue () const { return m_forced.color_vertex_contrast_value; }
3464 
3465 
3470  void SetColorTextContrastForcedLockMask (int m) { m_forced.color_text_contrast_mask = (short)m; }
3475  int GetColorTextContrastForcedLockMask () const { return m_forced.color_text_contrast_mask; }
3476 
3481  void SetColorTextContrastForcedLockValue (int v) { m_forced.color_text_contrast_value = (short)v; }
3486  int GetColorTextContrastForcedLockValue () const { return m_forced.color_text_contrast_value; }
3487 
3488 
3489 
3490 
3492  void SetBufferOptionsMask (int v) { m_buffer_options_mask = (unsigned char)v; }
3494  int GetBufferOptionsMask () const { return m_buffer_options_mask; }
3496  void SetBufferOptionsValue (int v) { m_buffer_options_value = (unsigned char) v; }
3498  int GetBufferOptionsValue () const { return m_buffer_options_value; }
3500  void SetBufferSizeLimit (int l) { m_buffer_size_limit = l; }
3502  int GetBufferSizeLimit () const { return m_buffer_size_limit; }
3503 
3504 
3506  void SetStereoSeparation (float s) { m_stereo_separation = s; }
3508  float GetStereoSeparation () const { return m_stereo_separation; }
3510  void SetStereoDistance (float d) { m_stereo_distance = d; }
3512  float GetStereoDistance () const { return m_stereo_distance; }
3513 
3514 
3516  void SetHlrOptions (int o) {
3517  m_hlr_options = o;
3518  if ((o & TKO_Hidden_Line_Extended_Mask) != 0) {
3519  m_hlr_options |= TKO_Hidden_Line_Extended;
3520  if ((o & TKO_Hidden_Line_Extended2_Mask) != 0)
3521  m_hlr_options |= TKO_Hidden_Line_Extended2;
3522  }
3523  }
3525  int GetHlrOptions () const { return m_hlr_options; }
3527  void SetHlrDimFactor (float d) { m_hlr_dim_factor = d; }
3529  float GetHlrDimFactor () const { return m_hlr_dim_factor; }
3531  void SetHlrFaceDisplacement (float d) { m_hlr_face_displacement = d; }
3533  float GetHlrFaceDisplacement () const { return m_hlr_face_displacement; }
3535  void SetHlrLinePattern (int p) { m_hlr_line_pattern = p; }
3537  int GetHlrLinePattern () const { return m_hlr_line_pattern; }
3539  void SetHlrFaceSortingAlgorithm (int a) { m_hlr_hsr_algorithm = (unsigned char)a; }
3541  float GetHlrFaceSortingAlgorithm () const { return m_hlr_hsr_algorithm; }
3542 
3543 
3545  void SetNURBSOptionsMask (int m) {
3546  m_nurbs_options_mask = m;
3547  if ((m & TKO_NURBS_Extended_Mask) != 0)
3548  m_nurbs_options_mask |= TKO_NURBS_Extended;
3549  }
3551  int GetNURBSOptionsMask () const { return m_nurbs_options_mask; }
3553  void SetNURBSOptionsValue (int v) { m_nurbs_options_value = v; }
3555  int GetNURBSOptionsValue () const { return m_nurbs_options_value; }
3557  void SetNURBSCurveBudget (int b) { m_curve_budget = b; }
3559  int GetNURBSCurveBudget () const { return m_curve_budget; }
3561  void SetNURBSCurveContinuedBudget (int b) { m_curve_continued_budget = b; }
3563  int GetNURBSCurveContinuedBudget () const { return m_curve_continued_budget; }
3565  void SetNURBSSurfaceBudget (int b) { m_surface_budget = b; }
3567  int GetNURBSSurfaceBudget () const { return m_surface_budget; }
3569  void SetNURBSSurfaceTrimBudget (int b) { m_surface_trim_budget = b; }
3571  int GetNURBSSurfaceTrimBudget () const { return m_surface_trim_budget; }
3572 
3573 
3575  void SetLodOptionsMask (int v) { m_lod_options_mask = v; }
3577  int GetLodOptionsMask () const { return m_lod_options_mask; }
3579  void SetLodOptionsValue (int v) { m_lod_options_value = v; }
3581  int GetLodOptionsValue () const { return m_lod_options_value; }
3583  void SetLodAlgorithm (int v) { m_lod_algorithm = (char)v; }
3585  int GetLodAlgorithm () const { return m_lod_algorithm; }
3587  void SetLodMinimumTriangleCount (int v) { m_min_triangle_count = v; }
3589  int GetLodMinimumTriangleCount () const { return m_min_triangle_count; }
3591  void SetLodNumLevels (int v) { m_num_levels = (unsigned char)v; }
3593  int GetLodNumLevels () const { return m_num_levels; }
3595  void SetLodClamp (int v) { m_clamp = (unsigned char)v; }
3597  int GetLodClamp () const { return m_clamp; }
3599  void SetLodMaxDegree (int v) { m_max_degree = v; }
3601  int GetLodMaxDegree () const { return m_max_degree; }
3603  void SetLodTolerance (float v) { m_tolerance = v; }
3605  float GetLodTolerance () const { return m_tolerance; }
3607  void SetLodFallback (int v) { m_fallback = (char)v; }
3609  int GetLodFallback () const { return m_fallback; }
3610 
3612  void SetLodBounding (float x1, float y1, float z1, float x2, float y2, float z2) {
3613  m_bounding[0] = x1; m_bounding[1] = y1; m_bounding[2] = z1;
3614  m_bounding[3] = x2; m_bounding[4] = y2; m_bounding[5] = z2;
3615  }
3617  void SetLodBounding (float const s[], float const e[]) {
3618  SetLodBounding (s[0], s[1], s[2], e[0], e[1], e[2]);
3619  }
3621  void SetLodBounding (float const p[]) { SetLodBounding (&p[0], &p[3]); }
3623  float const * GetLodBounding () const { return m_bounding; }
3624 
3626  void SetLodRatio (float r) { m_num_ratios = 1; m_ratio[0] = r; }
3628  void SetLodRatios (int c, float const r[] = 0) {
3629  m_num_ratios = (char)c;
3630  if (r != 0) {
3631  int i;
3632  for (i=0; i<c; ++i)
3633  m_ratio[i] = r[i];
3634  }
3635  }
3637  int GetLodNumRatios () const { return m_num_ratios; }
3639  float const * GetLodRatios () const { return m_ratio; }
3641  float * GetLodRatios () { return m_ratio; }
3642 
3644  void SetLodThresholdType (int v) { m_threshold_type = (char)v; }
3646  int GetLodThresholdType () const { return m_threshold_type; }
3648  void SetLodThreshold (float r) { m_num_thresholds = 1; m_threshold[0] = r; }
3650  void SetLodThresholds (int c, float const r[] = 0) {
3651  m_num_thresholds = (char)c;
3652  if (r != 0) {
3653  int i;
3654  for (i=0; i<c; ++i)
3655  m_threshold[i] = r[i];
3656  }
3657  }
3659  int GetLodNumThresholds () const { return m_num_thresholds; }
3661  float const * GetLodThresholds () const { return m_threshold; }
3663  float * GetLodThresholds () { return m_threshold; }
3664 
3666  void SetLodCutoff (float r) { m_num_cutoffs = 1; m_cutoff[0] = r; }
3668  void SetLodCutoffs (int c, float const r[] = 0) {
3669  m_num_cutoffs = (char)c;
3670  if (r != 0) {
3671  int i;
3672  for (i=0; i<c; ++i)
3673  m_cutoff[i] = r[i];
3674  }
3675  }
3677  int GetLodNumCutoffs () const { return m_num_cutoffs; }
3679  float const * GetLodCutoffs () const { return m_cutoff; }
3681  float * GetLodCutoffs () { return m_cutoff; }
3682 
3683 
3685  void SetTessellationMask (int m) { m_tessellations = (unsigned char)m; }
3687  int GetTessellationMask () const { return m_tessellations; }
3689  void SetCylinderTessellation (int n) { m_num_cylinder = (char)1; m_cylinder[0] = (char)n; }
3691  void SetCylinderTessellations (int c, char const * n = 0) {
3692  m_num_cylinder = (char)c;
3693  if (n != 0) {
3694  int i;
3695  for (i=0; i<c; ++i)
3696  m_cylinder[i] = n[i];
3697  }
3698  }
3700  int GetNumCylinderTessellations () const { return m_num_cylinder; }
3702  char const * GetCylinderTessellations () const { return m_cylinder; }
3704  char * GetCylinderTessellations () { return m_cylinder; }
3706  void SetSphereTessellation (int n) { m_num_sphere = (char)1; m_sphere[0] = (char)n; }
3708  void SetSphereTessellations (int c, char const * n = 0) {
3709  m_num_sphere = (char)c;
3710  if (n != 0) {
3711  int i;
3712  for (i=0; i<c; ++i)
3713  m_sphere[i] = n[i];
3714  }
3715  }
3717  int GetNumSphereTessellations () const { return m_num_sphere; }
3719  char const * GetSphereTessellations () const { return m_sphere; }
3721  char * GetSphereTessellations () { return m_sphere; }
3722 
3724  void SetGeometryOptionsMask (int m) { m_geometry_options = (unsigned char)m; }
3726  int GetGeometryOptionsMask () const { return m_geometry_options; }
3727 
3729  void SetHardEdgeAngle (int m) { m_dihedral = (unsigned char)m; }
3731  float GetHardEdgeAngle () const { return m_dihedral; }
3732 
3734  void SetMaskTransform (int m) { m_mask_transform = (unsigned short)m; }
3736  int GetMaskTransform () const { return (int)m_mask_transform; }
3737 
3738 
3740  void SetCutGeometry (int m) { m_cut_geometry = (unsigned char)m; }
3742  int GetCutGeometry () const { return (int)m_cut_geometry; }
3743 
3745  void SetCutGeometryLevel (int m) { m_cut_geometry_level = (unsigned char)m; }
3747  int GetCutGeometryLevel () const { return (int)m_cut_geometry_level; }
3748 
3750  void SetCutGeometryColorMatch (int m) { m_cut_geometry_match = (unsigned char)m; }
3752  int GetCutGeometryColorMatch () const { return (int)m_cut_geometry_match; }
3753 
3755  void SetCutGeometryTolerance (float m) { m_cut_geometry_tolerance = m; }
3757  float GetCutGeometryTolerance () const { return m_cut_geometry_tolerance; }
3758 
3760  void SetCutGeometryEdgeWeight (float value, int units = TKO_Generic_Size_Unspecified) {
3761  m_cut_geometry_edge_weight = (value > 0.0f) ? value : -1.0f;
3762  m_cut_geometry_edge_weight_units = (value > 0.0f) ? (unsigned char) units : (unsigned char) TKO_Generic_Size_Unspecified;
3763  }
3765  float GetCutGeometryEdgeWeight () const { return m_cut_geometry_edge_weight; }
3767  int GetCutGeometryEdgeWeightUnits () const { return m_cut_geometry_edge_weight_units; }
3768 
3770  void SetCutGeometryEdgePattern (char const * pattern);
3772  void SetCutGeometryEdgePattern (int length);
3774  char const * GetCutGeometryEdgePattern () const { return m_cut_geometry_edge_pattern; }
3776  char * GetCutGeometryEdgePattern () { return m_cut_geometry_edge_pattern; }
3777 
3778 
3780  void SetDisplayListLevel (int m) { m_display_list_level = (unsigned char)m; }
3782  int GetDisplayListLevel () const { return (int)m_display_list_level; }
3783 
3785  void SetSimpleShadow (int m) {
3786  m_simple_shadow = (unsigned short)m;
3787  if ((m & TKO_Simple_Shadow_Extended_Mask) != 0)
3788  m_simple_shadow |= TKO_Simple_Shadow_Extended;
3789  }
3791  int GetSimpleShadow () const { return (int)m_simple_shadow; }
3792 
3794  void SetSimpleShadowBlur (int m) { m_simple_shadow_blur = (unsigned char)m; }
3796  int GetSimpleShadowBlur () const { return (int)m_simple_shadow_blur; }
3797 
3799  void SetSimpleShadowResolution (int m) { m_simple_shadow_resolution = (unsigned short)m; }
3801  int GetSimpleShadowResolution () const { return (int)m_simple_shadow_resolution; }
3802 
3804  void SetSimpleShadowLight (float x, float y, float z) {
3805  m_simple_shadow_light[0] = x;
3806  m_simple_shadow_light[1] = y;
3807  m_simple_shadow_light[2] = z;
3808  }
3810  void SetSimpleShadowLight (float const l[]) { SetSimpleShadowLight (l[0], l[1], l[2]); }
3812  float const * getSimpleShadowLight () const { return m_simple_shadow_light; }
3813 
3815  void SetSimpleShadowPlane (float a, float b, float c, float d) {
3816  m_simple_shadow_plane[0] = a;
3817  m_simple_shadow_plane[1] = b;
3818  m_simple_shadow_plane[2] = c;
3819  m_simple_shadow_plane[3] = d;
3820  }
3822  void SetSimpleShadowPlane (float const p[]) { SetSimpleShadowPlane (p[0], p[1], p[2], p[3]); }
3824  float const * GetSimpleShadowPlane () const { return m_simple_shadow_plane; }
3825 
3827  void SetSimpleShadowColor (float r, float g, float b)
3828  { m_simple_shadow_color[0] = r; m_simple_shadow_color[1] = g; m_simple_shadow_color[2] = b; }
3830  void SetSimpleShadowColor (float const rgb[]) { SetSimpleShadowColor (rgb[0], rgb[1], rgb[2]); }
3832  float const * GetSimpleShadowColor () const { return m_simple_shadow_color; }
3833 
3835  void SetSimpleShadowOpacity (float o) { m_simple_shadow_opacity = o; }
3837  float GetSimpleShadowOpacity () const { return m_simple_shadow_opacity; }
3838 
3839 
3841  void SetShadowMap (int m) { m_shadow_map = (unsigned char)m; }
3843  int GetShadowMap () const { return (int)m_shadow_map; }
3844 
3846  void SetShadowMapResolution (int m) { m_shadow_map_resolution = (unsigned short)m; }
3848  int GetShadowMapResolution () const { return (int)m_shadow_map_resolution; }
3849 
3851  void SetShadowMapSamples (int m) { m_shadow_map_samples = (unsigned char)m; }
3853  int GetShadowMapSamples () const { return (int)m_shadow_map_samples; }
3854 
3855 
3857  void SetSimpleReflection (int m) { m_simple_reflection = (unsigned short)m; }
3859  int GetSimpleReflection () const { return (int)m_simple_reflection; }
3860 
3862  void SetSimpleReflectionPlane (float a, float b, float c, float d) {
3863  m_simple_reflection_plane[0] = a;
3864  m_simple_reflection_plane[1] = b;
3865  m_simple_reflection_plane[2] = c;
3866  m_simple_reflection_plane[3] = d;
3867  }
3869  void SetSimpleReflectionPlane (float const p[]) { SetSimpleReflectionPlane (p[0], p[1], p[2], p[3]); }
3871  float const * GetSimpleReflectionPlane () const { return m_simple_reflection_plane; }
3872 
3874  void SetSimpleReflectionOpacity (float o) { m_simple_reflection_opacity = o; }
3876  float GetSimpleReflectionOpacity () const { return m_simple_reflection_opacity; }
3877 
3879  void SetSimpleReflectionVisibilityMask (int m) { m_simple_reflection_visibility_mask = m; }
3881  int GetSimpleReflectionVisibilityValue () const { return m_simple_reflection_visibility_value; }
3882 
3883 
3885  void SetDepthRange (float n, float f) { m_depth_range[0] = n; m_depth_range[1] = f; }
3887  void SetDepthRange (float const l[]) { SetDepthRange (l[0], l[1]); }
3889  float const * GetDepthRange () const { return m_depth_range; }
3890 
3891 
3893  void SetScreenRange (float l, float r, float b, float t,
3894  float lo = 0, float ro = 0, float bo = 0, float to = 0)
3895  { m_screen_range[0] = l; m_screen_range[1] = r; m_screen_range[2] = b; m_screen_range[3] = t;
3896  m_screen_range[4] = lo; m_screen_range[5] = ro; m_screen_range[6] = bo; m_screen_range[7] = to; }
3898  void SetScreenRange (float const l[]) { SetScreenRange (l[0], l[1], l[2], l[3]); }
3900  void SetScreenRange (float const l[], float const o[])
3901  { SetScreenRange (l[0], l[1], l[2], l[3], o[0], o[1], o[2], o[3]); }
3903  void SetScreenRange (int n, float const l[])
3904  { if (n == 8) SetScreenRange (l[0], l[1], l[2], l[4], l[5], l[6], l[7], l[8]);
3905  else SetScreenRange (l[0], l[1], l[2], l[3]);
3906  }
3908  float const * GetScreenRange () const { return m_screen_range; }
3909 
3913  void SetAmbientUpVector (float x, float y, float z)
3914  { m_ambient_up_vector[0] = x; m_ambient_up_vector[1] = y; m_ambient_up_vector[2] = z; }
3916  void SetAmbientUpVector (float const v[]) { SetAmbientUpVector (v[0], v[1], v[2]); }
3918  float const * GetAmbientUpVector () const { return m_ambient_up_vector; }
3919 
3921  void SetImageScale (float x, float y) { m_image_scale[0] = x; m_image_scale[1] = y; }
3923  void SetImageScale (float const s[]) { SetImageScale (s[0], s[1]); }
3925  float const * GetImageScale () const { return m_image_scale; }
3926 
3927 
3929  void SetImageTintColor (float r, float g, float b)
3930  { m_image_tint_color[0] = r; m_image_tint_color[1] = g; m_image_tint_color[2] = b; }
3932  void SetImageTintColor (float const rgb[]) { SetImageTintColor (rgb[0], rgb[1], rgb[2]); }
3934  float const * GetImageTintColor () const { return m_image_tint_color; }
3935 
3937  void SetDiffuseTextureTintColor (float r, float g, float b)
3938  { m_texture_tint_color[0] = r; m_texture_tint_color[1] = g; m_texture_tint_color[2] = b; }
3940  void SetDiffuseTextureTintColor (float const rgb[]) { SetDiffuseTextureTintColor (rgb[0], rgb[1], rgb[2]); }
3942  float const * GetDiffuseTextureTintColor () const { return m_texture_tint_color; }
3943 
3945  void SetAntiAlias (int m) { m_antialias = (unsigned char)m; }
3947  int GetAntiAlias () const { return (int)m_antialias; }
3948 
3950  void SetVertexDecimation (float f) { m_vertex_decimation = f; }
3952  float GetVertexDecimation () const { return m_vertex_decimation; }
3953 };
3954 
3956 
3957 
3959 
3965 class BBINFILETK_API TK_Heuristics : public BBaseOpcodeHandler {
3966  protected:
3967  int m_mask;
3968  int m_value;
3969 
3973 
3974  unsigned char m_extras;
3977  unsigned short m_selection_bias;
3984  float m_vector[3];
3987  float m_view_volume[6];
3988 
3989  unsigned char m_ordered_weights_mask;
3990  float m_ordered_weights[TKO_Heur_Order_Count];
3991  unsigned char m_selection_level;
3992  unsigned char m_selection_sorting;
3993  unsigned char m_model_type;
3994 
3995  public:
3997  TK_Heuristics () : BBaseOpcodeHandler (TKE_Heuristics),
3998  m_mask (0), m_value (0), m_culling(0), m_selection_culling(0), m_selection_bias(0),
3999  m_pixel_threshold (0), m_maximum_extent (0), m_maximum_extent_mode(0) {}
4000  ~TK_Heuristics ();
4001 
4004  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
4005 
4006  TK_Status ReadAscii (BStreamFileToolkit & tk);
4007  TK_Status WriteAscii (BStreamFileToolkit & tk);
4008 
4010  void SetMask (int m) {
4011  m_mask = m;
4012  if ((m & TKO_Heuristic_Extended_Mask) != 0)
4013  m_mask |= TKO_Heuristic_Extended;
4014  }
4016  int GetMask () const { return m_mask; }
4017 
4019  void SetValue (int v) { m_value = v; }
4021  int GetValue () const { return m_value; }
4022 
4024  void SetRelatedSelectionLimit (int r) { m_related = r; }
4026  int GetRelatedSelectionLimit () const { return m_related; }
4027 
4029  void SetInternalSelectionLimit (int i) { m_internal_shell = m_internal_polyline = i; }
4031  int GetInternalSelectionLimit () const { return m_internal_shell; }
4032 
4034  void SetInternalShellSelectionLimit (int i) { m_internal_shell = i; }
4036  int GetInternalShellSelectionLimit () const { return m_internal_shell; }
4037 
4039  void SetInternalPolylineSelectionLimit (int i) { m_internal_polyline = i; }
4041  int GetInternalPolylineSelectionLimit () const { return m_internal_polyline; }
4042 
4044  void SetExtras (int e) { m_extras = (unsigned char)e; }
4046  int GetExtras () const { return (int)m_extras; }
4047 
4049  void SetCulling (int c) { m_culling = c; }
4051  int GetCulling () const { return (int)m_culling; }
4053  void SetSelectionCulling (int c) { m_selection_culling = (unsigned short)c; }
4055  int GetSelectionCulling () const { return (int)m_selection_culling; }
4057  void SetSelectionBias (int c) { m_selection_bias = (unsigned short)c; }
4059  int GetSelectionBias () const { return (int)m_selection_bias; }
4061  void SetPixelThreshold (int c) { m_pixel_threshold = c; }
4063  int GetPixelThreshold () const { return m_pixel_threshold; }
4065  void SetMaximumExtent (int c) { m_maximum_extent = c; }
4067  int GetMaximumExtent () const { return m_maximum_extent; }
4069  int GetMaximumExtentMode () const { return m_maximum_extent_mode; }
4071  void SetMaximumExtentMode (int c) { m_maximum_extent_mode = c; }
4073  int GetMaximumExtentLevel () const { return m_maximum_extent_level; }
4075  void SetMaximumExtentLevel (int c) { m_maximum_extent_level = (unsigned char)c; }
4077  void SetHardExtent (int c) { m_hard_extent = c; }
4079  int GetHardExtent () const { return m_hard_extent; }
4081  float const * GetVector () const { return m_vector; }
4083  void SetVector (float x, float y, float z) {
4084  m_vector[0] = x;
4085  m_vector[1] = y;
4086  m_vector[2] = z;
4087  }
4089  void SetVector (float const v[]) { SetVector(v[0], v[1], v[2]); }
4091  float GetVectorTolerance () const { return m_vector_tolerance; }
4093  void SetVectorTolerance (float tol) { m_vector_tolerance = tol; }
4094 
4095  void SetMaxDistance (float m) { m_max_distance = m; }
4097  float GetMaxDistance () const { return m_max_distance; }
4098 
4100  float const * GetViewVolume () const { return m_view_volume; }
4102  void SetViewVolume (float ax, float ay, float az, float bx, float by, float bz) {
4103  m_view_volume[0] = ax;
4104  m_view_volume[1] = ay;
4105  m_view_volume[2] = az;
4106  m_view_volume[3] = bx;
4107  m_view_volume[4] = by;
4108  m_view_volume[5] = bz;
4109  }
4111  void SetViewVolume (float const v[]) { SetViewVolume(v[0], v[1], v[2], v[3], v[4], v[5]); }
4112 
4114  void SetOrderedWeightsMask (int c) { m_ordered_weights_mask = (unsigned char)c; }
4116  int GetOrderedWeightsMask () const { return (int)m_ordered_weights_mask; }
4117 
4119  void SetOrderedWeight (int index, float weight) {
4120  m_ordered_weights[index] = weight;
4121  m_ordered_weights_mask |= 1<<index;
4122  }
4124  float GetOrderedWeight (int index) const { return m_ordered_weights[index]; }
4126  float const * GetOrderedWeights () const { return m_ordered_weights; }
4128  float * GetOrderedWeights () { return m_ordered_weights; }
4129 
4131  void SetSelectionLevel (int l) { m_selection_level = (unsigned char)l; }
4133  int GetSelectionLevel () const { return (int)m_selection_level; }
4134 
4136  void SetSelectionSorting (int s) { m_selection_sorting = (unsigned char)s; }
4138  int GetSelectionSorting () const { return (int)m_selection_sorting; }
4139 
4141  void SetForceDefer (int l) { m_force_defer = l; }
4143  int GetForceDefer () const { return m_force_defer; }
4144 
4145 };
4146 
4148 
4149 
4151 
4157 class BBINFILETK_API TK_Geometry_Options : public BBaseOpcodeHandler {
4158  protected:
4159  unsigned short m_mask;
4160  unsigned short m_value;
4161 
4163  float m_orientation[6];
4166 
4167  struct {
4168  unsigned char mask;
4169  unsigned char mode;
4170  float color[3];
4171  float alpha;
4172  float scale;
4173  } m_cut_visualization;
4174 
4175  public:
4177  TK_Geometry_Options () : BBaseOpcodeHandler (TKE_Geometry_Options),
4178  m_mask (0), m_value (0), m_orientation_count (0),
4179  m_coordinate_system_count (0), m_coordinate_systems (0) {
4180  m_cut_visualization.mask = 0;
4181  }
4182  ~TK_Geometry_Options ();
4183 
4184  void Reset ();
4185 
4188  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
4189 
4190  TK_Status ReadAscii (BStreamFileToolkit & tk);
4191  TK_Status WriteAscii (BStreamFileToolkit & tk);
4192 
4194  void SetMask (int m) { m_mask = (unsigned short)m; }
4196  int GetMask () const { return (int)m_mask; }
4197 
4199  void SetOrientation (int count, float const o[]) {
4200  if (count != 3 && count != 6)
4201  return;
4202  m_orientation_count = (unsigned char)count;
4203  while (count-- > 0)
4204  m_orientation[count] = o[count];
4205  }
4207  int GetOrientationCount () const { return (int) m_orientation_count; }
4209  float const * GetOrientation () const { return m_orientation; }
4210 
4212  void SetCoordinateSystems (int count, char const cs[]) {
4213  m_coordinate_system_count = count;
4214  m_coordinate_systems = new char [count];
4215  while (count-- > 0)
4216  m_coordinate_systems[count] = cs[count];
4217  }
4219  int GetCoordinateSystemCount () const { return m_coordinate_system_count; }
4221  char const * GetCoordinateSystems () const { return m_coordinate_systems; }
4222 
4223 
4224 
4226  void SetCutVisualizationMask (int m) { m_cut_visualization.mask = (unsigned char)m; }
4228  int GetCutVisualizationMask () const { return (int)m_cut_visualization.mask; }
4229 
4231  void SetCutVisualizationMode (int m) { m_cut_visualization.mode = (unsigned char)m; }
4233  int GetCutVisualizationMode () const { return (int)m_cut_visualization.mode; }
4234 
4236  void SetCutVisualizationColor (float const * c) {
4237  m_cut_visualization.color[0] = c[0];
4238  m_cut_visualization.color[1] = c[1];
4239  m_cut_visualization.color[2] = c[2];
4240  }
4242  float const * GetCutVisualizationColor () const { return m_cut_visualization.color; }
4243 
4245  void SetCutVisualizationAlpha (float a) { m_cut_visualization.alpha = a; }
4247  float GetCutVisualizationAlpha () const { return m_cut_visualization.alpha; }
4248 
4250  void SetCutVisualizationSCale (float s) { m_cut_visualization.scale = s; }
4252  float GetCutVisualizationScale () const { return m_cut_visualization.scale; }
4253 };
4254 
4257 
4262 class BBINFILETK_API TK_Visibility : public BBaseOpcodeHandler {
4263  protected:
4264  int m_mask;
4265  int m_value;
4266 
4267  public:
4270  : BBaseOpcodeHandler (TKE_Visibility), m_mask (0), m_value (0) {}
4271 
4274  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
4275 
4276  TK_Status ReadAscii (BStreamFileToolkit & tk);
4277  TK_Status WriteAscii (BStreamFileToolkit & tk);
4278 
4282  void SetGeometry (int m) {
4283  m_mask = m & TKO_Geo_All_Visibles;
4284  if ((m & TKO_Geo_Extended_Mask) != 0) {
4285  m_mask |= TKO_Geo_Extended;
4286  if ((m & TKO_Geo_Extended2_Mask) != 0)
4287  m_mask |= TKO_Geo_Extended2;
4288  }
4289  }
4294  int GetGeometry () const { return m_mask; }
4295 
4300  void SetValue (int m) { m_value = m; }
4305  int GetValue () const { return m_value; }
4306 };
4307 
4310 
4317 class BBINFILETK_API TK_Selectability : public BBaseOpcodeHandler {
4318  protected:
4319  int m_mask;
4320  int m_down;
4321  int m_up;
4325 
4326  public:
4329  : BBaseOpcodeHandler (TKE_Selectability),
4330  m_mask (0), m_down (0), m_up (0), m_move_down (0), m_move_up (0), m_invisible (0) {}
4331 
4334  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
4335 
4336  TK_Status ReadAscii (BStreamFileToolkit & tk);
4337  TK_Status WriteAscii (BStreamFileToolkit & tk);
4338 
4342  void SetGeometry (int m) {
4343  m_mask = m & TKO_Geo_All_Selects;
4344  if ((m & TKO_Geo_Extended_Mask) != 0)
4345  m_mask |= TKO_Geo_Extended;
4346  }
4351  int GetGeometry () const { return m_mask; }
4352 
4357  void SetDown (int m) { m_down = m; }
4362  int GetDown () const { return m_down; }
4363 
4368  void SetUp (int m) { m_up = m; }
4373  int GetUp () const { return m_up; }
4374 
4379  void SetMoveDown (int m) { m_move_down = m; }
4384  int GetMoveDown () const { return m_move_down; }
4385 
4390  void SetMoveUp (int m) { m_move_up = m; }
4395  int GetMoveUp () const { return m_move_up; }
4396 
4401  void SetWhenInvisible (int m) { m_invisible = m; }
4406  int GetWhenInvisible () const { return m_invisible; }
4407 };
4408 
4410 
4416 class BBINFILETK_API TK_Matrix : public BBaseOpcodeHandler {
4417  protected:
4418  float m_matrix[16];
4419  double m_dmatrix[16];
4420 
4421  public:
4423  TK_Matrix (unsigned char opcode)
4424  : BBaseOpcodeHandler (opcode) {}
4425 
4428  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
4429 
4430  TK_Status ReadAscii (BStreamFileToolkit & tk);
4431  TK_Status WriteAscii (BStreamFileToolkit & tk);
4432 
4434  void SetMatrix (float const m[]) {
4435  int i; for (i=0; i<16; i++) m_matrix[i] = m[i];
4436  }
4438  void SetDMatrix (double const m[]) {
4439  int i; for (i=0; i<16; i++) m_dmatrix[i] = m[i];
4440  }
4442  float const * GetMatrix () const { return m_matrix; }
4444  float * GetMatrix () { return m_matrix; }
4446  double const * GetDMatrix () const { return m_dmatrix; }
4448  double * GetDMatrix () { return m_dmatrix; }
4449 };
4450 
4451 
4457 class BBINFILETK_API TK_Enumerated : public BBaseOpcodeHandler {
4458  protected:
4459  char m_index;
4460 
4461  public:
4463  TK_Enumerated (unsigned char opcode)
4464  : BBaseOpcodeHandler (opcode), m_index (0) {}
4465 
4468  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
4469 
4470  TK_Status ReadAscii (BStreamFileToolkit & tk);
4471  TK_Status WriteAscii (BStreamFileToolkit & tk);
4472 
4473  void SetIndex (int i) { m_index = (char)i; }
4475  int GetIndex () const { return (int)m_index; }
4476 };
4477 
4478 
4484 class BBINFILETK_API TK_Size : public BBaseOpcodeHandler {
4485  protected:
4486  float m_value;
4487  unsigned char m_units;
4488 
4489  public:
4491  TK_Size (unsigned char opcode)
4492  : BBaseOpcodeHandler (opcode), m_value (0.0f), m_units (TKO_Generic_Size_Unspecified) {}
4493 
4496  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
4497 
4498  TK_Status ReadAscii (BStreamFileToolkit & tk);
4499  TK_Status WriteAscii (BStreamFileToolkit & tk);
4500 
4502  void SetSize (float value, int units = TKO_Generic_Size_Unspecified) {
4503  m_value = (value > 0.0f) ? value : 0.0f;
4504  m_units = (m_value > 0.0f) ? (unsigned char) units : (unsigned char) TKO_Generic_Size_Unspecified;
4505  }
4507  float GetSize () const { return m_value; }
4509  int GetUnits () const { return m_units; }
4510 };
4511 
4516 class BBINFILETK_API TK_Linear_Pattern : public BBaseOpcodeHandler {
4517  protected:
4518  unsigned short m_pattern;
4519 
4520  public:
4522  TK_Linear_Pattern (unsigned char opcode)
4523  : BBaseOpcodeHandler (opcode), m_pattern (0) {}
4524 
4527  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
4528 
4529  TK_Status ReadAscii (BStreamFileToolkit & tk);
4530  TK_Status WriteAscii (BStreamFileToolkit & tk);
4531 
4533  void SetPattern (int p) { m_pattern = (unsigned short)p; }
4535  int GetPattern () const { return (int)m_pattern; }
4536 };
4537 
4543 class BBINFILETK_API TK_Named : public BBaseOpcodeHandler {
4544  protected:
4546  char * m_name;
4547  int m_index;
4548 
4549  public:
4551  TK_Named (unsigned char opcode)
4552  : BBaseOpcodeHandler (opcode), m_name_length (0), m_name (0), m_index (0) {}
4553  ~TK_Named();
4554 
4557  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
4558 
4559  TK_Status ReadAscii (BStreamFileToolkit & tk);
4560  TK_Status WriteAscii (BStreamFileToolkit & tk);
4561 
4562  void Reset ();
4563 
4565  void SetName (char const * name);
4567  void SetName (int length);
4569  char const * GetName () const { return m_name; }
4571  char * GetName () { return m_name; }
4572 
4574  void SetIndex (int i) { Reset(); m_index = i; }
4576  int GetIndex () const { return (int)m_index; }
4577 };
4578 
4579 
4580 
4587 class BBINFILETK_API TK_Streaming : public BBaseOpcodeHandler {
4588  protected:
4589  bool m_flag;
4590 
4591  public:
4594 
4597  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
4598 
4599  TK_Status ReadAscii (BStreamFileToolkit & tk);
4600  TK_Status WriteAscii (BStreamFileToolkit & tk);
4601 
4602  void SetStreaming (bool s) { m_flag = s; }
4604  bool GetStreaming () const { return m_flag; }
4605 };
4606 
4609 
4615 class BBINFILETK_API TK_Conditions : public BBaseOpcodeHandler {
4616  protected:
4617  int m_length;
4618  char * m_string;
4620  public:
4622  TK_Conditions () : BBaseOpcodeHandler (TKE_Conditions), m_length (0), m_string (0) {}
4623  ~TK_Conditions();
4624 
4627  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
4628 
4629  TK_Status ReadAscii (BStreamFileToolkit & tk);
4630  TK_Status WriteAscii (BStreamFileToolkit & tk);
4631 
4632  void Reset ();
4633 
4635  void SetConditions (char const * options);
4637  void SetConditions (int length);
4639  char const * GetConditions () const { return m_string; }
4641  char * GetConditions () { return m_string; }
4643  int GetLength() { return m_length; }
4644 };
4645 
4646 
4649 
4654 class BBINFILETK_API TK_Conditional_Action : public BBaseOpcodeHandler {
4655  protected:
4656  short m_type;
4657  short m_options;
4658  int m_length;
4659  char * m_string;
4661  public:
4663  TK_Conditional_Action () : BBaseOpcodeHandler (TKE_Conditional_Action), m_length (0), m_string (0) {}
4665 
4668  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
4669 
4670  TK_Status ReadAscii (BStreamFileToolkit & tk);
4671  TK_Status WriteAscii (BStreamFileToolkit & tk);
4672 
4673  void Reset ();
4674 
4676  void SetCondition (char const * options);
4678  void SetCondition (int length);
4680  char const * GetCondition () const { return m_string; }
4682  char * GetCondition () { return m_string; }
4684  int GetLength() { return m_length; }
4685 
4687  void SetAction (int at) { m_type = (short)at; }
4689  int GetAction () const { return (int)m_type; }
4691  void SetOptions (int at) { m_options = (short)at; }
4693  int GetOptions () const { return (int)m_options; }
4694 };
4695 
4698 
4704 class BBINFILETK_API TK_User_Options : public BBaseOpcodeHandler {
4705  protected:
4706  int m_length;
4707  char * m_string;
4712  void set_options (char const * options);
4713  void set_options (int length);
4714 
4715  public:
4717  TK_User_Options () : BBaseOpcodeHandler (TKE_User_Options), m_length (0), m_string (0),
4718  m_indices (0), m_unicode (0), m_index_data(0) {}
4719  ~TK_User_Options();
4720 
4723  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
4724 
4725  TK_Status ReadAscii (BStreamFileToolkit & tk);
4726  TK_Status WriteAscii (BStreamFileToolkit & tk);
4727 
4728  void Reset ();
4729 
4731  void SetOptions (char const * options) { set_options (options); }
4733  void SetOptions (int length) { set_options (length); }
4735  char const * GetOptions () const { return m_string; }
4737  char * GetOptions () { return m_string; }
4739  int GetLength() { return m_length; }
4740 };
4741 
4744 
4750 class BBINFILETK_API TK_Unicode_Options : public BBaseOpcodeHandler {
4751  protected:
4752  int m_length;
4753  unsigned short * m_string;
4755  public:
4757  TK_Unicode_Options () : BBaseOpcodeHandler (TKE_Unicode_Options), m_length (0), m_string (0) {}
4758  ~TK_Unicode_Options();
4759 
4762  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
4763 
4764  TK_Status ReadAscii (BStreamFileToolkit & tk);
4765  TK_Status WriteAscii (BStreamFileToolkit & tk);
4766 
4767  void Reset ();
4768 
4770  void SetOptions (unsigned short const * options);
4772  void SetOptions (int length);
4774  unsigned short const * GetOptions () const { return m_string; }
4776  unsigned short * GetOptions () { return m_string; }
4778  int GetLength() { return m_length; }
4779 };
4780 
4782 
4788 class BBINFILETK_API TK_User_Index : public BBaseOpcodeHandler {
4789  protected:
4790  int m_count;
4791  int * m_indices;
4792  HLONG * m_values;
4794  void set_indices (int count, int const indices[], POINTER_SIZED_INT const values[]);
4795  void set_indices (int count);
4796 
4797  public:
4800  : BBaseOpcodeHandler (TKE_User_Index), m_count (0), m_indices (0), m_values (0), m_current_value(0) {}
4801  ~TK_User_Index();
4802 
4805  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
4806 
4807  TK_Status ReadAscii (BStreamFileToolkit & tk);
4808  TK_Status WriteAscii (BStreamFileToolkit & tk);
4809 
4810  void Reset ();
4811 
4813  void SetIndices (int count, int const indices[], POINTER_SIZED_INT const values[])
4814  { set_indices (count, indices, values); }
4816  void SetIndices (int count) { set_indices (count); }
4818  int GetCount () const { return m_count; }
4820  int const * GetIndices () const { return m_indices; }
4822  int * GetIndices () { return m_indices; }
4824  HLONG const * GetValues () const { return m_values; }
4826  HLONG * GetValues () { return m_values; }
4827 };
4828 
4830 
4836 class BBINFILETK_API TK_User_Index_Data : public BBaseOpcodeHandler {
4837 protected:
4838  int m_count;
4839  int * m_indices;
4840  void ** m_values;
4841  int * m_sizes;
4842 
4844  void set_indices (int count, int const indices[], void const * values[], int const sizes[]);
4845  void set_indices (int count);
4846  void FreeMem ();
4847 
4848 public:
4851  : BBaseOpcodeHandler (TKE_User_Index_Data), m_count (0), m_indices (0), m_values (0), m_sizes(0), m_current_value(0) {}
4852  ~TK_User_Index_Data();
4853 
4856  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
4857 
4858  void Reset ();
4859 
4861  void SetIndices (int count, int const indices[], void const * values[], int const sizes[]) {
4862  set_indices (count, indices, values, sizes);
4863  }
4864 
4866  void SetIndices (int count) { set_indices (count);}
4867 
4869  int GetCount () const { return m_count;}
4870 
4872  int const * GetIndices () const { return m_indices;}
4873 
4875  int * GetIndices () { return m_indices;}
4876 
4878  void ** const GetValues () const { return m_values;}
4879 
4881  void ** const GetValues () { return m_values;}
4882 
4884  int const * GetSizes () const { return m_sizes;}
4885 
4887  int * GetSizes () { return m_sizes;}
4888 };
4889 
4890 
4892 
4897 class BBINFILETK_API TK_User_Value : public BBaseOpcodeHandler {
4898  protected:
4899  HLONG m_value;
4900 
4901  public:
4904  : BBaseOpcodeHandler (TKE_User_Value), m_value (0) {}
4905 
4908  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
4909 
4910  TK_Status ReadAscii (BStreamFileToolkit & tk);
4911  TK_Status WriteAscii (BStreamFileToolkit & tk);
4912 
4914  void SetValue (HLONG v) { m_value = v; }
4916  HLONG GetValue () const { return m_value; }
4917 };
4918 
4919 
4921 
4926 class BBINFILETK_API2 TK_Camera : public BBaseOpcodeHandler {
4927  protected:
4931  float m_settings[14];
4933  double m_dsettings[14];
4935  float m_details[3];
4936  unsigned char m_projection;
4937  int m_length;
4938  char * m_name;
4941  void set_name (char const * name);
4942 
4943  void set_name (int length);
4944 
4945  public:
4947  TK_Camera (unsigned char opcode = TKE_Camera)
4948  : BBaseOpcodeHandler (opcode), m_length (0), m_name (0) {
4949  int i;
4950  int count = (int)(sizeof(m_settings) / sizeof(m_settings[0]));
4951  for (i = 0; i < count; i++) {
4952  m_settings[i] = 0;
4953  m_dsettings[i] = 0;
4954  }
4955  }
4956  ~TK_Camera();
4957 
4960  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
4961 
4962  TK_Status ReadAscii (BStreamFileToolkit & tk);
4963  TK_Status WriteAscii (BStreamFileToolkit & tk);
4964 
4966  void SetPosition (float x, float y, float z)
4967  { m_settings[0] = x; m_settings[1] = y; m_settings[2] = z; }
4969  void SetPosition (float const p[]) { SetPosition (p[0], p[1], p[2]); }
4971  float const * GetPosition () const { return &m_settings[0]; }
4973  void GetPosition (float p[]) const { memcpy(p, GetPosition(), 3*sizeof(float)); }
4974 
4976  void SetDPosition (double x, double y, double z)
4977  { m_dsettings[0] = x; m_dsettings[1] = y; m_dsettings[2] = z; }
4979  void SetDPosition (double const p[]) { SetDPosition (p[0], p[1], p[2]); }
4981  double const * GetDPosition () const { return &m_dsettings[0]; }
4983  void GetDPosition (double p[]) const { memcpy(p, GetDPosition(), 3*sizeof(double)); }
4984 
4986  void SetTarget (float x, float y, float z)
4987  { m_settings[3] = x; m_settings[4] = y; m_settings[5] = z; }
4989  void SetTarget (float const t[]) { SetTarget (t[0], t[1], t[2]); }
4991  float const * GetTarget () const { return &m_settings[3]; }
4993  void GetTarget (float t[]) const { memcpy(t, GetTarget(), 3*sizeof(float)); }
4994 
4996  void SetDTarget (double x, double y, double z)
4997  { m_dsettings[3] = x; m_dsettings[4] = y; m_dsettings[5] = z; }
4999  void SetDTarget (double const t[]) { SetDTarget (t[0], t[1], t[2]); }
5001  double const * GetDTarget () const { return &m_dsettings[3]; }
5003  void GetDTarget (double t[]) const { memcpy(t, GetDTarget(), 3*sizeof(double)); }
5004 
5006  void SetUpVector (float x, float y, float z)
5007  { m_settings[6] = x; m_settings[7] = y; m_settings[8] = z; }
5009  void SetUpVector (float const u[]) { SetUpVector (u[0], u[1], u[2]); }
5011  float const * GetUpVector () const { return &m_settings[6]; }
5013  void GetUpVector (float u[]) const { memcpy(u,GetUpVector(),3*sizeof(float)); }
5014 
5016  void SetDUpVector (double x, double y, double z)
5017  { m_dsettings[6] = x; m_dsettings[7] = y; m_dsettings[8] = z; }
5019  void SetDUpVector (double const u[]) { SetDUpVector (u[0], u[1], u[2]); }
5021  double const * GetDUpVector () const { return &m_dsettings[6]; }
5023  void GetDUpVector (double u[]) const { memcpy(u, GetDUpVector(), 3*sizeof(double)); }
5024 
5026  void SetField (float w, float h) { m_settings[9] = w; m_settings[10] = h; }
5028  void SetField (float const f[]) { SetField (f[0], f[1]); }
5030  float const * GetField () const { return &m_settings[9]; }
5032  void GetField (float f[]) const { memcpy(f,GetField(),2*sizeof(float)); }
5033 
5035  void SetDField (double w, double h) { m_dsettings[9] = w; m_dsettings[10] = h; }
5037  void SetDField (double const f[]) { SetDField (f[0], f[1]); }
5039  double const * GetDField () const { return &m_dsettings[9]; }
5041  void GetDField (double f[]) const { memcpy(f, GetDField(), 2*sizeof(double)); }
5042 
5043 
5045  void SetOblique (float h, float v) { m_details[0] = h; m_details[1] = v;
5046  m_projection &= ~TKO_Camera_Oblique_Mask;
5047  if (h != 0.0f) m_projection |= TKO_Camera_Oblique_Y;
5048  if (v != 0.0f) m_projection |= TKO_Camera_Oblique_Mask;
5049  }
5051  void SetOblique (float const o[]) { SetOblique (o[0], o[1]); }
5053  float const * GetOblique () const { return m_details; }
5055  void GetOblique (float o[]) const { memcpy(o, GetOblique(), 2*sizeof(float)); }
5056 
5058  void SetNearLimit (float l) { m_details[2] = l;
5059  m_projection &= ~TKO_Camera_Near_Limit;
5060  if (l != 0.0f) m_projection |= TKO_Camera_Near_Limit;
5061  }
5063  float GetNearLimit () const { return m_details[2]; }
5064 
5065 
5067  void SetProjection (int p) { m_projection = (char)p; }
5069  int GetProjection () const { return (int)m_projection; }
5070 
5071 
5073  void SetView (char const * name) { set_name (name); }
5075  void SetView (int length) { set_name (length); }
5077  char const * GetView () const { return m_name; }
5079  char * GetView () { return m_name; }
5080 };
5081 
5083 
5088 class BBINFILETK_API TK_Window : public BBaseOpcodeHandler {
5089  protected:
5090  float m_window[8];
5091  unsigned char m_options;
5092 
5093  public:
5096  : BBaseOpcodeHandler (TKE_Window), m_options (0) {}
5097 
5100  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
5101 
5102  TK_Status ReadAscii (BStreamFileToolkit & tk);
5103  TK_Status WriteAscii (BStreamFileToolkit & tk);
5104 
5106  void SetWindow (float l, float r, float b, float t,
5107  float lo = 0, float ro = 0, float bo = 0, float to = 0)
5108  { m_window[0] = l; m_window[1] = r; m_window[2] = b; m_window[3] = t;
5109  m_window[4] = lo; m_window[5] = ro; m_window[6] = bo; m_window[7] = to; }
5111  void SetWindow (float const w[]) { SetWindow (w[0], w[1], w[2], w[3]); }
5113  void SetWindow (float const w[], float const o[])
5114  { SetWindow (w[0], w[1], w[2], w[3], o[0], o[1], o[2], o[3]); }
5116  void SetWindow (int n, float const w[])
5117  { if (n == 8) SetWindow (w[0], w[1], w[2], w[4], w[5], w[6], w[7], w[8]);
5118  else SetWindow (w[0], w[1], w[2], w[3]);
5119  }
5121  float const * GetWindow () const { return m_window; }
5122 
5124  void SetOptions (int opt) { m_options = (unsigned char)opt; }
5126  int GetOptions () const { return m_options; }
5127 };
5128 
5129 
5130 
5132 
5139 class BBINFILETK_API TK_Text_Font : public BBaseOpcodeHandler {
5140  protected:
5141  int m_mask;
5142  int m_value;
5144  char * m_names;
5145  float m_size;
5146  float m_tolerance;
5147  float m_rotation;
5148  float m_slant;
5155  int m_renderers[2];
5156  int m_preferences[2];
5159  char * m_shape;
5160  char * m_style;
5162  float m_margins[4];
5163  unsigned char m_margin_units[4];
5164  unsigned char m_size_units;
5165  unsigned char m_tolerance_units;
5166  unsigned char m_space_units;
5167  unsigned char m_greeking_units;
5168  unsigned char m_greeking_mode;
5169  unsigned char m_transforms;
5170  unsigned char m_renderer_cutoff_units;
5172  unsigned char m_layout;
5173 
5174  void set_names (int length);
5175  void set_names (char const * names);
5176 
5177  public:
5180  : BBaseOpcodeHandler (TKE_Text_Font), m_names_length (0), m_names (0)
5181  , m_shape_length (0), m_style_length (0), m_shape (0), m_style (0) {}
5182  ~TK_Text_Font ();
5183 
5186  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
5187 
5188  TK_Status ReadAscii (BStreamFileToolkit & tk);
5189  TK_Status WriteAscii (BStreamFileToolkit & tk);
5190 
5191  void Reset ();
5192 
5194  void SetMask (int m) {
5195  m_mask = m;
5196  if ((m & TKO_Font_Extended2_Mask) != 0)
5197  m_mask |= TKO_Font_Extended2;
5198  if ((m & TKO_Font_Extended_Mask) != 0)
5199  m_mask |= TKO_Font_Extended;
5200  }
5202  int GetMask () const { return m_mask; }
5203 
5205  void SetValue (int v) { m_value = v; }
5207  int GetValue () const { return m_value; }
5208 
5210  void SetNames (char const * names) { set_names (names); }
5212  void SetNames (int length) { set_names (length); }
5214  char const * GetNames () const { return m_names; }
5216  char * GetNames () { return m_names; }
5217 
5219  void SetShape (char const * shape);
5221  void SetShape (int length);
5223  char const * GetShape () const { return m_shape; }
5225  char * GetShape () { return m_shape; }
5226 
5228  void SetStyle (char const * shape);
5230  void SetStyle (int length);
5232  char const * GetStyle () const { return m_style; }
5234  char * GetStyle () { return m_style; }
5235 
5237  void SetSize (float s) { m_size = s; }
5239  float GetSize () const { return m_size; }
5240 
5242  void SetSizeUnits (int u) { m_size_units = (unsigned char)u; }
5244  int GetSizeUnits () const { return (int)m_size_units; }
5245 
5247  void SetTolerance (float t) { m_tolerance = t; }
5249  float GetTolerance () const { return m_tolerance; }
5250 
5252  void SetToleranceUnits (int u) { m_tolerance_units = (unsigned char)u; }
5254  int GetToleranceUnits () const { return (int)m_tolerance_units; }
5255 
5257  void SetRotation (float r) { m_rotation = r; }
5259  float GetRotation () const { return m_rotation; }
5260 
5262  void SetSlant (float s) { m_slant = s; }
5264  float GetSlant () const { return m_slant; }
5265 
5267  void SetWidthScale (float s) { m_width_scale = s; }
5269  float GetWidthScale () const { return m_width_scale; }
5270 
5272  void SetExtraSpace (float s) { m_extra_space = s; }
5274  float GetExtraSpace () const { return m_extra_space; }
5275 
5277  void SetExtraSpaceUnits (int u) { m_space_units = (unsigned char)u; }
5279  int GetExtraSpaceUnits () const { return (int)m_space_units; }
5280 
5282  void SetLineSpacing (float s) { m_line_spacing = s; }
5284  float GetLineSpacing () const { return m_line_spacing; }
5285 
5287  void SetTransforms (int t) { m_transforms = (unsigned char)t; }
5289  int GetTransforms () const { return (int)m_transforms; }
5290 
5292  void SetGreekingLimit (float s) { m_greeking_limit = s; }
5294  float GetGreekingLimit () const { return m_greeking_limit; }
5295 
5297  void SetGreekingLimitUnits (int u) { m_greeking_units = (unsigned char)u; }
5299  int GetGreekingLimitUnits () const { return (int)m_greeking_units; }
5300 
5302  void SetGreekingMode (int m) { m_greeking_mode = (unsigned char)m; }
5304  int GetGreekingMode () const { return (int)m_greeking_mode; }
5305 
5306 
5308  void SetRenderer (int r) { m_renderers[0] = m_renderers[1] = r; }
5310  int GetRenderer () const { return m_renderers[0]; }
5311 
5313  void SetRenderers (int r1, int r2) { m_renderers[0] = r1; m_renderers[1] = r2; }
5315  int const * GetRenderers () const { return m_renderers; }
5316 
5318  void SetRendererCutoff (float s) { m_renderer_cutoff = s; }
5320  float GetRendererCutoff () const { return m_renderer_cutoff; }
5321 
5323  void SetRendererCutoffUnits (int u) { m_renderer_cutoff_units = (unsigned char)u; }
5325  int GetRendererCutoffUnits () const { return (int)m_renderer_cutoff_units; }
5326 
5327 
5329  void SetPreference (int r) { m_preferences[0] = m_preferences[1] = r; }
5331  int GetPreference () const { return m_preferences[0]; }
5332 
5334  void SetPreferences (int r1, int r2) { m_preferences[0] = r1; m_preferences[1] = r2; }
5336  int const * GetPreferences () const { return m_preferences; }
5337 
5339  void SetPreferenceCutoff (float s) { m_preference_cutoff = s; }
5341  float GetPreferenceCutoff () const { return m_preference_cutoff; }
5342 
5344  void SetPreferenceCutoffUnits (int u) { m_preference_cutoff_units = (unsigned char)u; }
5346  int GetPreferenceCutoffUnits () const { return (int)m_preference_cutoff_units; }
5347 
5349  void SetLayout (int l) {m_layout = (unsigned char)l;}
5351  int GetLayout () const {return (int)m_layout;}
5352 };
5353 
5355 
5357 
5367 
5379 class BBINFILETK_API2 TK_Bounding : public BBaseOpcodeHandler {
5380  protected:
5381  double m_dvalues[6];
5382  float m_values[6];
5383  char m_type;
5384  bool m_is_valid;
5385  public:
5387  TK_Bounding (unsigned char opcode)
5388  : BBaseOpcodeHandler (opcode) {}
5390  TK_Bounding (unsigned char opcode, float min[], float max[])
5391  : BBaseOpcodeHandler (opcode), m_type (TKO_Bounding_Type_Cuboid), m_is_valid (true) {
5392  m_values[0] = min[0]; m_values[1] = min[1]; m_values[2] = min[2];
5393  m_values[3] = max[0]; m_values[4] = max[1]; m_values[5] = max[2];
5394  }
5396  TK_Bounding (unsigned char opcode, float center[], float radius)
5397  : BBaseOpcodeHandler (opcode), m_type (TKO_Bounding_Type_Sphere), m_is_valid (true) {
5398  m_values[0] = center[0]; m_values[1] = center[1]; m_values[2] = center[2];
5399  m_values[3] = radius;
5400  }
5402  TK_Bounding (unsigned char opcode, double min[], double max[])
5403  : BBaseOpcodeHandler (opcode), m_type (TKO_Bounding_Type_Cuboid), m_is_valid (true) {
5404  m_dvalues[0] = min[0]; m_dvalues[1] = min[1]; m_dvalues[2] = min[2];
5405  m_dvalues[3] = max[0]; m_dvalues[4] = max[1]; m_dvalues[5] = max[2];
5407  }
5409  TK_Bounding (unsigned char opcode, double center[], double radius)
5410  : BBaseOpcodeHandler (opcode), m_type (TKO_Bounding_Type_Sphere), m_is_valid (true) {
5411  m_dvalues[0] = center[0]; m_dvalues[1] = center[1]; m_dvalues[2] = center[2];
5412  m_dvalues[3] = radius;
5414  }
5415 
5418  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
5419 
5420  TK_Status ReadAscii (BStreamFileToolkit & tk);
5421  TK_Status WriteAscii (BStreamFileToolkit & tk);
5422 };
5423 
5425 
5427 
5433 class BBINFILETK_API TK_Point : public BBaseOpcodeHandler {
5434  protected:
5435  float m_point[3];
5436  double m_dpoint[3];
5437  char m_options;
5438 
5439  public:
5441  TK_Point (unsigned char opcode)
5442  : BBaseOpcodeHandler (opcode) {
5443  m_point[0] = m_point[1] = m_point[2] = 0;
5444  m_dpoint[0] = m_dpoint[1] = m_dpoint[2] = 0;
5445  m_options = 0;
5446  };
5447 
5450  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
5451 
5452  TK_Status ReadAscii (BStreamFileToolkit & tk);
5453  TK_Status WriteAscii (BStreamFileToolkit & tk);
5454 
5455  void Reset(void) {
5456  m_point[0] = m_point[1] = m_point[2] = 0;
5457  m_dpoint[0] = m_dpoint[1] = m_dpoint[2] = 0;
5458  m_options = 0;
5460  };
5461 
5462 
5463 
5465  void SetPoint (float x, float y, float z) { m_point[0] = x; m_point[1] = y; m_point[2] = z; }
5467  void SetPoint (float const p[]) { SetPoint (p[0], p[1], p[2]); }
5469  float const * GetPoint () const { return m_point; }
5470 
5472  void SetDPoint (double x, double y, double z) { m_dpoint[0] = x; m_dpoint[1] = y; m_dpoint[2] = z; }
5474  void SetDPoint (double const p[]) { SetDPoint (p[0], p[1], p[2]); }
5476  double const * GetDPoint () const { return m_dpoint; }
5477 
5479  void SetOptions (int o) { m_options = (char)o; }
5481  int GetOptions () const { return (int)m_options; }
5482 
5483 };
5484 
5485 
5486 
5488 
5493 class BBINFILETK_API TK_Line : public BBaseOpcodeHandler {
5494  protected:
5496  float m_points[6];
5498  double m_dpoints[6];
5499 
5500  public:
5502  TK_Line (unsigned char opcode = TKE_Line)
5503  : BBaseOpcodeHandler (opcode) {}
5504 
5507  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
5508 
5509  TK_Status ReadAscii (BStreamFileToolkit & tk);
5510  TK_Status WriteAscii (BStreamFileToolkit & tk);
5511 
5513  void SetPoints (float x1, float y1, float z1, float x2, float y2, float z2) {
5514  m_points[0] = x1; m_points[1] = y1; m_points[2] = z1;
5515  m_points[3] = x2; m_points[4] = y2; m_points[5] = z2;
5516  }
5518  void SetPoints (float const s[], float const e[]) {
5519  SetPoints (s[0], s[1], s[2], e[0], e[1], e[2]);
5520  }
5522  void SetPoints (float const p[]) { SetPoints (&p[0], &p[3]); }
5524  float const * GetPoints () const { return m_points; }
5525 
5527  void SetDPoints (double x1, double y1, double z1, double x2, double y2, double z2) {
5528  m_dpoints[0] = x1; m_dpoints[1] = y1; m_dpoints[2] = z1;
5529  m_dpoints[3] = x2; m_dpoints[4] = y2; m_dpoints[5] = z2;
5530  }
5532  void SetDPoints (double const s[], double const e[]) {
5533  SetDPoints (s[0], s[1], s[2], e[0], e[1], e[2]);
5534  }
5536  void SetDPoints (double const p[]) { SetDPoints (&p[0], &p[3]); }
5538  double const * GetDPoints () const { return m_dpoints; }
5539 
5540 };
5541 
5542 
5543 
5545 
5552 class BBINFILETK_API TK_Polypoint : public BBaseOpcodeHandler {
5553  protected:
5554  int m_count;
5556  float * m_points;
5557  double * m_dpoints;
5560  void set_points (int count, float const points[] = 0) { SetPoints (count, points); }
5561  public:
5565  TK_Polypoint (unsigned char opcode)
5566  : BBaseOpcodeHandler (opcode), m_count (0), m_allocated (0), m_points (0), m_dpoints (0) {}
5567  ~TK_Polypoint();
5568 
5571  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
5572 
5573  TK_Status ReadAscii (BStreamFileToolkit & tk);
5574  TK_Status WriteAscii (BStreamFileToolkit & tk);
5575 
5576  void Reset ();
5577 
5580  void SetPoints (int count, float const points[] = 0);
5582  float const * GetPoints () const { return m_points; }
5584  float * GetPoints () { return m_points; }
5585 
5588  void SetDPoints (int count, double const points[] = 0);
5590  double const * GetDPoints () const { return m_dpoints; }
5592  double * GetDPoints () { return m_dpoints; }
5593 
5595  int GetCount () const { return m_count; }
5596 
5597 };
5598 
5599 
5600 
5601 
5602 #define NC_HAS_WEIGHTS 0x01
5603 #define NC_HAS_KNOTS 0x02
5604 #define NC_HAS_START 0x04
5605 #define NC_HAS_END 0x08
5606 
5607 
5613 class BBINFILETK_API TK_NURBS_Curve : public BBaseOpcodeHandler {
5614  protected:
5615  unsigned char m_optionals;
5616  unsigned char m_degree;
5621  float *m_weights;
5622  float *m_knots;
5623  float m_start;
5624  float m_end;
5626  void set_curve (int degree, int control_count, float const points[] = 0,
5628  float const weights[] = 0, float const knots[] = 0,
5629  float start = 0.0f, float end = 1.0f);
5630  public:
5631  TK_NURBS_Curve();
5632  ~TK_NURBS_Curve();
5633 
5636  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
5637 
5638  TK_Status ReadAscii (BStreamFileToolkit & tk);
5639  TK_Status WriteAscii (BStreamFileToolkit & tk);
5640 
5641  void Reset ();
5642 
5644  void SetCurve (int degree, int control_count, float const points[] = 0,
5645  float const weights[] = 0, float const knots[] = 0,
5646  float start = 0.0f, float end = 1.0f) {
5647  set_curve (degree, control_count, points, weights, knots, start, end);
5648  }
5649  void SetDCurve (int degree, int control_count, double const points[] = 0,
5650  float const weights[] = 0, float const knots[] = 0,
5651  float start = 0.0f, float end = 1.0f);
5652 
5653  float const * GetPoints () const { return m_control_points; }
5654  float * GetPoints () { return m_control_points; }
5655  double const * GetDPoints () const { return m_dcontrol_points; }
5656  double * GetDPoints () { return m_dcontrol_points; }
5658  int GetDegree () const { return m_degree; }
5659  int GetCount () const { return m_control_point_count; }
5660  float const * GetWeights () const { return m_weights; }
5661  float * GetWeights () { return m_weights; }
5662  float const * GetKnots () const { return m_knots; }
5663  float * GetKnots () { return m_knots; }
5665  void SetStart (float s) { m_start = s; }
5666  float GetStart () const { return m_start; }
5667  void SetEnd (float e) { m_end = e; }
5668  float GetEnd () const { return m_end; }
5670  void SetOptions (int o) { m_optionals = (unsigned char)o; }
5671  int GetOptions () const { return m_optionals; }
5673 };
5674 
5675 
5676 
5677 
5678 
5679 #define NS_HAS_WEIGHTS 0x01
5680 #define NS_HAS_KNOTS 0x02
5681 #define NS_HAS_TRIMS 0x04
5682 
5683 #define NS_TRIM_END 0
5684 #define NS_TRIM_POLY 1
5685 #define NS_TRIM_CURVE 2
5686 #define NS_TRIM_COLLECTION 3
5687 #define NS_TRIM_LAST_KNOWN_TYPE 3
5688 
5689 #define NS_TRIM_KEEP 0x01
5690 #define NS_TRIM_HAS_WEIGHTS 0x02
5691 #define NS_TRIM_HAS_KNOTS 0x04
5692 
5693 
5700 class BBINFILETK_API HT_NURBS_Trim : public BBaseOpcodeHandler {
5701  friend class TK_NURBS_Surface;
5702  protected:
5703  //first 5 are relevant to polys and curves
5706  unsigned char m_type;
5707  int m_count;
5708  float * m_points;
5709  //next 6 are specific to curves
5710  unsigned char m_degree;
5711  unsigned char m_options;
5712  float * m_weights;
5713  float * m_knots;
5714  float m_start_u;
5715  float m_end_u;
5719  HT_NURBS_Trim();
5720  TK_Status read_collection(BStreamFileToolkit & tk);
5721  TK_Status write_collection(BStreamFileToolkit & tk);
5724  public:
5725  ~HT_NURBS_Trim();
5726  void SetPoly (int count, float const points[] = 0);
5727  void SetCurve (int degree, int control_count, float const points[] = 0,
5728  float const weights[] = 0, float const knots[] = 0, float start_u = 0, float end_u = 1);
5729  void SetCollection ();
5730  HT_NURBS_Trim * PrependCollection();
5731  void SetOptions (int o) { m_options = (unsigned char)o; }
5732  void SetList (HT_NURBS_Trim *node) { m_list = node; }
5733  void SetNext (HT_NURBS_Trim *next) { m_next = next; }
5734  void SetStart(float start) { m_start_u = start; }
5735  void SetEnd(float end) { m_end_u = end; }
5736 
5739 
5742 
5743  TK_Status read_collection_ascii(BStreamFileToolkit & tk);
5744  TK_Status write_collection_ascii(BStreamFileToolkit & tk);
5745 
5747  HT_NURBS_Trim * GetNext (void) { return m_next; }
5748  HT_NURBS_Trim const * GetNext (void) const { return m_next; }
5750  int GetType () const { return m_type; }
5752  int GetCount () const { return m_count; }
5754  float const * GetPoints () const { return m_points; }
5756  float * GetPoints () { return m_points; }
5758  int GetDegree () const { return m_degree; }
5760  float GetStart() const { return m_start_u; }
5762  float GetEnd() const { return m_end_u; }
5764  int GetOptions () const { return m_options; }
5766  float const * GetWeights () const { return m_weights; }
5768  float * GetWeights () { return m_weights; }
5770  float const * GetKnots () const { return m_knots; }
5772  float * GetKnots () { return m_knots; }
5774  HT_NURBS_Trim const *GetList () const { return m_list; }
5776  HT_NURBS_Trim * GetList () { return m_list; }
5777 
5778 };
5779 
5781 
5786 class BBINFILETK_API TK_NURBS_Surface : public BBaseOpcodeHandler {
5787  protected:
5788  unsigned char m_optionals;
5789  unsigned char m_degree[2];
5790  int m_size[2];
5793  float * m_weights;
5794  float * m_u_knots;
5795  float * m_v_knots;
5801  public:
5802  TK_NURBS_Surface();
5803  ~TK_NURBS_Surface();
5804 
5807  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
5808 
5809  TK_Status ReadAscii (BStreamFileToolkit & tk);
5810  TK_Status WriteAscii (BStreamFileToolkit & tk);
5811 
5812  void Reset ();
5814  void SetSurface (int u_degree, int v_degree, int u_size, int v_size,
5815  float const points[] = 0, float const weights[] = 0,
5816  float const u_knots[] = 0, float const v_knots[] = 0);
5817  void SetDSurface (int u_degree, int v_degree, int u_size, int v_size,
5818  double const points[] = 0, float const weights[] = 0,
5819  float const u_knots[] = 0, float const v_knots[] = 0);
5822  float const * GetPoints () const { return m_control_points; }
5824  float * GetPoints () { return m_control_points; }
5826  double const * GetDPoints () const { return m_dcontrol_points; }
5828  double * GetDPoints () { return m_dcontrol_points; }
5829 
5831  int GetUDegree () const { return m_degree[0]; }
5833  int GetVDegree () const { return m_degree[1]; }
5835  int GetUSize () const { return m_size[0]; }
5837  int GetVSize () const { return m_size[1]; }
5839  float const * GetWeights () const { return m_weights; }
5841  float * GetWeights () { return m_weights; }
5843  float const * GetUKnots () const { return m_u_knots; }
5845  float * GetUKnots () { return m_u_knots; }
5847  float const * GetVKnots () const { return m_v_knots; }
5849  float * GetVKnots () { return m_v_knots; }
5850 
5852  void SetOptions (int o) { m_optionals = (unsigned char)o; }
5854  int GetOptions () const { return m_optionals; }
5855 
5857  HT_NURBS_Trim * NewTrim (int type = NS_TRIM_END);
5859  HT_NURBS_Trim * GetTrims () { return m_trims; }
5860 
5861 
5862 };
5863 
5865 
5870 class BBINFILETK_API TK_Area_Light : public BBaseOpcodeHandler {
5871  protected:
5872  int m_count;
5873  float * m_points;
5874  double * m_dpoints;
5875  char m_options;
5876 
5878  void set_points (int count, float const points[] = 0);
5879 
5880  public:
5883  : BBaseOpcodeHandler (TKE_Area_Light), m_count (0), m_points (0), m_dpoints (0), m_options (0) {}
5884  ~TK_Area_Light();
5885 
5888  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
5889 
5890  TK_Status ReadAscii (BStreamFileToolkit & tk);
5891  TK_Status WriteAscii (BStreamFileToolkit & tk);
5892 
5893  void Reset ();
5894 
5899  void SetPoints (int count, float const points[] = 0) { set_points (count, points); }
5901  float const * GetPoints () const { return m_points; }
5903  float * GetPoints () { return m_points; }
5904 
5909  void SetDPoints (int count, double const points[] = 0) ;
5911  double const * GetDPoints () const { return m_dpoints; }
5913  double * GetDPoints () { return m_dpoints; }
5914 
5916  int GetCount () const { return m_count; }
5917 
5919  void SetOptions (int o) { m_options = (char)o; }
5921  int GetOptions () const { return (int)m_options; }
5922 };
5923 
5924 
5926 
5931 class BBINFILETK_API TK_Spot_Light : public BBaseOpcodeHandler {
5932  protected:
5933  float m_position[3];
5934  float m_target[3];
5935  double m_dposition[3];
5936  double m_dtarget[3];
5937  float m_outer;
5938  float m_inner;
5940  char m_options;
5941 
5942  public:
5945  : BBaseOpcodeHandler (TKE_Spot_Light), m_options (0) {}
5946 
5949  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
5950 
5951  TK_Status ReadAscii (BStreamFileToolkit & tk);
5952  TK_Status WriteAscii (BStreamFileToolkit & tk);
5953 
5955  void SetPosition (float x, float y, float z)
5956  { m_position[0] = x; m_position[1] = y; m_position[2] = z; }
5958  void SetPosition (float const p[]) { SetPosition (p[0], p[1], p[2]); }
5960  float const * GetPosition () const { return m_position; }
5961 
5963  void SetDPosition (double x, double y, double z)
5964  { m_dposition[0] = x; m_dposition[1] = y; m_dposition[2] = z; }
5966  void SetDPosition (double const p[]) { SetDPosition (p[0], p[1], p[2]); }
5968  double const * GetDPosition () const { return m_dposition; }
5969 
5971  void SetTarget (float x, float y, float z)
5972  { m_target[0] = x; m_target[1] = y; m_target[2] = z; }
5974  void SetTarget (float const t[]) { SetTarget (t[0], t[1], t[2]); }
5976  float const * GetTarget () const { return m_target; }
5977 
5979  void SetDTarget (double x, double y, double z)
5980  { m_dtarget[0] = x; m_dtarget[1] = y; m_dtarget[2] = z; }
5982  void SetDTarget (double const t[]) { SetDTarget (t[0], t[1], t[2]); }
5984  double const * GetDTarget () const { return m_dtarget; }
5985 
5987  void SetOuter (float o) { m_outer = o; }
5989  float GetOuter () const { return m_outer; }
5990 
5992  void SetInner (float i) { m_inner = i; }
5994  float GetInner () const { return m_inner; }
5995 
5997  void SetConcentration (float c) { m_concentration = c; }
5999  float GetConcentration () const { return m_concentration; }
6000 
6002  void SetOptions (int o) { m_options = (char)o; }
6004  int GetOptions () const { return (int)m_options; }
6005 };
6006 
6007 
6009 
6014 class BBINFILETK_API TK_Cutting_Plane : public BBaseOpcodeHandler {
6015  protected:
6016  float * m_planes;
6017  double * m_dplanes;
6018  int m_count;
6019 
6020  public:
6023  : BBaseOpcodeHandler (TKE_Cutting_Plane), m_planes (0), m_dplanes (0), m_count (0) {}
6024  ~TK_Cutting_Plane ();
6025 
6028  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
6029 
6030  TK_Status ReadAscii (BStreamFileToolkit & tk);
6031  TK_Status WriteAscii (BStreamFileToolkit & tk);
6032 
6033  void Reset ();
6034 
6036  void SetPlanes (int count, float const p[]=0);
6038  void SetDPlanes (int count, double const p[]=0);
6039 
6041  void SetPlane (float a, float b, float c, float d)
6042  { SetPlanes(1);
6043  m_planes[0] = a; m_planes[1] = b; m_planes[2] = c; m_planes[3] = d; }
6045  void SetDPlane (double a, double b, double c, double d)
6046  { SetDPlanes(1);
6047  m_dplanes[0] = a; m_dplanes[1] = b; m_dplanes[2] = c; m_dplanes[3] = d; }
6048 
6050  void SetPlane (float const p[]) { SetPlanes (1, p); }
6052  void SetDPlane (double const p[]) { SetDPlanes (1, p); }
6053 
6055  float const * GetPlane () const { return m_planes; }
6057  double const * GetDPlane () const { return m_dplanes; }
6058 
6060  float const * GetPlanes () const { return m_planes; }
6062  double const * GetDPlanes () const { return m_dplanes; }
6063 
6065  int GetCount () const { return m_count; }
6066 };
6067 
6068 
6070 
6077 class BBINFILETK_API TK_Circle : public BBaseOpcodeHandler {
6078  protected:
6079  float m_points[9];
6080  float m_center[3];
6081  double m_dpoints[9];
6082  double m_dcenter[3];
6083  unsigned char m_flags;
6086  public:
6088  TK_Circle (unsigned char opcode)
6089  : BBaseOpcodeHandler (opcode), m_flags (0) {}
6090 
6093  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
6094 
6095  TK_Status ReadAscii (BStreamFileToolkit & tk);
6096  TK_Status WriteAscii (BStreamFileToolkit & tk);
6097 
6098  void Reset ();
6099 
6101  void SetStart (float x, float y, float z) {
6102  m_points[0] = x; m_points[1] = y; m_points[2] = z;
6103  }
6105  void SetStart (float const s[]) {
6106  SetStart (s[0], s[1], s[2]);
6107  }
6109  void SetMiddle (float x, float y, float z) {
6110  m_points[3] = x; m_points[4] = y; m_points[5] = z;
6111  }
6113  void SetMiddle (float const m[]) {
6114  SetMiddle (m[0], m[1], m[2]);
6115  }
6117  void SetEnd (float x, float y, float z) {
6118  m_points[6] = x; m_points[7] = y; m_points[8] = z;
6119  }
6121  void SetEnd (float const e[]) {
6122  SetEnd (e[0], e[1], e[2]);
6123  }
6125  void SetCenter (float x, float y, float z) {
6126  m_center[0] = x; m_center[1] = y; m_center[2] = z;
6127  m_flags = TKO_Circular_Center;
6128  }
6130  void SetCenter (float const c[]) {
6131  if (c) SetCenter (c[0], c[1], c[2]);
6132  else m_flags = 0;
6133  }
6135  void SetPoints (float const s[], float const m[], float const e[],
6136  float const c[] = 0) {
6137  SetStart (s); SetMiddle (m); SetEnd (e); SetCenter (c);
6138  }
6139 
6141  float const * GetStart () const { return &m_points[0]; }
6143  float const * GetMiddle () const { return &m_points[3]; }
6145  float const * GetEnd () const { return &m_points[6]; }
6147  float const * GetCenter () const { return (m_flags & TKO_Circular_Center) ? m_center : 0; }
6148 
6150  void SetDStart (double x, double y, double z) {
6151  m_dpoints[0] = x; m_dpoints[1] = y; m_dpoints[2] = z;
6152  }
6154  void SetDStart (double const s[]) {
6155  SetDStart (s[0], s[1], s[2]);
6156  }
6158  void SetDMiddle (double x, double y, double z) {
6159  m_dpoints[3] = x; m_dpoints[4] = y; m_dpoints[5] = z;
6160  }
6162  void SetDMiddle (double const m[]) {
6163  SetDMiddle (m[0], m[1], m[2]);
6164  }
6166  void SetDEnd (double x, double y, double z) {
6167  m_dpoints[6] = x; m_dpoints[7] = y; m_dpoints[8] = z;
6168  }
6170  void SetDEnd (double const e[]) {
6171  SetDEnd (e[0], e[1], e[2]);
6172  }
6174  void SetDCenter (double x, double y, double z) {
6175  m_dcenter[0] = x; m_dcenter[1] = y; m_dcenter[2] = z;
6176  m_flags = TKO_Circular_Center;
6177  }
6179  void SetDCenter (double const c[]) {
6180  if (c) SetDCenter (c[0], c[1], c[2]);
6181  else m_flags = 0;
6182  }
6184  void SetDPoints (double const s[], double const m[], double const e[],
6185  double const c[] = 0) {
6186  SetDStart (s); SetDMiddle (m); SetDEnd (e); SetDCenter (c);
6187  }
6188 
6190  double const * GetDStart () const { return &m_dpoints[0]; }
6192  double const * GetDMiddle () const { return &m_dpoints[3]; }
6194  double const * GetDEnd () const { return &m_dpoints[6]; }
6196  double const * GetDCenter () const { return (m_flags & TKO_Circular_Center) ? m_dcenter : 0; }
6197 };
6198 
6199 
6201 
6208 class BBINFILETK_API TK_Ellipse : public BBaseOpcodeHandler {
6209  protected:
6210  float m_points[9];
6211  double m_dpoints[9];
6212  float m_limits[2];
6214  public:
6216  TK_Ellipse (unsigned char opcode)
6217  : BBaseOpcodeHandler (opcode) {}
6218 
6221  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
6222 
6223  TK_Status ReadAscii (BStreamFileToolkit & tk);
6224  TK_Status WriteAscii (BStreamFileToolkit & tk);
6225 
6227  void SetCenter (float x, float y, float z) {
6228  m_points[0] = x; m_points[1] = y; m_points[2] = z;
6229  }
6231  void SetCenter (float const s[]) { SetCenter (s[0], s[1], s[2]); }
6233  float const * GetCenter () const { return &m_points[0]; }
6234 
6236  void SetMajor (float x, float y, float z) {
6237  m_points[3] = x; m_points[4] = y; m_points[5] = z;
6238  }
6240  void SetMajor (float const m[]) { SetMajor (m[0], m[1], m[2]); }
6242  float const * GetMajor () const { return &m_points[3]; }
6243 
6245  void SetMinor (float x, float y, float z) {
6246  m_points[6] = x; m_points[7] = y; m_points[8] = z;
6247  }
6249  void SetMinor (float const m[]) { SetMinor (m[0], m[1], m[2]); }
6251  float const * GetMinor () const { return &m_points[6]; }
6252 
6253 
6255  void SetDCenter (double x, double y, double z) {
6256  m_dpoints[0] = x; m_dpoints[1] = y; m_dpoints[2] = z;
6257  }
6259  void SetDCenter (double const s[]) { SetDCenter (s[0], s[1], s[2]);}
6261  double const * GetDCenter () const { return &m_dpoints[0]; }
6262 
6264  void SetDMajor (double x, double y, double z) {
6265  m_dpoints[3] = x; m_dpoints[4] = y; m_dpoints[5] = z;
6266  }
6268  void SetDMajor (double const m[]) { SetDMajor (m[0], m[1], m[2]); }
6270  double const * GetDMajor () const { return &m_dpoints[3]; }
6271 
6273  void SetDMinor (double x, double y, double z) {
6274  m_dpoints[6] = x; m_dpoints[7] = y; m_dpoints[8] = z;
6275  }
6277  void SetDMinor (double const m[]) { SetDMinor (m[0], m[1], m[2]); }
6279  double const * GetDMinor () const { return &m_dpoints[6]; }
6280 
6282  void SetLimits (float s, float e) {
6283  m_limits[0] = s; m_limits[1] = e;
6284  }
6286  float const * GetLimits () const { return m_limits; }
6287 };
6288 
6289 
6291 
6298 class BBINFILETK_API TK_Sphere : public BBaseOpcodeHandler {
6299  protected:
6300  unsigned char m_flags;
6301  float m_center[3];
6302  float m_radius;
6303  float m_axis[3];
6304  float m_ortho[3];
6305  double m_dcenter[3];
6306  double m_dradius;
6307  double m_daxis[3];
6308  double m_dortho[3];
6310  public:
6313  : BBaseOpcodeHandler (TKE_Sphere) { Reset(); }
6314 
6317  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
6318 
6319  TK_Status ReadAscii (BStreamFileToolkit & tk);
6320  TK_Status WriteAscii (BStreamFileToolkit & tk);
6321 
6322  void Reset ();
6323 
6325  void SetCenter (float x, float y, float z) {
6326  m_center[0] = x; m_center[1] = y; m_center[2] = z;
6327  }
6329  void SetCenter (float const s[]) { SetCenter (s[0], s[1], s[2]); }
6331  float const * GetCenter () const { return m_center; }
6332 
6333 
6335  void SetRadius (float r) { m_radius = r; }
6337  float GetRadius () const { return m_radius; }
6338 
6340  void SetAxis (float x, float y, float z) {
6341  m_axis[0] = x; m_axis[1] = y; m_axis[2] = z;
6342  if (x != 0.0f || y != 1.0f || z != 0.0f)
6343  m_flags &= ~TKSPH_NULL_AXIS;
6344  }
6346  void SetAxis (float const s[]) { SetAxis (s[0], s[1], s[2]); }
6348  float const * GetAxis () const { return m_axis; }
6349 
6351  void SetOrtho (float x, float y, float z) {
6352  m_ortho[0] = x; m_ortho[1] = y; m_ortho[2] = z;
6353  if (x != 1.0f || y != 0.0f || z != 0.0f)
6354  m_flags &= ~TKSPH_NULL_AXIS;
6355  }
6357  void SetOrtho (float const s[]) { SetOrtho (s[0], s[1], s[2]); }
6359  float const * GetOrtho () const { return m_ortho; }
6360 
6361 
6363  void SetDCenter (double x, double y, double z) {
6364  m_dcenter[0] = x; m_dcenter[1] = y; m_dcenter[2] = z;
6365  }
6367  void SetDCenter (double const s[]) { SetDCenter (s[0], s[1], s[2]);}
6369  double const * GetDCenter () const { return m_dcenter; }
6370 
6371 
6373  void SetDRadius (double r) { m_dradius = r; }
6375  double GetDRadius () const { return m_dradius; }
6376 
6378  void SetDAxis (double x, double y, double z) {
6379  m_daxis[0] = x; m_daxis[1] = y; m_daxis[2] = z;
6380  if (x != 0.0f || y != 1.0f || z != 0.0f)
6381  m_flags &= ~TKSPH_NULL_AXIS;
6382  }
6384  void SetDAxis (double const s[]) { SetDAxis (s[0], s[1], s[2]); }
6386  double const * GetDAxis () const { return m_daxis; }
6387 
6389  void SetDOrtho (double x, double y, double z) {
6390  m_dortho[0] = x; m_dortho[1] = y; m_dortho[2] = z;
6391  if (x != 1.0f || y != 0.0f || z != 0.0f)
6392  m_flags &= ~TKSPH_NULL_AXIS;
6393  }
6395  void SetDOrtho (double const s[]) { SetDOrtho (s[0], s[1], s[2]); }
6397  double const * GetDOrtho () const { return m_dortho; }
6398 
6399 
6403  enum Flags {
6404  TKSPH_NONE = 0x0,
6405  TKSPH_NULL_AXIS = 0x1
6406  };
6407 
6408 };
6409 
6410 
6412 
6419 class BBINFILETK_API TK_Cylinder : public BBaseOpcodeHandler {
6420  protected:
6421  float m_axis[6];
6422  float m_radius;
6423  double m_daxis[6];
6424  double m_dradius;
6425  unsigned char m_flags;
6427  public:
6430  : BBaseOpcodeHandler (TKE_Cylinder) {}
6431 
6434  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
6435 
6436  TK_Status ReadAscii (BStreamFileToolkit & tk);
6437  TK_Status WriteAscii (BStreamFileToolkit & tk);
6438 
6440  void SetAxis (float x1, float y1, float z1, float x2, float y2, float z2) {
6441  m_axis[0] = x1; m_axis[1] = y1; m_axis[2] = z1;
6442  m_axis[3] = x2; m_axis[4] = y2; m_axis[5] = z2;
6443  }
6445  void SetAxis (float const s[], float const e[]) { SetAxis (s[0], s[1], s[2], e[0], e[1], e[2]); }
6447  void SetAxis (float const a[]) { SetAxis (&a[0], &a[3]); }
6449  float const * GetAxis () const { return m_axis; }
6451  float const * GetStart () const { return &m_axis[0]; }
6453  float const * GetEnd () const { return &m_axis[3]; }
6454 
6456  void SetRadius (float r) { m_radius = r; }
6458  float GetRadius () const { return m_radius; }
6459 
6460 
6462  void SetDAxis (double x1, double y1, double z1, double x2, double y2, double z2) {
6463  m_daxis[0] = x1; m_daxis[1] = y1; m_daxis[2] = z1;
6464  m_daxis[3] = x2; m_daxis[4] = y2; m_daxis[5] = z2;
6465  }
6467  void SetDAxis (double const s[], double const e[]) { SetDAxis (s[0], s[1], s[2], e[0], e[1], e[2]); }
6469  void SetDAxis (double const a[]) { SetDAxis (&a[0], &a[3]); }
6471  double const * GetDAxis () const { return m_daxis; }
6473  double const * GetDStart () const { return &m_daxis[0]; }
6475  double const * GetDEnd () const { return &m_daxis[3]; }
6476 
6478  void SetDRadius (double r) { m_dradius = r; }
6480  double GetDRadius () const { return m_dradius; }
6481 
6482 
6484  void SetCaps (int f) { m_flags = (unsigned char)f; }
6486  int GetCaps () const { return m_flags; }
6487 
6492  TKCYL_NONE = 0,
6493  TKCYL_FIRST = 1,
6494  TKCYL_SECOND = 2,
6495  TKCYL_BOTH = 3
6496  };
6497 
6498 };
6499 
6500 
6502 
6509 #include "BPolyhedron.h"
6510 
6511 class BBINFILETK_API TK_PolyCylinder : public TK_Polyhedron {
6512  protected:
6513  int m_count;
6514  float * m_points;
6515  double * m_dpoints;
6517  float * m_radii;
6518  double * m_dradii;
6519  unsigned char m_flags;
6520  float m_normals[6];
6522  public:
6525  : TK_Polyhedron (TKE_PolyCylinder), m_count (0), m_points (0), m_dpoints (0),
6526  m_radius_count (0), m_radii (0), m_dradii (0) {}
6527  ~TK_PolyCylinder();
6528 
6531  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
6532 
6533  TK_Status ReadAscii (BStreamFileToolkit & tk);
6534  TK_Status WriteAscii (BStreamFileToolkit & tk);
6535 
6536  virtual void Reset ();
6537 
6542  TKCYL_NORMAL_FIRST = 0x04,
6543  TKCYL_NORMAL_SECOND = 0x08,
6544  TKCYL_OPTIONALS = 0x10
6545  };
6546 
6551  void SetPoints (int count, float const points[] = 0);
6553  float const * GetPoints () const { return m_points; }
6555  float * GetPoints () { return m_points; }
6556 
6561  void SetRadii (int count, float const radii[] = 0);
6563  void SetRadius (float radius) { SetRadii (1, &radius); }
6565  float const * GetRadii () const { return m_radii; }
6567  float * GetRadii () { return m_radii; }
6568 
6569 
6574  void SetDPoints (int count, double const points[] = 0);
6576  double const * GetDPoints () const { return m_dpoints; }
6578  double * GetDPoints () { return m_dpoints; }
6579 
6584  void SetDRadii (int count, double const radii[] = 0);
6586  void SetDRadius (double radius) { SetDRadii (1, &radius); }
6588  double const * GetDRadii () const { return m_dradii; }
6590  double * GetDRadii () { return m_dradii; }
6591 
6592 
6594  int GetCount () const { return m_count; }
6596  int GetRadiusCount () const { return m_radius_count; }
6597 
6598 
6599 
6600 
6602  void SetCaps (int f) { m_flags &= ~0x03; m_flags |= f; }
6604  int GetCaps () const { return m_flags & 0x03; }
6605 
6607  void SetEndNormal (int index, float const normal[] = 0) {
6608  int mask = 0x40 << index;
6609  if (normal == 0)
6610  m_flags &= ~mask;
6611  else {
6612  m_flags |= mask;
6613  m_normals[3*index+0] = normal[0];
6614  m_normals[3*index+1] = normal[1];
6615  m_normals[3*index+2] = normal[2];
6616  }
6617  }
6619  float const * GetEndNormal (int index) const {
6620  int mask = 0x40 << index;
6621  if (m_flags & mask)
6622  return &m_normals[3*index];
6623  else
6624  return 0;
6625  }
6626 };
6627 
6628 
6630 
6636 class BBINFILETK_API TK_Grid : public BBaseOpcodeHandler {
6637  protected:
6638  char m_type;
6639  float m_points[9];
6640  double m_dpoints[9];
6641  int m_counts[2];
6643  public:
6646  : BBaseOpcodeHandler (TKE_Grid) {}
6647 
6650  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
6651 
6652  TK_Status ReadAscii (BStreamFileToolkit & tk);
6653  TK_Status WriteAscii (BStreamFileToolkit & tk);
6654 
6656  void SetOrigin (float x, float y, float z) {
6657  m_points[0] = x; m_points[1] = y; m_points[2] = z;
6658  }
6660  void SetOrigin (float const o[]) { SetOrigin (o[0], o[1], o[2]); }
6662  float const * GetOrigin () const { return &m_points[0]; }
6664  float * GetOrigin () { return &m_points[0]; }
6665 
6667  void SetRef1 (float x, float y, float z) {
6668  m_points[3] = x; m_points[4] = y; m_points[5] = z;
6669  }
6671  void SetRef1 (float const r[]) { SetRef1 (r[0], r[1], r[2]); }
6673  float const * GetRef1 () const { return &m_points[3]; }
6675  float * GetRef1 () { return &m_points[3]; }
6676 
6678  void SetRef2 (float x, float y, float z) {
6679  m_points[6] = x; m_points[7] = y; m_points[8] = z;
6680  }
6682  void SetRef2 (float const r[]) { SetRef2 (r[0], r[1], r[2]); }
6684  float const * GetRef2 () const { return &m_points[6]; }
6686  float * GetRef2 () { return &m_points[6]; }
6687 
6688 
6690  void SetDOrigin (double x, double y, double z) {
6691  m_dpoints[0] = x; m_dpoints[1] = y; m_dpoints[2] = z;
6692  }
6694  void SetDOrigin (double const o[]) { SetDOrigin (o[0], o[1], o[2]);}
6696  double const * GetDOrigin () const { return &m_dpoints[0]; }
6698  double * GetDOrigin () { return &m_dpoints[0]; }
6699 
6701  void SetDRef1 (double x, double y, double z) {
6702  m_dpoints[3] = x; m_dpoints[4] = y; m_dpoints[5] = z;
6703  }
6705  void SetDRef1 (double const r[]) { SetDRef1 (r[0], r[1], r[2]); }
6707  double const * GetDRef1 () const { return &m_dpoints[3]; }
6709  double * GetDRef1 () { return &m_dpoints[3]; }
6710 
6712  void SetDRef2 (double x, double y, double z) {
6713  m_dpoints[6] = x; m_dpoints[7] = y; m_dpoints[8] = z;
6714  }
6716  void SetDRef2 (double const r[]) { SetDRef2 (r[0], r[1], r[2]); }
6718  double const * GetDRef2 () const { return &m_dpoints[6]; }
6720  double * GetDRef2 () { return &m_dpoints[6]; }
6721 
6722 
6724  void SetCounts (int c1, int c2) {
6725  m_counts[0] = c1; m_counts[1] = c2;
6726  }
6728  int const * GetCounts () const { return m_counts; }
6730  int * GetCounts () { return m_counts; }
6731 
6733  void SetType (int t) { m_type = (char)t; }
6735  int GetType () const { return (int)m_type; }
6736 };
6737 
6739 
6742  char * name;
6743 
6744  float color[3];
6745  float size;
6748  float slant;
6749  float rotation;
6750  float width_scale;
6751 
6752  unsigned short mask;
6753  unsigned short value;
6754 
6755  unsigned char size_units;
6756  unsigned char vertical_offset_units;
6757  unsigned char horizontal_offset_units;
6758 };
6759 
6760 
6762 
6768 class BBINFILETK_API TK_Text : public BBaseOpcodeHandler {
6769  protected:
6770  float m_position[3];
6771  double m_dposition[3];
6772  int m_length;
6774  char * m_string;
6775  unsigned char m_encoding;
6776  unsigned char m_options;
6777  unsigned char m_region_options;
6778  unsigned char m_region_fit;
6779  unsigned char m_region_count;
6780  float m_region[4*3];
6781  double m_dregion[4*3];
6783  int * m_cursors;
6785  float * m_leaders;
6786  unsigned char * m_leader_flags;
6788  double * m_dleaders;
6789  unsigned char * m_dleader_flags;
6790  int m_count;
6793  int m_tmp;
6795  void set_string (char const * string);
6796  void set_string (int length);
6797 
6798  public:
6800  TK_Text (unsigned char opcode);
6801  ~TK_Text();
6802 
6805  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
6806 
6807  TK_Status ReadAscii (BStreamFileToolkit & tk);
6808  TK_Status WriteAscii (BStreamFileToolkit & tk);
6809 
6810  void Reset ();
6811 
6813  void SetString (char const * string) { set_string (string); }
6815  void SetString (unsigned short const * string);
6817  void SetString (unsigned int const * string);
6819  void SetString (int length) { set_string (length); }
6821  char const * GetString () const { return m_string; }
6823  char * GetString () { return m_string; }
6824 
6826  void SetPosition (float x, float y, float z)
6827  { m_position[0] = x; m_position[1] = y; m_position[2] = z; }
6829  void SetPosition (float const p[]) { SetPosition (p[0], p[1], p[2]); }
6831  float const * GetPosition () const { return &m_position[0]; }
6832 
6834  void SetDPosition (double x, double y, double z)
6835  { m_dposition[0] = x; m_dposition[1] = y; m_dposition[2] = z; }
6837  void SetDPosition (double const p[]) { SetDPosition (p[0], p[1], p[2]); }
6839  double const * GetDPosition () const { return &m_dposition[0]; }
6840 
6842  void SetEncoding (int e) { m_encoding = (unsigned char)e; }
6844  int GetEncoding () const { return (int)m_encoding; }
6845 
6847  void SetTextRegion (int c, float const p[], int o=0, int f=0);
6849  void SetTextDRegion (int c, double const p[], int o=0, int f=0);
6851  int GetTextRegionCount () const { return (int)m_region_count; }
6853  float const * GetTextRegionPoints () const { return m_region; }
6855  double const * GetTextRegionDPoints () const { return m_dregion; }
6857  int GetTextRegionOptions () const { return (int)m_region_options; }
6859  int GetTextRegionFitting () const { return (int)m_region_fit; }
6860 
6861 
6863  void SetStringCursors (int length, int * locations = 0);
6865  int GetStringCursorCount () const { return m_cursor_count; }
6867  int const * GetStringCursors () const { return m_cursors; }
6869  int * GetStringCursors () { return m_cursors; }
6870 
6872  void SetTextLeaders (int length, float * locations = 0, unsigned char * flags = 0);
6874  int GetTextLeaderCount () const { return m_leader_count; }
6876  float const * GetTextLeaders () const { return m_leaders; }
6878  float * GetTextLeaders () { return m_leaders; }
6880  unsigned char const * GetTextLeaderFlags () const { return m_leader_flags; }
6882  unsigned char * GetTextLeaderFlags () { return m_leader_flags; }
6883 
6885  void SetDTextLeaders (int length, double * locations = 0, unsigned char * flags = 0);
6887  int GetDTextLeaderCount () const { return m_dleader_count; }
6889  double const * GetDTextLeaders () const { return m_dleaders; }
6891  double * GetDTextLeaders () { return m_dleaders; }
6893  unsigned char const * GetDTextLeaderFlags () const { return m_dleader_flags; }
6895  unsigned char * GetDTextLeaderFlags () { return m_dleader_flags; }
6896 };
6897 
6899 
6901 
6907 class BBINFILETK_API TK_Font : public BBaseOpcodeHandler {
6908  protected:
6909  char * m_name;
6910  char * m_lookup;
6911  char * m_bytes;
6914  int m_length;
6915  unsigned char m_type;
6916  unsigned char m_encoding;
6918  void set_bytes (int size, char const * bytes = 0);
6921  void set_name (char const * string);
6923  void set_name (int length);
6925  void set_lookup (char const * string);
6927  void set_lookup (int length);
6928 
6929  public:
6931  TK_Font () : BBaseOpcodeHandler (TKE_Font),
6932  m_name (0), m_lookup (0), m_bytes (0), m_name_length (0), m_lookup_length (0), m_length (0),
6933  m_type (0), m_encoding (0) {}
6934  ~TK_Font();
6935 
6938  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
6939 
6940  TK_Status ReadAscii (BStreamFileToolkit & tk);
6941  TK_Status WriteAscii (BStreamFileToolkit & tk);
6942 
6943  void Reset ();
6944 
6945 
6947  void SetType (int t) { m_type = (unsigned char)t;}
6949  int GetType () const { return (int)m_type; }
6950 
6955  void SetBytes (int size, char const * bytes = 0) { set_bytes (size, bytes); }
6957  int GetBytesCount () const { return m_length; }
6959  char const * GetBytes () const { return m_bytes; }
6961  char * GetBytes () { return m_bytes; }
6962 
6964  void SetName (char const * string) { set_name (string); }
6966  void SetName (int length) { set_name (length); }
6968  char const * GetName () const { return m_name; }
6970  char * GetName () { return m_name; }
6971 
6973  void SetLookup (char const * string) { set_lookup (string); }
6975  void SetLookup (int length) { set_lookup (length); }
6977  char const * GetLookup () const { return m_lookup; }
6979  char * GetLookup () { return m_lookup; }
6980 
6982  void SetEncoding (int e) { m_encoding = (unsigned char)e;}
6984  int GetEncoding () const { return (int)m_encoding; }
6985 };
6986 
6988 
6989 
6991 extern const int TK_Image_Bytes_Per_Pixel[];
6992 
6993 #ifndef DOXYGEN_SHOULD_SKIP_THIS
6994 
6995 class BBINFILETK_API2 TK_Image_Data_Buffer {
6996  protected:
6997  unsigned char * m_buffer;
6998  unsigned int m_allocated;
6999  unsigned int m_used;
7000 
7001  public:
7003  TK_Image_Data_Buffer() : m_buffer (0), m_allocated (0), m_used (0) {}
7004  ~TK_Image_Data_Buffer();
7005 
7006  void Resize (unsigned int size);
7007  void Expand (unsigned int size) { Resize (Size() + size); }
7008  void Reset ();
7009 
7010  unsigned int const & Size () const { return m_allocated; }
7011  unsigned int const & Used () const { return m_used; }
7012  unsigned int & Used () { return m_used; }
7013  unsigned char const * Buffer () const { return m_buffer; }
7014  unsigned char * Buffer () { return m_buffer; }
7015 };
7016 
7017 
7018 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
7019 
7020 
7022 
7028 class BBINFILETK_API2 TK_Image : public BBaseOpcodeHandler {
7029  protected:
7030  char * m_bytes;
7031  char * m_name;
7032  char * m_reference;
7033  float m_position[3];
7034  double m_dposition[3];
7035  int m_size[2];
7039  unsigned char m_format;
7040  unsigned int m_options;
7041  unsigned char m_compression;
7042  unsigned char m_bytes_format;
7043  float m_explicit_size[2];
7044  unsigned char m_explicit_units[2];
7045  TK_Image_Data_Buffer m_work_area[2];
7050  void set_data (int size, char const * bytes = 0, unsigned char data_format = TKO_Compression_None);
7053  void set_name (char const * string);
7055  void set_name (int length);
7056 
7058  TK_Status compress_image (BStreamFileToolkit & tk, int active_work_area = 0);
7060  TK_Status decompress_image (BStreamFileToolkit & tk, int active_work_area = 0);
7062  TK_Status read_jpeg_header ();
7063 
7064  public:
7066  TK_Image ();
7067  ~TK_Image();
7068 
7071  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
7072 
7073  TK_Status ReadAscii (BStreamFileToolkit & tk);
7074  TK_Status WriteAscii (BStreamFileToolkit & tk);
7075  TK_Status compress_image_ascii (BStreamFileToolkit & tk);
7076 
7077 
7078  void Reset ();
7079 
7084  void SetBytes (int size, char const * bytes = 0,
7085  unsigned char data_format = TKO_Compression_None)
7086  { set_data (size, bytes, data_format); }
7088  char const * GetBytes () const { return m_bytes; }
7090  char * GetBytes () { return m_bytes; }
7091 
7093  void SetName (char const * string) { set_name (string); }
7095  void SetName (int length) { set_name (length); }
7097  char const * GetName () const { return m_name; }
7099  char * GetName () { return m_name; }
7100 
7102  void SetReference (char const * string);
7104  void SetReference (int length);
7106  char const * GetReference () const { return m_reference; }
7108  char * GetReference () { return m_reference; }
7109 
7111  void SetPosition (float x, float y, float z)
7112  { m_position[0] = x; m_position[1] = y; m_position[2] = z; }
7114  void SetPosition (float const p[]) { SetPosition (p[0], p[1], p[2]); }
7116  float const * GetPosition () const { return &m_position[0]; }
7117 
7119  void SetDPosition (double x, double y, double z)
7120  { m_dposition[0] = x; m_dposition[1] = y; m_dposition[2] = z; }
7122  void SetDPosition (double const p[]) { SetDPosition (p[0], p[1], p[2]); }
7124  double const * GetDPosition () const { return &m_dposition[0]; }
7125 
7127  void SetSize (int w, int h) { m_size[0] = w; m_size[1] = h; }
7129  void SetSize (int const s[]) { m_size[0] = s[0]; m_size[1] = s[1]; }
7131  int const * GetSize () const { return m_size; }
7132 
7134  void SetFormat (int f) { m_format = (unsigned char)(f & TKO_Image_Format_Mask); }
7136  int GetFormat () const { return (int)m_format; }
7137 
7139  void SetOptions (int f) { m_options = (unsigned char)(f & TKO_Image_Options_Mask); }
7141  int GetOptions () const { return (int)m_options; }
7142 
7144  void SetCompression (int c) { m_compression = (unsigned char)c; }
7146  int GetCompression () const { return (int)m_compression; }
7147 };
7148 
7149 
7151 
7153 
7159 class BBINFILETK_API2 TK_Texture : public BBaseOpcodeHandler {
7160  protected:
7161  char * m_name;
7163  char * m_image;
7164  char * m_camera;
7169  int m_flags;
7180  char m_layout;
7181  char m_tiling;
7182  float m_value_scale[2];
7183  int m_source_dimensions[3];
7184  char * m_transform;
7188  void set_name (int length);
7189  void set_name (char const * name);
7190  void set_image (int length);
7191  void set_image (char const * image);
7192  void set_transform (int length);
7193  void set_transform (char const * transform);
7194 
7195  public:
7197  TK_Texture () : BBaseOpcodeHandler (TKE_Texture),
7198  m_name (0), m_shader_source(0), m_image (0), m_camera (0),
7199  m_name_length (0), m_shader_source_length(0), m_image_length (0), m_camera_length (0),
7200  m_transform (0) {
7201  Reset();
7202  }
7203  ~TK_Texture();
7204 
7207  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
7208 
7209  TK_Status ReadAscii (BStreamFileToolkit & tk);
7210  TK_Status WriteAscii (BStreamFileToolkit & tk);
7211 
7212  void Reset ();
7213 
7215  void SetName (char const * name) { set_name (name); }
7217  void SetName (int length) { set_name (length); }
7219  char const * GetName () const { return m_name; }
7221  char * GetName () { return m_name; }
7222 
7224  void SetShaderSource (char const * shader_source);
7226  void SetShaderSource (int length);
7228  char const * GetShaderSource () const { return m_shader_source; }
7230  char * GetShaderSource () { return m_shader_source; }
7231 
7233  void SetImage (char const * image) { set_image (image); }
7235  void SetImage (int length) { set_image (length); }
7237  char const * GetImage () const { return m_image; }
7239  char * GetImage () { return m_image; }
7240 
7242  void SetCamera (char const * camera);
7244  void SetCamera (int length);
7246  char const * GetCamera () const { return m_camera; }
7248  char * GetCamera () { return m_camera; }
7249 
7251  void SetFlags (int f) {
7252  m_flags = f;
7253  if ((f & TKO_Texture_Extended_Mask) != 0)
7254  m_flags |= TKO_Texture_Extended;
7255  }
7257  int GetFlags () const { return m_flags; }
7258 
7260  void SetParameterSource (int p) { m_param_source = (char)p; }
7262  int GetParameterSource () const { return (int)m_param_source; }
7263 
7265  void SetInterpolation (int p) { m_interpolation = (char)p; }
7267  int GetInterpolation () const { return (int)m_interpolation; }
7268 
7270  void SetDecimation (int p) { m_decimation = (char)p; }
7272  int GetDecimation () const { return (int)m_decimation; }
7273 
7275  void SetRedMapping (int p) { m_red_mapping = (char)p; }
7277  int GetRedMapping () const { return (int)m_red_mapping; }
7278 
7280  void SetGreenMapping (int p) { m_green_mapping = (char)p; }
7282  int GetGreenMapping () const { return (int)m_green_mapping; }
7283 
7285  void SetBlueMapping (int p) { m_blue_mapping = (char)p; }
7287  int GetBlueMapping () const { return (int)m_blue_mapping; }
7288 
7290  void SetAlphaMapping (int p) { m_alpha_mapping = (char)p; }
7292  int GetAlphaMapping () const { return (int)m_alpha_mapping; }
7293 
7295  void SetParameterFunction (int p) { m_param_function = (char)p; }
7297  int GetParameterFunction () const { return (int)m_param_function; }
7298 
7300  void SetLayout (int p) { m_layout = (char)p; }
7302  int GetLayout () const { return (int)m_layout; }
7303 
7305  void SetTiling (int p) { m_tiling = (char)p; }
7307  int GetTiling () const { return (int)m_tiling; }
7308 
7310  void SetValueScale (float v1, float v2) { m_value_scale[0] = v1; m_value_scale[1] = v2; }
7312  float const * GetValueScale () const { return m_value_scale; }
7313 
7315  void SetApplicationMode (int p) { m_apply_mode = (char)p; }
7317  int GetApplicationMode () const { return (int)m_apply_mode; }
7318 
7320  void SetParameterOffset (int p) { m_param_offset = (char)p; }
7322  int GetParameterOffset () const { return (int)m_param_offset; }
7323 
7328  void SetTransform (char const * transform) { set_transform (transform); }
7333  void SetTransform (int length) { set_transform (length); }
7335  char const * GetTransform () const { return m_transform; }
7337  char * GetTransform () { return m_transform; }
7338 };
7339 
7341 
7343 
7349 class BBINFILETK_API2 TK_Thumbnail : public BBaseOpcodeHandler {
7350  protected:
7351  unsigned char * m_bytes;
7353  int m_size[2];
7354  unsigned char m_format;
7356  public:
7358  TK_Thumbnail() : BBaseOpcodeHandler (TKE_Thumbnail), m_bytes (0), m_allocated (0), m_format (TKO_Thumbnail_Invalid) {}
7359  ~TK_Thumbnail();
7360 
7363  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
7364 
7365  TK_Status ReadAscii (BStreamFileToolkit & tk);
7366  TK_Status WriteAscii (BStreamFileToolkit & tk);
7367 
7369  TK_Status Interpret (BStreamFileToolkit & tk, ID_Key key, int variant);
7370  TK_Status Interpret (BStreamFileToolkit & tk, ID_Key key, char const * special)
7371  { return BBaseOpcodeHandler::Interpret(tk, key, special); }
7372  void Reset ();
7373 
7378  void SetBytes (int size, unsigned char const * bytes = 0);
7380  unsigned char const * GetBytes () const { return m_bytes; }
7382  unsigned char * GetBytes () { return m_bytes; }
7383 
7385  void SetSize (int w, int h) { m_size[0] = w; m_size[1] = h; }
7387  void SetSize (int const s[]) { m_size[0] = s[0]; m_size[1] = s[1]; }
7389  int const * GetSize () const { return m_size; }
7390 
7392  void SetFormat (int f) { m_format = (unsigned char)f; }
7394  int GetFormat () const { return (int)m_format; }
7395 };
7396 
7397 
7399 
7401 
7406 class BBINFILETK_API2 TK_Glyph_Definition : public BBaseOpcodeHandler {
7407  protected:
7409  int m_size;
7410  char * m_name;
7411  char * m_data;
7413  public:
7415  TK_Glyph_Definition () : BBaseOpcodeHandler (TKE_Glyph_Definition),
7416  m_name_length (0), m_size (0),
7417  m_name (0), m_data (0) {}
7419 
7422  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
7423 
7424  TK_Status ReadAscii (BStreamFileToolkit & tk);
7425  TK_Status WriteAscii (BStreamFileToolkit & tk);
7426 
7427  void Reset ();
7428 
7430  void SetName (char const * name);
7432  void SetName (int length);
7434  char const * GetName () const { return m_name; }
7436  char * GetName () { return m_name; }
7437 
7439  void SetDefinition (int size, char const * data = 0);
7441  int GetDefinitionSize () const { return m_size; }
7443  char const * GetDefinition () const { return m_data; }
7445  char * GetDefinition () { return m_data; }
7446 };
7447 
7448 
7450 
7455 class BBINFILETK_API2 TK_Shape_Definition : public BBaseOpcodeHandler {
7456  protected:
7458  int m_size;
7459  char * m_name;
7460  float * m_data;
7462  public:
7464  TK_Shape_Definition () : BBaseOpcodeHandler (TKE_Shape_Definition),
7465  m_name_length (0), m_size (0),
7466  m_name (0), m_data (0) {}
7468 
7471  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
7472 
7473  TK_Status ReadAscii (BStreamFileToolkit & tk);
7474  TK_Status WriteAscii (BStreamFileToolkit & tk);
7475 
7476  void Reset ();
7477 
7479  void SetName (char const * name);
7481  void SetName (int length);
7483  char const * GetName () const { return m_name; }
7485  char * GetName () { return m_name; }
7486 
7488  void SetDefinition (int size, float const * data = 0);
7490  int GetDefinitionSize () const { return m_size; }
7492  float const * GetDefinition () const { return m_data; }
7494  float * GetDefinition () { return m_data; }
7495 };
7496 
7497 
7499 
7504 class BBINFILETK_API2 TK_Named_Style_Def : public BBaseOpcodeHandler {
7505  protected:
7507  char * m_name;
7510  char * m_segment;
7514  char * m_condition;
7518  bool m_follow;
7519 
7520  public:
7523  m_name_length (0), m_name (0),
7524  m_segment_length (0), m_segment (0) ,
7525  m_cond_length (0), m_cond_allocated (0), m_condition (0),
7526  m_key(-1), m_referee(0), m_follow(true) {}
7527  ~TK_Named_Style_Def();
7528 
7531  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
7532 
7533  TK_Status ReadAscii (BStreamFileToolkit & tk);
7534  TK_Status WriteAscii (BStreamFileToolkit & tk);
7535 
7536  void Reset ();
7537 
7539  void SetName (char const * name);
7541  void SetName (int length);
7543  char const * GetName () const { return m_name; }
7545  char * GetName () { return m_name; }
7546 
7551  void SetSegment (char const * segment);
7556  void SetSegment (int length);
7560  char const * GetSegment () const { return m_segment; }
7565  char * GetSegment () { return m_segment; }
7566 };
7567 
7569 
7574 class BBINFILETK_API2 TK_Line_Style : public BBaseOpcodeHandler {
7575  protected:
7578  char * m_name;
7579  char * m_definition;
7581  public:
7583  TK_Line_Style () : BBaseOpcodeHandler (TKE_Line_Style),
7584  m_name_length (0), m_definition_length (0),
7585  m_name (0), m_definition (0) {}
7586  ~TK_Line_Style();
7587 
7590  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
7591 
7592  TK_Status ReadAscii (BStreamFileToolkit & tk);
7593  TK_Status WriteAscii (BStreamFileToolkit & tk);
7594 
7595  void Reset ();
7596 
7598  void SetName (char const * name);
7600  void SetName (int length);
7602  char const * GetName () const { return m_name; }
7604  char * GetName () { return m_name; }
7605 
7607  void SetDefinition (char const * def);
7609  void SetDefinition (int length);
7611  char const * GetDefinition () const { return m_definition; }
7613  char * GetDefinition () { return m_definition; }
7614 };
7615 
7617 
7619 
7624 class BBINFILETK_API TK_Clip_Rectangle : public BBaseOpcodeHandler {
7625  protected:
7626  char m_options;
7627  float m_rect[4];
7629  public:
7632  : BBaseOpcodeHandler (TKE_Clip_Rectangle), m_options (0) {}
7633 
7636  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
7637 
7638  TK_Status ReadAscii (BStreamFileToolkit & tk);
7639  TK_Status WriteAscii (BStreamFileToolkit & tk);
7640 
7641  void Reset ();
7642 
7644  void SetRectangle (float left, float right, float bottom, float top)
7645  { m_rect[0] = left; m_rect[1] = right; m_rect[2] = bottom; m_rect[3] = top; }
7647  void SetRectangle (float const * rect)
7648  { SetRectangle (rect[0], rect[1], rect[2], rect[3]); }
7650  float const * GetRectangle () const { return m_rect; }
7651 
7653  void SetOptions (int o) { m_options = (char)o; }
7655  int GetOptions () const { return (int)m_options; }
7656 };
7657 
7659 
7661 
7666 class BBINFILETK_API TK_Clip_Region : public BBaseOpcodeHandler {
7667  protected:
7668  char m_options;
7669  int m_count;
7670  float * m_points;
7671  double * m_dpoints;
7675  public:
7678  : BBaseOpcodeHandler (TKE_Clip_Region), m_options (0), m_count (0), m_points (0), m_dpoints (0), m_complex (0) {}
7679  ~TK_Clip_Region();
7680 
7683  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
7684 
7685  TK_Status ReadAscii (BStreamFileToolkit & tk);
7686  TK_Status WriteAscii (BStreamFileToolkit & tk);
7687 
7688  void Reset ();
7689 
7694  void SetPoints (int count, float const points[] = 0);
7696  float const * GetPoints () const { return m_points; }
7698  float * GetPoints () { return m_points; }
7699 
7704  void SetDPoints (int count, double const points[] = 0);
7706  double const * GetDPoints () const { return m_dpoints; }
7708  double * GetDPoints () { return m_dpoints; }
7709 
7710 
7712  int GetCount () const { return m_count; }
7713 
7714 
7716  void SetOptions (int o) { m_options = (char)o; }
7718  int GetOptions () const { return (int)m_options; }
7719 };
7720 
7721 
7723 
7725 
7730 class BBINFILETK_API TK_Complex_Clip_Region : public BBaseOpcodeHandler {
7731  protected:
7732  char m_options;
7733  int m_loops;
7734  int m_total;
7735  int * m_lengths;
7736  float * m_points;
7737  double * m_dpoints;
7739  public:
7742  : BBaseOpcodeHandler (TKE_Complex_Clip_Region), m_options (0), m_loops (0), m_total (0),
7743  m_lengths (0), m_points (0), m_dpoints (0) {}
7745 
7748  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
7749 
7750  TK_Status ReadAscii (BStreamFileToolkit & tk);
7751  TK_Status WriteAscii (BStreamFileToolkit & tk);
7752 
7753  void Reset ();
7754 
7759  void SetPoints (int count, float const points[] = 0);
7761  float const * GetPoints () const { return m_points; }
7763  float * GetPoints () { return m_points; }
7764 
7769  void SetDPoints (int count, double const points[] = 0);
7771  double const * GetDPoints () const { return m_dpoints; }
7773  double * GetDPoints () { return m_dpoints; }
7774 
7775 
7780  void SetLengths (int count, int const lengths[] = 0);
7782  int const * GetLengths () const { return m_lengths; }
7784  int * GetLengths () { return m_lengths; }
7785 
7786 
7788  int GetTotal () const { return m_total; }
7790  int GetLoops () const { return m_loops; }
7791 
7792 
7794  void SetOptions (int o) { m_options = (char)o; }
7796  int GetOptions () const { return (int)m_options; }
7797 };
7798 
7799 
7801 
7803 
7819 class BBINFILETK_API2 TK_User_Data : public BBaseOpcodeHandler {
7820  protected:
7821  int m_size;
7822  unsigned char * m_data;
7825  void set_data (int size, unsigned char const * bytes = 0);
7827 
7828  public:
7831  : BBaseOpcodeHandler (TKE_Start_User_Data), m_size (0), m_data (0), m_buffer_size(0) {}
7832  ~TK_User_Data();
7833 
7836  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
7837 
7838  TK_Status ReadAscii (BStreamFileToolkit & tk);
7839  TK_Status WriteAscii (BStreamFileToolkit & tk);
7840 
7842  void Reset ();
7843 
7848  void SetUserData (int size, unsigned char const * bytes = 0) { set_data (size, bytes); }
7850  unsigned char const * GetUserData () const { return m_data; }
7852  unsigned char * GetUserData () { return m_data; }
7854  int GetSize () const { return m_size; }
7855 
7857  void Resize (int size);
7858 
7860  void SetSize (int size);
7861 };
7862 
7863 
7865 
7867 
7879 class BBINFILETK_API2 TK_Material : public BBaseOpcodeHandler {
7880  protected:
7882 
7885  struct vlist_s *m_data;
7886 
7887  public:
7889  TK_Material () : BBaseOpcodeHandler (TKE_Material), m_total_size(0), m_data(0) {}
7890  ~TK_Material();
7891 
7894  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
7895  void Reset ();
7896 
7897  TK_Status PushUserData (char const *buffer, int buffer_size, bool tally_total_size = true);
7898  TK_Status GetBlock (char const **ptr, int *buffer_size);
7899 };
7900 
7902 
7907 class BBINFILETK_API TK_XML : public BBaseOpcodeHandler {
7908  protected:
7909  int m_size;
7910  char * m_data;
7912  public:
7914  TK_XML (): BBaseOpcodeHandler (TKE_XML), m_size (0), m_data (0) {}
7915  ~TK_XML();
7916 
7919  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
7920 
7921  TK_Status ReadAscii (BStreamFileToolkit & tk);
7922  TK_Status WriteAscii (BStreamFileToolkit & tk);
7923 
7925  void Reset ();
7926 
7931  void SetXML (int size, char const * data = 0);
7935  void AppendXML (int size, char const * data = 0);
7937  char const * GetXML () const { return m_data; }
7939  char * GetXML () { return m_data; }
7941  int GetSize () const { return m_size; }
7942 };
7943 
7944 
7945 
7947 
7953 class BBINFILETK_API TK_URL : public BBaseOpcodeHandler {
7954  protected:
7955  int m_length;
7957  char * m_string;
7959  public:
7962  m_length (0), m_allocated (0), m_string (0) {}
7963  ~TK_URL();
7964 
7967  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
7968 
7969  TK_Status ReadAscii (BStreamFileToolkit & tk);
7970  TK_Status WriteAscii (BStreamFileToolkit & tk);
7971 
7972  void Reset ();
7973 
7975  void SetString (char const * string);
7977  void SetString (int length);
7979  char const * GetString () const { return m_string; }
7981  char * GetString () { return m_string; }
7982 };
7983 
7984 
7986 
7992 class BBINFILETK_API TK_External_Reference : public BBaseOpcodeHandler {
7993  protected:
7994  int m_length;
7996  char * m_string;
7998  public:
7999  TK_External_Reference () : BBaseOpcodeHandler (TKE_External_Reference),
8000  m_length (0), m_allocated (0), m_string (0) {}
8002 
8005  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
8006 
8007  TK_Status ReadAscii (BStreamFileToolkit & tk);
8008  TK_Status WriteAscii (BStreamFileToolkit & tk);
8009 
8011  void Reset ();
8012 
8014  void SetString (char const * string);
8016  void SetString (int length);
8018  char const * GetString () const { return m_string; }
8020  char * GetString () { return m_string; }
8021 };
8022 
8023 
8025 
8031 class BBINFILETK_API TK_External_Reference_Unicode : public BBaseOpcodeHandler {
8032  protected:
8033  int m_length;
8035  wchar_t * m_string;
8037  public:
8038  TK_External_Reference_Unicode () : BBaseOpcodeHandler (TKE_External_Reference_Unicode),
8039  m_length (0), m_allocated (0), m_string (0) {}
8041 
8044  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
8045 
8047  void Reset ();
8048 
8050  void SetString (__wchar_t const * string);
8051 #ifdef _MSC_VER
8052  void SetString (unsigned short const * string);
8053 #endif
8054 
8055  void SetString (int length);
8057  wchar_t const * GetString () const { return m_string; }
8059  wchar_t * GetString () { return m_string; }
8060 };
8061 
8062 
8063 
8064 
8066 
8072 class BBINFILETK_API TK_Image_XRef : public BBaseOpcodeHandler {
8073  protected:
8074  char * m_name;
8076  int m_size[2];
8077  char m_bpp;
8078 
8080  void set_name (char const * string);
8082  void set_name (int length);
8083 
8084  public:
8085  TK_Image_XRef () : BBaseOpcodeHandler (TKE_Image_XRef), m_name (0), m_name_length (0), m_bpp(0)
8086  { m_size[0] = m_size[1] = 0; }
8087  ~TK_Image_XRef();
8088 
8091  TK_Status Clone (BStreamFileToolkit & tk, BBaseOpcodeHandler **handler) const;
8093  void Reset (void);
8094 
8096  void SetName (char const * string) { set_name (string);}
8098  void SetName (int length) { set_name (length);}
8100  char const * GetName (void) const { return m_name;}
8102  char * GetName (void) { return m_name;}
8103 
8104  void SetSize (int x, int y ) { m_size[0] = x; m_size[1] = y;}
8105  int const* GetSize (void) const { return m_size;}
8106  int * GetSize (void) { return m_size;}
8107 
8108  void SetBitDepth( char bpp ) { m_bpp = bpp;}
8109  char const GetBitDepth (void) const { return m_bpp;}
8110  char GetBitDepth (void) { return m_bpp;}
8111 };
8112 
8113 
8114 #endif //BOPCODE_HANDLER
8115 
void SetOptions(int o)
Definition: BOpcodeHandler.h:5731
void SetAxis(float const s[], float const e[])
Definition: BOpcodeHandler.h:6445
char ** m_isoline_patterns
for internal use only.
Definition: BOpcodeHandler.h:2472
float GetPreferenceCutoff() const
Definition: BOpcodeHandler.h:5341
char * GetString()
Definition: BOpcodeHandler.h:2181
void SetColorMarkerContrastLockMask(int m)
Definition: BOpcodeHandler.h:3021
void SetRoughnessMap(char const *name)
Definition: BOpcodeHandler.h:2283
float * m_control_points
Definition: BOpcodeHandler.h:5619
float const * GetRGB() const
Definition: BOpcodeHandler.h:1948
int m_nurbs_options_value
For internal use only.
Definition: BOpcodeHandler.h:2502
static TK_Status PutData(BStreamFileToolkit &tk, short const *s, int n)
Definition: BOpcodeHandler.h:353
shift corresponding to extended bit
Definition: BOpcodeEnums.h:280
int GetMask(int index=0) const
Definition: BOpcodeHandler.h:2620
int GetTechnology() const
Definition: BOpcodeHandler.h:2645
char m_isoline_position_type
for internal use only.
Definition: BOpcodeHandler.h:2466
BBaseOpcodeHandler * m_indices
Definition: BOpcodeHandler.h:4708
int GetOptions() const
Definition: BOpcodeHandler.h:5481
for further expansion
Definition: BOpcodeEnums.h:1172
void SetPoints(float const s[], float const e[])
Definition: BOpcodeHandler.h:5518
ID_Key last_key(BStreamFileToolkit &tk) const
obsolete
Definition: BOpcodeHandler.h:650
int value
For internal use only.
Definition: BOpcodeHandler.h:1059
char * m_coordinate_systems
internal use
Definition: BOpcodeHandler.h:4165
int GetSelectionLevel() const
Definition: BOpcodeHandler.h:4133
int GetFlags() const
Definition: BOpcodeHandler.h:7257
void SetType(int t)
Definition: BOpcodeHandler.h:6733
virtual bool NeedsContext(BStreamFileToolkit &tk) const
Definition: BOpcodeHandler.h:227
unsigned char const * GetUserData() const
Definition: BOpcodeHandler.h:7850
int GetMaximumExtentMode() const
Definition: BOpcodeHandler.h:4069
TK_Clip_Rectangle()
Definition: BOpcodeHandler.h:7631
int m_name_length
Definition: BOpcodeHandler.h:7408
TK_Grid()
Definition: BOpcodeHandler.h:6645
int m_name_length
Definition: BOpcodeHandler.h:7037
char m_maximum_extent_level
internal use; maximum extent level
Definition: BOpcodeHandler.h:3981
char * GetName()
Definition: BOpcodeHandler.h:6970
void SetJoinCutoffAngle(int d)
Definition: BOpcodeHandler.h:2673
int GetLodMinimumTriangleCount() const
Definition: BOpcodeHandler.h:3589
int GetFormat() const
Definition: BOpcodeHandler.h:7136
void SetPixelThreshold(int c)
Definition: BOpcodeHandler.h:4061
float GetCutGeometryTolerance() const
Definition: BOpcodeHandler.h:3757
void SetDUpVector(double const u[])
Definition: BOpcodeHandler.h:5019
void SetVisibilityLockValue(int v)
Definition: BOpcodeHandler.h:2710
int const * GetSize() const
Definition: BOpcodeHandler.h:7389
mask for HLR suboptions; refer to ::HC_Set_Rendering_Options for description
Definition: BOpcodeEnums.h:662
int GetToleranceUnits() const
Definition: BOpcodeHandler.h:5254
float const * GetDefinition() const
Definition: BOpcodeHandler.h:7492
bool GetLogging() const
Definition: BStreamFileToolkit.h:1005
float * m_v_knots
Definition: BOpcodeHandler.h:5795
void SetPattern(int p)
Definition: BOpcodeHandler.h:4533
int color_value
For internal use only.
Definition: BOpcodeHandler.h:1061
channel m_bump
internal use
Definition: BOpcodeHandler.h:1741
short color_text_mask
For internal use only.
Definition: BOpcodeHandler.h:1070
unsigned short m_unsigned_short
temporary
Definition: BOpcodeHandler.h:82
char m_space
internal use
Definition: BOpcodeHandler.h:1962
int GetOffset() const
Definition: BOpcodeHandler.h:1700
int m_allocated
Definition: BOpcodeHandler.h:7352
void SetTransmissionName(int length)
Definition: BOpcodeHandler.h:1848
double * m_dcontrol_points
Definition: BOpcodeHandler.h:5620
void SetCoordinateSystems(int count, char const cs[])
Definition: BOpcodeHandler.h:4212
ID_Key GetIndex()
Definition: BOpcodeHandler.h:1410
void SetDUpVector(double x, double y, double z)
Definition: BOpcodeHandler.h:5016
void SetTransmission(float const rgb[])
Definition: BOpcodeHandler.h:1844
float const * GetField() const
Definition: BOpcodeHandler.h:5030
void SetLodFallback(int v)
Definition: BOpcodeHandler.h:3607
double * m_dpoints
Definition: BOpcodeHandler.h:6515
int GetCount() const
Definition: BOpcodeHandler.h:5916
char * GetCondition()
Definition: BOpcodeHandler.h:1430
static TK_Status GetData(BStreamFileToolkit &tk, short &s)
Definition: BOpcodeHandler.h:308
void SetComment(int length)
Definition: BOpcodeHandler.h:984
char const * GetCamera() const
Definition: BOpcodeHandler.h:7246
void SetColorMarkerContrastForcedLockMask(int m)
Definition: BOpcodeHandler.h:3424
float * m_leaders
Definition: BOpcodeHandler.h:6785
void SetOptions(int o)
Definition: BOpcodeHandler.h:7653
char * m_name
Definition: BOpcodeHandler.h:8074
static TK_Status GetData(BStreamFileToolkit &tk, unsigned char *b, int n)
Definition: BOpcodeHandler.h:296
int GetRadiusCount() const
Definition: BOpcodeHandler.h:6596
int const * GetIndices() const
Definition: BOpcodeHandler.h:4872
void SetColorLockValue(int v)
Definition: BOpcodeHandler.h:2733
static TK_Status PutData(BStreamFileToolkit &tk, char const *b, int n)
Definition: BOpcodeHandler.h:350
char const * GetTransmissionName() const
Definition: BOpcodeHandler.h:1852
void SetPosition(float const p[])
Definition: BOpcodeHandler.h:7114
int GetForcedLockValue() const
Definition: BOpcodeHandler.h:3096
void SetInternalSelectionLimit(int i)
Definition: BOpcodeHandler.h:4029
int m_count
internal use
Definition: BOpcodeHandler.h:5872
int m_lookup_length
Definition: BOpcodeHandler.h:6913
int m_shader_source_length
Definition: BOpcodeHandler.h:7166
void SetDRef1(double const r[])
Definition: BOpcodeHandler.h:6705
void SetDPosition(double x, double y, double z)
Definition: BOpcodeHandler.h:5963
void SetGeneralDisplacement(int d)
Definition: BOpcodeHandler.h:2668
unsigned short mask
specifies which settings are active (i.e. the attributes for which we have an opinion at this point) ...
Definition: BOpcodeHandler.h:6752
int m_current_value
for internal use only
Definition: BOpcodeHandler.h:4793
bool NeedsTag() const
Definition: BOpcodeHandler.h:199
unsigned int NextOpcodeSequence()
Definition: BStreamFileToolkit.h:1036
int GetColorVertexLockMask() const
Definition: BOpcodeHandler.h:2957
TK_Header()
Definition: BOpcodeHandler.h:879
int m_values_length
internal use
Definition: BOpcodeHandler.h:2122
float const * GetWeights() const
Definition: BOpcodeHandler.h:5766
unsigned char m_degree
Definition: BOpcodeHandler.h:5710
int GetColorWindowForcedLockMask() const
Definition: BOpcodeHandler.h:3268
void SetAmbientUpVector(float const v[])
Definition: BOpcodeHandler.h:3916
Capping_Options
Definition: BOpcodeHandler.h:6541
int m_simple_reflection_blur
For internal use only.
Definition: BOpcodeHandler.h:2554
char const * GetView() const
Definition: BOpcodeHandler.h:5077
int m_shape_length
for internal use only
Definition: BOpcodeHandler.h:5157
unsigned char m_tolerance_units
for internal use only
Definition: BOpcodeHandler.h:5165
int GetColorLineContrastLockValue() const
Definition: BOpcodeHandler.h:3014
unsigned char m_opcode
The opcode being handled by this particular object.
Definition: BOpcodeHandler.h:65
float const * GetPlane() const
Definition: BOpcodeHandler.h:6055
int GetTextRegionFitting() const
Definition: BOpcodeHandler.h:6859
void SetEmissiveMap(char const *name)
Definition: BOpcodeHandler.h:2265
int GetStringCursorCount() const
Definition: BOpcodeHandler.h:6865
float GetHlrFaceDisplacement() const
Definition: BOpcodeHandler.h:3533
float * GetDefinition()
Definition: BOpcodeHandler.h:7494
int GetDebug() const
Definition: BOpcodeHandler.h:2655
int GetNURBSCurveBudget() const
Definition: BOpcodeHandler.h:3559
char const * GetNormalMap() const
Definition: BOpcodeHandler.h:2260
float const * GetAmbientUpVector() const
Definition: BOpcodeHandler.h:3918
char m_char
temporary
Definition: BOpcodeHandler.h:84
TK_Status PutGeneral(BStreamFileToolkit &tk)
Definition: BOpcodeHandler.h:491
int GetColorTextContrastLockMask() const
Definition: BOpcodeHandler.h:3072
static TK_Status GetData(BStreamFileToolkit &tk, short *s, int n)
Definition: BOpcodeHandler.h:264
void SetCutVisualizationColor(float const *c)
Definition: BOpcodeHandler.h:4236
float const * GetTextLeaders() const
Definition: BOpcodeHandler.h:6876
int GetGeometry() const
Definition: BOpcodeHandler.h:2103
void SetVertexDisplacement(int d)
Definition: BOpcodeHandler.h:2663
double const * GetDPoints() const
Definition: BOpcodeHandler.h:5538
int m_size
Definition: BOpcodeHandler.h:7821
self-explanatory; (internal note: keep this listed last)
Definition: BOpcodeEnums.h:1109
void SetFormat(int f)
Definition: BOpcodeHandler.h:7134
int GetLodAlgorithm() const
Definition: BOpcodeHandler.h:3585
void SetOblique(float h, float v)
Definition: BOpcodeHandler.h:5045
void SetColorTextLockValue(int v)
Definition: BOpcodeHandler.h:2848
unsigned short m_pattern
internal use
Definition: BOpcodeHandler.h:4518
double * m_dpoints
Definition: BOpcodeHandler.h:7671
channel m_specular
internal use
Definition: BOpcodeHandler.h:1736
unsigned char const * GetBytes() const
Definition: BOpcodeHandler.h:7380
float vertical_offset
offset, positive or negative, from the standard position. units are specified separately in vertical_...
Definition: BOpcodeHandler.h:6746
self-explanatory
Definition: BOpcodeEnums.h:267
char * m_shader_source
Definition: BOpcodeHandler.h:7162
int m_length
internal use
Definition: BOpcodeHandler.h:942
////
Definition: BOpcodeEnums.h:134
short color_face_value
For internal use only.
Definition: BOpcodeHandler.h:1063
void SetColorWindowForcedLockMask(int m)
Definition: BOpcodeHandler.h:3263
TK_Status ReadAscii(BStreamFileToolkit &tk)
Deprecated.
void SetBufferSizeLimit(int l)
Definition: BOpcodeHandler.h:3500
float * GetPoints()
Definition: BOpcodeHandler.h:5824
short m_type
Definition: BOpcodeHandler.h:4656
unsigned char Opcode() const
Definition: BOpcodeHandler.h:164
void SetOcclusionFactor(float f)
Definition: BOpcodeHandler.h:2331
void SetTechnology(int t)
Definition: BOpcodeHandler.h:2643
int m_surface_trim_budget
For internal use only.
Definition: BOpcodeHandler.h:2506
void SetDTarget(double const t[])
Definition: BOpcodeHandler.h:4999
Handles the TKE_Reopen_Segment opcode.
Definition: BOpcodeHandler.h:1257
int m_current_level
the index of the level currently in progress.
Definition: BOpcodeHandler.h:1515
void SetScreenRange(float const l[], float const o[])
Definition: BOpcodeHandler.h:3900
char m_options
for internal use only
Definition: BOpcodeHandler.h:5940
void SetPreferenceCutoffUnits(int u)
Definition: BOpcodeHandler.h:5344
void increase_nesting(BStreamFileToolkit &tk, int amount=1)
for internal use only
Definition: BOpcodeHandler.h:659
HT_NURBS_Trim * m_list
Definition: BOpcodeHandler.h:5716
void SetDPoints(double const p[])
Definition: BOpcodeHandler.h:5536
void SetTolerance(float t)
Definition: BOpcodeHandler.h:5247
int m_highest_level
keeps track of highest level lod that has been seen so far
Definition: BOpcodeHandler.h:1511
char * GetTransform()
Definition: BOpcodeHandler.h:7337
void SetSimpleShadowBlur(int m)
Definition: BOpcodeHandler.h:3794
float m_surface_max_facet_angle
For internal use only.
Definition: BOpcodeHandler.h:2508
unsigned short m_mask
internal use
Definition: BOpcodeHandler.h:4159
float m_radius
Definition: BOpcodeHandler.h:6422
void SetTarget(float const t[])
Definition: BOpcodeHandler.h:4989
int GetColorForcedLockValue() const
Definition: BOpcodeHandler.h:3141
int GetColorLineContrastLockMask() const
Definition: BOpcodeHandler.h:3003
char const * GetName() const
Definition: BOpcodeHandler.h:7543
void SetLodBounding(float const s[], float const e[])
Definition: BOpcodeHandler.h:3617
float m_hlr_weight
for internal use only.
Definition: BOpcodeHandler.h:2455
double * GetDTextLeaders()
Definition: BOpcodeHandler.h:6891
char * m_name
Definition: BOpcodeHandler.h:7507
void SetBufferOptionsMask(int v)
Definition: BOpcodeHandler.h:3492
int m_nurbs_options_mask
For internal use only.
Definition: BOpcodeHandler.h:2501
float * m_control_points
Definition: BOpcodeHandler.h:5791
int m_loops
Definition: BOpcodeHandler.h:7733
void SetImage(int length)
Definition: BOpcodeHandler.h:7235
short color_edge_value
For internal use only.
Definition: BOpcodeHandler.h:1065
void SetEncoding(int e)
Definition: BOpcodeHandler.h:6982
Handles the TKE_Close_Segment opcode.
Definition: BOpcodeHandler.h:1229
int GetPattern() const
Definition: BOpcodeHandler.h:4535
Handles the TKE_Geometry_Options opcode.
Definition: BOpcodeHandler.h:4157
float const * GetCenter() const
Definition: BOpcodeHandler.h:6331
int m_up
internal use; specifies what geometry is selectable on mouse button up. For internal use only...
Definition: BOpcodeHandler.h:4321
int m_debug_allocated
Definition: BOpcodeHandler.h:71
double const * GetDPoints() const
Definition: BOpcodeHandler.h:5911
int GetOrientationCount() const
Definition: BOpcodeHandler.h:4207
float const * GetPoints() const
Definition: BOpcodeHandler.h:7761
void SetDEnd(double const e[])
Definition: BOpcodeHandler.h:6170
int GetColorVertexLockValue() const
Definition: BOpcodeHandler.h:2968
TK_Unavailable(char opcode)
Definition: BOpcodeHandler.h:858
void SetOptions(char const *options)
Definition: BOpcodeHandler.h:4731
static TK_Status GetData(BStreamFileToolkit &tk, float *f, int n)
Definition: BOpcodeHandler.h:280
void SetColorFaceLockMask(int m)
Definition: BOpcodeHandler.h:2745
int GetUSize() const
Definition: BOpcodeHandler.h:5835
short color_window_mask
For internal use only.
Definition: BOpcodeHandler.h:1072
int m_allocated
Definition: BOpcodeHandler.h:8034
TK_Status Interpret(BStreamFileToolkit &tk, ID_Key key, char const *special)
Definition: BOpcodeHandler.h:1623
void SetSelectionCulling(int c)
Definition: BOpcodeHandler.h:4053
void SetAxis(float x, float y, float z)
Definition: BOpcodeHandler.h:6340
float m_max_distance
internal use; max distance
Definition: BOpcodeHandler.h:3986
void SetDPoints(double const s[], double const m[], double const e[], double const c[]=0)
Definition: BOpcodeHandler.h:6184
channel m_transmission
internal use
Definition: BOpcodeHandler.h:1738
Handles the TKE_Cylinder opcode.
Definition: BOpcodeHandler.h:6419
void SetCenter(float const s[])
Definition: BOpcodeHandler.h:6231
float m_radius
Definition: BOpcodeHandler.h:6302
void Reset(void)
Definition: BOpcodeHandler.h:5455
char const * GetBytes() const
Definition: BOpcodeHandler.h:7088
Handles the TKE_Color_By_Value opcode.
Definition: BOpcodeHandler.h:1958
unsigned char m_flags
Definition: BOpcodeHandler.h:6300
char * m_string
internal use
Definition: BOpcodeHandler.h:2125
TK_Sphere()
Definition: BOpcodeHandler.h:6312
int GetTotal() const
Definition: BOpcodeHandler.h:7788
HLONG const * GetValues() const
Definition: BOpcodeHandler.h:4824
double * GetDRadii()
Definition: BOpcodeHandler.h:6590
int GetCutVisualizationMode() const
Definition: BOpcodeHandler.h:4233
////
Definition: BOpcodeEnums.h:50
double * m_dpoints
Definition: BOpcodeHandler.h:7737
float GetGreekingLimit() const
Definition: BOpcodeHandler.h:5294
void SetShadowMapResolution(int m)
Definition: BOpcodeHandler.h:3846
double * GetDOrigin()
Definition: BOpcodeHandler.h:6698
void SetInner(float i)
Definition: BOpcodeHandler.h:5992
unsigned char m_region_count
Definition: BOpcodeHandler.h:6779
TK_Conditional_Action()
Definition: BOpcodeHandler.h:4663
char const * GetImage() const
Definition: BOpcodeHandler.h:7237
void SetDPlane(double a, double b, double c, double d)
Definition: BOpcodeHandler.h:6045
options mask (unsigned char if file version is < 1805)
Definition: BOpcodeEnums.h:1417
void SetColorBackForcedLockMask(int m)
Definition: BOpcodeHandler.h:3332
int GetCount() const
Definition: BOpcodeHandler.h:6065
Handles the TKE_Termination and TKE_Pause opcodes.
Definition: BOpcodeHandler.h:1006
unsigned short m_contour_options
for internal use only.
Definition: BOpcodeHandler.h:2461
char * m_condition
Definition: BOpcodeHandler.h:7514
double * m_dpoints
internal use
Definition: BOpcodeHandler.h:5874
int GetMaximumExtentLevel() const
Definition: BOpcodeHandler.h:4073
TK_Thumbnail()
Definition: BOpcodeHandler.h:7358
void GetDTarget(double t[]) const
Definition: BOpcodeHandler.h:5003
void decrease_nesting(BStreamFileToolkit &tk, int amount=1)
for internal use only
Definition: BOpcodeHandler.h:661
int GetLodNumCutoffs() const
Definition: BOpcodeHandler.h:3677
char m_options
relevant to TKE_Distant_Light and TKE_Local_Light only. See TKO_Light_Options.
Definition: BOpcodeHandler.h:5437
short color_vertex_contrast_mask
For internal use only.
Definition: BOpcodeHandler.h:1088
int GetLodClamp() const
Definition: BOpcodeHandler.h:3597
int GetTransparentHSR() const
Definition: BOpcodeHandler.h:2635
int GetHSR() const
Definition: BOpcodeHandler.h:2630
void SetLookup(int length)
Definition: BOpcodeHandler.h:6975
void SetChannels(int c)
Definition: BOpcodeHandler.h:1788
near limit setting
Definition: BOpcodeEnums.h:1142
float m_end_u
Definition: BOpcodeHandler.h:5715
void SetName(int length)
Definition: BOpcodeHandler.h:6966
void SetPosition(float const p[])
Definition: BOpcodeHandler.h:5958
short color_window_value
For internal use only.
Definition: BOpcodeHandler.h:1073
float m_cut_geometry_tolerance
For internal use only.
Definition: BOpcodeHandler.h:2533
float * m_points
Definition: BOpcodeHandler.h:5708
type for HLR suboptions; refer to ::HC_Set_Rendering_Options for description
Definition: BOpcodeEnums.h:661
bool validate_count(int count, int limit=1<< 24) const
Definition: BOpcodeHandler.h:690
void SetShadowMap(int m)
Definition: BOpcodeHandler.h:3841
void SetEnd(float x, float y, float z)
Definition: BOpcodeHandler.h:6117
void SetDPosition(double const p[])
Definition: BOpcodeHandler.h:6837
double * GetDPoints()
Definition: BOpcodeHandler.h:5828
int m_cond_allocated
Definition: BOpcodeHandler.h:1386
void Revisit(BStreamFileToolkit &tk, float priority=0.0f, int variant=0) const
Definition: BOpcodeHandler.h:666
char * m_name
Definition: BOpcodeHandler.h:7161
char m_green_mapping
Definition: BOpcodeHandler.h:7176
char * GetSegment()
Definition: BOpcodeHandler.h:1341
int GetLockValue() const
Definition: BOpcodeHandler.h:2693
char * GetString()
Definition: BOpcodeHandler.h:8020
unsigned char m_encoding
Definition: BOpcodeHandler.h:6916
Handles the TKE_Comment opcode.
Definition: BOpcodeHandler.h:939
void SetSegment(char const *segment)
Definition: BOpcodeHandler.h:1198
TK_Bounding(unsigned char opcode, double min[], double max[])
Definition: BOpcodeHandler.h:5402
Definition: BOpcodeHandler.h:4543
void SetBumpName(char const *name)
Definition: BOpcodeHandler.h:1881
void SetImageScale(float const s[])
Definition: BOpcodeHandler.h:3923
char * m_style
for internal use only
Definition: BOpcodeHandler.h:5160
void SetOrtho(float const s[])
Definition: BOpcodeHandler.h:6357
int GetColorTextLockValue() const
Definition: BOpcodeHandler.h:2853
int m_from_variant
internal use
Definition: BOpcodeHandler.h:1453
float const * GetDepthRange() const
Definition: BOpcodeHandler.h:3889
int m_mask
specifies which rendering options are active (and hence, which are valid). For internal use only...
Definition: BOpcodeHandler.h:5141
void SetTarget(float const t[])
Definition: BOpcodeHandler.h:5974
virtual void Reset()
int m_mask
internal use; specifies which selectability settings are active (and hence, which are valid)...
Definition: BOpcodeHandler.h:4319
void SetGloss(float g)
Definition: BOpcodeHandler.h:1890
char const * GetTransform() const
Definition: BOpcodeHandler.h:7335
TK_Delete_Object()
Definition: BOpcodeHandler.h:1484
TK_Cutting_Plane()
Definition: BOpcodeHandler.h:6022
void SetCallback(int length)
Definition: BOpcodeHandler.h:2395
void SetMaximumExtentMode(int c)
Definition: BOpcodeHandler.h:4071
int m_hard_extent
internal use; hard extent
Definition: BOpcodeHandler.h:3982
static TK_Status PutData(BStreamFileToolkit &tk, char const &c)
Definition: BOpcodeHandler.h:450
void SetMoveDown(int m)
Definition: BOpcodeHandler.h:4379
void SetAxis(float const a[])
Definition: BOpcodeHandler.h:6447
void SetValue(float const triple[])
Definition: BOpcodeHandler.h:2006
int m_style_length
for internal use only
Definition: BOpcodeHandler.h:5158
wchar_t * m_string
Definition: BOpcodeHandler.h:8035
int m_internal_polyline
internal use
Definition: BOpcodeHandler.h:3972
int GetColorFaceForcedLockMask() const
Definition: BOpcodeHandler.h:3153
int m_min_triangle_count
For internal use only.
Definition: BOpcodeHandler.h:2490
short color_line_contrast_value
For internal use only.
Definition: BOpcodeHandler.h:1085
Handles the TKE_Reference opcodes.
Definition: BOpcodeHandler.h:1382
short color_cut_face_value
For internal use only.
Definition: BOpcodeHandler.h:1095
The BStreamFileToolkit class provides support for importing/exporting HOOPS Stream File information...
Definition: BStreamFileToolkit.h:367
void SetDAxis(double const s[])
Definition: BOpcodeHandler.h:6384
TK_Circle(unsigned char opcode)
Definition: BOpcodeHandler.h:6088
void SetOrderedWeight(int index, float weight)
Definition: BOpcodeHandler.h:4119
int m_flags
Definition: BOpcodeHandler.h:7169
char m_orientation_count
internal use
Definition: BOpcodeHandler.h:4162
void SetCutVisualizationMask(int m)
Definition: BOpcodeHandler.h:4226
int GetType() const
Definition: BOpcodeHandler.h:6949
static TK_Status GetData(BStreamFileToolkit &tk, float &f)
Definition: BOpcodeHandler.h:323
char m_layout
Definition: BOpcodeHandler.h:7180
static int flip(int i)
for internal use only
Definition: BOpcodeHandler.h:510
int GetColorLineLockMask() const
Definition: BOpcodeHandler.h:2796
int GetForceDefer() const
Definition: BOpcodeHandler.h:4143
char * GetXML()
Definition: BOpcodeHandler.h:7939
int m_leader_count
Definition: BOpcodeHandler.h:6784
int GetColorLineContrastForcedLockMask() const
Definition: BOpcodeHandler.h:3406
double const * GetDPosition() const
Definition: BOpcodeHandler.h:4981
Handles the TKE_Selectability opcode.
Definition: BOpcodeHandler.h:4317
float * m_points
Definition: BOpcodeHandler.h:5556
int GetOptions() const
Definition: BOpcodeHandler.h:7655
void SetTransparentHSR(int t)
Definition: BOpcodeHandler.h:2633
int GetMoveDown() const
Definition: BOpcodeHandler.h:4384
Definition: BOpcodeEnums.h:377
double const * GetDField() const
Definition: BOpcodeHandler.h:5039
void SetSimpleReflectionVisibilityMask(int m)
Definition: BOpcodeHandler.h:3879
unsigned char m_format
Definition: BOpcodeHandler.h:7354
static TK_Status PutData(BStreamFileToolkit &tk, int const *i, int n)
Definition: BOpcodeHandler.h:374
unsigned char General_Flags() const
Definition: BOpcodeHandler.h:167
void SetRadius(float radius)
Definition: BOpcodeHandler.h:6563
int m_count
Definition: BOpcodeHandler.h:6790
int m_count
Definition: BOpcodeHandler.h:5707
void SetInternalShellSelectionLimit(int i)
Definition: BOpcodeHandler.h:4034
int GetDegree() const
Definition: BOpcodeHandler.h:5758
Handles the TKE_Glyph_Definition opcode.
Definition: BOpcodeHandler.h:7406
static void fix(int *i, int n)
for internal use only
Definition: BOpcodeHandler.h:535
int m_size
Definition: BOpcodeHandler.h:7909
void SetColorVertexContrastForcedLockValue(int v)
Definition: BOpcodeHandler.h:3458
void SetView(char const *name)
Definition: BOpcodeHandler.h:5073
int m_edge_join_cutoff_angle
For internal use only.
Definition: BOpcodeHandler.h:2577
int m_knot_count_implicit
Definition: BOpcodeHandler.h:5618
int m_progress
Tracks the amount of data that has been read/written so far.
Definition: BOpcodeHandler.h:64
self-explanatory
Definition: BOpcodeEnums.h:1259
void SetPosition(float const p[])
Definition: BOpcodeHandler.h:4969
short color_marker_contrast_value
For internal use only.
Definition: BOpcodeHandler.h:1087
int GetCaps() const
Definition: BOpcodeHandler.h:6604
int m_allocated
Definition: BOpcodeHandler.h:6773
void SetIndex(float val)
Definition: BOpcodeHandler.h:2106
int GetRelatedSelectionLimit() const
Definition: BOpcodeHandler.h:4026
unsigned char mask
internal use
Definition: BOpcodeHandler.h:4168
unsigned char m_bytes_format
Definition: BOpcodeHandler.h:7042
void SetCylinderTessellation(int n)
Definition: BOpcodeHandler.h:3689
void SetRef2(float x, float y, float z)
Definition: BOpcodeHandler.h:6678
Handles the TKE_Dictionary_Locater opcode.
Definition: BOpcodeHandler.h:1672
void SetEnd(float const e[])
Definition: BOpcodeHandler.h:6121
char m_num_sphere
For internal use only.
Definition: BOpcodeHandler.h:2521
char m_options
Definition: BOpcodeHandler.h:7732
Handles the TKE_Tag opcode.
Definition: BOpcodeHandler.h:1608
float GetMetalnessFactor() const
Definition: BOpcodeHandler.h:2323
static TK_Status GetData(BStreamFileToolkit &tk, unsigned int *i, int n)
Definition: BOpcodeHandler.h:302
Definition: BStreamFileToolkit.h:34
float m_dihedral
For internal use only.
Definition: BOpcodeHandler.h:2567
int GetVisibilityLockValue() const
Definition: BOpcodeHandler.h:2715
float * m_u_knots
Definition: BOpcodeHandler.h:5794
int GetUnits() const
Definition: BOpcodeHandler.h:4509
extra item for selectability; refer to ::HC_Set_Selectability for a description
Definition: BOpcodeEnums.h:224
unsigned char * m_bytes
Definition: BOpcodeHandler.h:7351
int m_count
Definition: BOpcodeHandler.h:6513
void SetIndex(int i)
Definition: BOpcodeHandler.h:1273
void SetOrderedWeightsMask(int c)
Definition: BOpcodeHandler.h:4114
unsigned int m_options
Definition: BOpcodeHandler.h:7040
unsigned char m_hlr_hsr_algorithm
for internal use only.
Definition: BOpcodeHandler.h:2459
void SetAntiAlias(int m)
Definition: BOpcodeHandler.h:3945
void SetDPosition(double const p[])
Definition: BOpcodeHandler.h:7122
float const * GetWeights() const
Definition: BOpcodeHandler.h:5660
float m_depth_peeling_min_area
For internal use only.
Definition: BOpcodeHandler.h:2572
int GetColorFaceForcedLockValue() const
Definition: BOpcodeHandler.h:3164
TK_Status Interpret(BStreamFileToolkit &tk, ID_Key key, char const *special)
Definition: BOpcodeHandler.h:1658
void SetLockMask(int m)
Definition: BOpcodeHandler.h:2686
void SetParameterSource(int p)
Definition: BOpcodeHandler.h:7260
extended bit
Definition: BOpcodeEnums.h:1457
char const * GetName() const
Definition: BOpcodeHandler.h:6968
void SetValue(int v)
Definition: BOpcodeHandler.h:4019
char * m_image
Definition: BOpcodeHandler.h:7163
unsigned char m_transforms
for internal use only
Definition: BOpcodeHandler.h:5169
Handles the TKE_Line_Style opcode.
Definition: BOpcodeHandler.h:7574
char m_options
Definition: BOpcodeHandler.h:7626
int GetApplicationMode() const
Definition: BOpcodeHandler.h:7317
int m_curve_budget
For internal use only.
Definition: BOpcodeHandler.h:2503
float * GetRef2()
Definition: BOpcodeHandler.h:6686
int GetColorWindowLockMask() const
Definition: BOpcodeHandler.h:2865
bool m_is_valid
internal use
Definition: BOpcodeHandler.h:5384
void SetAlphaFactor(float f)
Definition: BOpcodeHandler.h:2336
int m_name_length
Definition: BOpcodeHandler.h:7506
int GetLength()
Definition: BOpcodeHandler.h:4778
float m_value
for internal use only.
Definition: BOpcodeHandler.h:4486
char * m_name
internal use: name
Definition: BOpcodeHandler.h:4546
void SetCaps(int f)
Definition: BOpcodeHandler.h:6602
void SetLodOptionsMask(int v)
Definition: BOpcodeHandler.h:3575
void SetPreferenceCutoff(float s)
Definition: BOpcodeHandler.h:5339
void SetNames(int length)
Definition: BOpcodeHandler.h:5212
void SetNURBSSurfaceBudget(int b)
Definition: BOpcodeHandler.h:3565
TK_Tag(unsigned char opcode=TKE_Tag)
Definition: BOpcodeHandler.h:1613
int GetOptions() const
Definition: BOpcodeHandler.h:5854
int m_count
for internal use only
Definition: BOpcodeHandler.h:4790
char * m_transform
Definition: BOpcodeHandler.h:7184
char * m_name
Definition: BOpcodeHandler.h:4938
char const * GetEmissionName() const
Definition: BOpcodeHandler.h:1867
char const * GetSegment() const
Definition: BOpcodeHandler.h:7560
void SetOblique(float const o[])
Definition: BOpcodeHandler.h:5051
void SetSize(int const s[])
Definition: BOpcodeHandler.h:7129
short color_marker_value
For internal use only.
Definition: BOpcodeHandler.h:1069
int GetDTextLeaderCount() const
Definition: BOpcodeHandler.h:6887
int GetVisibilityForcedLockValue() const
Definition: BOpcodeHandler.h:3118
void SetColorFaceLockValue(int v)
Definition: BOpcodeHandler.h:2756
unsigned char m_renumbered_scope
for internal use only
Definition: BOpcodeHandler.h:1299
int m_int
temporary
Definition: BOpcodeHandler.h:83
void SetMetalnessMap(int length)
Definition: BOpcodeHandler.h:2276
short color_line_value
For internal use only.
Definition: BOpcodeHandler.h:1067
TK_Status Tag(BStreamFileToolkit &tk, int variant=-1) const
Definition: BOpcodeHandler.h:182
int GetSize() const
Definition: BOpcodeHandler.h:7941
int visibility_value
For internal use only.
Definition: BOpcodeHandler.h:1099
float * m_isoline_positions
for internal use only.
Definition: BOpcodeHandler.h:2468
int m_to_index
internal use
Definition: BOpcodeHandler.h:1454
void SetDPoints(double const s[], double const e[])
Definition: BOpcodeHandler.h:5532
int GetEncoding() const
Definition: BOpcodeHandler.h:6984
static TK_Status GetData(BStreamFileToolkit &tk, unsigned int &i)
Definition: BOpcodeHandler.h:320
int GetAntiAlias() const
Definition: BOpcodeHandler.h:3947
char const * GetReference() const
Definition: BOpcodeHandler.h:7106
int GetSimpleShadowResolution() const
Definition: BOpcodeHandler.h:3801
char m_red_mapping
Definition: BOpcodeHandler.h:7175
void SetPosition(float x, float y, float z)
Definition: BOpcodeHandler.h:7111
int m_segment_length
Definition: BOpcodeHandler.h:7509
static TK_Status PutData(BStreamFileToolkit &tk, float const &f)
Definition: BOpcodeHandler.h:468
int GetLodNumRatios() const
Definition: BOpcodeHandler.h:3637
Handles the TKE_Texture opcode.
Definition: BOpcodeHandler.h:7159
int m_allocated
Definition: BOpcodeHandler.h:1173
TK_Status WriteAscii(BStreamFileToolkit &tk)
Deprecated.
unsigned char m_options
Definition: BOpcodeHandler.h:5711
Handles the TKE_Inlude_Segment TKE_Named_Style and TKE_Style_Segment opcodes.
Definition: BOpcodeHandler.h:1288
TK_Clip_Region()
Definition: BOpcodeHandler.h:7677
int GetColorFaceLockMask() const
Definition: BOpcodeHandler.h:2750
void SetNURBSOptionsValue(int v)
Definition: BOpcodeHandler.h:3553
void SetColorWindowContrastLockMask(int m)
Definition: BOpcodeHandler.h:2906
void SetMirror(float r, float g, float b)
Definition: BOpcodeHandler.h:1827
int m_length
Definition: BOpcodeHandler.h:4937
int GetVisibilityForcedLockMask() const
Definition: BOpcodeHandler.h:3107
void SetFogLimits(float const l[])
Definition: BOpcodeHandler.h:2680
float const * GetTarget() const
Definition: BOpcodeHandler.h:4991
void SetValue(int v0, int v1=0, int v2=0)
Definition: BOpcodeHandler.h:2623
int m_cut_geometry_edge_pattern_length
for internal use only.
Definition: BOpcodeHandler.h:2537
void SetRef1(float x, float y, float z)
Definition: BOpcodeHandler.h:6667
TK_Close_Segment()
Definition: BOpcodeHandler.h:1232
int GetColorTextForcedLockMask() const
Definition: BOpcodeHandler.h:3245
int GetColorWindowContrastForcedLockValue() const
Definition: BOpcodeHandler.h:3325
char * GetCutGeometryEdgePattern()
Definition: BOpcodeHandler.h:3776
TK_Unicode_Options()
Definition: BOpcodeHandler.h:4757
self-explanatory
Definition: BOpcodeEnums.h:1426
float const * GetValue() const
Definition: BOpcodeHandler.h:2008
void SetSelectionBias(int c)
Definition: BOpcodeHandler.h:4057
float const * GetViewVolume() const
Definition: BOpcodeHandler.h:4100
char const * GetLoggingString() const
Definition: BOpcodeHandler.h:244
short color_edge_mask
For internal use only.
Definition: BOpcodeHandler.h:1064
void SetGeometry(int m)
Definition: BOpcodeHandler.h:4342
HT_NURBS_Trim * GetNext(void)
Definition: BOpcodeHandler.h:5747
float * GetLodThresholds()
Definition: BOpcodeHandler.h:3663
void SetColorLineContrastLockValue(int v)
Definition: BOpcodeHandler.h:3009
int m_index
internal use: simple value for recognised old forms
Definition: BOpcodeHandler.h:4547
char const * GetCoordinateSystems() const
Definition: BOpcodeHandler.h:4221
void Set_General_Flags(int f)
Definition: BOpcodeHandler.h:170
float const * GetOblique() const
Definition: BOpcodeHandler.h:5053
color by index
Definition: BOpcodeEnums.h:272
void SetNormalMap(int length)
Definition: BOpcodeHandler.h:2258
int m_mask
internal use
Definition: BOpcodeHandler.h:1908
void SetDAxis(double x1, double y1, double z1, double x2, double y2, double z2)
Definition: BOpcodeHandler.h:6462
int GetColorVertexForcedLockMask() const
Definition: BOpcodeHandler.h:3360
float m_gloss
internal use
Definition: BOpcodeHandler.h:1742
Handles the TKE_LOD opcode.
Definition: BOpcodeHandler.h:1507
double const * GetDPosition() const
Definition: BOpcodeHandler.h:5968
void SetColorFaceContrastLockMask(int m)
Definition: BOpcodeHandler.h:2883
char const * GetBumpName() const
Definition: BOpcodeHandler.h:1885
int GetGeneralDisplacement() const
Definition: BOpcodeHandler.h:2670
int GetGreekingMode() const
Definition: BOpcodeHandler.h:5304
unsigned char m_layout
for internal use only
Definition: BOpcodeHandler.h:5172
short color_edge_contrast_value
For internal use only.
Definition: BOpcodeHandler.h:1083
float * GetPoints()
Definition: BOpcodeHandler.h:7698
void SetString(char const *string)
Definition: BOpcodeHandler.h:6813
void SetDPosition(double x, double y, double z)
Definition: BOpcodeHandler.h:6834
TK_Bounding(unsigned char opcode, float min[], float max[])
Definition: BOpcodeHandler.h:5390
void SetOptions(int o)
Definition: BOpcodeHandler.h:6002
void SetWindow(int n, float const w[])
Definition: BOpcodeHandler.h:5116
int m_max_degree
For internal use only.
Definition: BOpcodeHandler.h:2493
int GetSelectionSorting() const
Definition: BOpcodeHandler.h:4138
void SetLodRatios(int c, float const r[]=0)
Definition: BOpcodeHandler.h:3628
float GetNearLimit() const
Definition: BOpcodeHandler.h:5063
TK_Font()
Definition: BOpcodeHandler.h:6931
float m_simple_reflection_yon
For internal use only.
Definition: BOpcodeHandler.h:2556
char * GetEnvironmentName()
Definition: BOpcodeHandler.h:1878
float const * GetStart() const
Definition: BOpcodeHandler.h:6141
float * GetPoints()
Definition: BOpcodeHandler.h:5584
int GetValue() const
Definition: BOpcodeHandler.h:5207
float const * GetPoints() const
Definition: BOpcodeHandler.h:6553
Does not handle any top level opcodes, but rather only the trim types allowable on nurbs surfaces...
Definition: BOpcodeHandler.h:5700
int GetColorLineContrastForcedLockValue() const
Definition: BOpcodeHandler.h:3417
void SetColorLineLockMask(int m)
Definition: BOpcodeHandler.h:2791
void SetValue(float a, float b, float c)
Definition: BOpcodeHandler.h:2002
void SetLayout(int l)
Definition: BOpcodeHandler.h:5349
float * GetPoints()
Definition: BOpcodeHandler.h:5903
TK_Conditions()
Definition: BOpcodeHandler.h:4622
double GetDRadius() const
Definition: BOpcodeHandler.h:6375
unsigned char m_tessellations
For internal use only.
Definition: BOpcodeHandler.h:2518
void SetDTarget(double x, double y, double z)
Definition: BOpcodeHandler.h:4996
void SetNURBSOptionsMask(int m)
Definition: BOpcodeHandler.h:3545
channel m_mirror
internal use
Definition: BOpcodeHandler.h:1737
int GetOptions() const
Definition: BOpcodeHandler.h:5764
void SetColorLineContrastForcedLockValue(int v)
Definition: BOpcodeHandler.h:3412
double const * GetDPoints() const
Definition: BOpcodeHandler.h:6576
char const * GetMirrorName() const
Definition: BOpcodeHandler.h:1837
int GetLodNumLevels() const
Definition: BOpcodeHandler.h:3593
float m_curve_max_angle
For internal use only.
Definition: BOpcodeHandler.h:2511
float GetWidthScale() const
Definition: BOpcodeHandler.h:5269
void SetMajor(float const m[])
Definition: BOpcodeHandler.h:6240
void GetUpVector(float u[]) const
Definition: BOpcodeHandler.h:5013
float GetAlphaFactor() const
Definition: BOpcodeHandler.h:2338
float * m_knots
Definition: BOpcodeHandler.h:5713
unsigned short m_mask_transform
For internal use only.
Definition: BOpcodeHandler.h:2564
double * m_dcontrol_points
Definition: BOpcodeHandler.h:5792
int GetOptions() const
Definition: BOpcodeHandler.h:2242
void SetOrtho(float x, float y, float z)
Definition: BOpcodeHandler.h:6351
void SetDTarget(double const t[])
Definition: BOpcodeHandler.h:5982
TK_Color_By_Value()
Definition: BOpcodeHandler.h:1966
void SetEnd(float e)
Definition: BOpcodeHandler.h:5667
float const * GetSimpleShadowColor() const
Definition: BOpcodeHandler.h:3832
ID_Key m_this_key
for internal use only
Definition: BOpcodeHandler.h:1389
Handles the TKE_Callback opcode.
Definition: BOpcodeHandler.h:2368
char const * GetString() const
Definition: BOpcodeHandler.h:7979
int GetPreferenceCutoffUnits() const
Definition: BOpcodeHandler.h:5346
void SetDRadius(double radius)
Definition: BOpcodeHandler.h:6586
void SetMiddle(float const m[])
Definition: BOpcodeHandler.h:6113
char * GetName()
Definition: BOpcodeHandler.h:7604
void SetCulling(int c)
Definition: BOpcodeHandler.h:4049
float * m_data
Definition: BOpcodeHandler.h:7460
TK_File_Info()
Definition: BOpcodeHandler.h:908
unsigned char m_space_units
for internal use only
Definition: BOpcodeHandler.h:5166
void GetDField(double f[]) const
Definition: BOpcodeHandler.h:5041
float GetRotation() const
Definition: BOpcodeHandler.h:5259
char * m_name
Definition: BOpcodeHandler.h:7410
void SetOcclusionMap(char const *name)
Definition: BOpcodeHandler.h:2292
void SetTransmission(float r, float g, float b)
Definition: BOpcodeHandler.h:1842
HT_NURBS_Trim * m_trims
Definition: BOpcodeHandler.h:5797
unsigned char m_region_options
Definition: BOpcodeHandler.h:6777
self-explanatory
Definition: BOpcodeEnums.h:271
void SetVisibilityLockMask(int m)
Definition: BOpcodeHandler.h:2699
double const * GetDUpVector() const
Definition: BOpcodeHandler.h:5021
Handles the TKE_Open_Segment opcode.
Definition: BOpcodeHandler.h:1170
unsigned char m_antialias
For internal use only.
Definition: BOpcodeHandler.h:2580
void SetWindow(float l, float r, float b, float t, float lo=0, float ro=0, float bo=0, float to=0)
Definition: BOpcodeHandler.h:5106
int GetColorEdgeLockValue() const
Definition: BOpcodeHandler.h:2784
float m_stereo_separation
For internal use only.
Definition: BOpcodeHandler.h:2515
int m_name_length
internal use: length of name
Definition: BOpcodeHandler.h:4545
double m_dradius
Definition: BOpcodeHandler.h:6306
int GetType() const
Definition: BOpcodeHandler.h:6735
int m_debug
For internal use only.
Definition: BOpcodeHandler.h:2436
float m_extra_space
for internal use only
Definition: BOpcodeHandler.h:5150
void SetLookup(char const *string)
Definition: BOpcodeHandler.h:6973
double * GetDPoints()
Definition: BOpcodeHandler.h:5592
void SetIndices(int count)
Definition: BOpcodeHandler.h:4866
void SetOptions(int o)
Definition: BOpcodeHandler.h:7794
void SetMinor(float x, float y, float z)
Definition: BOpcodeHandler.h:6245
float GetExtraSpace() const
Definition: BOpcodeHandler.h:5274
int GetTextLeaderCount() const
Definition: BOpcodeHandler.h:6874
void SetMaskTransform(int m)
Definition: BOpcodeHandler.h:3734
void SetOptions(int o)
Definition: BOpcodeHandler.h:5670
float * GetWeights()
Definition: BOpcodeHandler.h:5661
static TK_Status PutData(BStreamFileToolkit &tk, unsigned char const &b)
Definition: BOpcodeHandler.h:459
int GetFlags()
Definition: BOpcodeHandler.h:926
char * GetDiffuseName()
Definition: BOpcodeHandler.h:1809
float GetOrderedWeight(int index) const
Definition: BOpcodeHandler.h:4124
int GetDefinitionSize() const
Definition: BOpcodeHandler.h:7490
void SetStart(float s)
Definition: BOpcodeHandler.h:5665
TK_Character_Attribute * m_character_attributes
Definition: BOpcodeHandler.h:6791
bump map
Definition: BOpcodeEnums.h:275
int GetDefinitionSize() const
Definition: BOpcodeHandler.h:7441
TK_Reopen_Segment()
Definition: BOpcodeHandler.h:1263
void SetAlphaMapping(int p)
Definition: BOpcodeHandler.h:7290
short color_marker_contrast_mask
For internal use only.
Definition: BOpcodeHandler.h:1086
TK_Status Interpret(BStreamFileToolkit &tk, ID_Key key, char const *special)
Definition: BOpcodeHandler.h:915
TK_Area_Light()
Definition: BOpcodeHandler.h:5882
int m_simple_reflection_visibility_mask
For internal use only.
Definition: BOpcodeHandler.h:2557
TK_Cylinder()
Definition: BOpcodeHandler.h:6429
int GetColorMarkerContrastLockValue() const
Definition: BOpcodeHandler.h:3037
float const * GetMirror() const
Definition: BOpcodeHandler.h:1835
Handles the TKE_Geometry_Attributes opcode.
Definition: BOpcodeHandler.h:1553
int m_length
Definition: BOpcodeHandler.h:8033
unsigned char m_optionals
Definition: BOpcodeHandler.h:5615
int m_gooch_color_map_segment_length
Definition: BOpcodeHandler.h:2527
format mask
Definition: BOpcodeEnums.h:1409
Handles the TKE_Sphere opcode.
Definition: BOpcodeHandler.h:6298
channel m_emission
internal use
Definition: BOpcodeHandler.h:1739
static TK_Status GetData(BStreamFileToolkit &tk, double &d)
Definition: BOpcodeHandler.h:326
float m_curve_max_deviation
For internal use only.
Definition: BOpcodeHandler.h:2512
int m_name_length
Definition: BOpcodeHandler.h:7165
void SetRef2(float const r[])
Definition: BOpcodeHandler.h:6682
float const * GetSpecular() const
Definition: BOpcodeHandler.h:1820
void SetOptions(int o)
Definition: BOpcodeHandler.h:7716
TK_User_Index()
Definition: BOpcodeHandler.h:4799
unsigned char m_renderer_cutoff_units
for internal use only
Definition: BOpcodeHandler.h:5170
float const * GetMajor() const
Definition: BOpcodeHandler.h:6242
short m_options
Definition: BOpcodeHandler.h:4657
Handles the TKE_User_Index opcode.
Definition: BOpcodeHandler.h:4788
short color_simple_reflection_value
For internal use only.
Definition: BOpcodeHandler.h:1093
void SetCutGeometryEdgeWeight(float value, int units=TKO_Generic_Size_Unspecified)
Definition: BOpcodeHandler.h:3760
int GetOptions() const
Definition: BOpcodeHandler.h:5671
short color_window_contrast_mask
For internal use only.
Definition: BOpcodeHandler.h:1076
unsigned char m_num_levels
For internal use only.
Definition: BOpcodeHandler.h:2492
TK_Renumber(unsigned char opcode, ID_Key key=0)
Definition: BOpcodeHandler.h:1587
double * GetDPoints()
Definition: BOpcodeHandler.h:5656
void SetExtraSpaceUnits(int u)
Definition: BOpcodeHandler.h:5277
void SetDPosition(double x, double y, double z)
Definition: BOpcodeHandler.h:7119
int m_mask
internal use
Definition: BOpcodeHandler.h:2070
float const * GetBaseColorFactor() const
Definition: BOpcodeHandler.h:2313
double const * GetDStart() const
Definition: BOpcodeHandler.h:6473
float m_tolerance
For internal use only.
Definition: BOpcodeHandler.h:2494
Definition: BStream.h:302
void SetGreekingMode(int m)
Definition: BOpcodeHandler.h:5302
mask of bits requiring extended
Definition: BOpcodeEnums.h:827
//// Default reader provided for "W3D Image XRef"
Definition: BOpcodeEnums.h:156
double const * GetDEnd() const
Definition: BOpcodeHandler.h:6475
int m_data_size
Definition: BOpcodeHandler.h:7036
int GetCutGeometry() const
Definition: BOpcodeHandler.h:3742
unsigned char vertical_offset_units
specified with enum TKO_Font_Size_Units
Definition: BOpcodeHandler.h:6756
int m_name_length
Definition: BOpcodeHandler.h:8075
void SetColorMarkerContrastLockValue(int v)
Definition: BOpcodeHandler.h:3032
int GetOptions() const
Definition: BOpcodeHandler.h:4693
static TK_Status GetData(BStreamFileToolkit &tk, unsigned short *s, int n)
Definition: BOpcodeHandler.h:299
void SetDMatrix(double const m[])
Definition: BOpcodeHandler.h:4438
unsigned char m_options
Definition: BOpcodeHandler.h:6776
Definition: BOpcodeHandler.h:830
char * m_condition
Definition: BOpcodeHandler.h:1295
Handles the TKE_Image opcode.
Definition: BOpcodeHandler.h:7028
void SetPlane(float const p[])
Definition: BOpcodeHandler.h:6050
int GetSimpleShadowBlur() const
Definition: BOpcodeHandler.h:3796
void SetInternalPolylineSelectionLimit(int i)
Definition: BOpcodeHandler.h:4039
float * GetPoints()
Definition: BOpcodeHandler.h:7763
Handles the TKE_Font opcode.
Definition: BOpcodeHandler.h:6907
virtual TK_Status Read(BStreamFileToolkit &tk)=0
void SetName(char const *string)
Definition: BOpcodeHandler.h:8096
Handles the TKE_Unicode_Options opcode.
Definition: BOpcodeHandler.h:4750
int * GetIndices()
Definition: BOpcodeHandler.h:4822
void SetView(int length)
Definition: BOpcodeHandler.h:5075
int GetShadowMap() const
Definition: BOpcodeHandler.h:3843
Internal_Translator::Index_Key_Pair * m_item
internal use; cache lookup in Pending cases
Definition: BOpcodeHandler.h:1644
unsigned char * GetTextLeaderFlags()
Definition: BOpcodeHandler.h:6882
float m_inner
for internal use only
Definition: BOpcodeHandler.h:5938
TK_Status Read(BStreamFileToolkit &)
Definition: BOpcodeHandler.h:1103
float * m_weights
Definition: BOpcodeHandler.h:5621
void SetCenter(float const c[])
Definition: BOpcodeHandler.h:6130
int GetCutGeometryEdgeWeightUnits() const
Definition: BOpcodeHandler.h:3767
void SetCutGeometryColorMatch(int m)
Definition: BOpcodeHandler.h:3750
void SetPoints(int count, float const points[]=0)
Definition: BOpcodeHandler.h:5899
void SetDCenter(double const s[])
Definition: BOpcodeHandler.h:6367
void SetDTarget(double x, double y, double z)
Definition: BOpcodeHandler.h:5979
int const * GetIndices() const
Definition: BOpcodeHandler.h:4820
int GetInternalShellSelectionLimit() const
Definition: BOpcodeHandler.h:4036
void SetProjection(int p)
Definition: BOpcodeHandler.h:5067
int GetAlphaMapping() const
Definition: BOpcodeHandler.h:7292
Handles the TKE_File_Info opcode.
Definition: BOpcodeHandler.h:901
TK_Status PutOpcode(BStreamFileToolkit &tk, int adjust=1)
Definition: BOpcodeHandler.h:474
BBaseOpcodeHandler * m_current_object
internal use
Definition: BOpcodeHandler.h:875
float m_end
Definition: BOpcodeHandler.h:5624
double const * GetDPosition() const
Definition: BOpcodeHandler.h:6839
Handles the TKE_Color opcode.
Definition: BOpcodeHandler.h:1713
double * GetDPoints()
Definition: BOpcodeHandler.h:5913
void SetColorWindowLockValue(int v)
Definition: BOpcodeHandler.h:2871
Handles the TKE_Heuristics opcode.
Definition: BOpcodeHandler.h:3965
int m_value
specifies what values to set for boolean options. For internal use only.
Definition: BOpcodeHandler.h:5142
Definition: BOpcodeHandler.h:1056
double const * GetDCenter() const
Definition: BOpcodeHandler.h:6369
void SetSimpleShadowLight(float x, float y, float z)
Definition: BOpcodeHandler.h:3804
unsigned char m_simple_shadow_blur
For internal use only.
Definition: BOpcodeHandler.h:2540
char m_decimation
Definition: BOpcodeHandler.h:7174
void SetTessellationMask(int m)
Definition: BOpcodeHandler.h:3685
void SetFormat(int f)
Definition: BOpcodeHandler.h:7392
int GetSimpleReflectionVisibilityValue() const
Definition: BOpcodeHandler.h:3881
char m_threshold_type
For internal use only.
Definition: BOpcodeHandler.h:2489
Handles the TKE_Circle, TKE_Circular_Arc, TKE_Circular_Chord and TKE_Circular_Wedge opcodes...
Definition: BOpcodeHandler.h:6077
int GetForcedLockMask() const
Definition: BOpcodeHandler.h:3091
int GetColorWindowContrastLockMask() const
Definition: BOpcodeHandler.h:2911
int GetBlueMapping() const
Definition: BOpcodeHandler.h:7287
int const * GetSize() const
Definition: BOpcodeHandler.h:7131
int * GetIndices()
Definition: BOpcodeHandler.h:4875
void SetHlrLinePattern(int p)
Definition: BOpcodeHandler.h:3535
short color_window_contrast_value
For internal use only.
Definition: BOpcodeHandler.h:1077
int GetColorEdgeForcedLockMask() const
Definition: BOpcodeHandler.h:3176
void SetSlant(float s)
Definition: BOpcodeHandler.h:5262
void SetViewVolume(float const v[])
Definition: BOpcodeHandler.h:4111
void SetVectorTolerance(float tol)
Definition: BOpcodeHandler.h:4093
void SetVisibilityForcedLockMask(int m)
Definition: BOpcodeHandler.h:3102
int GetCount() const
Definition: BOpcodeHandler.h:7712
char * GetName()
Definition: BOpcodeHandler.h:7099
char * GetMetalnessMap()
Definition: BOpcodeHandler.h:2280
float GetSlant() const
Definition: BOpcodeHandler.h:5264
void SetSimpleShadowLight(float const l[])
Definition: BOpcodeHandler.h:3810
void set_points(int count, float const points[]=0)
Definition: BOpcodeHandler.h:5560
double * m_dleaders
Definition: BOpcodeHandler.h:6788
void SetDPosition(double const p[])
Definition: BOpcodeHandler.h:5966
int GetColorBackForcedLockMask() const
Definition: BOpcodeHandler.h:3337
short color_face_contrast_mask
For internal use only.
Definition: BOpcodeHandler.h:1074
Definition: BStream.h:276
TK_Bounding(unsigned char opcode)
Definition: BOpcodeHandler.h:5387
int GetWhenInvisible() const
Definition: BOpcodeHandler.h:4406
void SetBaseColorFactor(float const rgba[])
Definition: BOpcodeHandler.h:2310
TK_Compression(char opcode)
Definition: BOpcodeHandler.h:1038
void SetColorFaceContrastForcedLockMask(int m)
Definition: BOpcodeHandler.h:3286
Definition: BOpcodeHandler.h:4516
float * GetPoints()
Definition: BOpcodeHandler.h:5756
float m_rotation
for internal use only
Definition: BOpcodeHandler.h:5147
char * GetNames()
Definition: BOpcodeHandler.h:5216
unsigned char m_greeking_units
for internal use only
Definition: BOpcodeHandler.h:5167
TK_Size(unsigned char opcode)
Definition: BOpcodeHandler.h:4491
int GetWriteFlags(int mask=~0) const
Definition: BStreamFileToolkit.h:933
void SetIndices(int count, int const indices[], void const *values[], int const sizes[])
Definition: BOpcodeHandler.h:4861
TK_XML()
Definition: BOpcodeHandler.h:7914
void SetLodClamp(int v)
Definition: BOpcodeHandler.h:3595
static TK_Status PutData(BStreamFileToolkit &tk, unsigned int const &i)
Definition: BOpcodeHandler.h:465
void SetFogLimits(float n, float f)
Definition: BOpcodeHandler.h:2678
void SetQuantization(int q)
Definition: BOpcodeHandler.h:2648
double const * GetDMiddle() const
Definition: BOpcodeHandler.h:6192
char m_lod_algorithm
For internal use only.
Definition: BOpcodeHandler.h:2484
void SetMirrorName(char const *name)
Definition: BOpcodeHandler.h:1831
char * m_cut_geometry_edge_pattern
for internal use only.
Definition: BOpcodeHandler.h:2536
Handles the TKE_URL opcodes.
Definition: BOpcodeHandler.h:7953
Handles the TKE_Area_Light opcode.
Definition: BOpcodeHandler.h:5870
int GetMask() const
Definition: BOpcodeHandler.h:5202
float const * GetImageScale() const
Definition: BOpcodeHandler.h:3925
void SetOrigin(float const o[])
Definition: BOpcodeHandler.h:6660
void SetSimpleReflectionOpacity(float o)
Definition: BOpcodeHandler.h:3874
void SetMetalnessMap(char const *name)
Definition: BOpcodeHandler.h:2274
int GetIndex()
Definition: BOpcodeHandler.h:1496
char * GetShaderSource()
Definition: BOpcodeHandler.h:7230
double const * GetDRef2() const
Definition: BOpcodeHandler.h:6718
void SetNURBSSurfaceTrimBudget(int b)
Definition: BOpcodeHandler.h:3569
int GetVertexDisplacement() const
Definition: BOpcodeHandler.h:2665
unsigned char * GetDTextLeaderFlags()
Definition: BOpcodeHandler.h:6895
Handles the TKE_Cutting_Plane opcode.
Definition: BOpcodeHandler.h:6014
float const * GetPosition() const
Definition: BOpcodeHandler.h:4971
int GetColorLineLockValue() const
Definition: BOpcodeHandler.h:2807
float * GetUKnots()
Definition: BOpcodeHandler.h:5845
void SetSelectionLevel(int l)
Definition: BOpcodeHandler.h:4131
int GetRedMapping() const
Definition: BOpcodeHandler.h:7277
int GetDisplayListLevel() const
Definition: BOpcodeHandler.h:3782
virtual TK_Status Interpret(BStreamFileToolkit &tk, ID_Key key, int variant=0)
int GetColorVertexContrastLockMask() const
Definition: BOpcodeHandler.h:3049
bool IsCollectionPart() const
Definition: BOpcodeHandler.h:209
void SetDPosition(double const p[])
Definition: BOpcodeHandler.h:4979
int GetOptions() const
Definition: BOpcodeHandler.h:7796
void SetLodThresholdType(int v)
Definition: BOpcodeHandler.h:3644
char * GetBaseColorMap()
Definition: BOpcodeHandler.h:2253
self-explanatory
Definition: BOpcodeEnums.h:270
void SetName(int length)
Definition: BOpcodeHandler.h:7217
TK_Callback()
Definition: BOpcodeHandler.h:2380
int const * GetPreferences() const
Definition: BOpcodeHandler.h:5336
float const * GetKnots() const
Definition: BOpcodeHandler.h:5662
TK_Complex_Clip_Region()
Definition: BOpcodeHandler.h:7741
void SetBlueMapping(int p)
Definition: BOpcodeHandler.h:7285
int GetParameterOffset() const
Definition: BOpcodeHandler.h:7322
Handles the TKE_Named_Style_Def opcode.
Definition: BOpcodeHandler.h:7504
int GetCoordinateSystemCount() const
Definition: BOpcodeHandler.h:4219
double * GetDRef1()
Definition: BOpcodeHandler.h:6709
void **const GetValues() const
Definition: BOpcodeHandler.h:4878
int GetLodOptionsValue() const
Definition: BOpcodeHandler.h:3581
int GetColorVertexContrastForcedLockValue() const
Definition: BOpcodeHandler.h:3463
float m_surface_max_facet_deviation
For internal use only.
Definition: BOpcodeHandler.h:2509
int GetTargetVersion() const
Definition: BStreamFileToolkit.h:986
int m_allocated
internal use
Definition: BOpcodeHandler.h:944
float const * GetRef1() const
Definition: BOpcodeHandler.h:6673
float GetRendererCutoff() const
Definition: BOpcodeHandler.h:5320
float GetLodTolerance() const
Definition: BOpcodeHandler.h:3605
float m_greeking_limit
for internal use only
Definition: BOpcodeHandler.h:5152
//– would like this to be obsolete, but...
Definition: BOpcodeEnums.h:152
int GetColorBackLockMask() const
Definition: BOpcodeHandler.h:2934
int GetColorFaceContrastLockMask() const
Definition: BOpcodeHandler.h:2888
float GetVectorTolerance() const
Definition: BOpcodeHandler.h:4091
float const * GetEndNormal(int index) const
Definition: BOpcodeHandler.h:6619
void SetField(float const f[])
Definition: BOpcodeHandler.h:5028
int GetIndex() const
Definition: BOpcodeHandler.h:1275
void SetBytes(int size, char const *bytes=0, unsigned char data_format=TKO_Compression_None)
Definition: BOpcodeHandler.h:7084
char const * GetConditions() const
Definition: BOpcodeHandler.h:4639
unsigned short const * GetOptions() const
Definition: BOpcodeHandler.h:4774
void SetIndex(float i)
Definition: BOpcodeHandler.h:1894
char * GetConditions()
Definition: BOpcodeHandler.h:4641
void SetMatrix(float const m[])
Definition: BOpcodeHandler.h:4434
self-explanatory
Definition: BOpcodeEnums.h:1140
Handles the TKE_Renumber_Key_Global, TKE_Renumber_Key_Local, and TKE_Priority opcodes.
Definition: BOpcodeHandler.h:1579
float slant
the angle (in degrees) that text is slanted (e.g. for italic). Positive numbers correspond to clockwi...
Definition: BOpcodeHandler.h:6748
Handles the TKE_Complex_Clip_Region opcodes.
Definition: BOpcodeHandler.h:7730
void SetShadowMapSamples(int m)
Definition: BOpcodeHandler.h:3851
void SetOptions(int o)
Definition: BOpcodeHandler.h:5479
char * m_string
Definition: BOpcodeHandler.h:7996
short color_back_value
For internal use only.
Definition: BOpcodeHandler.h:1079
unsigned char m_present
internal use
Definition: BOpcodeHandler.h:1641
void SetRoughnessMapChannel(int c)
Definition: BOpcodeHandler.h:2347
void SetDecimation(int p)
Definition: BOpcodeHandler.h:7270
void SetName(int length)
Definition: BOpcodeHandler.h:7095
void SetName(char const *string)
Definition: BOpcodeHandler.h:6964
char const * GetDefinition() const
Definition: BOpcodeHandler.h:7611
int GetInterpolation() const
Definition: BOpcodeHandler.h:7267
void SetCutVisualizationAlpha(float a)
Definition: BOpcodeHandler.h:4245
unsigned char m_preference_cutoff_units
for internal use only
Definition: BOpcodeHandler.h:5171
char const * GetCallback() const
Definition: BOpcodeHandler.h:2397
TK_User_Options()
Definition: BOpcodeHandler.h:4717
unsigned char m_region_fit
Definition: BOpcodeHandler.h:6778
double * m_dpoints
Definition: BOpcodeHandler.h:5557
int m_selection_culling
internal use; selection culling options
Definition: BOpcodeHandler.h:3976
float m_line_spacing
for internal use only
Definition: BOpcodeHandler.h:5151
TK_Color_By_FIndex()
Definition: BOpcodeHandler.h:2075
char * GetName()
Definition: BOpcodeHandler.h:7545
int m_coordinate_system_count
internal use
Definition: BOpcodeHandler.h:4164
float rotation
the angle (in degrees) that text is rotated
Definition: BOpcodeHandler.h:6749
void SetField(float w, float h)
Definition: BOpcodeHandler.h:5026
int GetCount() const
Definition: BOpcodeHandler.h:4869
int m_down
internal use; specifies what geometry is selectable on mouse button down. For internal use only...
Definition: BOpcodeHandler.h:4320
unsigned short * GetOptions()
Definition: BOpcodeHandler.h:4776
char * GetCallback()
Definition: BOpcodeHandler.h:2399
float const * GetVector() const
Definition: BOpcodeHandler.h:4081
void SetPosition(float x, float y, float z)
Definition: BOpcodeHandler.h:6826
int GetSize() const
Definition: BOpcodeHandler.h:1696
int GetDown() const
Definition: BOpcodeHandler.h:4362
bool Find_Item(BStreamFileToolkit &tk, ID_Key key) const
Definition: BOpcodeHandler.h:687
void SetHardExtent(int c)
Definition: BOpcodeHandler.h:4077
char const * GetSphereTessellations() const
Definition: BOpcodeHandler.h:3719
static void fix_in(float *f, int n)
for internal use only
Definition: BOpcodeHandler.h:560
float m_rgb[3]
The RGB value of the color for this channel.
Definition: BOpcodeHandler.h:1723
int GetGeometry() const
Definition: BOpcodeHandler.h:4294
TK_Spot_Light()
Definition: BOpcodeHandler.h:5944
void SetImageTintColor(float const rgb[])
Definition: BOpcodeHandler.h:3932
void SetOuter(float o)
Definition: BOpcodeHandler.h:5987
void SetSize(int size)
Definition: BOpcodeHandler.h:1694
void SetVector(float x, float y, float z)
Definition: BOpcodeHandler.h:4083
float GetHlrDimFactor() const
Definition: BOpcodeHandler.h:3529
float m_compression_quality
Definition: BOpcodeHandler.h:7046
void SetPosition(float const p[])
Definition: BOpcodeHandler.h:6829
short color_face_mask
For internal use only.
Definition: BOpcodeHandler.h:1062
void SetParameterFunction(int p)
Definition: BOpcodeHandler.h:7295
BBaseOpcodeHandler *** m_primitives
for each level, an array of opcode handler pointers that store the primitives
Definition: BOpcodeHandler.h:1510
void SetUpVector(float x, float y, float z)
Definition: BOpcodeHandler.h:5006
int m_camera_length
Definition: BOpcodeHandler.h:7168
int m_to_variant
internal use
Definition: BOpcodeHandler.h:1455
Handles the TKE_XML opcode.
Definition: BOpcodeHandler.h:7907
double const * GetDPosition() const
Definition: BOpcodeHandler.h:7124
ID_Key remove_segment(BStreamFileToolkit &tk)
for internal use only
Definition: BOpcodeHandler.h:646
TK_Terminator(char opcode, bool is_file_terminator=true)
Definition: BOpcodeHandler.h:1009
extended bit
Definition: BOpcodeEnums.h:273
short color_line_contrast_mask
For internal use only.
Definition: BOpcodeHandler.h:1084
char * m_bytes
Definition: BOpcodeHandler.h:7030
Handles the TKE_External_Reference opcodes.
Definition: BOpcodeHandler.h:7992
Definition: BOpcodeHandler.h:4457
TK_Material()
Definition: BOpcodeHandler.h:7889
int GetSimpleReflection() const
Definition: BOpcodeHandler.h:3859
virtual TK_Status Error(char const *msg=0) const
int m_allocated
Definition: BOpcodeHandler.h:5555
TK_Bounding(unsigned char opcode, float center[], float radius)
Definition: BOpcodeHandler.h:5396
unsigned short m_simple_shadow
For internal use only.
Definition: BOpcodeHandler.h:2539
void SetFlags(int f)
Definition: BOpcodeHandler.h:7251
int const * GetStringCursors() const
Definition: BOpcodeHandler.h:6867
void SetGeometry(int m)
Definition: BOpcodeHandler.h:1926
char * GetName()
Definition: BOpcodeHandler.h:7221
void SetColorForcedLockValue(int v)
Definition: BOpcodeHandler.h:3136
Handles the TKE_Repeat_Object opcode.
Definition: BOpcodeHandler.h:1450
void SetCutGeometryTolerance(float m)
Definition: BOpcodeHandler.h:3755
void SetHSR(int h)
Definition: BOpcodeHandler.h:2628
int GetLength()
Definition: BOpcodeHandler.h:4643
float GetOcclusionFactor() const
Definition: BOpcodeHandler.h:2333
void SetName(char const *string)
Definition: BOpcodeHandler.h:7093
unsigned char m_cut_geometry_edge_weight_units
for internal use only.
Definition: BOpcodeHandler.h:2535
char * m_string
Definition: BOpcodeHandler.h:2371
int GetSimpleShadow() const
Definition: BOpcodeHandler.h:3791
void SetLodCutoffs(int c, float const r[]=0)
Definition: BOpcodeHandler.h:3668
int m_count
Definition: BOpcodeHandler.h:5554
int const * GetSizes() const
Definition: BOpcodeHandler.h:4884
char * GetSphereTessellations()
Definition: BOpcodeHandler.h:3721
int GetColorMarkerForcedLockMask() const
Definition: BOpcodeHandler.h:3222
void SetNext(HT_NURBS_Trim *next)
Definition: BOpcodeHandler.h:5733
for further expansion
Definition: BOpcodeEnums.h:1171
char m_num_cutoffs
For internal use only.
Definition: BOpcodeHandler.h:2496
void Remember_Item(BStreamFileToolkit &tk, ID_Key key) const
Definition: BOpcodeHandler.h:685
int m_debug_length
Definition: BOpcodeHandler.h:70
void SetGeometry(int m)
Definition: BOpcodeHandler.h:1979
Handles the TKE_NURBS_Curve opcode.
Definition: BOpcodeHandler.h:5613
void SetDiffuseTextureTintColor(float r, float g, float b)
Definition: BOpcodeHandler.h:3937
char const * GetName(void) const
Definition: BOpcodeHandler.h:8100
int GetEncoding() const
Definition: BOpcodeHandler.h:6844
void SetScreenRange(float l, float r, float b, float t, float lo=0, float ro=0, float bo=0, float to=0)
Definition: BOpcodeHandler.h:3893
Handles the TKE_Conditions opcode.
Definition: BOpcodeHandler.h:4615
int GetInternalSelectionLimit() const
Definition: BOpcodeHandler.h:4031
float m_surface_max_facet_width
For internal use only.
Definition: BOpcodeHandler.h:2510
char m_blue_mapping
Definition: BOpcodeHandler.h:7177
float * m_points
Definition: BOpcodeHandler.h:6514
void SetLodCutoff(float r)
Definition: BOpcodeHandler.h:3666
unsigned char m_optionals
Definition: BOpcodeHandler.h:5788
int GetColorTextContrastForcedLockMask() const
Definition: BOpcodeHandler.h:3475
unsigned char m_shadow_map_samples
For internal use only.
Definition: BOpcodeHandler.h:2549
int GetTextRegionOptions() const
Definition: BOpcodeHandler.h:6857
double const * GetDMajor() const
Definition: BOpcodeHandler.h:6270
int m_value
internal use; specifies what values to set for boolean options. For internal use only.
Definition: BOpcodeHandler.h:4265
void SetUserData(int size, unsigned char const *bytes=0)
Definition: BOpcodeHandler.h:7848
void SetNames(char const *names)
Definition: BOpcodeHandler.h:5210
void SetDPoints(double x1, double y1, double z1, double x2, double y2, double z2)
Definition: BOpcodeHandler.h:5527
char * m_names
for internal use only
Definition: BOpcodeHandler.h:5144
void SetList(HT_NURBS_Trim *node)
Definition: BOpcodeHandler.h:5732
void SetLodNumLevels(int v)
Definition: BOpcodeHandler.h:3591
int GetGeometry() const
Definition: BOpcodeHandler.h:2054
TK_Dictionary_Locater()
Definition: BOpcodeHandler.h:1679
env map
Definition: BOpcodeEnums.h:274
int GetInternalPolylineSelectionLimit() const
Definition: BOpcodeHandler.h:4041
static TK_Status GetData(BStreamFileToolkit &tk, int &i)
Definition: BOpcodeHandler.h:311
float const * GetMatrix() const
Definition: BOpcodeHandler.h:4442
////
Definition: BOpcodeEnums.h:149
int m_index
Definition: BOpcodeHandler.h:1384
int m_dleader_count
Definition: BOpcodeHandler.h:6787
float size
the size. Units are specified separately in size_units
Definition: BOpcodeHandler.h:6745
bool Tagging(BStreamFileToolkit &tk) const
Definition: BOpcodeHandler.h:187
void SetHlrDimFactor(float d)
Definition: BOpcodeHandler.h:3527
TK_Enumerated(unsigned char opcode)
Definition: BOpcodeHandler.h:4463
unsigned char m_buffer_options_value
For internal use only.
Definition: BOpcodeHandler.h:2446
int * GetCounts()
Definition: BOpcodeHandler.h:6730
float m_hlr_threshold
for internal use only.
Definition: BOpcodeHandler.h:2457
float * GetRadii()
Definition: BOpcodeHandler.h:6567
char const * GetXML() const
Definition: BOpcodeHandler.h:7937
int m_offset
internal use
Definition: BOpcodeHandler.h:1675
void SetStart(float const s[])
Definition: BOpcodeHandler.h:6105
char m_alpha_mapping
Definition: BOpcodeHandler.h:7178
void SetNormalMap(char const *name)
Definition: BOpcodeHandler.h:2256
unsigned char m_buffer_options_mask
For internal use only.
Definition: BOpcodeHandler.h:2445
void SetBufferOptionsValue(int v)
Definition: BOpcodeHandler.h:3496
static TK_Status PutData(BStreamFileToolkit &tk, unsigned short const *s, int n)
Definition: BOpcodeHandler.h:444
float GetInner() const
Definition: BOpcodeHandler.h:5994
float m_renderer_cutoff
for internal use only
Definition: BOpcodeHandler.h:5153
char * GetStyle()
Definition: BOpcodeHandler.h:5234
int m_mask
internal use; specifies which visibility settings are active (and hence, which are valid)...
Definition: BOpcodeHandler.h:4264
void SetColorLineForcedLockValue(int v)
Definition: BOpcodeHandler.h:3205
char * m_comment
internal use
Definition: BOpcodeHandler.h:946
int GetSelectionCulling() const
Definition: BOpcodeHandler.h:4055
float * m_points
Definition: BOpcodeHandler.h:7670
double * m_dplanes
internal use
Definition: BOpcodeHandler.h:6017
char const * GetCylinderTessellations() const
Definition: BOpcodeHandler.h:3702
int GetExtras() const
Definition: BOpcodeHandler.h:4046
unsigned char m_greeking_mode
for internal use only
Definition: BOpcodeHandler.h:5168
static short flip(short s)
for internal use only
Definition: BOpcodeHandler.h:506
int GetFaceDisplacement() const
Definition: BOpcodeHandler.h:2660
float GetEnd() const
Definition: BOpcodeHandler.h:5668
TK_Polypoint(unsigned char opcode)
Definition: BOpcodeHandler.h:5565
void SetDepthRange(float const l[])
Definition: BOpcodeHandler.h:3887
void SetSpecularName(int length)
Definition: BOpcodeHandler.h:1818
char * GetEmissiveMap()
Definition: BOpcodeHandler.h:2271
int GetLoops() const
Definition: BOpcodeHandler.h:7790
float m_simple_reflection_opacity
For internal use only.
Definition: BOpcodeHandler.h:2553
channel m_environment
internal use; note: environment & bump are never a simple RGB type color
Definition: BOpcodeHandler.h:1740
void SetRadius(float r)
Definition: BOpcodeHandler.h:6456
short color_text_value
For internal use only.
Definition: BOpcodeHandler.h:1071
void SetOffset(int offset)
Definition: BOpcodeHandler.h:1698
void SetPreference(int r)
Definition: BOpcodeHandler.h:5329
int m_maximum_extent
internal use; maximum extent
Definition: BOpcodeHandler.h:3979
int GetSelectionBias() const
Definition: BOpcodeHandler.h:4059
unsigned char m_clamp
For internal use only.
Definition: BOpcodeHandler.h:2491
int GetValue() const
Definition: BOpcodeHandler.h:4305
bool GetFollow()
Definition: BOpcodeHandler.h:1436
void SetColorWindowContrastForcedLockValue(int v)
Definition: BOpcodeHandler.h:3320
float * GetKnots()
Definition: BOpcodeHandler.h:5663
char const * GetName() const
Definition: BOpcodeHandler.h:7483
void SetVisibilityForcedLockValue(int v)
Definition: BOpcodeHandler.h:3113
float const * GetOrientation() const
Definition: BOpcodeHandler.h:4209
int GetQuantization() const
Definition: BOpcodeHandler.h:2650
char * GetTransmissionName()
Definition: BOpcodeHandler.h:1854
void SetColorTextContrastForcedLockValue(int v)
Definition: BOpcodeHandler.h:3481
TK_User_Value()
Definition: BOpcodeHandler.h:4903
int m_cond_length
Definition: BOpcodeHandler.h:7512
void SetColorVertexLockMask(int m)
Definition: BOpcodeHandler.h:2952
char * GetCondition()
Definition: BOpcodeHandler.h:4682
int GetColorVertexContrastForcedLockMask() const
Definition: BOpcodeHandler.h:3452
int * GetSizes()
Definition: BOpcodeHandler.h:4887
void SetLodBounding(float const p[])
Definition: BOpcodeHandler.h:3621
//// pseudo-handler (non-zero value)
Definition: BOpcodeEnums.h:158
void SetValue(HLONG v)
Definition: BOpcodeHandler.h:4914
int const * GetLengths() const
Definition: BOpcodeHandler.h:7782
char * GetLookup()
Definition: BOpcodeHandler.h:6979
float const * GetPoints() const
Definition: BOpcodeHandler.h:5524
void SetColorEdgeForcedLockMask(int m)
Definition: BOpcodeHandler.h:3171
int m_count
Definition: BOpcodeHandler.h:7669
void SetLimits(float s, float e)
Definition: BOpcodeHandler.h:6282
void SetIndices(int count, int const indices[], POINTER_SIZED_INT const values[])
Definition: BOpcodeHandler.h:4813
unsigned char m_flags
Definition: BOpcodeHandler.h:6519
int GetAction() const
Definition: BOpcodeHandler.h:4689
float GetSimpleShadowOpacity() const
Definition: BOpcodeHandler.h:3837
void SetDMiddle(double x, double y, double z)
Definition: BOpcodeHandler.h:6158
void GetField(float f[]) const
Definition: BOpcodeHandler.h:5032
void SetRelatedSelectionLimit(int r)
Definition: BOpcodeHandler.h:4024
TK_Geometry_Attributes()
Definition: BOpcodeHandler.h:1558
int GetMaximumExtent() const
Definition: BOpcodeHandler.h:4067
Handles the TKE_Clip_Rectangle opcode.
Definition: BOpcodeHandler.h:7624
void SetLockValue(int v)
Definition: BOpcodeHandler.h:2691
void SetMaximumExtent(int c)
Definition: BOpcodeHandler.h:4065
unsigned char m_fallback
For internal use only.
Definition: BOpcodeHandler.h:2499
unsigned char m_compression
Definition: BOpcodeHandler.h:7041
char const * GetCondition() const
Definition: BOpcodeHandler.h:1357
Handles the TKE_Text_Font opcode.
Definition: BOpcodeHandler.h:5139
int GetLodOptionsMask() const
Definition: BOpcodeHandler.h:3577
struct vlist_s * m_current_working
holds the geometry list in progress. struct vlist_s the incomplete type for vlist_t (used until vlist...
Definition: BOpcodeHandler.h:1514
int m_flags
internal use
Definition: BOpcodeHandler.h:904
void SetDiffuse(float r, float g, float b)
Definition: BOpcodeHandler.h:1797
bool m_needs_tag
Indicate if this object explicitly needs tagging.
Definition: BOpcodeHandler.h:67
int GetColorFaceLockValue() const
Definition: BOpcodeHandler.h:2761
char const * GetDiffuseName() const
Definition: BOpcodeHandler.h:1807
void SetMajor(float x, float y, float z)
Definition: BOpcodeHandler.h:6236
static TK_Status GetData(BStreamFileToolkit &tk, double *d, int n)
Definition: BOpcodeHandler.h:288
float const * GetOrderedWeights() const
Definition: BOpcodeHandler.h:4126
HLONG * m_values
for internal use only
Definition: BOpcodeHandler.h:4792
int GetOptions() const
Definition: BOpcodeHandler.h:7141
static TK_Status PutData(BStreamFileToolkit &tk, double const &d)
Definition: BOpcodeHandler.h:471
float const * GetValueScale() const
Definition: BOpcodeHandler.h:7312
Handles the TKE_User_Index opcode.
Definition: BOpcodeHandler.h:4836
int m_size
Definition: BOpcodeHandler.h:7409
unsigned char * m_isoline_weights_unit
for internal use only.
Definition: BOpcodeHandler.h:2475
float const * GetValues() const
Definition: BOpcodeHandler.h:2157
void SetCollectionPart(bool n)
Definition: BOpcodeHandler.h:204
int GetParameterSource() const
Definition: BOpcodeHandler.h:7262
void floats_to_bytes(float const *in, unsigned char *out, int count) const
for internal use only
Definition: BOpcodeHandler.h:632
double GetDRadius() const
Definition: BOpcodeHandler.h:6480
void SetBytes(int size, char const *bytes=0)
Definition: BOpcodeHandler.h:6955
float * GetVKnots()
Definition: BOpcodeHandler.h:5849
BBaseOpcodeHandler(int op)
Definition: BOpcodeHandler.h:92
char const * GetOptions() const
Definition: BOpcodeHandler.h:4735
Definition: BOpcodeHandler.h:4484
float const * GetImageTintColor() const
Definition: BOpcodeHandler.h:3934
int m_name_length
Definition: BOpcodeHandler.h:7457
char * GetOcclusionMap()
Definition: BOpcodeHandler.h:2298
char const * GetCutGeometryEdgePattern() const
Definition: BOpcodeHandler.h:3774
double const * GetDPlanes() const
Definition: BOpcodeHandler.h:6062
unsigned char * m_leader_flags
Definition: BOpcodeHandler.h:6786
Handles the TKE_Dictionary opcode.
Definition: BOpcodeHandler.h:1637
float * GetLodRatios()
Definition: BOpcodeHandler.h:3641
void SetValue(int v)
Definition: BOpcodeHandler.h:5205
float const * GetPosition() const
Definition: BOpcodeHandler.h:6831
float const * GetTransmission() const
Definition: BOpcodeHandler.h:1850
int GetCaps() const
Definition: BOpcodeHandler.h:6486
int GetColorEdgeLockMask() const
Definition: BOpcodeHandler.h:2773
void SetOrientation(int count, float const o[])
Definition: BOpcodeHandler.h:4199
void reset_string(char *&s)
internal use
Definition: BOpcodeHandler.h:2214
bool GetStreaming() const
Definition: BOpcodeHandler.h:4604
char * GetRoughnessMap()
Definition: BOpcodeHandler.h:2289
void SetLayout(int p)
Definition: BOpcodeHandler.h:7300
char m_param_function
Definition: BOpcodeHandler.h:7179
char * m_definition
Definition: BOpcodeHandler.h:7579
int m_string_length
internal use
Definition: BOpcodeHandler.h:2124
char m_num_cylinder
For internal use only.
Definition: BOpcodeHandler.h:2519
int m_surface_budget
For internal use only.
Definition: BOpcodeHandler.h:2505
ID_Key m_key
for internal use only
Definition: BOpcodeHandler.h:1581
float GetGloss() const
Definition: BOpcodeHandler.h:1892
HT_NURBS_Trim * GetTrims()
Definition: BOpcodeHandler.h:5859
internal use, indicates bits which require TKO_Geo_Extended
Definition: BOpcodeEnums.h:178
float * m_isoline_weights_value
for internal use only.
Definition: BOpcodeHandler.h:2474
short color_cut_edge_mask
For internal use only.
Definition: BOpcodeHandler.h:1096
char const * GetDefinition() const
Definition: BOpcodeHandler.h:7443
int GetVisibilityLockMask() const
Definition: BOpcodeHandler.h:2704
Definition: BStream.h:275
void SetRotation(float r)
Definition: BOpcodeHandler.h:5257
int GetValue(int index=0) const
Definition: BOpcodeHandler.h:2625
int GetBufferOptionsMask() const
Definition: BOpcodeHandler.h:3494
//
Definition: BOpcodeEnums.h:143
float * m_weights
Definition: BOpcodeHandler.h:5793
void SetColorBackLockMask(int m)
Definition: BOpcodeHandler.h:2929
Handles the TKE_Marker, TKE_Text_Path TKE_Distant_Light, and TKE_Local_Light opcodes.
Definition: BOpcodeHandler.h:5433
TK_PolyCylinder()
Definition: BOpcodeHandler.h:6524
void SetRectangle(float left, float right, float bottom, float top)
Definition: BOpcodeHandler.h:7644
void SetUpVector(float const u[])
Definition: BOpcodeHandler.h:5009
unsigned char m_tq
internal use; low half technology, high half quantization. For internal use only. ...
Definition: BOpcodeHandler.h:2435
unsigned char m_general_flags
Basic flags common to many handlers.
Definition: BOpcodeHandler.h:66
char * m_name
Definition: BOpcodeHandler.h:7578
HLONG m_value
for internal use only
Definition: BOpcodeHandler.h:4899
char * GetCondition()
Definition: BOpcodeHandler.h:1362
float const * GetWindow() const
Definition: BOpcodeHandler.h:5121
unsigned char m_type
Definition: BOpcodeHandler.h:6915
void SetDMajor(double const m[])
Definition: BOpcodeHandler.h:6268
void SetScreenRange(float const l[])
Definition: BOpcodeHandler.h:3898
int GetCutGeometryLevel() const
Definition: BOpcodeHandler.h:3747
char * GetName()
Definition: BOpcodeHandler.h:4571
char * GetShape()
Definition: BOpcodeHandler.h:5225
void SetImageScale(float x, float y)
Definition: BOpcodeHandler.h:3921
float const * GetVKnots() const
Definition: BOpcodeHandler.h:5847
void SetStreaming(bool s)
Definition: BOpcodeHandler.h:4602
void SetSpace(int s)
Definition: BOpcodeHandler.h:1997
void SetEnvironmentName(int length)
Definition: BOpcodeHandler.h:1874
int GetCompression() const
Definition: BOpcodeHandler.h:7146
int const * GetRenderers() const
Definition: BOpcodeHandler.h:5315
int m_index
internal use
Definition: BOpcodeHandler.h:2022
void SetRadius(float r)
Definition: BOpcodeHandler.h:6335
HT_NURBS_Trim * m_next
Definition: BOpcodeHandler.h:5705
TK_Open_Segment()
Definition: BOpcodeHandler.h:1183
void SetLodOptionsValue(int v)
Definition: BOpcodeHandler.h:3579
void SetVector(float const v[])
Definition: BOpcodeHandler.h:4089
int GetColorTextLockMask() const
Definition: BOpcodeHandler.h:2842
extended bits for common/shared items
Definition: BOpcodeEnums.h:177
BBaseOpcodeHandler * m_complex
Definition: BOpcodeHandler.h:7672
Definition: BOpcodeHandler.h:1721
double const * GetDStart() const
Definition: BOpcodeHandler.h:6190
void SetMiddle(float x, float y, float z)
Definition: BOpcodeHandler.h:6109
int GetGeometry() const
Definition: BOpcodeHandler.h:1941
int GetRendererCutoffUnits() const
Definition: BOpcodeHandler.h:5325
short m_channels
internal use
Definition: BOpcodeHandler.h:1716
void SetSize(int w, int h)
Definition: BOpcodeHandler.h:7127
self-explanatory
Definition: BOpcodeEnums.h:1260
float m_hlr_transparency_cutoff
For internal use only.
Definition: BOpcodeHandler.h:2452
float m_preference_cutoff
for internal use only
Definition: BOpcodeHandler.h:5154
void SetLodMinimumTriangleCount(int v)
Definition: BOpcodeHandler.h:3587
char * m_condition
Definition: BOpcodeHandler.h:1387
void SetMetalnessMapChannel(int c)
Definition: BOpcodeHandler.h:2342
float m_start
Definition: BOpcodeHandler.h:5623
void SetDOrigin(double const o[])
Definition: BOpcodeHandler.h:6694
TK_Ellipse(unsigned char opcode)
Definition: BOpcodeHandler.h:6216
int GetCount() const
Definition: BOpcodeHandler.h:6594
TK_Heuristics()
Definition: BOpcodeHandler.h:3997
void SetHlrFaceDisplacement(float d)
Definition: BOpcodeHandler.h:3531
void SetPoints(float const s[], float const m[], float const e[], float const c[]=0)
Definition: BOpcodeHandler.h:6135
int GetMaskTransform() const
Definition: BOpcodeHandler.h:3736
int GetColorTextContrastForcedLockValue() const
Definition: BOpcodeHandler.h:3486
char * GetString()
Definition: BOpcodeHandler.h:7981
void SetDStart(double x, double y, double z)
Definition: BOpcodeHandler.h:6150
void SetDiffuseTextureTintColor(float const rgb[])
Definition: BOpcodeHandler.h:3940
void SetEmissiveMap(int length)
Definition: BOpcodeHandler.h:2267
void SetEmission(float const rgb[])
Definition: BOpcodeHandler.h:1859
void SetOptions(int f)
Definition: BOpcodeHandler.h:7139
unsigned char * GetBytes()
Definition: BOpcodeHandler.h:7382
void SetMask(int m)
Definition: BOpcodeHandler.h:4010
void SetConcentration(float c)
Definition: BOpcodeHandler.h:5997
char m_param_source
Definition: BOpcodeHandler.h:7172
float * GetWeights()
Definition: BOpcodeHandler.h:5768
int m_buffer_size
Definition: BOpcodeHandler.h:7823
ID_Key GetKey() const
Definition: BOpcodeHandler.h:1598
static void fix_out(double *d, int n)
for internal use only
Definition: BOpcodeHandler.h:609
void SetColorBackForcedLockValue(int v)
Definition: BOpcodeHandler.h:3343
unsigned short m_simple_shadow_resolution
For internal use only.
Definition: BOpcodeHandler.h:2541
int const * GetCounts() const
Definition: BOpcodeHandler.h:6728
float const * GetEnd() const
Definition: BOpcodeHandler.h:6453
void SetPlane(float a, float b, float c, float d)
Definition: BOpcodeHandler.h:6041
int GetOrderedWeightsMask() const
Definition: BOpcodeHandler.h:4116
void add_segment(BStreamFileToolkit &tk, ID_Key key)
for internal use only
Definition: BOpcodeHandler.h:644
BBaseOpcodeHandler * m_referee
for internal use only
Definition: BOpcodeHandler.h:7517
Lock_Masks m_filter
for internal use only
Definition: BOpcodeHandler.h:1302
void SetColorTextForcedLockMask(int m)
Definition: BOpcodeHandler.h:3240
char * GetName(void)
Definition: BOpcodeHandler.h:8102
void SetForceDefer(int l)
Definition: BOpcodeHandler.h:4141
void SetColorLockMask(int m)
Definition: BOpcodeHandler.h:2722
ID_Key m_renumbered_key
for internal use only
Definition: BOpcodeHandler.h:1298
Handles the TKE_Modelling_Matrix and TKE_Texture_Matrix opcodes.
Definition: BOpcodeHandler.h:4416
void SetWindow(float const w[], float const o[])
Definition: BOpcodeHandler.h:5113
void SetIndex(int i)
Definition: BOpcodeHandler.h:4473
void SetVertexDecimation(float f)
Definition: BOpcodeHandler.h:3950
int GetColorWindowContrastForcedLockMask() const
Definition: BOpcodeHandler.h:3314
void SetDiffuseName(int length)
Definition: BOpcodeHandler.h:1803
void Reset()
internal use
Definition: BOpcodeHandler.h:1728
int m_number_of_items
internal use
Definition: BOpcodeHandler.h:1642
int GetGreenMapping() const
Definition: BOpcodeHandler.h:7282
char * GetCylinderTessellations()
Definition: BOpcodeHandler.h:3704
void SetTarget(float x, float y, float z)
Definition: BOpcodeHandler.h:5971
void SetSphereTessellation(int n)
Definition: BOpcodeHandler.h:3706
void SetColorBackLockValue(int v)
Definition: BOpcodeHandler.h:2940
void SetAction(int at)
Definition: BOpcodeHandler.h:4687
float m_index
internal use
Definition: BOpcodeHandler.h:2071
void SetDAxis(double const s[], double const e[])
Definition: BOpcodeHandler.h:6467
char * GetSegment()
Definition: BOpcodeHandler.h:1214
void SetSize(int const s[])
Definition: BOpcodeHandler.h:7387
void SetColorVertexContrastLockValue(int v)
Definition: BOpcodeHandler.h:3055
int m_general_displacement
For internal use only.
Definition: BOpcodeHandler.h:2575
Handles the TKE_Color_RGB opcode.
Definition: BOpcodeHandler.h:1906
BBaseOpcodeHandler * m_referee
for internal use only
Definition: BOpcodeHandler.h:1300
char const * GetSegment() const
Definition: BOpcodeHandler.h:1336
int m_definition_length
Definition: BOpcodeHandler.h:7577
static TK_Status GetData(BStreamFileToolkit &tk, int *i, int n)
Definition: BOpcodeHandler.h:272
TK_Line(unsigned char opcode=TKE_Line)
Definition: BOpcodeHandler.h:5502
int m_stage
The writing stage.
Definition: BOpcodeHandler.h:63
void SetColorLineContrastLockMask(int m)
Definition: BOpcodeHandler.h:2998
void SetColorVertexForcedLockValue(int v)
Definition: BOpcodeHandler.h:3366
int GetNURBSOptionsValue() const
Definition: BOpcodeHandler.h:3555
float * m_planes
internal use
Definition: BOpcodeHandler.h:6016
Handles the TKE_Image_XRef opcodes.
Definition: BOpcodeHandler.h:8072
void SetTiling(int p)
Definition: BOpcodeHandler.h:7305
int GetLodFallback() const
Definition: BOpcodeHandler.h:3609
float GetCutGeometryEdgeWeight() const
Definition: BOpcodeHandler.h:3765
short color_edge_contrast_mask
For internal use only.
Definition: BOpcodeHandler.h:1082
void SetDMinor(double const m[])
Definition: BOpcodeHandler.h:6277
Handles the TKE_PolyCylinder opcode.
Definition: BOpcodeHandler.h:6511
int * GetLengths()
Definition: BOpcodeHandler.h:7784
char m_type
internal use
Definition: BOpcodeHandler.h:5383
all
Definition: BOpcodeEnums.h:359
mask of bits in second byte
Definition: BOpcodeEnums.h:779
unsigned short m_shadow_map
For internal use only.
Definition: BOpcodeHandler.h:2547
void GetDPosition(double p[]) const
Definition: BOpcodeHandler.h:4983
float m_stereo_distance
For internal use only.
Definition: BOpcodeHandler.h:2516
int m_length
Definition: BOpcodeHandler.h:4706
float GetLineSpacing() const
Definition: BOpcodeHandler.h:5284
static TK_Status LookatData(BStreamFileToolkit &tk, unsigned char &b)
Definition: BOpcodeHandler.h:344
int m_length
Definition: BOpcodeHandler.h:2370
int visibility_mask
For internal use only.
Definition: BOpcodeHandler.h:1098
int GetCount() const
Definition: BOpcodeHandler.h:5752
void SetColorTextContrastForcedLockMask(int m)
Definition: BOpcodeHandler.h:3470
int GetColorBackLockValue() const
Definition: BOpcodeHandler.h:2945
void SetWhenInvisible(int m)
Definition: BOpcodeHandler.h:4401
mask for HLR suboptions; refer to ::HC_Set_Rendering_Options for description
Definition: BOpcodeEnums.h:667
void SetKey(ID_Key k)
Definition: BOpcodeHandler.h:1596
char const * GetNames() const
Definition: BOpcodeHandler.h:5214
int GetLength() const
Definition: BOpcodeHandler.h:2161
int m_placeholder
internal use
Definition: BOpcodeHandler.h:1640
unsigned char * m_dleader_flags
Definition: BOpcodeHandler.h:6789
float m_vertex_decimation
For internal use only.
Definition: BOpcodeHandler.h:2578
double const * GetDRadii() const
Definition: BOpcodeHandler.h:6588
char * GetName()
Definition: BOpcodeHandler.h:7485
void SetColorMarkerForcedLockMask(int m)
Definition: BOpcodeHandler.h:3217
wchar_t const * GetString() const
Definition: BOpcodeHandler.h:8057
void SetInterpolation(int p)
Definition: BOpcodeHandler.h:7265
void SetDCenter(double x, double y, double z)
Definition: BOpcodeHandler.h:6363
void SetDMinor(double x, double y, double z)
Definition: BOpcodeHandler.h:6273
float * GetMatrix()
Definition: BOpcodeHandler.h:4444
void SetOrigin(float x, float y, float z)
Definition: BOpcodeHandler.h:6656
int m_length
Definition: BOpcodeHandler.h:4617
int GetGeometryOptionsMask() const
Definition: BOpcodeHandler.h:3726
char m_marker_drawing_preference
For internal use only.
Definition: BOpcodeHandler.h:2587
int m_allocated
Definition: BOpcodeHandler.h:1291
int GetCutGeometryColorMatch() const
Definition: BOpcodeHandler.h:3752
unsigned char size_units
specified with enum TKO_Font_Size_Units
Definition: BOpcodeHandler.h:6755
Handles the TKE_External_Reference_Unicode opcodes.
Definition: BOpcodeHandler.h:8031
float m_outer
for internal use only
Definition: BOpcodeHandler.h:5937
Handles the TKE_Polyline and TKE_Polygon opcodes.
Definition: BOpcodeHandler.h:5552
char m_apply_mode
Definition: BOpcodeHandler.h:7185
int * m_cursors
Definition: BOpcodeHandler.h:6783
HLONG * GetValues()
Definition: BOpcodeHandler.h:4826
int GetHlrOptions() const
Definition: BOpcodeHandler.h:3525
int m_pixel_threshold
internal use; pixel threshold
Definition: BOpcodeHandler.h:3978
int m_count
internal use
Definition: BOpcodeHandler.h:6018
int mask
For internal use only.
Definition: BOpcodeHandler.h:1058
void SetMetalnessFactor(float f)
Definition: BOpcodeHandler.h:2321
int m_internal_shell
internal use
Definition: BOpcodeHandler.h:3971
void SetRef1(float const r[])
Definition: BOpcodeHandler.h:6671
float const * GetLimits() const
Definition: BOpcodeHandler.h:6286
unsigned char m_type
Definition: BOpcodeHandler.h:5706
float GetConcentration() const
Definition: BOpcodeHandler.h:5999
void SetColorFaceContrastLockValue(int v)
Definition: BOpcodeHandler.h:2894
int GetColorMarkerLockMask() const
Definition: BOpcodeHandler.h:2819
Handles the TKE_Bounding and TKE_Bounding_Info opcodes.
Definition: BOpcodeHandler.h:5379
unsigned char m_projection
internal use
Definition: BOpcodeHandler.h:4936
char m_tint_effect
For internal use only.
Definition: BOpcodeHandler.h:2480
void SetColorFaceForcedLockValue(int v)
Definition: BOpcodeHandler.h:3159
TK_User_Data()
Definition: BOpcodeHandler.h:7830
int GetCount() const
Definition: BOpcodeHandler.h:5659
void SetRGB(float const rgb[])
Definition: BOpcodeHandler.h:1946
unsigned char m_degree[2]
Definition: BOpcodeHandler.h:5789
int m_force_defer
internal use; hard extent
Definition: BOpcodeHandler.h:3983
float GetOuter() const
Definition: BOpcodeHandler.h:5989
float const * GetPosition() const
Definition: BOpcodeHandler.h:5960
int m_index
Definition: BOpcodeHandler.h:1259
void SetPoint(float x, float y, float z)
Definition: BOpcodeHandler.h:5465
void SetSelectionSorting(int s)
Definition: BOpcodeHandler.h:4136
////
Definition: BOpcodeEnums.h:96
const int TK_Image_Bytes_Per_Pixel[]
Specifies the number of bytes per pixel for each format.
TK_Glyph_Definition()
Definition: BOpcodeHandler.h:7415
Handles the TKE_Shape_Definition opcode.
Definition: BOpcodeHandler.h:7455
int GetColorForcedLockMask() const
Definition: BOpcodeHandler.h:3130
float * GetTextLeaders()
Definition: BOpcodeHandler.h:6878
double m_dradius
Definition: BOpcodeHandler.h:6424
void SetColorVertexContrastLockMask(int m)
Definition: BOpcodeHandler.h:3044
int GetColorLockMask() const
Definition: BOpcodeHandler.h:2727
void SetGreekingLimit(float s)
Definition: BOpcodeHandler.h:5292
float const * GetStart() const
Definition: BOpcodeHandler.h:6451
void SetLodAlgorithm(int v)
Definition: BOpcodeHandler.h:3583
char * GetEmissionName()
Definition: BOpcodeHandler.h:1869
void SetBaseColorMap(int length)
Definition: BOpcodeHandler.h:2249
int GetNURBSSurfaceBudget() const
Definition: BOpcodeHandler.h:3567
unsigned short m_tint_options
For internal use only.
Definition: BOpcodeHandler.h:2477
int m_maximum_extent_mode
internal use; maximum extent mode – int! argh...
Definition: BOpcodeHandler.h:3980
TK_Status Write(BStreamFileToolkit &)
Definition: BOpcodeHandler.h:1104
void SetWindow(float const w[])
Definition: BOpcodeHandler.h:5111
channel m_diffuse
internal use
Definition: BOpcodeHandler.h:1735
void SetGeometry(int m)
Definition: BOpcodeHandler.h:2088
void SetRendererCutoff(float s)
Definition: BOpcodeHandler.h:5318
int GetNumSphereTessellations() const
Definition: BOpcodeHandler.h:3717
float * GetValues()
Definition: BOpcodeHandler.h:2159
float * m_radii
Definition: BOpcodeHandler.h:6517
Handles the TKE_Camera opcode.
Definition: BOpcodeHandler.h:4926
int GetTransparentStyle() const
Definition: BOpcodeHandler.h:2640
int m_mask
internal use
Definition: BOpcodeHandler.h:2021
int GetSpace() const
Definition: BOpcodeHandler.h:1999
float m_index
internal use
Definition: BOpcodeHandler.h:1743
int GetColorMarkerContrastForcedLockMask() const
Definition: BOpcodeHandler.h:3429
int GetSizeUnits() const
Definition: BOpcodeHandler.h:5244
void SetLodThreshold(float r)
Definition: BOpcodeHandler.h:3648
float m_start_u
Definition: BOpcodeHandler.h:5714
int GetJoinCutoffAngle() const
Definition: BOpcodeHandler.h:2675
void SetName(int length)
Definition: BOpcodeHandler.h:8098
int GetColorWindowLockValue() const
Definition: BOpcodeHandler.h:2876
unsigned short m_transparency_options
internal use; low nibble style, next peeling flags, then zsort
Definition: BOpcodeHandler.h:2528
int m_total_size
the total size of the blind material data
Definition: BOpcodeHandler.h:7881
int m_mask
internal use
Definition: BOpcodeHandler.h:1715
char m_interpolation
Definition: BOpcodeHandler.h:7173
void SetNURBSCurveContinuedBudget(int b)
Definition: BOpcodeHandler.h:3561
char const * GetComment() const
Definition: BOpcodeHandler.h:988
void SetHlrOptions(int o)
Definition: BOpcodeHandler.h:3516
void SetStereoDistance(float d)
Definition: BOpcodeHandler.h:3510
Handles the TKE_Text and TKE_Text_With_Encoding opcodes.
Definition: BOpcodeHandler.h:6768
int GetColorBackForcedLockValue() const
Definition: BOpcodeHandler.h:3348
unsigned char m_size_units
for internal use only
Definition: BOpcodeHandler.h:5164
float const * GetWeights() const
Definition: BOpcodeHandler.h:5839
short color_back_mask
For internal use only.
Definition: BOpcodeHandler.h:1078
void set_last_key(BStreamFileToolkit &tk, ID_Key key)
sets the given key as "most recent" on the toolkit for the purposes of associating keys with indices ...
Definition: BOpcodeHandler.h:648
int m_length
Definition: BOpcodeHandler.h:7994
float width_scale
adjustment to character width
Definition: BOpcodeHandler.h:6750
char m_param_offset
Definition: BOpcodeHandler.h:7186
int m_substage
Definition: BOpcodeHandler.h:5704
double * GetDRef2()
Definition: BOpcodeHandler.h:6720
double const * GetDCenter() const
Definition: BOpcodeHandler.h:6261
void SetOcclusionMapChannel(int c)
Definition: BOpcodeHandler.h:2352
float * m_weights
Definition: BOpcodeHandler.h:5712
void SetFlags(int f)
Definition: BOpcodeHandler.h:924
char * GetLoggingString()
Definition: BOpcodeHandler.h:249
void SetDebug(int d)
Definition: BOpcodeHandler.h:2653
int m_lod_options_value
For internal use only.
Definition: BOpcodeHandler.h:2483
char * GetDefinition()
Definition: BOpcodeHandler.h:7613
float * m_points
Definition: BOpcodeHandler.h:7736
unsigned char m_format
Definition: BOpcodeHandler.h:7039
int GetColorMarkerContrastLockMask() const
Definition: BOpcodeHandler.h:3026
bool m_collection_part
Indicates if this object is part of a LOD collection.
Definition: BOpcodeHandler.h:68
int color_mask
For internal use only.
Definition: BOpcodeHandler.h:1060
float const * GetPoints() const
Definition: BOpcodeHandler.h:5901
int m_length
Definition: BOpcodeHandler.h:6914
oblique y setting
Definition: BOpcodeEnums.h:1138
Handles the TKE_Rendering_Options opcode.
Definition: BOpcodeHandler.h:2429
void SetScreenRange(int n, float const l[])
Definition: BOpcodeHandler.h:3903
void SetMaximumExtentLevel(int c)
Definition: BOpcodeHandler.h:4075
float const * GetPoints() const
Definition: BOpcodeHandler.h:5754
int Pass(BStreamFileToolkit &tk) const
Definition: BOpcodeHandler.h:176
secondary extended bits
Definition: BOpcodeEnums.h:206
int GetUDegree() const
Definition: BOpcodeHandler.h:5831
BBaseOpcodeHandler * Opcode_Handler(BStreamFileToolkit &tk, unsigned char op) const
Definition: BOpcodeHandler.h:671
void SetViewVolume(float ax, float ay, float az, float bx, float by, float bz)
Definition: BOpcodeHandler.h:4102
unsigned char m_units
for internal use only.
Definition: BOpcodeHandler.h:4487
void SetCenter(float x, float y, float z)
Definition: BOpcodeHandler.h:6227
int GetMask() const
Definition: BOpcodeHandler.h:4016
void SetComment(char const *comment)
Definition: BOpcodeHandler.h:979
unsigned char m_flags
Definition: BOpcodeHandler.h:6083
bool m_terminate_file
internal use for hsx read-write only. This indicates if the TKE_Terminate is
Definition: BOpcodeHandler.h:1023
int GetColorVertexForcedLockValue() const
Definition: BOpcodeHandler.h:3371
void SetColorMarkerForcedLockValue(int v)
Definition: BOpcodeHandler.h:3228
self-explanatory
Definition: BOpcodeEnums.h:1575
HT_NURBS_Trim const * GetList() const
Definition: BOpcodeHandler.h:5774
void SetDAxis(double const a[])
Definition: BOpcodeHandler.h:6469
Definition: BOpcodeHandler.h:855
short color_marker_mask
For internal use only.
Definition: BOpcodeHandler.h:1068
char * GetSegment()
Definition: BOpcodeHandler.h:7565
int GetRoughnessMapChannel() const
Definition: BOpcodeHandler.h:2349
int m_isoline_weight_count
for internal use only.
Definition: BOpcodeHandler.h:2473
void SetParameterOffset(int p)
Definition: BOpcodeHandler.h:7320
float const * GetPoints() const
Definition: BOpcodeHandler.h:5653
float const * GetKnots() const
Definition: BOpcodeHandler.h:5770
Contains enum types which are used by BBaseOpcodeHandler.
char * m_string
Definition: BOpcodeHandler.h:7957
float const * GetEmission() const
Definition: BOpcodeHandler.h:1865
int m_buffer_size_limit
For internal use only.
Definition: BOpcodeHandler.h:2447
The BBaseOpcodeHandler abstract class is used as a base for derived classes which manage logical piec...
Definition: BOpcodeHandler.h:55
double const * GetDMatrix() const
Definition: BOpcodeHandler.h:4446
float const * GetDiffuseTextureTintColor() const
Definition: BOpcodeHandler.h:3942
char * GetString()
Definition: BOpcodeHandler.h:6823
double const * GetDPoints() const
Definition: BOpcodeHandler.h:7706
int GetCount() const
Definition: BOpcodeHandler.h:5595
unsigned char m_hsr
internal use; low half hsr, high half thsr. For internal use only.
Definition: BOpcodeHandler.h:2434
void SetDiffuseName(char const *name)
Definition: BOpcodeHandler.h:1801
char const * GetCondition() const
Definition: BOpcodeHandler.h:1425
float GetSimpleReflectionOpacity() const
Definition: BOpcodeHandler.h:3876
int m_hlr_line_pattern
For internal use only.
Definition: BOpcodeHandler.h:2453
Handles the TKE_Material opcode.
Definition: BOpcodeHandler.h:7879
void SetStereoSeparation(float s)
Definition: BOpcodeHandler.h:3506
void SetCallback(char const *callback)
Definition: BOpcodeHandler.h:2393
static TK_Status GetData(BStreamFileToolkit &tk, unsigned short &s)
Definition: BOpcodeHandler.h:317
TK_Status
Codes which can be either passed to various toolkit functions, or indicate the result of a toolkit fu...
Definition: BStream.h:274
char const * GetCondition() const
Definition: BOpcodeHandler.h:4680
void SetCaps(int f)
Definition: BOpcodeHandler.h:6484
int GetBytesCount() const
Definition: BOpcodeHandler.h:6957
Handles the TKE_Window opcode.
Definition: BOpcodeHandler.h:5088
BBaseOpcodeHandler * m_index_data
Definition: BOpcodeHandler.h:4710
TK_Point(unsigned char opcode)
Definition: BOpcodeHandler.h:5441
int m_length
Definition: BOpcodeHandler.h:6772
BBaseOpcodeHandler * m_unicode
Definition: BOpcodeHandler.h:4709
unsigned char m_encoding
Definition: BOpcodeHandler.h:6775
TK_LOD()
Definition: BOpcodeHandler.h:1521
int GetColorEdgeContrastLockValue() const
Definition: BOpcodeHandler.h:2991
void SetColorVertexContrastForcedLockMask(int m)
Definition: BOpcodeHandler.h:3447
void SetSize(float value, int units=TKO_Generic_Size_Unspecified)
Definition: BOpcodeHandler.h:4502
void SetAxis(float const s[])
Definition: BOpcodeHandler.h:6346
void SetValue(int m)
Definition: BOpcodeHandler.h:4300
double const * GetDAxis() const
Definition: BOpcodeHandler.h:6471
Handles the TKE_Visibility opcode.
Definition: BOpcodeHandler.h:4262
unsigned short m_selection_bias
internal use; selection bias options
Definition: BOpcodeHandler.h:3977
float GetIndex() const
Definition: BOpcodeHandler.h:1896
void SetPoint(float const p[])
Definition: BOpcodeHandler.h:5467
void SetExtras(int e)
Definition: BOpcodeHandler.h:4044
void SetFollow(bool f)
Definition: BOpcodeHandler.h:1434
unsigned char m_hlr_weight_units
for internal use only.
Definition: BOpcodeHandler.h:2456
TK_Named_Style_Def()
Definition: BOpcodeHandler.h:7522
void SetCutVisualizationMode(int m)
Definition: BOpcodeHandler.h:4231
TK_Status Interpret(BStreamFileToolkit &tk, ID_Key key, char const *special)
Definition: BOpcodeHandler.h:7370
unsigned char m_cut_geometry_match
For internal use only.
Definition: BOpcodeHandler.h:2532
char * m_string
Definition: BOpcodeHandler.h:1292
void SetPoints(float const p[])
Definition: BOpcodeHandler.h:5522
double * GetDPoints()
Definition: BOpcodeHandler.h:7773
void SetTransparentStyle(int s)
Definition: BOpcodeHandler.h:2638
float const * GetRectangle() const
Definition: BOpcodeHandler.h:7650
int m_length
Definition: BOpcodeHandler.h:1290
internal use, indicates bits which require TKO_Geo_Extended2
Definition: BOpcodeEnums.h:207
float m_contour_value_scale
for internal use only.
Definition: BOpcodeHandler.h:2464
short color_text_contrast_mask
For internal use only.
Definition: BOpcodeHandler.h:1090
unsigned short value
for active settings, on or off
Definition: BOpcodeHandler.h:6753
TK_Color_RGB()
Definition: BOpcodeHandler.h:1913
unsigned char m_cut_geometry
For internal use only.
Definition: BOpcodeHandler.h:2530
char m_type
Definition: BOpcodeHandler.h:6638
void SetNeedsTag(bool n)
Definition: BOpcodeHandler.h:194
char * m_shape
for internal use only
Definition: BOpcodeHandler.h:5159
float const * GetRef2() const
Definition: BOpcodeHandler.h:6684
int m_current_value
for internal use only
Definition: BOpcodeHandler.h:4843
int m_ascii_progress
Tracks the amount of data that has been read/written so far by GetAscii functions.
Definition: BOpcodeHandler.h:79
void SetColorLineForcedLockMask(int m)
Definition: BOpcodeHandler.h:3194
char * GetView()
Definition: BOpcodeHandler.h:5079
void SetRoughnessFactor(float f)
Definition: BOpcodeHandler.h:2326
void SetWidthScale(float s)
Definition: BOpcodeHandler.h:5267
void SetColorEdgeLockMask(int m)
Definition: BOpcodeHandler.h:2768
float GetRoughnessFactor() const
Definition: BOpcodeHandler.h:2328
void SetColorFaceContrastForcedLockValue(int v)
Definition: BOpcodeHandler.h:3297
unsigned char m_degree
Definition: BOpcodeHandler.h:5616
double const * GetDPoints() const
Definition: BOpcodeHandler.h:5826
int GetDegree() const
Definition: BOpcodeHandler.h:5658
void SetFollow(bool f)
Definition: BOpcodeHandler.h:1366
char * GetSpecularName()
Definition: BOpcodeHandler.h:1824
int m_name_length
Definition: BOpcodeHandler.h:7576
Handles the TKE_NURBS_Surface opcode.
Definition: BOpcodeHandler.h:5786
int m_reference_length
Definition: BOpcodeHandler.h:7038
void SetCutVisualizationSCale(float s)
Definition: BOpcodeHandler.h:4250
float const * GetUKnots() const
Definition: BOpcodeHandler.h:5843
int GetColorWindowForcedLockValue() const
Definition: BOpcodeHandler.h:3279
char * m_data
Definition: BOpcodeHandler.h:7910
float * m_points
internal use
Definition: BOpcodeHandler.h:5873
int GetShadowMapResolution() const
Definition: BOpcodeHandler.h:3848
void SetOptions(int o)
Definition: BOpcodeHandler.h:5919
int m_names_length
for internal use only
Definition: BOpcodeHandler.h:5143
ID_Key m_key
for internal use only
Definition: BOpcodeHandler.h:1390
void SetDField(double const f[])
Definition: BOpcodeHandler.h:5037
int GetShadowMapSamples() const
Definition: BOpcodeHandler.h:3853
double const * GetDTarget() const
Definition: BOpcodeHandler.h:5001
struct vlist_s * m_data
Definition: BOpcodeHandler.h:7885
unsigned char m_geometry_options
For internal use only.
Definition: BOpcodeHandler.h:2566
Handles the TKE_Color_By_Index and TKE_Color_By_Index_16 opcode.
Definition: BOpcodeHandler.h:2019
void SetGeometry(int m)
Definition: BOpcodeHandler.h:2039
void SetNormalFactor(float f)
Definition: BOpcodeHandler.h:2316
TK_Shape_Definition()
Definition: BOpcodeHandler.h:7464
void SetColorLineLockValue(int v)
Definition: BOpcodeHandler.h:2802
void SetIndices(int count)
Definition: BOpcodeHandler.h:4816
float const * GetSimpleReflectionPlane() const
Definition: BOpcodeHandler.h:3871
float m_vector_tolerance
internal use; culling vector tolerance
Definition: BOpcodeHandler.h:3985
int m_join_cutoff_angle
For internal use only.
Definition: BOpcodeHandler.h:2576
int GetHlrLinePattern() const
Definition: BOpcodeHandler.h:3537
float GetStereoDistance() const
Definition: BOpcodeHandler.h:3512
int m_levels_allocated
the number of entries allocated in m_num_primitives and m_primitives
Definition: BOpcodeHandler.h:1512
unsigned char horizontal_offset_units
specified with enum TKO_Font_Size_Units
Definition: BOpcodeHandler.h:6757
int GetRenderer() const
Definition: BOpcodeHandler.h:5310
void SetCylinderTessellations(int c, char const *n=0)
Definition: BOpcodeHandler.h:3691
void SetNearLimit(float l)
Definition: BOpcodeHandler.h:5058
char m_contour_value_adjustment
for internal use only.
Definition: BOpcodeHandler.h:2463
void SetExtraSpace(float s)
Definition: BOpcodeHandler.h:5272
#define ID_Key
Definition: BStream.h:250
unsigned short m_value
internal use
Definition: BOpcodeHandler.h:4160
void SetTarget(float x, float y, float z)
Definition: BOpcodeHandler.h:4986
int GetIndex() const
Definition: BOpcodeHandler.h:2059
void SetMask(int m0, int m1=0, int m2=0)
Definition: BOpcodeHandler.h:2610
int m_cond_allocated
Definition: BOpcodeHandler.h:7513
int GetColorVertexContrastLockValue() const
Definition: BOpcodeHandler.h:3060
unsigned char m_flags
Definition: BOpcodeHandler.h:6425
char * name
the font name
Definition: BOpcodeHandler.h:6742
int GetLayout() const
Definition: BOpcodeHandler.h:5351
double * GetDPoints()
Definition: BOpcodeHandler.h:7708
wchar_t * GetString()
Definition: BOpcodeHandler.h:8059
int GetColorFaceContrastForcedLockMask() const
Definition: BOpcodeHandler.h:3291
void SetTransmissionName(char const *name)
Definition: BOpcodeHandler.h:1846
void SetBaseColorFactor(float r, float g, float b, float a)
Definition: BOpcodeHandler.h:2302
TK_Status Interpret(BStreamFileToolkit &tk, ID_Key key, int variant)
Definition: BOpcodeHandler.h:967
#define TKO_Rendo_Extended
Definition: BOpcodeEnums.h:450
void SetDCenter(double x, double y, double z)
Definition: BOpcodeHandler.h:6174
double * m_dradii
Definition: BOpcodeHandler.h:6518
int GetMask() const
Definition: BOpcodeHandler.h:4196
Utility class for managing HSF header information.
Definition: BOpcodeHandler.h:872
float const * GetUpVector() const
Definition: BOpcodeHandler.h:5011
unsigned short m_isoline_options
for internal use only.
Definition: BOpcodeHandler.h:2462
float GetVertexDecimation() const
Definition: BOpcodeHandler.h:3952
internal use, indicates bits which require TKO_Geo_Extended_Colors
Definition: BOpcodeEnums.h:193
void SetPoints(float x1, float y1, float z1, float x2, float y2, float z2)
Definition: BOpcodeHandler.h:5513
int m_index
internal use
Definition: BOpcodeHandler.h:1480
float * GetPoints()
Definition: BOpcodeHandler.h:6555
int m_simple_reflection_visibility_value
For internal use only.
Definition: BOpcodeHandler.h:2558
void SetSimpleReflectionPlane(float const p[])
Definition: BOpcodeHandler.h:3869
float m_concentration
for internal use only
Definition: BOpcodeHandler.h:5939
void SetString(int length)
Definition: BOpcodeHandler.h:6819
int GetNumCylinderTessellations() const
Definition: BOpcodeHandler.h:3700
int GetChannels() const
Definition: BOpcodeHandler.h:1794
float * GetWeights()
Definition: BOpcodeHandler.h:5841
void SetTransform(int length)
Definition: BOpcodeHandler.h:7333
void SetToleranceUnits(int u)
Definition: BOpcodeHandler.h:5252
float const * GetDiffuse() const
Definition: BOpcodeHandler.h:1805
int GetOptions() const
Definition: BOpcodeHandler.h:7718
void SetColorWindowForcedLockValue(int v)
Definition: BOpcodeHandler.h:3274
void SetTransform(char const *transform)
Definition: BOpcodeHandler.h:7328
Handles the TKE_Thumbnail opcode.
Definition: BOpcodeHandler.h:7349
Handles the TKE_User_Options opcode.
Definition: BOpcodeHandler.h:4704
int m_margin_count
for internal use only
Definition: BOpcodeHandler.h:5161
HT_NURBS_Trim * m_current_trim
Definition: BOpcodeHandler.h:5798
int GetTransforms() const
Definition: BOpcodeHandler.h:5289
void SetForcedLockValue(int v)
Definition: BOpcodeHandler.h:3094
int m_face_displacement
For internal use only.
Definition: BOpcodeHandler.h:2437
TK_Dictionary()
Definition: BOpcodeHandler.h:1648
unsigned char m_byte
temporary
Definition: BOpcodeHandler.h:81
int GetGeometry() const
Definition: BOpcodeHandler.h:4351
Handles the TKE_Clip_Region opcodes.
Definition: BOpcodeHandler.h:7666
void SetSegment(int length)
Definition: BOpcodeHandler.h:1332
char const * GetString() const
Definition: BOpcodeHandler.h:8018
unsigned char m_display_list_level
For internal use only.
Definition: BOpcodeHandler.h:2579
int GetVDegree() const
Definition: BOpcodeHandler.h:5833
int GetValue() const
Definition: BOpcodeHandler.h:4021
char const * GetName() const
Definition: BOpcodeHandler.h:7434
#define NS_TRIM_END
terminates an NS_TRIM_COLLECTION if one is active, otherwise terminates the list of trims ...
Definition: BOpcodeHandler.h:5683
char * GetImage()
Definition: BOpcodeHandler.h:7239
float GetCutVisualizationAlpha() const
Definition: BOpcodeHandler.h:4247
float * GetOrderedWeights()
Definition: BOpcodeHandler.h:4128
float const * GetMiddle() const
Definition: BOpcodeHandler.h:6143
TK_Color_Map()
Definition: BOpcodeHandler.h:2133
int m_size
Definition: BOpcodeHandler.h:7458
char * m_string
Definition: BOpcodeHandler.h:4618
double const * GetDPoint() const
Definition: BOpcodeHandler.h:5476
void SetDiffuse(float const rgb[])
Definition: BOpcodeHandler.h:1799
double const * GetTextRegionDPoints() const
Definition: BOpcodeHandler.h:6855
double const * GetDOrtho() const
Definition: BOpcodeHandler.h:6397
static void fix_in(double *d, int n)
for internal use only
Definition: BOpcodeHandler.h:577
int GetIndex() const
Definition: BOpcodeHandler.h:4576
void SetDepthRange(float n, float f)
Definition: BOpcodeHandler.h:3885
short color_vertex_mask
For internal use only.
Definition: BOpcodeHandler.h:1080
int GetMoveUp() const
Definition: BOpcodeHandler.h:4395
short color_face_contrast_value
For internal use only.
Definition: BOpcodeHandler.h:1075
int GetColorFaceContrastForcedLockValue() const
Definition: BOpcodeHandler.h:3302
TK_Streaming()
Definition: BOpcodeHandler.h:4593
static void fix(short *s, int n)
for internal use only
Definition: BOpcodeHandler.h:547
char const * GetRoughnessMap() const
Definition: BOpcodeHandler.h:2287
float GetMaxDistance() const
Definition: BOpcodeHandler.h:4097
void GetOblique(float o[]) const
Definition: BOpcodeHandler.h:5055
void SetMoveUp(int m)
Definition: BOpcodeHandler.h:4390
int GetDecimation() const
Definition: BOpcodeHandler.h:7272
void SetRendererCutoffUnits(int u)
Definition: BOpcodeHandler.h:5323
void SetCutGeometry(int m)
Definition: BOpcodeHandler.h:3740
void SetBaseColorMap(char const *name)
Definition: BOpcodeHandler.h:2247
void SetEndNormal(int index, float const normal[]=0)
Definition: BOpcodeHandler.h:6607
TK_Bounding(unsigned char opcode, double center[], double radius)
Definition: BOpcodeHandler.h:5409
char * m_debug_string
Definition: BOpcodeHandler.h:72
char m_tiling
Definition: BOpcodeHandler.h:7181
void SetColorVertexForcedLockMask(int m)
Definition: BOpcodeHandler.h:3355
char const * GetSegment() const
Definition: BOpcodeHandler.h:1209
int m_cursor_count
Definition: BOpcodeHandler.h:6782
void SetSimpleReflection(int m)
Definition: BOpcodeHandler.h:3857
int GetGreekingLimitUnits() const
Definition: BOpcodeHandler.h:5299
Handles the TKE_Color_Map opcode.
Definition: BOpcodeHandler.h:2119
static TK_Status GetData(BStreamFileToolkit &tk, unsigned char &b)
Definition: BOpcodeHandler.h:314
static TK_Status PutData(BStreamFileToolkit &tk, unsigned int const *i, int n)
Definition: BOpcodeHandler.h:447
char * GetBumpName()
Definition: BOpcodeHandler.h:1887
char m_num_thresholds
For internal use only.
Definition: BOpcodeHandler.h:2487
int GetNURBSSurfaceTrimBudget() const
Definition: BOpcodeHandler.h:3571
float m_contour_value_translate
for internal use only.
Definition: BOpcodeHandler.h:2465
int GetCutVisualizationMask() const
Definition: BOpcodeHandler.h:4228
unsigned char const * GetTextLeaderFlags() const
Definition: BOpcodeHandler.h:6880
int m_mask
internal use
Definition: BOpcodeHandler.h:1960
float const * GetLodCutoffs() const
Definition: BOpcodeHandler.h:3679
char const * GetBaseColorMap() const
Definition: BOpcodeHandler.h:2251
TK_Named(unsigned char opcode)
Definition: BOpcodeHandler.h:4551
bool m_follow
for internal use only
Definition: BOpcodeHandler.h:1301
void SetAxis(float x1, float y1, float z1, float x2, float y2, float z2)
Definition: BOpcodeHandler.h:6440
void SetEmissionName(int length)
Definition: BOpcodeHandler.h:1863
char * m_name
Definition: BOpcodeHandler.h:6909
int * m_indices
for internal use only
Definition: BOpcodeHandler.h:4791
char const * GetString() const
Definition: BOpcodeHandler.h:6821
void SetDStart(double const s[])
Definition: BOpcodeHandler.h:6154
void SetColorEdgeContrastForcedLockValue(int v)
Definition: BOpcodeHandler.h:3389
float m_width_scale
for internal use only
Definition: BOpcodeHandler.h:5149
int GetColorEdgeForcedLockValue() const
Definition: BOpcodeHandler.h:3187
void SetCurve(int degree, int control_count, float const points[]=0, float const weights[]=0, float const knots[]=0, float start=0.0f, float end=1.0f)
sets the curve properties
Definition: BOpcodeHandler.h:5644
char const * GetStyle() const
Definition: BOpcodeHandler.h:5232
ID_Key m_key
for internal use only
Definition: BOpcodeHandler.h:7516
char * m_name
Definition: BOpcodeHandler.h:7031
bool m_follow
for internal use only
Definition: BOpcodeHandler.h:1392
float GetSize() const
Definition: BOpcodeHandler.h:5239
int m_move_up
internal use; specifies what geometry is selectable on mouse move without buttons down...
Definition: BOpcodeHandler.h:4323
TK_Matrix(unsigned char opcode)
Definition: BOpcodeHandler.h:4423
void SetDMiddle(double const m[])
Definition: BOpcodeHandler.h:6162
unsigned short m_simple_reflection
For internal use only.
Definition: BOpcodeHandler.h:2551
float GetRadius() const
Definition: BOpcodeHandler.h:6337
float const * GetTarget() const
Definition: BOpcodeHandler.h:5976
int GetNURBSCurveContinuedBudget() const
Definition: BOpcodeHandler.h:3563
static float read_float(char const *cp, char **newcpp)
for internal use only
Definition: BOpcodeHandler.h:697
static TK_Status GetData(BStreamFileToolkit &tk, char *b, int n)
Definition: BOpcodeHandler.h:261
int * m_num_primitives
an array of ints to indicate the length of each row in m_primitives
Definition: BOpcodeHandler.h:1509
bool m_flag
for internal use only
Definition: BOpcodeHandler.h:4589
Lock_Masks m_lock
For internal use only.
Definition: BOpcodeHandler.h:2442
unsigned char * m_data
Definition: BOpcodeHandler.h:7822
float GetSize() const
Definition: BOpcodeHandler.h:4507
void SetGreenMapping(int p)
Definition: BOpcodeHandler.h:7280
void SetLodThresholds(int c, float const r[]=0)
Definition: BOpcodeHandler.h:3650
void SetRectangle(float const *rect)
Definition: BOpcodeHandler.h:7647
TK_Status SetDPoints(int count, double const points[]=0)
void SetOptions(int at)
Definition: BOpcodeHandler.h:4691
Base class for shell and mesh.
Definition: BPolyhedron.h:22
char const * GetName() const
Definition: BOpcodeHandler.h:7219
char m_options
Definition: BOpcodeHandler.h:7668
void ** m_values
for internal use only
Definition: BOpcodeHandler.h:4840
char * m_string
Definition: BOpcodeHandler.h:1174
int m_hlr_options
For internal use only.
Definition: BOpcodeHandler.h:2449
double const * GetDPoints() const
Definition: BOpcodeHandler.h:7771
TK_User_Index_Data()
Definition: BOpcodeHandler.h:4850
void SetDCenter(double const c[])
Definition: BOpcodeHandler.h:6179
void SetCompression(int c)
Definition: BOpcodeHandler.h:7144
int GetHardExtent() const
Definition: BOpcodeHandler.h:4079
TK_Color_By_Index(unsigned char opcode)
Definition: BOpcodeHandler.h:2026
char * m_reference
Definition: BOpcodeHandler.h:7032
void SetSimpleReflectionPlane(float a, float b, float c, float d)
Definition: BOpcodeHandler.h:3862
extends font options to a second byte
Definition: BOpcodeEnums.h:1161
void SetRenderer(int r)
Definition: BOpcodeHandler.h:5308
int m_name_length
Definition: BOpcodeHandler.h:6912
Handles the TKE_Conditional_Action opcode.
Definition: BOpcodeHandler.h:4654
char const * GetName() const
Definition: BOpcodeHandler.h:4569
TK_Geometry_Options()
Definition: BOpcodeHandler.h:4177
int GetUp() const
Definition: BOpcodeHandler.h:4373
void SetEmissionName(char const *name)
Definition: BOpcodeHandler.h:1861
char * m_bytes
Definition: BOpcodeHandler.h:6911
int m_vertex_displacement
For internal use only.
Definition: BOpcodeHandler.h:2438
float GetIndex() const
Definition: BOpcodeHandler.h:2108
void SetHardEdgeAngle(int m)
Definition: BOpcodeHandler.h:3729
float m_surface_max_trim_curve_deviation
For internal use only.
Definition: BOpcodeHandler.h:2507
void SetColorEdgeContrastLockValue(int v)
Definition: BOpcodeHandler.h:2986
double const * GetDPlane() const
Definition: BOpcodeHandler.h:6057
Handles the TKE_Start_User_Data opcode.
Definition: BOpcodeHandler.h:7819
float m_size
for internal use only
Definition: BOpcodeHandler.h:5145
float * GetKnots()
Definition: BOpcodeHandler.h:5772
int m_length
internal use
Definition: BOpcodeHandler.h:2121
float const * GetPoints() const
Definition: BOpcodeHandler.h:5822
unsigned char m_format
internal use
Definition: BOpcodeHandler.h:2126
void SetName(char const *name)
Definition: BOpcodeHandler.h:7215
TK_Status SetPoints(int count, float const points[]=0)
unsigned char const * GetDTextLeaderFlags() const
Definition: BOpcodeHandler.h:6893
virtual TK_Status Clone(BStreamFileToolkit &tk, BBaseOpcodeHandler **handler) const
Definition: BOpcodeHandler.h:217
void bytes_to_floats(unsigned char const *in, float *out, int count) const
for internal use only
Definition: BOpcodeHandler.h:637
int GetVSize() const
Definition: BOpcodeHandler.h:5837
void set_channel_rgb(channel &c, float r, float g, float b, int which_channel=-1)
internal use
Definition: BOpcodeHandler.h:1747
char * m_lookup
Definition: BOpcodeHandler.h:6910
char const * GetLookup() const
Definition: BOpcodeHandler.h:6977
TK_Window()
Definition: BOpcodeHandler.h:5095
void SetColorTextContrastLockValue(int v)
Definition: BOpcodeHandler.h:3078
int GetColorLineForcedLockValue() const
Definition: BOpcodeHandler.h:3210
TK_Linear_Pattern(unsigned char opcode)
Definition: BOpcodeHandler.h:4522
int m_radius_count
Definition: BOpcodeHandler.h:6516
void SetSimpleShadowResolution(int m)
Definition: BOpcodeHandler.h:3799
void SetIndex(int index)
Definition: BOpcodeHandler.h:1408
float GetTolerance() const
Definition: BOpcodeHandler.h:5249
void SetDCenter(double const s[])
Definition: BOpcodeHandler.h:6259
void SetDRef2(double const r[])
Definition: BOpcodeHandler.h:6716
TK_Line_Style()
Definition: BOpcodeHandler.h:7583
Definition: BOpcodeHandler.h:4587
void SetDOrtho(double x, double y, double z)
Definition: BOpcodeHandler.h:6389
float * GetRef1()
Definition: BOpcodeHandler.h:6675
char m_num_ratios
For internal use only.
Definition: BOpcodeHandler.h:2485
float GetHardEdgeAngle() const
Definition: BOpcodeHandler.h:3731
void SetGreekingLimitUnits(int u)
Definition: BOpcodeHandler.h:5297
int GetParameterFunction() const
Definition: BOpcodeHandler.h:7297
unsigned char m_extras
internal use; low bit set == left handed, second bit set == spriting
Definition: BOpcodeHandler.h:3974
void SetLineSpacing(float s)
Definition: BOpcodeHandler.h:5282
float const * GetMinor() const
Definition: BOpcodeHandler.h:6251
void SetEncoding(int e)
Definition: BOpcodeHandler.h:6842
Handles the TKE_Start_Compression and TKE_Stop_Compression opcodes.
Definition: BOpcodeHandler.h:1035
char const * GetShape() const
Definition: BOpcodeHandler.h:5223
unsigned short * m_string
Definition: BOpcodeHandler.h:4753
static void fix_out(float *f, int n)
for internal use only
Definition: BOpcodeHandler.h:592
char const * GetName() const
Definition: BOpcodeHandler.h:7097
void SetColorWindowContrastForcedLockMask(int m)
Definition: BOpcodeHandler.h:3309
void SetPreferences(int r1, int r2)
Definition: BOpcodeHandler.h:5334
TK_Texture()
Definition: BOpcodeHandler.h:7197
char * m_gooch_color_map_segment
For internal use only.
Definition: BOpcodeHandler.h:2526
void SetColorEdgeContrastForcedLockMask(int m)
Definition: BOpcodeHandler.h:3378
TK_Status Interpret(BStreamFileToolkit &tk, ID_Key key, char const *special)
Definition: BOpcodeHandler.h:1048
void SetDRadius(double r)
Definition: BOpcodeHandler.h:6478
int m_allocated
Definition: BOpcodeHandler.h:7995
int GetLodThresholdType() const
Definition: BOpcodeHandler.h:3646
static TK_Status PutData(BStreamFileToolkit &tk, double const *d, int n)
Definition: BOpcodeHandler.h:418
int GetPreference() const
Definition: BOpcodeHandler.h:5331
float m_gooch_diffuse_weight
For internal use only.
Definition: BOpcodeHandler.h:2525
void SetColorEdgeContrastLockMask(int m)
Definition: BOpcodeHandler.h:2975
char const * GetName() const
Definition: BOpcodeHandler.h:7602
int GetLodNumThresholds() const
Definition: BOpcodeHandler.h:3659
void SetAmbientUpVector(float x, float y, float z)
Definition: BOpcodeHandler.h:3913
int GetFormat() const
Definition: BOpcodeHandler.h:2149
static TK_Status PutData(BStreamFileToolkit &tk, int const &i)
Definition: BOpcodeHandler.h:456
unsigned char * GetUserData()
Definition: BOpcodeHandler.h:7852
double const * GetDTextLeaders() const
Definition: BOpcodeHandler.h:6889
float const * GetLodRatios() const
Definition: BOpcodeHandler.h:3639
int GetColorTextContrastLockValue() const
Definition: BOpcodeHandler.h:3083
extended bits for color
Definition: BOpcodeEnums.h:192
void SetColorWindowLockMask(int m)
Definition: BOpcodeHandler.h:2860
int m_total
Definition: BOpcodeHandler.h:7734
int GetColorMarkerContrastForcedLockValue() const
Definition: BOpcodeHandler.h:3440
HT_NURBS_Trim * GetList()
Definition: BOpcodeHandler.h:5776
void SetIndex(int i)
Definition: BOpcodeHandler.h:1494
float const * getSimpleShadowLight() const
Definition: BOpcodeHandler.h:3812
static TK_Status PutData(BStreamFileToolkit &tk, float const *f, int n)
Definition: BOpcodeHandler.h:395
float GetStereoSeparation() const
Definition: BOpcodeHandler.h:3508
char const * GetEnvironmentName() const
Definition: BOpcodeHandler.h:1876
void SetSimpleShadowOpacity(float o)
Definition: BOpcodeHandler.h:3835
void SetColorWindowContrastLockValue(int v)
Definition: BOpcodeHandler.h:2917
double const * GetDOrigin() const
Definition: BOpcodeHandler.h:6696
char * GetName()
Definition: BOpcodeHandler.h:7436
void SetStart(float x, float y, float z)
Definition: BOpcodeHandler.h:6101
void GetTarget(float t[]) const
Definition: BOpcodeHandler.h:4993
char const * GetSpecularName() const
Definition: BOpcodeHandler.h:1822
void SetIndex(int i)
Definition: BOpcodeHandler.h:2057
int m_substage
Definition: BOpcodeHandler.h:6792
float const * GetPoint() const
Definition: BOpcodeHandler.h:5469
int GetFormat() const
Definition: BOpcodeHandler.h:7394
int m_options
internal use
Definition: BOpcodeHandler.h:1456
int GetMetalnessMapChannel() const
Definition: BOpcodeHandler.h:2344
char * GetComment()
Definition: BOpcodeHandler.h:993
short color_line_mask
For internal use only.
Definition: BOpcodeHandler.h:1066
float const * GetEnd() const
Definition: BOpcodeHandler.h:6145
extra item for color; refer to ::HC_Set_Color for a description
Definition: BOpcodeEnums.h:215
void SetSimpleShadowPlane(float const p[])
Definition: BOpcodeHandler.h:3822
float const * GetFogLimits() const
Definition: BOpcodeHandler.h:2682
int GetCount() const
Definition: BOpcodeHandler.h:4818
void SetDEnd(double x, double y, double z)
Definition: BOpcodeHandler.h:6166
void SetColorForcedLockMask(int m)
Definition: BOpcodeHandler.h:3125
self-explanatory
Definition: BOpcodeEnums.h:1299
int m_lod_options_mask
For internal use only.
Definition: BOpcodeHandler.h:2482
int GetTiling() const
Definition: BOpcodeHandler.h:7307
float * m_isoline_colors
for internal use only.
Definition: BOpcodeHandler.h:2470
void SetColorEdgeLockValue(int v)
Definition: BOpcodeHandler.h:2779
void SetDisplayListLevel(int m)
Definition: BOpcodeHandler.h:3780
TK_URL()
Definition: BOpcodeHandler.h:7961
int GetProjection() const
Definition: BOpcodeHandler.h:5069
int m_allocated
Definition: BOpcodeHandler.h:7956
void SetSphereTessellations(int c, char const *n=0)
Definition: BOpcodeHandler.h:3708
void SetImage(char const *image)
Definition: BOpcodeHandler.h:7233
int GetLength()
Definition: BOpcodeHandler.h:4684
float const * GetTextRegionPoints() const
Definition: BOpcodeHandler.h:6853
void SetRedMapping(int p)
Definition: BOpcodeHandler.h:7275
Handles the TKE_Delete_Object opcode.
Definition: BOpcodeHandler.h:1478
void SetMinor(float const m[])
Definition: BOpcodeHandler.h:6249
double * GetDPoints()
Definition: BOpcodeHandler.h:6578
float * GetOrigin()
Definition: BOpcodeHandler.h:6664
void SetColorMarkerContrastForcedLockValue(int v)
Definition: BOpcodeHandler.h:3435
double const * GetDMinor() const
Definition: BOpcodeHandler.h:6279
TK_Default()
Definition: BOpcodeHandler.h:838
short m_fbe_mask
For internal use only.
Definition: BOpcodeHandler.h:2582
void SetColorFaceForcedLockMask(int m)
Definition: BOpcodeHandler.h:3148
void SetSegment(char const *segment)
Definition: BOpcodeHandler.h:1327
short color_cut_face_mask
For internal use only.
Definition: BOpcodeHandler.h:1094
void SetOptions(int m)
Definition: BOpcodeHandler.h:2238
void GetDUpVector(double u[]) const
Definition: BOpcodeHandler.h:5023
HLONG GetValue() const
Definition: BOpcodeHandler.h:4916
float GetCutVisualizationScale() const
Definition: BOpcodeHandler.h:4252
unsigned char m_heuristic
For internal use only.
Definition: BOpcodeHandler.h:2498
int * GetStringCursors()
Definition: BOpcodeHandler.h:6869
ID_Key m_key
for internal use only
Definition: BOpcodeHandler.h:1297
char * GetDefinition()
Definition: BOpcodeHandler.h:7445
int m_count
for internal use only
Definition: BOpcodeHandler.h:4838
void SetApplicationMode(int p)
Definition: BOpcodeHandler.h:7315
void SetEnvironmentName(char const *name)
Definition: BOpcodeHandler.h:1872
Handles the TKE_Spot_Light opcode.
Definition: BOpcodeHandler.h:5931
TK_Camera(unsigned char opcode=TKE_Camera)
Definition: BOpcodeHandler.h:4947
void SetRenderers(int r1, int r2)
Definition: BOpcodeHandler.h:5313
void SetMirror(float const rgb[])
Definition: BOpcodeHandler.h:1829
int GetType() const
Definition: BOpcodeHandler.h:5750
void SetSpecularName(char const *name)
Definition: BOpcodeHandler.h:1816
float const * GetPosition() const
Definition: BOpcodeHandler.h:7116
double const * GetDTarget() const
Definition: BOpcodeHandler.h:5984
float const * GetOrigin() const
Definition: BOpcodeHandler.h:6662
int m_length
Definition: BOpcodeHandler.h:1172
void Record_Instance(BStreamFileToolkit &tk, ID_Key key, int variant, int val1, int val2, int val3) const
Definition: BOpcodeHandler.h:675
TK_Status Interpret(BStreamFileToolkit &tk, ID_Key key, char const *special)
Definition: BOpcodeHandler.h:971
short color_text_contrast_value
For internal use only.
Definition: BOpcodeHandler.h:1091
int GetBufferSizeLimit() const
Definition: BOpcodeHandler.h:3502
void SetMirrorName(int length)
Definition: BOpcodeHandler.h:1833
char const * GetBytes() const
Definition: BOpcodeHandler.h:6959
char const * GetEmissiveMap() const
Definition: BOpcodeHandler.h:2269
bool GetFollow()
Definition: BOpcodeHandler.h:1368
char * m_string
Definition: BOpcodeHandler.h:6774
TK_Text_Font()
Definition: BOpcodeHandler.h:5179
int GetGeometry() const
Definition: BOpcodeHandler.h:1786
int m_length
Definition: BOpcodeHandler.h:4752
float * m_values
internal use
Definition: BOpcodeHandler.h:2123
int GetColorEdgeContrastLockMask() const
Definition: BOpcodeHandler.h:2980
void SetSize(float s)
Definition: BOpcodeHandler.h:5237
float const * GetAxis() const
Definition: BOpcodeHandler.h:6348
int m_move_down
internal use; specifies what geometry is selectable on mouse button down and move. For internal use only.
Definition: BOpcodeHandler.h:4322
void SetOptions(int length)
Definition: BOpcodeHandler.h:4733
int m_cond_length
Definition: BOpcodeHandler.h:1385
char * m_name
Definition: BOpcodeHandler.h:7459
void SetDRef1(double x, double y, double z)
Definition: BOpcodeHandler.h:6701
int GetColorWindowContrastLockValue() const
Definition: BOpcodeHandler.h:2922
int GetColorTextForcedLockValue() const
Definition: BOpcodeHandler.h:3256
void SetLodMaxDegree(int v)
Definition: BOpcodeHandler.h:3599
void SetSegment(int length)
Definition: BOpcodeHandler.h:1204
float m_simple_reflection_hither
For internal use only.
Definition: BOpcodeHandler.h:2555
void SetSimpleShadow(int m)
Definition: BOpcodeHandler.h:3785
void SetNURBSCurveBudget(int b)
Definition: BOpcodeHandler.h:3557
int GetNURBSOptionsMask() const
Definition: BOpcodeHandler.h:3551
void SetGeometry(int m)
Definition: BOpcodeHandler.h:1774
extra item for visibility; refer to ::HC_Set_Visibility for a description
Definition: BOpcodeEnums.h:257
void SetCutGeometryLevel(int m)
Definition: BOpcodeHandler.h:3745
unsigned char m_depth_peeling_algorithm
For internal use only.
Definition: BOpcodeHandler.h:2573
char * GetNormalMap()
Definition: BOpcodeHandler.h:2262
void SetIndex(int i)
Definition: BOpcodeHandler.h:4574
int m_value
internal use
Definition: BOpcodeHandler.h:3968
void SetColorMarkerLockMask(int m)
Definition: BOpcodeHandler.h:2814
void SetDPosition(double x, double y, double z)
Definition: BOpcodeHandler.h:4976
Handles the TKE_Line opcode.
Definition: BOpcodeHandler.h:5493
float m_slant
for internal use only
Definition: BOpcodeHandler.h:5148
float const * GetAxis() const
Definition: BOpcodeHandler.h:6449
int GetColorEdgeContrastForcedLockValue() const
Definition: BOpcodeHandler.h:3394
void SetRoughnessMap(int length)
Definition: BOpcodeHandler.h:2285
virtual TK_Status Execute(BStreamFileToolkit &tk)
HT_NURBS_Trim * m_current_trim
Definition: BOpcodeHandler.h:5717
void SetDown(int m)
Definition: BOpcodeHandler.h:4357
int GetCulling() const
Definition: BOpcodeHandler.h:4051
float GetHlrFaceSortingAlgorithm() const
Definition: BOpcodeHandler.h:3541
void SetSize(int w, int h)
Definition: BOpcodeHandler.h:7385
int GetExtraSpaceUnits() const
Definition: BOpcodeHandler.h:5279
double const * GetDPoints() const
Definition: BOpcodeHandler.h:5655
float const * GetOrtho() const
Definition: BOpcodeHandler.h:6359
void SetDRadius(double r)
Definition: BOpcodeHandler.h:6373
int GetLayout() const
Definition: BOpcodeHandler.h:7302
float const * GetCenter() const
Definition: BOpcodeHandler.h:6233
char * m_string
Definition: BOpcodeHandler.h:4659
int m_substage
Definition: BOpcodeHandler.h:7170
void SetColorTextForcedLockValue(int v)
Definition: BOpcodeHandler.h:3251
int m_substage
internal use; To track the subcases
Definition: BOpcodeHandler.h:1744
void SetSpecular(float const rgb[])
Definition: BOpcodeHandler.h:1814
char const * GetMetalnessMap() const
Definition: BOpcodeHandler.h:2278
self-explanatory
Definition: BOpcodeEnums.h:266
void SetSizeUnits(int u)
Definition: BOpcodeHandler.h:5242
void SetEmission(float r, float g, float b)
Definition: BOpcodeHandler.h:1857
void SetLodRatio(float r)
Definition: BOpcodeHandler.h:3626
void SetDPoint(double const p[])
Definition: BOpcodeHandler.h:5474
TK_Visibility(void)
Definition: BOpcodeHandler.h:4269
char const * GetOcclusionMap() const
Definition: BOpcodeHandler.h:2296
int GetColorMarkerForcedLockValue() const
Definition: BOpcodeHandler.h:3233
int m_control_point_count
Definition: BOpcodeHandler.h:5617
char m_index
internal use
Definition: BOpcodeHandler.h:4459
char * GetReference()
Definition: BOpcodeHandler.h:7108
self-explanatory
Definition: BOpcodeEnums.h:269
void SetSimpleShadowColor(float const rgb[])
Definition: BOpcodeHandler.h:3830
void SetColorLineContrastForcedLockMask(int m)
Definition: BOpcodeHandler.h:3401
float GetStart() const
Definition: BOpcodeHandler.h:5666
int m_related
internal use
Definition: BOpcodeHandler.h:3970
int * m_indices
for internal use only
Definition: BOpcodeHandler.h:4839
void SetUp(int m)
Definition: BOpcodeHandler.h:4368
void SetMask(int m)
Definition: BOpcodeHandler.h:5194
void SetGeometryOptionsMask(int m)
Definition: BOpcodeHandler.h:3724
float const * GetPoints() const
Definition: BOpcodeHandler.h:5582
Lock_Masks m_forced
For internal use only.
Definition: BOpcodeHandler.h:2443
int GetOptions() const
Definition: BOpcodeHandler.h:6004
int GetLength()
Definition: BOpcodeHandler.h:4739
void SetValueScale(float v1, float v2)
Definition: BOpcodeHandler.h:7310
void SetCenter(float x, float y, float z)
Definition: BOpcodeHandler.h:6125
float const * GetLodBounding() const
Definition: BOpcodeHandler.h:3623
int GetLockMask() const
Definition: BOpcodeHandler.h:2688
char * m_camera
Definition: BOpcodeHandler.h:7164
float const * GetRadii() const
Definition: BOpcodeHandler.h:6565
int m_image_length
Definition: BOpcodeHandler.h:7167
int GetIndex() const
Definition: BOpcodeHandler.h:4475
TK_Selectability(void)
Definition: BOpcodeHandler.h:4328
void SetColorEdgeForcedLockValue(int v)
Definition: BOpcodeHandler.h:3182
float const * GetScreenRange() const
Definition: BOpcodeHandler.h:3908
char const * GetString() const
Definition: BOpcodeHandler.h:2176
int m_length
Definition: BOpcodeHandler.h:7955
float const * GetLodThresholds() const
Definition: BOpcodeHandler.h:3661
int GetOcclusionMapChannel() const
Definition: BOpcodeHandler.h:2354
unsigned char m_format
internal use
Definition: BOpcodeHandler.h:1639
unsigned short m_shadow_map_resolution
For internal use only.
Definition: BOpcodeHandler.h:2548
float m_hlr_face_displacement
For internal use only.
Definition: BOpcodeHandler.h:2451
int m_tmp
Definition: BOpcodeHandler.h:6793
Handles the TKE_Ellipse and TKE_Elliptical_Arc opcodes.
Definition: BOpcodeHandler.h:6208
float const * GetCenter() const
Definition: BOpcodeHandler.h:6147
short m_fbe_value
For internal use only.
Definition: BOpcodeHandler.h:2583
void SetDRef2(double x, double y, double z)
Definition: BOpcodeHandler.h:6712
int GetBufferOptionsValue() const
Definition: BOpcodeHandler.h:3498
float horizontal_offset
offset, positive or negative, from the standard position. units are specified separately in horizonta...
Definition: BOpcodeHandler.h:6747
int GetSize() const
Definition: BOpcodeHandler.h:7854
char * m_name
The name of the color channel.
Definition: BOpcodeHandler.h:1724
self-explanatory
Definition: BOpcodeEnums.h:268
Definition: BOpcodeHandler.h:6741
void SetDAxis(double x, double y, double z)
Definition: BOpcodeHandler.h:6378
TK_Status Interpret(BStreamFileToolkit &tk, ID_Key key, char const *special)
Definition: BOpcodeHandler.h:1689
void SetDMajor(double x, double y, double z)
Definition: BOpcodeHandler.h:6264
void SetForcedLockMask(int m)
Definition: BOpcodeHandler.h:3089
void SetSpecular(float r, float g, float b)
Definition: BOpcodeHandler.h:1812
void SetColorMarkerLockValue(int v)
Definition: BOpcodeHandler.h:2825
int * m_lengths
Definition: BOpcodeHandler.h:7735
void **const GetValues()
Definition: BOpcodeHandler.h:4881
int m_cond_allocated
Definition: BOpcodeHandler.h:1294
void SetTransforms(int t)
Definition: BOpcodeHandler.h:5287
Handles the TKE_Grid opcode.
Definition: BOpcodeHandler.h:6636
char * GetCamera()
Definition: BOpcodeHandler.h:7248
void SetBumpName(int length)
Definition: BOpcodeHandler.h:1883
static TK_Status PutData(BStreamFileToolkit &tk, short const &s)
Definition: BOpcodeHandler.h:453
static TK_Status PutData(BStreamFileToolkit &tk, unsigned char const *b, int n)
Definition: BOpcodeHandler.h:441
refer to ::HC_Set_Heuristics
Definition: BOpcodeEnums.h:906
float color[3]
the color. RGB triplet
Definition: BOpcodeHandler.h:6744
void adjust_written(BStreamFileToolkit &tk, int count)
for internal use only
Definition: BOpcodeHandler.h:657
float const * GetPoints() const
Definition: BOpcodeHandler.h:7696
int m_size
internal use
Definition: BOpcodeHandler.h:1674
int GetColorLineForcedLockMask() const
Definition: BOpcodeHandler.h:3199
BBaseOpcodeHandler * m_referee
for internal use only
Definition: BOpcodeHandler.h:1391
int m_from_index
internal use
Definition: BOpcodeHandler.h:1452
float m_hlr_dim_factor
For internal use only.
Definition: BOpcodeHandler.h:2450
bool m_follow
for internal use only
Definition: BOpcodeHandler.h:7518
float const * GetSimpleShadowPlane() const
Definition: BOpcodeHandler.h:3824
int m_curve_continued_budget
For internal use only.
Definition: BOpcodeHandler.h:2504
void SetCounts(int c1, int c2)
Definition: BOpcodeHandler.h:6724
int m_length
Definition: BOpcodeHandler.h:4658
indicates that the 2nd byte should be written
Definition: BOpcodeEnums.h:778
char * m_segment
Definition: BOpcodeHandler.h:7510
float GetRadius() const
Definition: BOpcodeHandler.h:6458
float const * GetPlanes() const
Definition: BOpcodeHandler.h:6060
unsigned char m_depth_peeling_layers
For internal use only.
Definition: BOpcodeHandler.h:2571
float m_cut_geometry_edge_weight
for internal use only.
Definition: BOpcodeHandler.h:2534
void SetCenter(float const s[])
Definition: BOpcodeHandler.h:6329
int GetColorLockValue() const
Definition: BOpcodeHandler.h:2738
int GetGeometry() const
Definition: BOpcodeHandler.h:1994
virtual TK_Status Write(BStreamFileToolkit &tk)=0
void SetOptions(int opt)
Definition: BOpcodeHandler.h:5124
TK_Status GetGeneral(BStreamFileToolkit &tk)
Definition: BOpcodeHandler.h:330
void SetLodBounding(float x1, float y1, float z1, float x2, float y2, float z2)
Definition: BOpcodeHandler.h:3612
int m_isoline_position_count
for internal use only.
Definition: BOpcodeHandler.h:2467
void SetDField(double w, double h)
Definition: BOpcodeHandler.h:5035
float * GetPoints()
Definition: BOpcodeHandler.h:5654
double const * GetDRef1() const
Definition: BOpcodeHandler.h:6707
double const * GetDAxis() const
Definition: BOpcodeHandler.h:6386
Flags
Definition: BOpcodeHandler.h:6403
short color_simple_reflection_mask
For internal use only.
Definition: BOpcodeHandler.h:1092
void SetColorTextLockMask(int m)
Definition: BOpcodeHandler.h:2837
extended bit
Definition: BOpcodeEnums.h:826
void SetLodTolerance(float v)
Definition: BOpcodeHandler.h:3603
int GetTessellationMask() const
Definition: BOpcodeHandler.h:3687
void SetPosition(float x, float y, float z)
Definition: BOpcodeHandler.h:5955
void SetOptions(int o)
Definition: BOpcodeHandler.h:5852
int m_cond_length
Definition: BOpcodeHandler.h:1293
float m_curve_max_length
For internal use only.
Definition: BOpcodeHandler.h:2513
int m_isoline_pattern_count
for internal use only.
Definition: BOpcodeHandler.h:2471
char * GetBytes()
Definition: BOpcodeHandler.h:7090
double const * GetDEnd() const
Definition: BOpcodeHandler.h:6194
bool Find_Instance(BStreamFileToolkit &tk, int val1, int val2, int val3)
Definition: BOpcodeHandler.h:680
int m_substage
tracks progress of reading individual opcode handler arrays.
Definition: BOpcodeHandler.h:1513
int GetLodMaxDegree() const
Definition: BOpcodeHandler.h:3601
void SetDPlane(double const p[])
Definition: BOpcodeHandler.h:6052
int m_culling
internal use; culling options
Definition: BOpcodeHandler.h:3975
Handles the TKE_PBR opcode.
Definition: BOpcodeHandler.h:2192
float * m_knots
Definition: BOpcodeHandler.h:5622
char m_options
internal use
Definition: BOpcodeHandler.h:5875
void SetPosition(float x, float y, float z)
Definition: BOpcodeHandler.h:4966
static TK_Status GetData(BStreamFileToolkit &tk, char &c)
Definition: BOpcodeHandler.h:305
void SetFaceDisplacement(int d)
Definition: BOpcodeHandler.h:2658
char * GetBytes()
Definition: BOpcodeHandler.h:6961
Handles the TKE_User_Value opcode.
Definition: BOpcodeHandler.h:4897
void SetHlrFaceSortingAlgorithm(int a)
Definition: BOpcodeHandler.h:3539
short color_cut_edge_value
For internal use only.
Definition: BOpcodeHandler.h:1097
int GetPixelThreshold() const
Definition: BOpcodeHandler.h:4063
void SetValues(int count, float const values[]=0)
Definition: BOpcodeHandler.h:2155
float GetStart() const
Definition: BOpcodeHandler.h:5760
extended bit for HLR suboptions; refer to ::HC_Set_Rendering_Options for description ...
Definition: BOpcodeEnums.h:666
char * m_string
Definition: BOpcodeHandler.h:4707
void SetColorTextContrastLockMask(int m)
Definition: BOpcodeHandler.h:3067
Handles the TKE_Color_By_FIndex opcode.
Definition: BOpcodeHandler.h:2068
double const * GetDCenter() const
Definition: BOpcodeHandler.h:6196
int m_mask
internal use
Definition: BOpcodeHandler.h:3967
void SetImageTintColor(float r, float g, float b)
Definition: BOpcodeHandler.h:3929
unsigned char m_cut_geometry_level
For internal use only.
Definition: BOpcodeHandler.h:2531
short color_vertex_contrast_value
For internal use only.
Definition: BOpcodeHandler.h:1089
char * m_data
Definition: BOpcodeHandler.h:7411
short color_vertex_value
For internal use only.
Definition: BOpcodeHandler.h:1081
int GetColorMarkerLockValue() const
Definition: BOpcodeHandler.h:2830
unsigned char m_hlr_threshold_units
for internal use only.
Definition: BOpcodeHandler.h:2458
int GetTextRegionCount() const
Definition: BOpcodeHandler.h:6851
void SetType(int t)
Definition: BOpcodeHandler.h:6947
int GetOptions() const
Definition: BOpcodeHandler.h:5126
float m_tolerance
for internal use only
Definition: BOpcodeHandler.h:5146
void SetDOrigin(double x, double y, double z)
Definition: BOpcodeHandler.h:6690
void SetSimpleShadowPlane(float a, float b, float c, float d)
Definition: BOpcodeHandler.h:3815
void SetFormat(int f)
Definition: BOpcodeHandler.h:2147
int GetOptions() const
Definition: BOpcodeHandler.h:5921
int GetVersion() const
Definition: BStreamFileToolkit.h:972
void SetCenter(float x, float y, float z)
Definition: BOpcodeHandler.h:6325
int m_isoline_color_count
for internal use only.
Definition: BOpcodeHandler.h:2469
static TK_Status PutData(BStreamFileToolkit &tk, unsigned short const &s)
Definition: BOpcodeHandler.h:462
void SetDPoint(double x, double y, double z)
Definition: BOpcodeHandler.h:5472
Capping_Options
Definition: BOpcodeHandler.h:6491
char * GetOptions()
Definition: BOpcodeHandler.h:4737
char const * GetShaderSource() const
Definition: BOpcodeHandler.h:7228
char * GetMirrorName()
Definition: BOpcodeHandler.h:1839
double const * GetDPoints() const
Definition: BOpcodeHandler.h:5590
float const * GetCutVisualizationColor() const
Definition: BOpcodeHandler.h:4242
void GetPosition(float p[]) const
Definition: BOpcodeHandler.h:4973
entity is double precision
Definition: BStream.h:353
void SetOcclusionMap(int length)
Definition: BOpcodeHandler.h:2294
double * GetDMatrix()
Definition: BOpcodeHandler.h:4448
float * GetLodCutoffs()
Definition: BOpcodeHandler.h:3681
bool m_jpeg_native
Definition: BOpcodeHandler.h:7048
float GetNormalFactor() const
Definition: BOpcodeHandler.h:2318
void SetGeometry(int m)
Definition: BOpcodeHandler.h:4282
void SetColorVertexLockValue(int v)
Definition: BOpcodeHandler.h:2963
int GetColorEdgeContrastForcedLockMask() const
Definition: BOpcodeHandler.h:3383
int m_invisible
internal use; specifies what geometry is selectable even when invisible. For internal use only...
Definition: BOpcodeHandler.h:4324
int GetColorFaceContrastLockValue() const
Definition: BOpcodeHandler.h:2899
void SetSimpleShadowColor(float r, float g, float b)
Definition: BOpcodeHandler.h:3827
void SetDCenter(double x, double y, double z)
Definition: BOpcodeHandler.h:6255
void SetMask(int m)
Definition: BOpcodeHandler.h:4194
void SetRGB(float r, float g, float b)
Definition: BOpcodeHandler.h:1944
void SetDOrtho(double const s[])
Definition: BOpcodeHandler.h:6395