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

Merge branch 'master' of https://github.com/assimp/assimp

pull/535/head
Alexander Gessler 2015-05-02 00:39:28 +02:00
parent 7eb5586c05 93bb63fdb4
commit 1851bf3acc
75 changed files with 5259 additions and 5050 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -58,3 +58,4 @@ test/gtest/src/gtest-stamp/gtest-gitinfo.txt
test/gtest/src/gtest-stamp/gtest-gitclone-lastrun.txt
Assimp.opensdf
contrib/zlib/CTestTestfile.cmake
ipch/assimp_viewer-44bbbcd1/assimp_viewerd-ccc45335.ipch

5
CMakeLists.txt
View File

@ -1,3 +1,4 @@
set(CMAKE_LEGACY_CYGWIN_WIN32 0) # Remove when CMake >= 2.8.4 is required
cmake_minimum_required( VERSION 2.8 )
PROJECT( Assimp )
@ -61,9 +62,9 @@ if( CMAKE_COMPILER_IS_MINGW )
endif()
if((CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX) AND NOT CMAKE_COMPILER_IS_MINGW)
add_definitions(-fPIC) # this is a very important switch and some libraries seem now to have it....
set(CMAKE_CXX_FLAGS "-fPIC") # this is a very important switch and some libraries seem now to have it....
# hide all not-exported symbols
add_definitions( -fvisibility=hidden -Wall )
set(CMAKE_CXX_FLAGS "-fvisibility=hidden -Wall" )
elseif(MSVC)
# enable multi-core compilation with MSVC
add_definitions(/MP)

19
code/Assimp.cpp
View File

@ -42,11 +42,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* @brief Implementation of the Plain-C API
*/
#include "../include/assimp/cimport.h"
#include "../include/assimp/LogStream.hpp"
#include "../include/assimp/DefaultLogger.hpp"
#include "../include/assimp/importerdesc.h"
#include "../include/assimp/scene.h"
#include <assimp/cimport.h>
#include <assimp/LogStream.hpp>
#include <assimp/DefaultLogger.hpp>
#include <assimp/Importer.hpp>
#include <assimp/importerdesc.h>
#include <assimp/scene.h>
#include "GenericProperty.h"
#include "CInterfaceIOWrapper.h"
@ -489,7 +490,7 @@ ASSIMP_API void aiSetImportPropertyInteger(aiPropertyStore* p, const char* szNam
{
ASSIMP_BEGIN_EXCEPTION_REGION();
PropertyMap* pp = reinterpret_cast<PropertyMap*>(p);
SetGenericProperty<int>(pp->ints,szName,value,NULL);
SetGenericProperty<int>(pp->ints,szName,value);
ASSIMP_END_EXCEPTION_REGION(void);
}
@ -499,7 +500,7 @@ ASSIMP_API void aiSetImportPropertyFloat(aiPropertyStore* p, const char* szName,
{
ASSIMP_BEGIN_EXCEPTION_REGION();
PropertyMap* pp = reinterpret_cast<PropertyMap*>(p);
SetGenericProperty<float>(pp->floats,szName,value,NULL);
SetGenericProperty<float>(pp->floats,szName,value);
ASSIMP_END_EXCEPTION_REGION(void);
}
@ -513,7 +514,7 @@ ASSIMP_API void aiSetImportPropertyString(aiPropertyStore* p, const char* szName
}
ASSIMP_BEGIN_EXCEPTION_REGION();
PropertyMap* pp = reinterpret_cast<PropertyMap*>(p);
SetGenericProperty<std::string>(pp->strings,szName,std::string(st->C_Str()),NULL);
SetGenericProperty<std::string>(pp->strings,szName,std::string(st->C_Str()));
ASSIMP_END_EXCEPTION_REGION(void);
}
@ -527,7 +528,7 @@ ASSIMP_API void aiSetImportPropertyMatrix(aiPropertyStore* p, const char* szName
}
ASSIMP_BEGIN_EXCEPTION_REGION();
PropertyMap* pp = reinterpret_cast<PropertyMap*>(p);
SetGenericProperty<aiMatrix4x4>(pp->matrices,szName,*mat,NULL);
SetGenericProperty<aiMatrix4x4>(pp->matrices,szName,*mat);
ASSIMP_END_EXCEPTION_REGION(void);
}

2
code/BaseImporter.cpp
View File

@ -46,7 +46,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "BaseImporter.h"
#include "FileSystemFilter.h"
#include "Importer.h"
#include "ByteSwap.h"
#include "ByteSwapper.h"
#include "../include/assimp/scene.h"
#include "../include/assimp/Importer.hpp"
#include "../include/assimp/postprocess.h"

2
code/Bitmap.cpp
View File

@ -49,7 +49,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "Bitmap.h"
#include "../include/assimp/texture.h"
#include "../include/assimp/IOStream.hpp"
#include "ByteSwap.h"
#include "ByteSwapper.h"
namespace Assimp {

6
code/ByteSwap.h → code/ByteSwapper.h
View File

@ -40,8 +40,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
/** @file Helper class tp perform various byte oder swappings
(e.g. little to big endian) */
#ifndef AI_BYTESWAP_H_INC
#define AI_BYTESWAP_H_INC
#ifndef AI_BYTESWAPPER_H_INC
#define AI_BYTESWAPPER_H_INC
#include "../include/assimp/ai_assert.h"
#include "../include/assimp/types.h"
@ -283,4 +283,4 @@ struct Getter<SwapEndianess,T,false> {
} // end Intern
} // end Assimp
#endif //!! AI_BYTESWAP_H_INC
#endif //!! AI_BYTESWAPPER_H_INC

4
code/CMakeLists.txt
View File

@ -98,7 +98,7 @@ SET( Common_SRCS
ScenePrivate.h
PostStepRegistry.cpp
ImporterRegistry.cpp
ByteSwap.h
ByteSwapper.h
DefaultProgressHandler.h
DefaultIOStream.cpp
DefaultIOStream.h
@ -784,7 +784,7 @@ if( MSVC )
else()
set(MSVC_PREFIX "vc130")
endif()
set(LIBRARY_SUFFIX "${ASSIMP_LIBRARY_SUFFIX}-${MSVC_PREFIX}-mt" CACHE STRING "the suffix for the assimp windows library" FORCE)
set(LIBRARY_SUFFIX "${ASSIMP_LIBRARY_SUFFIX}-${MSVC_PREFIX}-mt" CACHE STRING "the suffix for the assimp windows library")
endif()
SET_TARGET_PROPERTIES( assimp PROPERTIES

6
code/ColladaHelper.h
View File

@ -513,6 +513,8 @@ struct Effect
// Scalar factory
float mShininess, mRefractIndex, mReflectivity;
float mTransparency;
bool mHasTransparency;
bool mRGBTransparency;
// local params referring to each other by their SID
typedef std::map<std::string, Collada::EffectParam> ParamLibrary;
@ -533,7 +535,9 @@ struct Effect
, mShininess (10.0f)
, mRefractIndex (1.f)
, mReflectivity (1.f)
, mTransparency (0.f)
, mTransparency (1.f)
, mHasTransparency (false)
, mRGBTransparency(false)
, mDoubleSided (false)
, mWireframe (false)
, mFaceted (false)

19
code/ColladaLoader.cpp
View File

@ -117,6 +117,7 @@ void ColladaLoader::SetupProperties(const Importer* pImp)
{
noSkeletonMesh = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_NO_SKELETON_MESHES,0) != 0;
ignoreUpDirection = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_COLLADA_IGNORE_UP_DIRECTION,0) != 0;
invertTransparency = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_COLLADA_INVERT_TRANSPARENCY,0) != 0;
}
@ -1338,12 +1339,26 @@ void ColladaLoader::FillMaterials( const ColladaParser& pParser, aiScene* /*pSce
mat.AddProperty( &effect.mRefractIndex, 1, AI_MATKEY_REFRACTI);
// transparency, a very hard one. seemingly not all files are following the
// specification here .. but we can trick.
if (effect.mTransparency >= 0.f && effect.mTransparency < 1.f) {
// specification here (1.0 transparency => completly opaque)...
// therefore, we let the opportunity for the user to manually invert
// the transparency if necessary and we add preliminary support for RGB_ZERO mode
if(effect.mTransparency >= 0.f && effect.mTransparency <= 1.f) {
// Trying some support for RGB_ZERO mode
if(effect.mRGBTransparency) {
effect.mTransparency = 1.f - effect.mTransparent.a;
}
// Global option
if(invertTransparency) {
effect.mTransparency = 1.f - effect.mTransparency;
}
// Is the material finally transparent ?
if (effect.mHasTransparency || effect.mTransparency < 1.f) {
mat.AddProperty( &effect.mTransparency, 1, AI_MATKEY_OPACITY );
mat.AddProperty( &effect.mTransparent, 1, AI_MATKEY_COLOR_TRANSPARENT );
}
}
// add textures, if given
if( !effect.mTexAmbient.mName.empty())

1
code/ColladaLoader.h
View File

@ -241,6 +241,7 @@ protected:
bool noSkeletonMesh;
bool ignoreUpDirection;
bool invertTransparency;
/** Used by FindNameForNode() to generate unique node names */
unsigned int mNodeNameCounter;

9
code/ColladaParser.cpp
View File

@ -46,6 +46,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef ASSIMP_BUILD_NO_COLLADA_IMPORTER
#include <sstream>
#include "ColladaParser.h"
#include "fast_atof.h"
#include "ParsingUtils.h"
@ -1230,6 +1231,14 @@ void ColladaParser::ReadEffectProfileCommon( Collada::Effect& pEffect)
ReadEffectColor( pEffect.mReflective, pEffect.mTexReflective);
}
else if( IsElement( "transparent")) {
pEffect.mHasTransparency = true;
// In RGB_ZERO mode, the transparency is interpreted in reverse, go figure...
if(::strcmp(mReader->getAttributeValueSafe("opaque"), "RGB_ZERO") == 0) {
// TODO: handle RGB_ZERO mode completely
pEffect.mRGBTransparency = true;
}
ReadEffectColor( pEffect.mTransparent,pEffect.mTexTransparent);
}
else if( IsElement( "shininess"))

