/************
*
*   This file is part of a tool for producing 3D content in the PRC format.
*   Copyright (C) 2008  Orest Shardt <shardtor (at) gmail dot com> and
*                       Michail Vidiassov <master@iaas.msu.ru>
*
*   This program is free software: you can redistribute it and/or modify
*   it under the terms of the GNU Lesser General Public License as published by
*   the Free Software Foundation, either version 3 of the License, or
*   (at your option) any later version.
*
*   This program is distributed in the hope that it will be useful,
*   but WITHOUT ANY WARRANTY; without even the implied warranty of
*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*   GNU Lesser General Public License for more details.
*
*   You should have received a copy of the GNU Lesser General Public License
*   along with this program.  If not, see <http://www.gnu.org/licenses/>.
*
*************/

#include "prc/writePRC.h"
#include <cassert>
#include <climits>

// debug print includes
#include <iostream>
#include <iomanip>
#include <fstream>
#include <sstream>

#if !defined(__GNUC__) || defined(__clang__)
#include <vector>
#endif

using namespace std;

#ifndef __GNUC_PREREQ
#define __GNUC_PREREQ(maj, min) (0)
#endif

// Count leading zeros.
uint32_t CLZ(uint32_t a)
{
#if __GNUC_PREREQ(3,4)
  return __builtin_clz(a);
#else
// find the log base 2 of a 32-bit integer
  static const int MultiplyDeBruijnBitPosition[32] = {
    0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30,
    8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31
  };

  a |= a >> 1; // first round down to one less than a power of 2
  a |= a >> 2;
  a |= a >> 4;
  a |= a >> 8;
  a |= a >> 16;

  return 31-MultiplyDeBruijnBitPosition[(uint32_t)(a * 0x07C4ACDDU) >> 27];
#endif
}

// Portable integer implementation of ceil(log2(x)).
uint32_t Log2(uint32_t x)
{
  assert(x != 0);
  uint32_t L=31-CLZ(x);
  return ((uint32_t) 1 << L == x) ? L : L+1;
}

#define WriteUnsignedInteger( value ) pbs << (uint32_t)(value);
#define WriteInteger( value ) pbs << (int32_t)(value);
#define WriteCharacter( value ) pbs << (uint8_t)(value);
#define WriteDouble( value ) pbs << (double)(value);
#define WriteBit( value ) pbs << (bool)(value);
#define WriteBoolean( value ) pbs << (bool)(value);
#define WriteString( value ) pbs << (value);
#define SerializeContentPRCBase serializeContentPRCBase(pbs);
#define SerializeGraphics serializeGraphics(pbs);
#define SerializePRCBaseWithGraphics { serializeContentPRCBase(pbs); serializeGraphics(pbs); }
#define SerializeRepresentationItemContent serializeRepresentationItemContent(pbs);
#define SerializeRepresentationItem( value ) (value)->serializeRepresentationItem(pbs);
#define SerializeMarkup( value ) (value).serializeMarkup(pbs);
#define SerializeReferenceUniqueIdentifier( value ) (value).serializeReferenceUniqueIdentifier(pbs);
#define SerializeContentBaseTessData serializeContentBaseTessData(pbs);
#define SerializeTessFace( value ) (value)->serializeTessFace(pbs);
#define SerializeUserData UserData(0,0).write(pbs);
#define SerializeLineAttr( value ) pbs << (uint32_t)((value)+1);
#define SerializeVector3d( value ) (value).serializeVector3d(pbs);
#define SerializeVector2d( value ) (value).serializeVector2d(pbs);
#define SerializeName( value ) writeName(pbs, (value));
#define SerializeInterval( value )  (value).serializeInterval(pbs);
// #define SerializeBoundingBox( value )  (value).serializeBoundingBox(pbs);
#define SerializeDomain( value )  (value).serializeDomain(pbs);
#define SerializeParameterization  serializeParameterization(pbs);
#define SerializeUVParameterization  serializeUVParameterization(pbs);
#define SerializeTransformation  serializeTransformation(pbs);
#define SerializeBaseTopology  serializeBaseTopology(pbs);
#define SerializeBaseGeometry  serializeBaseGeometry(pbs);
#define SerializePtrCurve( value )    {WriteBoolean( false ); if((value)==NULL) pbs << (uint32_t)PRC_TYPE_ROOT; else (value)->serializeCurve(pbs);}
#define SerializePtrSurface( value )  {WriteBoolean( false ); if((value)==NULL) pbs << (uint32_t)PRC_TYPE_ROOT; else (value)->serializeSurface(pbs);}
#define SerializePtrTopology( value ) {WriteBoolean( false ); if((value)==NULL) pbs << (uint32_t)PRC_TYPE_ROOT; else (value)->serializeTopoItem(pbs);}
#define SerializeContentCurve  serializeContentCurve(pbs);
#define SerializeContentWireEdge  serializeContentWireEdge(pbs);
#define SerializeContentBody  serializeContentBody(pbs);
#define SerializeTopoContext  serializeTopoContext(pbs);
#define SerializeContextAndBodies( value )  (value).serializeContextAndBodies(pbs);
#define SerializeBody( value )  (value)->serializeBody(pbs);
#define ResetCurrentGraphics resetGraphics();
#define SerializeContentSurface  serializeContentSurface(pbs);
#define SerializeCompressedUniqueId( value ) (value).serializeCompressedUniqueId(pbs);
#define SerializeUnit( value ) (value).serializeUnit(pbs);
#define SerializeBoundingBox serializeBoundingBox(pbs);
#define SerializeAttributeEntry serializeAttributeEntry(pbs);
#define SerializeContentSingleAttribute( value ) (value).serializeSingleAttribute(pbs);
#define SerializeAttribute( value ) (value).serializeAttribute(pbs);
#define SerializeAttributeData serializeAttributes(pbs);
#define WriteUncompressedUnsignedInteger( value ) writeUncompressedUnsignedInteger(out, (uint32_t)(value));
#define SerializeFileStructureUncompressedUniqueId( value ) (value).serializeFileStructureUncompressedUniqueId(out);

void writeUncompressedUnsignedInteger(ostream &out, uint32_t data)
{
#ifdef WORDS_BIGENDIAN
  out.write(((char*)&data)+3,1);
  out.write(((char*)&data)+2,1);
  out.write(((char*)&data)+1,1);
  out.write(((char*)&data)+0,1);
#else
  out.write(((char*)&data)+0,1);
  out.write(((char*)&data)+1,1);
  out.write(((char*)&data)+2,1);
  out.write(((char*)&data)+3,1);
#endif
}

double PRCVector3d::Length()
{
  return sqrt(x*x+y*y+z*z);
}

bool PRCVector3d::Normalize()
{
 double fLength=Length();
 if(fLength < FLT_EPSILON) return false;
 double factor=1.0/fLength;
 x *= factor;
 y *= factor;
 z *= factor;
 return true;
}

double PRCVector2d::Length()
{
  return sqrt(x*x+y*y);
}

bool PRCVector2d::Normalize()
{
  double fLength=Length();
  if(fLength < FLT_EPSILON) return false;
  double factor=1.0/fLength;
  x *= factor;
  y *= factor;

  return true;
}

void PRCVector2d::serializeVector2d(PRCbitStream &pbs)
{
  WriteDouble (x)
  WriteDouble (y)
}

uint32_t makeCADID()
{
  static uint32_t ID = 1;
  return ID++;
}

uint32_t makePRCID()
{
  static uint32_t ID = 1;
  return ID++;
}

bool type_eligible_for_reference(uint32_t type)
{
  if(
     type == PRC_TYPE_MISC_EntityReference ||
     type == PRC_TYPE_MISC_MarkupLinkedItem ||
     type == PRC_TYPE_RI_BrepModel ||
     type == PRC_TYPE_RI_Curve ||
     type == PRC_TYPE_RI_Direction ||
     type == PRC_TYPE_RI_Plane ||
     type == PRC_TYPE_RI_PointSet ||
     type == PRC_TYPE_RI_PolyBrepModel ||
     type == PRC_TYPE_RI_PolyWire ||
     type == PRC_TYPE_RI_Set ||
     type == PRC_TYPE_RI_CoordinateSystem ||
     type == PRC_TYPE_ASM_ProductOccurence ||
     type == PRC_TYPE_ASM_PartDefinition ||
     type == PRC_TYPE_ASM_Filter ||
     type == PRC_TYPE_MKP_View ||
     type == PRC_TYPE_MKP_Markup ||
     type == PRC_TYPE_MKP_Leader ||
     type == PRC_TYPE_MKP_AnnotationItem ||
     type == PRC_TYPE_MKP_AnnotationSet ||
     type == PRC_TYPE_MKP_AnnotationReference ||
     type == PRC_TYPE_GRAPH_Style ||
     type == PRC_TYPE_GRAPH_Material ||
     type == PRC_TYPE_GRAPH_TextureApplication ||
     type == PRC_TYPE_GRAPH_TextureDefinition ||
     type == PRC_TYPE_GRAPH_LinePattern ||
     type == PRC_TYPE_GRAPH_DottingPattern ||
     type == PRC_TYPE_GRAPH_HatchingPattern ||
     type == PRC_TYPE_GRAPH_SolidPattern ||
     type == PRC_TYPE_GRAPH_VPicturePattern ||
     type == PRC_TYPE_GRAPH_AmbientLight ||
     type == PRC_TYPE_GRAPH_PointLight ||
     type == PRC_TYPE_GRAPH_DirectionalLight ||
     type == PRC_TYPE_GRAPH_SpotLight ||
     type == PRC_TYPE_GRAPH_SceneDisplayParameters ||
     type == PRC_TYPE_GRAPH_Camera
    )
    return true;
  else
    return false;
}

void UserData::write(PRCbitStream &pbs)
{
  pbs << size;
  if(size > 0) {
    uint32_t quot=size/8;
    uint32_t rem=size-8*quot;
    for(uint32_t i = 0; i < quot; ++i)
      pbs << data[i];
    for(uint32_t j = 0; j < rem; ++j) // 0-based, big endian bit counting
      pbs << (bool)((data[quot] & (0x80 >> j))!=0);
  }
}

