582 lines
25 KiB
C++
582 lines
25 KiB
C++
/*
|
|
Open Asset Import Library (assimp)
|
|
----------------------------------------------------------------------
|
|
|
|
Copyright (c) 2006-2020, assimp team
|
|
|
|
|
|
All rights reserved.
|
|
|
|
Redistribution and use of this software in source and binary forms,
|
|
with or without modification, are permitted provided that the
|
|
following conditions are met:
|
|
|
|
* Redistributions of source code must retain the above
|
|
copyright notice, this list of conditions and the
|
|
following disclaimer.
|
|
|
|
* Redistributions in binary form must reproduce the above
|
|
copyright notice, this list of conditions and the
|
|
following disclaimer in the documentation and/or other
|
|
materials provided with the distribution.
|
|
|
|
* Neither the name of the assimp team, nor the names of its
|
|
contributors may be used to endorse or promote products
|
|
derived from this software without specific prior
|
|
written permission of the assimp team.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
----------------------------------------------------------------------
|
|
*/
|
|
|
|
#include <assimp/Subdivision.h>
|
|
#include <assimp/SceneCombiner.h>
|
|
#include <assimp/SpatialSort.h>
|
|
#include <assimp/Vertex.h>
|
|
#include <assimp/ai_assert.h>
|
|
|
|
#include "PostProcessing/ProcessHelper.h"
|
|
|
|
#include <stdio.h>
|
|
|
|
using namespace Assimp;
|
|
void mydummy() {}
|
|
|
|
#if _MSC_VER > 1920
|
|
#pragma warning(disable : 4709)
|
|
#endif // _WIN32
|
|
// ------------------------------------------------------------------------------------------------
|
|
/** Subdivider stub class to implement the Catmull-Clarke subdivision algorithm. The
|
|
* implementation is basing on recursive refinement. Directly evaluating the result is also
|
|
* possible and much quicker, but it depends on lengthy matrix lookup tables. */
|
|
// ------------------------------------------------------------------------------------------------
|
|
class CatmullClarkSubdivider : public Subdivider {
|
|
public:
|
|
void Subdivide(aiMesh *mesh, aiMesh *&out, unsigned int num, bool discard_input);
|
|
void Subdivide(aiMesh **smesh, size_t nmesh,
|
|
aiMesh **out, unsigned int num, bool discard_input);
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/** Intermediate description of an edge between two corners of a polygon*/
|
|
// ---------------------------------------------------------------------------
|
|
struct Edge {
|
|
Edge() :
|
|
ref(0) {}
|
|
Vertex edge_point, midpoint;
|
|
unsigned int ref;
|
|
};
|
|
|
|
typedef std::vector<unsigned int> UIntVector;
|
|
typedef std::map<uint64_t, Edge> EdgeMap;
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Hashing function to derive an index into an #EdgeMap from two given
|
|
// 'unsigned int' vertex coordinates (!!distinct coordinates - same
|
|
// vertex position == same index!!).
|
|
// NOTE - this leads to rare hash collisions if a) sizeof(unsigned int)>4
|
|
// and (id[0]>2^32-1 or id[0]>2^32-1).
|
|
// MAKE_EDGE_HASH() uses temporaries, so INIT_EDGE_HASH() needs to be put
|
|
// at the head of every function which is about to use MAKE_EDGE_HASH().
|
|
// Reason is that the hash is that hash construction needs to hold the
|
|
// invariant id0<id1 to identify an edge - else two hashes would refer
|
|
// to the same edge.
|
|
// ---------------------------------------------------------------------------
|
|
#define MAKE_EDGE_HASH(id0, id1) (eh_tmp0__ = id0, eh_tmp1__ = id1, \
|
|
(eh_tmp0__ < eh_tmp1__ ? std::swap(eh_tmp0__, eh_tmp1__) : mydummy()), (uint64_t)eh_tmp0__ ^ ((uint64_t)eh_tmp1__ << 32u))
|
|
|
|
#define INIT_EDGE_HASH_TEMPORARIES() \
|
|
unsigned int eh_tmp0__, eh_tmp1__;
|
|
|
|
private:
|
|
void InternSubdivide(const aiMesh *const *smesh,
|
|
size_t nmesh, aiMesh **out, unsigned int num);
|
|
};
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Construct a subdivider of a specific type
|
|
Subdivider *Subdivider::Create(Algorithm algo) {
|
|
switch (algo) {
|
|
case CATMULL_CLARKE:
|
|
return new CatmullClarkSubdivider();
|
|
};
|
|
|
|
ai_assert(false);
|
|
|
|
return nullptr; // shouldn't happen
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Call the Catmull Clark subdivision algorithm for one mesh
|
|
void CatmullClarkSubdivider::Subdivide(
|
|
aiMesh *mesh,
|
|
aiMesh *&out,
|
|
unsigned int num,
|
|
bool discard_input) {
|
|
ai_assert(mesh != out);
|
|
|
|
Subdivide(&mesh, 1, &out, num, discard_input);
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Call the Catmull Clark subdivision algorithm for multiple meshes
|
|
void CatmullClarkSubdivider::Subdivide(
|
|
aiMesh **smesh,
|
|
size_t nmesh,
|
|
aiMesh **out,
|
|
unsigned int num,
|
|
bool discard_input) {
|
|
ai_assert(nullptr != smesh);
|
|
ai_assert(nullptr != out);
|
|
|
|
// course, both regions may not overlap
|
|
ai_assert(smesh < out || smesh + nmesh > out + nmesh);
|
|
if (!num) {
|
|
// No subdivision at all. Need to copy all the meshes .. argh.
|
|
if (discard_input) {
|
|
for (size_t s = 0; s < nmesh; ++s) {
|
|
out[s] = smesh[s];
|
|
smesh[s] = nullptr;
|
|
}
|
|
} else {
|
|
for (size_t s = 0; s < nmesh; ++s) {
|
|
SceneCombiner::Copy(out + s, smesh[s]);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
std::vector<aiMesh *> inmeshes;
|
|
std::vector<aiMesh *> outmeshes;
|
|
std::vector<unsigned int> maptbl;
|
|
|
|
inmeshes.reserve(nmesh);
|
|
outmeshes.reserve(nmesh);
|
|
maptbl.reserve(nmesh);
|
|
|
|
// Remove pure line and point meshes from the working set to reduce the
|
|
// number of edge cases the subdivider is forced to deal with. Line and
|
|
// point meshes are simply passed through.
|
|
for (size_t s = 0; s < nmesh; ++s) {
|
|
aiMesh *i = smesh[s];
|
|
// FIX - mPrimitiveTypes might not yet be initialized
|
|
if (i->mPrimitiveTypes && (i->mPrimitiveTypes & (aiPrimitiveType_LINE | aiPrimitiveType_POINT)) == i->mPrimitiveTypes) {
|
|
ASSIMP_LOG_VERBOSE_DEBUG("Catmull-Clark Subdivider: Skipping pure line/point mesh");
|
|
|
|
if (discard_input) {
|
|
out[s] = i;
|
|
smesh[s] = nullptr;
|
|
} else {
|
|
SceneCombiner::Copy(out + s, i);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
outmeshes.push_back(nullptr);
|
|
inmeshes.push_back(i);
|
|
maptbl.push_back(static_cast<unsigned int>(s));
|
|
}
|
|
|
|
// Do the actual subdivision on the preallocated storage. InternSubdivide
|
|
// *always* assumes that enough storage is available, it does not bother
|
|
// checking any ranges.
|
|
ai_assert(inmeshes.size() == outmeshes.size());
|
|
ai_assert(inmeshes.size() == maptbl.size());
|
|
if (inmeshes.empty()) {
|
|
ASSIMP_LOG_WARN("Catmull-Clark Subdivider: Pure point/line scene, I can't do anything");
|
|
return;
|
|
}
|
|
InternSubdivide(&inmeshes.front(), inmeshes.size(), &outmeshes.front(), num);
|
|
for (unsigned int i = 0; i < maptbl.size(); ++i) {
|
|
ai_assert(nullptr != outmeshes[i]);
|
|
out[maptbl[i]] = outmeshes[i];
|
|
}
|
|
|
|
if (discard_input) {
|
|
for (size_t s = 0; s < nmesh; ++s) {
|
|
delete smesh[s];
|
|
}
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Note - this is an implementation of the standard (recursive) Cm-Cl algorithm without further
|
|
// optimizations (except we're using some nice LUTs). A description of the algorithm can be found
|
|
// here: http://en.wikipedia.org/wiki/Catmull-Clark_subdivision_surface
|
|
//
|
|
// The code is mostly O(n), however parts are O(nlogn) which is therefore the algorithm's
|
|
// expected total runtime complexity. The implementation is able to work in-place on the same
|
|
// mesh arrays. Calling #InternSubdivide() directly is not encouraged. The code can operate
|
|
// in-place unless 'smesh' and 'out' are equal (no strange overlaps or reorderings).
|
|
// Previous data is replaced/deleted then.
|
|
// ------------------------------------------------------------------------------------------------
|
|
void CatmullClarkSubdivider::InternSubdivide(
|
|
const aiMesh *const *smesh,
|
|
size_t nmesh,
|
|
aiMesh **out,
|
|
unsigned int num) {
|
|
ai_assert(nullptr != smesh);
|
|
ai_assert(nullptr != out);
|
|
|
|
INIT_EDGE_HASH_TEMPORARIES();
|
|
|
|
// no subdivision requested or end of recursive refinement
|
|
if (!num) {
|
|
return;
|
|
}
|
|
|
|
UIntVector maptbl;
|
|
SpatialSort spatial;
|
|
|
|
// ---------------------------------------------------------------------
|
|
// 0. Offset table to index all meshes continuously, generate a spatially
|
|
// sorted representation of all vertices in all meshes.
|
|
// ---------------------------------------------------------------------
|
|
typedef std::pair<unsigned int, unsigned int> IntPair;
|
|
std::vector<IntPair> moffsets(nmesh);
|
|
unsigned int totfaces = 0, totvert = 0;
|
|
for (size_t t = 0; t < nmesh; ++t) {
|
|
const aiMesh *mesh = smesh[t];
|
|
|
|
spatial.Append(mesh->mVertices, mesh->mNumVertices, sizeof(aiVector3D), false);
|
|
moffsets[t] = IntPair(totfaces, totvert);
|
|
|
|
totfaces += mesh->mNumFaces;
|
|
totvert += mesh->mNumVertices;
|
|
}
|
|
|
|
spatial.Finalize();
|
|
const unsigned int num_unique = spatial.GenerateMappingTable(maptbl, ComputePositionEpsilon(smesh, nmesh));
|
|
|
|
#define FLATTEN_VERTEX_IDX(mesh_idx, vert_idx) (moffsets[mesh_idx].second + vert_idx)
|
|
#define FLATTEN_FACE_IDX(mesh_idx, face_idx) (moffsets[mesh_idx].first + face_idx)
|
|
|
|
// ---------------------------------------------------------------------
|
|
// 1. Compute the centroid point for all faces
|
|
// ---------------------------------------------------------------------
|
|
std::vector<Vertex> centroids(totfaces);
|
|
unsigned int nfacesout = 0;
|
|
for (size_t t = 0, n = 0; t < nmesh; ++t) {
|
|
const aiMesh *mesh = smesh[t];
|
|
for (unsigned int i = 0; i < mesh->mNumFaces; ++i, ++n) {
|
|
const aiFace &face = mesh->mFaces[i];
|
|
Vertex &c = centroids[n];
|
|
|
|
for (unsigned int a = 0; a < face.mNumIndices; ++a) {
|
|
c += Vertex(mesh, face.mIndices[a]);
|
|
}
|
|
|
|
c /= static_cast<float>(face.mNumIndices);
|
|
nfacesout += face.mNumIndices;
|
|
}
|
|
}
|
|
|
|
{
|
|
// we want edges to go away before the recursive calls so begin a new scope
|
|
EdgeMap edges;
|
|
|
|
// ---------------------------------------------------------------------
|
|
// 2. Set each edge point to be the average of all neighbouring
|
|
// face points and original points. Every edge exists twice
|
|
// if there is a neighboring face.
|
|
// ---------------------------------------------------------------------
|
|
for (size_t t = 0; t < nmesh; ++t) {
|
|
const aiMesh *mesh = smesh[t];
|
|
|
|
for (unsigned int i = 0; i < mesh->mNumFaces; ++i) {
|
|
const aiFace &face = mesh->mFaces[i];
|
|
|
|
for (unsigned int p = 0; p < face.mNumIndices; ++p) {
|
|
const unsigned int id[] = {
|
|
face.mIndices[p],
|
|
face.mIndices[p == face.mNumIndices - 1 ? 0 : p + 1]
|
|
};
|
|
const unsigned int mp[] = {
|
|
maptbl[FLATTEN_VERTEX_IDX(t, id[0])],
|
|
maptbl[FLATTEN_VERTEX_IDX(t, id[1])]
|
|
};
|
|
|
|
Edge &e = edges[MAKE_EDGE_HASH(mp[0], mp[1])];
|
|
e.ref++;
|
|
if (e.ref <= 2) {
|
|
if (e.ref == 1) { // original points (end points) - add only once
|
|
e.edge_point = e.midpoint = Vertex(mesh, id[0]) + Vertex(mesh, id[1]);
|
|
e.midpoint *= 0.5f;
|
|
}
|
|
e.edge_point += centroids[FLATTEN_FACE_IDX(t, i)];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------
|
|
// 3. Normalize edge points
|
|
// ---------------------------------------------------------------------
|
|
{
|
|
unsigned int bad_cnt = 0;
|
|
for (EdgeMap::iterator it = edges.begin(); it != edges.end(); ++it) {
|
|
if ((*it).second.ref < 2) {
|
|
ai_assert((*it).second.ref);
|
|
++bad_cnt;
|
|
}
|
|
(*it).second.edge_point *= 1.f / ((*it).second.ref + 2.f);
|
|
}
|
|
|
|
if (bad_cnt) {
|
|
// Report the number of bad edges. bad edges are referenced by less than two
|
|
// faces in the mesh. They occur at outer model boundaries in non-closed
|
|
// shapes.
|
|
ASSIMP_LOG_VERBOSE_DEBUG_F("Catmull-Clark Subdivider: got ", bad_cnt, " bad edges touching only one face (totally ",
|
|
static_cast<unsigned int>(edges.size()), " edges). ");
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------
|
|
// 4. Compute a vertex-face adjacency table. We can't reuse the code
|
|
// from VertexTriangleAdjacency because we need the table for multiple
|
|
// meshes and out vertex indices need to be mapped to distinct values
|
|
// first.
|
|
// ---------------------------------------------------------------------
|
|
UIntVector faceadjac(nfacesout), cntadjfac(maptbl.size(), 0), ofsadjvec(maptbl.size() + 1, 0);
|
|
{
|
|
for (size_t t = 0; t < nmesh; ++t) {
|
|
const aiMesh *const minp = smesh[t];
|
|
for (unsigned int i = 0; i < minp->mNumFaces; ++i) {
|
|
|
|
const aiFace &f = minp->mFaces[i];
|
|
for (unsigned int n = 0; n < f.mNumIndices; ++n) {
|
|
++cntadjfac[maptbl[FLATTEN_VERTEX_IDX(t, f.mIndices[n])]];
|
|
}
|
|
}
|
|
}
|
|
unsigned int cur = 0;
|
|
for (size_t i = 0; i < cntadjfac.size(); ++i) {
|
|
ofsadjvec[i + 1] = cur;
|
|
cur += cntadjfac[i];
|
|
}
|
|
for (size_t t = 0; t < nmesh; ++t) {
|
|
const aiMesh *const minp = smesh[t];
|
|
for (unsigned int i = 0; i < minp->mNumFaces; ++i) {
|
|
|
|
const aiFace &f = minp->mFaces[i];
|
|
for (unsigned int n = 0; n < f.mNumIndices; ++n) {
|
|
faceadjac[ofsadjvec[1 + maptbl[FLATTEN_VERTEX_IDX(t, f.mIndices[n])]]++] = FLATTEN_FACE_IDX(t, i);
|
|
}
|
|
}
|
|
}
|
|
|
|
// check the other way round for consistency
|
|
#ifdef ASSIMP_BUILD_DEBUG
|
|
|
|
for (size_t t = 0; t < ofsadjvec.size() - 1; ++t) {
|
|
for (unsigned int m = 0; m < cntadjfac[t]; ++m) {
|
|
const unsigned int fidx = faceadjac[ofsadjvec[t] + m];
|
|
ai_assert(fidx < totfaces);
|
|
for (size_t n = 1; n < nmesh; ++n) {
|
|
|
|
if (moffsets[n].first > fidx) {
|
|
const aiMesh *msh = smesh[--n];
|
|
const aiFace &f = msh->mFaces[fidx - moffsets[n].first];
|
|
|
|
bool haveit = false;
|
|
for (unsigned int i = 0; i < f.mNumIndices; ++i) {
|
|
if (maptbl[FLATTEN_VERTEX_IDX(n, f.mIndices[i])] == (unsigned int)t) {
|
|
haveit = true;
|
|
break;
|
|
}
|
|
}
|
|
ai_assert(haveit);
|
|
if (!haveit) {
|
|
ASSIMP_LOG_VERBOSE_DEBUG("Catmull-Clark Subdivider: Index not used");
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif
|
|
}
|
|
|
|
#define GET_ADJACENT_FACES_AND_CNT(vidx, fstartout, numout) \
|
|
fstartout = &faceadjac[ofsadjvec[vidx]], numout = cntadjfac[vidx]
|
|
|
|
typedef std::pair<bool, Vertex> TouchedOVertex;
|
|
std::vector<TouchedOVertex> new_points(num_unique, TouchedOVertex(false, Vertex()));
|
|
// ---------------------------------------------------------------------
|
|
// 5. Spawn a quad from each face point to the corresponding edge points
|
|
// the original points being the fourth quad points.
|
|
// ---------------------------------------------------------------------
|
|
for (size_t t = 0; t < nmesh; ++t) {
|
|
const aiMesh *const minp = smesh[t];
|
|
aiMesh *const mout = out[t] = new aiMesh();
|
|
|
|
for (unsigned int a = 0; a < minp->mNumFaces; ++a) {
|
|
mout->mNumFaces += minp->mFaces[a].mNumIndices;
|
|
}
|
|
|
|
// We need random access to the old face buffer, so reuse is not possible.
|
|
mout->mFaces = new aiFace[mout->mNumFaces];
|
|
|
|
mout->mNumVertices = mout->mNumFaces * 4;
|
|
mout->mVertices = new aiVector3D[mout->mNumVertices];
|
|
|
|
// quads only, keep material index
|
|
mout->mPrimitiveTypes = aiPrimitiveType_POLYGON;
|
|
mout->mMaterialIndex = minp->mMaterialIndex;
|
|
|
|
if (minp->HasNormals()) {
|
|
mout->mNormals = new aiVector3D[mout->mNumVertices];
|
|
}
|
|
|
|
if (minp->HasTangentsAndBitangents()) {
|
|
mout->mTangents = new aiVector3D[mout->mNumVertices];
|
|
mout->mBitangents = new aiVector3D[mout->mNumVertices];
|
|
}
|
|
|
|
for (unsigned int i = 0; minp->HasTextureCoords(i); ++i) {
|
|
mout->mTextureCoords[i] = new aiVector3D[mout->mNumVertices];
|
|
mout->mNumUVComponents[i] = minp->mNumUVComponents[i];
|
|
}
|
|
|
|
for (unsigned int i = 0; minp->HasVertexColors(i); ++i) {
|
|
mout->mColors[i] = new aiColor4D[mout->mNumVertices];
|
|
}
|
|
|
|
mout->mNumVertices = mout->mNumFaces << 2u;
|
|
for (unsigned int i = 0, v = 0, n = 0; i < minp->mNumFaces; ++i) {
|
|
|
|
const aiFace &face = minp->mFaces[i];
|
|
for (unsigned int a = 0; a < face.mNumIndices; ++a) {
|
|
|
|
// Get a clean new face.
|
|
aiFace &faceOut = mout->mFaces[n++];
|
|
faceOut.mIndices = new unsigned int[faceOut.mNumIndices = 4];
|
|
|
|
// Spawn a new quadrilateral (ccw winding) for this original point between:
|
|
// a) face centroid
|
|
centroids[FLATTEN_FACE_IDX(t, i)].SortBack(mout, faceOut.mIndices[0] = v++);
|
|
|
|
// b) adjacent edge on the left, seen from the centroid
|
|
const Edge &e0 = edges[MAKE_EDGE_HASH(maptbl[FLATTEN_VERTEX_IDX(t, face.mIndices[a])],
|
|
maptbl[FLATTEN_VERTEX_IDX(t, face.mIndices[a == face.mNumIndices - 1 ? 0 : a + 1])])]; // fixme: replace with mod face.mNumIndices?
|
|
|
|
// c) adjacent edge on the right, seen from the centroid
|
|
const Edge &e1 = edges[MAKE_EDGE_HASH(maptbl[FLATTEN_VERTEX_IDX(t, face.mIndices[a])],
|
|
maptbl[FLATTEN_VERTEX_IDX(t, face.mIndices[!a ? face.mNumIndices - 1 : a - 1])])]; // fixme: replace with mod face.mNumIndices?
|
|
|
|
e0.edge_point.SortBack(mout, faceOut.mIndices[3] = v++);
|
|
e1.edge_point.SortBack(mout, faceOut.mIndices[1] = v++);
|
|
|
|
// d= original point P with distinct index i
|
|
// F := 0
|
|
// R := 0
|
|
// n := 0
|
|
// for each face f containing i
|
|
// F := F+ centroid of f
|
|
// R := R+ midpoint of edge of f from i to i+1
|
|
// n := n+1
|
|
//
|
|
// (F+2R+(n-3)P)/n
|
|
const unsigned int org = maptbl[FLATTEN_VERTEX_IDX(t, face.mIndices[a])];
|
|
TouchedOVertex &ov = new_points[org];
|
|
|
|
if (!ov.first) {
|
|
ov.first = true;
|
|
|
|
const unsigned int *adj;
|
|
unsigned int cnt;
|
|
GET_ADJACENT_FACES_AND_CNT(org, adj, cnt);
|
|
|
|
if (cnt < 3) {
|
|
ov.second = Vertex(minp, face.mIndices[a]);
|
|
} else {
|
|
|
|
Vertex F, R;
|
|
for (unsigned int o = 0; o < cnt; ++o) {
|
|
ai_assert(adj[o] < totfaces);
|
|
F += centroids[adj[o]];
|
|
|
|
// adj[0] is a global face index - search the face in the mesh list
|
|
const aiMesh *mp = nullptr;
|
|
size_t nidx;
|
|
|
|
if (adj[o] < moffsets[0].first) {
|
|
mp = smesh[nidx = 0];
|
|
} else {
|
|
for (nidx = 1; nidx <= nmesh; ++nidx) {
|
|
if (nidx == nmesh || moffsets[nidx].first > adj[o]) {
|
|
mp = smesh[--nidx];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
ai_assert(adj[o] - moffsets[nidx].first < mp->mNumFaces);
|
|
const aiFace &f = mp->mFaces[adj[o] - moffsets[nidx].first];
|
|
bool haveit = false;
|
|
|
|
// find our original point in the face
|
|
for (unsigned int m = 0; m < f.mNumIndices; ++m) {
|
|
if (maptbl[FLATTEN_VERTEX_IDX(nidx, f.mIndices[m])] == org) {
|
|
|
|
// add *both* edges. this way, we can be sure that we add
|
|
// *all* adjacent edges to R. In a closed shape, every
|
|
// edge is added twice - so we simply leave out the
|
|
// factor 2.f in the amove formula and get the right
|
|
// result.
|
|
|
|
const Edge &c0 = edges[MAKE_EDGE_HASH(org, maptbl[FLATTEN_VERTEX_IDX(
|
|
nidx, f.mIndices[!m ? f.mNumIndices - 1 : m - 1])])];
|
|
// fixme: replace with mod face.mNumIndices?
|
|
|
|
const Edge &c1 = edges[MAKE_EDGE_HASH(org, maptbl[FLATTEN_VERTEX_IDX(
|
|
nidx, f.mIndices[m == f.mNumIndices - 1 ? 0 : m + 1])])];
|
|
// fixme: replace with mod face.mNumIndices?
|
|
R += c0.midpoint + c1.midpoint;
|
|
|
|
haveit = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// this invariant *must* hold if the vertex-to-face adjacency table is valid
|
|
ai_assert(haveit);
|
|
if (!haveit) {
|
|
ASSIMP_LOG_WARN("OBJ: no name for material library specified.");
|
|
}
|
|
}
|
|
|
|
const float div = static_cast<float>(cnt), divsq = 1.f / (div * div);
|
|
ov.second = Vertex(minp, face.mIndices[a]) * ((div - 3.f) / div) + R * divsq + F * divsq;
|
|
}
|
|
}
|
|
ov.second.SortBack(mout, faceOut.mIndices[2] = v++);
|
|
}
|
|
}
|
|
}
|
|
} // end of scope for edges, freeing its memory
|
|
|
|
// ---------------------------------------------------------------------
|
|
// 7. Apply the next subdivision step.
|
|
// ---------------------------------------------------------------------
|
|
if (num != 1) {
|
|
std::vector<aiMesh *> tmp(nmesh);
|
|
InternSubdivide(out, nmesh, &tmp.front(), num - 1);
|
|
for (size_t i = 0; i < nmesh; ++i) {
|
|
delete out[i];
|
|
out[i] = tmp[i];
|
|
}
|
|
}
|
|
}
|