20
code/Exporter.cpp
View File

@ -513,34 +513,30 @@ ExportProperties::ExportProperties(const ExportProperties &other)
// ------------------------------------------------------------------------------------------------
// Set a configuration property
void ExportProperties :: SetPropertyInteger(const char* szName, int iValue,
bool* bWasExisting /*= NULL*/)
bool ExportProperties :: SetPropertyInteger(const char* szName, int iValue)
{
SetGenericProperty<int>(mIntProperties, szName,iValue,bWasExisting);
return SetGenericProperty<int>(mIntProperties, szName,iValue);
}
// ------------------------------------------------------------------------------------------------
// Set a configuration property
void ExportProperties :: SetPropertyFloat(const char* szName, float iValue,
bool* bWasExisting /*= NULL*/)
bool ExportProperties :: SetPropertyFloat(const char* szName, float iValue)
{
SetGenericProperty<float>(mFloatProperties, szName,iValue,bWasExisting);
return SetGenericProperty<float>(mFloatProperties, szName,iValue);
}
// ------------------------------------------------------------------------------------------------
// Set a configuration property
void ExportProperties :: SetPropertyString(const char* szName, const std::string& value,
bool* bWasExisting /*= NULL*/)
bool ExportProperties :: SetPropertyString(const char* szName, const std::string& value)
{
SetGenericProperty<std::string>(mStringProperties, szName,value,bWasExisting);
return SetGenericProperty<std::string>(mStringProperties, szName,value);
}
// ------------------------------------------------------------------------------------------------
// Set a configuration property
void ExportProperties :: SetPropertyMatrix(const char* szName, const aiMatrix4x4& value,
bool* bWasExisting /*= NULL*/)
bool ExportProperties :: SetPropertyMatrix(const char* szName, const aiMatrix4x4& value)
{
SetGenericProperty<aiMatrix4x4>(mMatrixProperties, szName,value,bWasExisting);
return SetGenericProperty<aiMatrix4x4>(mMatrixProperties, szName,value);
}
// ------------------------------------------------------------------------------------------------

2
code/FBXBinaryTokenizer.cpp
View File

@ -50,7 +50,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "../include/assimp/defs.h"
#include <stdint.h>
#include "Exceptional.h"
#include "ByteSwap.h"
#include "ByteSwapper.h"
namespace Assimp {
namespace FBX {

3
code/FBXParser.cpp
View File

@ -59,7 +59,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "ParsingUtils.h"
#include "fast_atof.h"
#include <boost/foreach.hpp>
#include "ByteSwap.h"
#include "ByteSwapper.h"
using namespace Assimp;
using namespace Assimp::FBX;
@ -1316,4 +1316,3 @@ int64_t ParseTokenAsInt64(const Token& t)
} // !Assimp
#endif

11
code/GenericProperty.h
View File

@ -49,22 +49,19 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// ------------------------------------------------------------------------------------------------
template <class T>
inline void SetGenericProperty(std::map< unsigned int, T >& list,
const char* szName, const T& value, bool* bWasExisting = NULL)
inline bool SetGenericProperty(std::map< unsigned int, T >& list,
const char* szName, const T& value)
{
ai_assert(NULL != szName);
const uint32_t hash = SuperFastHash(szName);
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 ));
return;
return false;
}
(*it).second = value;
if (bWasExisting)
*bWasExisting = true;
return true;
}
// ------------------------------------------------------------------------------------------------

4
code/IFF.h
View File