void PRCAttributeEntry::serializeAttributeEntry(PRCbitStream &pbs) const
{
  WriteBoolean (title_is_integer)
  if (title_is_integer)
    WriteUnsignedInteger (title_integer)
  else
    WriteString (title_text)
}

void PRCSingleAttribute::serializeSingleAttribute(PRCbitStream &pbs) const
{
  SerializeAttributeEntry
  WriteUnsignedInteger (type)
  switch (type)
  {
    case KEPRCModellerAttributeTypeInt:
      WriteInteger (value.integer)
      break;
    case KEPRCModellerAttributeTypeReal:
      WriteDouble (value.real)
      break;
    case KEPRCModellerAttributeTypeTime:
      WriteUnsignedInteger (value.time)
      break;
    case KEPRCModellerAttributeTypeString:
      WriteString (value_text)
      break;
    default:
      break;
  }
}

void PRCAttribute::serializeAttribute(PRCbitStream &pbs) const
{
  WriteUnsignedInteger (PRC_TYPE_MISC_Attribute)

  SerializeAttributeEntry
  const uint32_t size_of_attribute_keys = attribute_keys.size();
  WriteUnsignedInteger (size_of_attribute_keys)
  for(uint32_t i=0;i<size_of_attribute_keys;i++)
    SerializeContentSingleAttribute (attribute_keys[i])
}

void PRCAttributes::serializeAttributes(PRCbitStream &pbs) const
{
  if (attributes.empty()) { // shortcut for most typical case
    const uint32_t number_of_attributes = 0;
    WriteUnsignedInteger (number_of_attributes)
    return;
  }
  const uint32_t number_of_attributes = attributes.size();
  WriteUnsignedInteger (number_of_attributes)
  for(PRCAttributeList::const_iterator it = attributes.begin(); it != attributes.end(); ++it)
  {
    SerializeAttribute(*it)
  }
}

void ContentPRCBase::serializeContentPRCBase(PRCbitStream &pbs) const
{
  SerializeAttributeData

  SerializeName (name)
  if (type_eligible_for_reference(type))
  {
    WriteUnsignedInteger (CAD_identifier)
    WriteUnsignedInteger (CAD_persistent_identifier)
    WriteUnsignedInteger (PRC_unique_identifier)
  }
}


bool IsCompressedType(uint32_t type)
{
  return (type == PRC_TYPE_TOPO_BrepDataCompress || type == PRC_TYPE_TOPO_SingleWireBodyCompress || type == PRC_TYPE_TESS_3D_Compressed);
}

void PRCReferenceUniqueIdentifier::serializeReferenceUniqueIdentifier(PRCbitStream &pbs)
{
  WriteUnsignedInteger (PRC_TYPE_MISC_ReferenceOnPRCBase)
  WriteUnsignedInteger (type)
  const bool reference_in_same_file_structure = true;
  WriteBoolean (reference_in_same_file_structure)
// if (!reference_in_same_file_structure)
//    SerializeCompressedUniqueId (target_file_structure)
  WriteUnsignedInteger (unique_identifier)
}

void PRCRgbColor::serializeRgbColor(PRCbitStream &pbs)
{
  WriteDouble (red)
  WriteDouble (green)
  WriteDouble (blue)
}

void PRCPicture::serializePicture(PRCbitStream &pbs)
{
  WriteUnsignedInteger (PRC_TYPE_GRAPH_Picture)
  SerializeContentPRCBase
  WriteInteger (format) //see Types for picture files
  WriteUnsignedInteger (uncompressed_file_index+1)
  WriteUnsignedInteger (pixel_width)
  WriteUnsignedInteger (pixel_height)
}

void PRCTextureDefinition::serializeTextureDefinition(PRCbitStream &pbs)
{
  uint32_t i=0; // universal index for PRC standart compatibility
  const uint8_t texture_dimension = 2;
  const uint32_t texture_mapping_attributes = texture_mapping_attribute;
  const uint32_t size_texture_mapping_attributes_intensities = 1;
  const double *texture_mapping_attributes_intensities = &texture_mapping_attribute_intensity;
  const uint32_t size_texture_mapping_attributes_components = 1;
  const uint8_t *texture_mapping_attributes_components = &texture_mapping_attribute_components;
  const EPRCTextureMappingType eMappingType = KEPRCTextureMappingType_Stored;

  const double red = 1.0;
  const double green = 1.0;
  const double blue = 1.0;
  const double alpha = 1.0;
  const EPRCTextureBlendParameter blend_src_rgb = KEPRCTextureBlendParameter_Unknown;
  const EPRCTextureBlendParameter blend_dst_rgb = KEPRCTextureBlendParameter_Unknown;
  const EPRCTextureBlendParameter blend_src_alpha = KEPRCTextureBlendParameter_Unknown;
  const EPRCTextureBlendParameter blend_dst_alpha = KEPRCTextureBlendParameter_Unknown;
  const EPRCTextureAlphaTest alpha_test = KEPRCTextureAlphaTest_Unknown;
  const double alpha_test_reference = 1.0;
  const EPRCTextureWrappingMode texture_wrapping_mode_R = KEPRCTextureWrappingMode_ClampToBorder;
  const bool texture_transformation = false;

  WriteUnsignedInteger (PRC_TYPE_GRAPH_TextureDefinition)

  SerializeContentPRCBase

  WriteUnsignedInteger (picture_index+1)
  WriteCharacter (texture_dimension)

  //   SerializeTextureMappingType
  WriteInteger (eMappingType) // Texture mapping type
  //  if (eMappingType == TEXTURE_MAPPING_OPERATOR)
  //  {
  //     WriteInteger (eMappingOperator) // Texture mapping operator
  //     WriteInteger (transformation)
  //     if (transformation)
  //        SerializeCartesianTransformation3d (transformation)
  //  }

  WriteUnsignedInteger (texture_mapping_attributes) // Texture mapping attributes
  WriteUnsignedInteger (size_texture_mapping_attributes_intensities)
  for (i=0;i<size_texture_mapping_attributes_intensities;i++)
     WriteDouble (texture_mapping_attributes_intensities[i])
  WriteUnsignedInteger (size_texture_mapping_attributes_components)
  for (i=0;i<size_texture_mapping_attributes_components;i++)
     WriteCharacter (texture_mapping_attributes_components[i])

  WriteInteger (texture_function)
  // reserved for future use; see Texture function
  if (texture_function == KEPRCTextureFunction_Blend)
  {
     WriteDouble (red) // blend color component in the range [0.0,1.0]
     WriteDouble (green) // blend color component in the range [0.0,1.0]
     WriteDouble (blue) // blend color component in the range [0.0,1.0]
     WriteDouble (alpha) // blend color component in the range [0.0,1.0]
  }

  WriteInteger (blend_src_rgb) // Texture blend parameter
  // reserved for future use; see Texture blend parameter
  if (blend_src_rgb != KEPRCTextureBlendParameter_Unknown)
     WriteInteger (blend_dst_rgb) // Texture blend parameter

  WriteInteger (blend_src_alpha) // Texture blend parameter
  // reserved for future use; see Texture blend parameter
  if (blend_src_alpha != KEPRCTextureBlendParameter_Unknown)
     WriteInteger (blend_dst_alpha) // Texture blend parameter

  WriteCharacter (texture_applying_mode) // Texture applying mode
  if (texture_applying_mode & PRC_TEXTURE_APPLYING_MODE_ALPHATEST)
  {
     WriteInteger (alpha_test) // Texture alpha test
     WriteDouble (alpha_test_reference)
  }

  WriteInteger (texture_wrapping_mode_S) // Texture wrapping mode
  if (texture_dimension > 1)
     WriteInteger (texture_wrapping_mode_T) // Texture wrapping mode
  if (texture_dimension > 2 )
     WriteInteger (texture_wrapping_mode_R) // Texture wrapping mode

  WriteBit (texture_transformation)
//  if (texture_transformation)
//     SerializeTextureTransformation (texture_transformation)
}

void PRCMaterialGeneric::serializeMaterialGeneric(PRCbitStream &pbs)
{
  WriteUnsignedInteger (PRC_TYPE_GRAPH_Material)
  SerializeContentPRCBase
  WriteUnsignedInteger (ambient + 1)
  WriteUnsignedInteger (diffuse + 1)
  WriteUnsignedInteger (emissive + 1)
  WriteUnsignedInteger (specular + 1)
  WriteDouble (shininess)
  WriteDouble (ambient_alpha)
  WriteDouble (diffuse_alpha)
  WriteDouble (emissive_alpha)
  WriteDouble (specular_alpha)
}

void PRCTextureApplication::serializeTextureApplication(PRCbitStream &pbs)
{
  WriteUnsignedInteger (PRC_TYPE_GRAPH_TextureApplication)
  SerializeContentPRCBase

  WriteUnsignedInteger (material_generic_index+1)
  WriteUnsignedInteger (texture_definition_index+1)
  WriteUnsignedInteger (next_texture_index+1)
  WriteUnsignedInteger (UV_coordinates_index+1)
}

void PRCLinePattern::serializeLinePattern(PRCbitStream &pbs)
{
  uint32_t i = 0;
  WriteUnsignedInteger (PRC_TYPE_GRAPH_LinePattern)
  SerializeContentPRCBase

  const uint32_t size_lengths = lengths.size();
  WriteUnsignedInteger (size_lengths)
  for (i=0;i<size_lengths;i++)
    WriteDouble (lengths[i])
  WriteDouble (phase)
  WriteBoolean (is_real_length)
}


