Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

aiBone *bone = kvp.first;

aiNode *bone_node = kvp.second;

ASSIMP_LOG_VERBOSE_DEBUG("active node lookup: ", bone->mName.C_Str());

// lcl transform grab - done in generate_nodes :)

aiNode *armature = GetArmatureRoot(bone_node, bones);

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

Open Asset Import Library (assimp)

---------------------------------------------------------------------------

localBitangent.NormalizeSafe();

// reconstruct tangent/bitangent according to normal and bitangent/tangent when it's infinite or NaN.

|| (-0.5f < localTangent.x && localTangent.x < 0.5f && -0.5f < localTangent.y && localTangent.y < 0.5f && -0.5f < localTangent.z && localTangent.z < 0.5f);

bool invalid_bitangent = is_special_float(localBitangent.x) || is_special_float(localBitangent.y) || is_special_float(localBitangent.z)

|| (-0.5f < localBitangent.x && localBitangent.x < 0.5f && -0.5f < localBitangent.y && localBitangent.y < 0.5f && -0.5f < localBitangent.z && localBitangent.z < 0.5f);

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

Open Asset Import Library (assimp)

---------------------------------------------------------------------------

All rights reserved.

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

struct aiMaterial;

struct aiCamera;

// -----------------------------------------------------------------------------------

/** @brief The MakeLeftHandedProcess converts all imported data to a left-handed

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

}

} else {

vertexBones[vid] = i;

}

if(!isBoneNecessary[i]) {

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

Open Asset Import Library (assimp)

---------------------------------------------------------------------------

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

#include "ProcessHelper.h"

#include <fstream>

using namespace Assimp;

ASSIMP_LOG_INFO("EmbedTexturesProcess finished. Embedded ", embeddedTexturesCount, " textures." );

}

bool EmbedTexturesProcess::addTexture(aiScene *pScene, const std::string &path) const {

std::streampos imageSize = 0;

}

IOStream* pFile = mIOHandler->Open(imagePath);

if (pFile == nullptr) {

ASSIMP_LOG_ERROR("EmbedTexturesProcess: Unable to embed texture: ", path, ".");

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

void SetupProperties(const Importer* pImp) override;

/// Overwritten, @see BaseProcess

private:

// Resolve the path and add the file content to the scene as a texture.

bool addTexture(aiScene *pScene, const std::string &path) const;

Open Asset Import Library (assimp)

---------------------------------------------------------------------------

All rights reserved.

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

#include <assimp/mesh.h>

class FindDegeneratesProcessTest;

// ---------------------------------------------------------------------------

Open Asset Import Library (assimp)

---------------------------------------------------------------------------

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

Open Asset Import Library (assimp)

---------------------------------------------------------------------------

All rights reserved.

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

Open Asset Import Library (assimp)

---------------------------------------------------------------------------

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

Open Asset Import Library (assimp)

---------------------------------------------------------------------------

All rights reserved.

Open Asset Import Library (assimp)

---------------------------------------------------------------------------

All rights reserved.

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

namespace Assimp {

* @brief Post-processing process to find axis-aligned bounding volumes for amm meshes

* used in a scene.

*/

Open Asset Import Library (assimp)

---------------------------------------------------------------------------

All rights reserved.

---------------------------------------------------------------------------

*/

#include "GenFaceNormalsProcess.h"

#include <assimp/Exceptional.h>

using namespace Assimp;

// ------------------------------------------------------------------------------------------------

bool GenFaceNormalsProcess::IsActive(unsigned int pFlags) const {

force_ = (pFlags & aiProcess_ForceGenNormals) != 0;

flippedWindingOrder_ = (pFlags & aiProcess_FlipWindingOrder) != 0;

}

// ------------------------------------------------------------------------------------------------

void GenFaceNormalsProcess::Execute(aiScene *pScene) {

ASSIMP_LOG_DEBUG("GenFaceNormalsProcess begin");

}

// ------------------------------------------------------------------------------------------------

