?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix game:addSpawnShapesByZone
[ryzomcore.git] / nel / tools / 3d / build_shadow_skin / main.cpp
blob4992ca19d72f19f55b2b334c172994c135cb4e7b
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 }