void PRCStyle::serializeCategory1LineStyle(PRCbitStream &pbs)
{
  const bool is_additional_1_defined = (additional!=0);
  const uint8_t additional_1 = additional;
  const bool is_additional_2_defined = false;
  const uint8_t additional_2 = 0;
  const bool is_additional_3_defined = false;
  const uint8_t additional_3 = 0;
  WriteUnsignedInteger (PRC_TYPE_GRAPH_Style)
  SerializeContentPRCBase
  WriteDouble (line_width)
  WriteBoolean (is_vpicture)
  WriteUnsignedInteger (line_pattern_vpicture_index + 1)
  WriteBoolean (is_material)
  WriteUnsignedInteger (color_material_index + 1)
  WriteBoolean (is_transparency_defined)
  if (is_transparency_defined)
     WriteCharacter (transparency)
  WriteBoolean (is_additional_1_defined)
  if (is_additional_1_defined)
     WriteCharacter (additional_1)
  WriteBoolean (is_additional_2_defined)
  if (is_additional_2_defined)
     WriteCharacter (additional_2)
  WriteBoolean (is_additional_3_defined)
  if (is_additional_3_defined)
     WriteCharacter (additional_3)
}

std::string currentName;

void writeName(PRCbitStream &pbs,const std::string &name)
{
  pbs << (name == currentName);
  if(name != currentName)
  {
    pbs << name;
    currentName = name;
  }
}

void resetName()
{
  currentName = "";
}

uint32_t current_layer_index = m1;
uint32_t current_index_of_line_style = m1;
uint16_t current_behaviour_bit_field = 1;

void writeGraphics(PRCbitStream &pbs,uint32_t l,uint32_t i,uint16_t b,bool force)
{
  if(force || current_layer_index != l || current_index_of_line_style != i || current_behaviour_bit_field != b)
  {
    pbs << false << (uint32_t)(l+1) << (uint32_t)(i+1)
        << (uint8_t)(b&0xFF) << (uint8_t)((b>>8)&0xFF);
    current_layer_index = l;
    current_index_of_line_style = i;
    current_behaviour_bit_field = b;
  }
  else
    pbs << true;
}

void writeGraphics(PRCbitStream &pbs,const PRCGraphics &graphics,bool force)
{
  if(force || current_layer_index != graphics.layer_index || current_index_of_line_style != graphics.index_of_line_style || current_behaviour_bit_field != graphics.behaviour_bit_field)
  {
    pbs << false
        << (uint32_t)(graphics.layer_index+1)
        << (uint32_t)(graphics.index_of_line_style+1)
        << (uint8_t)(graphics.behaviour_bit_field&0xFF)
        << (uint8_t)((graphics.behaviour_bit_field>>8)&0xFF);
    current_layer_index = graphics.layer_index;
    current_index_of_line_style = graphics.index_of_line_style;
    current_behaviour_bit_field = graphics.behaviour_bit_field;
  }
  else
    pbs << true;
}

void PRCGraphics::serializeGraphics(PRCbitStream &pbs)
{
  if(current_layer_index != this->layer_index || current_index_of_line_style != this->index_of_line_style || current_behaviour_bit_field != this->behaviour_bit_field)
  {
    pbs << false
        << (uint32_t)(this->layer_index+1)
        << (uint32_t)(this->index_of_line_style+1)
        << (uint8_t)(this->behaviour_bit_field&0xFF)
        << (uint8_t)((this->behaviour_bit_field>>8)&0xFF);
    current_layer_index = this->layer_index;
    current_index_of_line_style = this->index_of_line_style;
    current_behaviour_bit_field = this->behaviour_bit_field;
  }
  else
    pbs << true;
}

void PRCGraphics::serializeGraphicsForced(PRCbitStream &pbs)
{
  pbs << false
      << (uint32_t)(this->layer_index+1)
      << (uint32_t)(this->index_of_line_style+1)
      << (uint8_t)(this->behaviour_bit_field&0xFF)
      << (uint8_t)((this->behaviour_bit_field>>8)&0xFF);
  current_layer_index = this->layer_index;
  current_index_of_line_style = this->index_of_line_style;
  current_behaviour_bit_field = this->behaviour_bit_field;
}

void resetGraphics()
{
  current_layer_index = m1;
  current_index_of_line_style = m1;
  current_behaviour_bit_field = 1;
}

void resetGraphicsAndName()
{
  resetGraphics(); resetName();
}

void  PRCMarkup::serializeMarkup(PRCbitStream &pbs)
{
  WriteUnsignedInteger (PRC_TYPE_MKP_Markup)
  SerializeContentPRCBase
  SerializeGraphics
  WriteUnsignedInteger (type)
  WriteUnsignedInteger (sub_type)
  const uint32_t number_of_linked_items = 0;
  WriteUnsignedInteger (number_of_linked_items)
//  for (i=0;i<number_of_linked_items;i++)
//     SerializeReferenceUniqueIdentifier (linked_items[i])
  const uint32_t number_of_leaders = 0;
  WriteUnsignedInteger (number_of_leaders)
//  for (i=0;i<number_of_leaders;i++)
//     SerializeReferenceUniqueIdentifier (leaders[i])
  WriteUnsignedInteger (index_tessellation + 1)
  SerializeUserData
}

void  PRCAnnotationItem::serializeAnnotationItem(PRCbitStream &pbs)
{
// group___tf_annotation_item_____serialize2.html
// group___tf_annotation_item_____serialize_content2.html
// group___tf_annotation_entity_____serialize_content2.html
  WriteUnsignedInteger (PRC_TYPE_MKP_AnnotationItem)
  SerializeContentPRCBase
  SerializeGraphics
  SerializeReferenceUniqueIdentifier (markup)
  SerializeUserData
}

void  PRCRepresentationItemContent::serializeRepresentationItemContent(PRCbitStream &pbs)
{
  SerializeContentPRCBase
  SerializeGraphics
  WriteUnsignedInteger (index_local_coordinate_system + 1)
  WriteUnsignedInteger (index_tessellation + 1)
}

void  PRCBrepModel::serializeBrepModel(PRCbitStream &pbs)
{
   WriteUnsignedInteger (PRC_TYPE_RI_BrepModel)

   SerializeRepresentationItemContent
   WriteBit (has_brep_data)
   if (has_brep_data)
   {
      WriteUnsignedInteger (context_id+1)
      WriteUnsignedInteger (body_id+1)
   }
   WriteBoolean (is_closed)
   SerializeUserData
}

void  PRCPolyBrepModel::serializePolyBrepModel(PRCbitStream &pbs)
{
   WriteUnsignedInteger (PRC_TYPE_RI_PolyBrepModel)

   SerializeRepresentationItemContent
   WriteBoolean (is_closed)
   SerializeUserData
}

void  PRCPointSet::serializePointSet(PRCbitStream &pbs)
{
  WriteUnsignedInteger (PRC_TYPE_RI_PointSet)

  SerializeRepresentationItemContent

  const uint32_t number_of_points = point.size();
  WriteUnsignedInteger (number_of_points)
  for (uint32_t i=0;i<number_of_points;i++)
  {
     SerializeVector3d (point[i])
  }
  SerializeUserData
}

void  PRCSet::serializeSet(PRCbitStream &pbs)
{
  WriteUnsignedInteger (PRC_TYPE_RI_Set)

  SerializeRepresentationItemContent

  const uint32_t number_of_elements = elements.size();
  WriteUnsignedInteger (number_of_elements)
  for (uint32_t i=0;i<number_of_elements;i++)
  {
    SerializeRepresentationItem (elements[i])
  }
  SerializeUserData
}

uint32_t PRCSet::addBrepModel(PRCBrepModel*& pBrepModel)
{
  elements.push_back(pBrepModel);
  pBrepModel = NULL;
  return elements.size()-1;
}

uint32_t PRCSet::addPolyBrepModel(PRCPolyBrepModel*& pPolyBrepModel)
{
  elements.push_back(pPolyBrepModel);
  pPolyBrepModel = NULL;
  return elements.size()-1;
}

uint32_t PRCSet::addPointSet(PRCPointSet*& pPointSet)
{
  elements.push_back(pPointSet);
  pPointSet  = NULL;
  return elements.size()-1;
}

uint32_t PRCSet::addSet(PRCSet*& pSet)
{
  elements.push_back(pSet);
  pSet = NULL;
  return elements.size()-1;
}

uint32_t PRCSet::addWire(PRCWire*& pWire)
{
  elements.push_back(pWire);
  pWire = NULL;
  return elements.size()-1;
}

uint32_t PRCSet::addPolyWire(PRCPolyWire*& pPolyWire)
{
  elements.push_back(pPolyWire);
  pPolyWire = NULL;
  return elements.size()-1;
}

uint32_t PRCSet::addRepresentationItem(PRCRepresentationItem*& pRepresentationItem)
{
  elements.push_back(pRepresentationItem);
  pRepresentationItem = NULL;
  return elements.size()-1;
}

void  PRCWire::serializeWire(PRCbitStream &pbs)
{
   WriteUnsignedInteger (PRC_TYPE_RI_Curve)

   SerializeRepresentationItemContent
   WriteBit (has_wire_body)
   if (has_wire_body)
   {
      WriteUnsignedInteger (context_id+1)
      WriteUnsignedInteger (body_id+1)
   }

   SerializeUserData
}

void  PRCPolyWire::serializePolyWire(PRCbitStream &pbs)
{
  WriteUnsignedInteger (PRC_TYPE_RI_PolyWire)

  SerializeRepresentationItemContent
  SerializeUserData
}

void  PRCGeneralTransformation3d::serializeGeneralTransformation3d(PRCbitStream &pbs) const
{
  WriteUnsignedInteger (PRC_TYPE_MISC_GeneralTransformation)
  // Like Fortran, PRC uses transposed (column-major) format!
  for (int j=0;j<4;j++)
    for (int i=0;i<4;i++)
     WriteDouble(mat[i][j]);
}

