Esempio n. 1
0
bool LWOFile::LoadWeightMap(unsigned int iChunkSize)
{
  Layer *pLayer=GetLastLayer();

  const char *pChunkEndPos=m_pData+iChunkSize-4;

  unsigned short iDimension=0;
  if(!ReadU2(iDimension))
  {
    return false;
  }

  // is not 1 float per vertex
  if(iDimension!=1)
  {
    // just skip
    m_pData+=iChunkSize-4-2;
    AddError("Warning: WeightMap has "+ConvertToString(iDimension)+" floats per vertex (1 expected)");
    return true;
  }

  unsigned int iStrBytes=0;
  std::string strName;
  if(!ReadS0(strName,iStrBytes))
  {
    return false;
  }


  // VMAP { type[ID4], dimension[U2], name[S0],
  //  ( vert[VX], value[F4] # dimension )* }

  WeightMap *pWeightMap=new WeightMap();
  pWeightMap->m_strName=strName;
  pWeightMap->m_Values.resize(1*pLayer->m_iPoints);
  pLayer->m_WeightMaps.push_back(pWeightMap);

  float *pValues=&pWeightMap->m_Values[0];
  memset(pValues,0,sizeof(float)*1*pLayer->m_iPoints);

  while(m_pData<pChunkEndPos)
  {
    unsigned int iVertexID=0;
    if(!ReadVX(iVertexID)) return false;
    if(iVertexID>=pLayer->m_iPoints) return false;
    if(!ReadF4(pValues[iVertexID])) return false;
  }

  return true;
}
Esempio n. 2
0
bool LWOFile::LoadLAYR(unsigned int iChunkSize)
{
  Layer *pLayer=new Layer();
  m_Layers.push_back(pLayer);

  // LAYR { number[U2], flags[U2], pivot[VEC12], name[S0], parent[U2] ? }
  const char *pChunkEndPos=m_pData+iChunkSize;
  if(!ReadU2(pLayer->m_iID)) return false;
  if(!ReadU2(pLayer->m_iFlags)) return false;
  if(!ReadF4(pLayer->m_vPivot[0])) return false;
  if(!ReadF4(pLayer->m_vPivot[1])) return false;
  if(!ReadF4(pLayer->m_vPivot[2])) return false;
  if(!ReadS0(pLayer->m_strName)) return false;

  // parent id is optional, so read it only if theres data left
  if(m_pData<pChunkEndPos)
  {
    if(!ReadU2(pLayer->m_iParentID)) return false;
  } else {
    pLayer->m_iParentID=0;
  }

  return true;
}
Esempio n. 3
0
bool LWOFile::LoadPTAG(unsigned int iChunkSize)
{
  Layer *pLayer=GetLastLayer();
  if(pLayer==NULL)
  {
    AddError("No LAYR before PTAG");
    return false;
  }

  if(pLayer->m_Polygons.size()==0)
  {
    AddError("No POLS before PTAG");
    return false;
  }

  const char *pChunkEndPos=m_pData+iChunkSize;

  // read type
  unsigned int iType=0;
  if(!ReadID4(iType))
  {
    return false;
  }

  if(iType!=ID4("SURF"))
  {
    // unknown type - skip
    m_pData+=iChunkSize-4;
    AddError("Warning: Unknown PTAG type "+ID4ToString(iType));
    return true;
  }

  while(m_pData<pChunkEndPos)
  {
    // read poly id
    unsigned int iPolyID;
    if(!ReadVX(iPolyID)) return false;

    // read tag
    unsigned short iTag;
    if(!ReadU2(iTag)) return false;

    if(iPolyID>=pLayer->m_Polygons.size()) return false;
    pLayer->m_Polygons[iPolyID].m_iSurface=iTag;
  }

  return true;
}
Esempio n. 4
0
bool LWOFile::LoadVMAD(unsigned int iChunkSize)
{
  Layer *pLayer=GetLastLayer();
  if(pLayer==NULL)
  {
    AddError("No LAYR before VMAD");
    return false;
  }

  const char *pChunkEndPos=m_pData+iChunkSize;

  // VMAD { type[ID4], dimension[U2], name[S0],
  // ( vert[VX], poly[VX], value[F4] # dimension )* }
  unsigned int iType=0;
  if(!ReadID4(iType)) return false;

  // type must be uvmap
  if(iType!=ID4("TXUV"))
  {
    AddError("Warning: Unknown discontinuous vertex map type "+ID4ToString(iType));
    m_pData+=iChunkSize-4;
    return true;
  }

  // dimension
  unsigned short iDimension=0;
  if(!ReadU2(iDimension))
  {
    return false;
  }

  // not 2 floats per vertex
  if(iDimension!=2)
  {
    AddError("Warning: Discontinuous UVMap has "+ConvertToString(iDimension)+" floats per vertex (2 expected)");
    // skip
    m_pData+=iChunkSize-4-2;
    return true;
  }

  // name
  unsigned int iStrBytes=0;
  std::string strName;
  if(!ReadS0(strName,iStrBytes))
  {
    return false;
  }

  // for each uvmap
  UVMap *pUV=NULL;
  for(unsigned int iUV=0;iUV<pLayer->m_UVMaps.size();iUV++)
  {
    if(pLayer->m_UVMaps[iUV]->m_strName==strName)
    {
      pUV=pLayer->m_UVMaps[iUV];
    }
  }

  if(pUV==NULL)
  {
    AddError("No matching UVMap for discontinuous UVMap \""+strName+"\"");
    return false;
  }


  // read rest of chunk to memory
  //
  unsigned int iBytesLeft=iChunkSize-4-2-iStrBytes;

  UVMapD *pUVMap=new UVMapD();
  pUVMap->m_strName=strName;
  pUVMap->m_pUVMap=pUV;
  // worst case estimate
  pUVMap->m_Entries.reserve(iBytesLeft/(2+2+4+4));
  pLayer->m_UVMapDs.push_back(pUVMap);

  while(m_pData<pChunkEndPos)
  {
    unsigned int iVertexID=0;
    if(!ReadVX(iVertexID)) return false;

    unsigned int iPolyID=0;
    if(!ReadVX(iPolyID)) return false;

    UVMapD::Entry e;
    e.iVertex=iVertexID;
    e.iPolygon=iPolyID;
    if(!ReadF4(e.u)) return false;
    if(!ReadF4(e.v)) return false;
    // flip v coordinate
    e.v=1-e.v;
    pUVMap->m_Entries.push_back(e);
  }

  return true;
}
Esempio n. 5
0
void LWOReader::ReadBLOK( LWSurface* pSurface, UInt32 pChunkSize )
{
    UInt32      dataRead = 0;
    UInt16      subChunkSize;
    UInt32      subChunkTag;
    UInt32      bytesHold;

    LWSurfaceBlock*     newSurfaceBlock = GD_NEW(LWSurfaceBlock, this, "SurfaceBlock");

    //dataRead += ReadS0( newSurfaceBlock->mOrdinalString );

    // Read all subchunks
    while( dataRead < pChunkSize )
    {
        subChunkTag = ReadSubChunk(subChunkSize,1);
        dataRead += sizeof(subChunkTag);   // Subchunk tag.
        dataRead += sizeof(subChunkSize);  // Subchunk size.

        bytesHold = dataRead;

        switch( subChunkTag )
        {
        case ID_IMAP:
        case ID_PROC:
        case ID_GRAD:
        case ID_SHDR:
            newSurfaceBlock->mType = subChunkTag;
	        ReadHEAD( newSurfaceBlock, subChunkSize );
            dataRead += subChunkSize;
            break;

        case ID_TMAP:
            ReadTMAP( &newSurfaceBlock->mTextureMapping, subChunkSize );
            dataRead += subChunkSize;
            break;

        case ID_PROJ:
            dataRead += ReadU2( newSurfaceBlock->mImageMap.mProjectionMode );
            break;

        case ID_AXIS:
            dataRead += ReadU2( newSurfaceBlock->mImageMap.mProjectionAxis );
            break;

        case ID_IMAG:
            newSurfaceBlock->mImageMap.mValid = true;
            dataRead += ReadVX( newSurfaceBlock->mImageMap.mImageMap );
            break;

        case ID_WRAP:
            dataRead += ReadU2( newSurfaceBlock->mImageMap.mWrapModeWidth );
            dataRead += ReadU2( newSurfaceBlock->mImageMap.mWrapModeHeight );
            break;

        case ID_VMAP:
            dataRead += ReadS0( newSurfaceBlock->mImageMap.mUVVertexMapName );
            break;

        default:
           dataRead += Skip( subChunkSize );   
           break;
        }

        // Make sure we've read all subchunk bytes (given by the size).
        if( (subChunkSize - dataRead + bytesHold) > 0 )
            dataRead += Skip( subChunkSize - dataRead + bytesHold );
    }

    pSurface->mBlocks.push_back( newSurfaceBlock );
}
Esempio n. 6
0
void LWOReader::ReadSURF( UInt32 pChunkSize )
{
    UInt32      dataRead = 0;
    UInt16      subChunkSize;
    UInt32      subChunkTag;
    UInt32      bytesHold;
    LWIndex     env;
    
    LWSurface*  newSurface = GD_NEW(LWSurface, this, "Surface");

    dataRead += ReadS0( newSurface->mSurfaceName );
    dataRead += ReadS0( newSurface->mSurfaceFile );

    // Read all subchunks
    while( dataRead < pChunkSize )
    {
        if( (pChunkSize - dataRead) < 6 )
        {
            dataRead += Skip( pChunkSize - dataRead );
            return;
	    }

        subChunkTag = ReadSubChunk(subChunkSize);
        dataRead += sizeof(subChunkTag);   // Subchunk tag.
        dataRead += sizeof(subChunkSize);  // Subchunk size.

        bytesHold = dataRead;

        switch( subChunkTag )
        {
        case ID_COLR:   
            dataRead += ReadCOL12( newSurface->mBaseColor );    
            dataRead += ReadVX( env );
            break;
            
        case ID_DIFF:
            dataRead += ReadFP4( newSurface->mDiffuse );    
            dataRead += ReadVX( env );
            break;

        case ID_LUMI:
            dataRead += ReadFP4( newSurface->mLuminosity );    
            dataRead += ReadVX( env );
            break;

        case ID_SPEC:
            dataRead += ReadFP4( newSurface->mSpecular );    
            dataRead += ReadVX( env );
            break;

        case ID_REFL:
            dataRead += ReadFP4( newSurface->mReflection );    
            dataRead += ReadVX( env );
            break;

        case ID_TRAN:
            dataRead += ReadFP4( newSurface->mTransparency );    
            dataRead += ReadVX( env );
            break;

        case ID_TRNL:
            dataRead += ReadFP4( newSurface->mTranslucency );    
            dataRead += ReadVX( env );
            break;
            
        case ID_GLOS:
            dataRead += ReadFP4( newSurface->mSpecularGlossiness );    
            dataRead += ReadVX( env );
            break;

        case ID_SHRP:
            dataRead += ReadFP4( newSurface->mDiffuseSharpness );    
            dataRead += ReadVX( env );
            break;

        case ID_BUMP:
            dataRead += ReadFP4( newSurface->mBumpStrength );    
            dataRead += ReadVX( env );
            break;
            
        case ID_SIDE:
            dataRead += ReadU2( newSurface->mPolySide );    
            break;
            
        case ID_SMAN:
            dataRead += ReadANG4( newSurface->mMaxSmoothingAngle );
            break;
            
        case ID_RFOP:
            dataRead += ReadU2( newSurface->mReflectionOptions );
            break;
            
        case ID_RIMG:
            dataRead += ReadVX( newSurface->mReflectionMapImage );
            break;
            
        case ID_RSAN:
            dataRead += ReadANG4( newSurface->mReflMapSeamAngle );
            dataRead += ReadVX( env );
            break;

        case ID_RBLR:
            dataRead += ReadFP4( newSurface->mReflBlurPercent );
            dataRead += ReadVX( env );
            break;

        case ID_CLRH:
            dataRead += ReadFP4( newSurface->mColorHighlights );
            dataRead += ReadVX( env );
            break;

        case ID_TROP:
            dataRead += ReadU2( newSurface->mTransparencyOptions );
            dataRead += Skip( subChunkSize - sizeof(UInt16) );
            break;

        case ID_CLRF:
            dataRead += ReadFP4( newSurface->mColorFilter );
            dataRead += ReadVX( env );
            break;

        case ID_ADTR:
            dataRead += ReadFP4( newSurface->mAdditiveTransparency );
            dataRead += ReadVX( env );
            break;         
        
        case ID_ALPH:
            dataRead += ReadU2( newSurface->mAlphaMode );
            dataRead += ReadFP4( newSurface->mAlphaValue );
            break;

        case ID_BLOK:
            ReadBLOK( newSurface, subChunkSize );
            dataRead += subChunkSize;
            break;
        
        case ID_VCOL:
        case ID_LINE:
        case ID_GLOW:
        case ID_TBLR:
        case ID_TIMG:
        case ID_RIND:
        default:    dataRead += Skip( subChunkSize );   break;
        }

        // Make sure we've read all subchunk bytes (given by the size).
        if( (subChunkSize - dataRead + bytesHold) > 0 )
            dataRead += Skip( subChunkSize - dataRead + bytesHold );
    }

    mObject->mSurfaces.push_back( newSurface );
}
Esempio n. 7
0
void LWOReader::ReadVMAP( UInt32 pChunkSize, Bool pPerPoly )
{
    UInt32              dataRead = 0;
    UInt16              dimension;
    LWIndex             vertexIndex;
    LWIndex             polygonIndex;
    
    LWVertexMap*        newVertexMap = GD_NEW(LWVertexMap, this, "VertexMap");

    newVertexMap->mPerPoly = pPerPoly;

    dataRead += ReadID4( newVertexMap->mType );
    dataRead += ReadU2( dimension );
    dataRead += ReadS0( newVertexMap->mName );

    while( dataRead < pChunkSize )
    {
        dataRead += ReadVX( vertexIndex );
        newVertexMap->mVertexIndex.push_back( vertexIndex );

        if( pPerPoly )
        {
            dataRead += ReadVX( polygonIndex );
            newVertexMap->mPolygonIndex.push_back( polygonIndex );
        }

        LWMapValue mapping;

        switch( newVertexMap->mType )
        {
        case ID_PICK:
            mapping.mPick = vertexIndex;
            break;

        case ID_WGHT:
            dataRead += ReadF4( mapping.mWeight );
            break;

        case ID_TXUV:   
            dataRead += ReadF4( mapping.mUV.U );
            dataRead += ReadF4( mapping.mUV.V );
            break;

        case ID_RGB:
            dataRead += ReadF4( mapping.mRGB.R );
            dataRead += ReadF4( mapping.mRGB.G );
            dataRead += ReadF4( mapping.mRGB.B );
            break;

        case ID_RGBA:
            dataRead += ReadF4( mapping.mRGBA.R );
            dataRead += ReadF4( mapping.mRGBA.G );
            dataRead += ReadF4( mapping.mRGBA.B );
            dataRead += ReadF4( mapping.mRGBA.A ); 
            break;

        case ID_MORF:
        case ID_SPOT:
        case ID_MNVW:   
        default:       
            dataRead += Skip( dimension * sizeof(Float) );      
            break;
        }   

        newVertexMap->mValues.push_back( mapping );
    }

    GetCurrentLayer()->mVertexMaps.push_back( newVertexMap );
}