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

small refactorings.

pull/3058/head
kimkulling 2020-03-09 10:55:32 +01:00
parent bb3db0ebaf
commit f3b6b78d4d
8 changed files with 83 additions and 134 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -589,7 +589,7 @@ IF ( ASSIMP_BUILD_ASSIMP_TOOLS )
ADD_SUBDIRECTORY( tools/assimp_view/ )
ENDIF ()
ENDIF ()
# Te command line tool
# The command line tool
ADD_SUBDIRECTORY( tools/assimp_cmd/ )
ENDIF ()

4
code/CMakeLists.txt
View File

@ -185,8 +185,6 @@ SET( Common_SRCS
Common/ScenePreprocessor.cpp
Common/ScenePreprocessor.h
Common/SkeletonMeshBuilder.cpp
Common/SplitByBoneCountProcess.cpp
Common/SplitByBoneCountProcess.h
Common/StandardShapes.cpp
Common/TargetAnimation.cpp
Common/TargetAnimation.h
@ -737,6 +735,8 @@ SET( PostProcessing_SRCS
PostProcessing/ArmaturePopulate.h
PostProcessing/GenBoundingBoxesProcess.cpp
PostProcessing/GenBoundingBoxesProcess.h
PostProcessing/SplitByBoneCountProcess.cpp
PostProcessing/SplitByBoneCountProcess.h
)
SOURCE_GROUP( PostProcessing FILES ${PostProcessing_SRCS})

39
code/Common/BaseProcess.cpp
View File

@ -5,8 +5,6 @@ Open Asset Import Library (assimp)
Copyright (c) 2006-2020, assimp team
All rights reserved.
Redistribution and use of this software in source and binary forms,
@ -43,45 +41,43 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
/** @file Implementation of BaseProcess */
#include <assimp/BaseImporter.h>
#include "BaseProcess.h"
#include <assimp/DefaultLogger.hpp>
#include <assimp/scene.h>
#include "Importer.h"
#include <assimp/BaseImporter.h>
#include <assimp/scene.h>
#include <assimp/DefaultLogger.hpp>
using namespace Assimp;
// ------------------------------------------------------------------------------------------------
// Constructor to be privately used by Importer
BaseProcess::BaseProcess() AI_NO_EXCEPT
: shared()
, progress()
{
: shared(),
progress() {
// empty
}
// ------------------------------------------------------------------------------------------------
// Destructor, private as well
BaseProcess::~BaseProcess()
{
BaseProcess::~BaseProcess() {
// nothing to do here
}
// ------------------------------------------------------------------------------------------------
void BaseProcess::ExecuteOnScene( Importer* pImp)
{
ai_assert(NULL != pImp && NULL != pImp->Pimpl()->mScene);
void BaseProcess::ExecuteOnScene(Importer *pImp) {
ai_assert( nullptr != pImp );
ai_assert( nullptr != pImp->Pimpl()->mScene);
progress = pImp->GetProgressHandler();
ai_assert(progress);
ai_assert(nullptr != progress);
SetupProperties( pImp );
SetupProperties(pImp);
// catch exceptions thrown inside the PostProcess-Step
try
{
try {
Execute(pImp->Pimpl()->mScene);
} catch( const std::exception& err ) {
} catch (const std::exception &err) {
// extract error description
pImp->Pimpl()->mErrorString = err.what();
@ -94,14 +90,11 @@ void BaseProcess::ExecuteOnScene( Importer* pImp)
}
// ------------------------------------------------------------------------------------------------
void BaseProcess::SetupProperties(const Importer* /*pImp*/)
{
void BaseProcess::SetupProperties(const Importer * /*pImp*/) {
// the default implementation does nothing
}
// ------------------------------------------------------------------------------------------------
bool BaseProcess::RequireVerboseFormat() const
{
bool BaseProcess::RequireVerboseFormat() const {
return true;
}

127
code/Common/BaseProcess.h
View File

@ -4,7 +4,6 @@ Open Asset Import Library (assimp)
Copyright (c) 2006-2020, assimp team
All rights reserved.
Redistribution and use of this software in source and binary forms,
@ -44,9 +43,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef INCLUDED_AI_BASEPROCESS_H
#define INCLUDED_AI_BASEPROCESS_H
#include <map>
#include <assimp/GenericProperty.h>
#include <map>
struct aiScene;
namespace Assimp {
@ -60,64 +60,50 @@ class Importer;
* to provide additional information to other steps. This is primarily
* intended for cross-step optimizations.
*/
class SharedPostProcessInfo
{
class SharedPostProcessInfo {
public:
struct Base
{
virtual ~Base()
{}
struct Base {
virtual ~Base() {}
};
//! Represents data that is allocated on the heap, thus needs to be deleted
template <typename T>
struct THeapData : public Base
{
explicit THeapData(T* in)
: data (in)
{}
struct THeapData : public Base {
explicit THeapData(T *in) :
data(in) {}
~THeapData()
{
~THeapData() {
delete data;
}
T* data;
T *data;
};
//! Represents static, by-value data not allocated on the heap
template <typename T>
struct TStaticData : public Base
{
explicit TStaticData(T in)
: data (in)
{}
struct TStaticData : public Base {
explicit TStaticData(T in) :
data(in) {}
~TStaticData()
{}
~TStaticData() {}
T data;
};
// some typedefs for cleaner code
typedef unsigned int KeyType;
typedef std::map<KeyType, Base*> PropertyMap;
typedef std::map<KeyType, Base *> PropertyMap;
public:
//! Destructor
~SharedPostProcessInfo()
{
~SharedPostProcessInfo() {
Clean();
}
//! Remove all stored properties from the table
void Clean()
{
void Clean() {
// invoke the virtual destructor for all stored properties
for (PropertyMap::iterator it = pmap.begin(), end = pmap.end();
it != end; ++it)
{
it != end; ++it) {
delete (*it).second;
}
pmap.clear();
@ -125,24 +111,21 @@ public:
//! Add a heap property to the list
template <typename T>
void AddProperty( const char* name, T* in ){
AddProperty(name,(Base*)new THeapData<T>(in));
void AddProperty(const char *name, T *in) {
AddProperty(name, (Base *)new THeapData<T>(in));
}
//! Add a static by-value property to the list
template <typename T>
void AddProperty( const char* name, T in ){
AddProperty(name,(Base*)new TStaticData<T>(in));
void AddProperty(const char *name, T in) {
AddProperty(name, (Base *)new TStaticData<T>(in));
}
//! Get a heap property
template <typename T>
bool GetProperty( const char* name, T*& out ) const
{
THeapData<T>* t = (THeapData<T>*)GetPropertyInternal(name);
if(!t)
{
bool GetProperty(const char *name, T *&out) const {
THeapData<T> *t = (THeapData<T> *)GetPropertyInternal(name);
if (!t) {
out = NULL;
return false;
}
@ -152,53 +135,34 @@ public:
//! Get a static, by-value property
template <typename T>
bool GetProperty( const char* name, T& out ) const
{
TStaticData<T>* t = (TStaticData<T>*)GetPropertyInternal(name);
if(!t)return false;
bool GetProperty(const char *name, T &out) const {
TStaticData<T> *t = (TStaticData<T> *)GetPropertyInternal(name);
if ( nullptr == t) {
return false;
}
out = t->data;
return true;
}
//! Remove a property of a specific type
void RemoveProperty( const char* name) {
SetGenericPropertyPtr<Base>(pmap,name,NULL);
void RemoveProperty(const char *name) {
SetGenericPropertyPtr<Base>(pmap, name, nullptr );
}
private:
void AddProperty( const char* name, Base* data) {
SetGenericPropertyPtr<Base>(pmap,name,data);
void AddProperty(const char *name, Base *data) {
SetGenericPropertyPtr<Base>(pmap, name, data);
}
Base* GetPropertyInternal( const char* name) const {
return GetGenericProperty<Base*>(pmap,name,NULL);
Base *GetPropertyInternal(const char *name) const {
return GetGenericProperty<Base *>(pmap, name, nullptr );
}
private:
//! Map of all stored properties
PropertyMap pmap;
};
#if 0
// ---------------------------------------------------------------------------
/** @brief Represents a dependency table for a postprocessing steps.
*
* For future use.
*/
struct PPDependencyTable
{
unsigned int execute_me_before_these;
unsigned int execute_me_after_these;
unsigned int only_if_these_are_not_specified;
unsigned int mutually_exclusive_with;
};
#endif
#define AI_SPP_SPATIAL_SORT "$Spat"
// ---------------------------------------------------------------------------
@ -228,7 +192,7 @@ public:
* @return true if the process is present in this flag fields,
* false if not.
*/
virtual bool IsActive( unsigned int pFlags) const = 0;
virtual bool IsActive(unsigned int pFlags) const = 0;
// -------------------------------------------------------------------
/** Check whether this step expects its input vertex data to be
@ -241,14 +205,14 @@ public:
* the object pointer will be set to NULL).
* @param pImp Importer instance (pImp->mScene must be valid)
*/
void ExecuteOnScene( Importer* pImp);
void ExecuteOnScene(Importer *pImp);
// -------------------------------------------------------------------
/** Called prior to ExecuteOnScene().
* The function is a request to the process to update its configuration
* basing on the Importer's configuration property list.
*/
virtual void SetupProperties(const Importer* pImp);
virtual void SetupProperties(const Importer *pImp);
// -------------------------------------------------------------------
/** Executes the post processing step on the given imported data.
@ -256,35 +220,32 @@ public:
* This method must be implemented by deriving classes.
* @param pScene The imported data to work at.
*/
virtual void Execute( aiScene* pScene) = 0;
virtual void Execute(aiScene *pScene) = 0;
// -------------------------------------------------------------------
/** Assign a new SharedPostProcessInfo to the step. This object
* allows multiple postprocess steps to share data.
* @param sh May be NULL
*/
inline void SetSharedData(SharedPostProcessInfo* sh) {
inline void SetSharedData(SharedPostProcessInfo *sh) {
shared = sh;
}
// -------------------------------------------------------------------
/** Get the shared data that is assigned to the step.
*/
inline SharedPostProcessInfo* GetSharedData() {
inline SharedPostProcessInfo *GetSharedData() {
return shared;
}
protected:
/** See the doc of #SharedPostProcessInfo for more details */
SharedPostProcessInfo* shared;
SharedPostProcessInfo *shared;
/** Currently active progress handler */
ProgressHandler* progress;
ProgressHandler *progress;
};
} // end of namespace Assimp
#endif // AI_BASEPROCESS_H_INC

2
code/Common/PostStepRegistry.cpp
View File

@ -123,7 +123,7 @@ corresponding preprocessor flag to selectively disable steps.
# include "PostProcessing/OptimizeGraph.h"
#endif
#ifndef ASSIMP_BUILD_NO_SPLITBYBONECOUNT_PROCESS
# include "Common/SplitByBoneCountProcess.h"
# include "PostProcessing/SplitByBoneCountProcess.h"
#endif
#ifndef ASSIMP_BUILD_NO_DEBONE_PROCESS
# include "PostProcessing/DeboneProcess.h"

0
code/Common/SplitByBoneCountProcess.cpp → code/PostProcessing/SplitByBoneCountProcess.cpp
View File

2
code/Common/SplitByBoneCountProcess.h → code/PostProcessing/SplitByBoneCountProcess.h
View File

@ -46,7 +46,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#define AI_SPLITBYBONECOUNTPROCESS_H_INC
#include <vector>
#include "BaseProcess.h"
#include "Common/BaseProcess.h"
#include <assimp/mesh.h>
#include <assimp/scene.h>

31
include/assimp/GenericProperty.h
View File

@ -4,7 +4,6 @@ Open Asset Import Library (assimp)
Copyright (c) 2006-2020, assimp team
All rights reserved.
Redistribution and use of this software in source and binary forms,
@ -48,23 +47,22 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
# pragma GCC system_header
#endif
#include <assimp/Importer.hpp>
#include <assimp/ai_assert.h>
#include <assimp/Hash.h>
#include <assimp/ai_assert.h>
#include <assimp/Importer.hpp>
#include <map>
// ------------------------------------------------------------------------------------------------
template <class T>
inline
bool SetGenericProperty(std::map< unsigned int, T >& list,
const char* szName, const T& value) {
inline bool SetGenericProperty(std::map<unsigned int, T> &list,
const char *szName, const T &value) {
ai_assert(nullptr != szName);
const uint32_t hash = SuperFastHash(szName);
typename std::map<unsigned int, T>::iterator it = list.find(hash);
if (it == list.end()) {
list.insert(std::pair<unsigned int, T>( hash, value ));
list.insert(std::pair<unsigned int, T>(hash, value));
return false;
}
(*it).second = value;
@ -74,9 +72,8 @@ bool SetGenericProperty(std::map< unsigned int, T >& list,
// ------------------------------------------------------------------------------------------------
template <class T>
inline
const T& GetGenericProperty(const std::map< unsigned int, T >& list,
const char* szName, const T& errorReturn) {
inline const T &GetGenericProperty(const std::map<unsigned int, T> &list,
const char *szName, const T &errorReturn) {
ai_assert(nullptr != szName);
const uint32_t hash = SuperFastHash(szName);
@ -92,19 +89,18 @@ const T& GetGenericProperty(const std::map< unsigned int, T >& list,
// Special version for pointer types - they will be deleted when replaced with another value
// passing NULL removes the whole property
template <class T>
inline
void SetGenericPropertyPtr(std::map< unsigned int, T* >& list,
const char* szName, T* value, bool* bWasExisting = nullptr ) {
inline void SetGenericPropertyPtr(std::map<unsigned int, T *> &list,
const char *szName, T *value, bool *bWasExisting = nullptr) {
ai_assert(nullptr != szName);
const uint32_t hash = SuperFastHash(szName);
typename std::map<unsigned int, T*>::iterator it = list.find(hash);
typename std::map<unsigned int, T *>::iterator it = list.find(hash);
if (it == list.end()) {
if (bWasExisting) {
*bWasExisting = false;
}
list.insert(std::pair<unsigned int,T*>( hash, value ));
list.insert(std::pair<unsigned int, T *>(hash, value));
return;
}
if ((*it).second != value) {
@ -121,9 +117,8 @@ void SetGenericPropertyPtr(std::map< unsigned int, T* >& list,
// ------------------------------------------------------------------------------------------------
template <class T>
inline
bool HasGenericProperty(const std::map< unsigned int, T >& list,
const char* szName) {
inline bool HasGenericProperty(const std::map<unsigned int, T> &list,
const char *szName) {
ai_assert(nullptr != szName);
const uint32_t hash = SuperFastHash(szName);