void  PRCCartesianTransformation3d::serializeCartesianTransformation3d(PRCbitStream &pbs) const
{
  WriteUnsignedInteger (PRC_TYPE_MISC_CartesianTransformation)
  WriteCharacter ( behaviour )
  if (behaviour & PRC_TRANSFORMATION_Translate)
     SerializeVector3d ( origin )
  if (behaviour & PRC_TRANSFORMATION_NonOrtho)
  {
     SerializeVector3d ( X )
     SerializeVector3d ( Y )
     SerializeVector3d ( Z )
  }
  else if (behaviour & PRC_TRANSFORMATION_Rotate)
  {
     SerializeVector3d ( X )
     SerializeVector3d ( Y )
  }

  if (behaviour & PRC_TRANSFORMATION_NonUniformScale)
  {
        SerializeVector3d ( scale )
  }
  else if (behaviour & PRC_TRANSFORMATION_Scale)
  {
        WriteDouble ( uniform_scale )
  }

  if (behaviour & PRC_TRANSFORMATION_Homogeneous)
  {
     WriteDouble ( X_homogeneous_coord )
     WriteDouble ( Y_homogeneous_coord )
     WriteDouble ( Z_homogeneous_coord )
     WriteDouble ( origin_homogeneous_coord )
  }
}

void  PRCTransformation::serializeTransformation(PRCbitStream &pbs)
{
   WriteBit ( has_transformation )
   if (has_transformation)
   {
      WriteCharacter ( behaviour )
      if ( geometry_is_2D )
      {
         if (behaviour & PRC_TRANSFORMATION_Translate)
            SerializeVector2d ( origin )
         if (behaviour & PRC_TRANSFORMATION_Rotate)
         {
            SerializeVector2d ( x_axis )
            SerializeVector2d ( y_axis )
         }
         if (behaviour & PRC_TRANSFORMATION_Scale)
            WriteDouble ( scale )
      }
      else
      {
         if (behaviour & PRC_TRANSFORMATION_Translate)
            SerializeVector3d ( origin )
         if (behaviour & PRC_TRANSFORMATION_Rotate)
         {
            SerializeVector3d ( x_axis )
            SerializeVector3d ( y_axis )
         }
         if (behaviour & PRC_TRANSFORMATION_Scale)
            WriteDouble ( scale )
      }
   }
}
void  PRCCoordinateSystem::serializeCoordinateSystem(PRCbitStream &pbs)
{
  WriteUnsignedInteger (PRC_TYPE_RI_CoordinateSystem)

  SerializeRepresentationItemContent
  axis_set->serializeTransformation3d(pbs);
  SerializeUserData
}

void  PRCFontKeysSameFont::serializeFontKeysSameFont(PRCbitStream &pbs)
{
  uint32_t i=0; // universal index for PRC standart compatibility
  WriteString (font_name)
  WriteUnsignedInteger (char_set)
  const uint32_t number_of_font_keys = font_keys.size();
  WriteUnsignedInteger (number_of_font_keys)
  for (i=0;i<number_of_font_keys;i++)
  {
     WriteUnsignedInteger (font_keys[i].font_size + 1)
     WriteCharacter (font_keys[i].attributes)
  }
}

void SerializeArrayRGBA (const std::vector<uint8_t> &rgba_vertices,const bool is_rgba, PRCbitStream &pbs)
{
  uint32_t i = 0;
  uint32_t j = 0;
// number_by_vector can be assigned a value of 3 (RGB) or 4 (RGBA).
// number_of_vectors is equal to number_of_colors / number_by_vector.
  const uint32_t number_by_vector=is_rgba?4:3;
  const std::vector<uint8_t> &vector_color = rgba_vertices;
  const uint32_t number_of_colors=vector_color.size();
  const uint32_t number_of_vectors=number_of_colors / number_by_vector;
  // first one
  for (i=0;i<number_by_vector;i++)
     WriteCharacter (vector_color[i])

  for (i=1;i<number_of_vectors;i++)
  {
     bool b_same = true;
     for (j=0;j<number_by_vector;j++)
     {
        if ((vector_color[i*number_by_vector+j] - vector_color[(i-1)*number_by_vector+j]) != 0)
        {
           b_same = false;
           break;
        }
     }
     WriteBoolean (b_same)
     if (!b_same)
     {
        for (j=0;j<number_by_vector;j++)
           WriteCharacter (vector_color[i*number_by_vector+j])
     }
  }
}

void  PRCTessFace::serializeTessFace(PRCbitStream &pbs)
{
  uint32_t i=0; // universal index for PRC standart compatibility
  WriteUnsignedInteger (PRC_TYPE_TESS_Face)

  const uint32_t size_of_line_attributes=line_attributes.size();
  WriteUnsignedInteger (size_of_line_attributes)
  for (i=0;i<size_of_line_attributes;i++)
     SerializeLineAttr (line_attributes[i])

  WriteUnsignedInteger (start_wire)
  const uint32_t size_of_sizes_wire=sizes_wire.size();
  WriteUnsignedInteger (size_of_sizes_wire)
  for (i=0;i<size_of_sizes_wire;i++)
     WriteUnsignedInteger (sizes_wire[i])

  WriteUnsignedInteger (used_entities_flag)

  WriteUnsignedInteger (start_triangulated)
  const uint32_t size_of_sizes_triangulated=sizes_triangulated.size();
  WriteUnsignedInteger (size_of_sizes_triangulated)
  for (i=0;i<size_of_sizes_triangulated;i++)
     WriteUnsignedInteger (sizes_triangulated[i])

  if(number_of_texture_coordinate_indexes==0 &&
     used_entities_flag &
     (
      PRC_FACETESSDATA_PolyfaceTextured|
      PRC_FACETESSDATA_TriangleTextured|
      PRC_FACETESSDATA_TriangleFanTextured|
      PRC_FACETESSDATA_TriangleStripeTextured|
      PRC_FACETESSDATA_PolyfaceOneNormalTextured|
      PRC_FACETESSDATA_TriangleOneNormalTextured|
      PRC_FACETESSDATA_TriangleFanOneNormalTextured|
      PRC_FACETESSDATA_TriangleStripeOneNormalTextured
     ))
    WriteUnsignedInteger (1)  // workaround for error of not setting number_of_texture_coordinate_indexes
  else
    WriteUnsignedInteger (number_of_texture_coordinate_indexes)

  const bool has_vertex_colors = !rgba_vertices.empty();
  WriteBoolean (has_vertex_colors)
  if (has_vertex_colors)
  {
     WriteBoolean (is_rgba)
     const bool b_optimised=false;
     WriteBoolean (b_optimised)
     if (!b_optimised)
     {
       SerializeArrayRGBA (rgba_vertices, is_rgba, pbs);
     }
     else
     {
     // not described
     }
  }
  if (size_of_line_attributes)
     WriteUnsignedInteger (behaviour)
}

void  PRCContentBaseTessData::serializeContentBaseTessData(PRCbitStream &pbs)
{
  uint32_t i=0; // universal index for PRC standart compatibility
  WriteBoolean (is_calculated)
  const uint32_t number_of_coordinates = coordinates.size();
  WriteUnsignedInteger (number_of_coordinates)
  for (i=0;i<number_of_coordinates;i++)
     WriteDouble (coordinates[i])
}

void  PRC3DTess::serialize3DTess(PRCbitStream &pbs)
{
  uint32_t i=0; // universal index for PRC standart compatibility
  WriteUnsignedInteger (PRC_TYPE_TESS_3D)
  SerializeContentBaseTessData
  WriteBoolean (has_faces)
  WriteBoolean (has_loops)
  const bool must_recalculate_normals=normal_coordinate.empty();
  WriteBoolean (must_recalculate_normals)
  if (must_recalculate_normals)
  {
     const uint8_t normals_recalculation_flags=0;
     // not used; should be zero
     WriteCharacter (normals_recalculation_flags)
     // definition similar to VRML
     WriteDouble (crease_angle)
  }

  const uint32_t number_of_normal_coordinates=normal_coordinate.size();
  WriteUnsignedInteger (number_of_normal_coordinates)
  for (i=0;i<number_of_normal_coordinates;i++)
     WriteDouble (normal_coordinate[i])

  const uint32_t number_of_wire_indices=wire_index.size();
  WriteUnsignedInteger (number_of_wire_indices)
  for (i=0;i<number_of_wire_indices;i++)
     WriteUnsignedInteger (wire_index[i])

  // note : those can be single triangles, triangle fans or stripes
  const uint32_t number_of_triangulated_indices=triangulated_index.size();
  WriteUnsignedInteger (number_of_triangulated_indices)
  for (i=0;i<number_of_triangulated_indices;i++)
     WriteUnsignedInteger (triangulated_index[i])

  const uint32_t number_of_face_tessellation=face_tessellation.size();
  WriteUnsignedInteger (number_of_face_tessellation)
  for (i=0;i<number_of_face_tessellation;i++)
     SerializeTessFace (face_tessellation[i])

  const uint32_t number_of_texture_coordinates=texture_coordinate.size();
  WriteUnsignedInteger (number_of_texture_coordinates)
  for (i=0;i<number_of_texture_coordinates;i++)
     WriteDouble (texture_coordinate[i])
}

void PRC3DTess::addTessFace(PRCTessFace*& pTessFace)
{
  face_tessellation.push_back(pTessFace);
  pTessFace = NULL;
}

void  PRC3DWireTess::serialize3DWireTess(PRCbitStream &pbs)
{
// group___tf3_d_wire_tess_data_____serialize2.html
// group___tf3_d_wire_tess_data_____serialize_content2.html
  uint32_t i=0; // universal index for PRC standart compatibility
  WriteUnsignedInteger (PRC_TYPE_TESS_3D_Wire)
  SerializeContentBaseTessData
  const uint32_t number_of_wire_indexes=wire_indexes.size();
  WriteUnsignedInteger (number_of_wire_indexes)
  for (i=0;i<number_of_wire_indexes;i++)
     WriteUnsignedInteger (wire_indexes[i])

  const bool has_vertex_colors = !rgba_vertices.empty();
  WriteBoolean (has_vertex_colors)
  if (has_vertex_colors)
  {
     WriteBoolean (is_rgba)
     WriteBoolean (is_segment_color)
     const bool b_optimised=false;
     WriteBoolean (b_optimised)
     if (!b_optimised)
     {
       SerializeArrayRGBA (rgba_vertices, is_rgba, pbs);
     }
     else
     {
     // not described
     }
  }
}