@ -1,5 +1,3 @@
// Definitions for the Interchange File Format (IFF)
// Alexander Gessler, 2006
// Adapted to Assimp August 2008
@ -7,7 +5,7 @@
#ifndef AI_IFF_H_INCLUDED
#define AI_IFF_H_INCLUDED
#include "ByteSwap.h"
#include "ByteSwapper.h"
namespace Assimp {
namespace IFF {

36
code/Importer.cpp
View File

@ -925,42 +925,46 @@ void Importer::GetExtensionList(aiString& szOut) const
// ------------------------------------------------------------------------------------------------
// Set a configuration property
void Importer::SetPropertyInteger(const char* szName, int iValue,
bool* bWasExisting /*= NULL*/)
bool Importer::SetPropertyInteger(const char* szName, int iValue)
{
bool existing;
ASSIMP_BEGIN_EXCEPTION_REGION();
SetGenericProperty<int>(pimpl->mIntProperties, szName,iValue,bWasExisting);
ASSIMP_END_EXCEPTION_REGION(void);
existing = SetGenericProperty<int>(pimpl->mIntProperties, szName,iValue);
ASSIMP_END_EXCEPTION_REGION(bool);
return existing;
}
// ------------------------------------------------------------------------------------------------
// Set a configuration property
void Importer::SetPropertyFloat(const char* szName, float iValue,
bool* bWasExisting /*= NULL*/)
bool Importer::SetPropertyFloat(const char* szName, float iValue)
{
bool exising;
ASSIMP_BEGIN_EXCEPTION_REGION();
SetGenericProperty<float>(pimpl->mFloatProperties, szName,iValue,bWasExisting);
ASSIMP_END_EXCEPTION_REGION(void);
exising = SetGenericProperty<float>(pimpl->mFloatProperties, szName,iValue);
ASSIMP_END_EXCEPTION_REGION(bool);
return exising;
}
// ------------------------------------------------------------------------------------------------
// Set a configuration property
void Importer::SetPropertyString(const char* szName, const std::string& value,
bool* bWasExisting /*= NULL*/)
bool Importer::SetPropertyString(const char* szName, const std::string& value)
{
bool exising;
ASSIMP_BEGIN_EXCEPTION_REGION();
SetGenericProperty<std::string>(pimpl->mStringProperties, szName,value,bWasExisting);
ASSIMP_END_EXCEPTION_REGION(void);
exising = SetGenericProperty<std::string>(pimpl->mStringProperties, szName,value);
ASSIMP_END_EXCEPTION_REGION(bool);
return exising;
}
// ------------------------------------------------------------------------------------------------
// Set a configuration property
void Importer::SetPropertyMatrix(const char* szName, const aiMatrix4x4& value,
bool* bWasExisting /*= NULL*/)
bool Importer::SetPropertyMatrix(const char* szName, const aiMatrix4x4& value)
{
bool exising;
ASSIMP_BEGIN_EXCEPTION_REGION();
SetGenericProperty<aiMatrix4x4>(pimpl->mMatrixProperties, szName,value,bWasExisting);
ASSIMP_END_EXCEPTION_REGION(void);
exising = SetGenericProperty<aiMatrix4x4>(pimpl->mMatrixProperties, szName,value);
ASSIMP_END_EXCEPTION_REGION(bool);
return exising;
}
// ------------------------------------------------------------------------------------------------

2
code/LWOLoader.cpp
View File

@ -50,7 +50,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "LWOLoader.h"
#include "StringComparison.h"
#include "SGSpatialSort.h"
#include "ByteSwap.h"
#include "ByteSwapper.h"
#include "ProcessHelper.h"
#include "ConvertToLHProcess.h"
#include <boost/scoped_ptr.hpp>

2
code/LWOMaterial.cpp
View File

@ -47,7 +47,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// internal headers
#include "LWOLoader.h"
#include "ByteSwap.h"
#include "ByteSwapper.h"
#include <boost/static_assert.hpp>

2
code/MD2Loader.cpp
View File

@ -44,7 +44,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
/** @file Implementation of the MD2 importer class */
#include "MD2Loader.h"
#include "ByteSwap.h"
#include "ByteSwapper.h"
#include "MD2NormalTable.h" // shouldn't be included by other units
#include "../include/assimp/DefaultLogger.hpp"
#include "../include/assimp/Importer.hpp"

2
code/MD2Loader.h
View File

@ -46,7 +46,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "BaseImporter.h"
#include "../include/assimp/types.h"
#include "ByteSwap.h"
#include "ByteSwapper.h"
#include "MD2FileData.h"
struct aiNode;

3
code/MD3Loader.cpp
View File

@ -52,7 +52,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef ASSIMP_BUILD_NO_MD3_IMPORTER
#include "MD3Loader.h"
#include "ByteSwap.h"
#include "SceneCombiner.h"
#include "GenericProperty.h"
#include "RemoveComments.h"
@ -564,7 +563,7 @@ bool MD3Importer::ReadMultipartFile()
// ensure we won't try to load ourselves recursively
BatchLoader::PropertyMap props;
SetGenericProperty( props.ints, AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART, 0, NULL);
SetGenericProperty( props.ints, AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART, 0);
// now read these three files
BatchLoader batch(mIOHandler);

2
code/MD3Loader.h
View File

@ -45,7 +45,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#define AI_MD3LOADER_H_INCLUDED
#include "BaseImporter.h"
#include "ByteSwap.h"
#include "ByteSwapper.h"
#include "MD3FileData.h"
#include "StringComparison.h"
#include "../include/assimp/types.h"

3
code/MDCLoader.h
View File

@ -48,7 +48,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "BaseImporter.h"
#include "MDCFileData.h"
#include "ByteSwap.h"
#include "ByteSwapper.h"
namespace Assimp {
using namespace MDC;
@ -125,4 +125,3 @@ protected:
} // end of namespace Assimp
#endif // AI_3DSIMPORTER_H_INC

2
code/MDLFileData.h
View File

@ -52,7 +52,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_MDLFILEHELPER_H_INC
#define AI_MDLFILEHELPER_H_INC
#include "ByteSwap.h"
#include "ByteSwapper.h"
#include "./../include/assimp/anim.h"
#include "./../include/assimp/mesh.h"
#include "./../include/assimp/Compiler/pushpack1.h"

1
code/ObjFileMtlImporter.cpp
View File

@ -42,6 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef ASSIMP_BUILD_NO_OBJ_IMPORTER
#include <stdlib.h>
#include "ObjFileMtlImporter.h"
#include "ObjTools.h"
#include "ObjFileData.h"

1
code/ObjFileParser.cpp
View File

@ -53,6 +53,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "../include/assimp/DefaultLogger.hpp"
#include "../include/assimp/material.h"
#include "../include/assimp/Importer.hpp"
#include <cstdlib>
namespace Assimp {

90
code/OpenGEXImporter.cpp
View File

@ -44,8 +44,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "MakeVerboseFormat.h"
#include <openddlparser/OpenDDLParser.h>
#include "../include/assimp/scene.h"
#include <assimp/scene.h>
#include <assimp/ai_assert.h>
#include <vector>
@ -80,6 +80,10 @@ namespace Grammar {
static const char *IndexArrayType = "IndexArray";
static const char *MaterialType = "Material";
static const char *ColorType = "Color";
static const std::string DiffuseColorToken = "diffuse";
static const std::string SpecularColorToken = "specular";
static const std::string EmissionColorToken = "emission";
static const char *TextureType = "Texture";
enum TokenType {
@ -363,9 +367,9 @@ void OpenGEXImporter::handleMetricNode( DDLNode *node, aiScene *pScene ) {
Property *prop( node->getProperties() );
while( NULL != prop ) {
if( NULL != prop->m_id ) {
if( Value::ddl_string == prop->m_primData->m_type ) {
std::string valName( (char*) prop->m_primData->m_data );
if( NULL != prop->m_key ) {
if( Value::ddl_string == prop->m_value->m_type ) {
std::string valName( ( char* ) prop->m_value->m_data );
int type( Grammar::isValidMetricType( valName.c_str() ) );
if( Grammar::NoneType != type ) {
Value *val( node->getValue() );
@ -415,7 +419,7 @@ static void getRefNames( DDLNode *node, std::vector<std::string> &names ) {
for( size_t i = 0; i < ref->m_numRefs; i++ ) {
Name *currentName( ref->m_referencedName[ i ] );
if( NULL != currentName && NULL != currentName->m_id ) {
const std::string name( currentName->m_id->m_buffer );
const std::string name( currentName->m_id->m_text.m_buffer );
if( !name.empty() ) {
names.push_back( name );
}
@ -530,10 +534,10 @@ static void propId2StdString( Property *prop, std::string &name, std::string &ke
return;
}
if( NULL != prop->m_id ) {
name = prop->m_id->m_buffer;
if( Value::ddl_string == prop->m_primData->m_type ) {
key = prop->m_primData->getString();
if( NULL != prop->m_key ) {
name = prop->m_key->m_text.m_buffer;
if( Value::ddl_string == prop->m_value->m_type ) {
key = prop->m_value->getString();
}
}
}
@ -705,7 +709,7 @@ void OpenGEXImporter::handleIndexArrayNode( ODDLParser::DDLNode *node, aiScene *
Value *next( vaList->m_dataList );
for( size_t indices = 0; indices < current.mNumIndices; indices++ ) {
const int idx = next->getInt32();
ai_assert( idx <= m_currentVertices.m_numVerts );
ai_assert( static_cast<size_t>( idx ) <= m_currentVertices.m_numVerts );
aiVector3D &pos = ( m_currentVertices.m_vertices[ idx ] );
aiVector3D &normal = ( m_currentVertices.m_normals[ idx ] );
@ -725,30 +729,36 @@ void OpenGEXImporter::handleIndexArrayNode( ODDLParser::DDLNode *node, aiScene *
}
//------------------------------------------------------------------------------------------------
static void getColorRGBA( aiColor3D *pColor, Value *data ) {
if( NULL == pColor || NULL == data ) {
static void getColorRGB( aiColor3D *pColor, DataArrayList *colList ) {
if( NULL == pColor || NULL == colList ) {
return;
}
pColor->r = data->getFloat();
data = data->getNext();
pColor->g = data->getFloat();
data = data->getNext();
pColor->b = data->getFloat();
data = data->getNext();
ai_assert( 3 == colList->m_numItems );
Value *val( colList->m_dataList );
pColor->r = val->getFloat();
val = val->getNext();
pColor->g = val->getFloat();
val = val->getNext();
pColor->b = val->getFloat();
}
//------------------------------------------------------------------------------------------------
enum ColorType {
NoneColor = 0,
DiffuseColor
DiffuseColor,
SpecularColor,
EmissionColor
};
//------------------------------------------------------------------------------------------------
static ColorType getColorType( Identifier *id ) {
const int res(strncmp("diffuse", id->m_buffer, id->m_len ) );
if( 0 == res ) {
if( id->m_text == Grammar::DiffuseColorToken ) {
return DiffuseColor;
} else if( id->m_text == Grammar::SpecularColorToken ) {
return SpecularColor;
} else if( id->m_text == Grammar::EmissionColorToken ) {
return EmissionColor;
}
return NoneColor;
@ -769,9 +779,23 @@ void OpenGEXImporter::handleColorNode( ODDLParser::DDLNode *node, aiScene *pScen
return;
}
Property *colorProp = node->getProperties();
if( NULL != colorProp ) {
if( NULL != colorProp->m_id ) {
Property *prop = node->findPropertyByName( "attrib" );
if( NULL != prop ) {
if( NULL != prop->m_value ) {
DataArrayList *colList( node->getDataArrayList() );
if( NULL == colList ) {
return;
}
aiColor3D col;
getColorRGB( &col, colList );
const ColorType colType( getColorType( prop->m_key ) );
if( DiffuseColor == colType ) {
m_currentMaterial->AddProperty( &col, 1, AI_MATKEY_COLOR_DIFFUSE );
} else if( SpecularColor == colType ) {
m_currentMaterial->AddProperty( &col, 1, AI_MATKEY_COLOR_SPECULAR );
} else if( EmissionColor == colType ) {
m_currentMaterial->AddProperty( &col, 1, AI_MATKEY_COLOR_EMISSIVE );
}
}
}
}
@ -786,13 +810,10 @@ void OpenGEXImporter::copyMeshes( aiScene *pScene ) {
if( m_meshCache.empty() ) {
return;
}
pScene->mNumMeshes = m_meshCache.size();
pScene->mMeshes = new aiMesh*[ pScene->mNumMeshes ];
size_t i( 0 );
for( std::vector<aiMesh*>::iterator it = m_meshCache.begin(); it != m_meshCache.end(); it++ ) {
pScene->mMeshes[ i ] = *it;
i++;
}
std::copy( m_meshCache.begin(), m_meshCache.end(), pScene->mMeshes );
}
//------------------------------------------------------------------------------------------------
@ -833,13 +854,10 @@ void OpenGEXImporter::createNodeTree( aiScene *pScene ) {
if( m_root->m_children.empty() ) {
return;
}
size_t i( 0 );
pScene->mRootNode->mNumChildren = m_root->m_children.size();
pScene->mRootNode->mChildren = new C_STRUCT aiNode*[ pScene->mRootNode->mNumChildren ];
for( ChildInfo::NodeList::iterator it = m_root->m_children.begin(); it != m_root->m_children.end(); it++ ) {
pScene->mRootNode->mChildren[ i ] = *it;
i++;
}
pScene->mRootNode->mChildren = new aiNode*[ pScene->mRootNode->mNumChildren ];
std::copy( m_root->m_children.begin(), m_root->m_children.end(), pScene->mRootNode->mChildren );
}
//------------------------------------------------------------------------------------------------

2
code/OpenGEXImporter.h
View File

@ -43,7 +43,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef ASSIMP_BUILD_NO_OPENGEX_IMPORTER
#include "BaseImporter.h"
#include "../include/assimp/mesh.h"
#include <assimp/mesh.h>
#include <vector>
#include <list>

6
code/PlyExporter.cpp
View File

@ -44,11 +44,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "PlyExporter.h"
#include <boost/scoped_ptr.hpp>
#include <cmath>
#include "Exceptional.h"
#include "../include/assimp/scene.h"
#include "../include/assimp/version.h"
#include "../include/assimp/IOSystem.hpp"
#include "../include/assimp/Exporter.hpp"
#include "qnan.h"
using namespace Assimp;
@ -213,6 +215,8 @@ PlyExporter::PlyExporter(const char* _filename, const aiScene* pScene, bool bina
// ------------------------------------------------------------------------------------------------
void PlyExporter::WriteMeshVerts(const aiMesh* m, unsigned int components)
{
static const float inf = std::numeric_limits<float>::infinity();
// If a component (for instance normal vectors) is present in at least one mesh in the scene,
// then default values are written for meshes that do not contain this component.
for (unsigned int i = 0; i < m->mNumVertices; ++i) {
@ -222,7 +226,7 @@ void PlyExporter::WriteMeshVerts(const aiMesh* m, unsigned int components)
m->mVertices[i].z
;
if(components & PLY_EXPORT_HAS_NORMALS) {
if (m->HasNormals()) {
if (m->HasNormals() && is_not_qnan(m->mNormals[i].x) && std::fabs(m->mNormals[i].x) != inf) {
mOutput <<
" " << m->mNormals[i].x <<
" " << m->mNormals[i].y <<

2
code/PlyParser.cpp
View File

@ -47,7 +47,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "PlyLoader.h"
#include "fast_atof.h"
#include "../include/assimp/DefaultLogger.hpp"
#include "ByteSwap.h"
#include "ByteSwapper.h"
using namespace Assimp;

5
code/Q3BSPZipArchive.cpp
View File

@ -45,6 +45,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "Q3BSPZipArchive.h"
#include <algorithm>
#include <cassert>
#include <cstdlib>
#include "../include/assimp/ai_assert.h"
@ -140,11 +141,11 @@ zlib_filefunc_def IOSystem2Unzip::get(IOSystem* pIOHandler) {
ZipFile::ZipFile(size_t size) : m_Size(size) {
ai_assert(m_Size != 0);
m_Buffer = std::malloc(m_Size);
m_Buffer = malloc(m_Size);
}
ZipFile::~ZipFile() {
std::free(m_Buffer);
free(m_Buffer);
m_Buffer = NULL;
}

2
code/STEPFileEncoding.cpp
View File

@ -332,7 +332,7 @@ bool STEP::StringToUTF8(std::string& s)
case '4':
if (s[i+3] == '\\') {
const size_t basei = i+4;
size_t j = basei, jend = s.size()-4;
size_t j = basei, jend = s.size()-3;
for (; j < jend; ++j) {
if (s[j] == '\\' && s[j] == 'X' && s[j] == '0' && s[j] == '\\') {

2
code/STLExporter.cpp
View File

@ -49,7 +49,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "../include/assimp/Exporter.hpp"
#include <boost/scoped_ptr.hpp>
#include "Exceptional.h"
#include "ByteSwap.h"
#include "ByteSwapper.h"
using namespace Assimp;
namespace Assimp {

2
code/SceneCombiner.cpp
View File

@ -920,7 +920,7 @@ void SceneCombiner::MergeMaterials(aiMaterial** dest,
// Test if we already have a matching property
const aiMaterialProperty* prop_exist;
if(aiGetMaterialProperty(out, sprop->mKey.C_Str(), sprop->mType, sprop->mIndex, &prop_exist) != AI_SUCCESS) {
if(aiGetMaterialProperty(out, sprop->mKey.C_Str(), sprop->mSemantic, sprop->mIndex, &prop_exist) != AI_SUCCESS) {
// If not, we add it to the new material
aiMaterialProperty* prop = out->mProperties[out->mNumProperties] = new aiMaterialProperty();

2
code/StreamReader.h
View File

@ -45,7 +45,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_STREAMREADER_H_INCLUDED
#define AI_STREAMREADER_H_INCLUDED
#include "ByteSwap.h"
#include "ByteSwapper.h"
#include "Exceptional.h"
#include <boost/shared_ptr.hpp>
#include "../include/assimp/IOStream.hpp"

2
code/StreamWriter.h
View File

@ -45,7 +45,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef AI_STREAMWRITER_H_INCLUDED
#define AI_STREAMWRITER_H_INCLUDED
#include "ByteSwap.h"
#include "ByteSwapper.h"
#include "../include/assimp/IOStream.hpp"
#include <boost/shared_ptr.hpp>

2
code/StringComparison.h
View File

@ -51,6 +51,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#define INCLUDED_AI_STRING_WORKERS_H
#include "../include/assimp/ai_assert.h"
#include "StringComparison.h"
#include <string.h>
#include <stdint.h>
#include <string>

9
code/TextureTransform.cpp
View File

@ -42,11 +42,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "TextureTransform.h"
#include "../include/assimp/postprocess.h"
#include "../include/assimp/DefaultLogger.hpp"
#include "../include/assimp/scene.h"
#include <assimp/Importer.hpp>
#include <assimp/postprocess.h>
#include <assimp/DefaultLogger.hpp>
#include <assimp/scene.h>
#include "TextureTransform.h"
using namespace Assimp;

9
code/UnrealLoader.cpp
View File

@ -55,9 +55,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "ParsingUtils.h"
#include "fast_atof.h"
#include "ConvertToLHProcess.h"
#include "../include/assimp/DefaultLogger.hpp"
#include "../include/assimp/IOSystem.hpp"
#include "../include/assimp/scene.h"
#include <assimp/Importer.hpp>
#include <assimp/DefaultLogger.hpp>
#include <assimp/IOSystem.hpp>
#include <assimp/scene.h>
#include <boost/scoped_ptr.hpp>
using namespace Assimp;

2
code/XFileParser.cpp
View File

@ -50,7 +50,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "Exceptional.h"
#include <boost/format.hpp>
#include <boost/lexical_cast.hpp>
#include "ByteSwap.h"
#include "ByteSwapper.h"
#include "../include/assimp/DefaultLogger.hpp"

4
code/fast_atof.h
View File

@ -286,14 +286,14 @@ inline const char* fast_atoreal_move( const char* c, Real& out, bool check_comma
}
if (!(c[0] >= '0' && c[0] <= '9') &&
!(c[0] == '.' && c[1] >= '0' && c[1] <= '9'))
!((c[0] == '.' || (check_comma && c[0] == ',')) && c[1] >= '0' && c[1] <= '9'))
{
throw std::invalid_argument("Cannot parse string "
"as real number: does not start with digit "
"or decimal point followed by digit.");
}
if (*c != '.')
if (*c != '.' && (! check_comma || c[0] != ','))
{
f = static_cast<Real>( strtoul10_64 ( c, &c) );
}

2
contrib/openddlparser/code/DDLNode.cpp
View File

@ -153,7 +153,7 @@ Property *DDLNode::findPropertyByName( const std::string &name ) {
}
Property *current( m_properties );
while( ddl_nullptr != current ) {
int res = strncmp( current->m_id->m_buffer, name.c_str(), name.size() );
int res = strncmp( current->m_key->m_text.m_buffer, name.c_str(), name.size() );
if( 0 == res ) {
return current;
}

16
contrib/openddlparser/code/OpenDDLParser.cpp
View File

@ -87,7 +87,7 @@ static DDLNode *createDDLNode( Identifier *id, OpenDDLParser *parser ) {
return ddl_nullptr;
}
const std::string type( id->m_buffer );
const std::string type( id->m_text.m_buffer );
DDLNode *parent( parser->top() );
DDLNode *node = DDLNode::create( type, "", parent );
@ -191,8 +191,6 @@ bool OpenDDLParser::parse() {
normalizeBuffer( m_buffer );
std::cout << &m_buffer[0] << std::endl;
m_context = new Context;
m_context->m_root = DDLNode::create( "root", "", ddl_nullptr );
pushNode( m_context->m_root );
@ -217,7 +215,7 @@ char *OpenDDLParser::parseNextNode( char *in, char *end ) {
static void dumpId( Identifier *id ) {
if( ddl_nullptr != id ) {
std::cout << id->m_buffer << std::endl;
std::cout << id->m_text.m_buffer << std::endl;
}
}
@ -277,7 +275,7 @@ char *OpenDDLParser::parseHeader( char *in, char *end ) {
Name *name( ddl_nullptr );
in = OpenDDLParser::parseName( in, end, &name );
if( ddl_nullptr != name ) {
const std::string nodeName( name->m_id->m_buffer );
const std::string nodeName( name->m_id->m_text.m_buffer );
node->setName( nodeName );
}
}
@ -500,10 +498,8 @@ char *OpenDDLParser::parseIdentifier( char *in, char *end, Identifier **id ) {
idLen++;
}
const size_t len( idLen + 1 );
Identifier *newId = new Identifier( len, new char[ len ] );
::strncpy( newId->m_buffer, start, newId->m_len-1 );
newId->m_buffer[ newId->m_len - 1 ] = '\0';
const size_t len( idLen );
Identifier *newId = new Identifier( start, len );
*id = newId;
return in;
@ -714,7 +710,7 @@ char *OpenDDLParser::parseStringLiteral( char *in, char *end, Value **stringData
static void createPropertyWithData( Identifier *id, Value *primData, Property **prop ) {
if( ddl_nullptr != primData ) {
( *prop ) = new Property( id );
( *prop )->m_primData = primData;
( *prop )->m_value = primData;
}
}

110
contrib/openddlparser/include/openddlparser/OpenDDLCommon.h
View File

@ -26,6 +26,7 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#include <cstddef>
#include <vector>
#include <string>
#include <string.h>
@ -77,41 +78,83 @@ enum NameType {
LocalName
};
struct Token {
public:
Token( const char *token )
: m_token( token )
, m_size( 0 ){
if( ddl_nullptr != token ) {
m_size = strlen( m_token );
struct Text {
size_t m_capacity;
size_t m_len;
char *m_buffer;
Text( const char *buffer, size_t numChars )
: m_capacity( 0 )
, m_len( 0 )
, m_buffer( ddl_nullptr ) {
set( buffer, numChars );
}
~Text() {
clear();
}
void clear() {
delete[] m_buffer;
m_buffer = ddl_nullptr;
m_capacity = 0;
m_len = 0;
}
void set( const char *buffer, size_t numChars ) {
clear();
if( numChars > 0 ) {
m_len = numChars;
m_capacity = m_len + 1;
m_buffer = new char[ m_capacity ];
strncpy( m_buffer, buffer, numChars );
m_buffer[ numChars ] = '\0';
}
}
~Token() {
// empty
bool operator == ( const std::string &name ) const {
if( m_len != name.size() ) {
return false;
}
const int res( strncmp( m_buffer, name.c_str(), name.size() ) );
return ( 0 == res );
}
size_t length() const {
return m_size;
}
bool operator == ( const Token &rhs ) const {
if( m_size != rhs.m_size ) {
bool operator == ( const Text &rhs ) const {
if( m_len != rhs.m_len ) {
return false;
}
const int res( strncmp( m_token, rhs.m_token, m_size ) );
return ( res == 0 );
const int res ( strncmp( m_buffer, rhs.m_buffer, m_len ) );
return ( 0 == res );
}
private:
Token();
Token( const Token & );
Token &operator = ( const Token & );
Text( const Text & );
Text &operator = ( const Text & );
};
struct Identifier {
Text m_text;
Identifier( char buffer[], size_t len )
: m_text( buffer, len ) {
// empty
}
Identifier( char buffer[] )
: m_text( buffer, strlen( buffer ) ) {
// empty
}
bool operator == ( const Identifier &rhs ) const {
return m_text == rhs.m_text;
}
private:
const char *m_token;
size_t m_size;
Identifier( const Identifier & );
Identifier &operator = ( const Identifier & );
};
struct Name {
@ -154,30 +197,15 @@ private:
Reference &operator = ( const Reference & );
};
struct Identifier {
size_t m_len;
char *m_buffer;
Identifier( size_t len, char buffer[] )
: m_len( len )
, m_buffer( buffer ) {
// empty
}
private:
Identifier( const Identifier & );
Identifier &operator = ( const Identifier & );
};
struct Property {
Identifier *m_id;
Value *m_primData;
Identifier *m_key;
Value *m_value;
Reference *m_ref;
Property *m_next;
Property( Identifier *id )
: m_id( id )
, m_primData( ddl_nullptr )
: m_key( id )
, m_value( ddl_nullptr )
, m_ref( ddl_nullptr )
, m_next( ddl_nullptr ) {
// empty

17
contrib/openddlparser/include/openddlparser/OpenDDLParserUtils.h
View File

@ -107,6 +107,12 @@ bool isNumeric( const T in ) {
return false;*/
}
template<class T>
inline
bool isNotEndOfToken( T *in, T *end ) {
return ( '}' != *in && ',' != *in && !isSpace( *in ) && in != end );
}
template<class T>
inline
bool isInteger( T *in, T *end ) {
@ -117,7 +123,8 @@ bool isInteger( T *in, T *end ) {
}
bool result( false );
while( '}' != *in && ',' != *in && !isSpace( *in ) && in != end ) {
while( isNotEndOfToken( in, end ) ) {
//while( '}' != *in && ',' != *in && !isSpace( *in ) && in != end ) {
result = isNumeric( *in );
if( !result ) {
break;
@ -139,7 +146,9 @@ bool isFloat( T *in, T *end ) {
// check for <1>.0f
bool result( false );
while( !isSpace( *in ) && in != end ) {
while( isNotEndOfToken( in, end ) ) {
// while( !isSpace( *in ) && in != end ) {
if( *in == '.' ) {
result = true;
break;
@ -159,7 +168,9 @@ bool isFloat( T *in, T *end ) {
}
// check for 1.<0>f
while( !isSpace( *in ) && in != end && *in != ',' ) {
while( isNotEndOfToken( in, end ) ) {
// while( !isSpace( *in ) && in != end && *in != ',' && *in != '}' ) {
result = isNumeric( *in );
if( !result ) {
return false;

2
doc/dox.h
View File

@ -1586,7 +1586,7 @@ Don't trust the input data! Check all offsets!
Mixed stuff for internal use by loaders, mostly documented (most of them are already included by <i>AssimpPCH.h</i>):
<ul>
<li><b>ByteSwap</b> (<i>ByteSwap.h</i>) - manual byte swapping stuff for binary loaders.</li>
<li><b>ByteSwapper</b> (<i>ByteSwapper.h</i>) - manual byte swapping stuff for binary loaders.</li>
<li><b>StreamReader</b> (<i>StreamReader.h</i>) - safe, endianess-correct, binary reading.</li>
<li><b>IrrXML</b> (<i>irrXMLWrapper.h</i>) - for XML-parsing (SAX.</li>
<li><b>CommentRemover</b> (<i>RemoveComments.h</i>) - remove single-line and multi-line comments from a text file.</li>

21
include/assimp/Exporter.hpp
View File

@ -348,16 +348,14 @@ public:
* are defined in the aiConfig.g header (all constants share the
* prefix AI_CONFIG_XXX and are simple strings).
* @param iValue New value of the property
* @param bWasExisting Optional pointer to receive true if the
* property was set before. The new value replaces the previous value
* in this case.
* @return true if the property was set before. The new value replaces
* the previous value in this case.
* @note Property of different types (float, int, string ..) are kept
* on different stacks, so calling SetPropertyInteger() for a
* floating-point property has no effect - the loader will call
* GetPropertyFloat() to read the property, but it won't be there.
*/
void SetPropertyInteger(const char* szName, int iValue,
bool* bWasExisting = NULL);
bool SetPropertyInteger(const char* szName, int iValue);
// -------------------------------------------------------------------
/** Set a boolean configuration property. Boolean properties
@ -366,30 +364,27 @@ public:
* #GetPropertyBool and vice versa.
* @see SetPropertyInteger()
*/
void SetPropertyBool(const char* szName, bool value, bool* bWasExisting = NULL) {
SetPropertyInteger(szName,value,bWasExisting);
bool SetPropertyBool(const char* szName, bool value) {
return SetPropertyInteger(szName,value);
}
// -------------------------------------------------------------------
/** Set a floating-point configuration property.
* @see SetPropertyInteger()
*/
void SetPropertyFloat(const char* szName, float fValue,
bool* bWasExisting = NULL);
bool SetPropertyFloat(const char* szName, float fValue);
// -------------------------------------------------------------------
/** Set a string configuration property.
* @see SetPropertyInteger()
*/
void SetPropertyString(const char* szName, const std::string& sValue,
bool* bWasExisting = NULL);
bool SetPropertyString(const char* szName, const std::string& sValue);
// -------------------------------------------------------------------
/** Set a matrix configuration property.
* @see SetPropertyInteger()
*/
void SetPropertyMatrix(const char* szName, const aiMatrix4x4& sValue,
bool* bWasExisting = NULL);
bool SetPropertyMatrix(const char* szName, const aiMatrix4x4& sValue);
// -------------------------------------------------------------------
/** Get a configuration property.

21
include/assimp/Importer.hpp
View File

@ -194,16 +194,14 @@ public:
* are defined in the aiConfig.g header (all constants share the
* prefix AI_CONFIG_XXX and are simple strings).
* @param iValue New value of the property
* @param bWasExisting Optional pointer to receive true if the
* property was set before. The new value replaces the previous value
* in this case.
* @return true if the property was set before. The new value replaces
* the previous value in this case.
* @note Property of different types (float, int, string ..) are kept
* on different stacks, so calling SetPropertyInteger() for a
* floating-point property has no effect - the loader will call
* GetPropertyFloat() to read the property, but it won't be there.
*/
void SetPropertyInteger(const char* szName, int iValue,
bool* bWasExisting = NULL);
bool SetPropertyInteger(const char* szName, int iValue);
// -------------------------------------------------------------------
/** Set a boolean configuration property. Boolean properties
@ -212,30 +210,27 @@ public:
* #GetPropertyBool and vice versa.
* @see SetPropertyInteger()
*/
void SetPropertyBool(const char* szName, bool value, bool* bWasExisting = NULL) {
SetPropertyInteger(szName,value,bWasExisting);
bool SetPropertyBool(const char* szName, bool value) {
return SetPropertyInteger(szName,value);
}
// -------------------------------------------------------------------
/** Set a floating-point configuration property.
* @see SetPropertyInteger()
*/
void SetPropertyFloat(const char* szName, float fValue,
bool* bWasExisting = NULL);
bool SetPropertyFloat(const char* szName, float fValue);
// -------------------------------------------------------------------
/** Set a string configuration property.
* @see SetPropertyInteger()
*/
void SetPropertyString(const char* szName, const std::string& sValue,
bool* bWasExisting = NULL);
bool SetPropertyString(const char* szName, const std::string& sValue);
// -------------------------------------------------------------------
/** Set a matrix configuration property.
* @see SetPropertyInteger()
*/
void SetPropertyMatrix(const char* szName, const aiMatrix4x4& sValue,
bool* bWasExisting = NULL);
bool SetPropertyMatrix(const char* szName, const aiMatrix4x4& sValue);
// -------------------------------------------------------------------
/** Get a configuration property.

17
include/assimp/config.h
View File

@ -877,8 +877,24 @@ enum aiComponent
*/
#define AI_CONFIG_IMPORT_IFC_CUSTOM_TRIANGULATION "IMPORT_IFC_CUSTOM_TRIANGULATION"
// ---------------------------------------------------------------------------
/** @brief Specifies whether the Collada loader will ignore the provided up direction.
*
* If this property is set to true, the up direction provided in the file header will
* be ignored and the file will be loaded as is.
* Property type: Bool. Default value: false.
*/
#define AI_CONFIG_IMPORT_COLLADA_IGNORE_UP_DIRECTION "IMPORT_COLLADA_IGNORE_UP_DIRECTION"
// ---------------------------------------------------------------------------
/** @brief Specifies whether the Collada loader will invert the transparency value.
*
* If this property is set to true, the transparency value will be interpreted as the
* inverse of the usual transparency. This is useful because lots of exporters does
* not respect the standard and do the opposite of what is normally expected.
* Property type: Bool. Default value: false.
*/
#define AI_CONFIG_IMPORT_COLLADA_INVERT_TRANSPARENCY "IMPORT_COLLADA_INVERT_TRANSPARENCY"
// ---------- All the Export defines ------------
@ -889,5 +905,4 @@ enum aiComponent
#define AI_CONFIG_EXPORT_XFILE_64BIT "EXPORT_XFILE_64BIT"
#endif // !! AI_CONFIG_H_INC

11
test/unit/utImporter.cpp
View File

@ -131,21 +131,19 @@ TEST_F(ImporterTest, testMemoryRead)
// ------------------------------------------------------------------------------------------------
TEST_F(ImporterTest, testIntProperty)
{
bool b;
pImp->SetPropertyInteger("quakquak",1503,&b);
bool b = pImp->SetPropertyInteger("quakquak",1503);
EXPECT_FALSE(b);
EXPECT_EQ(1503, pImp->GetPropertyInteger("quakquak",0));
EXPECT_EQ(314159, pImp->GetPropertyInteger("not_there",314159));
pImp->SetPropertyInteger("quakquak",1504,&b);
b = pImp->SetPropertyInteger("quakquak",1504);
EXPECT_TRUE(b);
}
// ------------------------------------------------------------------------------------------------
TEST_F(ImporterTest, testFloatProperty)
{
bool b;
pImp->SetPropertyFloat("quakquak",1503.f,&b);
bool b = pImp->SetPropertyFloat("quakquak",1503.f);
EXPECT_TRUE(!b);
EXPECT_EQ(1503.f, pImp->GetPropertyFloat("quakquak",0.f));
EXPECT_EQ(314159.f, pImp->GetPropertyFloat("not_there",314159.f));
@ -154,8 +152,7 @@ TEST_F(ImporterTest, testFloatProperty)
// ------------------------------------------------------------------------------------------------
TEST_F(ImporterTest, testStringProperty)
{
bool b;
pImp->SetPropertyString("quakquak","test",&b);
bool b = pImp->SetPropertyString("quakquak","test");
EXPECT_TRUE(!b);
EXPECT_EQ("test", pImp->GetPropertyString("quakquak","weghwekg"));
EXPECT_EQ("ILoveYou", pImp->GetPropertyString("not_there","ILoveYou"));

1
tools/assimp_view/AnimEvaluator.cpp
View File

@ -39,7 +39,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------------
*/
#include "stdafx.h"
#include "assimp_view.h"
using namespace AssimpView;

9
tools/assimp_view/AssetHelper.h
View File

@ -43,6 +43,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#if (!defined AV_ASSET_HELPER_H_INCLUDED)
#define AV_ASSET_HELPER_H_INCLUDED
#include <d3d9.h>
#include <d3dx9.h>
#include <d3dx9mesh.h>
#include <assimp/scene.h>
namespace AssimpView {
class SceneAnimator;
//-------------------------------------------------------------------------------
@ -233,5 +241,6 @@ class AssetHelper
void FlipNormals();
void FlipNormalsInt();
};
}
#endif // !! IG

3
tools/assimp_view/Background.cpp
View File

@ -39,12 +39,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------------
*/
#include "stdafx.h"
#include "assimp_view.h"
namespace AssimpView {
extern std::string g_szSkyboxShader;
// From: U3D build 1256 (src\kernel\graphic\scenegraph\SkyBox.cpp)
// ------------------------------------------------------------------------------

8
tools/assimp_view/Background.h
View File

@ -38,10 +38,10 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------------
*/
#pragma once
#if (!defined AV_BACKGROUND_H_INCLUDED)
#define AV_BACKGROUND_H_INCLUDED
namespace AssimpView
{
class CBackgroundPainter
{
@ -125,4 +125,4 @@ private:
aiMatrix4x4 mMatrix;
};
#endif // !! AV_BACKGROUND_H_INCLUDED
}

13
tools/assimp_view/Display.cpp
View File

@ -38,13 +38,16 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------------
*/
#include "stdafx.h"
#include "assimp_view.h"
#include "AnimEvaluator.h"
#include "SceneAnimator.h"
namespace AssimpView {
using namespace Assimp;
extern std::string g_szCheckerBackgroundShader;
struct SVertex
{
float x,y,z,w,u,v;
@ -690,7 +693,7 @@ int CDisplay::FillDisplayList(void)
// fill in the first entry
TVITEMEX tvi;
TVINSERTSTRUCT sNew;
tvi.pszText = "Model";
tvi.pszText = (char*) "Model";
tvi.cchTextMax = (int)strlen(tvi.pszText);
tvi.mask = TVIF_TEXT | TVIF_SELECTEDIMAGE | TVIF_IMAGE | TVIF_HANDLE | TVIF_STATE;
tvi.state = TVIS_EXPANDED;
@ -2240,7 +2243,7 @@ int CDisplay::RenderTextureView()
const float ny = (float)sRect.bottom;
const float x = (float)sDesc.Width;
const float y = (float)sDesc.Height;
float f = std::min((nx-30) / x,(ny-30) / y) * (m_fTextureZoom/1000.0f);
float f = min((nx-30) / x,(ny-30) / y) * (m_fTextureZoom/1000.0f);
float fHalfX = (nx - (f * x)) / 2.0f;
float fHalfY = (ny - (f * y)) / 2.0f;

8
tools/assimp_view/Display.h
View File

@ -42,6 +42,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#if (!defined AV_DISPLAY_H_INCLUDED)
#define AV_DISPLAY_H_INCLUDE
#include <windows.h>
#include <shellapi.h>
#include <commctrl.h>
// see CDisplay::m_aiImageList
#define AI_VIEW_IMGLIST_NODE 0x0
#define AI_VIEW_IMGLIST_MATERIAL 0x1
@ -49,6 +53,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#define AI_VIEW_IMGLIST_TEXTURE_INVALID 0x3
#define AI_VIEW_IMGLIST_MODEL 0x4
namespace AssimpView
{
//-------------------------------------------------------------------------------
/* Corresponds to the "Display" combobox in the UI
*/
@ -531,4 +538,5 @@ private:
aiVector3D vPos;
};
}
#endif // AV_DISPLAY_H_INCLUDE

2
tools/assimp_view/HelpDialog.cpp
View File

@ -39,14 +39,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------------
*/
#include "stdafx.h"
#include "assimp_view.h"
#include "richedit.h"
namespace AssimpView {
//-------------------------------------------------------------------------------
// Message procedure for the help dialog
//-------------------------------------------------------------------------------

2
tools/assimp_view/Input.cpp
View File

@ -39,10 +39,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------------
*/
#include "stdafx.h"
#include "assimp_view.h"
namespace AssimpView {
//-------------------------------------------------------------------------------

5
tools/assimp_view/LogDisplay.cpp
View File

@ -39,14 +39,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------------
*/
#include "stdafx.h"
#include "assimp_view.h"
namespace AssimpView {
/* extern */ CLogDisplay CLogDisplay::s_cInstance;
CLogDisplay CLogDisplay::s_cInstance;
//-------------------------------------------------------------------------------
void CLogDisplay::AddEntry(const std::string& szText,

9
tools/assimp_view/LogDisplay.h
View File

@ -38,9 +38,12 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------------
*/
#pragma once
#if (!defined AV_LOG_DISPLAY_H_INCLUDED)
#define AV_LOG_DISPLAY_H_INCLUDE
#include <list>
namespace AssimpView
{
//-------------------------------------------------------------------------------
/** \brief Class to display log strings in the upper right corner of the view
@ -93,4 +96,4 @@ private:
ID3DXFont* piFont;
};
#endif // AV_LOG_DISPLAY_H_INCLUDE
}

4
tools/assimp_view/LogWindow.cpp
View File

@ -39,13 +39,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------------
*/
#include "stdafx.h"
#include "assimp_view.h"
#include "richedit.h"
namespace AssimpView {
/* extern */ CLogWindow CLogWindow::s_cInstance;
CLogWindow CLogWindow::s_cInstance;
extern HKEY g_hRegistry;
// header for the RTF log file

5
tools/assimp_view/LogWindow.h
View File

@ -42,6 +42,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#if (!defined AV_LOG_WINDOW_H_INCLUDED)
#define AV_LOG_WINDOW_H_INCLUDE
namespace AssimpView
{
//-------------------------------------------------------------------------------
/** \brief Subclass of Assimp::LogStream used to add all log messages to the
@ -125,4 +128,6 @@ public:
CMyLogStream* pcStream;
};
}
#endif // AV_LOG_DISPLA

99
tools/assimp_view/Material.cpp
View File

@ -38,15 +38,106 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------------
*/
#include "stdafx.h"
#include "assimp_view.h"
#include "MaterialManager.h"
#include "AssetHelper.h"
#include <assimp/cimport.h>
#include <assimp/Importer.hpp>
#include <assimp/ai_assert.h>
#include <assimp/cfileio.h>
#include <assimp/postprocess.h>
#include <assimp/scene.h>
#include <assimp/IOSystem.hpp>
#include <assimp/IOStream.hpp>
#include <assimp/LogStream.hpp>
#include <assimp/DefaultLogger.hpp>
#include <../code/StringComparison.h>
#include <vector>
#include <algorithm>
namespace AssimpView {
using namespace Assimp;
/*static */ CMaterialManager CMaterialManager::s_cInstance;
extern std::string g_szMaterialShader;
extern HINSTANCE g_hInstance /*= NULL*/;
extern HWND g_hDlg /*= NULL*/;
extern IDirect3D9* g_piD3D /*= NULL*/;
extern IDirect3DDevice9* g_piDevice /*= NULL*/;
extern IDirect3DVertexDeclaration9* gDefaultVertexDecl /*= NULL*/;
extern double g_fFPS /*= 0.0f*/;
extern char g_szFileName[ MAX_PATH ];
extern ID3DXEffect* g_piDefaultEffect /*= NULL*/;
extern ID3DXEffect* g_piNormalsEffect /*= NULL*/;
extern ID3DXEffect* g_piPassThroughEffect /*= NULL*/;
extern ID3DXEffect* g_piPatternEffect /*= NULL*/;
extern bool g_bMousePressed /*= false*/;
extern bool g_bMousePressedR /*= false*/;
extern bool g_bMousePressedM /*= false*/;
extern bool g_bMousePressedBoth /*= false*/;
extern float g_fElpasedTime /*= 0.0f*/;
extern D3DCAPS9 g_sCaps;
extern bool g_bLoadingFinished /*= false*/;
extern HANDLE g_hThreadHandle /*= NULL*/;
extern float g_fWheelPos /*= -10.0f*/;
extern bool g_bLoadingCanceled /*= false*/;
extern IDirect3DTexture9* g_pcTexture /*= NULL*/;
extern aiMatrix4x4 g_mWorld;
extern aiMatrix4x4 g_mWorldRotate;
extern aiVector3D g_vRotateSpeed /*= aiVector3D(0.5f,0.5f,0.5f)*/;
extern aiVector3D g_avLightDirs[ 1 ] /* =
{ aiVector3D(-0.5f,0.6f,0.2f) ,
aiVector3D(-0.5f,0.5f,0.5f)} */;
extern POINT g_mousePos /*= {0,0};*/;
extern POINT g_LastmousePos /*= {0,0}*/;
extern bool g_bFPSView /*= false*/;
extern bool g_bInvert /*= false*/;
extern EClickPos g_eClick;
extern unsigned int g_iCurrentColor /*= 0*/;
// NOTE: The light intensity is separated from the color, it can
// directly be manipulated using the middle mouse button.
// When the user chooses a color from the palette the intensity
// is reset to 1.0
// index[2] is the ambient color
extern float g_fLightIntensity /*=0.0f*/;
extern D3DCOLOR g_avLightColors[ 3 ];
extern RenderOptions g_sOptions;
extern Camera g_sCamera;
extern AssetHelper *g_pcAsset /*= NULL*/;
//
// Contains the mask image for the HUD
// (used to determine the position of a click)
//
// The size of the image is identical to the size of the main
// HUD texture
//
extern unsigned char* g_szImageMask /*= NULL*/;
extern float g_fACMR /*= 3.0f*/;
extern IDirect3DQuery9* g_piQuery;
extern bool g_bPlay /*= false*/;
extern double g_dCurrent;
extern float g_smoothAngle /*= 80.f*/;
extern unsigned int ppsteps, ppstepsdefault;
extern bool nopointslines;
CMaterialManager CMaterialManager::s_cInstance;
//-------------------------------------------------------------------------------
// D3DX callback function to fill a texture with a checkers pattern
@ -184,7 +275,7 @@ bool CMaterialManager::TryLongerPath(char* szTemp,aiString* p_szString)
for (unsigned int i = 0; i < iSizeFound;++i)
info.cFileName[i] = (CHAR)tolower(info.cFileName[i]);
if (0 == memcmp(info.cFileName,szFile2, std::min(iSizeFound,iSize)))
if (0 == memcmp(info.cFileName,szFile2, min(iSizeFound,iSize)))
{
// we have it. Build the full path ...
char* sz = strrchr(szTempB,'*');

12
tools/assimp_view/MaterialManager.h
View File

@ -39,8 +39,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------------
*/
#if (!defined AV_MATERIAL_H_INCLUDED)
#define AV_MATERIAL_H_INCLUDE
#pragma once
#include <map>
#include "AssetHelper.h"
namespace AssimpView
{
//-------------------------------------------------------------------------------
/* Helper class to create, access and destroy materials
@ -199,4 +205,4 @@ private:
TextureCache sCachedTextures;
};
#endif //!! include guard
}

2
tools/assimp_view/MeshRenderer.cpp
View File

@ -39,7 +39,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------------
*/
#include "stdafx.h"
#include "assimp_view.h"
#include <map>
@ -47,7 +46,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
namespace AssimpView {
CMeshRenderer CMeshRenderer::s_cInstance;
//-------------------------------------------------------------------------------

2
tools/assimp_view/MeshRenderer.h
View File

@ -42,6 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#if (!defined AV_MESH_RENDERER_H_INCLUDED)
#define AV_MESH_RENDERER_H_INCLUDED
namespace AssimpView {
//-------------------------------------------------------------------------------
@ -94,4 +95,5 @@ private:
};
}
#endif //!! include guard

10
tools/assimp_view/MessageProc.cpp
View File

@ -39,12 +39,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------------
*/
#include "stdafx.h"
#include "assimp_view.h"
#include <assimp/Exporter.hpp>
#include <algorithm>
#include <windowsx.h>
namespace AssimpView {
using namespace Assimp;
// Static array to keep custom color values
COLORREF g_aclCustomColors[16] = {0};
@ -1044,9 +1048,9 @@ void DoExport(size_t formatId)
ai_assert(strlen(szFileName) <= MAX_PATH);
// invent a nice default file name
char* sz = std::max(strrchr(szFileName,'\\'),strrchr(szFileName,'/'));
char* sz = max(strrchr(szFileName,'\\'),strrchr(szFileName,'/'));
if (sz) {
strncpy(sz,std::max(strrchr(g_szFileName,'\\'),strrchr(g_szFileName,'/')),MAX_PATH);
strncpy(sz,max(strrchr(g_szFileName,'\\'),strrchr(g_szFileName,'/')),MAX_PATH);
}
}
else {

2
tools/assimp_view/Normals.cpp
View File

@ -40,7 +40,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "stdafx.h"
#include "assimp_view.h"
// note: these are no longer part of the public API, but they are
@ -53,6 +52,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
namespace AssimpView {
using namespace Assimp;
bool g_bWasFlipped = false;
float g_smoothAngle = 80.f;

1
tools/assimp_view/SceneAnimator.cpp
View File

@ -43,7 +43,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* @brief Implementation of the utility class SceneAnimator
*/
#include "stdafx.h"
#include "assimp_view.h"
using namespace AssimpView;

6
tools/assimp_view/Shaders.cpp
View File

@ -38,13 +38,9 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------------
*/
#include "stdafx.h"
#include "assimp_view.h"
namespace AssimpView
{
namespace AssimpView {
// ------------------------------------------------------------------------------------------------
std::string g_szNormalsShader = std::string(

27
tools/assimp_view/assimp_view.cpp
View File

@ -40,16 +40,17 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "stdafx.h"
#include "assimp_view.h"
#include <map>
using namespace std;
namespace AssimpView {
extern std::string g_szNormalsShader;
extern std::string g_szDefaultShader;
extern std::string g_szPassThroughShader;
//-------------------------------------------------------------------------------
// evil globals
//-------------------------------------------------------------------------------
HINSTANCE g_hInstance = NULL;
HWND g_hDlg = NULL;
@ -361,12 +362,12 @@ int CalculateBounds(aiNode* piNode, aiVector3D* p_avOut,
D3DXVec3TransformCoord((D3DXVECTOR3*)&pc1,(D3DXVECTOR3*)&pc,
(D3DXMATRIX*)&aiMe);
p_avOut[0].x = std::min( p_avOut[0].x, pc1.x);
p_avOut[0].y = std::min( p_avOut[0].y, pc1.y);
p_avOut[0].z = std::min( p_avOut[0].z, pc1.z);
p_avOut[1].x = std::max( p_avOut[1].x, pc1.x);
p_avOut[1].y = std::max( p_avOut[1].y, pc1.y);
p_avOut[1].z = std::max( p_avOut[1].z, pc1.z);
p_avOut[0].x = min( p_avOut[0].x, pc1.x);
p_avOut[0].y = min( p_avOut[0].y, pc1.y);
p_avOut[0].z = min( p_avOut[0].z, pc1.z);
p_avOut[1].x = max( p_avOut[1].x, pc1.x);
p_avOut[1].y = max( p_avOut[1].y, pc1.y);
p_avOut[1].z = max( p_avOut[1].z, pc1.z);
}
}
for (unsigned int i = 0; i < piNode->mNumChildren;++i)
@ -593,10 +594,10 @@ int CreateAssetData()
if (mesh->HasVertexColors( 0)) {
pbData2->dColorDiffuse = D3DCOLOR_ARGB(
((unsigned char)std::max( std::min( mesh->mColors[0][x].a * 255.0f, 255.0f),0.0f)),
((unsigned char)std::max( std::min( mesh->mColors[0][x].r * 255.0f, 255.0f),0.0f)),
((unsigned char)std::max( std::min( mesh->mColors[0][x].g * 255.0f, 255.0f),0.0f)),
((unsigned char)std::max( std::min( mesh->mColors[0][x].b * 255.0f, 255.0f),0.0f)));
((unsigned char)max( min( mesh->mColors[0][x].a * 255.0f, 255.0f),0.0f)),
((unsigned char)max( min( mesh->mColors[0][x].r * 255.0f, 255.0f),0.0f)),
((unsigned char)max( min( mesh->mColors[0][x].g * 255.0f, 255.0f),0.0f)),
((unsigned char)max( min( mesh->mColors[0][x].b * 255.0f, 255.0f),0.0f)));
}
else pbData2->dColorDiffuse = D3DCOLOR_ARGB(0xFF,0xff,0xff,0xff);

29
tools/assimp_view/assimp_view.h
View File

@ -47,6 +47,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// include resource definitions
#include "resource.h"
#include <assert.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>
#include <stdio.h>
#include <time.h>
// Include ASSIMP headers (XXX: do we really need all of them?)
#include <assimp/cimport.h>
#include <assimp/Importer.hpp>
@ -59,17 +67,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <assimp/LogStream.hpp>
#include <assimp/DefaultLogger.hpp>
#include "../../code/AssimpPCH.h" /* HACK */
#include "../../code/MaterialSystem.h" // aiMaterial class
#include "../../code/StringComparison.h" // ASSIMP_stricmp and ASSIMP_strincmp
// in order for std::min and std::max to behave properly
#ifdef min
#undef min
#endif // min
#ifdef max
#undef max
#ifndef max
#define max(a,b) (((a) > (b)) ? (a) : (b))
#endif // max
#ifndef min
#define min(a,b) (((a) < (b)) ? (a) : (b))
#endif // min
#include <time.h>
@ -77,11 +84,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// default movement speed
#define MOVE_SPEED 3.f
using namespace Assimp;
namespace AssimpView
{
#include "AssetHelper.h"
#include "Camera.h"
#include "RenderOptions.h"
@ -93,7 +95,6 @@ namespace AssimpView
#include "MeshRenderer.h"
#include "MaterialManager.h"
} // end of namespace AssimpView - for a while
// outside of namespace, to help Intellisense and solve boost::metatype_stuff_miracle
#include "AnimEvaluator.h"
@ -160,7 +161,7 @@ INT_PTR CALLBACK AboutMessageProc(HWND hwndDlg,UINT uMsg,
//-------------------------------------------------------------------------------
//
// Dialog prcoedure for the help dialog
// Dialog procedure for the help dialog
//
//-------------------------------------------------------------------------------
INT_PTR CALLBACK HelpDialogProc(HWND hwndDlg,UINT uMsg,
@ -182,7 +183,7 @@ type clamp(intype in)
{
// for unsigned types only ...
intype mask = (0x1u << (sizeof(type)*8))-1;
return (type)std::max((intype)0,std::min(in,mask));
return (type)max((intype)0,min(in,mask));
}

24
workspaces/xcode3/assimp.xcodeproj/project.pbxproj
View File

@ -117,11 +117,11 @@
2B7F478E1708365200A106A9 /* tuple.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 2B7F45961708365100A106A9 /* tuple.hpp */; };
2B7F478F1708365200A106A9 /* tuple.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 2B7F45961708365100A106A9 /* tuple.hpp */; };
2B7F47901708365200A106A9 /* tuple.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 2B7F45961708365100A106A9 /* tuple.hpp */; };
2B7F479B1708365200A106A9 /* ByteSwap.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B7F45991708365100A106A9 /* ByteSwap.h */; };
2B7F479C1708365200A106A9 /* ByteSwap.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B7F45991708365100A106A9 /* ByteSwap.h */; };
2B7F479D1708365200A106A9 /* ByteSwap.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B7F45991708365100A106A9 /* ByteSwap.h */; };
2B7F479E1708365200A106A9 /* ByteSwap.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B7F45991708365100A106A9 /* ByteSwap.h */; };
2B7F479F1708365200A106A9 /* ByteSwap.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B7F45991708365100A106A9 /* ByteSwap.h */; };
2B7F479B1708365200A106A9 /* ByteSwapper.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B7F45991708365100A106A9 /* ByteSwapper.h */; };
2B7F479C1708365200A106A9 /* ByteSwapper.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B7F45991708365100A106A9 /* ByteSwapper.h */; };
2B7F479D1708365200A106A9 /* ByteSwapper.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B7F45991708365100A106A9 /* ByteSwapper.h */; };
2B7F479E1708365200A106A9 /* ByteSwapper.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B7F45991708365100A106A9 /* ByteSwapper.h */; };
2B7F479F1708365200A106A9 /* ByteSwapper.h in Headers */ = {isa = PBXBuildFile; fileRef = 2B7F45991708365100A106A9 /* ByteSwapper.h */; };
2B7F47A01708365200A106A9 /* CalcTangentsProcess.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B7F459A1708365100A106A9 /* CalcTangentsProcess.cpp */; };
2B7F47A11708365200A106A9 /* CalcTangentsProcess.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B7F459A1708365100A106A9 /* CalcTangentsProcess.cpp */; };
2B7F47A21708365200A106A9 /* CalcTangentsProcess.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2B7F459A1708365100A106A9 /* CalcTangentsProcess.cpp */; };
@ -2018,7 +2018,7 @@
2B7F45931708365100A106A9 /* static_assert.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = static_assert.hpp; sourceTree = "<group>"; };
2B7F45941708365100A106A9 /* timer.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = timer.hpp; sourceTree = "<group>"; };
2B7F45961708365100A106A9 /* tuple.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = tuple.hpp; sourceTree = "<group>"; };
2B7F45991708365100A106A9 /* ByteSwap.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ByteSwap.h; sourceTree = "<group>"; };
2B7F45991708365100A106A9 /* ByteSwapper.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ByteSwapper.h; sourceTree = "<group>"; };
2B7F459A1708365100A106A9 /* CalcTangentsProcess.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CalcTangentsProcess.cpp; sourceTree = "<group>"; };
2B7F459B1708365100A106A9 /* CalcTangentsProcess.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CalcTangentsProcess.h; sourceTree = "<group>"; };
2B7F459C1708365100A106A9 /* CInterfaceIOWrapper.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CInterfaceIOWrapper.h; sourceTree = "<group>"; };
@ -2509,7 +2509,7 @@
2B7F45761708365100A106A9 /* BaseProcess.cpp */,
2B7F45771708365100A106A9 /* BaseProcess.h */,
2B7F45831708365100A106A9 /* BlobIOSystem.h */,
2B7F45991708365100A106A9 /* ByteSwap.h */,
2B7F45991708365100A106A9 /* ByteSwapper.h */,
2B7F459A1708365100A106A9 /* CalcTangentsProcess.cpp */,
2B7F459B1708365100A106A9 /* CalcTangentsProcess.h */,
2B7F459C1708365100A106A9 /* CInterfaceIOWrapper.h */,
@ -3517,7 +3517,7 @@
2B7F47841708365200A106A9 /* static_assert.hpp in Headers */,
2B7F47891708365200A106A9 /* timer.hpp in Headers */,
2B7F478E1708365200A106A9 /* tuple.hpp in Headers */,
2B7F479D1708365200A106A9 /* ByteSwap.h in Headers */,
2B7F479D1708365200A106A9 /* ByteSwapper.h in Headers */,
2B7F47A71708365200A106A9 /* CalcTangentsProcess.h in Headers */,
2B7F47AC1708365200A106A9 /* CInterfaceIOWrapper.h in Headers */,
2B7F47C51708365200A106A9 /* ColladaExporter.h in Headers */,
@ -3765,7 +3765,7 @@
2B7F47851708365200A106A9 /* static_assert.hpp in Headers */,
2B7F478A1708365200A106A9 /* timer.hpp in Headers */,
2B7F478F1708365200A106A9 /* tuple.hpp in Headers */,
2B7F479E1708365200A106A9 /* ByteSwap.h in Headers */,
2B7F479E1708365200A106A9 /* ByteSwapper.h in Headers */,
2B7F47A81708365200A106A9 /* CalcTangentsProcess.h in Headers */,
2B7F47AD1708365200A106A9 /* CInterfaceIOWrapper.h in Headers */,
2B7F47C61708365200A106A9 /* ColladaExporter.h in Headers */,
@ -4013,7 +4013,7 @@
2B7F47861708365200A106A9 /* static_assert.hpp in Headers */,
2B7F478B1708365200A106A9 /* timer.hpp in Headers */,
2B7F47901708365200A106A9 /* tuple.hpp in Headers */,
2B7F479F1708365200A106A9 /* ByteSwap.h in Headers */,
2B7F479F1708365200A106A9 /* ByteSwapper.h in Headers */,
2B7F47A91708365200A106A9 /* CalcTangentsProcess.h in Headers */,
2B7F47AE1708365200A106A9 /* CInterfaceIOWrapper.h in Headers */,
2B7F47C71708365200A106A9 /* ColladaExporter.h in Headers */,
@ -4261,7 +4261,7 @@
2B7F47821708365200A106A9 /* static_assert.hpp in Headers */,
2B7F47871708365200A106A9 /* timer.hpp in Headers */,
2B7F478C1708365200A106A9 /* tuple.hpp in Headers */,
2B7F479B1708365200A106A9 /* ByteSwap.h in Headers */,
2B7F479B1708365200A106A9 /* ByteSwapper.h in Headers */,
2B7F47A51708365200A106A9 /* CalcTangentsProcess.h in Headers */,
2B7F47AA1708365200A106A9 /* CInterfaceIOWrapper.h in Headers */,
2B7F47C31708365200A106A9 /* ColladaExporter.h in Headers */,
@ -4509,7 +4509,7 @@
2B7F47831708365200A106A9 /* static_assert.hpp in Headers */,
2B7F47881708365200A106A9 /* timer.hpp in Headers */,
2B7F478D1708365200A106A9 /* tuple.hpp in Headers */,
2B7F479C1708365200A106A9 /* ByteSwap.h in Headers */,
2B7F479C1708365200A106A9 /* ByteSwapper.h in Headers */,
2B7F47A61708365200A106A9 /* CalcTangentsProcess.h in Headers */,
2B7F47AB1708365200A106A9 /* CInterfaceIOWrapper.h in Headers */,
2B7F47C41708365200A106A9 /* ColladaExporter.h in Headers */,