bool GenFaceNormalsProcess::GenMeshFaceNormals(aiMesh *pMesh) {

if (nullptr != pMesh->mNormals) {

if (force_) {

}

// allocate an array to hold the output normals

// iterate through all faces and compute per-face normals but store them per-vertex.

for (unsigned int a = 0; a < pMesh->mNumFaces; a++) {

if (face.mNumIndices < 3) {

// either a point or a line -> no well-defined normal vector

for (unsigned int i = 0; i < face.mNumIndices; ++i) {

}

continue;

}

const aiVector3D *pV1 = &pMesh->mVertices[face.mIndices[0]];

const aiVector3D *pV2 = &pMesh->mVertices[face.mIndices[1]];

const aiVector3D *pV3 = &pMesh->mVertices[face.mIndices[face.mNumIndices - 1]];

std::swap(pV2, pV3);

const aiVector3D vNor = ((*pV2 - *pV1) ^ (*pV3 - *pV1)).NormalizeSafe();

for (unsigned int i = 0; i < face.mNumIndices; ++i) {

}

}

return true;

}

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

namespace Assimp {

// ---------------------------------------------------------------------------

* @brief The GenFaceNormalsProcess computes face normals for all faces of all meshes

*/

class ASSIMP_API_WINONLY GenFaceNormalsProcess : public BaseProcess {

Open Asset Import Library (assimp)

---------------------------------------------------------------------------

All rights reserved.

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

Open Asset Import Library (assimp)

---------------------------------------------------------------------------

All rights reserved.

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

Open Asset Import Library (assimp)

---------------------------------------------------------------------------

All rights reserved.

#include <unordered_set>

#include <unordered_map>

#include <memory>

using namespace Assimp;

namespace {

template<class XMesh>

void updateXMeshVertices(XMesh *pMesh, std::vector<int> &uniqueVertices) {

// replace vertex data with the unique data sets

// ----------------------------------------------------------------------------

// Position, if present (check made for aiAnimMesh)

std::unique_ptr<aiVector3D[]> oldVertices(pMesh->mVertices);

pMesh->mVertices = new aiVector3D[pMesh->mNumVertices];

for (unsigned int a = 0; a < pMesh->mNumVertices; a++)

} // namespace

// ------------------------------------------------------------------------------------------------

static constexpr size_t JOINED_VERTICES_MARK = 0x80000000u;

// We'll never have more vertices afterwards.

std::vector<int> uniqueVertices;

// For each vertex the index of the vertex it was replaced by.

// Since the maximal number of vertices is 2^31-1, the most significand bit can be used to mark

static_assert(AI_MAX_VERTICES == 0x7fffffff, "AI_MAX_VERTICES == 0x7fffffff");

std::vector<unsigned int> replaceIndex( pMesh->mNumVertices, 0xffffffff);

// Run an optimized code path if we don't have multiple UVs or vertex colors.

// This should yield false in more than 99% of all imports ...

const bool hasAnimMeshes = pMesh->mNumAnimMeshes > 0;

}

}

// a map that maps a vertex to its new index

// we can not end up with more vertices than we started with

// Now check each vertex if it brings something new to the table

int newIndex = 0;

for( unsigned int a = 0; a < pMesh->mNumVertices; a++) {

// if the vertex is not in the map then it is a new vertex add it.

if (it == vertex2Index.end()) {

// this is a new vertex give it a new index

replaceIndex[a] = newIndex++;

// add the vertex to the unique vertices

uniqueVertices.push_back(a);

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

public:

// -------------------------------------------------------------------

/// The default class constructor / destructor.

~JoinVerticesProcess() override = default;

// -------------------------------------------------------------------

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

// Executes the post processing step on the given imported data.

void LimitBoneWeightsProcess::Execute( aiScene* pScene) {

ai_assert(pScene != nullptr);

ASSIMP_LOG_DEBUG("LimitBoneWeightsProcess begin");

for (unsigned int m = 0; m < pScene->mNumMeshes; ++m) {

// ------------------------------------------------------------------------------------------------

static unsigned int removeEmptyBones(aiMesh *pMesh) {

ai_assert(pMesh != nullptr);

unsigned int writeBone = 0;

for (unsigned int readBone = 0; readBone< pMesh->mNumBones; ++readBone) {

aiBone* bone = pMesh->mBones[readBone];

delete bone;

}

}

return writeBone;

}

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

Open Asset Import Library (assimp)

---------------------------------------------------------------------------

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

struct aiMesh;

// ---------------------------------------------------------------------------

/** MakeVerboseFormatProcess: Class to convert an asset to the verbose

Open Asset Import Library (assimp)

---------------------------------------------------------------------------

All rights reserved.

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

class OptimizeGraphProcessTest;

// -----------------------------------------------------------------------------

/** @brief Postprocessing step to optimize the scenegraph

Open Asset Import Library (assimp)

---------------------------------------------------------------------------

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

struct aiNode;

class OptimizeMeshesProcessTest;

// ---------------------------------------------------------------------------

/** @brief Postprocessing step to optimize mesh usage

Open Asset Import Library (assimp)

---------------------------------------------------------------------------

All rights reserved.

mesh->mBones = reinterpret_cast<aiBone **>(&node->mTransformation);

mesh->mNumBones = UINT_MAX;

continue;

// try to find us in the list of newly created meshes

for (unsigned int n = 0; n < out.size(); ++n) {

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

Open Asset Import Library (assimp)

---------------------------------------------------------------------------

All rights reserved.

if (pScene->mNumMaterials == 0) {

return;

}

// Find out which materials are referenced by meshes

std::vector<bool> abReferenced(pScene->mNumMaterials,false);

for (unsigned int i = 0;i < pScene->mNumMeshes;++i) {

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

class RemoveRedundantMatsTest;

// ---------------------------------------------------------------------------

/** RemoveRedundantMatsProcess: Post-processing step to remove redundant

Open Asset Import Library (assimp)

---------------------------------------------------------------------------

All rights reserved.

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

* The function is a request to the process to update its configuration

* basing on the Importer's configuration property list.

*/

// -------------------------------------------------------------------

/** Manually setup the configuration flags for the step

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

ai_real getScale() const;

/// Overwritten, @see BaseProcess

/// Overwritten, @see BaseProcess

/// Overwritten, @see BaseProcess

private:

void traverseNodes( aiNode *currentNode, unsigned int nested_node_id = 0 );

Open Asset Import Library (assimp)

---------------------------------------------------------------------------

All rights reserved.

}

// ------------------------------------------------------------------------------------------------

// Update changed meshes in all nodes

void UpdateNodes(const std::vector<unsigned int> &replaceMeshIndex, aiNode *node) {

if (node->mNumMeshes) {

unsigned int newSize = 0;

for (unsigned int m = 0; m < node->mNumMeshes; ++m) {

unsigned int add = node->mMeshes[m] << 2;

for (unsigned int i = 0; i < 4; ++i) {

}

}

}

}

}

}

// call all subnodes recursively

for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {

aiMesh *const mesh = pScene->mMeshes[i];

if (mesh->mPrimitiveTypes == 0) {

throw DeadlyImportError("Mesh with invalid primitive type: ", mesh->mName.C_Str());

}

// with the largest number of primitives

unsigned int aiNumPerPType[4] = { 0, 0, 0, 0 };

aiFace *pFirstFace = mesh->mFaces;

aiFace *const pLastFace = pFirstFace + mesh->mNumFaces;

unsigned int numPolyVerts = 0;

if (vert) {

*vert++ = mesh->mVertices[idx];

}

*nor++ = mesh->mNormals[idx];

if (tan) {

*tan++ = mesh->mTangents[idx];

}

for (unsigned int pp = 0; pp < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++pp) {

break;

*uv[pp]++ = mesh->mTextureCoords[pp][idx];

}

for (unsigned int pp = 0; pp < AI_MAX_NUMBER_OF_COLOR_SETS; ++pp) {

break;

*cols[pp]++ = mesh->mColors[pp][idx];

}

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

class SortByPTypeProcessTest;

// ---------------------------------------------------------------------------

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

/// @brief Called prior to ExecuteOnScene().

/// The function is a request to the process to update its configuration

/// basing on the Importer's configuration property list.

/// @brief Will return the maximal number of bones.

/// @return The maximal number of bones.

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

// ------------------------------------------------------------------------------------------------

// Update a node after some meshes have been split

void SplitLargeMeshesProcess_Triangle::UpdateNode(aiNode* pcNode, const std::vector<std::pair<aiMesh*, unsigned int> >& avList) {

// for every index in out list build a new entry

std::vector<unsigned int> aiEntries;

aiEntries.reserve(pcNode->mNumMeshes + 1);

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

struct aiNode;

struct aiMaterial;

#define AI_TT_UV_IDX_LOCK_TBD 0xffffffff

#define AI_TT_UV_IDX_LOCK_NONE 0xeeeeeeee

private:

unsigned int configFlags;

};

} // namespace Assimp

#endif //! AI_TEXTURE_TRANSFORM_H_INCLUDED

Open Asset Import Library (assimp)

---------------------------------------------------------------------------

All rights reserved.

#include "PostProcessing/TriangulateProcess.h"

#include "PostProcessing/ProcessHelper.h"

#include "Common/PolyTools.h"

#include <memory>

#include <cstdint>

#define POLY_GRID_XPAD 20

#define POLY_OUTPUT_FILE "assimp_polygons_debug.txt"

using namespace Assimp;

namespace {

ASSIMP_LOG_ERROR( "Invalidation detected in the number of indices: does not fit to the primitive type." );

return false;

}

aiVector3D *nor_out = nullptr;

// if we don't have normals yet, but expect them to be a cheap side

aiFace* out = new aiFace[numOut](), *curOut = out;

std::vector<aiVector3D> temp_verts3d(max_out+2); /* temporary storage for vertices */

NGONEncoder ngonEncoder;

const aiVector3D* verts = pMesh->mVertices;

for( unsigned int a = 0; a < pMesh->mNumFaces; a++) {

aiFace& face = pMesh->mFaces[a];

unsigned int* idx = face.mIndices;

// Apply vertex colors to represent the face winding?

#ifdef AI_BUILD_TRIANGULATE_COLOR_FACE_WINDING

// We project it onto a plane to get a 2d triangle.

// Collect all vertices of of the polygon.

temp_verts3d[tmp] = verts[idx[tmp]];

}

// Get newell normal of the polygon. Store it for future use if it's a polygon-only mesh

aiVector3D n;

if (nor_out) {

}

// Select largest normal coordinate to ignore for projection

std::swap(ac,bc);

}

temp_verts[tmp].x = verts[idx[tmp]][ac];

temp_verts[tmp].y = verts[idx[tmp]][bc];

}

#ifdef AI_BUILD_TRIANGULATE_DEBUG_POLYS

fprintf(fout,"\ntriangulation sequence: ");

#endif

}

#ifdef AI_BUILD_TRIANGULATE_DEBUG_POLYS

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

Open Asset Import Library (assimp)

---------------------------------------------------------------------------

All rights reserved.

if (size == 0) {

return;

}

if (!parray) {

ReportError("aiScene::%s is nullptr (aiScene::%s is %i)",

firstName, secondName, size);

if (pBone->mWeights[i].mVertexId >= pMesh->mNumVertices) {

ReportError("aiBone::mWeights[%i].mVertexId is out of range", i);

} else if (!pBone->mWeights[i].mWeight || pBone->mWeights[i].mWeight > 1.0f) {

}

afSum[pBone->mWeights[i].mVertexId] += pBone->mWeights[i].mWeight;

}

ReportError("aiNode \"%s\" child %i \"%s\" parent is someone else: \"%s\"", pNode->mName.C_Str(), i, pChild->mName.C_Str(), parentName);

}

}

}

}

Open Asset Import Library (assimp)

----------------------------------------------------------------------

All rights reserved.

struct aiCamera;

struct aiLight;

// --------------------------------------------------------------------------------------

/** Validates the whole ASSIMP scene data structure for correctness.