void  PRCMarkupTess::serializeMarkupTess(PRCbitStream &pbs)
{
// group___tf_markup_tess_data_____serialize2.html
// group___tf_markup_tess_data_____serialize_content2.html
  uint32_t i=0; // universal index for PRC standart compatibility
  WriteUnsignedInteger (PRC_TYPE_TESS_Markup)
  SerializeContentBaseTessData

  const uint32_t number_of_codes=codes.size();
  WriteUnsignedInteger (number_of_codes)
  for (i=0;i<number_of_codes;i++)
     WriteUnsignedInteger (codes[i])
  const uint32_t number_of_texts=texts.size();
  WriteUnsignedInteger (number_of_texts)
  for (i=0;i<number_of_texts;i++)
     WriteString (texts[i])
  WriteString (label) // label of tessellation
  WriteCharacter (behaviour)
}

void writeUnit(PRCbitStream &out,bool fromCAD,double unit)
{
  out << fromCAD << unit;
}

void writeEmptyMarkups(PRCbitStream &out)
{
  out << (uint32_t)0 // # of linked items
      << (uint32_t)0 // # of leaders
      << (uint32_t)0 // # of markups
      << (uint32_t)0; // # of annotation entities
}

void PRCBaseTopology::serializeBaseTopology(PRCbitStream &pbs)
{
   WriteBoolean (base_information)
   if (base_information)
   {
      SerializeAttributeData
      SerializeName (name)
      WriteUnsignedInteger (identifier)
   }
}

void PRCBaseGeometry::serializeBaseGeometry(PRCbitStream &pbs)
{
   WriteBoolean (base_information)
   if (base_information)
   {
      SerializeAttributeData
      SerializeName (name)
      WriteUnsignedInteger (identifier)
   }
}

void PRCContentBody::serializeContentBody(PRCbitStream &pbs)
{
   SerializeBaseTopology
   WriteCharacter ( behavior )
}

void PRCBoundingBox::serializeBoundingBox(PRCbitStream &pbs)
{
   SerializeVector3d ( min )
   SerializeVector3d ( max )
}

void PRCDomain::serializeDomain(PRCbitStream &pbs)
{
   SerializeVector2d ( min )
   SerializeVector2d ( max )
}

void PRCInterval::serializeInterval(PRCbitStream &pbs)
{
   WriteDouble ( min )
   WriteDouble ( max )
}

void PRCParameterization::serializeParameterization(PRCbitStream &pbs)
{
   SerializeInterval ( interval )
   WriteDouble ( parameterization_coeff_a )
   WriteDouble ( parameterization_coeff_b )
}

void PRCUVParameterization::serializeUVParameterization(PRCbitStream &pbs)
{
   WriteBoolean ( swap_uv )
   SerializeDomain ( uv_domain )
   WriteDouble ( parameterization_on_u_coeff_a )
   WriteDouble ( parameterization_on_v_coeff_a )
   WriteDouble ( parameterization_on_u_coeff_b )
   WriteDouble ( parameterization_on_v_coeff_b )
}

void PRCContentSurface::serializeContentSurface(PRCbitStream &pbs)
{
   SerializeBaseGeometry
   WriteUnsignedInteger ( extend_info )
}

void  PRCNURBSSurface::serializeNURBSSurface(PRCbitStream &pbs)
{
   uint32_t i=0;
//  uint32_t i=0, j=0;
   WriteUnsignedInteger (PRC_TYPE_SURF_NURBS)

   SerializeContentSurface
   WriteBoolean ( is_rational )
   WriteUnsignedInteger ( degree_in_u )
   WriteUnsignedInteger ( degree_in_v )
   const uint32_t highest_index_of_knots_in_u = knot_u.size()-1;
   const uint32_t highest_index_of_knots_in_v = knot_v.size()-1;
   const uint32_t highest_index_of_control_point_in_u = highest_index_of_knots_in_u - degree_in_u - 1;
   const uint32_t highest_index_of_control_point_in_v = highest_index_of_knots_in_v - degree_in_v - 1;
   WriteUnsignedInteger ( highest_index_of_control_point_in_u )
   WriteUnsignedInteger ( highest_index_of_control_point_in_v )
   WriteUnsignedInteger ( highest_index_of_knots_in_u )
   WriteUnsignedInteger ( highest_index_of_knots_in_v )
   for (i=0; i < (highest_index_of_control_point_in_u+1)*(highest_index_of_control_point_in_v+1); i++)
   {
      WriteDouble ( control_point[i].x )
      WriteDouble ( control_point[i].y )
      WriteDouble ( control_point[i].z )
      if (is_rational)
         WriteDouble ( control_point[i].w )
   }
//  for (i=0; i<=highest_index_of_control_point_in_u; i++)
//  {
//     for (j=0; j<=highest_index_of_control_point_in_v; j++)
//     {
//        WriteDouble ( control_point[i*(highest_index_of_control_point_in_u+1)+j].x )
//        WriteDouble ( control_point[i*(highest_index_of_control_point_in_u+1)+j].y )
//        WriteDouble ( control_point[i*(highest_index_of_control_point_in_u+1)+j].z )
//        if (is_rational)
//           WriteDouble ( control_point[i*(highest_index_of_control_point_in_u+1)+j].w )
//     }
//  }
   for (i=0; i<=highest_index_of_knots_in_u; i++)
      WriteDouble ( knot_u[i] )
   for (i=0; i<=highest_index_of_knots_in_v; i++)
      WriteDouble ( knot_v[i] )
   WriteUnsignedInteger ( knot_type )
   WriteUnsignedInteger ( surface_form )
}

void writeUnsignedIntegerWithVariableBitNumber(PRCbitStream &pbs, uint32_t value, uint32_t bit_number)
{
   uint32_t i;
   for(i=0; i<bit_number; i++)
   {
      if( value >= 1u<<(bit_number - 1 - i) )
      {
         WriteBoolean (true)

         value -= 1u<<(bit_number - 1 - i);
      }
      else
      {
         WriteBoolean (false)
      }
   }
}
#define WriteUnsignedIntegerWithVariableBitNumber( value, bit_number )  writeUnsignedIntegerWithVariableBitNumber( pbs, (value), (bit_number) );

void writeIntegerWithVariableBitNumber(PRCbitStream &pbs, int32_t iValue, uint32_t uBitNumber)
{
  WriteBoolean(iValue<0);
  WriteUnsignedIntegerWithVariableBitNumber(abs(iValue), uBitNumber - 1);
}
#define WriteIntegerWithVariableBitNumber( value, bit_number )  writeIntegerWithVariableBitNumber( pbs, (value), (bit_number) );

void writeDoubleWithVariableBitNumber(PRCbitStream &pbs, double dValue,double dTolerance, unsigned uBitNumber)
{
// calling functions must ensure no overflow
  int32_t iTempValue = (int32_t) ( dValue / dTolerance );
  WriteIntegerWithVariableBitNumber(iTempValue, uBitNumber);
}
#define WriteDoubleWithVariableBitNumber( value, bit_number )  writeDoubleWithVariableBitNumber( pbs, (value), (bit_number) );

uint32_t  GetNumberOfBitsUsedToStoreUnsignedInteger(uint32_t uValue)
{
  uint32_t uNbBit=2;
  uint32_t uTemp = 2;
  while(uValue >= uTemp)
  {
    uTemp*=2;
    uNbBit++;
  }
  return uNbBit-1;
}

void  writeNumberOfBitsThenUnsignedInteger(PRCbitStream &pbs, uint32_t unsigned_integer)
{
   uint32_t number_of_bits = GetNumberOfBitsUsedToStoreUnsignedInteger( unsigned_integer );
   WriteUnsignedIntegerWithVariableBitNumber ( number_of_bits, 5 )
   WriteUnsignedIntegerWithVariableBitNumber ( unsigned_integer, number_of_bits )
}
#define WriteNumberOfBitsThenUnsignedInteger( value ) writeNumberOfBitsThenUnsignedInteger( pbs, value );

uint32_t  GetNumberOfBitsUsedToStoreInteger(int32_t iValue)
{
   return GetNumberOfBitsUsedToStoreUnsignedInteger(abs(iValue))+1;
}

int32_t intdiv(double dValue, double dTolerance)
{
  double ratio=fabs(dValue)/dTolerance;
  assert(ratio <= INT_MAX);
  int32_t iTempValue=(int32_t) ratio;
  if(ratio - iTempValue >= 0.5) iTempValue++;
  if(dValue < 0)
    return -iTempValue;
  else
    return iTempValue;
}

// round dValue to nearest multiple of dTolerance
double roundto(double dValue, double dTolerance)
{
    return intdiv(dValue, dTolerance) * dTolerance;
}

PRCVector3d roundto(PRCVector3d vec, double dTolerance)
{
    PRCVector3d res;
    res.x = roundto(vec.x,dTolerance);
    res.y = roundto(vec.y,dTolerance);
    res.z = roundto(vec.z,dTolerance);
    return    res;
}

uint32_t  GetNumberOfBitsUsedToStoreDouble(double dValue, double dTolerance )
{
   return GetNumberOfBitsUsedToStoreInteger(intdiv(dValue,dTolerance));
}

struct itriple
{
  int32_t x;
  int32_t y;
  int32_t z;
};

uint32_t  GetNumberOfBitsUsedToStoreTripleInteger(const itriple &iTriple)
{
   const uint32_t x_bits = GetNumberOfBitsUsedToStoreInteger(iTriple.x);
   const uint32_t y_bits = GetNumberOfBitsUsedToStoreInteger(iTriple.y);
   const uint32_t z_bits = GetNumberOfBitsUsedToStoreInteger(iTriple.z);
   uint32_t bits = x_bits;
   if(y_bits > bits)
     bits = y_bits;
   if(z_bits > bits)
     bits = z_bits;
   return bits;
}

itriple iroundto(PRCVector3d vec, double dTolerance)
{
    itriple res;
    res.x = intdiv(vec.x, dTolerance);
    res.y = intdiv(vec.y, dTolerance);
    res.z = intdiv(vec.z, dTolerance);
    return    res;
}

