Source/System/FileIO/OSB/OSGOSBSHLChunkElement.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *                   Copyright (C) 2013 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 #include "OSGOSBSHLChunkElement.h"
  31
  32 #include "OSGOSBRootElement.h"
  33 #include "OSGOSBShaderParameterBoolElement.h"
  34 #include "OSGOSBShaderParameterIntElement.h"
  35 #include "OSGOSBShaderParameterMatrixElement.h"
  36 #include "OSGOSBShaderParameterMIntElement.h"
  37 #include "OSGOSBShaderParameterMRealElement.h"
  38 #include "OSGOSBShaderParameterMVec2fElement.h"
  39 #include "OSGOSBShaderParameterMVec3fElement.h"
  40 #include "OSGOSBShaderParameterMVec4fElement.h"
  41 #include "OSGOSBShaderParameterRealElement.h"
  42 #include "OSGOSBShaderParameterVec2fElement.h"
  43 #include "OSGOSBShaderParameterVec3fElement.h"
  44 #include "OSGOSBShaderParameterVec4fElement.h"
  45
  46 #include "OSGSimpleSHLChunk.h"
  47
  48 OSG_BEGIN_NAMESPACE
  49
  50 /*-------------------------------------------------------------------------*/
  51 /* OSBSHLChunkElement                                                      */
  52 /*-------------------------------------------------------------------------*/
  53
  54 /*! Reads the SHLChunk from OpenSG 1.x and converts it to a SimpleSHLChunk.
  55  */
  56
  57 /*-------------------------------------------------------------------------*/
  58 /* Static members                                                          */
  59
  60 OSBElementRegistrationHelper<OSBSHLChunkElement>
  61     OSBSHLChunkElement::_regHelper =
  62         OSBElementRegistrationHelper<OSBSHLChunkElement>("SHLChunk");
  63
  64 /*-------------------------------------------------------------------------*/
  65 /* Constructor                                                             */
  66
  67 OSBSHLChunkElement::OSBSHLChunkElement(OSBRootElement *root) :
  68      Inherited(root, OSGOSBHeaderVersion200),
  69     _pSHLChunk(NULL                        ),
  70     _paramIds (                            )
  71 {
  72 }
  73
  74 /*-------------------------------------------------------------------------*/
  75 /* Destructor                                                              */
  76
  77 OSBSHLChunkElement::~OSBSHLChunkElement(void)
  78 {
  79 }
  80
  81 /*-------------------------------------------------------------------------*/
  82 /* Reading                                                                 */
  83
  84 void
  85 OSBSHLChunkElement::read(const std::string &typeName)
  86 {
  87     OSG_OSB_LOG(("OSBSHLChunkElement::read: [%s]\n", typeName.c_str()));
  88
  89     BinaryReadHandler *rh = editRoot()->getReadHandler();
  90
  91     UInt8  ptrTypeId;
  92     UInt16 version;
  93
  94     rh->getValue(ptrTypeId);
  95     rh->getValue(version  );
  96
  97     OSG_OSB_LOG(("OSBSHLChunkElement::read: version: [%u]\n", version));
  98
  99     // create replacement chunk
 100     _pSHLChunk = SimpleSHLChunk::create();
 101     setContainer(_pSHLChunk);
 102
 103     std::string    fieldName;
 104     std::string    fieldTypeName;
 105     UInt32         fieldSize;
 106     PtrFieldListIt ptrFieldIt;
 107
 108     MFGLenum       paramNames;
 109     MFUInt32       paramValues;
 110
 111     while(readFieldHeader("", fieldName, fieldTypeName, fieldSize))
 112     {
 113         if(isSimpleSHLField(fieldName))
 114         {
 115             readFieldContent(fieldName, fieldTypeName, fieldSize, "", ptrFieldIt);
 116         }
 117         else if(fieldName == "parameters")
 118         {
 119             UInt32 ptrId;
 120             UInt32 numElements;
 121
 122             rh->getValue(numElements);
 123             _paramIds.resize(numElements);
 124
 125             for(UInt32 i = 0; i < numElements; ++i)
 126             {
 127                 rh->getValue(ptrId);
 128                 _paramIds[i] = ptrId;
 129             }
 130         }
 131         else if(fieldName == "programParameterNames")
 132         {
 133             paramNames.copyFromBin(*rh);
 134         }
 135         else if(fieldName == "programParameterValues")
 136         {
 137             paramValues.copyFromBin(*rh);
 138         }
 139         else
 140         {
 141             OSG_OSB_LOG(("Skipping [%d] bytes for field [%s]\n",
 142                          fieldSize, fieldName.c_str()));
 143             rh->skip(fieldSize);
 144         }
 145     }
 146
 147     // handle paramNames, paramValues
 148     if(paramNames.empty() == false)
 149     {
 150         if(paramNames.size() != paramValues.size())
 151         {
 152             FWARNING(("OSBSHLChunkElement::read: Fields "
 153                       "'MFProgramParamterNamse' and 'MFProgramParameterValues' "
 154                       "have inconsistent sizes.\n"));
 155         }
 156         else
 157         {
 158             for(UInt32 i = 0; i < paramNames.size(); ++i)
 159             {
 160                 _pSHLChunk->setProgramParameter(paramNames[i], paramValues[i]);
 161             }
 162         }
 163     }
 164 }
 165
 166 void
 167 OSBSHLChunkElement::postRead(void)
 168 {
 169     OSG_OSB_LOG(("OSBSHLChunkElement::postRead:\n"));
 170
 171     const OSBRootElement::IdElemMap& elemMap = getRoot()->getIdElemMap();
 172
 173     for(UInt32 i = 0; i < _paramIds.size(); ++i)
 174     {
 175         OSBRootElement::IdElemMapConstIt elemIt = elemMap.find(_paramIds[i]);
 176
 177         if(elemIt != elemMap.end())
 178         {
 179             handleParameterElem(elemIt->second);
 180         }
 181         else
 182         {
 183             FWARNING(("No entry in IdElemMap for id [%d]\n", _paramIds[i]));
 184         }
 185     }
 186 }
 187
 188 /*-------------------------------------------------------------------------*/
 189 /* Writing                                                                 */
 190
 191 void
 192 OSBSHLChunkElement::preWrite(FieldContainer * const)
 193 {
 194     // This can not be called, SHLChunk does not exist
 195     OSG_ASSERT(false);
 196 }
 197
 198 void
 199 OSBSHLChunkElement::write(void)
 200 {
 201     // This can not be called, SHLChunk does not exist
 202     OSG_ASSERT(false);
 203 }
 204
 205 bool
 206 OSBSHLChunkElement::isSimpleSHLField(const std::string& fieldName) const
 207 {
 208     return SimpleSHLChunk::getClassType().getFieldDesc(fieldName.c_str()) != NULL;
 209 }
 210
 211 void
 212 OSBSHLChunkElement::handleParameterElem(OSBElementBase* elem)
 213 {
 214     OSBShaderParameterElement* shElem =
 215         dynamic_cast<OSBShaderParameterElement*>(elem);
 216
 217     if(shElem != NULL)
 218     {
 219         OSBShaderParameterBoolElement* shElemBool  =
 220             dynamic_cast<OSBShaderParameterBoolElement*>(shElem);
 221         OSBShaderParameterIntElement* shElemInt   =
 222             dynamic_cast<OSBShaderParameterIntElement*>(shElem);
 223         OSBShaderParameterMatrixElement* shElemMatrix =
 224             dynamic_cast<OSBShaderParameterMatrixElement*>(shElem);
 225         OSBShaderParameterMIntElement* shElemMInt =
 226             dynamic_cast<OSBShaderParameterMIntElement*>(shElem);
 227         OSBShaderParameterMRealElement* shElemMReal =
 228             dynamic_cast<OSBShaderParameterMRealElement*>(shElem);
 229         OSBShaderParameterMVec2fElement* shElemMVec2f =
 230             dynamic_cast<OSBShaderParameterMVec2fElement*>(shElem);
 231         OSBShaderParameterMVec3fElement* shElemMVec3f =
 232             dynamic_cast<OSBShaderParameterMVec3fElement*>(shElem);
 233         OSBShaderParameterMVec4fElement* shElemMVec4f =
 234             dynamic_cast<OSBShaderParameterMVec4fElement*>(shElem);
 235         OSBShaderParameterRealElement* shElemReal =
 236             dynamic_cast<OSBShaderParameterRealElement*>(shElem);
 237         OSBShaderParameterVec2fElement* shElemVec2f =
 238             dynamic_cast<OSBShaderParameterVec2fElement*>(shElem);
 239         OSBShaderParameterVec3fElement* shElemVec3f =
 240             dynamic_cast<OSBShaderParameterVec3fElement*>(shElem);
 241         OSBShaderParameterVec4fElement* shElemVec4f =
 242             dynamic_cast<OSBShaderParameterVec4fElement*>(shElem);
 243
 244         if(shElemBool != NULL)
 245         {
 246             _pSHLChunk->addUniformVariable<bool>(shElemBool->getName (),
 247                                                  shElemBool->getValue() );
 248         }
 249         else if(shElemInt != NULL)
 250         {
 251             _pSHLChunk->addUniformVariable<Int32>(shElemInt->getName (),
 252                                                   shElemInt->getValue() );
 253         }
 254         else if(shElemMatrix != NULL)
 255         {
 256             _pSHLChunk->addUniformVariable<Matrix>(shElemMatrix->getName (),
 257                                                    shElemMatrix->getValue() );
 258         }
 259         else if(shElemMInt != NULL)
 260         {
 261             _pSHLChunk->addUniformVariable<MFInt32>(shElemMInt->getName (),
 262                                                     shElemMInt->getValue() );
 263         }
 264         else if(shElemMReal != NULL)
 265         {
 266             _pSHLChunk->addUniformVariable<MFReal32>(shElemMReal->getName (),
 267                                                      shElemMReal->getValue() );
 268         }
 269         else if(shElemMVec2f != NULL)
 270         {
 271             _pSHLChunk->addUniformVariable<MFVec2f>(shElemMVec2f->getName (),
 272                                                     shElemMVec2f->getValue() );
 273         }
 274         else if(shElemMVec3f != NULL)
 275         {
 276             _pSHLChunk->addUniformVariable<MFVec3f>(shElemMVec3f->getName (),
 277                                                     shElemMVec3f->getValue() );
 278         }
 279         else if(shElemMVec4f != NULL)
 280         {
 281             _pSHLChunk->addUniformVariable<MFVec4f>(shElemMVec4f->getName (),
 282                                                     shElemMVec4f->getValue() );
 283         }
 284         else if(shElemReal != NULL)
 285         {
 286             _pSHLChunk->addUniformVariable<Real32>(shElemReal->getName (),
 287                                                    shElemReal->getValue() );
 288         }
 289         else if(shElemVec2f != NULL)
 290         {
 291             _pSHLChunk->addUniformVariable<Vec2f>(shElemVec2f->getName (),
 292                                                   shElemVec2f->getValue() );
 293         }
 294         else if(shElemVec3f != NULL)
 295         {
 296             _pSHLChunk->addUniformVariable<Vec3f>(shElemVec3f->getName (),
 297                                                   shElemVec3f->getValue() );
 298         }
 299         else if(shElemVec4f != NULL)
 300         {
 301             _pSHLChunk->addUniformVariable<Vec4f>(shElemVec4f->getName (),
 302                                                   shElemVec4f->getValue() );
 303         }
 304         else
 305         {
 306             FWARNING(("OSBSHLChunkElement::handleParameterElem: "
 307                       "Unknown parameter type for parameter named '%s'\n",
 308                       shElem->getName()));
 309         }
 310     }
 311 }
 312
 313 OSG_END_NAMESPACE