nel/src/3d/mesh_morpher.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #include "std3d.h"
  18
  19 #include "nel/3d/mesh_morpher.h"
  20 #include "nel/3d/vertex_buffer.h"
  21 #include "nel/3d/raw_skin.h"
  22
  23
  24 using namespace std;
  25 using namespace NLMISC;
  26
  27 #ifdef DEBUG_NEW
  28 #define new DEBUG_NEW
  29 #endif
  30
  31 namespace NL3D
  32 {
  33
  34 // ***************************************************************************
  35 void CBlendShape::serial (NLMISC::IStream &f)
  36 {
  37         /* ***********************************************
  38          *      WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
  39          *      It can be loaded/called through CAsyncFileManager for instance
  40          * ***********************************************/
  41
  42         // version 1 : added tangent space support
  43         sint ver = f.serialVersion (1);
  44
  45         f.serial (Name);
  46
  47         f.serialCont (deltaPos);
  48         f.serialCont (deltaNorm);
  49         f.serialCont (deltaUV);
  50         f.serialCont (deltaCol);
  51
  52         if (ver >= 1) f.serialCont(deltaTgSpace);
  53
  54         f.serialCont (VertRefs);
  55 }
  56
  57 // ***************************************************************************
  58 CMeshMorpher::CMeshMorpher()
  59 {
  60         /* ***********************************************
  61          *      WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
  62          *      It can be loaded/called through CAsyncFileManager for instance
  63          * ***********************************************/
  64
  65         _VBOri = NULL;
  66         _VBDst = NULL;
  67
  68         _Vertices = NULL;
  69         _Normals = NULL;
  70         _TgSpace= NULL;
  71         _SkinApplied= false;
  72 }
  73
  74 // ***************************************************************************
  75 void CMeshMorpher::init (CVertexBuffer *vbOri, CVertexBuffer *vbDst, bool hasTgSpace)
  76 {
  77         _VBOri = vbOri;
  78         _VBDst = vbDst;
  79         _UseTgSpace = hasTgSpace;
  80 }
  81
  82 // ***************************************************************************
  83 void CMeshMorpher::initSkinned (CVertexBuffer *vbOri,
  84                                                         CVertexBuffer *vbDst,
  85                                                         bool hasTgSpace,
  86                                                         std::vector<CVector> *vVertices,
  87                                                         std::vector<CVector> *vNormals,
  88                                                         std::vector<CVector> *vTgSpace, /* NULL if none */
  89                                                         bool bSkinApplied       )
  90 {
  91         _VBOri = vbOri;
  92         _VBDst = vbDst;
  93         _UseTgSpace = hasTgSpace;
  94
  95         _Vertices = vVertices;
  96         _Normals = vNormals;
  97         _TgSpace = vTgSpace;
  98         _SkinApplied = bSkinApplied;
  99 }
 100
 101 // ***************************************************************************
 102 void CMeshMorpher::update (std::vector<CAnimatedMorph> *pBSFactor)
 103 {
 104         uint32 i, j;
 105
 106         if (_VBOri == NULL)
 107                 return;
 108         if (BlendShapes.empty())
 109                 return;
 110
 111         if (_VBOri->getNumVertices() != _VBDst->getNumVertices())
 112         {       // Because the original vertex buffer is not initialized by default
 113                 // we must init it here (if there are some blendshapes)
 114                 *_VBOri = *_VBDst;
 115         }
 116
 117         // Does the flags are reserved ?
 118         if (_Flags.size() != _VBOri->getNumVertices())
 119         {
 120                 _Flags.resize (_VBOri->getNumVertices());
 121                 for (i = 0; i < _Flags.size(); ++i)
 122                         _Flags[i] = Modified; // Modified to update all
 123         }
 124
 125         nlassert(_VBOri->getVertexFormat() == _VBDst->getVertexFormat());
 126
 127         // Cleaning with original vertex buffer
 128         uint32 VBVertexSize = _VBOri->getVertexSize();
 129         CVertexBufferRead srcvba;
 130         _VBOri->lock (srcvba);
 131         CVertexBufferReadWrite dstvba;
 132         _VBDst->lock (dstvba);
 133         const uint8 *pOri = (const uint8*)srcvba.getVertexCoordPointer ();
 134         uint8 *pDst = (uint8*)dstvba.getVertexCoordPointer ();
 135
 136         for (i= 0; i < _Flags.size(); ++i)
 137         if (_Flags[i] >= Modified)
 138         {
 139                 _Flags[i] = OriginalVBDst;
 140
 141                 for(j = 0; j < VBVertexSize; ++j)
 142                         pDst[j+i*VBVertexSize] = pOri[j+i*VBVertexSize];
 143         }
 144
 145         uint tgSpaceStage = 0;
 146         if (_UseTgSpace)
 147         {
 148                 tgSpaceStage = _VBDst->getNumTexCoordUsed() - 1;
 149         }
 150
 151         // Blending with blendshape
 152         for (i = 0; i < BlendShapes.size(); ++i)
 153         {
 154                 CBlendShape &rBS = BlendShapes[i];
 155                 float rFactor = pBSFactor->operator[](i).getFactor()/100.0f;
 156
 157                 // todo hulud check it works
 158                 // if (rFactor > 0.0f)
 159                 if (rFactor != 0.0f)
 160                 for (j = 0; j < rBS.VertRefs.size(); ++j)
 161                 {
 162                         uint32 vp = rBS.VertRefs[j];
 163
 164                         // Modify Pos/Norm/TgSpace.
 165                         //------------
 166                         if (_VBDst->getVertexFormat() & CVertexBuffer::PositionFlag)
 167                         if (!rBS.deltaPos.empty())
 168                         {
 169                                 CVector *pV = dstvba.getVertexCoordPointer (vp);
 170                                 *pV += rBS.deltaPos[j] * rFactor;
 171                         }
 172
 173                         if (_VBDst->getVertexFormat() & CVertexBuffer::NormalFlag)
 174                         if (!rBS.deltaNorm.empty())
 175                         {
 176                                 CVector *pV = dstvba.getNormalCoordPointer (vp);
 177                                 *pV += rBS.deltaNorm[j] * rFactor;
 178                         }
 179
 180                         if (_UseTgSpace)
 181                         if (!rBS.deltaTgSpace.empty())
 182                         {
 183                                 CVector *pV = (CVector*)dstvba.getTexCoordPointer (vp, tgSpaceStage);
 184                                 *pV += rBS.deltaTgSpace[j] * rFactor;
 185                         }
 186
 187                         // Modify UV0 / Color
 188                         //------------
 189                         if (_VBDst->getVertexFormat() & CVertexBuffer::TexCoord0Flag)
 190                         if (!rBS.deltaUV.empty())
 191                         {
 192                                 CUV *pUV = dstvba.getTexCoordPointer (vp);
 193                                 *pUV += rBS.deltaUV[j] * rFactor;
 194                         }
 195
 196                         if (_VBDst->getVertexFormat() & CVertexBuffer::PrimaryColorFlag)
 197                         if (!rBS.deltaCol.empty())
 198                         {
 199                                 // todo hulud d3d vertex color RGBA / BGRA
 200                                 CRGBA *pRGBA = (CRGBA*)dstvba.getColorPointer (vp);
 201                                 CRGBAF rgbf(*pRGBA);
 202                                 rgbf.R += rBS.deltaCol[j].R * rFactor;
 203                                 rgbf.G += rBS.deltaCol[j].G * rFactor;
 204                                 rgbf.B += rBS.deltaCol[j].B * rFactor;
 205                                 rgbf.A += rBS.deltaCol[j].A * rFactor;
 206                                 clamp(rgbf.R, 0.0f, 1.0f);
 207                                 clamp(rgbf.G, 0.0f, 1.0f);
 208                                 clamp(rgbf.B, 0.0f, 1.0f);
 209                                 clamp(rgbf.A, 0.0f, 1.0f);
 210                                 *pRGBA = rgbf;
 211                         }
 212
 213                         // Modified
 214                         _Flags[vp] = Modified;
 215                 }
 216         }
 217 }
 218
 219
 220 // ***************************************************************************
 221 void CMeshMorpher::updateSkinned (std::vector<CAnimatedMorph> *pBSFactor)
 222 {
 223         uint32 i, j;
 224
 225         if (_VBOri == NULL)
 226                 return;
 227         if (BlendShapes.empty())
 228                 return;
 229
 230         if (_VBOri->getNumVertices() != _VBDst->getNumVertices())
 231         {       // Because the original vertex buffer is not initialized by default
 232                 // we must init it here (if there are some blendshapes)
 233                 *_VBOri = *_VBDst;
 234         }
 235
 236         // Does the flags are reserved ?
 237         if (_Flags.size() != _VBOri->getNumVertices())
 238         {
 239                 _Flags.resize (_VBOri->getNumVertices());
 240                 for (i = 0; i < _Flags.size(); ++i)
 241                         _Flags[i] = Modified; // Modified to update all
 242         }
 243
 244         nlassert(_VBOri->getVertexFormat() == _VBDst->getVertexFormat());
 245
 246         uint tgSpaceStage;
 247         uint tgSpaceOff = 0;
 248         if (_UseTgSpace && _TgSpace)
 249         {
 250                 tgSpaceStage = _VBDst->getNumTexCoordUsed() - 1;
 251                 tgSpaceOff = _VBDst->getTexCoordOff(tgSpaceStage);
 252         }
 253
 254         // Cleaning with original vertex buffer
 255         uint32 VBVertexSize = _VBOri->getVertexSize();
 256         CVertexBufferRead srcvba;
 257         _VBOri->lock (srcvba);
 258         CVertexBufferReadWrite dstvba;
 259         _VBDst->lock (dstvba);
 260         const uint8 *pOri = (const uint8*)srcvba.getVertexCoordPointer ();
 261         uint8 *pDst = (uint8*)dstvba.getVertexCoordPointer ();
 262
 263         for (i= 0; i < _Flags.size(); ++i)
 264         if (_Flags[i] >= Modified)
 265         {
 266                 for(j = 0; j < VBVertexSize; ++j)
 267                         pDst[j+i*VBVertexSize] = pOri[j+i*VBVertexSize];
 268
 269                 if (_Vertices != NULL)
 270                         _Vertices->operator[](i) = ((CVector*)(pOri+i*VBVertexSize))[0];
 271
 272                 if (_Normals != NULL)
 273                         _Normals->operator[](i) = ((CVector*)(pOri+i*VBVertexSize))[1];
 274
 275                 if (_TgSpace != NULL)
 276                         (*_TgSpace)[i] = * (CVector*)(pOri + i * VBVertexSize + tgSpaceOff);
 277
 278                 _Flags[i] = OriginalVBDst;
 279         }
 280
 281         // Blending with blendshape
 282         for (i = 0; i < BlendShapes.size(); ++i)
 283         {
 284                 CBlendShape &rBS = BlendShapes[i];
 285                 float rFactor = pBSFactor->operator[](i).getFactor()/100.0f;
 286
 287                 if (rFactor != 0.0f)
 288                 for (j = 0; j < rBS.VertRefs.size(); ++j)
 289                 {
 290                         uint32 vp = rBS.VertRefs[j];
 291
 292                         // Modify Pos/Norm/TgSpace.
 293                         //------------
 294                         if (_Vertices != NULL)
 295                         if (!rBS.deltaPos.empty())
 296                         {
 297                                 CVector *pV = &(_Vertices->operator[](vp));
 298                                 *pV += rBS.deltaPos[j] * rFactor;
 299                         }
 300
 301                         if (_Normals != NULL)
 302                         if (!rBS.deltaNorm.empty())
 303                         {
 304                                 CVector *pV = &(_Normals->operator[](vp));
 305                                 *pV += rBS.deltaNorm[j] * rFactor;
 306                         }
 307
 308                         if (_UseTgSpace && _TgSpace != NULL)
 309                         if (!rBS.deltaTgSpace.empty())
 310                         {
 311                                 CVector *pV = &((*_TgSpace)[vp]);
 312                                 *pV += rBS.deltaTgSpace[j] * rFactor;
 313                         }
 314
 315                         // Modify UV0 / Color
 316                         //------------
 317                         if (_VBDst->getVertexFormat() & CVertexBuffer::TexCoord0Flag)
 318                         if (!rBS.deltaUV.empty())
 319                         {
 320                                 CUV *pUV = dstvba.getTexCoordPointer (vp);
 321                                 *pUV += rBS.deltaUV[j] * rFactor;
 322                         }
 323
 324                         if (_VBDst->getVertexFormat() & CVertexBuffer::PrimaryColorFlag)
 325                         if (!rBS.deltaCol.empty())
 326                         {
 327                                 // todo hulud d3d vertex color RGBA / BGRA
 328                                 CRGBA *pRGBA = (CRGBA*)dstvba.getColorPointer (vp);
 329                                 CRGBAF rgbf(*pRGBA);
 330                                 rgbf.R += rBS.deltaCol[j].R * rFactor;
 331                                 rgbf.G += rBS.deltaCol[j].G * rFactor;
 332                                 rgbf.B += rBS.deltaCol[j].B * rFactor;
 333                                 rgbf.A += rBS.deltaCol[j].A * rFactor;
 334                                 clamp(rgbf.R, 0.0f, 1.0f);
 335                                 clamp(rgbf.G, 0.0f, 1.0f);
 336                                 clamp(rgbf.B, 0.0f, 1.0f);
 337                                 clamp(rgbf.A, 0.0f, 1.0f);
 338                                 *pRGBA = rgbf;
 339                         }
 340
 341                         // Modified
 342                         _Flags[vp] = Modified;
 343                 }
 344         }
 345 }
 346
 347 // ***************************************************************************
 348 void CMeshMorpher::serial (NLMISC::IStream &f)
 349 {
 350         /* ***********************************************
 351          *      WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
 352          *      It can be loaded/called through CAsyncFileManager for instance
 353          * ***********************************************/
 354
 355         (void)f.serialVersion (0);
 356
 357         f.serialCont (BlendShapes);
 358 }
 359
 360
 361 // ***************************************************************************
 362 #define NL3D_RAWSKIN_NORMAL_OFF         12
 363 #define NL3D_RAWSKIN_UV_OFF                     24
 364 #define NL3D_RAWSKIN_VERTEX_SIZE        32
 365
 366 void CMeshMorpher::updateRawSkin (CVertexBuffer *vbOri,
 367                                         NLMISC::CObjectVector<CRawSkinVertex*, false>   &vertexRemap,
 368                                         std::vector<CAnimatedMorph> *pBSFactor)
 369 {
 370         uint32 i, j;
 371
 372         if (vbOri == NULL)
 373                 return;
 374         if (BlendShapes.empty())
 375                 return;
 376
 377         nlassert(vbOri->getVertexFormat() == (CVertexBuffer::PositionFlag | CVertexBuffer::NormalFlag |CVertexBuffer::TexCoord0Flag) );
 378         nlassert(NL3D_RAWSKIN_VERTEX_SIZE == vbOri->getVertexSize());
 379         nlassert(NL3D_RAWSKIN_NORMAL_OFF == vbOri->getNormalOff());
 380         nlassert(NL3D_RAWSKIN_UV_OFF == vbOri->getTexCoordOff(0));
 381
 382         // Cleaning with original vertex buffer
 383         CVertexBufferRead srcvba;
 384         vbOri->lock (srcvba);
 385         const uint8                     *pOri = (const uint8*)srcvba.getVertexCoordPointer ();
 386         CRawSkinVertex  **vRemap= vertexRemap.getPtr();
 387         uint                    numVertices= vbOri->getNumVertices();
 388
 389         // Update only the vertices of this lod
 390         for (i= 0; i < numVertices; ++i)
 391         {
 392                 if(*vRemap)
 393                 {
 394                         (*vRemap)->Pos= *(CVector*)(pOri);
 395                         (*vRemap)->Normal= *(CVector*)(pOri + NL3D_RAWSKIN_NORMAL_OFF);
 396                         (*vRemap)->UV= *(CUV*)(pOri + NL3D_RAWSKIN_UV_OFF);
 397                 }
 398                 pOri+= NL3D_RAWSKIN_VERTEX_SIZE;
 399                 vRemap++;
 400         }
 401
 402         // Blending with blendshape
 403         for (i = 0; i < BlendShapes.size(); ++i)
 404         {
 405                 CBlendShape             &rBS = BlendShapes[i];
 406                 float                   rFactor = pBSFactor->operator[](i).getFactor();
 407
 408                 if (rFactor != 0.0f)
 409                 {
 410                         rFactor*= 0.01f;
 411                         uint32          numVertices= (uint32)rBS.VertRefs.size();
 412                         // don't know why, but cases happen where deltaNorm not empty while deltaPos is
 413                         bool            hasPos = !rBS.deltaPos.empty();
 414                         bool            hasNorm = !rBS.deltaNorm.empty();
 415                         bool            hasUV = !rBS.deltaUV.empty();
 416
 417                         for (j = 0; j < numVertices; ++j)
 418                         {
 419                                 // Get the vertex Index in the VBufferFinal
 420                                 uint    vid= rBS.VertRefs[j];
 421                                 // Then get the RawSkin vertex to modify
 422                                 CRawSkinVertex  *rsVert= vertexRemap[vid];
 423
 424                                 // If exist in this Lod RawSkin, apply
 425                                 if(rsVert)
 426                                 {
 427                                         if(hasPos)
 428                                                 rsVert->Pos+= rBS.deltaPos[j] * rFactor;
 429                                         if(hasNorm)
 430                                                 rsVert->Normal+= rBS.deltaNorm[j] * rFactor;
 431                                         if(hasUV)
 432                                                 rsVert->UV+= rBS.deltaUV[j] * rFactor;
 433                                 }
 434                         }
 435                 }
 436
 437         }
 438
 439 }
 440
 441
 442 } // NL3D
 443
 444
 445
 446
 447
 448
 449
 450
 451
 452