void  PRCCompressedFace::serializeCompressedFace(PRCbitStream &pbs, double brep_data_compressed_tolerance)
{
   serializeCompressedAnaNurbs( pbs, brep_data_compressed_tolerance );
}
#define SerializeCompressedFace( value ) (value)->serializeCompressedFace( pbs, brep_data_compressed_tolerance );

void  PRCCompressedFace::serializeContentCompressedFace(PRCbitStream &pbs)
{
   WriteBoolean ( orientation_surface_with_shell )
   const bool surface_is_trimmed = false;
   WriteBoolean ( surface_is_trimmed )
}

void  PRCCompressedFace::serializeCompressedAnaNurbs(PRCbitStream &pbs, double brep_data_compressed_tolerance)
{
   // WriteCompressedEntityType ( PRC_HCG_AnaNurbs )
   const bool is_a_curve = false;
   WriteBoolean ( is_a_curve )
   WriteUnsignedIntegerWithVariableBitNumber (13 , 4)
   serializeContentCompressedFace( pbs );
   serializeCompressedNurbs( pbs, brep_data_compressed_tolerance );
}

void  PRCCompressedFace::serializeCompressedNurbs(PRCbitStream &pbs, double brep_data_compressed_tolerance)
{
   const double nurbs_tolerance = 0.2*brep_data_compressed_tolerance;
   const uint32_t degree_in_u = degree;
   const uint32_t degree_in_v = degree;

   WriteUnsignedIntegerWithVariableBitNumber ( degree_in_u, 5)
   WriteUnsignedIntegerWithVariableBitNumber ( degree_in_v, 5)

   const uint32_t number_of_knots_in_u = 4; // 0011 or 00001111 knot vector - just 2 spans
   WriteUnsignedIntegerWithVariableBitNumber (number_of_knots_in_u - 2, 16)
   uint32_t number_bit = degree_in_u ? Log2( degree_in_u + 2 ) : 2;
   WriteBoolean (false) // Multiplicity_is_already_stored - no
   WriteUnsignedIntegerWithVariableBitNumber( degree_in_u+1,number_bit)
   WriteBoolean (true) // Multiplicity_is_already_stored - yes
   const uint32_t number_of_knots_in_v = 4; // 0011 or 00001111 knot vector - just 2 spans
   WriteUnsignedIntegerWithVariableBitNumber (number_of_knots_in_v - 2, 16)
   number_bit = degree_in_v ? Log2( degree_in_v + 2 ) : 2;
   WriteBoolean (false) // Multiplicity_is_already_stored - no
   WriteUnsignedIntegerWithVariableBitNumber( degree_in_v+1,number_bit)
   WriteBoolean (true) // Multiplicity_is_already_stored - yes

   const bool is_closed_u = false;
   WriteBoolean ( is_closed_u )
   const bool is_closed_v = false;
   WriteBoolean ( is_closed_v )

   const uint32_t number_of_control_point_in_u = degree_in_u + 1;
   const uint32_t number_of_control_point_in_v = degree_in_v + 1;

#if defined(__GNUC__) && !defined(__clang__)
   PRCVector3d P[number_of_control_point_in_u][number_of_control_point_in_v];
#else
   vector<vector<PRCVector3d> > P(number_of_control_point_in_u, vector<PRCVector3d>(number_of_control_point_in_v));
#endif
   for(uint32_t i=0;i<number_of_control_point_in_u;i++)
   for(uint32_t j=0;j<number_of_control_point_in_v;j++)
      P[i][j] = control_point[i*number_of_control_point_in_v+j];
#if defined(__GNUC__) && !defined(__clang__)
   itriple compressed_control_point[number_of_control_point_in_u][number_of_control_point_in_v];
   uint32_t control_point_type[number_of_control_point_in_u][number_of_control_point_in_v];
#else
   vector<vector<itriple> > compressed_control_point(number_of_control_point_in_u, vector<itriple>(number_of_control_point_in_v));
   vector<vector<uint32_t> > control_point_type(number_of_control_point_in_u, vector<uint32_t>(number_of_control_point_in_v));
#endif

   uint32_t number_of_bits_for_isomin = 1;
   uint32_t number_of_bits_for_rest = 1;

   for(uint32_t j = 1; j < number_of_control_point_in_v; j++)
   {
      compressed_control_point[0][j] = iroundto(P[0][j]-P[0][j-1], nurbs_tolerance );
      P[0][j] = P[0][j-1] + roundto(P[0][j]-P[0][j-1], nurbs_tolerance);
      uint32_t bit_size = GetNumberOfBitsUsedToStoreTripleInteger(compressed_control_point[0][j]);
      if (bit_size > number_of_bits_for_isomin)
        number_of_bits_for_isomin = bit_size;
   }

   for(uint32_t i = 1; i < number_of_control_point_in_u; i++)
   {
      compressed_control_point[i][0] = iroundto(P[i][0]-P[i-1][0], nurbs_tolerance );
      P[i][0] = P[i-1][0] + roundto(P[i][0]-P[i-1][0], nurbs_tolerance);
      uint32_t bit_size = GetNumberOfBitsUsedToStoreTripleInteger(compressed_control_point[i][0]);
      if (bit_size > number_of_bits_for_isomin)
        number_of_bits_for_isomin = bit_size;
   }

   for(uint32_t i=1;i<number_of_control_point_in_u;i++)
   for(uint32_t j=1;j<number_of_control_point_in_v;j++)
   {
     compressed_control_point[i][j].x = 0;
     compressed_control_point[i][j].y = 0;
     compressed_control_point[i][j].z = 0;

     PRCVector3d V = P[i-1][j] - P[i-1][j-1];
     PRCVector3d U = P[i][j-1] - P[i-1][j-1];
     PRCVector3d Pc = P[i][j] - (P[i-1][j-1] + U + V);

     if(Pc.Length() < nurbs_tolerance)
     {
       control_point_type[i][j] = 0;
       P[i][j] = P[i-1][j-1] + U + V;
     }
     else
     {
       PRCVector3d N = U*V;
       PRCVector3d Ue = U;
       PRCVector3d Ne = N;
       if( V.Length() < FLT_EPSILON || !Ue.Normalize() || !Ne.Normalize())
       {
          control_point_type[i][j] = 3;
       // Pc = roundto(Pc, nurbs_tolerance); // not sure if this rounding really happens, need to experiment, docs imply but do not state
          compressed_control_point[i][j] = iroundto(Pc, nurbs_tolerance);
          P[i][j] = P[i-1][j-1] + U + V + roundto(Pc, nurbs_tolerance); // see above
       }
       else
       {
         PRCVector3d NUe = Ne*Ue;
         double x = Pc.Dot(Ue);
         double y = Pc.Dot(NUe);
         double z = Pc.Dot(Ne);

         if(x*x+y*y<nurbs_tolerance*nurbs_tolerance)
         {
           control_point_type[i][j] = 1;
           compressed_control_point[i][j] = iroundto(PRCVector3d(0.0,0.0,z), nurbs_tolerance);
           P[i][j] = P[i-1][j-1] + U + V + roundto(z, nurbs_tolerance)*Ne; // see above
         }
         else
         {
           if(fabs(z)<nurbs_tolerance/2)
           {
             control_point_type[i][j] = 2;
             compressed_control_point[i][j] = iroundto(PRCVector3d(x,y,0), nurbs_tolerance);
             P[i][j] = P[i-1][j-1] + U + V + roundto(x, nurbs_tolerance)*Ue + roundto(y, nurbs_tolerance)*NUe; // see above
           }
           else
           {
             control_point_type[i][j] = 3;
             compressed_control_point[i][j] = iroundto(Pc, nurbs_tolerance);
             P[i][j] = P[i-1][j-1] + U + V + roundto(Pc, nurbs_tolerance); // see above
           }
         }
       }
     }
     uint32_t bit_size = GetNumberOfBitsUsedToStoreTripleInteger(compressed_control_point[i][j]);
     if (bit_size > number_of_bits_for_rest)
       number_of_bits_for_rest = bit_size;
   }

   if( number_of_bits_for_rest == 2 ) number_of_bits_for_rest--; // really I think it must be unconditional, but so it seems to be done in Adobe Acrobat (9.3)
   WriteUnsignedIntegerWithVariableBitNumber ( number_of_bits_for_isomin, 20 )
   WriteUnsignedIntegerWithVariableBitNumber ( number_of_bits_for_rest,   20 )
   WriteDouble ( P[0][0].x )
   WriteDouble ( P[0][0].y )
   WriteDouble ( P[0][0].z )

   for(uint32_t j = 1; j < number_of_control_point_in_v; j++)
   {
      WriteIntegerWithVariableBitNumber(compressed_control_point[0][j].x, number_of_bits_for_isomin+1)
      WriteIntegerWithVariableBitNumber(compressed_control_point[0][j].y, number_of_bits_for_isomin+1)
      WriteIntegerWithVariableBitNumber(compressed_control_point[0][j].z, number_of_bits_for_isomin+1)
   }

   for(uint32_t i = 1; i < number_of_control_point_in_u; i++)
   {
      WriteIntegerWithVariableBitNumber(compressed_control_point[i][0].x, number_of_bits_for_isomin+1)
      WriteIntegerWithVariableBitNumber(compressed_control_point[i][0].y, number_of_bits_for_isomin+1)
      WriteIntegerWithVariableBitNumber(compressed_control_point[i][0].z, number_of_bits_for_isomin+1)
   }

   for(uint32_t i = 1; i < number_of_control_point_in_u; i++)
   {
      for(uint32_t j = 1; j < number_of_control_point_in_v; j++)
      {
         WriteUnsignedIntegerWithVariableBitNumber ( control_point_type[i][j], 2 )

         if(control_point_type[i][j] == 1)
         {
            WriteIntegerWithVariableBitNumber ( compressed_control_point[i][j].z, number_of_bits_for_rest+1 )
         }
         else if(control_point_type[i][j] == 2)
         {
            WriteIntegerWithVariableBitNumber ( compressed_control_point[i][j].x, number_of_bits_for_rest+1 )
            WriteIntegerWithVariableBitNumber ( compressed_control_point[i][j].y, number_of_bits_for_rest+1 )
         }
         else if(control_point_type[i][j] == 3)
         {
            WriteIntegerWithVariableBitNumber ( compressed_control_point[i][j].x, number_of_bits_for_rest+1 )
            WriteIntegerWithVariableBitNumber ( compressed_control_point[i][j].y, number_of_bits_for_rest+1 )
            WriteIntegerWithVariableBitNumber ( compressed_control_point[i][j].z, number_of_bits_for_rest+1 )
         }
      }
   }

   const uint32_t type_param_u = 0;
   WriteBoolean( type_param_u == 0 )
   const uint32_t type_param_v = 0;
   WriteBoolean( type_param_v == 0 )
   const bool is_rational = false;
   WriteBoolean( is_rational )
}

