nel/tools/3d/build_shadow_skin/main.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 "nel/misc/path.h"
  18 #include "nel/3d/mesh_mrm_skinned.h"
  19 #include "nel/3d/mesh_mrm.h"
  20 #include "nel/3d/mesh.h"
  21 #include "nel/misc/file.h"
  22 #include "nel/misc/path.h"
  23 #include "nel/3d/stripifier.h"
  24 #include "nel/3d/register_3d.h"
  25
  26
  27 using namespace NLMISC;
  28 using namespace NL3D;
  29 using namespace std;
  30
  31
  32 // ***************************************************************************
  33
  34 const CIndexBuffer *getRdrPassPrimitiveBlock(const CMeshMRMGeom *mesh, uint lodId, uint renderPass)
  35 {
  36         return &(mesh->getRdrPassPrimitiveBlock(lodId, renderPass));
  37 }
  38
  39 // ***************************************************************************
  40
  41 const CIndexBuffer *getRdrPassPrimitiveBlock(const CMeshMRMSkinnedGeom *mesh, uint lodId, uint renderPass)
  42 {
  43         static CIndexBuffer block;
  44         mesh->getRdrPassPrimitiveBlock(lodId, renderPass, block);
  45         return &block;
  46 }
  47
  48 // ***************************************************************************
  49
  50 template<class T>
  51 void            addShadowMesh(T *meshIn, float paramFaceRatio, sint paramMaxFace, const std::vector<CMesh::CSkinWeight> &skinWeights, const CVertexBuffer &vertexBuffer)
  52 {
  53         CVertexBufferRead vba;
  54         vertexBuffer.lock (vba);
  55         uint    i, j;
  56
  57         // **** Select the Lod.
  58         uint    numLods= meshIn->getNbLod();
  59
  60         // get the max tris displayed
  61         float   numMeshFacesMin= (float)meshIn->getLevelDetail().MinFaceUsed;
  62         float   numMeshFacesMax= (float)meshIn->getLevelDetail().MaxFaceUsed;
  63         float   maxFaceWanted= numMeshFacesMax * paramFaceRatio;
  64         // minimize with maxFace param
  65         maxFaceWanted= min(maxFaceWanted, (float)paramMaxFace);
  66         // find the lod
  67         float   fLod= ( (maxFaceWanted-numMeshFacesMin) / (numMeshFacesMax-numMeshFacesMin) )*(numLods-1);
  68         // round the lod wanted.
  69         sint lodId= (sint)floor(0.5f + fLod);
  70         clamp(lodId, 0, (sint)numLods-1);
  71
  72
  73         // **** First, for the best lod indicate what vertex is used or not. Also index geomorphs to know what real vertex is used
  74         vector<sint>            vertexUsed;
  75         // -1 means "not used"
  76         vertexUsed.resize(skinWeights.size(), -1);
  77         // Parse all triangles.
  78         for(i=0;i<meshIn->getNbRdrPass(lodId);i++)
  79         {
  80                 const CIndexBuffer *pb = getRdrPassPrimitiveBlock(meshIn, lodId, i);
  81                 CIndexBufferRead iba;
  82                 pb->lock (iba);
  83                 if (iba.getFormat() == CIndexBuffer::Indices32)
  84                 {
  85                         const uint32    *triPtr= (const uint32 *) iba.getPtr();
  86                         for(j=0;j<pb->getNumIndexes();j++)
  87                         {
  88                                 uint    idx= *triPtr;
  89                                 // Flag the vertex with its own index => used.
  90                                 vertexUsed[idx]= idx;
  91                                 triPtr++;
  92                         }
  93                 }
  94                 else
  95                 {
  96                         const uint16    *triPtr= (const uint16 *) iba.getPtr();
  97                         for(j=0;j<pb->getNumIndexes();j++)
  98                         {
  99                                 uint    idx= *triPtr;
 100                                 // Flag the vertex with its own index => used.
 101                                 vertexUsed[idx]= idx;
 102                                 triPtr++;
 103                         }
 104                 }
 105         }
 106         // Special for Geomorphs: must take The End target vertex.
 107         const std::vector<CMRMWedgeGeom>        &geomorphs= meshIn->getGeomorphs(lodId);
 108         for(i=0;i<geomorphs.size();i++)
 109         {
 110                 uint    trueIdx= geomorphs[i].End;
 111                 // map to the Geomorph Target.
 112                 vertexUsed[i]= trueIdx;
 113                 // mark also the real vertex used as used.
 114                 vertexUsed[trueIdx]= trueIdx;
 115         }
 116
 117
 118         // **** For all vertices used (not geomorphs), compute vertex Skins.
 119         vector<CShadowVertex>           shadowVertices;
 120         vector<sint>                            vertexToVSkin;
 121         vertexToVSkin.resize(vertexUsed.size());
 122         shadowVertices.reserve(vertexUsed.size());
 123         // use a map to remove duplicates (because of UV/normal discontinuities before!!)
 124         map<CShadowVertex, uint>        shadowVertexMap;
 125         uint                                            numMerged= 0;
 126         // Skip Geomorphs.
 127         for(i=(uint)geomorphs.size();i<vertexUsed.size();i++)
 128         {
 129                 // If this vertex is used.
 130                 if(vertexUsed[i]!=-1)
 131                 {
 132                         // Build the vertex
 133                         CShadowVertex   shadowVert;
 134                         shadowVert.Vertex= *(CVector*)vba.getVertexCoordPointer(i);
 135                         // Select the best Matrix.
 136                         CMesh::CSkinWeight              sw= skinWeights[i];
 137                         float   maxW= 0;
 138                         uint    matId= 0;
 139                         for(j=0;j<NL3D_MESH_SKINNING_MAX_MATRIX;j++)
 140                         {
 141                                 // if no more matrix influenced, stop
 142                                 if(sw.Weights[j]==0)
 143                                         break;
 144                                 if(sw.Weights[j]>maxW)
 145                                 {
 146                                         matId= sw.MatrixId[j];
 147                                         maxW= sw.Weights[j];
 148                                 }
 149                         }
 150                         shadowVert.MatrixId= matId;
 151
 152                         // If dont find the shadowVertex in the map.
 153                         map<CShadowVertex, uint>::iterator              it= shadowVertexMap.find(shadowVert);
 154                         if(it==shadowVertexMap.end())
 155                         {
 156                                 // Append
 157                                 uint    index= (uint)shadowVertices.size();
 158                                 vertexToVSkin[i]= index;
 159                                 shadowVertices.push_back(shadowVert);
 160                                 shadowVertexMap.insert(make_pair(shadowVert, index));
 161                         }
 162                         else
 163                         {
 164                                 // Ok, map.
 165                                 vertexToVSkin[i]= it->second;
 166                                 numMerged++;
 167                         }
 168                 }
 169         }
 170
 171         // Some Info on what have been merged.
 172         if(shadowVertices.size())
 173         {
 174                 // TestYoyo.
 175                 /*nlinfo("%d Vertices have been merged. => %d %%", numMerged,
 176                         100*numMerged / (numMerged+shadowVertices.size()));*/
 177         }
 178
 179
 180         // **** Get All Faces
 181         // Final List Of Triangles that match the bone.
 182         vector<uint32>                  shadowTriangles;
 183         shadowTriangles.reserve(1000);
 184         // Parse all input tri of the mesh.
 185         for(i=0;i<meshIn->getNbRdrPass(lodId);i++)
 186         {
 187                 const CIndexBuffer *pb = getRdrPassPrimitiveBlock(meshIn, lodId, i);
 188                 CIndexBufferRead iba;
 189                 pb->lock (iba);
 190                 if (iba.getFormat() == CIndexBuffer::Indices32)
 191                 {
 192                         const uint32    *triPtr= (const uint32 *) iba.getPtr();
 193                         for(j=0;j<pb->getNumIndexes();j++)
 194                         {
 195                                 uint    idx= *triPtr;
 196                                 // Get the real Vertex (ie not the geomporhed one).
 197                                 idx= vertexUsed[idx];
 198                                 // Get the ShadowVertex associated
 199                                 idx= vertexToVSkin[idx];
 200
 201                                 shadowTriangles.push_back(idx);
 202                                 triPtr++;
 203                         }
 204                 }
 205                 else
 206                 {
 207                         const uint16    *triPtr= (const uint16 *) iba.getPtr();
 208                         for(j=0;j<pb->getNumIndexes();j++)
 209                         {
 210                                 uint    idx= *triPtr;
 211                                 // Get the real Vertex (ie not the geomporhed one).
 212                                 idx= vertexUsed[idx];
 213                                 // Get the ShadowVertex associated
 214                                 idx= vertexToVSkin[idx];
 215
 216                                 shadowTriangles.push_back(idx);
 217                                 triPtr++;
 218                         }
 219                 }
 220         }
 221
 222         // Re-Optim VertexCache Hard usage
 223         if(shadowTriangles.size())
 224         {
 225                 CIndexBuffer            pb;
 226                 // fill
 227                 pb.setNumIndexes((uint32)shadowTriangles.size());
 228                 {
 229                         CIndexBufferReadWrite iba;
 230                         pb.lock (iba);
 231                         for(i=0;i<shadowTriangles.size()/3;i++)
 232                         {
 233                                 iba.setTri(i*3, shadowTriangles[i*3 + 0],
 234                                                          shadowTriangles[i*3 + 1],
 235                                                          shadowTriangles[i*3 + 2]);
 236                         }
 237                 }
 238                 // optimize
 239                 CStripifier             stripifier;
 240                 stripifier.optimizeTriangles(pb, pb);
 241                 // get.
 242                 {
 243                         CIndexBufferReadWrite iba;
 244                         pb.lock (iba);
 245                         if (iba.getFormat() == CIndexBuffer::Indices32)
 246                         {
 247                                 const uint32    *triPtr= (const uint32 *) iba.getPtr();
 248                                 for(i=0;i<shadowTriangles.size();i++)
 249                                 {
 250                                         shadowTriangles[i]= *triPtr;
 251                                         triPtr++;
 252                                 }
 253                         }
 254                         else
 255                         {
 256                                 const uint16    *triPtr= (const uint16 *) iba.getPtr();
 257                                 for(i=0;i<shadowTriangles.size();i++)
 258                                 {
 259                                         shadowTriangles[i]= *triPtr;
 260                                         triPtr++;
 261                                 }
 262                         }
 263                 }
 264         }
 265
 266         // set
 267         meshIn->setShadowMesh(shadowVertices, shadowTriangles);
 268 }
 269
 270 // ***************************************************************************
 271
 272 void            addShadowMeshIntro(CMeshMRMGeom *meshIn, float paramFaceRatio, sint paramMaxFace)
 273 {
 274         const std::vector<CMesh::CSkinWeight>   &skinWeights= meshIn->getSkinWeights();
 275         const CVertexBuffer                                             &vertexBuffer= meshIn->getVertexBuffer();
 276         addShadowMesh (meshIn, paramFaceRatio, paramMaxFace, skinWeights, vertexBuffer);
 277 }
 278
 279 // ***************************************************************************
 280
 281 void            addShadowMeshIntro(CMeshMRMSkinnedGeom *meshIn, float paramFaceRatio, sint paramMaxFace)
 282 {
 283         std::vector<CMesh::CSkinWeight> skinWeights;
 284         meshIn->getSkinWeights(skinWeights);
 285         CVertexBuffer vertexBuffer;
 286         meshIn->getVertexBuffer(vertexBuffer);
 287         addShadowMesh (meshIn, paramFaceRatio, paramMaxFace, skinWeights, vertexBuffer);
 288 }
 289
 290 // ***************************************************************************
 291
 292 int             main(int argc, char *argv[])
 293 {
 294         // Filter addSearchPath
 295         NLMISC::createDebug();
 296         NLMISC::InfoLog->addNegativeFilter ("adding the path");
 297
 298         NL3D::registerSerial3d();
 299
 300         if (argc <3 )
 301         {
 302                 string  execName= CFile::getFilename(argv[0]);
 303                 printf("%s add a ShadowSkin to a Skinned MRM Mesh\n", execName.c_str());
 304                 printf("   usage: %s shape_in shape_out [facePercentage] [maxFaces] \n", execName.c_str());
 305                 printf("   NB: shape_in and shape_out can be same file\n");
 306                 printf("   NB: facePercentage is a number between 0 and 100. It computes the maxFaces for the shadow according to the input Mesh.\n");
 307                 printf("   NB: maxFaces can be given manually. The min of the 2 parameters is taken.\n");
 308                 exit(-1);
 309         }
 310
 311         // Parse args.
 312         string  shapeNameIn= argv[1];
 313         string  shapeNameOut= argv[2];
 314         sint    percentageFace= 100;
 315         sint    maxFace= INT_MAX;
 316         if(argc>=4)
 317                 NLMISC::fromString(argv[3], percentageFace);
 318         if(argc>=5)
 319                 NLMISC::fromString(argv[4], maxFace);
 320
 321         // **** Load the Mesh In.
 322         IShape *pResult = NULL;
 323         CMeshMRM        *pMesh;
 324         CShapeStream    shapeStreamIn;
 325         CIFile          shapeFileIn;
 326         if(!shapeFileIn.open(shapeNameIn))
 327         {
 328                 nlwarning("ERROR: cannot open input file: %s", shapeNameIn.c_str());
 329                 exit(-1);
 330         }
 331         shapeStreamIn.serial(shapeFileIn);
 332         pMesh= dynamic_cast<CMeshMRM*>(shapeStreamIn.getShapePointer());
 333         shapeFileIn.close();
 334         if(!pMesh)
 335         {
 336                 CMeshMRMSkinned *pMeshSkinned= dynamic_cast<CMeshMRMSkinned*>(shapeStreamIn.getShapePointer());
 337                 if(!pMeshSkinned)
 338                 {
 339                         nlwarning("ERROR: Not a MRM Mesh nor a MRM Mesh skinned: %s", shapeNameIn.c_str());
 340                         exit(-1);
 341                 }
 342
 343                 CMeshMRMSkinnedGeom     *pMeshGeom= (CMeshMRMSkinnedGeom*)&pMeshSkinned->getMeshGeom();
 344
 345                 // **** Add Shadow mesh.
 346                 float   faceRatio;
 347                 clamp(percentageFace, 0, 100);
 348                 faceRatio= (float)percentageFace/100;
 349                 maxFace= max(0, maxFace);
 350                 addShadowMeshIntro(pMeshGeom, faceRatio, maxFace);
 351                 pResult = pMeshSkinned;
 352         }
 353         else
 354         {
 355                 CMeshMRMGeom    *pMeshGeom= (CMeshMRMGeom*)&pMesh->getMeshGeom();
 356                 if( !pMeshGeom->isSkinned() )
 357                 {
 358                         nlwarning("ERROR: Not a Skinned MRM Mesh: %s", shapeNameIn.c_str());
 359                         exit(-1);
 360                 }
 361
 362                 // **** Add Shadow mesh.
 363                 float   faceRatio;
 364                 clamp(percentageFace, 0, 100);
 365                 faceRatio= (float)percentageFace/100;
 366                 maxFace= max(0, maxFace);
 367                 addShadowMeshIntro(pMeshGeom, faceRatio, maxFace);
 368                 pResult = pMesh;
 369         }
 370
 371         // **** Save It
 372         CShapeStream    shapeStreamOut;
 373         COFile          shapeFileOut;
 374         if(!shapeFileOut.open(shapeNameOut) )
 375         {
 376                 nlwarning("ERROR: cannot open output file: %s", shapeNameOut.c_str());
 377                 exit(-1);
 378         }
 379
 380         nlassert (pResult);
 381         shapeStreamOut.setShapePointer(pResult);
 382         shapeStreamOut.serial(shapeFileOut);
 383         shapeFileOut.close();
 384
 385         return 0;
 386 }