v4games
/
assimp
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Refactoring: Some cleanups

pull/5320/head
Kim Kulling 2023-11-11 09:59:42 +01:00 committed by Kim Kulling
parent aa3abb3c06
commit 8cf2d6e588
64 changed files with 557 additions and 686 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
code/AssetLib/3DS/3DSLoader.cpp
View File

@ -56,7 +56,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
using namespace Assimp;
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"Discreet 3DS Importer",
"",
"",

2
code/AssetLib/3MF/D3MFImporter.cpp
View File

@ -68,7 +68,7 @@ namespace Assimp {
using namespace D3MF;
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"3mf Importer",
"",
"",

2
code/AssetLib/AC/ACLoader.cpp
View File

@ -62,7 +62,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
using namespace Assimp;
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"AC3D Importer",
"",
"",

2
code/AssetLib/AMF/AMFImporter.cpp
View File

@ -53,7 +53,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
namespace Assimp {
const aiImporterDesc AMFImporter::Description = {
static constexpr aiImporterDesc Description = {
"Additive manufacturing file format(AMF) Importer",
"smalcom",
"",

103
code/AssetLib/AMF/AMFImporter.hpp
View File

@ -98,8 +98,12 @@ namespace Assimp {
/// old - <map> and children <u1>, <u2>, <u3>, <v1>, <v2>, <v3>
///
class AMFImporter : public BaseImporter {
private:
struct SPP_Material; // forward declaration
using AMFMetaDataArray = std::vector<AMFMetadata *>;
using MeshArray = std::vector<aiMesh *>;
using NodeArray = std::vector<aiNode *>;
public:
struct SPP_Material;
/// Data type for post-processing step. More suitable container for part of material's composition.
struct SPP_Composite {
@ -107,22 +111,6 @@ private:
std::string Formula; ///< Formula for calculating ratio of \ref Material.
};
/// \struct SPP_Material
/// Data type for post-processing step. More suitable container for material.
struct SPP_Material {
std::string ID; ///< Material ID.
std::list<AMFMetadata *> Metadata; ///< Metadata of material.
AMFColor *Color; ///< Color of material.
std::list<SPP_Composite> Composition; ///< List of child materials if current material is composition of few another.
/// Return color calculated for specified coordinate.
/// \param [in] pX - "x" coordinate.
/// \param [in] pY - "y" coordinate.
/// \param [in] pZ - "z" coordinate.
/// \return calculated color.
aiColor4D GetColor(const float pX, const float pY, const float pZ) const;
};
/// Data type for post-processing step. More suitable container for texture.
struct SPP_Texture {
std::string ID;
@ -139,10 +127,52 @@ private:
const AMFTexMap *TexMap; ///< Face texture mapping data. Equal to nullptr if texture mapping is not set for the face.
};
using AMFMetaDataArray = std::vector<AMFMetadata*>;
using MeshArray = std::vector<aiMesh*>;
using NodeArray = std::vector<aiNode*>;
/// Data type for post-processing step. More suitable container for material.
struct SPP_Material {
std::string ID; ///< Material ID.
std::list<AMFMetadata *> Metadata; ///< Metadata of material.
AMFColor *Color; ///< Color of material.
std::list<SPP_Composite> Composition; ///< List of child materials if current material is composition of few another.
/// Return color calculated for specified coordinate.
/// \param [in] pX - "x" coordinate.
/// \param [in] pY - "y" coordinate.
/// \param [in] pZ - "z" coordinate.
/// \return calculated color.
aiColor4D GetColor(const float pX, const float pY, const float pZ) const;
};
/// Default constructor.
AMFImporter() AI_NO_EXCEPT;
/// Default destructor.
~AMFImporter() override;
/// Parse AMF file and fill scene graph. The function has no return value. Result can be found by analyzing the generated graph.
/// Also exception can be thrown if trouble will found.
/// \param [in] pFile - name of file to be parsed.
/// \param [in] pIOHandler - pointer to IO helper object.
void ParseFile(const std::string &pFile, IOSystem *pIOHandler);
void ParseHelper_Node_Enter(AMFNodeElementBase *child);
void ParseHelper_Node_Exit();
bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool pCheckSig) const override;
void InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) override;
const aiImporterDesc *GetInfo() const override;
bool Find_NodeElement(const std::string &pID, const AMFNodeElementBase::EType pType, AMFNodeElementBase **pNodeElement) const;
bool Find_ConvertedNode(const std::string &pID, NodeArray &nodeArray, aiNode **pNode) const;
bool Find_ConvertedMaterial(const std::string &pID, const SPP_Material **pConvertedMaterial) const;
AI_WONT_RETURN void Throw_CloseNotFound(const std::string &nodeName) AI_WONT_RETURN_SUFFIX;
AI_WONT_RETURN void Throw_IncorrectAttr(const std::string &nodeName, const std::string &pAttrName) AI_WONT_RETURN_SUFFIX;
AI_WONT_RETURN void Throw_IncorrectAttrValue(const std::string &nodeName, const std::string &pAttrName) AI_WONT_RETURN_SUFFIX;
AI_WONT_RETURN void Throw_MoreThanOnceDefined(const std::string &nodeName, const std::string &pNodeType, const std::string &pDescription) AI_WONT_RETURN_SUFFIX;
AI_WONT_RETURN void Throw_ID_NotFound(const std::string &pID) const AI_WONT_RETURN_SUFFIX;
void XML_CheckNode_MustHaveChildren(pugi::xml_node &node);
bool XML_SearchNode(const std::string &nodeName);
void ParseHelper_FixTruncatedFloatString(const char *pInStr, std::string &pOutString);
AMFImporter(const AMFImporter &pScene) = delete;
AMFImporter &operator=(const AMFImporter &pScene) = delete;
private:
/// Clear all temporary data.
void Clear();
@ -262,40 +292,9 @@ private:
/// \param [in] pUseOldName - if true then use old name of node(and children) - <map>, instead of new name - <texmap>.
void ParseNode_TexMap(XmlNode &node, const bool pUseOldName = false);
public:
/// Default constructor.
AMFImporter() AI_NO_EXCEPT;
/// Default destructor.
~AMFImporter() override;
/// Parse AMF file and fill scene graph. The function has no return value. Result can be found by analyzing the generated graph.
/// Also exception can be thrown if trouble will found.
/// \param [in] pFile - name of file to be parsed.
/// \param [in] pIOHandler - pointer to IO helper object.
void ParseFile(const std::string &pFile, IOSystem *pIOHandler);
void ParseHelper_Node_Enter(AMFNodeElementBase *child);
void ParseHelper_Node_Exit();
bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool pCheckSig) const override;
void InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) override;
const aiImporterDesc *GetInfo() const override;
bool Find_NodeElement(const std::string &pID, const AMFNodeElementBase::EType pType, AMFNodeElementBase **pNodeElement) const;
bool Find_ConvertedNode(const std::string &pID, NodeArray &nodeArray, aiNode **pNode) const;
bool Find_ConvertedMaterial(const std::string &pID, const SPP_Material **pConvertedMaterial) const;
AI_WONT_RETURN void Throw_CloseNotFound(const std::string &nodeName) AI_WONT_RETURN_SUFFIX;
AI_WONT_RETURN void Throw_IncorrectAttr(const std::string &nodeName, const std::string &pAttrName) AI_WONT_RETURN_SUFFIX;
AI_WONT_RETURN void Throw_IncorrectAttrValue(const std::string &nodeName, const std::string &pAttrName) AI_WONT_RETURN_SUFFIX;
AI_WONT_RETURN void Throw_MoreThanOnceDefined(const std::string &nodeName, const std::string &pNodeType, const std::string &pDescription) AI_WONT_RETURN_SUFFIX;
AI_WONT_RETURN void Throw_ID_NotFound(const std::string &pID) const AI_WONT_RETURN_SUFFIX;
void XML_CheckNode_MustHaveChildren(pugi::xml_node &node);
bool XML_SearchNode(const std::string &nodeName);
void ParseHelper_FixTruncatedFloatString(const char *pInStr, std::string &pOutString);
AMFImporter(const AMFImporter &pScene) = delete;
AMFImporter &operator=(const AMFImporter &pScene) = delete;
private:
static const aiImporterDesc Description;
AMFNodeElementBase *mNodeElement_Cur; ///< Current element.
std::list<AMFNodeElementBase *> mNodeElement_List; ///< All elements of scene graph.
XmlParser *mXmlParser;

2
code/AssetLib/ASE/ASELoader.cpp
View File

@ -66,7 +66,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
using namespace Assimp;
using namespace Assimp::ASE;
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"ASE Importer",
"",
"",

2
code/AssetLib/Assbin/AssbinLoader.cpp
View File

@ -65,7 +65,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
using namespace Assimp;
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"Assimp Binary Importer",
"Gargaj / Conspiracy",
"",

2
code/AssetLib/B3D/B3DImporter.cpp
View File

@ -62,7 +62,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
using namespace Assimp;
using namespace std;
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"BlitzBasic 3D Importer",
"",
"",

2
code/AssetLib/BVH/BVHLoader.cpp
View File

@ -58,7 +58,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
using namespace Assimp;
using namespace Assimp::Formatter;
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"BVH Importer (MoCap)",
"",
"",

7
code/AssetLib/Blender/BlenderLoader.cpp
View File

@ -69,11 +69,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// zlib is needed for compressed blend files
#ifndef ASSIMP_BUILD_NO_COMPRESSED_BLEND
#include "Common/Compression.h"
/* #ifdef ASSIMP_BUILD_NO_OWN_ZLIB
# include <zlib.h>
# else
# include "../contrib/zlib/zlib.h"
# endif*/
#endif
namespace Assimp {
@ -89,7 +84,7 @@ using namespace Assimp;
using namespace Assimp::Blender;
using namespace Assimp::Formatter;
static const aiImporterDesc blenderDesc = {
static constexpr aiImporterDesc blenderDesc = {
"Blender 3D Importer (http://www.blender3d.org)",
"",
"",

12
code/AssetLib/COB/COBLoader.cpp
View File

@ -65,7 +65,7 @@ using namespace Assimp;
using namespace Assimp::COB;
using namespace Assimp::Formatter;
static const float units[] = {
static constexpr float units[] = {
1000.f,
100.f,
1.f,
@ -76,7 +76,7 @@ static const float units[] = {
1.f / 1609.344f
};
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"TrueSpace Object Importer",
"",
"",
@ -89,14 +89,6 @@ static const aiImporterDesc desc = {
"cob scn"
};
// ------------------------------------------------------------------------------------------------
// Constructor to be privately used by Importer
COBImporter::COBImporter() = default;
// ------------------------------------------------------------------------------------------------
// Destructor, private as well
COBImporter::~COBImporter() = default;
// ------------------------------------------------------------------------------------------------
// Returns whether the class can handle the format of the given file.
bool COBImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {

16
code/AssetLib/COB/COBLoader.h
View File

@ -56,16 +56,16 @@ class LineSplitter;
// TinyFormatter.h
namespace Formatter {
template <typename T, typename TR, typename A>
class basic_formatter;
typedef class basic_formatter<char, std::char_traits<char>, std::allocator<char>> format;
template <typename T, typename TR, typename A>
class basic_formatter;
typedef class basic_formatter<char, std::char_traits<char>, std::allocator<char>> format;
} // namespace Formatter
// COBScene.h
namespace COB {
struct ChunkInfo;
struct Node;
struct Scene;
struct ChunkInfo;
struct Node;
struct Scene;
} // namespace COB
// -------------------------------------------------------------------------------------------
@ -75,8 +75,8 @@ struct Scene;
// -------------------------------------------------------------------------------------------
class COBImporter : public BaseImporter {
public:
COBImporter();
~COBImporter() override;
COBImporter() = default;
~COBImporter() override = default;
// --------------------
bool CanRead(const std::string &pFile, IOSystem *pIOHandler,

15
code/AssetLib/CSM/CSMLoader.cpp
View File

@ -44,9 +44,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
/** @file CSMLoader.cpp
* Implementation of the CSM importer class.
*/
#ifndef ASSIMP_BUILD_NO_CSM_IMPORTER
#include "CSMLoader.h"
@ -63,7 +60,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
using namespace Assimp;
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"CharacterStudio Motion Importer (MoCap)",
"",
"",
@ -79,13 +76,9 @@ static const aiImporterDesc desc = {
// ------------------------------------------------------------------------------------------------
// Constructor to be privately used by Importer
CSMImporter::CSMImporter()
: noSkeletonMesh()
{}
// ------------------------------------------------------------------------------------------------
// Destructor, private as well
CSMImporter::~CSMImporter() = default;
CSMImporter::CSMImporter() : noSkeletonMesh(){
// empty
}
// ------------------------------------------------------------------------------------------------
// Returns whether the class can handle the format of the given file.

7
code/AssetLib/CSM/CSMLoader.h
View File

@ -61,7 +61,7 @@ namespace Assimp {
class CSMImporter : public BaseImporter {
public:
CSMImporter();
~CSMImporter() override;
~CSMImporter() override = default;
// -------------------------------------------------------------------
bool CanRead(const std::string &pFile, IOSystem *pIOHandler,
@ -81,9 +81,8 @@ protected:
private:
bool noSkeletonMesh;
}; // end of class CSMImporter
};
} // end of namespace Assimp
} // namespace Assimp
#endif // AI_AC3DIMPORTER_H_INC

6
code/AssetLib/Collada/ColladaLoader.cpp
View File

@ -64,7 +64,7 @@ namespace Assimp {
using namespace Assimp::Formatter;
using namespace Assimp::Collada;
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"Collada Importer",
"",
"",
@ -101,10 +101,6 @@ ColladaLoader::ColladaLoader() :
// empty
}
// ------------------------------------------------------------------------------------------------
// Destructor, private as well
ColladaLoader::~ColladaLoader() = default;
// ------------------------------------------------------------------------------------------------
// Returns whether the class can handle the format of the given file.
bool ColladaLoader::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {

2
code/AssetLib/Collada/ColladaLoader.h
View File

@ -86,7 +86,7 @@ public:
ColladaLoader();
/// The class destructor.
~ColladaLoader() override;
~ColladaLoader() override = default;
/// Returns whether the class can handle the format of the given file.
/// @see BaseImporter::CanRead() for more details.

4
code/AssetLib/DXF/DXFLoader.cpp
View File

@ -70,7 +70,7 @@ static const aiColor4D AI_DXF_DEFAULT_COLOR(aiColor4D(0.6f, 0.6f, 0.6f, 0.6f));
// color indices for DXF - 16 are supported, the table is
// taken directly from the DXF spec.
static aiColor4D g_aclrDxfIndexColors[] = {
static const aiColor4D g_aclrDxfIndexColors[] = {
aiColor4D(0.6f, 0.6f, 0.6f, 1.0f),
aiColor4D (1.0f, 0.0f, 0.0f, 1.0f), // red
aiColor4D (0.0f, 1.0f, 0.0f, 1.0f), // green
@ -97,7 +97,7 @@ static const int GroupCode_XComp = 10;
static const int GroupCode_YComp = 20;
static const int GroupCode_ZComp = 30;
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"Drawing Interchange Format (DXF) Importer",
"",
"",

9
code/AssetLib/FBX/FBXImporter.cpp
View File

@ -72,8 +72,7 @@ using namespace Assimp::Formatter;
using namespace Assimp::FBX;
namespace {
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"Autodesk FBX Importer",
"",
"",
@ -84,13 +83,9 @@ static const aiImporterDesc desc = {
0,
0,
"fbx"
};
};
}
// ------------------------------------------------------------------------------------------------
// Constructor to be privately used by #Importer
FBXImporter::FBXImporter() = default;
// ------------------------------------------------------------------------------------------------
// Returns whether the class can handle the format of the given file.
bool FBXImporter::CanRead(const std::string & pFile, IOSystem * pIOHandler, bool /*checkSig*/) const {

2
code/AssetLib/FBX/FBXImporter.h
View File

@ -70,7 +70,7 @@ typedef class basic_formatter<char, std::char_traits<char>, std::allocator<char>
class FBXImporter : public BaseImporter, public LogFunctions<FBXImporter> {
public:
/// @brief The class constructor.
FBXImporter();
FBXImporter() = default;
/// @brief The class destructor, default implementation.
~FBXImporter() override = default;

2
code/AssetLib/HMP/HMPLoader.cpp
View File

@ -57,7 +57,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
using namespace Assimp;
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"3D GameStudio Heightmap (HMP) Importer",
"",
"",

2
code/AssetLib/IFC/IFCLoader.cpp
View File

@ -103,7 +103,7 @@ void ConvertUnit(const ::Assimp::STEP::EXPRESS::DataType &dt, ConversionData &co
} // namespace
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"Industry Foundation Classes (IFC) Importer",
"",
"",

3
code/AssetLib/IQM/IQMImporter.cpp
View File

@ -59,7 +59,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// http://sauerbraten.org/iqm/
// https://github.com/lsalzman/iqm
inline void swap_block( uint32_t *block, size_t size ){
(void)block; // suppress 'unreferenced formal parameter' MSVC warning
size >>= 2;
@ -67,7 +66,7 @@ inline void swap_block( uint32_t *block, size_t size ){
AI_SWAP4( block[ i ] );
}
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"Inter-Quake Model Importer",
"",
"",

2
code/AssetLib/Irr/IRRLoader.cpp
View File

@ -66,7 +66,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
using namespace Assimp;
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"Irrlicht Scene Reader",
"",
"",

2
code/AssetLib/Irr/IRRMeshLoader.cpp
View File

@ -56,7 +56,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
using namespace Assimp;
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"Irrlicht Mesh Reader",
"",
"",

105
code/AssetLib/LWO/LWOBLoader.cpp
View File

@ -51,64 +51,56 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "LWOLoader.h"
using namespace Assimp;
// ------------------------------------------------------------------------------------------------
void LWOImporter::LoadLWOBFile()
{
void LWOImporter::LoadLWOBFile() {
LE_NCONST uint8_t* const end = mFileBuffer + fileSize;
bool running = true;
while (running)
{
if (mFileBuffer + sizeof(IFF::ChunkHeader) > end)break;
while (running) {
if (mFileBuffer + sizeof(IFF::ChunkHeader) > end)
break;
const IFF::ChunkHeader head = IFF::LoadChunk(mFileBuffer);
if (mFileBuffer + head.length > end)
{
if (mFileBuffer + head.length > end) {
throw DeadlyImportError("LWOB: Invalid chunk length");
}
uint8_t* const next = mFileBuffer+head.length;
switch (head.type)
{
switch (head.type) {
// vertex list
case AI_LWO_PNTS:
{
case AI_LWO_PNTS: {
if (!mCurLayer->mTempPoints.empty())
ASSIMP_LOG_WARN("LWO: PNTS chunk encountered twice");
else LoadLWOPoints(head.length);
break;
}
// face list
case AI_LWO_POLS:
{
else
LoadLWOPoints(head.length);
} break;
case AI_LWO_POLS: { // face list
if (!mCurLayer->mFaces.empty())
ASSIMP_LOG_WARN("LWO: POLS chunk encountered twice");
else LoadLWOBPolygons(head.length);
break;
}
// list of tags
case AI_LWO_SRFS:
else
LoadLWOBPolygons(head.length);
} break;
case AI_LWO_SRFS: // list of tags
{
if (!mTags->empty())
ASSIMP_LOG_WARN("LWO: SRFS chunk encountered twice");
else LoadLWOTags(head.length);
break;
}
else
LoadLWOTags(head.length);
} break;
// surface chunk
case AI_LWO_SURF:
case AI_LWO_SURF: // surface chunk
{
LoadLWOBSurface(head.length);
} break;
default:
break;
}
}
mFileBuffer = next;
}
}
// ------------------------------------------------------------------------------------------------
void LWOImporter::LoadLWOBPolygons(unsigned int length)
{
void LWOImporter::LoadLWOBPolygons(unsigned int length) {
// first find out how many faces and vertices we'll finally need
LE_NCONST uint16_t* const end = (LE_NCONST uint16_t*)(mFileBuffer+length);
LE_NCONST uint16_t* cursor = (LE_NCONST uint16_t*)mFileBuffer;
@ -123,8 +115,7 @@ void LWOImporter::LoadLWOBPolygons(unsigned int length)
CountVertsAndFacesLWOB(iNumVertices,iNumFaces,cursor,end);
// allocate the output array and copy face indices
if (iNumFaces)
{
if (iNumFaces) {
cursor = (LE_NCONST uint16_t*)mFileBuffer;
mCurLayer->mFaces.resize(iNumFaces);
@ -135,10 +126,8 @@ void LWOImporter::LoadLWOBPolygons(unsigned int length)
// ------------------------------------------------------------------------------------------------
void LWOImporter::CountVertsAndFacesLWOB(unsigned int& verts, unsigned int& faces,
LE_NCONST uint16_t*& cursor, const uint16_t* const end, unsigned int max)
{
while (cursor < end && max--)
{
LE_NCONST uint16_t*& cursor, const uint16_t* const end, unsigned int max) {
while (cursor < end && max--) {
uint16_t numIndices;
// must have 2 shorts left for numIndices and surface
if (end - cursor < 2) {
@ -154,8 +143,7 @@ void LWOImporter::CountVertsAndFacesLWOB(unsigned int& verts, unsigned int& face
cursor += numIndices;
int16_t surface;
::memcpy(&surface, cursor++, 2);
if (surface < 0)
{
if (surface < 0) {
// there are detail polygons
::memcpy(&numIndices, cursor++, 2);
CountVertsAndFacesLWOB(verts,faces,cursor,end,numIndices);
@ -167,18 +155,14 @@ void LWOImporter::CountVertsAndFacesLWOB(unsigned int& verts, unsigned int& face
void LWOImporter::CopyFaceIndicesLWOB(FaceList::iterator& it,
LE_NCONST uint16_t*& cursor,
const uint16_t* const end,
unsigned int max)
{
while (cursor < end && max--)
{
unsigned int max) {
while (cursor < end && max--) {
LWO::Face& face = *it;++it;
uint16_t numIndices;
::memcpy(&numIndices, cursor++, 2);
face.mNumIndices = numIndices;
if(face.mNumIndices)
{
if (cursor + face.mNumIndices >= end)
{
if(face.mNumIndices) {
if (cursor + face.mNumIndices >= end) {
break;
}
face.mIndices = new unsigned int[face.mNumIndices];
@ -187,8 +171,7 @@ void LWOImporter::CopyFaceIndicesLWOB(FaceList::iterator& it,
uint16_t index;
::memcpy(&index, cursor++, 2);
mi = index;
if (mi > mCurLayer->mTempPoints.size())
{
if (mi > mCurLayer->mTempPoints.size()) {
ASSIMP_LOG_WARN("LWOB: face index is out of range");
mi = (unsigned int)mCurLayer->mTempPoints.size()-1;
}
@ -198,15 +181,13 @@ void LWOImporter::CopyFaceIndicesLWOB(FaceList::iterator& it,
}
int16_t surface;
::memcpy(&surface, cursor++, 2);
if (surface < 0)
{
if (surface < 0) {
surface = -surface;
// there are detail polygons.
uint16_t numPolygons;
::memcpy(&numPolygons, cursor++, 2);
if (cursor < end)
{
if (cursor < end) {
CopyFaceIndicesLWOB(it,cursor,end,numPolygons);
}
}
@ -215,8 +196,7 @@ void LWOImporter::CopyFaceIndicesLWOB(FaceList::iterator& it,
}
// ------------------------------------------------------------------------------------------------
LWO::Texture* LWOImporter::SetupNewTextureLWOB(LWO::TextureList& list,unsigned int size)
{
LWO::Texture* LWOImporter::SetupNewTextureLWOB(LWO::TextureList& list,unsigned int size) {
list.emplace_back();
LWO::Texture* tex = &list.back();
@ -224,8 +204,7 @@ LWO::Texture* LWOImporter::SetupNewTextureLWOB(LWO::TextureList& list,unsigned i
GetS0(type,size);
const char* s = type.c_str();
if(strstr(s, "Image Map"))
{
if(strstr(s, "Image Map")) {
// Determine mapping type
if(strstr(s, "Planar"))
tex->mapMode = LWO::Texture::Planar;
@ -237,9 +216,7 @@ LWO::Texture* LWOImporter::SetupNewTextureLWOB(LWO::TextureList& list,unsigned i
tex->mapMode = LWO::Texture::Cubic;
else if(strstr(s, "Front"))
tex->mapMode = LWO::Texture::FrontProjection;
}
else
{
} else {
// procedural or gradient, not supported
ASSIMP_LOG_ERROR("LWOB: Unsupported legacy texture: ", type);
}
@ -248,8 +225,7 @@ LWO::Texture* LWOImporter::SetupNewTextureLWOB(LWO::TextureList& list,unsigned i
}
// ------------------------------------------------------------------------------------------------
void LWOImporter::LoadLWOBSurface(unsigned int size)
{
void LWOImporter::LoadLWOBSurface(unsigned int size) {
LE_NCONST uint8_t* const end = mFileBuffer + size;
mSurfaces->push_back( LWO::Surface () );
@ -277,8 +253,7 @@ void LWOImporter::LoadLWOBSurface(unsigned int size)
}
uint8_t* const next = mFileBuffer+head.length;
switch (head.type)
{
switch (head.type) {
// diffuse color
case AI_LWO_COLR:
{

6
code/AssetLib/LWS/LWSLoader.cpp
View File

@ -63,7 +63,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
using namespace Assimp;
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"LightWave Scene Importer",
"",
"",
@ -139,10 +139,6 @@ LWSImporter::LWSImporter() :
// nothing to do here
}
// ------------------------------------------------------------------------------------------------
// Destructor, private as well
LWSImporter::~LWSImporter() = default;
// ------------------------------------------------------------------------------------------------
// Returns whether the class can handle the format of the given file.
bool LWSImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {

2
code/AssetLib/LWS/LWSLoader.h
View File

@ -174,7 +174,7 @@ struct NodeDesc {
class LWSImporter : public BaseImporter {
public:
LWSImporter();
~LWSImporter() override;
~LWSImporter() override = default;
// -------------------------------------------------------------------
// Check whether we can read a specific file

2
code/AssetLib/M3D/M3DImporter.cpp
View File

@ -85,7 +85,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
are listed in aiScene->mRootNode->children, but all without meshes
*/
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"Model 3D Importer",
"",
"",

11
code/AssetLib/MD2/MD2Loader.cpp
View File

@ -5,8 +5,6 @@ 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,
@ -41,7 +39,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------------
*/
#ifndef ASSIMP_BUILD_NO_MD2_IMPORTER
/** @file Implementation of the MD2 importer class */
@ -65,7 +62,7 @@ using namespace Assimp::MD2;
# define ARRAYSIZE(_array) (int(sizeof(_array) / sizeof(_array[0])))
#endif
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"Quake II Mesh Importer",
"",
"",
@ -79,7 +76,7 @@ static const aiImporterDesc desc = {
};
// ------------------------------------------------------------------------------------------------
// Helper function to lookup a normal in Quake 2's precalculated table
// Helper function to lookup a normal in Quake 2's pre-calculated table
void MD2::LookupNormalIndex(uint8_t iNormalIndex,aiVector3D& vOut)
{
// make sure the normal index has a valid value
@ -100,10 +97,6 @@ MD2Importer::MD2Importer()
fileSize()
{}
// ------------------------------------------------------------------------------------------------
// Destructor, private as well
MD2Importer::~MD2Importer() = default;
// ------------------------------------------------------------------------------------------------
// Returns whether the class can handle the format of the given file.
bool MD2Importer::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool /*checkSig*/) const

2
code/AssetLib/MD2/MD2Loader.h
View File

@ -63,7 +63,7 @@ using namespace MD2;
class MD2Importer : public BaseImporter {
public:
MD2Importer();
~MD2Importer() override;
~MD2Importer() override = default;
// -------------------------------------------------------------------
/** Returns whether the class can handle the format of the given file.

2
code/AssetLib/MD3/MD3Loader.cpp
View File

@ -70,7 +70,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
using namespace Assimp;
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"Quake III Mesh Importer",
"",
"",

6
code/AssetLib/MD5/MD5Loader.cpp
View File

@ -64,7 +64,7 @@ using namespace Assimp;
// Minimum weight value. Weights inside [-n ... n] are ignored
#define AI_MD5_WEIGHT_EPSILON Math::getEpsilon<float>()
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"Doom 3 / MD5 Mesh Importer",
"",
"",
@ -92,10 +92,6 @@ MD5Importer::MD5Importer() :
// empty
}
// ------------------------------------------------------------------------------------------------
// Destructor, private as well
MD5Importer::~MD5Importer() = default;
// ------------------------------------------------------------------------------------------------
// Returns whether the class can handle the format of the given file.
bool MD5Importer::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {

2
code/AssetLib/MD5/MD5Loader.h
View File

@ -65,7 +65,7 @@ using namespace Assimp::MD5;
class MD5Importer : public BaseImporter {
public:
MD5Importer();
~MD5Importer() override;
~MD5Importer() override = default;
// -------------------------------------------------------------------
/** Returns whether the class can handle the format of the given file.

6
code/AssetLib/MDC/MDCLoader.cpp
View File

@ -60,7 +60,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
using namespace Assimp;
using namespace Assimp::MDC;
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"Return To Castle Wolfenstein Mesh Importer",
"",
"",
@ -103,10 +103,6 @@ MDCImporter::MDCImporter() :
// empty
}
// ------------------------------------------------------------------------------------------------
// Destructor, private as well
MDCImporter::~MDCImporter() = default;
// ------------------------------------------------------------------------------------------------
// Returns whether the class can handle the format of the given file.
bool MDCImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {

2
code/AssetLib/MDC/MDCLoader.h
View File

@ -62,7 +62,7 @@ using namespace MDC;
class MDCImporter : public BaseImporter {
public:
MDCImporter();
~MDCImporter() override;
~MDCImporter() override = default;
// -------------------------------------------------------------------
/** Returns whether the class can handle the format of the given file.

6
code/AssetLib/MDL/MDLLoader.cpp
View File

@ -65,7 +65,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
using namespace Assimp;
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"Quake Mesh / 3D GameStudio Mesh Importer",
"",
"",
@ -96,10 +96,6 @@ MDLImporter::MDLImporter() :
// empty
}
// ------------------------------------------------------------------------------------------------
// Destructor, private as well
MDLImporter::~MDLImporter() = default;
// ------------------------------------------------------------------------------------------------
// Returns whether the class can handle the format of the given file.
bool MDLImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {

11
code/AssetLib/MDL/MDLLoader.h
View File

@ -39,10 +39,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------
*/
/** @file MDLLoader.h
* @brief Declaration of the loader for MDL files
*/
/// @file MDLLoader.h
/// @brief Declaration of the loader for MDL files
#pragma once
#ifndef AI_MDLLOADER_H_INCLUDED
#define AI_MDLLOADER_H_INCLUDED
@ -83,11 +81,10 @@ using namespace MDL;
* them all with a single 1000-line function-beast. However, it has been
* split into several code paths to make the code easier to read and maintain.
*/
class MDLImporter : public BaseImporter
{
class MDLImporter : public BaseImporter {
public:
MDLImporter();
~MDLImporter() override;
~MDLImporter() override = default;
// -------------------------------------------------------------------
/** Returns whether the class can handle the format of the given file.

6
code/AssetLib/MMD/MMDImporter.cpp
View File

@ -57,7 +57,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <memory>
#include <sstream>
static const aiImporterDesc desc = { "MMD Importer",
static constexpr aiImporterDesc desc = { "MMD Importer",
"",
"",
"surfaces supported?",
@ -81,10 +81,6 @@ MMDImporter::MMDImporter() :
m_strAbsPath = io.getOsSeparator();
}
// ------------------------------------------------------------------------------------------------
// Destructor.
MMDImporter::~MMDImporter() = default;
// ------------------------------------------------------------------------------------------------
// Returns true, if file is an pmx file.
bool MMDImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler,

26
code/AssetLib/MMD/MMDImporter.h
View File

@ -50,46 +50,34 @@ struct aiMesh;
namespace Assimp {
// ------------------------------------------------------------------------------------------------
/// \class MMDImporter
/// \brief Imports MMD a pmx/pmd/vmd file
/// @class MMDImporter
/// @brief Imports MMD a pmx/pmd/vmd file
// ------------------------------------------------------------------------------------------------
class MMDImporter : public BaseImporter {
public:
/// \brief Default constructor
/// @brief Default constructor
MMDImporter();
/// \brief Destructor
~MMDImporter() override;
/// @brief Destructor
~MMDImporter() override = default;
public:
/// \brief Returns whether the class can handle the format of the given file.
/// \remark See BaseImporter::CanRead() for details.
/// @brief Returns whether the class can handle the format of the given file.
/// @remark See BaseImporter::CanRead() for details.
bool CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const override;
private:
//! \brief Appends the supported extension.
const aiImporterDesc* GetInfo() const override;
//! \brief File import implementation.
void InternReadFile(const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) override;
//! \brief Create the data from imported content.
void CreateDataFromImport(const pmx::PmxModel* pModel, aiScene* pScene);
//! \brief Create the mesh
aiMesh* CreateMesh(const pmx::PmxModel* pModel, const int indexStart, const int indexCount);
//! \brief Create the material
aiMaterial* CreateMaterial(const pmx::PmxMaterial* pMat, const pmx::PmxModel* pModel);
private:
//! Data buffer
std::vector<char> m_Buffer;
//! Absolute pathname of model in file system
std::string m_strAbsPath;
};
// ------------------------------------------------------------------------------------------------
} // Namespace Assimp

5
code/AssetLib/MS3D/MS3DLoader.cpp
View File

@ -60,7 +60,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
using namespace Assimp;
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"Milkshape 3D Importer",
"",
"",
@ -84,9 +84,6 @@ MS3DImporter::MS3DImporter()
: mScene()
{}
// ------------------------------------------------------------------------------------------------
// Destructor, private as well
MS3DImporter::~MS3DImporter() = default;
// ------------------------------------------------------------------------------------------------
// Returns whether the class can handle the format of the given file.
bool MS3DImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool /*checkSig*/) const

3
code/AssetLib/MS3D/MS3DLoader.h
View File

@ -48,6 +48,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <assimp/BaseImporter.h>
#include <assimp/StreamReader.h>
struct aiNode;
namespace Assimp {
@ -58,7 +59,7 @@ namespace Assimp {
class MS3DImporter : public BaseImporter {
public:
MS3DImporter();
~MS3DImporter() override;
~MS3DImporter() override = default;
// -------------------------------------------------------------------
/** Returns whether the class can handle the format of the given file.

12
code/AssetLib/NDO/NDOLoader.cpp
View File

@ -43,8 +43,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* Implementation of the NDO importer class.
*/
#ifndef ASSIMP_BUILD_NO_NDO_IMPORTER
#include "NDOLoader.h"
#include <assimp/DefaultLogger.hpp>
#include <assimp/IOSystem.hpp>
@ -56,7 +56,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
using namespace Assimp;
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"Nendo Mesh Importer",
"",
"",
@ -69,14 +69,6 @@ static const aiImporterDesc desc = {
"ndo"
};
// ------------------------------------------------------------------------------------------------
// Constructor to be privately used by Importer
NDOImporter::NDOImporter() = default;
// ------------------------------------------------------------------------------------------------
// Destructor, private as well
NDOImporter::~NDOImporter() = default;
// ------------------------------------------------------------------------------------------------
// Returns whether the class can handle the format of the given file.
bool NDOImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool /*checkSig*/) const

4
code/AssetLib/NDO/NDOLoader.h
View File

@ -65,8 +65,8 @@ class Importer;
*/
class NDOImporter : public BaseImporter {
public:
NDOImporter();
~NDOImporter() override;
NDOImporter() = default;
~NDOImporter() override = default;
//! Represents a single edge
struct Edge {

35
code/AssetLib/NFF/NFFLoader.cpp
View File

@ -56,9 +56,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <assimp/IOSystem.hpp>
#include <memory>
using namespace Assimp;
namespace Assimp {
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"Neutral File Format Importer",
"",
"",
@ -71,14 +71,6 @@ static const aiImporterDesc desc = {
"enff nff"
};
// ------------------------------------------------------------------------------------------------
// Constructor to be privately used by Importer
NFFImporter::NFFImporter() = default;
// ------------------------------------------------------------------------------------------------
// Destructor, private as well
NFFImporter::~NFFImporter() = default;
// ------------------------------------------------------------------------------------------------
// Returns whether the class can handle the format of the given file.
bool NFFImporter::CanRead(const std::string & pFile, IOSystem * /*pIOHandler*/, bool /*checkSig*/) const {
@ -94,7 +86,7 @@ const aiImporterDesc *NFFImporter::GetInfo() const {
// ------------------------------------------------------------------------------------------------
#define AI_NFF_PARSE_FLOAT(f) \
SkipSpaces(&sz); \
if (!::IsLineEnd(*sz)) sz = fast_atoreal_move<ai_real>(sz, (ai_real &)f);
if (!IsLineEnd(*sz)) sz = fast_atoreal_move<ai_real>(sz, (ai_real &)f);
// ------------------------------------------------------------------------------------------------
#define AI_NFF_PARSE_TRIPLE(v) \
@ -338,8 +330,8 @@ void NFFImporter::InternReadFile(const std::string &pFile,
break;
}
// read the numbr of vertices
unsigned int num = ::strtoul10(sz, &sz);
// read the number of vertices
unsigned int num = strtoul10(sz, &sz);
// temporary storage
std::vector<aiColor4D> tempColors;
@ -365,7 +357,7 @@ void NFFImporter::InternReadFile(const std::string &pFile,
// color definition
if (TokenMatch(sz, "0x", 2)) {
hasColor = true;
unsigned int numIdx = ::strtoul16(sz, &sz);
unsigned int numIdx = strtoul16(sz, &sz);
aiColor4D clr;
clr.a = 1.f;
@ -403,15 +395,16 @@ void NFFImporter::InternReadFile(const std::string &pFile,
}
AI_NFF2_GET_NEXT_TOKEN();
if (!num) throw DeadlyImportError("NFF2: There are zero vertices");
num = ::strtoul10(sz, &sz);
if (!num)
throw DeadlyImportError("NFF2: There are zero vertices");
num = strtoul10(sz, &sz);
std::vector<unsigned int> tempIdx;
tempIdx.reserve(10);
for (unsigned int i = 0; i < num; ++i) {
AI_NFF2_GET_NEXT_TOKEN();
SkipSpaces(line, &sz);
unsigned int numIdx = ::strtoul10(sz, &sz);
unsigned int numIdx = strtoul10(sz, &sz);
// read all faces indices
if (numIdx) {
@ -421,7 +414,7 @@ void NFFImporter::InternReadFile(const std::string &pFile,
for (unsigned int a = 0; a < numIdx; ++a) {
SkipSpaces(sz, &sz);
unsigned int m = ::strtoul10(sz, &sz);
unsigned int m = strtoul10(sz, &sz);
if (m >= (unsigned int)tempPositions.size()) {
ASSIMP_LOG_ERROR("NFF2: Vertex index overflow");
m = 0;
@ -446,7 +439,7 @@ void NFFImporter::InternReadFile(const std::string &pFile,
if (TokenMatch(sz, "0x", 2)) {
hasColor = true;
const char *sz2 = sz;
numIdx = ::strtoul16(sz, &sz);
numIdx = strtoul16(sz, &sz);
const unsigned int diff = (unsigned int)(sz - sz2);
// 0xRRGGBB
@ -518,7 +511,7 @@ void NFFImporter::InternReadFile(const std::string &pFile,
// Material ID?
else if (!materialTable.empty() && TokenMatch(sz, "matid", 5)) {
SkipSpaces(&sz);
matIdx = ::strtoul10(sz, &sz);
matIdx = strtoul10(sz, &sz);
if (matIdx >= materialTable.size()) {
ASSIMP_LOG_ERROR("NFF2: Material index overflow.");
matIdx = 0;
@ -1165,4 +1158,6 @@ void NFFImporter::InternReadFile(const std::string &pFile,
pScene->mRootNode = root;
}
} // namespace Assimp
#endif // !! ASSIMP_BUILD_NO_NFF_IMPORTER

4
code/AssetLib/NFF/NFFLoader.h
View File

@ -63,8 +63,8 @@ namespace Assimp {
*/
class NFFImporter : public BaseImporter {
public:
NFFImporter();
~NFFImporter() override;
NFFImporter() = default;
~NFFImporter() override = default;
// -------------------------------------------------------------------
/** Returns whether the class can handle the format of the given file.

125
code/AssetLib/OFF/OFFLoader.cpp
View File

@ -43,7 +43,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* @brief Implementation of the OFF importer class
*/
#ifndef ASSIMP_BUILD_NO_OFF_IMPORTER
// internal headers
@ -56,9 +55,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <assimp/DefaultLogger.hpp>
#include <assimp/importerdesc.h>
using namespace Assimp;
namespace Assimp {
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"OFF Importer",
"",
"",
@ -71,31 +70,20 @@ static const aiImporterDesc desc = {
"off"
};
// ------------------------------------------------------------------------------------------------
// Constructor to be privately used by Importer
OFFImporter::OFFImporter() = default;
// ------------------------------------------------------------------------------------------------
// Destructor, private as well
OFFImporter::~OFFImporter() = default;
// ------------------------------------------------------------------------------------------------
// Returns whether the class can handle the format of the given file.
bool OFFImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool /*checkSig*/) const
{
static const char* tokens[] = { "off" };
return SearchFileHeaderForToken(pIOHandler,pFile,tokens,AI_COUNT_OF(tokens),3);
bool OFFImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
static const char *tokens[] = { "off" };
return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens), 3);
}
// ------------------------------------------------------------------------------------------------
const aiImporterDesc* OFFImporter::GetInfo () const
{
const aiImporterDesc *OFFImporter::GetInfo() const {
return &desc;
}
// skip blank space, lines and comments
static void NextToken(const char **car, const char* end) {
static void NextToken(const char **car, const char *end) {
SkipSpacesAndLineEnd(car);
while (*car < end && (**car == '#' || **car == '\n' || **car == '\r')) {
SkipLine(car);
@ -105,8 +93,8 @@ static void NextToken(const char **car, const char* end) {
// ------------------------------------------------------------------------------------------------
// Imports the given file into the given scene structure.
void OFFImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) {
std::unique_ptr<IOStream> file( pIOHandler->Open( pFile, "rb"));
void OFFImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
std::unique_ptr<IOStream> file(pIOHandler->Open(pFile, "rb"));
// Check whether we can read from the file
if (file == nullptr) {
@ -115,31 +103,36 @@ void OFFImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
// allocate storage and copy the contents of the file to a memory buffer
std::vector<char> mBuffer2;
TextFileToBuffer(file.get(),mBuffer2);
const char* buffer = &mBuffer2[0];
TextFileToBuffer(file.get(), mBuffer2);
const char *buffer = &mBuffer2[0];
// Proper OFF header parser. We only implement normal loading for now.
bool hasTexCoord = false, hasNormals = false, hasColors = false;
bool hasHomogenous = false, hasDimension = false;
unsigned int dimensions = 3;
const char* car = buffer;
const char* end = buffer + mBuffer2.size();
const char *car = buffer;
const char *end = buffer + mBuffer2.size();
NextToken(&car, end);
if (car < end - 2 && car[0] == 'S' && car[1] == 'T') {
hasTexCoord = true; car += 2;
hasTexCoord = true;
car += 2;
}
if (car < end - 1 && car[0] == 'C') {
hasColors = true; car++;
hasColors = true;
car++;
}
if (car < end- 1 && car[0] == 'N') {
hasNormals = true; car++;
if (car < end - 1 && car[0] == 'N') {
hasNormals = true;
car++;
}
if (car < end - 1 && car[0] == '4') {
hasHomogenous = true; car++;
hasHomogenous = true;
car++;
}
if (car < end - 1 && car[0] == 'n') {
hasDimension = true; car++;
hasDimension = true;
car++;
}
if (car < end - 3 && car[0] == 'O' && car[1] == 'F' && car[2] == 'F') {
car += 3;
@ -162,8 +155,7 @@ void OFFImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
NextToken(&car, end);
}
if (dimensions > 3) {
throw DeadlyImportError
("OFF: Number of vertex coordinates higher than 3 unsupported");
throw DeadlyImportError("OFF: Number of vertex coordinates higher than 3 unsupported");
}
NextToken(&car, end);
@ -182,13 +174,13 @@ void OFFImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
}
pScene->mNumMeshes = 1;
pScene->mMeshes = new aiMesh*[ pScene->mNumMeshes ];
pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
aiMesh* mesh = new aiMesh();
aiMesh *mesh = new aiMesh();
pScene->mMeshes[0] = mesh;
mesh->mNumFaces = numFaces;
aiFace* faces = new aiFace[mesh->mNumFaces];
aiFace *faces = new aiFace[mesh->mNumFaces];
mesh->mFaces = faces;
mesh->mNumVertices = numVertices;
@ -206,18 +198,18 @@ void OFFImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
// now read all vertex lines
for (unsigned int i = 0; i < numVertices; ++i) {
if(!GetNextLine(buffer, line)) {
if (!GetNextLine(buffer, line)) {
ASSIMP_LOG_ERROR("OFF: The number of verts in the header is incorrect");
break;
}
aiVector3D& v = mesh->mVertices[i];
aiVector3D &v = mesh->mVertices[i];
sz = line;
// helper array to write a for loop over possible dimension values
ai_real* vec[3] = {&v.x, &v.y, &v.z};
ai_real *vec[3] = { &v.x, &v.y, &v.z };
// stop at dimensions: this allows loading 1D or 2D coordinate vertices
for (unsigned int dim = 0; dim < dimensions; ++dim ) {
for (unsigned int dim = 0; dim < dimensions; ++dim) {
SkipSpaces(&sz);
sz = fast_atoreal_move<ai_real>(sz, *vec[dim]);
}
@ -227,20 +219,20 @@ void OFFImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
SkipSpaces(&sz);
ai_real w = 1.;
sz = fast_atoreal_move<ai_real>(sz, w);
for (unsigned int dim = 0; dim < dimensions; ++dim ) {
for (unsigned int dim = 0; dim < dimensions; ++dim) {
*(vec[dim]) /= w;
}
}
// read optional normals
if (hasNormals) {
aiVector3D& n = mesh->mNormals[i];
aiVector3D &n = mesh->mNormals[i];
SkipSpaces(&sz);
sz = fast_atoreal_move<ai_real>(sz,(ai_real&)n.x);
sz = fast_atoreal_move<ai_real>(sz, (ai_real &)n.x);
SkipSpaces(&sz);
sz = fast_atoreal_move<ai_real>(sz,(ai_real&)n.y);
sz = fast_atoreal_move<ai_real>(sz, (ai_real &)n.y);
SkipSpaces(&sz);
fast_atoreal_move<ai_real>(sz,(ai_real&)n.z);
fast_atoreal_move<ai_real>(sz, (ai_real &)n.z);
}
// reading colors is a pain because the specification says it can be
@ -248,48 +240,49 @@ void OFFImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
// until the next comment or end of line
// in theory should be testing type !
if (hasColors) {
aiColor4D& c = mesh->mColors[0][i];
aiColor4D &c = mesh->mColors[0][i];
SkipSpaces(&sz);
sz = fast_atoreal_move<ai_real>(sz,(ai_real&)c.r);
sz = fast_atoreal_move<ai_real>(sz, (ai_real &)c.r);
if (*sz != '#' && *sz != '\n' && *sz != '\r') {
SkipSpaces(&sz);
sz = fast_atoreal_move<ai_real>(sz,(ai_real&)c.g);
sz = fast_atoreal_move<ai_real>(sz, (ai_real &)c.g);
} else {
c.g = 0.;
}
if (*sz != '#' && *sz != '\n' && *sz != '\r') {
SkipSpaces(&sz);
sz = fast_atoreal_move<ai_real>(sz,(ai_real&)c.b);
sz = fast_atoreal_move<ai_real>(sz, (ai_real &)c.b);
} else {
c.b = 0.;
}
if (*sz != '#' && *sz != '\n' && *sz != '\r') {
SkipSpaces(&sz);
sz = fast_atoreal_move<ai_real>(sz,(ai_real&)c.a);
sz = fast_atoreal_move<ai_real>(sz, (ai_real &)c.a);
} else {
c.a = 1.;
}
}
if (hasTexCoord) {
aiVector3D& t = mesh->mTextureCoords[0][i];
aiVector3D &t = mesh->mTextureCoords[0][i];
SkipSpaces(&sz);
sz = fast_atoreal_move<ai_real>(sz,(ai_real&)t.x);
sz = fast_atoreal_move<ai_real>(sz, (ai_real &)t.x);
SkipSpaces(&sz);
fast_atoreal_move<ai_real>(sz,(ai_real&)t.y);
fast_atoreal_move<ai_real>(sz, (ai_real &)t.y);
}
}
// load faces with their indices
faces = mesh->mFaces;
for (unsigned int i = 0; i < numFaces; ) {
if(!GetNextLine(buffer,line)) {
for (unsigned int i = 0; i < numFaces;) {
if (!GetNextLine(buffer, line)) {
ASSIMP_LOG_ERROR("OFF: The number of faces in the header is incorrect");
throw DeadlyImportError("OFF: The number of faces in the header is incorrect");
}
unsigned int idx;
sz = line; SkipSpaces(&sz);
idx = strtoul10(sz,&sz);
if(!idx || idx > 9) {
sz = line;
SkipSpaces(&sz);
idx = strtoul10(sz, &sz);
if (!idx || idx > 9) {
ASSIMP_LOG_ERROR("OFF: Faces with zero indices aren't allowed");
--mesh->mNumFaces;
++i;
@ -297,9 +290,9 @@ void OFFImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
}
faces->mNumIndices = idx;
faces->mIndices = new unsigned int[faces->mNumIndices];
for (unsigned int m = 0; m < faces->mNumIndices;++m) {
for (unsigned int m = 0; m < faces->mNumIndices; ++m) {
SkipSpaces(&sz);
idx = strtoul10(sz,&sz);
idx = strtoul10(sz, &sz);
if (idx >= numVertices) {
ASSIMP_LOG_ERROR("OFF: Vertex index is out of range");
idx = numVertices - 1;
@ -314,20 +307,22 @@ void OFFImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
pScene->mRootNode = new aiNode();
pScene->mRootNode->mName.Set("<OFFRoot>");
pScene->mRootNode->mNumMeshes = 1;
pScene->mRootNode->mMeshes = new unsigned int [pScene->mRootNode->mNumMeshes];
pScene->mRootNode->mMeshes = new unsigned int[pScene->mRootNode->mNumMeshes];
pScene->mRootNode->mMeshes[0] = 0;
// generate a default material
pScene->mNumMaterials = 1;
pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials];
aiMaterial* pcMat = new aiMaterial();
pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials];
aiMaterial *pcMat = new aiMaterial();
aiColor4D clr( ai_real( 0.6 ), ai_real( 0.6 ), ai_real( 0.6 ), ai_real( 1.0 ) );
pcMat->AddProperty(&clr,1,AI_MATKEY_COLOR_DIFFUSE);
aiColor4D clr(ai_real(0.6), ai_real(0.6), ai_real(0.6), ai_real(1.0));
pcMat->AddProperty(&clr, 1, AI_MATKEY_COLOR_DIFFUSE);
pScene->mMaterials[0] = pcMat;
const int twosided = 1;
pcMat->AddProperty(&twosided, 1, AI_MATKEY_TWOSIDED);
}
} // namespace Assimp
#endif // !! ASSIMP_BUILD_NO_OFF_IMPORTER

4
code/AssetLib/OFF/OFFLoader.h
View File

@ -57,8 +57,8 @@ namespace Assimp {
*/
class OFFImporter : public BaseImporter {
public:
OFFImporter();
~OFFImporter() override;
OFFImporter() = default;
~OFFImporter() override = default;
// -------------------------------------------------------------------
/** Returns whether the class can handle the format of the given file.

7
code/AssetLib/Obj/ObjFileImporter.cpp
View File

@ -54,7 +54,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <assimp/ObjMaterial.h>
#include <memory>
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"Wavefront Object Importer",
"",
"",
@ -103,6 +103,11 @@ const aiImporterDesc *ObjFileImporter::GetInfo() const {
// ------------------------------------------------------------------------------------------------
// Obj-file import implementation
void ObjFileImporter::InternReadFile(const std::string &file, aiScene *pScene, IOSystem *pIOHandler) {
if (m_pRootObject != nullptr) {
delete m_pRootObject;
m_pRootObject = nullptr;
}
// Read file into memory
static constexpr char mode[] = "rb";
auto streamCloser = [&](IOStream *pStream) {

2
code/AssetLib/Ogre/OgreImporter.cpp
View File

@ -48,7 +48,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <assimp/Importer.hpp>
#include <memory>
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"Ogre3D Mesh Importer",
"",
"",

72
code/AssetLib/OpenGEX/OpenGEXImporter.cpp
View File

@ -52,7 +52,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <assimp/scene.h>
#include <openddlparser/OpenDDLParser.h>
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"Open Game Engine Exchange",
"",
"",
@ -66,42 +66,42 @@ static const aiImporterDesc desc = {
};
namespace Grammar {
static const char* MetricType = "Metric";
static const char *Metric_DistanceType = "distance";
static const char *Metric_AngleType = "angle";
static const char *Metric_TimeType = "time";
static const char *Metric_UpType = "up";
static const char *NameType = "Name";
static const char *ObjectRefType = "ObjectRef";
static const char *MaterialRefType = "MaterialRef";
static const char *MetricKeyType = "key";
static const char *GeometryNodeType = "GeometryNode";
static const char *CameraNodeType = "CameraNode";
static const char *LightNodeType = "LightNode";
static const char *GeometryObjectType = "GeometryObject";
static const char *CameraObjectType = "CameraObject";
static const char *LightObjectType = "LightObject";
static const char *TransformType = "Transform";
static const char *MeshType = "Mesh";
static const char *VertexArrayType = "VertexArray";
static const char *IndexArrayType = "IndexArray";
static const char *MaterialType = "Material";
static const char *ColorType = "Color";
static const char *ParamType = "Param";
static const char *TextureType = "Texture";
static const char *AttenType = "Atten";
static constexpr char MetricType[] = "Metric";
static constexpr char Metric_DistanceType[] = "distance";
static constexpr char Metric_AngleType[] = "angle";
static constexpr char Metric_TimeType[] = "time";
static constexpr char Metric_UpType[] = "up";
static constexpr char NameType[] = "Name";
static constexpr char ObjectRefType[] = "ObjectRef";
static constexpr char MaterialRefType[] = "MaterialRef";
static constexpr char MetricKeyType[] = "key";
static constexpr char GeometryNodeType[] = "GeometryNode";
static constexpr char CameraNodeType[] = "CameraNode";
static constexpr char LightNodeType[] = "LightNode";
static constexpr char GeometryObjectType[] = "GeometryObject";
static constexpr char CameraObjectType[] = "CameraObject";
static constexpr char LightObjectType[] = "LightObject";
static constexpr char TransformType[] = "Transform";
static constexpr char MeshType[] = "Mesh";
static constexpr char VertexArrayType[] = "VertexArray";
static constexpr char IndexArrayType[] = "IndexArray";
static constexpr char MaterialType[] = "Material";
static constexpr char ColorType[] = "Color";
static constexpr char ParamType[] = "Param";
static constexpr char TextureType[] = "Texture";
static constexpr char AttenType[] = "Atten";
static const char *DiffuseColorToken = "diffuse";
static const char *SpecularColorToken = "specular";
static const char *EmissionColorToken = "emission";
static constexpr char DiffuseColorToken[] = "diffuse";
static constexpr char SpecularColorToken[] = "specular";
static constexpr char EmissionColorToken[] = "emission";
static const char *DiffuseTextureToken = "diffuse";
static const char *DiffuseSpecularTextureToken = "specular";
static const char *SpecularPowerTextureToken = "specular_power";
static const char *EmissionTextureToken = "emission";
static const char *OpacyTextureToken = "opacity";
static const char *TransparencyTextureToken = "transparency";
static const char *NormalTextureToken = "normal";
static constexpr char DiffuseTextureToken[] = "diffuse";
static constexpr char DiffuseSpecularTextureToken[] = "specular";
static constexpr char SpecularPowerTextureToken[] = "specular_power";
static constexpr char EmissionTextureToken[] = "emission";
static constexpr char OpacyTextureToken[] = "opacity";
static constexpr char TransparencyTextureToken[] = "transparency";
static constexpr char NormalTextureToken[] = "normal";
enum TokenType {
NoneType = -1,
@ -139,7 +139,7 @@ namespace Grammar {
return false;
}
int idx(-1);
int idx = -1;
for (size_t i = 0; i < 4; i++) {
if (ValidMetricToken[i] == token) {
idx = (int)i;

46
code/AssetLib/Ply/PlyLoader.cpp
View File

@ -53,9 +53,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <assimp/IOSystem.hpp>
#include <memory>
using namespace ::Assimp;
namespace Assimp {
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"Stanford Polygon Library (PLY) Importer",
"",
"",
@ -71,16 +71,16 @@ static const aiImporterDesc desc = {
// ------------------------------------------------------------------------------------------------
// Internal stuff
namespace {
// ------------------------------------------------------------------------------------------------
// Checks that property index is within range
template <class T>
inline const T &GetProperty(const std::vector<T> &props, int idx) {
// ------------------------------------------------------------------------------------------------
// Checks that property index is within range
template <class T>
inline const T &GetProperty(const std::vector<T> &props, int idx) {
if (static_cast<size_t>(idx) >= props.size()) {
throw DeadlyImportError("Invalid .ply file: Property index is out of range.");
}
return props[idx];
}
}
} // namespace
// ------------------------------------------------------------------------------------------------
@ -92,10 +92,6 @@ PLYImporter::PLYImporter() :
// empty
}
// ------------------------------------------------------------------------------------------------
// Destructor, private as well
PLYImporter::~PLYImporter() = default;
// ------------------------------------------------------------------------------------------------
// Returns whether the class can handle the format of the given file.
bool PLYImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
@ -215,7 +211,7 @@ void PLYImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSy
throw DeadlyImportError("Invalid .ply file: Missing format specification");
}
//free the file buffer
// free the file buffer
streamedBuffer.close();
if (mGeneratedMesh == nullptr) {
@ -376,7 +372,7 @@ void PLYImporter::LoadVertex(const PLY::Element *pcElement, const PLY::ElementIn
haveNormal = true;
}
//Colors
// Colors
aiColor4D cOut;
bool haveColor = false;
if (0xFFFFFFFF != aiColors[0]) {
@ -415,7 +411,7 @@ void PLYImporter::LoadVertex(const PLY::Element *pcElement, const PLY::ElementIn
haveColor = true;
}
//Texture coordinates
// Texture coordinates
aiVector3D tOut;
tOut.z = 0;
bool haveTextureCoords = false;
@ -431,7 +427,7 @@ void PLYImporter::LoadVertex(const PLY::Element *pcElement, const PLY::ElementIn
haveTextureCoords = true;
}
//create aiMesh if needed
// create aiMesh if needed
if (nullptr == mGeneratedMesh) {
mGeneratedMesh = new aiMesh();
mGeneratedMesh->mMaterialIndex = 0;
@ -512,8 +508,8 @@ void PLYImporter::LoadFace(const PLY::Element *pcElement, const PLY::ElementInst
bool bIsTriStrip = false;
// index of the material index property
//unsigned int iMaterialIndex = 0xFFFFFFFF;
//PLY::EDataType eType2 = EDT_Char;
// unsigned int iMaterialIndex = 0xFFFFFFFF;
// PLY::EDataType eType2 = EDT_Char;
// texture coordinates
unsigned int iTextureCoord = 0xFFFFFFFF;
@ -595,7 +591,7 @@ void PLYImporter::LoadFace(const PLY::Element *pcElement, const PLY::ElementInst
if (0xFFFFFFFF != iTextureCoord) {
const unsigned int iNum = (unsigned int)GetProperty(instElement->alProperties, iTextureCoord).avList.size();
//should be 6 coords
// should be 6 coords
std::vector<PLY::PropertyInstance::ValueUnion>::const_iterator p =
GetProperty(instElement->alProperties, iTextureCoord).avList.begin();
@ -625,7 +621,7 @@ void PLYImporter::LoadFace(const PLY::Element *pcElement, const PLY::ElementInst
// a value of -1 indicates a restart of the strip
bool flip = false;
const std::vector<PLY::PropertyInstance::ValueUnion> &quak = GetProperty(instElement->alProperties, iProperty).avList;
//pvOut->reserve(pvOut->size() + quak.size() + (quak.size()>>2u)); //Limits memory consumption
// pvOut->reserve(pvOut->size() + quak.size() + (quak.size()>>2u)); //Limits memory consumption
int aiTable[2] = { -1, -1 };
for (std::vector<PLY::PropertyInstance::ValueUnion>::const_iterator a = quak.begin(); a != quak.end(); ++a) {
@ -863,7 +859,7 @@ void PLYImporter::LoadMaterial(std::vector<aiMaterial *> *pvOut, std::string &de
const int two_sided = 1;
pcHelper->AddProperty(&two_sided, 1, AI_MATKEY_TWOSIDED);
//default texture
// default texture
if (!defaultTexture.empty()) {
const aiString name(defaultTexture.c_str());
pcHelper->AddProperty(&name, _AI_MATKEY_TEXTURE_BASE, aiTextureType_DIFFUSE, 0);
@ -873,7 +869,7 @@ void PLYImporter::LoadMaterial(std::vector<aiMaterial *> *pvOut, std::string &de
pcHelper->AddProperty(&two_sided, 1, AI_MATKEY_TWOSIDED);
}
//set to wireframe, so when using this material info we can switch to points rendering
// set to wireframe, so when using this material info we can switch to points rendering
if (pointsOnly) {
const int wireframe = 1;
pcHelper->AddProperty(&wireframe, 1, AI_MATKEY_ENABLE_WIREFRAME);
@ -890,7 +886,7 @@ void PLYImporter::LoadMaterial(std::vector<aiMaterial *> *pvOut, std::string &de
int iMode = (int)aiShadingMode_Gouraud;
pcHelper->AddProperty<int>(&iMode, 1, AI_MATKEY_SHADING_MODEL);
//generate white material most 3D engine just multiply ambient / diffuse color with actual ambient / light color
// generate white material most 3D engine just multiply ambient / diffuse color with actual ambient / light color
aiColor3D clr;
clr.b = clr.g = clr.r = 1.0f;
pcHelper->AddProperty<aiColor3D>(&clr, 1, AI_MATKEY_COLOR_DIFFUSE);
@ -906,13 +902,13 @@ void PLYImporter::LoadMaterial(std::vector<aiMaterial *> *pvOut, std::string &de
pcHelper->AddProperty(&two_sided, 1, AI_MATKEY_TWOSIDED);
}
//default texture
// default texture
if (!defaultTexture.empty()) {
const aiString name(defaultTexture.c_str());
pcHelper->AddProperty(&name, _AI_MATKEY_TEXTURE_BASE, aiTextureType_DIFFUSE, 0);
}
//set to wireframe, so when using this material info we can switch to points rendering
// set to wireframe, so when using this material info we can switch to points rendering
if (pointsOnly) {
const int wireframe = 1;
pcHelper->AddProperty(&wireframe, 1, AI_MATKEY_ENABLE_WIREFRAME);
@ -922,4 +918,6 @@ void PLYImporter::LoadMaterial(std::vector<aiMaterial *> *pvOut, std::string &de
}
}
} // namespace Assimp
#endif // !! ASSIMP_BUILD_NO_PLY_IMPORTER

2
code/AssetLib/Ply/PlyLoader.h
View File

@ -65,7 +65,7 @@ using namespace PLY;
class PLYImporter : public BaseImporter {
public:
PLYImporter();
~PLYImporter() override;
~PLYImporter() override = default;
// -------------------------------------------------------------------
/** Returns whether the class can handle the format of the given file.

9
code/AssetLib/Q3BSP/Q3BSPFileImporter.cpp
View File

@ -65,7 +65,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <sstream>
#include <vector>
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"Quake III BSP Importer",
"",
"",
@ -146,7 +146,11 @@ Q3BSPFileImporter::Q3BSPFileImporter() :
// ------------------------------------------------------------------------------------------------
// Destructor.
Q3BSPFileImporter::~Q3BSPFileImporter() {
// Clear face-to-material map
clear();
}
// ------------------------------------------------------------------------------------------------
void Q3BSPFileImporter::clear() {
for (FaceMap::iterator it = m_MaterialLookupMap.begin(); it != m_MaterialLookupMap.end(); ++it) {
const std::string &matName = it->first;
if (!matName.empty()) {
@ -173,6 +177,7 @@ const aiImporterDesc *Q3BSPFileImporter::GetInfo() const {
// ------------------------------------------------------------------------------------------------
// Import method.
void Q3BSPFileImporter::InternReadFile(const std::string &rFile, aiScene *scene, IOSystem *ioHandler) {
clear();
ZipArchiveIOSystem Archive(ioHandler, rFile);
if (!Archive.isOpen()) {
throw DeadlyImportError("Failed to open file ", rFile, ".");

1
code/AssetLib/Q3BSP/Q3BSPFileImporter.h
View File

@ -81,6 +81,7 @@ protected:
using FaceMapIt = std::map<std::string, std::vector<Q3BSP::sQ3BSPFace*>* >::iterator;
using FaceMapConstIt = std::map<std::string, std::vector<Q3BSP::sQ3BSPFace*>*>::const_iterator;
void clear();
const aiImporterDesc* GetInfo () const override;
void InternReadFile(const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) override;
void separateMapName( const std::string &rImportName, std::string &rArchiveName, std::string &rMapName );

25
code/AssetLib/Q3D/Q3DLoader.cpp
View File

@ -55,9 +55,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <assimp/DefaultLogger.hpp>
#include <assimp/IOSystem.hpp>
using namespace Assimp;
namespace Assimp {
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"Quick3D Importer",
"",
"",
@ -127,7 +127,7 @@ void Q3DImporter::InternReadFile(const std::string &pFile,
std::vector<Material> materials;
try {
materials.reserve(numMats);
} catch(const std::bad_alloc&) {
} catch (const std::bad_alloc &) {
ASSIMP_LOG_ERROR("Invalid alloc for materials.");
throw DeadlyImportError("Invalid Quick3D-file, material allocation failed.");
}
@ -135,7 +135,7 @@ void Q3DImporter::InternReadFile(const std::string &pFile,
std::vector<Mesh> meshes;
try {
meshes.reserve(numMeshes);
} catch(const std::bad_alloc&) {
} catch (const std::bad_alloc &) {
ASSIMP_LOG_ERROR("Invalid alloc for meshes.");
throw DeadlyImportError("Invalid Quick3D-file, mesh allocation failed.");
}
@ -237,7 +237,6 @@ void Q3DImporter::InternReadFile(const std::string &pFile,
if (minor > '0' && major == '3')
stream.IncPtr(mesh.faces.size());
}
// stream.IncPtr(4); // unknown value here
} break;
// materials chunk
@ -275,8 +274,6 @@ void Q3DImporter::InternReadFile(const std::string &pFile,
// 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();
}
@ -425,7 +422,8 @@ outer:
pScene->mMeshes = new aiMesh *[pScene->mNumMaterials];
for (unsigned int i = 0, real = 0; i < (unsigned int)materials.size(); ++i) {
if (fidx[i].empty()) continue;
if (fidx[i].empty())
continue;
// Allocate a mesh and a material
aiMesh *mesh = pScene->mMeshes[real] = new aiMesh();
@ -548,14 +546,9 @@ outer:
// 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)
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;
@ -577,4 +570,6 @@ outer:
}
}
} // namespace Assimp
#endif // !! ASSIMP_BUILD_NO_Q3D_IMPORTER

14
code/AssetLib/Raw/RawLoader.cpp
View File

@ -55,9 +55,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <assimp/IOSystem.hpp>
#include <memory>
using namespace Assimp;
namespace Assimp {
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"Raw Importer",
"",
"",
@ -70,14 +70,6 @@ static const aiImporterDesc desc = {
"raw"
};
// ------------------------------------------------------------------------------------------------
// Constructor to be privately used by Importer
RAWImporter::RAWImporter() = default;
// ------------------------------------------------------------------------------------------------
// Destructor, private as well
RAWImporter::~RAWImporter() = default;
// ------------------------------------------------------------------------------------------------
// Returns whether the class can handle the format of the given file.
bool RAWImporter::CanRead(const std::string &filename, IOSystem * /*pIOHandler*/, bool /*checkSig*/) const {
@ -295,4 +287,6 @@ void RAWImporter::InternReadFile(const std::string &pFile,
}
}
} // namespace Assimp
#endif // !! ASSIMP_BUILD_NO_RAW_IMPORTER

4
code/AssetLib/Raw/RawLoader.h
View File

@ -57,8 +57,8 @@ namespace Assimp {
*/
class RAWImporter : public BaseImporter {
public:
RAWImporter();
~RAWImporter() override;
RAWImporter() = default;
~RAWImporter() override = default;
// -------------------------------------------------------------------
/** Returns whether the class can handle the format of the given file.

17
code/AssetLib/SIB/SIBImporter.cpp
View File

@ -69,9 +69,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <map>
using namespace Assimp;
namespace Assimp {
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"Silo SIB Importer",
"Richard Mitton (http://www.codersnotes.com/about)",
"",
@ -94,7 +94,7 @@ enum {
N
};
typedef std::pair<uint32_t, uint32_t> SIBPair;
using SIBPair = std::pair<uint32_t, uint32_t>;
struct SIBEdge {
uint32_t faceA, faceB;
@ -199,15 +199,6 @@ static aiString ReadString(StreamReaderLE *stream, uint32_t numWChars) {
return result;
}
// ------------------------------------------------------------------------------------------------
// Constructor to be privately used by Importer
SIBImporter::SIBImporter() = default;
// ------------------------------------------------------------------------------------------------
// Destructor, private as well
SIBImporter::~SIBImporter() = default;
// ------------------------------------------------------------------------------------------------
// Returns whether the class can handle the format of the given file.
bool SIBImporter::CanRead(const std::string &filename, IOSystem * /*pIOHandler*/, bool /*checkSig*/) const {
@ -882,4 +873,6 @@ void SIBImporter::InternReadFile(const std::string &pFile,
}
}
} // namespace Assimp
#endif // !! ASSIMP_BUILD_NO_SIB_IMPORTER

4
code/AssetLib/SIB/SIBImporter.h
View File

@ -57,8 +57,8 @@ namespace Assimp {
*/
class ASSIMP_API SIBImporter : public BaseImporter {
public:
SIBImporter();
~SIBImporter() override;
SIBImporter() = default;
~SIBImporter() override = default;
// -------------------------------------------------------------------
/** Returns whether the class can handle the format of the given file.

2
code/AssetLib/Unreal/UnrealLoader.cpp
View File

@ -152,7 +152,7 @@ inline void DecompressVertex(aiVector3D &v, int32_t in) {
} // end namespace Unreal
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"Unreal Mesh Importer",
"",
"",

6
code/AssetLib/glTF/glTFImporter.cpp
View File

@ -62,11 +62,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
using namespace Assimp;
using namespace glTF;
//
// glTFImporter
//
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"glTF Importer",
"",
"",

2
code/AssetLib/glTF2/glTF2Importer.cpp
View File

@ -82,7 +82,7 @@ struct Tangent {
// glTF2Importer
//
static const aiImporterDesc desc = {
static constexpr aiImporterDesc desc = {
"glTF2 Importer",
"",
"",

4
include/assimp/BaseImporter.h
View File

@ -63,6 +63,7 @@ struct aiImporterDesc;
namespace Assimp {
// Forward declarations
class Importer;
class IOSystem;
class BaseProcess;
@ -73,6 +74,9 @@ class IOStream;
#define AI_MAKE_MAGIC(string) ((uint32_t)((string[0] << 24) + \
(string[1] << 16) + (string[2] << 8) + string[3]))
using UByteBuffer = std::vector<uint8_t>;
using ByteBuffer = std::vector<int8_t>;
// ---------------------------------------------------------------------------
/** FOR IMPORTER PLUGINS ONLY: The BaseImporter defines a common interface
* for all importer worker classes.

1
include/assimp/ParsingUtils.h
View File

@ -70,7 +70,6 @@ namespace Assimp {
static const unsigned int BufferSize = 4096;
// ---------------------------------------------------------------------------------
template <class char_t>
AI_FORCE_INLINE bool IsUpper(char_t in) {