void PRCCompressedBrepData::serializeCompressedShell(PRCbitStream &pbs)
{
   uint32_t i;
   const uint32_t number_of_face = face.size();
   WriteBoolean ( number_of_face == 1 )

   if( number_of_face != 1 )
      WriteNumberOfBitsThenUnsignedInteger (number_of_face)

   for( i=0; i < number_of_face; i++)
         SerializeCompressedFace ( face[i] )

   const bool is_an_iso_face = false;
   for( i=0; i < number_of_face; i++)
      WriteBoolean ( is_an_iso_face )
}

void PRCCompressedBrepData::serializeCompressedBrepData(PRCbitStream &pbs)
{
   WriteUnsignedInteger ( PRC_TYPE_TOPO_BrepDataCompress )
   SerializeContentBody

   WriteDouble ( brep_data_compressed_tolerance )
   const uint32_t number_of_bits_to_store_reference = 1;
   WriteNumberOfBitsThenUnsignedInteger ( number_of_bits_to_store_reference )
   const uint32_t number_vertex_iso = 0;
   WriteUnsignedIntegerWithVariableBitNumber ( number_vertex_iso, number_of_bits_to_store_reference )
   const uint32_t number_edge_iso = 0;
   WriteUnsignedIntegerWithVariableBitNumber ( number_edge_iso, number_of_bits_to_store_reference )

   const uint32_t number_of_shell = 1;
   const uint32_t number_of_connex = 1;
   WriteBoolean ( number_of_shell == 1 && number_of_connex == 1 )
   serializeCompressedShell( pbs );

   uint32_t i;
   const uint32_t number_of_faces = face.size();
   for(i=0; i< number_of_faces; i++)
      face[i]->serializeBaseTopology( pbs );
}

void  PRCBlend01::serializeBlend01(PRCbitStream &pbs)
{
   WriteUnsignedInteger (PRC_TYPE_SURF_Blend01)

   SerializeContentSurface
   SerializeTransformation
   SerializeUVParameterization
   SerializePtrCurve ( center_curve )
   SerializePtrCurve ( origin_curve )
   SerializePtrCurve ( tangent_curve )
}

void  PRCRuled::serializeRuled(PRCbitStream &pbs)
{
   WriteUnsignedInteger (PRC_TYPE_SURF_Ruled)

   SerializeContentSurface
   SerializeTransformation
   SerializeUVParameterization
   SerializePtrCurve ( first_curve )
   SerializePtrCurve ( second_curve )
}

void  PRCSphere::serializeSphere(PRCbitStream &pbs)
{
   WriteUnsignedInteger (PRC_TYPE_SURF_Sphere)

   SerializeContentSurface
   SerializeTransformation
   SerializeUVParameterization
   WriteDouble ( radius )
}

void  PRCCone::serializeCone(PRCbitStream &pbs)
{
   WriteUnsignedInteger (PRC_TYPE_SURF_Cone)

   SerializeContentSurface
   SerializeTransformation
   SerializeUVParameterization
   WriteDouble ( bottom_radius )
   WriteDouble ( semi_angle )
}

void  PRCCylinder::serializeCylinder(PRCbitStream &pbs)
{
   WriteUnsignedInteger (PRC_TYPE_SURF_Cylinder)

   SerializeContentSurface
   SerializeTransformation
   SerializeUVParameterization
   WriteDouble ( radius )
}

void  PRCTorus::serializeTorus(PRCbitStream &pbs)
{
   WriteUnsignedInteger (PRC_TYPE_SURF_Torus)

   SerializeContentSurface
   SerializeTransformation
   SerializeUVParameterization
   WriteDouble ( major_radius )
   WriteDouble ( minor_radius )
}

void PRCFace::serializeFace(PRCbitStream &pbs)
{
   uint32_t i = 0;
   WriteUnsignedInteger (PRC_TYPE_TOPO_Face)

   SerializeBaseTopology
   SerializePtrSurface ( base_surface )
   WriteBit ( have_surface_trim_domain )
   if ( have_surface_trim_domain )
      SerializeDomain ( surface_trim_domain )
   WriteBit ( have_tolerance )
   if ( have_tolerance )
      WriteDouble ( tolerance )
   WriteUnsignedInteger ( number_of_loop )
   WriteInteger ( outer_loop_index )
   for (i=0;i<number_of_loop;i++)
   {
//    SerializePtrTopology ( loop[i] )
   }
}

void PRCShell::serializeShell(PRCbitStream &pbs)
{
   uint32_t i = 0;
   WriteUnsignedInteger (PRC_TYPE_TOPO_Shell)

   SerializeBaseTopology
   WriteBoolean ( shell_is_closed )
   uint32_t number_of_face = face.size();
   WriteUnsignedInteger ( number_of_face )
   for (i=0;i<number_of_face;i++)
   {
      SerializePtrTopology ( face[i] )
      WriteCharacter ( orientation_surface_with_shell[i] )
   }
}

void PRCShell::addFace(PRCFace*& pFace, uint8_t orientation)
{
  face.push_back(pFace);
  pFace = NULL;
  orientation_surface_with_shell.push_back(orientation);
}

void PRCConnex::serializeConnex(PRCbitStream &pbs)
{
   uint32_t i = 0;
   WriteUnsignedInteger (PRC_TYPE_TOPO_Connex)

   SerializeBaseTopology
   uint32_t number_of_shell = shell.size();
   WriteUnsignedInteger ( number_of_shell )
   for (i=0;i<number_of_shell;i++)
   {
      SerializePtrTopology ( shell[i] )
   }
}

void PRCConnex::addShell(PRCShell*& pShell)
{
  shell.push_back(pShell);
  pShell = NULL;
}

#define have_bbox( behavior ) (behavior!=0)
void PRCBrepData::serializeBrepData(PRCbitStream &pbs)
{
   uint32_t i = 0;
   WriteUnsignedInteger ( PRC_TYPE_TOPO_BrepData)

   SerializeContentBody
   uint32_t number_of_connex = connex.size();
   WriteUnsignedInteger ( number_of_connex )
   for ( i=0; i<number_of_connex; i++)
   {
      SerializePtrTopology ( connex[i] )
   }
   if ( have_bbox(behavior) )
      SerializeBoundingBox
}
#undef have_bbox

void PRCBrepData::addConnex(PRCConnex*& pConnex)
{
  connex.push_back(pConnex);
  pConnex = NULL;
}

void PRCContentWireEdge::serializeContentWireEdge(PRCbitStream &pbs)
{
   SerializeBaseTopology
   SerializePtrCurve ( curve_3d )
   WriteBit ( has_curve_trim_interval )
   if ( has_curve_trim_interval )
      SerializeInterval ( curve_trim_interval )
}

void PRCWireEdge::serializeWireEdge(PRCbitStream &pbs)
{
   WriteUnsignedInteger (PRC_TYPE_TOPO_WireEdge)
   SerializeContentWireEdge
}

void PRCContentCurve::serializeContentCurve(PRCbitStream &pbs)
{
   SerializeBaseGeometry
   WriteUnsignedInteger ( extend_info )
   WriteBoolean ( is_3d )
}

void  PRCNURBSCurve::serializeNURBSCurve(PRCbitStream &pbs)
{
   uint32_t i=0;
   WriteUnsignedInteger (PRC_TYPE_CRV_NURBS)

   SerializeContentCurve
   WriteBoolean ( is_rational )
   WriteUnsignedInteger ( degree )
   uint32_t highest_index_of_control_point = control_point.size()-1;
   uint32_t highest_index_of_knots = knot.size()-1;
   WriteUnsignedInteger ( highest_index_of_control_point )
   WriteUnsignedInteger ( highest_index_of_knots )
   for (i=0; i<=highest_index_of_control_point; i++)
   {
      WriteDouble ( control_point[i].x )
      WriteDouble ( control_point[i].y )
      if (is_3d)
         WriteDouble ( control_point[i].z )
      if (is_rational)
         WriteDouble ( control_point[i].w )
   }
   for (i=0; i<=highest_index_of_knots; i++)
      WriteDouble ( knot[i] )
   WriteUnsignedInteger ( knot_type )
   WriteUnsignedInteger ( curve_form )
}

void  PRCPolyLine::serializePolyLine(PRCbitStream &pbs)
{
   uint32_t i=0;
   WriteUnsignedInteger (PRC_TYPE_CRV_PolyLine)

   SerializeContentCurve
   SerializeTransformation
   SerializeParameterization
   uint32_t number_of_point = point.size();
   WriteUnsignedInteger ( number_of_point )
   for (i=0; i<number_of_point; i++)
   {
      if (is_3d)
         SerializeVector3d ( point[i] )
      else
         SerializeVector2d ( point[i] )
   }
}

void  PRCCircle::serializeCircle(PRCbitStream &pbs)
{
   WriteUnsignedInteger (PRC_TYPE_CRV_Circle)

   SerializeContentCurve
   SerializeTransformation
   SerializeParameterization
   WriteDouble ( radius )
}

