khanat-code-old/code/nel/tools/3d/build_clodtex/lod_texture_builder.cpp
2017-03-15 20:43:10 +01:00

419 lines
13 KiB
C++

// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "lod_texture_builder.h"
#include "nel/misc/aabbox.h"
using namespace std;
using namespace NLMISC;
using namespace NL3D;
// ***************************************************************************
// Quality factor. Useful to get maximum of interseting values in the range 0..255.
#define NL_LTB_MAX_DISTANCE_QUALITY_FACTOR 0.05f
// The bigger, the lower the influence of the normal is. must be >=0
#define NL_LTB_NORMAL_BIAS 1.f
// ***************************************************************************
CLodTextureBuilder::CLodTextureBuilder()
{
_OverSampleDistance= 0.05f;
}
// ***************************************************************************
float CLodTextureBuilder::computeQualityPixel(const CPixelInfo &p0, const CPixelInfo &p1) const
{
float d= (p1.Pos-p0.Pos).norm();
float dotProd= p1.Normal*p0.Normal;
// With NL_NORMAL_BIAS==1, it return froms d*1(normals aligned) to d*3 (opposite normals)
return d*(NL_LTB_NORMAL_BIAS+1-dotProd);
}
// ***************************************************************************
void CLodTextureBuilder::setLod(const NL3D::CLodCharacterShapeBuild &lod)
{
uint i;
_CLod= lod;
// **** compute the max quality distance. ie where CTUVQ.Q== 255
// build a bbox around the lod.
CAABBox bbox;
bbox.setCenter(lod.Vertices[0]);
for(i=0;i<lod.Vertices.size();i++)
bbox.extend(lod.Vertices[i]);
/* get the opposite vertices/normals and so compute the max qualityPixel "possible" (it is still possible
for the CMesh to be completely out of the bbox of the CLod, but doesn't matter)
*/
CPixelInfo p0, p1;
p0.Pos= bbox.getMin();
p0.Normal.set(1,0,0);
p1.Pos= bbox.getMax();
p1.Normal.set(-1,0,0);
_MaxDistanceQuality= computeQualityPixel(p0, p1);
// apply a user factor.
_MaxDistanceQuality*= NL_LTB_MAX_DISTANCE_QUALITY_FACTOR;
}
// ***************************************************************************
bool CLodTextureBuilder::computeTexture(const CMesh &mesh, NL3D::CLodCharacterTexture &text)
{
// a set to flag if an edge has already been overSampled
TEdgeSet edgeSet;
// **** Over sample the mesh
_Samples.clear();
_Samples.reserve(1000);
// Get vertex info
const CVertexBuffer &VB= mesh.getVertexBuffer();
CVertexBufferRead vba;
VB.lock (vba);
const uint8 *srcPos= (const uint8*)vba.getVertexCoordPointer();
const uint8 *srcNormal= (const uint8*)vba.getNormalCoordPointer();
const uint8 *srcUV= (const uint8*)vba.getTexCoordPointer();
uint vertexSize= VB.getVertexSize();
// For all matrix blocks..
for(uint mb=0; mb<mesh.getNbMatrixBlock();mb++)
{
// for all rdrPass
for(uint rp=0; rp<mesh.getNbRdrPass(mb);rp++)
{
const CIndexBuffer &pb= mesh.getRdrPassPrimitiveBlock(mb, rp);
CIndexBufferRead iba;
pb.lock (iba);
uint matId= mesh.getRdrPassMaterial(mb, rp);
// samples the tris of this pass
if (iba.getFormat() == CIndexBuffer::Indices16)
{
addSampleTris(srcPos, srcNormal, srcUV, vertexSize, (uint16 *) iba.getPtr(), pb.getNumIndexes()/3, matId, edgeSet);
}
else
{
nlassert(iba.getFormat() == CIndexBuffer::Indices32);
addSampleTris(srcPos, srcNormal, srcUV, vertexSize, (uint32 *) iba.getPtr(), pb.getNumIndexes()/3, matId, edgeSet);
}
}
}
// **** compute the texture, with the samples
computeTextureFromSamples(text);
return true;
}
// ***************************************************************************
bool CLodTextureBuilder::computeTexture(const CMeshMRM &meshMRM, NL3D::CLodCharacterTexture &text)
{
// a set to flag if an edge has already been overSampled
TEdgeSet edgeSet;
// **** Over sample the mesh
_Samples.clear();
_Samples.reserve(1000);
// Get vertex info
CVertexBuffer &VB= const_cast<CVertexBuffer&>(meshMRM.getVertexBuffer());
CVertexBufferRead vba;
VB.lock (vba);
const uint8 *srcPos= (const uint8*)vba.getVertexCoordPointer();
const uint8 *srcNormal= (const uint8*)vba.getNormalCoordPointer();
const uint8 *srcUV= (const uint8*)vba.getTexCoordPointer();
uint vertexSize = VB.getVertexSize();
// For the more precise lod
uint lodId= meshMRM.getNbLod()-1;
// Resolve Geomoprh problem: copy End to all geomorphs dest. Hence sure that all ids points to good vertex data
const std::vector<CMRMWedgeGeom> &geoms= meshMRM.getMeshGeom().getGeomorphs(lodId);
for(uint gm=0;gm<geoms.size();gm++)
{
uint srcId= geoms[gm].End;
// copy the geom src to the dest VB place.
*(CVector*)(srcPos+gm*vertexSize)= *(CVector*)(srcPos+srcId*vertexSize);
*(CVector*)(srcNormal+gm*vertexSize)= *(CVector*)(srcNormal+srcId*vertexSize);
*(CUV*)(srcUV+gm*vertexSize)= *(CUV*)(srcUV+srcId*vertexSize);
}
// for all rdrPass
for(uint rp=0; rp<meshMRM.getNbRdrPass(lodId);rp++)
{
const CIndexBuffer &pb= meshMRM.getRdrPassPrimitiveBlock(lodId, rp);
CIndexBufferRead iba;
pb.lock (iba);
uint matId= meshMRM.getRdrPassMaterial(lodId, rp);
// samples the tris of this pass
if (iba.getFormat() == CIndexBuffer::Indices16)
{
addSampleTris(srcPos, srcNormal, srcUV, vertexSize, (uint16 *) iba.getPtr(), pb.getNumIndexes()/3, matId, edgeSet);
}
else
{
nlassert(iba.getFormat() == CIndexBuffer::Indices32);
addSampleTris(srcPos, srcNormal, srcUV, vertexSize, (uint32 *) iba.getPtr(), pb.getNumIndexes()/3, matId, edgeSet);
}
}
// **** compute the texture, with the samples
computeTextureFromSamples(text);
return true;
}
// ***************************************************************************
bool CLodTextureBuilder::computeTexture(const CMeshMRMSkinned &meshMRM, NL3D::CLodCharacterTexture &text)
{
// a set to flag if an edge has already been overSampled
TEdgeSet edgeSet;
// **** Over sample the mesh
_Samples.clear();
_Samples.reserve(1000);
// Get vertex info
CVertexBuffer tmp;
meshMRM.getVertexBuffer(tmp);
CVertexBufferRead vba;
tmp.lock (vba);
const uint8 *srcPos= (const uint8*)vba.getVertexCoordPointer();
const uint8 *srcNormal= (const uint8*)vba.getNormalCoordPointer();
const uint8 *srcUV= (const uint8*)vba.getTexCoordPointer();
uint vertexSize= tmp.getVertexSize();
// For the more precise lod
uint lodId= meshMRM.getNbLod()-1;
// Resolve Geomoprh problem: copy End to all geomorphs dest. Hence sure that all ids points to good vertex data
const std::vector<CMRMWedgeGeom> &geoms= meshMRM.getMeshGeom().getGeomorphs(lodId);
for(uint gm=0;gm<geoms.size();gm++)
{
uint srcId= geoms[gm].End;
// copy the geom src to the dest VB place.
*(CVector*)(srcPos+gm*vertexSize)= *(CVector*)(srcPos+srcId*vertexSize);
*(CVector*)(srcNormal+gm*vertexSize)= *(CVector*)(srcNormal+srcId*vertexSize);
*(CUV*)(srcUV+gm*vertexSize)= *(CUV*)(srcUV+srcId*vertexSize);
}
// for all rdrPass
for(uint rp=0; rp<meshMRM.getNbRdrPass(lodId);rp++)
{
CIndexBuffer pb;
meshMRM.getRdrPassPrimitiveBlock(lodId, rp, pb);
uint matId= meshMRM.getRdrPassMaterial(lodId, rp);
CIndexBufferRead iba;
pb.lock (iba);
// samples the tris of this pass
if (iba.getFormat() == CIndexBuffer::Indices16)
{
addSampleTris(srcPos, srcNormal, srcUV, vertexSize, (uint16 *) iba.getPtr(), pb.getNumIndexes()/3, matId, edgeSet);
}
else
{
addSampleTris(srcPos, srcNormal, srcUV, vertexSize, (uint32 *) iba.getPtr(), pb.getNumIndexes()/3, matId, edgeSet);
}
}
// **** compute the texture, with the samples
computeTextureFromSamples(text);
return true;
}
// ***************************************************************************
void CLodTextureBuilder::addSampleTris(const uint8 *srcPos, const uint8 *srcNormal, const uint8 *srcUV, uint vertexSize,
const uint16 *triPointer, uint numTris, uint materialId, TEdgeSet &edgeSet)
{
std::vector<uint32> indices32(triPointer, triPointer + numTris * 3);
addSampleTris(srcPos, srcNormal, srcUV, vertexSize, &indices32[0], numTris, materialId, edgeSet);
}
// ***************************************************************************
void CLodTextureBuilder::addSampleTris(const uint8 *srcPos, const uint8 *srcNormal, const uint8 *srcUV, uint vertexSize,
const uint32 *triPointer, uint numTris, uint materialId, TEdgeSet &edgeSet)
{
nlassert(srcPos);
// ensure that the material is in 0..255
clamp(materialId, 0U, 255U);
for(uint i=0;i<numTris;i++)
{
uint c;
// **** get tri indices and tri values.
uint idx[3];
CVector pos[3];
CVector normal[3];
CUV uv[3];
for(c=0;c<3;c++)
{
idx[c]= *triPointer++;
pos[c]= *(CVector*)(srcPos + idx[c]*vertexSize);
if(srcNormal)
normal[c]= *(CVector*)(srcNormal + idx[c]*vertexSize);
else
normal[c]= CVector::K;
if(srcUV)
uv[c]= *(CUV*)(srcUV + idx[c]*vertexSize);
else
uv[c].set(0,0);
}
// **** Append the 3 vertices in the samples. only if not already done
for(c=0;c<3;c++)
{
// special edgeId: vertStart==vertEnd
TEdge edgeId;
edgeId.first= idx[c];
edgeId.second= idx[c];
// if success to insert in the set, then must add it to samples
if(edgeSet.insert(edgeId).second)
{
CSample sample;
sample.P.Pos= pos[c];
sample.P.Normal= normal[c];
sample.P.Normal.normalize();
sample.UV= uv[c];
sample.MaterialId= materialId;
_Samples.push_back(sample);
}
}
// **** Append the interior of each edges, according to _OverSampleDistance
uint numEdgeOverSamples[3];
for(c=0;c<3;c++)
{
uint cNext= (c+1)%3;
// get the edgeId
TEdge edgeId;
edgeId.first= idx[c];
edgeId.second= idx[cNext];
// compute the number of overSamples to apply to the edge
numEdgeOverSamples[c]= (uint)floor( (pos[cNext]-pos[c]).norm()/_OverSampleDistance );
// if success to insert in the set, then must add it to samples
if(edgeSet.insert(edgeId).second)
{
// Do it only if numOverSamples>=2
if(numEdgeOverSamples[c]>=2)
{
// Sample the edge, exclude endPoints.
for(uint s=1;s<numEdgeOverSamples[c];s++)
{
float f= s/(float)numEdgeOverSamples[c];
// interpoalte the sample
CSample sample;
sample.P.Pos= pos[c]*(1-f) + pos[cNext]*f;
sample.P.Normal= normal[c]*(1-f) + normal[cNext]*f;
sample.P.Normal.normalize();
sample.UV= uv[c]*(1-f) + uv[cNext]*f;
sample.MaterialId= materialId;
// add it
_Samples.push_back(sample);
}
}
}
}
// **** Append the interior of the triangle, if too many overSample
// compute min of over samples
uint triOverSample= min(numEdgeOverSamples[0], numEdgeOverSamples[1]);
triOverSample= min(triOverSample, numEdgeOverSamples[2]);
// If >=3 (at least one vertex in the middle)
if(triOverSample>=2)
{
// Interpolate with barycentric coordinate rules
uint s,t,v;
// Donc't compute on triangles edges.
for(s=1;s<triOverSample;s++)
{
for(t=1;t<triOverSample-s;t++)
{
// barycentric sum==1 guaranteed.
v= triOverSample-s-t;
float fs= s/(float)triOverSample;
float ft= t/(float)triOverSample;
float fv= v/(float)triOverSample;
// compute the sample
CSample sample;
sample.P.Pos= pos[0]*fs + pos[1]*ft + pos[2]*fv;
sample.P.Normal= normal[0]*fs + normal[1]*ft + normal[2]*fv;
sample.P.Normal.normalize();
sample.UV= uv[0]*fs + uv[1]*ft + uv[2]*fv;
sample.MaterialId= materialId;
// add it
_Samples.push_back(sample);
}
}
}
}
}
// ***************************************************************************
bool CLodTextureBuilder::computeTextureFromSamples(NL3D::CLodCharacterTexture &text)
{
// The lod must have correct width/height
if(NL3D_CLOD_TEXT_WIDTH!=_CLod.getTextureInfoWidth() || NL3D_CLOD_TEXT_HEIGHT!=_CLod.getTextureInfoHeight() )
{
nlwarning("ERROR: the _CLod must have a textureInfo size of %d/%d", NL3D_CLOD_TEXT_WIDTH, NL3D_CLOD_TEXT_HEIGHT);
return false;
}
// prepare dest.
text.Texture.resize(NL3D_CLOD_TEXT_SIZE);
CLodCharacterTexture::CTUVQ emptyTUVQ;
emptyTUVQ.T= 0;
emptyTUVQ.U= 0;
emptyTUVQ.V= 0;
emptyTUVQ.Q= 255;
fill(text.Texture.begin(), text.Texture.end(), emptyTUVQ);
// For all pixels.
const CPixelInfo *srcPixel= _CLod.getTextureInfoPtr();
for(uint i=0;i<NL3D_CLOD_TEXT_SIZE;i++)
{
// if the src pixel is not empty
if( !(srcPixel[i]==CPixelInfo::EmptyPixel) )
{
CLodCharacterTexture::CTUVQ &dstTUVQ= text.Texture[i];
// For All samples, search the best.
float minQuality= FLT_MAX;
uint bestIdx= 0;
for(uint j=0;j<_Samples.size();j++)
{
float q= computeQualityPixel(srcPixel[i], _Samples[j].P);
if(q<minQuality)
{
minQuality= q;
bestIdx= j;
}
}
// Then compress the sample info in the TUVQ.
dstTUVQ.T= _Samples[bestIdx].MaterialId;
dstTUVQ.U= (uint8)(sint)(_Samples[bestIdx].UV.U*256);
dstTUVQ.V= (uint8)(sint)(_Samples[bestIdx].UV.V*256);
minQuality= minQuality*255/_MaxDistanceQuality;
clamp(minQuality, 0, 255);
dstTUVQ.Q= (uint8)minQuality;
}
}
return true;
}