diff options
Diffstat (limited to 'src/mesh/assimp-master/code/AssetLib/Q3D')
| -rw-r--r-- | src/mesh/assimp-master/code/AssetLib/Q3D/Q3DLoader.cpp | 575 | ||||
| -rw-r--r-- | src/mesh/assimp-master/code/AssetLib/Q3D/Q3DLoader.h | 116 |
2 files changed, 691 insertions, 0 deletions
diff --git a/src/mesh/assimp-master/code/AssetLib/Q3D/Q3DLoader.cpp b/src/mesh/assimp-master/code/AssetLib/Q3D/Q3DLoader.cpp new file mode 100644 index 0000000..c773bbf --- /dev/null +++ b/src/mesh/assimp-master/code/AssetLib/Q3D/Q3DLoader.cpp @@ -0,0 +1,575 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (assimp) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2022, 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. +--------------------------------------------------------------------------- +*/ + +/** @file Q3DLoader.cpp + * @brief Implementation of the Q3D importer class + */ + +#ifndef ASSIMP_BUILD_NO_Q3D_IMPORTER + +// internal headers +#include "Q3DLoader.h" +#include <assimp/StringUtils.h> +#include <assimp/StreamReader.h> +#include <assimp/fast_atof.h> +#include <assimp/importerdesc.h> +#include <assimp/scene.h> +#include <assimp/DefaultLogger.hpp> +#include <assimp/IOSystem.hpp> + +using namespace Assimp; + +static const aiImporterDesc desc = { + "Quick3D Importer", + "", + "", + "http://www.quick3d.com/", + aiImporterFlags_SupportBinaryFlavour, + 0, + 0, + 0, + 0, + "q3o q3s" +}; + +// ------------------------------------------------------------------------------------------------ +// Constructor to be privately used by Importer +Q3DImporter::Q3DImporter() { + // empty +} + +// ------------------------------------------------------------------------------------------------ +// Destructor, private as well +Q3DImporter::~Q3DImporter() { + // empty +} + +// ------------------------------------------------------------------------------------------------ +// Returns whether the class can handle the format of the given file. +bool Q3DImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { + static const char *tokens[] = { "quick3Do", "quick3Ds" }; + return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens)); +} + +// ------------------------------------------------------------------------------------------------ +const aiImporterDesc *Q3DImporter::GetInfo() const { + return &desc; +} + +// ------------------------------------------------------------------------------------------------ +// Imports the given file into the given scene structure. +void Q3DImporter::InternReadFile(const std::string &pFile, + aiScene *pScene, IOSystem *pIOHandler) { + + auto file = pIOHandler->Open(pFile, "rb"); + if (!file) + throw DeadlyImportError("Quick3D: Could not open ", pFile); + + StreamReaderLE stream(file); + + // The header is 22 bytes large + if (stream.GetRemainingSize() < 22) + throw DeadlyImportError("File is either empty or corrupt: ", pFile); + + // Check the file's signature + if (ASSIMP_strincmp((const char *)stream.GetPtr(), "quick3Do", 8) && + ASSIMP_strincmp((const char *)stream.GetPtr(), "quick3Ds", 8)) { + throw DeadlyImportError("Not a Quick3D file. Signature string is: ", ai_str_toprintable((const char *)stream.GetPtr(), 8)); + } + + // Print the file format version + ASSIMP_LOG_INFO("Quick3D File format version: ", + std::string(&((const char *)stream.GetPtr())[8], 2)); + + // ... an store it + char major = ((const char *)stream.GetPtr())[8]; + char minor = ((const char *)stream.GetPtr())[9]; + + stream.IncPtr(10); + unsigned int numMeshes = (unsigned int)stream.GetI4(); + unsigned int numMats = (unsigned int)stream.GetI4(); + unsigned int numTextures = (unsigned int)stream.GetI4(); + + std::vector<Material> materials; + materials.reserve(numMats); + + std::vector<Mesh> meshes; + meshes.reserve(numMeshes); + + // Allocate the scene root node + pScene->mRootNode = new aiNode(); + + aiColor3D fgColor(0.6f, 0.6f, 0.6f); + + // Now read all file chunks + while (true) { + if (stream.GetRemainingSize() < 1) break; + char c = stream.GetI1(); + switch (c) { + // Meshes chunk + case 'm': { + for (unsigned int quak = 0; quak < numMeshes; ++quak) { + meshes.push_back(Mesh()); + Mesh &mesh = meshes.back(); + + // read all vertices + unsigned int numVerts = (unsigned int)stream.GetI4(); + if (!numVerts) + throw DeadlyImportError("Quick3D: Found mesh with zero vertices"); + + std::vector<aiVector3D> &verts = mesh.verts; + verts.resize(numVerts); + + for (unsigned int i = 0; i < numVerts; ++i) { + verts[i].x = stream.GetF4(); + verts[i].y = stream.GetF4(); + verts[i].z = stream.GetF4(); + } + + // read all faces + numVerts = (unsigned int)stream.GetI4(); + if (!numVerts) + throw DeadlyImportError("Quick3D: Found mesh with zero faces"); + + std::vector<Face> &faces = mesh.faces; + faces.reserve(numVerts); + + // number of indices + for (unsigned int i = 0; i < numVerts; ++i) { + faces.push_back(Face(stream.GetI2())); + if (faces.back().indices.empty()) + throw DeadlyImportError("Quick3D: Found face with zero indices"); + } + + // indices + for (unsigned int i = 0; i < numVerts; ++i) { + Face &vec = faces[i]; + for (unsigned int a = 0; a < (unsigned int)vec.indices.size(); ++a) + vec.indices[a] = stream.GetI4(); + } + + // material indices + for (unsigned int i = 0; i < numVerts; ++i) { + faces[i].mat = (unsigned int)stream.GetI4(); + } + + // read all normals + numVerts = (unsigned int)stream.GetI4(); + std::vector<aiVector3D> &normals = mesh.normals; + normals.resize(numVerts); + + for (unsigned int i = 0; i < numVerts; ++i) { + normals[i].x = stream.GetF4(); + normals[i].y = stream.GetF4(); + normals[i].z = stream.GetF4(); + } + + numVerts = (unsigned int)stream.GetI4(); + if (numTextures && numVerts) { + // read all texture coordinates + std::vector<aiVector3D> &uv = mesh.uv; + uv.resize(numVerts); + + for (unsigned int i = 0; i < numVerts; ++i) { + uv[i].x = stream.GetF4(); + uv[i].y = stream.GetF4(); + } + + // UV indices + for (unsigned int i = 0; i < (unsigned int)faces.size(); ++i) { + Face &vec = faces[i]; + for (unsigned int a = 0; a < (unsigned int)vec.indices.size(); ++a) { + vec.uvindices[a] = stream.GetI4(); + if (!i && !a) + mesh.prevUVIdx = vec.uvindices[a]; + else if (vec.uvindices[a] != mesh.prevUVIdx) + mesh.prevUVIdx = UINT_MAX; + } + } + } + + // we don't need the rest, but we need to get to the next chunk + stream.IncPtr(36); + if (minor > '0' && major == '3') + stream.IncPtr(mesh.faces.size()); + } + // stream.IncPtr(4); // unknown value here + } break; + + // materials chunk + case 'c': + + for (unsigned int i = 0; i < numMats; ++i) { + materials.push_back(Material()); + Material &mat = materials.back(); + + // read the material name + c = stream.GetI1(); + while (c) { + mat.name.data[mat.name.length++] = c; + c = stream.GetI1(); + } + + // add the terminal character + mat.name.data[mat.name.length] = '\0'; + + // read the ambient color + mat.ambient.r = stream.GetF4(); + mat.ambient.g = stream.GetF4(); + mat.ambient.b = stream.GetF4(); + + // read the diffuse color + mat.diffuse.r = stream.GetF4(); + mat.diffuse.g = stream.GetF4(); + mat.diffuse.b = stream.GetF4(); + + // read the ambient color + mat.specular.r = stream.GetF4(); + mat.specular.g = stream.GetF4(); + mat.specular.b = stream.GetF4(); + + // read the transparency + mat.transparency = stream.GetF4(); + + // unknown value here + // stream.IncPtr(4); + // FIX: it could be the texture index ... + mat.texIdx = (unsigned int)stream.GetI4(); + } + + break; + + // texture chunk + case 't': + + pScene->mNumTextures = numTextures; + if (!numTextures) { + break; + } + pScene->mTextures = new aiTexture *[pScene->mNumTextures]; + // to make sure we won't crash if we leave through an exception + ::memset(pScene->mTextures, 0, sizeof(void *) * pScene->mNumTextures); + for (unsigned int i = 0; i < pScene->mNumTextures; ++i) { + aiTexture *tex = pScene->mTextures[i] = new aiTexture; + + // skip the texture name + while (stream.GetI1()) + ; + + // read texture width and height + tex->mWidth = (unsigned int)stream.GetI4(); + tex->mHeight = (unsigned int)stream.GetI4(); + + if (!tex->mWidth || !tex->mHeight) { + throw DeadlyImportError("Quick3D: Invalid texture. Width or height is zero"); + } + + unsigned int mul = tex->mWidth * tex->mHeight; + aiTexel *begin = tex->pcData = new aiTexel[mul]; + aiTexel *const end = &begin[mul - 1] + 1; + + for (; begin != end; ++begin) { + begin->r = stream.GetI1(); + begin->g = stream.GetI1(); + begin->b = stream.GetI1(); + begin->a = 0xff; + } + } + + break; + + // scene chunk + case 's': { + // skip position and rotation + stream.IncPtr(12); + + for (unsigned int i = 0; i < 4; ++i) + for (unsigned int a = 0; a < 4; ++a) + pScene->mRootNode->mTransformation[i][a] = stream.GetF4(); + + stream.IncPtr(16); + + // now setup a single camera + pScene->mNumCameras = 1; + pScene->mCameras = new aiCamera *[1]; + aiCamera *cam = pScene->mCameras[0] = new aiCamera(); + cam->mPosition.x = stream.GetF4(); + cam->mPosition.y = stream.GetF4(); + cam->mPosition.z = stream.GetF4(); + cam->mName.Set("Q3DCamera"); + + // skip eye rotation for the moment + stream.IncPtr(12); + + // read the default material color + fgColor.r = stream.GetF4(); + fgColor.g = stream.GetF4(); + fgColor.b = stream.GetF4(); + + // skip some unimportant properties + stream.IncPtr(29); + + // setup a single point light with no attenuation + pScene->mNumLights = 1; + pScene->mLights = new aiLight *[1]; + aiLight *light = pScene->mLights[0] = new aiLight(); + light->mName.Set("Q3DLight"); + light->mType = aiLightSource_POINT; + + light->mAttenuationConstant = 1; + light->mAttenuationLinear = 0; + light->mAttenuationQuadratic = 0; + + light->mColorDiffuse.r = stream.GetF4(); + light->mColorDiffuse.g = stream.GetF4(); + light->mColorDiffuse.b = stream.GetF4(); + + light->mColorSpecular = light->mColorDiffuse; + + // We don't need the rest, but we need to know where this chunk ends. + unsigned int temp = (unsigned int)(stream.GetI4() * stream.GetI4()); + + // skip the background file name + while (stream.GetI1()) + ; + + // skip background texture data + the remaining fields + stream.IncPtr(temp * 3 + 20); // 4 bytes of unknown data here + + // TODO + goto outer; + } break; + + default: + throw DeadlyImportError("Quick3D: Unknown chunk"); + break; + }; + } +outer: + + // If we have no mesh loaded - break here + if (meshes.empty()) + throw DeadlyImportError("Quick3D: No meshes loaded"); + + // If we have no materials loaded - generate a default mat + if (materials.empty()) { + ASSIMP_LOG_INFO("Quick3D: No material found, generating one"); + materials.push_back(Material()); + materials.back().diffuse = fgColor; + } + + // find out which materials we'll need + typedef std::pair<unsigned int, unsigned int> FaceIdx; + typedef std::vector<FaceIdx> FaceIdxArray; + FaceIdxArray *fidx = new FaceIdxArray[materials.size()]; + + unsigned int p = 0; + for (std::vector<Mesh>::iterator it = meshes.begin(), end = meshes.end(); + it != end; ++it, ++p) { + unsigned int q = 0; + for (std::vector<Face>::iterator fit = (*it).faces.begin(), fend = (*it).faces.end(); + fit != fend; ++fit, ++q) { + if ((*fit).mat >= materials.size()) { + ASSIMP_LOG_WARN("Quick3D: Material index overflow"); + (*fit).mat = 0; + } + if (fidx[(*fit).mat].empty()) ++pScene->mNumMeshes; + fidx[(*fit).mat].push_back(FaceIdx(p, q)); + } + } + pScene->mNumMaterials = pScene->mNumMeshes; + pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials]; + pScene->mMeshes = new aiMesh *[pScene->mNumMaterials]; + + for (unsigned int i = 0, real = 0; i < (unsigned int)materials.size(); ++i) { + if (fidx[i].empty()) continue; + + // Allocate a mesh and a material + aiMesh *mesh = pScene->mMeshes[real] = new aiMesh(); + aiMaterial *mat = new aiMaterial(); + pScene->mMaterials[real] = mat; + + mesh->mMaterialIndex = real; + + // Build the output material + Material &srcMat = materials[i]; + mat->AddProperty(&srcMat.diffuse, 1, AI_MATKEY_COLOR_DIFFUSE); + mat->AddProperty(&srcMat.specular, 1, AI_MATKEY_COLOR_SPECULAR); + mat->AddProperty(&srcMat.ambient, 1, AI_MATKEY_COLOR_AMBIENT); + + // NOTE: Ignore transparency for the moment - it seems + // unclear how to interpret the data +#if 0 + if (!(minor > '0' && major == '3')) + srcMat.transparency = 1.0f - srcMat.transparency; + mat->AddProperty(&srcMat.transparency, 1, AI_MATKEY_OPACITY); +#endif + + // add shininess - Quick3D seems to use it ins its viewer + srcMat.transparency = 16.f; + mat->AddProperty(&srcMat.transparency, 1, AI_MATKEY_SHININESS); + + int m = (int)aiShadingMode_Phong; + mat->AddProperty(&m, 1, AI_MATKEY_SHADING_MODEL); + + if (srcMat.name.length) + mat->AddProperty(&srcMat.name, AI_MATKEY_NAME); + + // Add a texture + if (srcMat.texIdx < pScene->mNumTextures || real < pScene->mNumTextures) { + srcMat.name.data[0] = '*'; + srcMat.name.length = ASSIMP_itoa10(&srcMat.name.data[1], 1000, + (srcMat.texIdx < pScene->mNumTextures ? srcMat.texIdx : real)); + mat->AddProperty(&srcMat.name, AI_MATKEY_TEXTURE_DIFFUSE(0)); + } + + mesh->mNumFaces = (unsigned int)fidx[i].size(); + aiFace *faces = mesh->mFaces = new aiFace[mesh->mNumFaces]; + + // Now build the output mesh. First find out how many + // vertices we'll need + for (FaceIdxArray::const_iterator it = fidx[i].begin(), end = fidx[i].end(); + it != end; ++it) { + mesh->mNumVertices += (unsigned int)meshes[(*it).first].faces[(*it).second].indices.size(); + } + + aiVector3D *verts = mesh->mVertices = new aiVector3D[mesh->mNumVertices]; + aiVector3D *norms = mesh->mNormals = new aiVector3D[mesh->mNumVertices]; + aiVector3D *uv = nullptr; + if (real < pScene->mNumTextures) { + uv = mesh->mTextureCoords[0] = new aiVector3D[mesh->mNumVertices]; + mesh->mNumUVComponents[0] = 2; + } + + // Build the final array + unsigned int cnt = 0; + for (FaceIdxArray::const_iterator it = fidx[i].begin(), end = fidx[i].end(); + it != end; ++it, ++faces) { + Mesh &curMesh = meshes[(*it).first]; + Face &face = curMesh.faces[(*it).second]; + faces->mNumIndices = (unsigned int)face.indices.size(); + faces->mIndices = new unsigned int[faces->mNumIndices]; + + aiVector3D faceNormal; + bool fnOK = false; + + for (unsigned int n = 0; n < faces->mNumIndices; ++n, ++cnt, ++norms, ++verts) { + if (face.indices[n] >= curMesh.verts.size()) { + ASSIMP_LOG_WARN("Quick3D: Vertex index overflow"); + face.indices[n] = 0; + } + + // copy vertices + *verts = curMesh.verts[face.indices[n]]; + + if (face.indices[n] >= curMesh.normals.size() && faces->mNumIndices >= 3) { + // we have no normal here - assign the face normal + if (!fnOK) { + const aiVector3D &pV1 = curMesh.verts[face.indices[0]]; + const aiVector3D &pV2 = curMesh.verts[face.indices[1]]; + const aiVector3D &pV3 = curMesh.verts[face.indices.size() - 1]; + faceNormal = (pV2 - pV1) ^ (pV3 - pV1).Normalize(); + fnOK = true; + } + *norms = faceNormal; + } else { + *norms = curMesh.normals[face.indices[n]]; + } + + // copy texture coordinates + if (uv && curMesh.uv.size()) { + if (curMesh.prevUVIdx != 0xffffffff && curMesh.uv.size() >= curMesh.verts.size()) // workaround + { + *uv = curMesh.uv[face.indices[n]]; + } else { + if (face.uvindices[n] >= curMesh.uv.size()) { + ASSIMP_LOG_WARN("Quick3D: Texture coordinate index overflow"); + face.uvindices[n] = 0; + } + *uv = curMesh.uv[face.uvindices[n]]; + } + uv->y = 1.f - uv->y; + ++uv; + } + + // setup the new vertex index + faces->mIndices[n] = cnt; + } + } + ++real; + } + + // Delete our nice helper array + delete[] fidx; + + // Now we need to attach the meshes to the root node of the scene + pScene->mRootNode->mNumMeshes = pScene->mNumMeshes; + pScene->mRootNode->mMeshes = new unsigned int[pScene->mNumMeshes]; + for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) + pScene->mRootNode->mMeshes[i] = i; + + /*pScene->mRootNode->mTransformation *= aiMatrix4x4( + 1.f, 0.f, 0.f, 0.f, + 0.f, -1.f,0.f, 0.f, + 0.f, 0.f, 1.f, 0.f, + 0.f, 0.f, 0.f, 1.f);*/ + + // Add cameras and light sources to the scene root node + pScene->mRootNode->mNumChildren = pScene->mNumLights + pScene->mNumCameras; + if (pScene->mRootNode->mNumChildren) { + pScene->mRootNode->mChildren = new aiNode *[pScene->mRootNode->mNumChildren]; + + // the light source + aiNode *nd = pScene->mRootNode->mChildren[0] = new aiNode(); + nd->mParent = pScene->mRootNode; + nd->mName.Set("Q3DLight"); + nd->mTransformation = pScene->mRootNode->mTransformation; + nd->mTransformation.Inverse(); + + // camera + nd = pScene->mRootNode->mChildren[1] = new aiNode(); + nd->mParent = pScene->mRootNode; + nd->mName.Set("Q3DCamera"); + nd->mTransformation = pScene->mRootNode->mChildren[0]->mTransformation; + } +} + +#endif // !! ASSIMP_BUILD_NO_Q3D_IMPORTER diff --git a/src/mesh/assimp-master/code/AssetLib/Q3D/Q3DLoader.h b/src/mesh/assimp-master/code/AssetLib/Q3D/Q3DLoader.h new file mode 100644 index 0000000..54af86d --- /dev/null +++ b/src/mesh/assimp-master/code/AssetLib/Q3D/Q3DLoader.h @@ -0,0 +1,116 @@ +/* +Open Asset Import Library (assimp) +---------------------------------------------------------------------- + +Copyright (c) 2006-2022, 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. +---------------------------------------------------------------------- +*/ + +/** @file Q3DLoader.h + * @brief Declaration of the Q3D importer class. + */ +#pragma once +#ifndef AI_Q3DLOADER_H_INCLUDED +#define AI_Q3DLOADER_H_INCLUDED + +#include <assimp/BaseImporter.h> +#include <assimp/types.h> +#include <vector> +#include <cstdint> + +namespace Assimp { + +// --------------------------------------------------------------------------- +/** Importer class for the Quick3D Object and Scene formats. +*/ +class Q3DImporter : public BaseImporter { +public: + Q3DImporter(); + ~Q3DImporter() override; + + // ------------------------------------------------------------------- + /** Returns whether the class can handle the format of the given file. + * See BaseImporter::CanRead() for details. */ + bool CanRead( const std::string& pFile, IOSystem* pIOHandler, + bool checkSig) const override; + +protected: + // ------------------------------------------------------------------- + /** Return importer meta information. + * See #BaseImporter::GetInfo for the details + */ + const aiImporterDesc* GetInfo () const override; + + // ------------------------------------------------------------------- + /** Imports the given file into the given scene structure. + * See BaseImporter::InternReadFile() for details + */ + void InternReadFile( const std::string& pFile, aiScene* pScene, + IOSystem* pIOHandler) override; + +private: + struct Material { + Material() : diffuse(0.6f,0.6f,0.6f), transparency(0.f), texIdx(UINT_MAX) { + // empty + } + + aiString name; + aiColor3D ambient, diffuse, specular; + float transparency; + unsigned int texIdx; + }; + + struct Face { + explicit Face(unsigned int s) : indices(s), uvindices(s), mat(0) { + // empty + } + + std::vector<unsigned int> indices; + std::vector<unsigned int> uvindices; + unsigned int mat; + }; + + struct Mesh { + std::vector<aiVector3D> verts; + std::vector<aiVector3D> normals; + std::vector<aiVector3D> uv; + std::vector<Face> faces; + uint32_t prevUVIdx; + }; +}; + +} // end of namespace Assimp + +#endif // AI_Q3DIMPORTER_H_IN |