void  PRCComposite::serializeComposite(PRCbitStream &pbs)
{
   uint32_t i=0;
   WriteUnsignedInteger (PRC_TYPE_CRV_Composite)

   SerializeContentCurve
   SerializeTransformation
   SerializeParameterization
   uint32_t number_of_curves = base_curve.size();
   WriteUnsignedInteger ( number_of_curves )
   for (i=0; i<number_of_curves; i++)
   {
      SerializePtrCurve ( base_curve[i] )
      WriteBoolean ( base_sense[i] )
   }
   WriteBoolean ( is_closed )
}

void PRCTopoContext::serializeTopoContext(PRCbitStream &pbs)
{
   WriteUnsignedInteger (PRC_TYPE_TOPO_Context)

   SerializeContentPRCBase
   WriteCharacter ( behaviour )
   WriteDouble ( granularity )
   WriteDouble ( tolerance )
   WriteBoolean ( have_smallest_face_thickness )
   if ( have_smallest_face_thickness )
      WriteDouble ( smallest_thickness )
   WriteBoolean ( have_scale )
   if ( have_scale )
      WriteDouble ( scale )
}

void PRCTopoContext::serializeContextAndBodies(PRCbitStream &pbs)
{
   uint32_t i=0;
   SerializeTopoContext
   uint32_t number_of_bodies = body.size();
   WriteUnsignedInteger (number_of_bodies)
   for (i=0;i<number_of_bodies;i++)
      SerializeBody (body[i])
}

void PRCTopoContext::serializeGeometrySummary(PRCbitStream &pbs)
{
   uint32_t i=0;
   uint32_t number_of_bodies = body.size();
   WriteUnsignedInteger (number_of_bodies)
   for (i=0;i<number_of_bodies;i++)
   {
      WriteUnsignedInteger ( body[i]->serialType() )
      if ( IsCompressedType(body[i]->serialType()) )
      {
         WriteDouble ( body[i]->serialTolerance() )
      }
   }
}

void PRCTopoContext::serializeContextGraphics(PRCbitStream &pbs)
{
   uint32_t i=0, j=0, k=0, l=0;
   ResetCurrentGraphics
   uint32_t number_of_body = body.size();
   PRCGraphicsList element;
   bool has_graphics = false;
   for (i=0;i<number_of_body;i++)
   {
        if ( body[i]->topo_item_type == PRC_TYPE_TOPO_BrepData && dynamic_cast<PRCBrepData*>(body[i]))
        {
                PRCBrepData *body_i = dynamic_cast<PRCBrepData*>(body[i]);
                for (j=0;j<body_i->connex.size();j++)
                {
                        for(k=0;k<body_i->connex[j]->shell.size();k++)
                        {
                                for( l=0;l<body_i->connex[j]->shell[k]->face.size();l++)
                                {
                                        element.push_back( body_i->connex[j]->shell[k]->face[l] );
                                        has_graphics = has_graphics || body_i->connex[j]->shell[k]->face[l]->has_graphics();
                                }
                        }
                }
        }
        else if ( body[i]->topo_item_type == PRC_TYPE_TOPO_BrepDataCompress && dynamic_cast<PRCCompressedBrepData*>(body[i]))
        {
                PRCCompressedBrepData *body_i = dynamic_cast<PRCCompressedBrepData*>(body[i]);
             	for( l=0;l<body_i->face.size();l++)
             	{
             		element.push_back( body_i->face[l] );
             		has_graphics = has_graphics || body_i->face[l]->has_graphics();
             	}
        }
   }
   uint32_t number_of_treat_type = 0;
   if (has_graphics && !element.empty())
     number_of_treat_type = 1;
   WriteUnsignedInteger (number_of_treat_type)
   for (i=0;i<number_of_treat_type;i++)
   {
      const uint32_t element_type = PRC_TYPE_TOPO_Face;
      WriteUnsignedInteger (element_type)
      const uint32_t number_of_element = element.size();
      WriteUnsignedInteger (number_of_element)
      for (j=0;j<number_of_element;j++)
      {
         WriteBoolean ( element[j]->has_graphics() )
         if (element[j]->has_graphics())
         {
            element[j]->serializeGraphics(pbs);
         }
      }
   }
}

uint32_t PRCTopoContext::addSingleWireBody(PRCSingleWireBody*& pSingleWireBody)
{
  body.push_back(pSingleWireBody);
  pSingleWireBody = NULL;
  return body.size()-1;
}

uint32_t PRCTopoContext::addBrepData(PRCBrepData*& pBrepData)
{
  body.push_back(pBrepData);
  pBrepData = NULL;
  return body.size()-1;
}

uint32_t PRCTopoContext::addCompressedBrepData(PRCCompressedBrepData*& pCompressedBrepData)
{
  body.push_back(pCompressedBrepData);
  pCompressedBrepData = NULL;
  return body.size()-1;
}

void PRCSingleWireBody::serializeSingleWireBody(PRCbitStream &pbs)
{
  WriteUnsignedInteger ( PRC_TYPE_TOPO_SingleWireBody)

  SerializeContentBody
  SerializePtrTopology ( wire_edge )
}

void PRCUniqueId::serializeCompressedUniqueId(PRCbitStream &pbs) const
{
   WriteUnsignedInteger (id0)
   WriteUnsignedInteger (id1)
   WriteUnsignedInteger (id2)
   WriteUnsignedInteger (id3)
}

void PRCUniqueId::serializeFileStructureUncompressedUniqueId(std::ostream& out) const
{
   WriteUncompressedUnsignedInteger (id0)
   WriteUncompressedUnsignedInteger (id1)
   WriteUncompressedUnsignedInteger (id2)
   WriteUncompressedUnsignedInteger (id3)
}

void PRCUnit::serializeUnit(PRCbitStream &pbs)
{
   WriteBoolean (unit_from_CAD_file)
   WriteDouble (unit)
}

void PRCProductOccurrence::serializeProductOccurrence(PRCbitStream &pbs)
{
   WriteUnsignedInteger ( PRC_TYPE_ASM_ProductOccurence )

   SerializePRCBaseWithGraphics

// SerializeReferencesOfProductOccurrence
   WriteUnsignedInteger (index_part+1)
   WriteUnsignedInteger (index_prototype+1)
   if (index_prototype != m1)
   {
      WriteBoolean (prototype_in_same_file_structure)
      if (!prototype_in_same_file_structure)
         SerializeCompressedUniqueId (prototype_file_structure)
   }
   WriteUnsignedInteger(index_external_data+1)
   if (index_external_data != m1)
   {
      WriteBoolean (external_data_in_same_file_structure)
      if (!external_data_in_same_file_structure)
         SerializeCompressedUniqueId (external_data_file_structure)
   }
   const uint32_t number_of_son_product_occurrences = index_son_occurrence.size();
   WriteUnsignedInteger (number_of_son_product_occurrences)
   for (uint32_t i=0;i<number_of_son_product_occurrences;i++)
      WriteUnsignedInteger (index_son_occurrence[i])

   WriteCharacter (product_behaviour)

// SerializeProductInformation (product_information)
   SerializeUnit (unit_information)
   WriteCharacter (product_information_flags)
   WriteInteger (product_load_status)

   const bool has_location = location != NULL;
   WriteBit (has_location)
   if (has_location)
     location->serializeTransformation3d (pbs);

   WriteUnsignedInteger (0) // number_of_references

// SerializeMarkups (markups)
   WriteUnsignedInteger (0) // number_of_linked_items
   WriteUnsignedInteger (0) // number_of_leaders
   WriteUnsignedInteger (0) // number_of_markups
   WriteUnsignedInteger (0) // number_of_annotation_entities


   WriteUnsignedInteger (0) // number_of_views
   WriteBit (false) // has_entity_filter
   WriteUnsignedInteger (0) // number_of_display_filters
   WriteUnsignedInteger (0) // number_of_scene_display_parameters

   SerializeUserData
}

uint32_t PRCPartDefinition::addBrepModel(PRCBrepModel*& pBrepModel)
{
  representation_item.push_back(pBrepModel);
  pBrepModel = NULL;
  return representation_item.size()-1;
}

uint32_t PRCPartDefinition::addPolyBrepModel(PRCPolyBrepModel*& pPolyBrepModel)
{
  representation_item.push_back(pPolyBrepModel);
  pPolyBrepModel = NULL;
  return representation_item.size()-1;
}

uint32_t PRCPartDefinition::addPointSet(PRCPointSet*& pPointSet)
{
  representation_item.push_back(pPointSet);
  pPointSet = NULL;
  return representation_item.size()-1;
}

uint32_t PRCPartDefinition::addSet(PRCSet*& pSet)
{
  representation_item.push_back(pSet);
  pSet = NULL;
  return representation_item.size()-1;
}

uint32_t PRCPartDefinition::addWire(PRCWire*& pWire)
{
  representation_item.push_back(pWire);
  pWire = NULL;
  return representation_item.size()-1;
}

uint32_t PRCPartDefinition::addPolyWire(PRCPolyWire*& pPolyWire)
{
  representation_item.push_back(pPolyWire);
  pPolyWire = NULL;
  return representation_item.size()-1;
}

uint32_t PRCPartDefinition::addRepresentationItem(PRCRepresentationItem*& pRepresentationItem)
{
  representation_item.push_back(pRepresentationItem);
  pRepresentationItem = NULL;
  return representation_item.size()-1;
}

void PRCPartDefinition::serializePartDefinition(PRCbitStream &pbs)
{
  WriteUnsignedInteger ( PRC_TYPE_ASM_PartDefinition )

  SerializePRCBaseWithGraphics
  SerializeBoundingBox

  uint32_t number_of_representation_items = representation_item.size();
  WriteUnsignedInteger (number_of_representation_items)
  for (uint32_t i=0;i<number_of_representation_items;i++)
    SerializeRepresentationItem (representation_item[i])

  // SerializeMarkups (markups)
  WriteUnsignedInteger (0) // number_of_linked_items
  WriteUnsignedInteger (0) // number_of_leaders
  WriteUnsignedInteger (0) // number_of_markups
  WriteUnsignedInteger (0) // number_of_annotation_entities

  WriteUnsignedInteger (0) // number_of_views
  SerializeUserData
}
