nevrax.org : docs

00001 
00007 /* Copyright, 2001 Nevrax Ltd.
00008  *
00009  * This file is part of NEVRAX NEL.
00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
00011  * it under the terms of the GNU General Public License as published by
00012  * the Free Software Foundation; either version 2, or (at your option)
00013  * any later version.
00014 
00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00018  * General Public License for more details.
00019 
00020  * You should have received a copy of the GNU General Public License
00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
00023  * MA 02111-1307, USA.
00024  */
00025 
00026 #include "std3d.h"
00027 
00028 #include "3d/mesh_morpher.h"
00029 #include "3d/vertex_buffer.h"
00030 #include "3d/vertex_buffer_hard.h"
00031 
00032 
00033 using namespace std;
00034 using namespace NLMISC;
00035 
00036 
00037 namespace NL3D 
00038 {
00039 
00040 // ***************************************************************************
00041 void CBlendShape::serial (NLMISC::IStream &f) throw(NLMISC::EStream)
00042 {
00043         // version 1 : added tangent space support
00044         sint ver = f.serialVersion (1);
00045 
00046         f.serial (Name);
00047 
00048         f.serialCont (deltaPos);
00049         f.serialCont (deltaNorm);
00050         f.serialCont (deltaUV);
00051         f.serialCont (deltaCol);
00052 
00053         if (ver >= 1) f.serialCont(deltaTgSpace);
00054 
00055         f.serialCont (VertRefs);
00056 }
00057 
00058 // ***************************************************************************
00059 CMeshMorpher::CMeshMorpher()
00060 {
00061         _VBOri = NULL;
00062         _VBDst = NULL;
00063         _VBDstHrd = NULL;
00064 
00065         _Vertices = NULL;
00066         _Normals = NULL;
00067         _TgSpace= NULL;
00068         _SkinApplied= false;
00069 }
00070 
00071 // ***************************************************************************
00072 void CMeshMorpher::init (CVertexBuffer *vbOri, CVertexBuffer *vbDst, IVertexBufferHard *vbDstHrd, bool hasTgSpace)
00073 {
00074         _VBOri = vbOri;
00075         _VBDst = vbDst;
00076         _VBDstHrd = vbDstHrd;
00077         _UseTgSpace = hasTgSpace;
00078 }
00079 
00080 // ***************************************************************************
00081 void CMeshMorpher::initSkinned (CVertexBuffer *vbOri,
00082                                                         CVertexBuffer *vbDst,
00083                                                         IVertexBufferHard *vbDstHrd,
00084                                                         bool hasTgSpace,
00085                                                         std::vector<CVector> *vVertices,
00086                                                         std::vector<CVector> *vNormals,
00087                                                         std::vector<CVector> *vTgSpace, /* NULL if none */
00088                                                         bool bSkinApplied       )
00089 {
00090         _VBOri = vbOri;
00091         _VBDst = vbDst;
00092         _VBDstHrd = vbDstHrd;
00093         _UseTgSpace = hasTgSpace;
00094 
00095         _Vertices = vVertices;
00096         _Normals = vNormals;
00097         _TgSpace = vTgSpace;
00098         _SkinApplied = bSkinApplied;
00099 }
00100 
00101 // ***************************************************************************
00102 void CMeshMorpher::update (std::vector<CAnimatedMorph> *pBSFactor)
00103 {
00104         uint32 i, j;
00105 
00106         if (_VBOri == NULL)
00107                 return;
00108         if (BlendShapes.size() == 0)
00109                 return;
00110 
00111         if (_VBOri->getNumVertices() != _VBDst->getNumVertices())
00112         {       // Because the original vertex buffer is not initialized by default
00113                 // we must init it here (if there are some blendshapes)
00114                 *_VBOri = *_VBDst;
00115         }
00116 
00117         // Does the flags are reserved ?
00118         if (_Flags.size() != _VBOri->getNumVertices())
00119         {
00120                 _Flags.resize (_VBOri->getNumVertices());
00121                 for (i = 0; i < _Flags.size(); ++i)
00122                         _Flags[i] = Modified; // Modified to update all
00123         }
00124 
00125         nlassert(_VBOri->getVertexFormat() == _VBDst->getVertexFormat());
00126 
00127         // Cleaning with original vertex buffer
00128         uint32 VBVertexSize = _VBOri->getVertexSize();
00129         uint8 *pOri = (uint8*)_VBOri->getVertexCoordPointer ();
00130         uint8 *pDst = (uint8*)_VBDst->getVertexCoordPointer ();
00131         
00132         for (i= 0; i < _Flags.size(); ++i)
00133         if (_Flags[i] >= Modified)
00134         {
00135                 _Flags[i] = OriginalVBDst;
00136 
00137                 for(j = 0; j < VBVertexSize; ++j)
00138                         pDst[j+i*VBVertexSize] = pOri[j+i*VBVertexSize];
00139         }
00140 
00141         uint tgSpaceStage = 0;
00142         if (_UseTgSpace)
00143         {
00144                 tgSpaceStage = _VBDst->getNumTexCoordUsed() - 1;
00145         }
00146 
00147         // Blending with blendshape
00148         for (i = 0; i < BlendShapes.size(); ++i)
00149         {
00150                 CBlendShape &rBS = BlendShapes[i];
00151                 float rFactor = pBSFactor->operator[](i).getFactor()/100.0f;
00152 
00153                 if (rFactor > 0.0f)
00154                 for (j = 0; j < rBS.VertRefs.size(); ++j)
00155                 {
00156                         uint32 vp = rBS.VertRefs[j];
00157 
00158                         // Modify Pos/Norm/TgSpace.
00159                         //------------
00160                         if (_VBDst->getVertexFormat() & CVertexBuffer::PositionFlag)
00161                         if (rBS.deltaPos.size() > 0)
00162                         {
00163                                 CVector *pV = (CVector*)_VBDst->getVertexCoordPointer (vp);
00164                                 *pV += rBS.deltaPos[j] * rFactor;
00165                         }
00166 
00167                         if (_VBDst->getVertexFormat() & CVertexBuffer::NormalFlag)
00168                         if (rBS.deltaNorm.size() > 0)
00169                         {
00170                                 CVector *pV = (CVector*)_VBDst->getNormalCoordPointer (vp);
00171                                 *pV += rBS.deltaNorm[j] * rFactor;
00172                         }
00173 
00174                         if (_UseTgSpace)
00175                         if (rBS.deltaTgSpace.size() > 0)
00176                         {
00177                                 CVector *pV = (CVector*)_VBDst->getTexCoordPointer (vp, tgSpaceStage);
00178                                 *pV += rBS.deltaTgSpace[j] * rFactor;
00179                         }
00180 
00181                         // Modify UV0 / Color
00182                         //------------
00183                         if (_VBDst->getVertexFormat() & CVertexBuffer::TexCoord0Flag)
00184                         if (rBS.deltaUV.size() > 0)
00185                         {
00186                                 CUV *pUV = (CUV*)_VBDst->getTexCoordPointer (vp);
00187                                 *pUV += rBS.deltaUV[j] * rFactor;
00188                         }
00189 
00190                         if (_VBDst->getVertexFormat() & CVertexBuffer::PrimaryColorFlag)
00191                         if (rBS.deltaCol.size() > 0)
00192                         {
00193                                 CRGBA *pRGBA = (CRGBA*)_VBDst->getColorPointer (vp);
00194                                 CRGBAF rgbf(*pRGBA);
00195                                 rgbf.R += rBS.deltaCol[j].R * rFactor;
00196                                 rgbf.G += rBS.deltaCol[j].G * rFactor;
00197                                 rgbf.B += rBS.deltaCol[j].B * rFactor;
00198                                 rgbf.A += rBS.deltaCol[j].A * rFactor;
00199                                 clamp(rgbf.R, 0.0f, 1.0f);
00200                                 clamp(rgbf.G, 0.0f, 1.0f);
00201                                 clamp(rgbf.B, 0.0f, 1.0f);
00202                                 clamp(rgbf.A, 0.0f, 1.0f);
00203                                 *pRGBA = rgbf;
00204                         }
00205 
00206                         // Modified
00207                         _Flags[vp] = Modified;
00208                 }
00209         }
00210 
00211         // Copying to hardware vertex buffer if some
00212         if (_VBDstHrd != NULL)
00213         {
00214                 uint8 *pDstHrd = (uint8*)_VBDstHrd->lock();
00215                 for (i = 0; i < _Flags.size(); ++i)
00216                 {
00217                         if (_Flags[i] != OriginalAll) // Not OriginalAll ?
00218                         {
00219                                 for(j = 0; j < VBVertexSize; ++j)
00220                                         pDstHrd[j+i*VBVertexSize] = pDst[j+i*VBVertexSize];
00221                         }
00222                         // if this vertex is original in the VBDst
00223                         if (_Flags[i] == OriginalVBDst)
00224                                 // then it is now copied into the VBHard
00225                                 _Flags[i] = OriginalAll;
00226                 }
00227                 _VBDstHrd->unlock();
00228         }
00229 }
00230 
00231 
00232 // ***************************************************************************
00233 void CMeshMorpher::updateSkinned (std::vector<CAnimatedMorph> *pBSFactor)
00234 {
00235         uint32 i, j;
00236 
00237         if (_VBOri == NULL)
00238                 return;
00239         if (BlendShapes.size() == 0)
00240                 return;
00241 
00242         if (_VBOri->getNumVertices() != _VBDst->getNumVertices())
00243         {       // Because the original vertex buffer is not initialized by default
00244                 // we must init it here (if there are some blendshapes)
00245                 *_VBOri = *_VBDst;
00246         }
00247 
00248         // Does the flags are reserved ?
00249         if (_Flags.size() != _VBOri->getNumVertices())
00250         {
00251                 _Flags.resize (_VBOri->getNumVertices());
00252                 for (i = 0; i < _Flags.size(); ++i)
00253                         _Flags[i] = Modified; // Modified to update all
00254         }
00255 
00256         nlassert(_VBOri->getVertexFormat() == _VBDst->getVertexFormat());
00257 
00258         uint tgSpaceStage;
00259         uint tgSpaceOff = 0;
00260         if (_UseTgSpace && _TgSpace)
00261         {
00262                 tgSpaceStage = _VBDst->getNumTexCoordUsed() - 1;
00263                 tgSpaceOff = _VBDst->getTexCoordOff(tgSpaceStage);
00264         }
00265 
00266         // Cleaning with original vertex buffer
00267         uint32 VBVertexSize = _VBOri->getVertexSize();
00268         uint8 *pOri = (uint8*)_VBOri->getVertexCoordPointer ();
00269         uint8 *pDst = (uint8*)_VBDst->getVertexCoordPointer ();
00270         
00271         for (i= 0; i < _Flags.size(); ++i)
00272         if (_Flags[i] >= Modified)
00273         {
00274                 for(j = 0; j < VBVertexSize; ++j)
00275                         pDst[j+i*VBVertexSize] = pOri[j+i*VBVertexSize];
00276                 
00277                 if (_Vertices != NULL)
00278                         _Vertices->operator[](i) = ((CVector*)(pOri+i*VBVertexSize))[0];
00279 
00280                 if (_Normals != NULL)
00281                         _Normals->operator[](i) = ((CVector*)(pOri+i*VBVertexSize))[1];
00282 
00283                 if (_TgSpace != NULL)
00284                         (*_TgSpace)[i] = * (CVector*)(pOri + i * VBVertexSize + tgSpaceOff);
00285                         
00286                 _Flags[i] = OriginalVBDst;
00287         }
00288 
00289         // Blending with blendshape
00290         for (i = 0; i < BlendShapes.size(); ++i)
00291         {
00292                 CBlendShape &rBS = BlendShapes[i];
00293                 float rFactor = pBSFactor->operator[](i).getFactor()/100.0f;
00294 
00295                 if (rFactor > 0.0f)
00296                 for (j = 0; j < rBS.VertRefs.size(); ++j)
00297                 {
00298                         uint32 vp = rBS.VertRefs[j];
00299 
00300                         // Modify Pos/Norm/TgSpace.
00301                         //------------
00302                         if (_Vertices != NULL)
00303                         if (rBS.deltaPos.size() > 0)
00304                         {
00305                                 CVector *pV = &(_Vertices->operator[](vp));
00306                                 *pV += rBS.deltaPos[j] * rFactor;
00307                         }
00308 
00309                         if (_Normals != NULL)
00310                         if (rBS.deltaNorm.size() > 0)
00311                         {
00312                                 CVector *pV = &(_Normals->operator[](vp));
00313                                 *pV += rBS.deltaNorm[j] * rFactor;
00314                         }
00315 
00316                         if (_UseTgSpace && _TgSpace != NULL)
00317                         if (rBS.deltaTgSpace.size() > 0)
00318                         {
00319                                 CVector *pV = &((*_TgSpace)[vp]);
00320                                 *pV += rBS.deltaTgSpace[j] * rFactor;
00321                         }
00322 
00323                         // Modify UV0 / Color
00324                         //------------
00325                         if (_VBDst->getVertexFormat() & CVertexBuffer::TexCoord0Flag)
00326                         if (rBS.deltaUV.size() > 0)
00327                         {
00328                                 CUV *pUV = (CUV*)_VBDst->getTexCoordPointer (vp);
00329                                 *pUV += rBS.deltaUV[j] * rFactor;
00330                         }
00331 
00332                         if (_VBDst->getVertexFormat() & CVertexBuffer::PrimaryColorFlag)
00333                         if (rBS.deltaCol.size() > 0)
00334                         {
00335                                 CRGBA *pRGBA = (CRGBA*)_VBDst->getColorPointer (vp);
00336                                 CRGBAF rgbf(*pRGBA);
00337                                 rgbf.R += rBS.deltaCol[j].R * rFactor;
00338                                 rgbf.G += rBS.deltaCol[j].G * rFactor;
00339                                 rgbf.B += rBS.deltaCol[j].B * rFactor;
00340                                 rgbf.A += rBS.deltaCol[j].A * rFactor;
00341                                 clamp(rgbf.R, 0.0f, 1.0f);
00342                                 clamp(rgbf.G, 0.0f, 1.0f);
00343                                 clamp(rgbf.B, 0.0f, 1.0f);
00344                                 clamp(rgbf.A, 0.0f, 1.0f);
00345                                 *pRGBA = rgbf;
00346                         }
00347 
00348                         // Modified
00349                         _Flags[vp] = Modified;
00350                 }
00351         }
00352 
00353         // Do some transfert to the VBHard if exist.
00354         if (_VBDstHrd != NULL)
00355         {
00356                 // lock.
00357                 uint8 *pDstHrd = (uint8*)_VBDstHrd->lock();
00358 
00359                 // If the skin is applied we have nothing to do 
00360                 // Because the skinning will transfert ALL the vertices of interest
00361                 if (!_SkinApplied) 
00362                 {
00363                         for (i = 0; i < _Flags.size(); ++i)
00364                         {
00365                                 if (_Flags[i] != OriginalAll) // Not OriginalAll ?
00366                                 {
00367                                         // We must write the whole vertex because the skinning may not copy 
00368                                         // vertex and normal changes into VBHard
00369                                         for(j = 0; j < VBVertexSize; ++j)
00370                                                 pDstHrd[j+i*VBVertexSize] = pDst[j+i*VBVertexSize];
00371                                 }
00372                                 if (_Flags[i] == OriginalVBDst) // OriginalVBDst ?
00373                                         _Flags[i] = OriginalAll; // So OriginalAll !
00374                         }
00375                 }
00376 
00377                 // unlock.
00378                 _VBDstHrd->unlock();
00379         }
00380 }
00381 
00382 // ***************************************************************************
00383 void CMeshMorpher::serial (NLMISC::IStream &f) throw(NLMISC::EStream)
00384 {
00385         (void)f.serialVersion (0);
00386 
00387         f.serialCont (BlendShapes);
00388 }
00389 
00390 
00391 } // NL3D
00392 
00393 
00394 
00395 
00396 
00397 
00398 
00399 
00400 
00401
mesh_morpher.cpp
