Source/System/FileIO/OSB/OSGOSBTextureChunkElement.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *                   Copyright (C) 2008 by the OpenSG Forum                  *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
  10  *                                                                           *
  11 \*---------------------------------------------------------------------------*/
  12 /*---------------------------------------------------------------------------*\
  13  *                                License                                    *
  14  *                                                                           *
  15  * This library is free software; you can redistribute it and/or modify it   *
  16  * under the terms of the GNU Library General Public License as published    *
  17  * by the Free Software Foundation, version 2.                               *
  18  *                                                                           *
  19  * This library is distributed in the hope that it will be useful, but       *
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  22  * Library General Public License for more details.                          *
  23  *                                                                           *
  24  * You should have received a copy of the GNU Library General Public         *
  25  * License along with this library; if not, write to the Free Software       *
  26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  27  *                                                                           *
  28 \*---------------------------------------------------------------------------*/
  29 /*---------------------------------------------------------------------------*\
  30  *                                Changes                                    *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35  *                                                                           *
  36  *                                                                           *
  37 \*---------------------------------------------------------------------------*/
  38
  39 #include "OSGOSBTextureChunkElement.h"
  40
  41 #include "OSGOSBRootElement.h"
  42
  43 #include "OSGChunkMaterial.h"
  44 #include "OSGTextureObjChunk.h"
  45 #include "OSGTextureEnvChunk.h"
  46
  47 OSG_USING_NAMESPACE
  48
  49 /*-------------------------------------------------------------------------*/
  50 /* OSBTextureChunkElement                                                  */
  51 /*-------------------------------------------------------------------------*/
  52
  53 /*! Reads the depreciated TextureChunk from an osb and converts it to the
  54     TextureObjChunk + TextureEnvChunk combination that is now the preferred
  55     way to store the same information.
  56  */
  57
  58 /*-------------------------------------------------------------------------*/
  59 /* Static members                                                          */
  60
  61 OSBElementRegistrationHelper<OSBTextureChunkElement>
  62     OSBTextureChunkElement::_regHelper =
  63         OSBElementRegistrationHelper<OSBTextureChunkElement>("TextureChunk");
  64
  65 /*-------------------------------------------------------------------------*/
  66 /* Constructor                                                             */
  67
  68 OSBTextureChunkElement::OSBTextureChunkElement(OSBRootElement *root) :
  69     Inherited(root, OSGOSBHeaderVersion200),
  70     _pTexObj (NULL                        ),
  71     _pTexEnv (                            )
  72 {
  73 }
  74
  75 /*-------------------------------------------------------------------------*/
  76 /* Destructor                                                              */
  77
  78 OSBTextureChunkElement::~OSBTextureChunkElement(void)
  79 {
  80 }
  81
  82 /*-------------------------------------------------------------------------*/
  83 /* Reading                                                                 */
  84
  85 // TextureChunk is being split into TextureObjChunk and TextureEnvChunk when
  86 // reading it from an .osb
  87 // The TextureObjChunk will be returned by the getContainer function for this
  88 // element.
  89
  90 void
  91 OSBTextureChunkElement::read(const std::string &typeName)
  92 {
  93     OSG_OSB_LOG(("OSBTextureChunkElement::read: [%s]\n", typeName.c_str()));
  94
  95     BinaryReadHandler *rh = editRoot()->getReadHandler();
  96
  97     UInt8  ptrTypeId;
  98     UInt16 version;
  99
 100     rh->getValue(ptrTypeId);
 101     rh->getValue(version  );
 102
 103     OSG_OSB_LOG(("OSBTextureChunkElement::read: version: [%u]\n", version));
 104
 105     // create the two replacement chunks
 106     _pTexObj = TextureObjChunk::create();
 107     _pTexEnv = TextureEnvChunk::create();
 108
 109     std::string    fieldName;
 110     std::string    fieldTypeName;
 111     UInt32         fieldSize;
 112     PtrFieldListIt ptrFieldIt;
 113
 114     while(readFieldHeader("", fieldName, fieldTypeName, fieldSize))
 115     {
 116         // some fields need to be duplicated for the two replacement chunks
 117         if(fieldName == "parents")
 118         {
 119             // parent fields are ignored
 120             rh->skip(fieldSize);
 121         }
 122         else if(fieldName == "internal")
 123         {
 124             bool fieldValue;
 125             rh->getValue(fieldValue);
 126
 127             _pTexObj->setInternal(fieldValue);
 128             _pTexEnv->setInternal(fieldValue);
 129         }
 130         else if(fieldName == "ignore")
 131         {
 132             bool fieldValue;
 133             rh->getValue(fieldValue);
 134
 135             _pTexObj->setIgnore(fieldValue);
 136             _pTexEnv->setIgnore(fieldValue);
 137         }
 138         else if(isTexObjField(fieldName))
 139         {
 140             // set TexObj as container for reading the field
 141             setContainer(_pTexObj);
 142             readFieldContent(fieldName, fieldTypeName, fieldSize, "", ptrFieldIt);
 143         }
 144         else if(isTexEnvField(fieldName))
 145         {
 146             // set TexEnv as container for reading the field
 147             setContainer(_pTexEnv);
 148             readFieldContent(fieldName, fieldTypeName, fieldSize, "", ptrFieldIt);
 149         }
 150         else
 151         {
 152             FWARNING(("OSBTextureChunkElement::read: Skipping unrecognized "
 153                       "field [%s].\n", fieldName.c_str()));
 154
 155             rh->skip(fieldSize);
 156         }
 157     }
 158
 159     // set TexObj as "the" container
 160     setContainer(_pTexObj);
 161 }
 162
 163 // All uses of (i.e. pointers to) the TextureChunk need to be replaced with
 164 // pointers to TexObj and TexEnv.
 165
 166 void
 167 OSBTextureChunkElement::postRead(void)
 168 {
 169     OSG_OSB_LOG(("OSBTextureChunkElement::postRead:\n"));
 170     OSBRootElement *pRoot = editRoot();
 171
 172     // for the id remapping TexEnv needs an id that is not used in the file
 173     UInt32 texEnvIdFile = pRoot->getIdMap().rbegin()->first;
 174     while(pRoot->getIdMap().find(texEnvIdFile) != pRoot->getIdMap().end())
 175     {
 176         ++texEnvIdFile;
 177     }
 178
 179     // add mapping entry for TexEnv
 180     pRoot->editIdMap()[texEnvIdFile] = _pTexEnv->getId();
 181
 182     PtrFieldListIt ptrFieldIt  = pRoot->editPtrFieldList().begin();
 183     PtrFieldListIt ptrFieldEnd = pRoot->editPtrFieldList().end  ();
 184
 185     for(; ptrFieldIt != ptrFieldEnd; ++ptrFieldIt)
 186     {
 187         ChunkMaterial *chkMat =
 188             dynamic_cast<ChunkMaterial *>(ptrFieldIt->getContainer());
 189
 190         if(chkMat != NULL)
 191         {
 192             // OSBChunkMaterialElement takes care of handling the two chunks
 193             // replacing TextureChunk
 194             continue;
 195         }
 196         else
 197         {
 198             UInt32 numIds  = UInt32(ptrFieldIt->getIdStore     ().size());
 199             UInt32 numBind = UInt32(ptrFieldIt->getBindingStore().size());
 200
 201             if(numBind > 0)
 202             {
 203                 // TextureChunk is pointed to from an attachment map
 204                 for(UInt32 i = 0; (i < numIds) && (i < numBind); ++i)
 205                 {
 206                     if(ptrFieldIt->getIdStore()[i] == getFCIdFile())
 207                     {
 208                         // insert a pointer to TexEnv right after the TexObj
 209                         ptrFieldIt->editIdStore().insert(
 210                             ptrFieldIt->editIdStore().begin() + i + 1,
 211                             texEnvIdFile                              );
 212
 213                         // duplicate the binding of the TexObj
 214                         ptrFieldIt->editBindingStore().insert(
 215                             ptrFieldIt->editBindingStore().begin() + i + 1,
 216                             ptrFieldIt->getBindingStore()[i]               );
 217
 218                         ++numIds;
 219                         ++numBind;
 220                     }
 221                 }
 222             }
 223             else
 224             {
 225                 for(UInt32 i = 0; i < numIds; ++i)
 226                 {
 227                     if(ptrFieldIt->getIdStore()[i] == getFCIdFile())
 228                     {
 229                         // insert a pointer to TexEnv right after the TexObj
 230                         ptrFieldIt->editIdStore().insert(
 231                             ptrFieldIt->editIdStore().begin() + i + 1,
 232                             texEnvIdFile                              );
 233
 234                         ++numIds;
 235                     }
 236                 }
 237             }
 238         }
 239     }
 240 }
 241
 242 /*-------------------------------------------------------------------------*/
 243 /* Writing                                                                 */
 244
 245 void
 246 OSBTextureChunkElement::preWrite(FieldContainer * const fc)
 247 {
 248     OSG_OSB_LOG(("OSBTextureChunkElement::preWrite\n"));
 249
 250     preWriteFieldContainer(fc, "");
 251 }
 252
 253 void
 254 OSBTextureChunkElement::write(void)
 255 {
 256     OSG_OSB_LOG(("OSBTextureChunkElement::write\n"));
 257
 258     if(getContainer() == NULL)
 259     {
 260         FWARNING(("OSBTextureChunkElement::write: Attempt to write NULL.\n"));
 261         return;
 262     }
 263
 264     BinaryWriteHandler *wh = editRoot()->getWriteHandler();
 265
 266     wh->putValue(getFCPtrType(getContainer()));
 267     wh->putValue(getVersion()                );
 268
 269     writeFields("", true);
 270 }
 271
 272
 273 bool
 274 OSBTextureChunkElement::isTexObjField(const std::string &fieldName) const
 275 {
 276     return TextureObjChunk::getClassType().getFieldDesc(fieldName.c_str()) != NULL;
 277 }
 278
 279 bool
 280 OSBTextureChunkElement::isTexEnvField(const std::string &fieldName) const
 281 {
 282     return TextureEnvChunk::getClassType().getFieldDesc(fieldName.c_str()) != NULL;
 283 }
 284