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

Merge pull request #947 from r-chris/optional-double-precision 

Optional double precision
pull/951/head
Kim Kulling 2016-07-16 11:15:16 +02:00 committed by GitHub
parent 45fae27aed c57b524a59
commit 23baecaff3
86 changed files with 896 additions and 799 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -18,6 +18,7 @@ assimp.pc
revision.h revision.h
contrib/zlib/zconf.h contrib/zlib/zconf.h
contrib/zlib/zlib.pc contrib/zlib/zlib.pc
include/assimp/config.h
# CMake # CMake
CMakeCache.txt CMakeCache.txt

15
CMakeLists.txt
View File

@ -80,15 +80,30 @@ IF(NOT GIT_COMMIT_HASH)
SET(GIT_COMMIT_HASH 0) SET(GIT_COMMIT_HASH 0)
ENDIF(NOT GIT_COMMIT_HASH) ENDIF(NOT GIT_COMMIT_HASH)
OPTION(ASSIMP_DOUBLE_PRECISION
"Set to ON to enable double precision processing"
OFF
)
IF(ASSIMP_DOUBLE_PRECISION)
ADD_DEFINITIONS(-DAI_DOUBLE_PRECISION)
ENDIF(ASSIMP_DOUBLE_PRECISION)
configure_file( configure_file(
${CMAKE_CURRENT_LIST_DIR}/revision.h.in ${CMAKE_CURRENT_LIST_DIR}/revision.h.in
# ${CMAKE_CURRENT_SOURCE_DIR}/revision.h.in # ${CMAKE_CURRENT_SOURCE_DIR}/revision.h.in
${CMAKE_CURRENT_BINARY_DIR}/revision.h ${CMAKE_CURRENT_BINARY_DIR}/revision.h
) )
configure_file(
${CMAKE_CURRENT_LIST_DIR}/include/assimp/config.h.in
${CMAKE_CURRENT_LIST_DIR}/include/assimp/config.h
)
include_directories( include_directories(
./ ./
${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_BINARY_DIR}
${CMAKE_CURRENT_BINARY_DIR}/include
) )
OPTION(ASSIMP_OPT_BUILD_PACKAGES "Set to ON to generate CPack configuration files and packaging targets" OFF) OPTION(ASSIMP_OPT_BUILD_PACKAGES "Set to ON to generate CPack configuration files and packaging targets" OFF)

16
code/3DSConverter.cpp
View File

@ -197,7 +197,7 @@ void CopyTexture(aiMaterial& mat, D3DS::Texture& texture, aiTextureType type)
// Setup the texture blend factor // Setup the texture blend factor
if (is_not_qnan(texture.mTextureBlend)) if (is_not_qnan(texture.mTextureBlend))
mat.AddProperty<float>( &texture.mTextureBlend, 1, AI_MATKEY_TEXBLEND(type,0)); mat.AddProperty<ai_real>( &texture.mTextureBlend, 1, AI_MATKEY_TEXBLEND(type,0));
// Setup the texture mapping mode // Setup the texture mapping mode
mat.AddProperty<int>((int*)&texture.mMapMode,1,AI_MATKEY_MAPPINGMODE_U(type,0)); mat.AddProperty<int>((int*)&texture.mMapMode,1,AI_MATKEY_MAPPINGMODE_U(type,0));
@ -207,14 +207,14 @@ void CopyTexture(aiMaterial& mat, D3DS::Texture& texture, aiTextureType type)
// FIXME: this is not really correct ... // FIXME: this is not really correct ...
if (texture.mMapMode == aiTextureMapMode_Mirror) if (texture.mMapMode == aiTextureMapMode_Mirror)
{ {
texture.mScaleU *= 2.f; texture.mScaleU *= 2.0;
texture.mScaleV *= 2.f; texture.mScaleV *= 2.0;
texture.mOffsetU /= 2.f; texture.mOffsetU /= 2.0;
texture.mOffsetV /= 2.f; texture.mOffsetV /= 2.0;
} }
// Setup texture UV transformations // Setup texture UV transformations
mat.AddProperty<float>(&texture.mOffsetU,5,AI_MATKEY_UVTRANSFORM(type,0)); mat.AddProperty<ai_real>(&texture.mOffsetU,5,AI_MATKEY_UVTRANSFORM(type,0));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -265,10 +265,10 @@ void Discreet3DSImporter::ConvertMaterial(D3DS::Material& oldMat,
} }
// Opacity // Opacity
mat.AddProperty<float>( &oldMat.mTransparency,1,AI_MATKEY_OPACITY); mat.AddProperty<ai_real>( &oldMat.mTransparency,1,AI_MATKEY_OPACITY);
// Bump height scaling // Bump height scaling
mat.AddProperty<float>( &oldMat.mBumpHeight,1,AI_MATKEY_BUMPSCALING); mat.AddProperty<ai_real>( &oldMat.mBumpHeight,1,AI_MATKEY_BUMPSCALING);
// Two sided rendering? // Two sided rendering?
if (oldMat.mTwoSided) if (oldMat.mTwoSided)

42
code/3DSHelper.h
View File

@ -327,11 +327,11 @@ struct Texture
{ {
//! Default constructor //! Default constructor
Texture() Texture()
: mOffsetU (0.0f) : mOffsetU (0.0)
, mOffsetV (0.0f) , mOffsetV (0.0)
, mScaleU (1.0f) , mScaleU (1.0)
, mScaleV (1.0f) , mScaleV (1.0)
, mRotation (0.0f) , mRotation (0.0)
, mMapMode (aiTextureMapMode_Wrap) , mMapMode (aiTextureMapMode_Wrap)
, bPrivate() , bPrivate()
, iUVSrc (0) , iUVSrc (0)
@ -340,17 +340,17 @@ struct Texture
} }
//! Specifies the blend factor for the texture //! Specifies the blend factor for the texture
float mTextureBlend; ai_real mTextureBlend;
//! Specifies the filename of the texture //! Specifies the filename of the texture
std::string mMapName; std::string mMapName;
//! Specifies texture coordinate offsets/scaling/rotations //! Specifies texture coordinate offsets/scaling/rotations
float mOffsetU; ai_real mOffsetU;
float mOffsetV; ai_real mOffsetV;
float mScaleU; ai_real mScaleU;
float mScaleV; ai_real mScaleV;
float mRotation; ai_real mRotation;
//! Specifies the mapping mode to be used for the texture //! Specifies the mapping mode to be used for the texture
aiTextureMapMode mMapMode; aiTextureMapMode mMapMode;
@ -369,12 +369,12 @@ struct Material
//! Default constructor. Builds a default name for the material //! Default constructor. Builds a default name for the material
Material() Material()
: :
mDiffuse (0.6f,0.6f,0.6f), // FIX ... we won't want object to be black mDiffuse (0.6,0.6,0.6), // FIX ... we won't want object to be black
mSpecularExponent (0.0f), mSpecularExponent (0.0),
mShininessStrength (1.0f), mShininessStrength (1.0),
mShading(Discreet3DS::Gouraud), mShading(Discreet3DS::Gouraud),
mTransparency (1.0f), mTransparency (1.0),
mBumpHeight (1.0f), mBumpHeight (1.0),
mTwoSided (false) mTwoSided (false)
{ {
static int iCnt = 0; static int iCnt = 0;
@ -389,9 +389,9 @@ struct Material
//! Diffuse color of the material //! Diffuse color of the material
aiColor3D mDiffuse; aiColor3D mDiffuse;
//! Specular exponent //! Specular exponent
float mSpecularExponent; ai_real mSpecularExponent;
//! Shininess strength, in percent //! Shininess strength, in percent
float mShininessStrength; ai_real mShininessStrength;
//! Specular color of the material //! Specular color of the material
aiColor3D mSpecular; aiColor3D mSpecular;
//! Ambient color of the material //! Ambient color of the material
@ -399,7 +399,7 @@ struct Material
//! Shading type to be used //! Shading type to be used
Discreet3DS::shadetype3ds mShading; Discreet3DS::shadetype3ds mShading;
//! Opacity of the material //! Opacity of the material
float mTransparency; ai_real mTransparency;
//! Diffuse texture channel //! Diffuse texture channel
Texture sTexDiffuse; Texture sTexDiffuse;
//! Opacity texture channel //! Opacity texture channel
@ -415,7 +415,7 @@ struct Material
//! Shininess texture channel //! Shininess texture channel
Texture sTexShininess; Texture sTexShininess;
//! Scaling factor for the bump values //! Scaling factor for the bump values
float mBumpHeight; ai_real mBumpHeight;
//! Emissive color //! Emissive color
aiColor3D mEmissive; aiColor3D mEmissive;
//! Ambient texture channel //! Ambient texture channel
@ -459,7 +459,7 @@ struct Mesh : public MeshWithSmoothingGroups<D3DS::Face>
struct aiFloatKey struct aiFloatKey
{ {
double mTime; ///< The time of this key double mTime; ///< The time of this key
float mValue; ///< The value of this key ai_real mValue; ///< The value of this key
#ifdef __cplusplus #ifdef __cplusplus

52
code/3DSLoader.cpp
View File

@ -458,20 +458,20 @@ void Discreet3DSImporter::ParseChunk(const char* name, unsigned int num)
camera->mLookAt.x = stream->GetF4() - camera->mPosition.x; camera->mLookAt.x = stream->GetF4() - camera->mPosition.x;
camera->mLookAt.y = stream->GetF4() - camera->mPosition.y; camera->mLookAt.y = stream->GetF4() - camera->mPosition.y;
camera->mLookAt.z = stream->GetF4() - camera->mPosition.z; camera->mLookAt.z = stream->GetF4() - camera->mPosition.z;
float len = camera->mLookAt.Length(); ai_real len = camera->mLookAt.Length();
if (len < 1e-5f) { if (len < 1e-5) {
// There are some files with lookat == position. Don't know why or whether it's ok or not. // There are some files with lookat == position. Don't know why or whether it's ok or not.
DefaultLogger::get()->error("3DS: Unable to read proper camera look-at vector"); DefaultLogger::get()->error("3DS: Unable to read proper camera look-at vector");
camera->mLookAt = aiVector3D(0.f,1.f,0.f); camera->mLookAt = aiVector3D(0.0,1.0,0.0);
} }
else camera->mLookAt /= len; else camera->mLookAt /= len;
// And finally - the camera rotation angle, in counter clockwise direction // And finally - the camera rotation angle, in counter clockwise direction
const float angle = AI_DEG_TO_RAD( stream->GetF4() ); const ai_real angle = AI_DEG_TO_RAD( stream->GetF4() );
aiQuaternion quat(camera->mLookAt,angle); aiQuaternion quat(camera->mLookAt,angle);
camera->mUp = quat.GetMatrix() * aiVector3D(0.f,1.f,0.f); camera->mUp = quat.GetMatrix() * aiVector3D(0.0,1.0,0.0);
// Read the lense angle // Read the lense angle
camera->mHorizontalFOV = AI_DEG_TO_RAD ( stream->GetF4() ); camera->mHorizontalFOV = AI_DEG_TO_RAD ( stream->GetF4() );
@ -1167,13 +1167,13 @@ void Discreet3DSImporter::ParseMaterialChunk()
case Discreet3DS::CHUNK_MAT_TRANSPARENCY: case Discreet3DS::CHUNK_MAT_TRANSPARENCY:
{ {
// This is the material's transparency // This is the material's transparency
float* pcf = &mScene->mMaterials.back().mTransparency; ai_real* pcf = &mScene->mMaterials.back().mTransparency;
*pcf = ParsePercentageChunk(); *pcf = ParsePercentageChunk();
// NOTE: transparency, not opacity // NOTE: transparency, not opacity
if (is_qnan(*pcf)) if (is_qnan(*pcf))
*pcf = 1.0f; *pcf = 1.0;
else *pcf = 1.0f - *pcf * (float)0xFFFF / 100.0f; else *pcf = 1.0 - *pcf * (ai_real)0xFFFF / 100.0;
} }
break; break;
@ -1189,30 +1189,30 @@ void Discreet3DSImporter::ParseMaterialChunk()
case Discreet3DS::CHUNK_MAT_SHININESS: case Discreet3DS::CHUNK_MAT_SHININESS:
{ // This is the shininess of the material { // This is the shininess of the material
float* pcf = &mScene->mMaterials.back().mSpecularExponent; ai_real* pcf = &mScene->mMaterials.back().mSpecularExponent;
*pcf = ParsePercentageChunk(); *pcf = ParsePercentageChunk();
if (is_qnan(*pcf)) if (is_qnan(*pcf))
*pcf = 0.0f; *pcf = 0.0;
else *pcf *= (float)0xFFFF; else *pcf *= (ai_real)0xFFFF;
} }
break; break;
case Discreet3DS::CHUNK_MAT_SHININESS_PERCENT: case Discreet3DS::CHUNK_MAT_SHININESS_PERCENT:
{ // This is the shininess strength of the material { // This is the shininess strength of the material
float* pcf = &mScene->mMaterials.back().mShininessStrength; ai_real* pcf = &mScene->mMaterials.back().mShininessStrength;
*pcf = ParsePercentageChunk(); *pcf = ParsePercentageChunk();
if (is_qnan(*pcf)) if (is_qnan(*pcf))
*pcf = 0.0f; *pcf = 0.0;
else *pcf *= (float)0xffff / 100.0f; else *pcf *= (ai_real)0xffff / 100.0;
} }
break; break;
case Discreet3DS::CHUNK_MAT_SELF_ILPCT: case Discreet3DS::CHUNK_MAT_SELF_ILPCT:
{ // This is the self illumination strength of the material { // This is the self illumination strength of the material
float f = ParsePercentageChunk(); ai_real f = ParsePercentageChunk();
if (is_qnan(f)) if (is_qnan(f))
f = 0.0f; f = 0.0;
else f *= (float)0xFFFF / 100.0f; else f *= (ai_real)0xFFFF / 100.0;
mScene->mMaterials.back().mEmissive = aiColor3D(f,f,f); mScene->mMaterials.back().mEmissive = aiColor3D(f,f,f);
} }
break; break;
@ -1277,7 +1277,7 @@ void Discreet3DSImporter::ParseTextureChunk(D3DS::Texture* pcOut)
case Discreet3DS::CHUNK_PERCENTW: case Discreet3DS::CHUNK_PERCENTW:
// Manually parse the blend factor // Manually parse the blend factor
pcOut->mTextureBlend = (float)((uint16_t)stream->GetI2()) / 100.0f; pcOut->mTextureBlend = (ai_real)((uint16_t)stream->GetI2()) / 100.0;
break; break;
case Discreet3DS::CHUNK_MAT_MAP_USCALE: case Discreet3DS::CHUNK_MAT_MAP_USCALE:
@ -1336,7 +1336,7 @@ void Discreet3DSImporter::ParseTextureChunk(D3DS::Texture* pcOut)
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Read a percentage chunk // Read a percentage chunk
float Discreet3DSImporter::ParsePercentageChunk() ai_real Discreet3DSImporter::ParsePercentageChunk()
{ {
Discreet3DS::Chunk chunk; Discreet3DS::Chunk chunk;
ReadChunk(&chunk); ReadChunk(&chunk);
@ -1344,7 +1344,7 @@ float Discreet3DSImporter::ParsePercentageChunk()
if (Discreet3DS::CHUNK_PERCENTF == chunk.Flag) if (Discreet3DS::CHUNK_PERCENTF == chunk.Flag)
return stream->GetF4(); return stream->GetF4();
else if (Discreet3DS::CHUNK_PERCENTW == chunk.Flag) else if (Discreet3DS::CHUNK_PERCENTW == chunk.Flag)
return (float)((uint16_t)stream->GetI2()) / (float)0xFFFF; return (ai_real)((uint16_t)stream->GetI2()) / (ai_real)0xFFFF;
return get_qnan(); return get_qnan();
} }
@ -1356,7 +1356,7 @@ void Discreet3DSImporter::ParseColorChunk(aiColor3D* out,
ai_assert(out != NULL); ai_assert(out != NULL);
// error return value // error return value
const float qnan = get_qnan(); const ai_real qnan = get_qnan();
static const aiColor3D clrError = aiColor3D(qnan,qnan,qnan); static const aiColor3D clrError = aiColor3D(qnan,qnan,qnan);
Discreet3DS::Chunk chunk; Discreet3DS::Chunk chunk;
@ -1372,7 +1372,7 @@ void Discreet3DSImporter::ParseColorChunk(aiColor3D* out,
bGamma = true; bGamma = true;
case Discreet3DS::CHUNK_RGBF: case Discreet3DS::CHUNK_RGBF:
if (sizeof(float) * 3 > diff) { if (sizeof(ai_real) * 3 > diff) {
*out = clrError; *out = clrError;
return; return;
} }
@ -1388,9 +1388,9 @@ void Discreet3DSImporter::ParseColorChunk(aiColor3D* out,
*out = clrError; *out = clrError;
return; return;
} }
out->r = (float)(uint8_t)stream->GetI1() / 255.0f; out->r = (ai_real)(uint8_t)stream->GetI1() / 255.0;
out->g = (float)(uint8_t)stream->GetI1() / 255.0f; out->g = (ai_real)(uint8_t)stream->GetI1() / 255.0;
out->b = (float)(uint8_t)stream->GetI1() / 255.0f; out->b = (ai_real)(uint8_t)stream->GetI1() / 255.0;
break; break;
// Percentage chunks are accepted, too. // Percentage chunks are accepted, too.
@ -1404,7 +1404,7 @@ void Discreet3DSImporter::ParseColorChunk(aiColor3D* out,
case Discreet3DS::CHUNK_PERCENTW: case Discreet3DS::CHUNK_PERCENTW:
if (acceptPercent && 1 <= diff) { if (acceptPercent && 1 <= diff) {
out->g = out->b = out->r = (float)(uint8_t)stream->GetI1() / 255.0f; out->g = out->b = out->r = (ai_real)(uint8_t)stream->GetI1() / 255.0;
break; break;
} }
*out = clrError; *out = clrError;

4
code/3DSLoader.h
View File

@ -119,7 +119,7 @@ protected:
* chunk behind afterwards. If no percentage chunk is found * chunk behind afterwards. If no percentage chunk is found
* QNAN is returned. * QNAN is returned.
*/ */
float ParsePercentageChunk(); ai_real ParsePercentageChunk();
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Parse a color chunk. mCurrent will point to the next /** Parse a color chunk. mCurrent will point to the next
@ -265,7 +265,7 @@ protected:
aiColor3D mClrAmbient; aiColor3D mClrAmbient;
/** Master scaling factor of the scene */ /** Master scaling factor of the scene */
float mMasterScale; ai_real mMasterScale;
/** Path to the background image of the scene */ /** Path to the background image of the scene */
std::string mBackgroundImage; std::string mBackgroundImage;

6
code/ASELoader.cpp
View File

@ -819,10 +819,10 @@ void CopyASETexture(aiMaterial& mat, ASE::Texture& texture, aiTextureType type)
// Setup the texture blend factor // Setup the texture blend factor
if (is_not_qnan(texture.mTextureBlend)) if (is_not_qnan(texture.mTextureBlend))
mat.AddProperty<float>( &texture.mTextureBlend, 1, AI_MATKEY_TEXBLEND(type,0)); mat.AddProperty<ai_real>( &texture.mTextureBlend, 1, AI_MATKEY_TEXBLEND(type,0));
// Setup texture UV transformations // Setup texture UV transformations
mat.AddProperty<float>(&texture.mOffsetU,5,AI_MATKEY_UVTRANSFORM(type,0)); mat.AddProperty<ai_real>(&texture.mOffsetU,5,AI_MATKEY_UVTRANSFORM(type,0));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -865,7 +865,7 @@ void ASEImporter::ConvertMaterial(ASE::Material& mat)
} }
// opacity // opacity
mat.pcInstance->AddProperty<float>( &mat.mTransparency,1,AI_MATKEY_OPACITY); mat.pcInstance->AddProperty<ai_real>( &mat.mTransparency,1,AI_MATKEY_OPACITY);
// Two sided rendering? // Two sided rendering?
if (mat.mTwoSided) if (mat.mTwoSided)

20
code/ASEParser.cpp
View File

@ -431,7 +431,7 @@ void Parser::ParseLV1SoftSkinBlock()
ParseString(bone,"*MESH_SOFTSKINVERTS.Bone"); ParseString(bone,"*MESH_SOFTSKINVERTS.Bone");
// Find the bone in the mesh's list // Find the bone in the mesh's list
std::pair<int,float> me; std::pair<int,ai_real> me;
me.first = -1; me.first = -1;
for (unsigned int n = 0; n < curMesh->mBones.size();++n) for (unsigned int n = 0; n < curMesh->mBones.size();++n)
@ -618,12 +618,12 @@ void Parser::ParseLV2MaterialBlock(ASE::Material& mat)
if (TokenMatch(filePtr,"MATERIAL_TRANSPARENCY",21)) if (TokenMatch(filePtr,"MATERIAL_TRANSPARENCY",21))
{ {
ParseLV4MeshFloat(mat.mTransparency); ParseLV4MeshFloat(mat.mTransparency);
mat.mTransparency = 1.0f - mat.mTransparency;continue; mat.mTransparency = 1.0 - mat.mTransparency;continue;
} }
// material self illumination // material self illumination
if (TokenMatch(filePtr,"MATERIAL_SELFILLUM",18)) if (TokenMatch(filePtr,"MATERIAL_SELFILLUM",18))
{ {
float f = 0.0f; ai_real f = 0.0;
ParseLV4MeshFloat(f); ParseLV4MeshFloat(f);
mat.mEmissive.r = f; mat.mEmissive.r = f;
@ -1251,7 +1251,7 @@ void Parser::ParseLV3RotAnimationBlock(ASE::Animation& anim)
{ {
anim.akeyRotations.push_back(aiQuatKey()); anim.akeyRotations.push_back(aiQuatKey());
aiQuatKey& key = anim.akeyRotations.back(); aiQuatKey& key = anim.akeyRotations.back();
aiVector3D v;float f; aiVector3D v;ai_real f;
ParseLV4MeshFloatTriple(&v.x,iIndex); ParseLV4MeshFloatTriple(&v.x,iIndex);
ParseLV4MeshFloat(f); ParseLV4MeshFloat(f);
key.mTime = (double)iIndex; key.mTime = (double)iIndex;
@ -1604,7 +1604,7 @@ void Parser::ParseLV4MeshBonesVertices(unsigned int iNumVertices,ASE::Mesh& mesh
} }
// --- ignored // --- ignored
float afVert[3]; ai_real afVert[3];
ParseLV4MeshFloatTriple(afVert); ParseLV4MeshFloatTriple(afVert);
std::pair<int,float> pairOut; std::pair<int,float> pairOut;
@ -2102,7 +2102,7 @@ void Parser::ParseLV4MeshLongTriple(unsigned int* apOut, unsigned int& rIndexOut
ParseLV4MeshLongTriple(apOut); ParseLV4MeshLongTriple(apOut);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
void Parser::ParseLV4MeshFloatTriple(float* apOut, unsigned int& rIndexOut) void Parser::ParseLV4MeshFloatTriple(ai_real* apOut, unsigned int& rIndexOut)
{ {
ai_assert(NULL != apOut); ai_assert(NULL != apOut);
@ -2113,7 +2113,7 @@ void Parser::ParseLV4MeshFloatTriple(float* apOut, unsigned int& rIndexOut)
ParseLV4MeshFloatTriple(apOut); ParseLV4MeshFloatTriple(apOut);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
void Parser::ParseLV4MeshFloatTriple(float* apOut) void Parser::ParseLV4MeshFloatTriple(ai_real* apOut)
{ {
ai_assert(NULL != apOut); ai_assert(NULL != apOut);
@ -2121,19 +2121,19 @@ void Parser::ParseLV4MeshFloatTriple(float* apOut)
ParseLV4MeshFloat(apOut[i]); ParseLV4MeshFloat(apOut[i]);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
void Parser::ParseLV4MeshFloat(float& fOut) void Parser::ParseLV4MeshFloat(ai_real& fOut)
{ {
// skip spaces and tabs // skip spaces and tabs
if(!SkipSpaces(&filePtr)) if(!SkipSpaces(&filePtr))
{ {
// LOG // LOG
LogWarning("Unable to parse float: unexpected EOL [#1]"); LogWarning("Unable to parse float: unexpected EOL [#1]");
fOut = 0.0f; fOut = 0.0;
++iLineNumber; ++iLineNumber;
return; return;
} }
// parse the first float // parse the first float
filePtr = fast_atoreal_move<float>(filePtr,fOut); filePtr = fast_atoreal_move<ai_real>(filePtr,fOut);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
void Parser::ParseLV4MeshLong(unsigned int& iOut) void Parser::ParseLV4MeshLong(unsigned int& iOut)

16
code/ASEParser.h
View File

@ -222,7 +222,7 @@ struct BaseNode
mName = szTemp; mName = szTemp;
// Set mTargetPosition to qnan // Set mTargetPosition to qnan
const float qnan = get_qnan(); const ai_real qnan = get_qnan();
mTargetPosition.x = qnan; mTargetPosition.x = qnan;
} }
@ -317,9 +317,9 @@ struct Light : public BaseNode
LightType mLightType; LightType mLightType;
aiColor3D mColor; aiColor3D mColor;
float mIntensity; ai_real mIntensity;
float mAngle; // in degrees ai_real mAngle; // in degrees
float mFalloff; ai_real mFalloff;
}; };
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
@ -342,7 +342,7 @@ struct Camera : public BaseNode
{ {
} }
float mFOV, mNear, mFar; ai_real mFOV, mNear, mFar;
CameraType mCameraType; CameraType mCameraType;
}; };
@ -544,13 +544,13 @@ private:
//! (also works for MESH_TVERT, MESH_CFACE, MESH_VERTCOL ...) //! (also works for MESH_TVERT, MESH_CFACE, MESH_VERTCOL ...)
//! \param apOut Output buffer (3 floats) //! \param apOut Output buffer (3 floats)
//! \param rIndexOut Output index //! \param rIndexOut Output index
void ParseLV4MeshFloatTriple(float* apOut, unsigned int& rIndexOut); void ParseLV4MeshFloatTriple(ai_real* apOut, unsigned int& rIndexOut);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
//! Parse a *MESH_VERT block in a file //! Parse a *MESH_VERT block in a file
//! (also works for MESH_TVERT, MESH_CFACE, MESH_VERTCOL ...) //! (also works for MESH_TVERT, MESH_CFACE, MESH_VERTCOL ...)
//! \param apOut Output buffer (3 floats) //! \param apOut Output buffer (3 floats)
void ParseLV4MeshFloatTriple(float* apOut); void ParseLV4MeshFloatTriple(ai_real* apOut);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
//! Parse a *MESH_TFACE block in a file //! Parse a *MESH_TFACE block in a file
@ -568,7 +568,7 @@ private:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
//! Parse a single float element //! Parse a single float element
//! \param fOut Output float //! \param fOut Output float
void ParseLV4MeshFloat(float& fOut); void ParseLV4MeshFloat(ai_real& fOut);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
//! Parse a single int element //! Parse a single int element

4
code/Assimp.cpp
View File

@ -546,11 +546,11 @@ ASSIMP_API void aiSetImportPropertyInteger(aiPropertyStore* p, const char* szNam
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Importer::SetPropertyFloat // Importer::SetPropertyFloat
ASSIMP_API void aiSetImportPropertyFloat(aiPropertyStore* p, const char* szName, float value) ASSIMP_API void aiSetImportPropertyFloat(aiPropertyStore* p, const char* szName, ai_real value)
{ {
ASSIMP_BEGIN_EXCEPTION_REGION(); ASSIMP_BEGIN_EXCEPTION_REGION();
PropertyMap* pp = reinterpret_cast<PropertyMap*>(p); PropertyMap* pp = reinterpret_cast<PropertyMap*>(p);
SetGenericProperty<float>(pp->floats,szName,value); SetGenericProperty<ai_real>(pp->floats,szName,value);
ASSIMP_END_EXCEPTION_REGION(void); ASSIMP_END_EXCEPTION_REGION(void);
} }

20
code/BlenderTessellator.cpp
View File

@ -50,7 +50,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "BlenderBMesh.h" #include "BlenderBMesh.h"
#include "BlenderTessellator.h" #include "BlenderTessellator.h"
#include <stddef.h> #include <stddef.h>
static const unsigned int BLEND_TESS_MAGIC = 0x83ed9ac3; static const unsigned int BLEND_TESS_MAGIC = 0x83ed9ac3;
@ -470,19 +470,19 @@ PlaneP2T BlenderTessellatorP2T::FindLLSQPlane( const std::vector< PointP2T >& po
{ {
PlaneP2T result; PlaneP2T result;
aiVector3D sum( 0.0f ); aiVector3D sum( 0.0 );
for ( size_t i = 0; i < points.size( ); ++i ) for ( size_t i = 0; i < points.size( ); ++i )
{ {
sum += points[ i ].point3D; sum += points[ i ].point3D;
} }
result.centre = sum * ( 1.0f / points.size( ) ); result.centre = sum * (ai_real)( 1.0 / points.size( ) );
float sumXX = 0.0f; ai_real sumXX = 0.0;
float sumXY = 0.0f; ai_real sumXY = 0.0;
float sumXZ = 0.0f; ai_real sumXZ = 0.0;
float sumYY = 0.0f; ai_real sumYY = 0.0;
float sumYZ = 0.0f; ai_real sumYZ = 0.0;
float sumZZ = 0.0f; ai_real sumZZ = 0.0;
for ( size_t i = 0; i < points.size( ); ++i ) for ( size_t i = 0; i < points.size( ); ++i )
{ {
aiVector3D offset = points[ i ].point3D - result.centre; aiVector3D offset = points[ i ].point3D - result.centre;
@ -496,7 +496,7 @@ PlaneP2T BlenderTessellatorP2T::FindLLSQPlane( const std::vector< PointP2T >& po
aiMatrix3x3 mtx( sumXX, sumXY, sumXZ, sumXY, sumYY, sumYZ, sumXZ, sumYZ, sumZZ ); aiMatrix3x3 mtx( sumXX, sumXY, sumXZ, sumXY, sumYY, sumYZ, sumXZ, sumYZ, sumZZ );
const float det = mtx.Determinant( ); const ai_real det = mtx.Determinant( );
if ( det == 0.0f ) if ( det == 0.0f )
{ {
result.normal = aiVector3D( 0.0f ); result.normal = aiVector3D( 0.0f );

18
code/ColladaExporter.cpp
View File

@ -149,7 +149,7 @@ void ColladaExporter::WriteFile()
// Writes the asset header // Writes the asset header
void ColladaExporter::WriteHeader() void ColladaExporter::WriteHeader()
{ {
static const float epsilon = 0.00001f; static const ai_real epsilon = 0.00001;
static const aiQuaternion x_rot(aiMatrix3x3( static const aiQuaternion x_rot(aiMatrix3x3(
0, -1, 0, 0, -1, 0,
1, 0, 0, 1, 0, 0,
@ -176,9 +176,9 @@ void ColladaExporter::WriteHeader()
bool add_root_node = false; bool add_root_node = false;
float scale = 1.0; ai_real scale = 1.0;
if(std::abs(scaling.x - scaling.y) <= epsilon && std::abs(scaling.x - scaling.z) <= epsilon && std::abs(scaling.y - scaling.z) <= epsilon) { if(std::abs(scaling.x - scaling.y) <= epsilon && std::abs(scaling.x - scaling.z) <= epsilon && std::abs(scaling.y - scaling.z) <= epsilon) {
scale = (float) ((((double) scaling.x) + ((double) scaling.y) + ((double) scaling.z)) / 3.0); scale = (ai_real) ((((double) scaling.x) + ((double) scaling.y) + ((double) scaling.z)) / 3.0);
} else { } else {
add_root_node = true; add_root_node = true;
} }
@ -450,7 +450,7 @@ void ColladaExporter::WriteSpotLight(const aiLight *const light){
srcLight->mFalloffAngle); srcLight->mFalloffAngle);
*/ */
const float fallOffAngle = AI_RAD_TO_DEG(light->mAngleInnerCone); const ai_real fallOffAngle = AI_RAD_TO_DEG(light->mAngleInnerCone);
mOutput << startstr <<"<falloff_angle sid=\"fall_off_angle\">" mOutput << startstr <<"<falloff_angle sid=\"fall_off_angle\">"
<< fallOffAngle << fallOffAngle
<<"</falloff_angle>" << endstr; <<"</falloff_angle>" << endstr;
@ -803,10 +803,10 @@ void ColladaExporter::WriteGeometry( size_t pIndex)
PushTag(); PushTag();
// Positions // Positions
WriteFloatArray( idstr + "-positions", FloatType_Vector, (float*) mesh->mVertices, mesh->mNumVertices); WriteFloatArray( idstr + "-positions", FloatType_Vector, (ai_real*) mesh->mVertices, mesh->mNumVertices);
// Normals, if any // Normals, if any
if( mesh->HasNormals() ) if( mesh->HasNormals() )
WriteFloatArray( idstr + "-normals", FloatType_Vector, (float*) mesh->mNormals, mesh->mNumVertices); WriteFloatArray( idstr + "-normals", FloatType_Vector, (ai_real*) mesh->mNormals, mesh->mNumVertices);
// texture coords // texture coords
for( size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) for( size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a)
@ -814,7 +814,7 @@ void ColladaExporter::WriteGeometry( size_t pIndex)
if( mesh->HasTextureCoords( a) ) if( mesh->HasTextureCoords( a) )
{ {
WriteFloatArray( idstr + "-tex" + std::to_string(a), mesh->mNumUVComponents[a] == 3 ? FloatType_TexCoord3 : FloatType_TexCoord2, WriteFloatArray( idstr + "-tex" + std::to_string(a), mesh->mNumUVComponents[a] == 3 ? FloatType_TexCoord3 : FloatType_TexCoord2,
(float*) mesh->mTextureCoords[a], mesh->mNumVertices); (ai_real*) mesh->mTextureCoords[a], mesh->mNumVertices);
} }
} }
@ -822,7 +822,7 @@ void ColladaExporter::WriteGeometry( size_t pIndex)
for( size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) for( size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a)
{ {
if( mesh->HasVertexColors( a) ) if( mesh->HasVertexColors( a) )
WriteFloatArray( idstr + "-color" + std::to_string(a), FloatType_Color, (float*) mesh->mColors[a], mesh->mNumVertices); WriteFloatArray( idstr + "-color" + std::to_string(a), FloatType_Color, (ai_real*) mesh->mColors[a], mesh->mNumVertices);
} }
// assemble vertex structure // assemble vertex structure
@ -917,7 +917,7 @@ void ColladaExporter::WriteGeometry( size_t pIndex)
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Writes a float array of the given type // Writes a float array of the given type
void ColladaExporter::WriteFloatArray( const std::string& pIdString, FloatDataType pType, const float* pData, size_t pElementCount) void ColladaExporter::WriteFloatArray( const std::string& pIdString, FloatDataType pType, const ai_real* pData, size_t pElementCount)
{ {
size_t floatsPerElement = 0; size_t floatsPerElement = 0;
switch( pType ) switch( pType )

6
code/ColladaExporter.h
View File

@ -108,7 +108,7 @@ protected:
enum FloatDataType { FloatType_Vector, FloatType_TexCoord2, FloatType_TexCoord3, FloatType_Color }; enum FloatDataType { FloatType_Vector, FloatType_TexCoord2, FloatType_TexCoord3, FloatType_Color };
/// Writes a float array of the given type /// Writes a float array of the given type
void WriteFloatArray( const std::string& pIdString, FloatDataType pType, const float* pData, size_t pElementCount); void WriteFloatArray( const std::string& pIdString, FloatDataType pType, const ai_real* pData, size_t pElementCount);
/// Writes the scene library /// Writes the scene library
void WriteSceneLibrary(); void WriteSceneLibrary();
@ -160,10 +160,10 @@ protected:
struct Property struct Property
{ {
bool exist; bool exist;
float value; ai_real value;
Property() Property()
: exist(false) : exist(false)
, value(0.0f) , value(0.0)
{} {}
}; };

34
code/ColladaHelper.h
View File

@ -94,7 +94,7 @@ struct Transform
{ {
std::string mID; ///< SID of the transform step, by which anim channels address their target node std::string mID; ///< SID of the transform step, by which anim channels address their target node
TransformType mType; TransformType mType;
float f[16]; ///< Interpretation of data depends on the type of the transformation ai_real f[16]; ///< Interpretation of data depends on the type of the transformation
}; };
/** A collada camera. */ /** A collada camera. */
@ -116,16 +116,16 @@ struct Camera
bool mOrtho; bool mOrtho;
//! Horizontal field of view in degrees //! Horizontal field of view in degrees
float mHorFov; ai_real mHorFov;
//! Vertical field of view in degrees //! Vertical field of view in degrees
float mVerFov; ai_real mVerFov;
//! Screen aspect //! Screen aspect
float mAspect; ai_real mAspect;
//! Near& far z //! Near& far z
float mZNear, mZFar; ai_real mZNear, mZFar;
}; };
#define ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET 1e9f #define ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET 1e9f
@ -152,21 +152,21 @@ struct Light
aiColor3D mColor; aiColor3D mColor;
//! Light attenuation //! Light attenuation
float mAttConstant,mAttLinear,mAttQuadratic; ai_real mAttConstant,mAttLinear,mAttQuadratic;
//! Spot light falloff //! Spot light falloff
float mFalloffAngle; ai_real mFalloffAngle;
float mFalloffExponent; ai_real mFalloffExponent;
// ----------------------------------------------------- // -----------------------------------------------------
// FCOLLADA extension from here // FCOLLADA extension from here
//! ... related stuff from maja and max extensions //! ... related stuff from maja and max extensions
float mPenumbraAngle; ai_real mPenumbraAngle;
float mOuterAngle; ai_real mOuterAngle;
//! Common light intensity //! Common light intensity
float mIntensity; ai_real mIntensity;
}; };
/** Short vertex index description */ /** Short vertex index description */
@ -275,7 +275,7 @@ struct Node
struct Data struct Data
{ {
bool mIsStringArray; bool mIsStringArray;
std::vector<float> mValues; std::vector<ai_real> mValues;
std::vector<std::string> mStrings; std::vector<std::string> mStrings;
}; };
@ -387,7 +387,7 @@ struct Controller
std::string mJointNameSource; std::string mJointNameSource;
///< The bind shape matrix, as array of floats. I'm not sure what this matrix actually describes, but it can't be ignored in all cases ///< The bind shape matrix, as array of floats. I'm not sure what this matrix actually describes, but it can't be ignored in all cases
float mBindShapeMatrix[16]; ai_real mBindShapeMatrix[16];
// accessor URL of the joint inverse bind matrices // accessor URL of the joint inverse bind matrices
std::string mJointOffsetMatrixSource; std::string mJointOffsetMatrixSource;
@ -490,11 +490,11 @@ struct Sampler
/** Weighting factor /** Weighting factor
*/ */
float mWeighting; ai_real mWeighting;
/** Mixing factor from OKINO /** Mixing factor from OKINO
*/ */
float mMixWithPrevious; ai_real mMixWithPrevious;
}; };
/** A collada effect. Can contain about anything according to the Collada spec, /** A collada effect. Can contain about anything according to the Collada spec,
@ -513,8 +513,8 @@ struct Effect
mTexTransparent, mTexBump, mTexReflective; mTexTransparent, mTexBump, mTexReflective;
// Scalar factory // Scalar factory
float mShininess, mRefractIndex, mReflectivity; ai_real mShininess, mRefractIndex, mReflectivity;
float mTransparency; ai_real mTransparency;
bool mHasTransparency; bool mHasTransparency;
bool mRGBTransparency; bool mRGBTransparency;
bool mInvertTransparency; bool mInvertTransparency;

46
code/ColladaLoader.cpp
View File

@ -704,7 +704,7 @@ aiMesh* ColladaLoader::CreateMesh( const ColladaParser& pParser, const Collada::
size_t jointIndex = iit->first; size_t jointIndex = iit->first;
size_t vertexIndex = iit->second; size_t vertexIndex = iit->second;
float weight = ReadFloat( weightsAcc, weights, vertexIndex, 0); ai_real weight = ReadFloat( weightsAcc, weights, vertexIndex, 0);
// one day I gonna kill that XSI Collada exporter // one day I gonna kill that XSI Collada exporter
if( weight > 0.0f) if( weight > 0.0f)
@ -1071,7 +1071,7 @@ void ColladaLoader::CreateAnimation( aiScene* pScene, const ColladaParser& pPars
continue; continue;
// resolve the data pointers for all anim channels. Find the minimum time while we're at it // resolve the data pointers for all anim channels. Find the minimum time while we're at it
float startTime = 1e20f, endTime = -1e20f; ai_real startTime = 1e20, endTime = -1e20;
for( std::vector<Collada::ChannelEntry>::iterator it = entries.begin(); it != entries.end(); ++it) for( std::vector<Collada::ChannelEntry>::iterator it = entries.begin(); it != entries.end(); ++it)
{ {
Collada::ChannelEntry& e = *it; Collada::ChannelEntry& e = *it;
@ -1100,7 +1100,7 @@ void ColladaLoader::CreateAnimation( aiScene* pScene, const ColladaParser& pPars
// now for every unique point in time, find or interpolate the key values for that time // now for every unique point in time, find or interpolate the key values for that time
// and apply them to the transform chain. Then the node's present transformation can be calculated. // and apply them to the transform chain. Then the node's present transformation can be calculated.
float time = startTime; ai_real time = startTime;
while( 1) while( 1)
{ {
for( std::vector<Collada::ChannelEntry>::iterator it = entries.begin(); it != entries.end(); ++it) for( std::vector<Collada::ChannelEntry>::iterator it = entries.begin(); it != entries.end(); ++it)
@ -1109,7 +1109,7 @@ void ColladaLoader::CreateAnimation( aiScene* pScene, const ColladaParser& pPars
// find the keyframe behind the current point in time // find the keyframe behind the current point in time
size_t pos = 0; size_t pos = 0;
float postTime = 0.f; ai_real postTime = 0.0;
while( 1) while( 1)
{ {
if( pos >= e.mTimeAccessor->mCount) if( pos >= e.mTimeAccessor->mCount)
@ -1123,19 +1123,19 @@ void ColladaLoader::CreateAnimation( aiScene* pScene, const ColladaParser& pPars
pos = std::min( pos, e.mTimeAccessor->mCount-1); pos = std::min( pos, e.mTimeAccessor->mCount-1);
// read values from there // read values from there
float temp[16]; ai_real temp[16];
for( size_t c = 0; c < e.mValueAccessor->mSize; ++c) for( size_t c = 0; c < e.mValueAccessor->mSize; ++c)
temp[c] = ReadFloat( *e.mValueAccessor, *e.mValueData, pos, c); temp[c] = ReadFloat( *e.mValueAccessor, *e.mValueData, pos, c);
// if not exactly at the key time, interpolate with previous value set // if not exactly at the key time, interpolate with previous value set
if( postTime > time && pos > 0) if( postTime > time && pos > 0)
{ {
float preTime = ReadFloat( *e.mTimeAccessor, *e.mTimeData, pos-1, 0); ai_real preTime = ReadFloat( *e.mTimeAccessor, *e.mTimeData, pos-1, 0);
float factor = (time - postTime) / (preTime - postTime); ai_real factor = (time - postTime) / (preTime - postTime);
for( size_t c = 0; c < e.mValueAccessor->mSize; ++c) for( size_t c = 0; c < e.mValueAccessor->mSize; ++c)
{ {
float v = ReadFloat( *e.mValueAccessor, *e.mValueData, pos-1, c); ai_real v = ReadFloat( *e.mValueAccessor, *e.mValueData, pos-1, c);
temp[c] += (v - temp[c]) * factor; temp[c] += (v - temp[c]) * factor;
} }
} }
@ -1152,7 +1152,7 @@ void ColladaLoader::CreateAnimation( aiScene* pScene, const ColladaParser& pPars
resultTrafos.push_back( mat); resultTrafos.push_back( mat);
// find next point in time to evaluate. That's the closest frame larger than the current in any channel // find next point in time to evaluate. That's the closest frame larger than the current in any channel
float nextTime = 1e20f; ai_real nextTime = 1e20;
for( std::vector<Collada::ChannelEntry>::iterator it = entries.begin(); it != entries.end(); ++it) for( std::vector<Collada::ChannelEntry>::iterator it = entries.begin(); it != entries.end(); ++it)
{ {
Collada::ChannelEntry& channelElement = *it; Collada::ChannelEntry& channelElement = *it;
@ -1161,7 +1161,7 @@ void ColladaLoader::CreateAnimation( aiScene* pScene, const ColladaParser& pPars
size_t pos = 0; size_t pos = 0;
while( pos < channelElement.mTimeAccessor->mCount) while( pos < channelElement.mTimeAccessor->mCount)
{ {
const float t = ReadFloat( *channelElement.mTimeAccessor, *channelElement.mTimeData, pos, 0); const ai_real t = ReadFloat( *channelElement.mTimeAccessor, *channelElement.mTimeData, pos, 0);
if( t > time) if( t > time)
{ {
nextTime = std::min( nextTime, t); nextTime = std::min( nextTime, t);
@ -1174,16 +1174,16 @@ void ColladaLoader::CreateAnimation( aiScene* pScene, const ColladaParser& pPars
// Sub-sample axis-angle channels if the delta between two consecutive // Sub-sample axis-angle channels if the delta between two consecutive
// key-frame angles is >= 180 degrees. // key-frame angles is >= 180 degrees.
if (transforms[channelElement.mTransformIndex].mType == Collada::TF_ROTATE && channelElement.mSubElement == 3 && pos > 0 && pos < channelElement.mTimeAccessor->mCount) { if (transforms[channelElement.mTransformIndex].mType == Collada::TF_ROTATE && channelElement.mSubElement == 3 && pos > 0 && pos < channelElement.mTimeAccessor->mCount) {
const float cur_key_angle = ReadFloat(*channelElement.mValueAccessor, *channelElement.mValueData, pos, 0); const ai_real cur_key_angle = ReadFloat(*channelElement.mValueAccessor, *channelElement.mValueData, pos, 0);
const float last_key_angle = ReadFloat(*channelElement.mValueAccessor, *channelElement.mValueData, pos - 1, 0); const ai_real last_key_angle = ReadFloat(*channelElement.mValueAccessor, *channelElement.mValueData, pos - 1, 0);
const float cur_key_time = ReadFloat(*channelElement.mTimeAccessor, *channelElement.mTimeData, pos, 0); const ai_real cur_key_time = ReadFloat(*channelElement.mTimeAccessor, *channelElement.mTimeData, pos, 0);
const float last_key_time = ReadFloat(*channelElement.mTimeAccessor, *channelElement.mTimeData, pos - 1, 0); const ai_real last_key_time = ReadFloat(*channelElement.mTimeAccessor, *channelElement.mTimeData, pos - 1, 0);
const float last_eval_angle = last_key_angle + (cur_key_angle - last_key_angle) * (time - last_key_time) / (cur_key_time - last_key_time); const ai_real last_eval_angle = last_key_angle + (cur_key_angle - last_key_angle) * (time - last_key_time) / (cur_key_time - last_key_time);
const float delta = std::fabs(cur_key_angle - last_eval_angle); const ai_real delta = std::abs(cur_key_angle - last_eval_angle);
if (delta >= 180.0f) { if (delta >= 180.0) {
const int subSampleCount = static_cast<int>(floorf(delta / 90.0f)); const int subSampleCount = static_cast<int>(floorf(delta / 90.0));
if (cur_key_time != time) { if (cur_key_time != time) {
const float nextSampleTime = time + (cur_key_time - time) / subSampleCount; const ai_real nextSampleTime = time + (cur_key_time - time) / subSampleCount;
nextTime = std::min(nextTime, nextSampleTime); nextTime = std::min(nextTime, nextSampleTime);
} }
} }
@ -1289,7 +1289,7 @@ void ColladaLoader::AddTexture ( aiMaterial& mat, const ColladaParser& pParser,
_AI_MATKEY_TEXBLEND_BASE, type, idx); _AI_MATKEY_TEXBLEND_BASE, type, idx);
// Blend factor // Blend factor
mat.AddProperty((float*)&sampler.mWeighting , 1, mat.AddProperty((ai_real*)&sampler.mWeighting , 1,
_AI_MATKEY_TEXBLEND_BASE, type, idx); _AI_MATKEY_TEXBLEND_BASE, type, idx);
// UV source index ... if we didn't resolve the mapping, it is actually just // UV source index ... if we didn't resolve the mapping, it is actually just
@ -1464,11 +1464,11 @@ void ColladaLoader::BuildMaterials( ColladaParser& pParser, aiScene* /*pScene*/)
const int shadeMode = aiShadingMode_Phong; const int shadeMode = aiShadingMode_Phong;
mat->AddProperty<int>( &shadeMode, 1, AI_MATKEY_SHADING_MODEL); mat->AddProperty<int>( &shadeMode, 1, AI_MATKEY_SHADING_MODEL);
aiColor4D colAmbient( 0.2f, 0.2f, 0.2f, 1.0f), colDiffuse( 0.8f, 0.8f, 0.8f, 1.0f), colSpecular( 0.5f, 0.5f, 0.5f, 0.5f); aiColor4D colAmbient( 0.2, 0.2, 0.2, 1.0), colDiffuse( 0.8, 0.8, 0.8, 1.0), colSpecular( 0.5, 0.5, 0.5, 0.5);
mat->AddProperty( &colAmbient, 1, AI_MATKEY_COLOR_AMBIENT); mat->AddProperty( &colAmbient, 1, AI_MATKEY_COLOR_AMBIENT);
mat->AddProperty( &colDiffuse, 1, AI_MATKEY_COLOR_DIFFUSE); mat->AddProperty( &colDiffuse, 1, AI_MATKEY_COLOR_DIFFUSE);
mat->AddProperty( &colSpecular, 1, AI_MATKEY_COLOR_SPECULAR); mat->AddProperty( &colSpecular, 1, AI_MATKEY_COLOR_SPECULAR);
const float specExp = 5.0f; const ai_real specExp = 5.0;
mat->AddProperty( &specExp, 1, AI_MATKEY_SHININESS); mat->AddProperty( &specExp, 1, AI_MATKEY_SHININESS);
} }
#endif #endif
@ -1587,7 +1587,7 @@ void ColladaLoader::ConvertPath (aiString& ss)
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Reads a float value from an accessor and its data array. // Reads a float value from an accessor and its data array.
float ColladaLoader::ReadFloat( const Collada::Accessor& pAccessor, const Collada::Data& pData, size_t pIndex, size_t pOffset) const ai_real ColladaLoader::ReadFloat( const Collada::Accessor& pAccessor, const Collada::Data& pData, size_t pIndex, size_t pOffset) const
{ {
// FIXME: (thom) Test for data type here in every access? For the moment, I leave this to the caller // FIXME: (thom) Test for data type here in every access? For the moment, I leave this to the caller
size_t pos = pAccessor.mStride * pIndex + pAccessor.mOffset + pOffset; size_t pos = pAccessor.mStride * pIndex + pAccessor.mOffset + pOffset;

2
code/ColladaLoader.h
View File

@ -190,7 +190,7 @@ protected:
* @param pOffset Offset into the element, for multipart elements such as vectors or matrices * @param pOffset Offset into the element, for multipart elements such as vectors or matrices
* @return the specified value * @return the specified value
*/ */
float ReadFloat( const Collada::Accessor& pAccessor, const Collada::Data& pData, size_t pIndex, size_t pOffset) const; ai_real ReadFloat( const Collada::Accessor& pAccessor, const Collada::Data& pData, size_t pIndex, size_t pOffset) const;
/** Reads a string value from an accessor and its data array. /** Reads a string value from an accessor and its data array.
* @param pAccessor The accessor to use for reading * @param pAccessor The accessor to use for reading

34
code/ColladaParser.cpp
View File

@ -128,7 +128,7 @@ bool ColladaParser::ReadBoolFromTextContent()
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Read float from text contents of current element // Read float from text contents of current element
float ColladaParser::ReadFloatFromTextContent() ai_real ColladaParser::ReadFloatFromTextContent()
{ {
const char* cur = GetTextContent(); const char* cur = GetTextContent();
return fast_atof(cur); return fast_atof(cur);
@ -674,7 +674,7 @@ void ColladaParser::ReadController( Collada::Controller& pController)
for( unsigned int a = 0; a < 16; a++) for( unsigned int a = 0; a < 16; a++)
{ {
// read a number // read a number
content = fast_atoreal_move<float>( content, pController.mBindShapeMatrix[a]); content = fast_atoreal_move<ai_real>( content, pController.mBindShapeMatrix[a]);
// skip whitespace after it // skip whitespace after it
SkipSpacesAndLineEnd( &content); SkipSpacesAndLineEnd( &content);
} }
@ -1179,13 +1179,13 @@ void ColladaParser::ReadLight( Collada::Light& pLight)
// text content contains 3 floats // text content contains 3 floats
const char* content = GetTextContent(); const char* content = GetTextContent();
content = fast_atoreal_move<float>( content, (float&)pLight.mColor.r); content = fast_atoreal_move<ai_real>( content, (ai_real&)pLight.mColor.r);
SkipSpacesAndLineEnd( &content); SkipSpacesAndLineEnd( &content);
content = fast_atoreal_move<float>( content, (float&)pLight.mColor.g); content = fast_atoreal_move<ai_real>( content, (ai_real&)pLight.mColor.g);
SkipSpacesAndLineEnd( &content); SkipSpacesAndLineEnd( &content);
content = fast_atoreal_move<float>( content, (float&)pLight.mColor.b); content = fast_atoreal_move<ai_real>( content, (ai_real&)pLight.mColor.b);
SkipSpacesAndLineEnd( &content); SkipSpacesAndLineEnd( &content);
TestClosing( "color"); TestClosing( "color");
@ -1578,16 +1578,16 @@ void ColladaParser::ReadEffectColor( aiColor4D& pColor, Sampler& pSampler)
// text content contains 4 floats // text content contains 4 floats
const char* content = GetTextContent(); const char* content = GetTextContent();
content = fast_atoreal_move<float>( content, (float&)pColor.r); content = fast_atoreal_move<ai_real>( content, (ai_real&)pColor.r);
SkipSpacesAndLineEnd( &content); SkipSpacesAndLineEnd( &content);
content = fast_atoreal_move<float>( content, (float&)pColor.g); content = fast_atoreal_move<ai_real>( content, (ai_real&)pColor.g);
SkipSpacesAndLineEnd( &content); SkipSpacesAndLineEnd( &content);
content = fast_atoreal_move<float>( content, (float&)pColor.b); content = fast_atoreal_move<ai_real>( content, (ai_real&)pColor.b);
SkipSpacesAndLineEnd( &content); SkipSpacesAndLineEnd( &content);
content = fast_atoreal_move<float>( content, (float&)pColor.a); content = fast_atoreal_move<ai_real>( content, (ai_real&)pColor.a);
SkipSpacesAndLineEnd( &content); SkipSpacesAndLineEnd( &content);
TestClosing( "color"); TestClosing( "color");
} }
@ -1636,7 +1636,7 @@ void ColladaParser::ReadEffectColor( aiColor4D& pColor, Sampler& pSampler)
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Reads an effect entry containing a float // Reads an effect entry containing a float
void ColladaParser::ReadEffectFloat( float& pFloat) void ColladaParser::ReadEffectFloat( ai_real& pFloat)
{ {
while( mReader->read()) while( mReader->read())
{ {
@ -1645,7 +1645,7 @@ void ColladaParser::ReadEffectFloat( float& pFloat)
{ {
// text content contains a single floats // text content contains a single floats
const char* content = GetTextContent(); const char* content = GetTextContent();
content = fast_atoreal_move<float>( content, pFloat); content = fast_atoreal_move<ai_real>( content, pFloat);
SkipSpacesAndLineEnd( &content); SkipSpacesAndLineEnd( &content);
TestClosing( "float"); TestClosing( "float");
@ -1943,9 +1943,9 @@ void ColladaParser::ReadDataArray()
if( *content == 0) if( *content == 0)
ThrowException( "Expected more values while reading float_array contents."); ThrowException( "Expected more values while reading float_array contents.");
float value; ai_real value;
// read a number // read a number
content = fast_atoreal_move<float>( content, value); content = fast_atoreal_move<ai_real>( content, value);
data.mValues.push_back( value); data.mValues.push_back( value);
// skip whitespace after it // skip whitespace after it
SkipSpacesAndLineEnd( &content); SkipSpacesAndLineEnd( &content);
@ -2456,11 +2456,11 @@ void ColladaParser::ExtractDataObjectFromChannel( const InputChannel& pInput, si
ThrowException( format() << "Invalid data index (" << pLocalIndex << "/" << acc.mCount << ") in primitive specification" ); ThrowException( format() << "Invalid data index (" << pLocalIndex << "/" << acc.mCount << ") in primitive specification" );
// get a pointer to the start of the data object referred to by the accessor and the local index // get a pointer to the start of the data object referred to by the accessor and the local index
const float* dataObject = &(acc.mData->mValues[0]) + acc.mOffset + pLocalIndex* acc.mStride; const ai_real* dataObject = &(acc.mData->mValues[0]) + acc.mOffset + pLocalIndex* acc.mStride;
// assemble according to the accessors component sub-offset list. We don't care, yet, // assemble according to the accessors component sub-offset list. We don't care, yet,
// what kind of object exactly we're extracting here // what kind of object exactly we're extracting here
float obj[4]; ai_real obj[4];
for( size_t c = 0; c < 4; ++c) for( size_t c = 0; c < 4; ++c)
obj[c] = dataObject[acc.mSubOffset[c]]; obj[c] = dataObject[acc.mSubOffset[c]];
@ -2764,7 +2764,7 @@ void ColladaParser::ReadNodeTransformation( Node* pNode, TransformType pType)
for( unsigned int a = 0; a < sNumParameters[pType]; a++) for( unsigned int a = 0; a < sNumParameters[pType]; a++)
{ {
// read a number // read a number
content = fast_atoreal_move<float>( content, tf.f[a]); content = fast_atoreal_move<ai_real>( content, tf.f[a]);
// skip whitespace after it // skip whitespace after it
SkipSpacesAndLineEnd( &content); SkipSpacesAndLineEnd( &content);
} }
@ -3075,7 +3075,7 @@ aiMatrix4x4 ColladaParser::CalculateResultTransform( const std::vector<Transform
case TF_ROTATE: case TF_ROTATE:
{ {
aiMatrix4x4 rot; aiMatrix4x4 rot;
float angle = tf.f[3] * float( AI_MATH_PI) / 180.0f; ai_real angle = tf.f[3] * ai_real( AI_MATH_PI) / 180.0;
aiVector3D axis( tf.f[0], tf.f[1], tf.f[2]); aiVector3D axis( tf.f[0], tf.f[1], tf.f[2]);
aiMatrix4x4::Rotation( angle, axis, rot); aiMatrix4x4::Rotation( angle, axis, rot);
res *= rot; res *= rot;

6
code/ColladaParser.h
View File

@ -147,7 +147,7 @@ namespace Assimp
void ReadEffectColor( aiColor4D& pColor, Collada::Sampler& pSampler); void ReadEffectColor( aiColor4D& pColor, Collada::Sampler& pSampler);
/** Reads an effect entry containing a float */ /** Reads an effect entry containing a float */
void ReadEffectFloat( float& pFloat); void ReadEffectFloat( ai_real& pFloat);
/** Reads an effect parameter specification of any kind */ /** Reads an effect parameter specification of any kind */
void ReadEffectParam( Collada::EffectParam& pParam); void ReadEffectParam( Collada::EffectParam& pParam);
@ -259,7 +259,7 @@ namespace Assimp
bool ReadBoolFromTextContent(); bool ReadBoolFromTextContent();
/** Reads a single float from current text content */ /** Reads a single float from current text content */
float ReadFloatFromTextContent(); ai_real ReadFloatFromTextContent();
/** Calculates the resulting transformation from all the given transform steps */ /** Calculates the resulting transformation from all the given transform steps */
aiMatrix4x4 CalculateResultTransform( const std::vector<Collada::Transform>& pTransforms) const; aiMatrix4x4 CalculateResultTransform( const std::vector<Collada::Transform>& pTransforms) const;
@ -335,7 +335,7 @@ namespace Assimp
Collada::Animation mAnims; Collada::Animation mAnims;
/** Size unit: how large compared to a meter */ /** Size unit: how large compared to a meter */
float mUnitSize; ai_real mUnitSize;
/** Which is the up vector */ /** Which is the up vector */
enum { UP_X, UP_Y, UP_Z } mUpDirection; enum { UP_X, UP_Y, UP_Z } mUpDirection;

64
code/ComputeUVMappingProcess.cpp
View File

@ -49,10 +49,10 @@ using namespace Assimp;
namespace { namespace {
const static aiVector3D base_axis_y(0.f,1.f,0.f); const static aiVector3D base_axis_y(0.0,1.0,0.0);
const static aiVector3D base_axis_x(1.f,0.f,0.f); const static aiVector3D base_axis_x(1.0,0.0,0.0);
const static aiVector3D base_axis_z(0.f,0.f,1.f); const static aiVector3D base_axis_z(0.0,0.0,1.0);
const static float angle_epsilon = 0.95f; const static ai_real angle_epsilon = 0.95;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -81,9 +81,9 @@ bool ComputeUVMappingProcess::IsActive( unsigned int pFlags) const
inline bool PlaneIntersect(const aiRay& ray, const aiVector3D& planePos, inline bool PlaneIntersect(const aiRay& ray, const aiVector3D& planePos,
const aiVector3D& planeNormal, aiVector3D& pos) const aiVector3D& planeNormal, aiVector3D& pos)
{ {
const float b = planeNormal * (planePos - ray.pos); const ai_real b = planeNormal * (planePos - ray.pos);
float h = ray.dir * planeNormal; ai_real h = ray.dir * planeNormal;
if ((h < 10e-5f && h > -10e-5f) || (h = b/h) < 0) if ((h < 10e-5 && h > -10e-5) || (h = b/h) < 0)
return false; return false;
pos = ray.pos + (ray.dir * h); pos = ray.pos + (ray.dir * h);
@ -109,11 +109,11 @@ void RemoveUVSeams (aiMesh* mesh, aiVector3D* out)
// much easier, but I don't know how and am currently too tired to // much easier, but I don't know how and am currently too tired to
// to think about a better solution. // to think about a better solution.
const static float LOWER_LIMIT = 0.1f; const static ai_real LOWER_LIMIT = 0.1;
const static float UPPER_LIMIT = 0.9f; const static ai_real UPPER_LIMIT = 0.9;
const static float LOWER_EPSILON = 10e-3f; const static ai_real LOWER_EPSILON = 10e-3;
const static float UPPER_EPSILON = 1.f-10e-3f; const static ai_real UPPER_EPSILON = 1.0-10e-3;
for (unsigned int fidx = 0; fidx < mesh->mNumFaces;++fidx) for (unsigned int fidx = 0; fidx < mesh->mNumFaces;++fidx)
{ {
@ -156,12 +156,12 @@ void RemoveUVSeams (aiMesh* mesh, aiVector3D* out)
// If the u value is over the upper limit and no other u // If the u value is over the upper limit and no other u
// value of that face is 0, round it to 0 // value of that face is 0, round it to 0
if (out[face.mIndices[n]].x > UPPER_LIMIT && !zero) if (out[face.mIndices[n]].x > UPPER_LIMIT && !zero)
out[face.mIndices[n]].x = 0.f; out[face.mIndices[n]].x = 0.0;
// If the u value is below the lower limit and no other u // If the u value is below the lower limit and no other u
// value of that face is 1, round it to 1 // value of that face is 1, round it to 1
else if (out[face.mIndices[n]].x < LOWER_LIMIT && !one) else if (out[face.mIndices[n]].x < LOWER_LIMIT && !one)
out[face.mIndices[n]].x = 1.f; out[face.mIndices[n]].x = 1.0;
// The face contains both 0 and 1 as UV coords. This can occur // The face contains both 0 and 1 as UV coords. This can occur
// for faces which have an edge that lies directly on the seam. // for faces which have an edge that lies directly on the seam.
@ -171,9 +171,9 @@ void RemoveUVSeams (aiMesh* mesh, aiVector3D* out)
else if (one && zero) else if (one && zero)
{ {
if (round_to_zero && out[face.mIndices[n]].x >= UPPER_EPSILON) if (round_to_zero && out[face.mIndices[n]].x >= UPPER_EPSILON)
out[face.mIndices[n]].x = 0.f; out[face.mIndices[n]].x = 0.0;
else if (!round_to_zero && out[face.mIndices[n]].x <= LOWER_EPSILON) else if (!round_to_zero && out[face.mIndices[n]].x <= LOWER_EPSILON)
out[face.mIndices[n]].x = 1.f; out[face.mIndices[n]].x = 1.0;
} }
} }
} }
@ -207,7 +207,7 @@ void ComputeUVMappingProcess::ComputeSphereMapping(aiMesh* mesh,const aiVector3D
for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt) { for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt) {
const aiVector3D diff = (mesh->mVertices[pnt]-center).Normalize(); const aiVector3D diff = (mesh->mVertices[pnt]-center).Normalize();
out[pnt] = aiVector3D((atan2 (diff.z, diff.y) + AI_MATH_PI_F ) / AI_MATH_TWO_PI_F, out[pnt] = aiVector3D((atan2 (diff.z, diff.y) + AI_MATH_PI_F ) / AI_MATH_TWO_PI_F,
(std::asin (diff.x) + AI_MATH_HALF_PI_F) / AI_MATH_PI_F, 0.f); (std::asin (diff.x) + AI_MATH_HALF_PI_F) / AI_MATH_PI_F, 0.0);
} }
} }
else if (axis * base_axis_y >= angle_epsilon) { else if (axis * base_axis_y >= angle_epsilon) {
@ -215,7 +215,7 @@ void ComputeUVMappingProcess::ComputeSphereMapping(aiMesh* mesh,const aiVector3D
for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt) { for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt) {
const aiVector3D diff = (mesh->mVertices[pnt]-center).Normalize(); const aiVector3D diff = (mesh->mVertices[pnt]-center).Normalize();
out[pnt] = aiVector3D((atan2 (diff.x, diff.z) + AI_MATH_PI_F ) / AI_MATH_TWO_PI_F, out[pnt] = aiVector3D((atan2 (diff.x, diff.z) + AI_MATH_PI_F ) / AI_MATH_TWO_PI_F,
(std::asin (diff.y) + AI_MATH_HALF_PI_F) / AI_MATH_PI_F, 0.f); (std::asin (diff.y) + AI_MATH_HALF_PI_F) / AI_MATH_PI_F, 0.0);
} }
} }
else if (axis * base_axis_z >= angle_epsilon) { else if (axis * base_axis_z >= angle_epsilon) {
@ -223,7 +223,7 @@ void ComputeUVMappingProcess::ComputeSphereMapping(aiMesh* mesh,const aiVector3D
for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt) { for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt) {
const aiVector3D diff = (mesh->mVertices[pnt]-center).Normalize(); const aiVector3D diff = (mesh->mVertices[pnt]-center).Normalize();
out[pnt] = aiVector3D((atan2 (diff.y, diff.x) + AI_MATH_PI_F ) / AI_MATH_TWO_PI_F, out[pnt] = aiVector3D((atan2 (diff.y, diff.x) + AI_MATH_PI_F ) / AI_MATH_TWO_PI_F,
(std::asin (diff.z) + AI_MATH_HALF_PI_F) / AI_MATH_PI_F, 0.f); (std::asin (diff.z) + AI_MATH_HALF_PI_F) / AI_MATH_PI_F, 0.0);
} }
} }
// slower code path in case the mapping axis is not one of the coordinate system axes // slower code path in case the mapping axis is not one of the coordinate system axes
@ -235,7 +235,7 @@ void ComputeUVMappingProcess::ComputeSphereMapping(aiMesh* mesh,const aiVector3D
for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt) { for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt) {
const aiVector3D diff = ((mTrafo*mesh->mVertices[pnt])-center).Normalize(); const aiVector3D diff = ((mTrafo*mesh->mVertices[pnt])-center).Normalize();
out[pnt] = aiVector3D((atan2 (diff.y, diff.x) + AI_MATH_PI_F ) / AI_MATH_TWO_PI_F, out[pnt] = aiVector3D((atan2 (diff.y, diff.x) + AI_MATH_PI_F ) / AI_MATH_TWO_PI_F,
(asin (diff.z) + AI_MATH_HALF_PI_F) / AI_MATH_PI_F, 0.f); (asin (diff.z) + AI_MATH_HALF_PI_F) / AI_MATH_PI_F, 0.0);
} }
} }
@ -257,7 +257,7 @@ void ComputeUVMappingProcess::ComputeCylinderMapping(aiMesh* mesh,const aiVector
// thus changing the mapping axis) // thus changing the mapping axis)
if (axis * base_axis_x >= angle_epsilon) { if (axis * base_axis_x >= angle_epsilon) {
FindMeshCenter(mesh, center, min, max); FindMeshCenter(mesh, center, min, max);
const float diff = max.x - min.x; const ai_real diff = max.x - min.x;
// If the main axis is 'z', the z coordinate of a point 'p' is mapped // If the main axis is 'z', the z coordinate of a point 'p' is mapped
// directly to the texture V axis. The other axis is derived from // directly to the texture V axis. The other axis is derived from
@ -268,12 +268,12 @@ void ComputeUVMappingProcess::ComputeCylinderMapping(aiMesh* mesh,const aiVector
aiVector3D& uv = out[pnt]; aiVector3D& uv = out[pnt];
uv.y = (pos.x - min.x) / diff; uv.y = (pos.x - min.x) / diff;
uv.x = (atan2 ( pos.z - center.z, pos.y - center.y) +(float)AI_MATH_PI ) / (float)AI_MATH_TWO_PI; uv.x = (atan2 ( pos.z - center.z, pos.y - center.y) +(ai_real)AI_MATH_PI ) / (ai_real)AI_MATH_TWO_PI;
} }
} }
else if (axis * base_axis_y >= angle_epsilon) { else if (axis * base_axis_y >= angle_epsilon) {
FindMeshCenter(mesh, center, min, max); FindMeshCenter(mesh, center, min, max);
const float diff = max.y - min.y; const ai_real diff = max.y - min.y;
// just the same ... // just the same ...
for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt) { for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt) {
@ -281,12 +281,12 @@ void ComputeUVMappingProcess::ComputeCylinderMapping(aiMesh* mesh,const aiVector
aiVector3D& uv = out[pnt]; aiVector3D& uv = out[pnt];
uv.y = (pos.y - min.y) / diff; uv.y = (pos.y - min.y) / diff;
uv.x = (atan2 ( pos.x - center.x, pos.z - center.z) +(float)AI_MATH_PI ) / (float)AI_MATH_TWO_PI; uv.x = (atan2 ( pos.x - center.x, pos.z - center.z) +(ai_real)AI_MATH_PI ) / (ai_real)AI_MATH_TWO_PI;
} }
} }
else if (axis * base_axis_z >= angle_epsilon) { else if (axis * base_axis_z >= angle_epsilon) {
FindMeshCenter(mesh, center, min, max); FindMeshCenter(mesh, center, min, max);
const float diff = max.z - min.z; const ai_real diff = max.z - min.z;
// just the same ... // just the same ...
for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt) { for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt) {
@ -294,7 +294,7 @@ void ComputeUVMappingProcess::ComputeCylinderMapping(aiMesh* mesh,const aiVector
aiVector3D& uv = out[pnt]; aiVector3D& uv = out[pnt];
uv.y = (pos.z - min.z) / diff; uv.y = (pos.z - min.z) / diff;
uv.x = (atan2 ( pos.y - center.y, pos.x - center.x) +(float)AI_MATH_PI ) / (float)AI_MATH_TWO_PI; uv.x = (atan2 ( pos.y - center.y, pos.x - center.x) +(ai_real)AI_MATH_PI ) / (ai_real)AI_MATH_TWO_PI;
} }
} }
// slower code path in case the mapping axis is not one of the coordinate system axes // slower code path in case the mapping axis is not one of the coordinate system axes
@ -302,7 +302,7 @@ void ComputeUVMappingProcess::ComputeCylinderMapping(aiMesh* mesh,const aiVector
aiMatrix4x4 mTrafo; aiMatrix4x4 mTrafo;
aiMatrix4x4::FromToMatrix(axis,base_axis_y,mTrafo); aiMatrix4x4::FromToMatrix(axis,base_axis_y,mTrafo);
FindMeshCenterTransformed(mesh, center, min, max,mTrafo); FindMeshCenterTransformed(mesh, center, min, max,mTrafo);
const float diff = max.y - min.y; const ai_real diff = max.y - min.y;
// again the same, except we're applying a transformation now // again the same, except we're applying a transformation now
for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt){ for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt){
@ -310,7 +310,7 @@ void ComputeUVMappingProcess::ComputeCylinderMapping(aiMesh* mesh,const aiVector
aiVector3D& uv = out[pnt]; aiVector3D& uv = out[pnt];
uv.y = (pos.y - min.y) / diff; uv.y = (pos.y - min.y) / diff;
uv.x = (atan2 ( pos.x - center.x, pos.z - center.z) +(float)AI_MATH_PI ) / (float)AI_MATH_TWO_PI; uv.x = (atan2 ( pos.x - center.x, pos.z - center.z) +(ai_real)AI_MATH_PI ) / (ai_real)AI_MATH_TWO_PI;
} }
} }
@ -323,7 +323,7 @@ void ComputeUVMappingProcess::ComputeCylinderMapping(aiMesh* mesh,const aiVector
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
void ComputeUVMappingProcess::ComputePlaneMapping(aiMesh* mesh,const aiVector3D& axis, aiVector3D* out) void ComputeUVMappingProcess::ComputePlaneMapping(aiMesh* mesh,const aiVector3D& axis, aiVector3D* out)
{ {
float diffu,diffv; ai_real diffu,diffv;
aiVector3D center, min, max; aiVector3D center, min, max;
// If the axis is one of x,y,z run a faster code path. It's worth the extra effort ... // If the axis is one of x,y,z run a faster code path. It's worth the extra effort ...
@ -337,7 +337,7 @@ void ComputeUVMappingProcess::ComputePlaneMapping(aiMesh* mesh,const aiVector3D&
for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt) { for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt) {
const aiVector3D& pos = mesh->mVertices[pnt]; const aiVector3D& pos = mesh->mVertices[pnt];
out[pnt].Set((pos.z - min.z) / diffu,(pos.y - min.y) / diffv,0.f); out[pnt].Set((pos.z - min.z) / diffu,(pos.y - min.y) / diffv,0.0);
} }
} }
else if (axis * base_axis_y >= angle_epsilon) { else if (axis * base_axis_y >= angle_epsilon) {
@ -347,7 +347,7 @@ void ComputeUVMappingProcess::ComputePlaneMapping(aiMesh* mesh,const aiVector3D&
for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt) { for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt) {
const aiVector3D& pos = mesh->mVertices[pnt]; const aiVector3D& pos = mesh->mVertices[pnt];
out[pnt].Set((pos.x - min.x) / diffu,(pos.z - min.z) / diffv,0.f); out[pnt].Set((pos.x - min.x) / diffu,(pos.z - min.z) / diffv,0.0);
} }
} }
else if (axis * base_axis_z >= angle_epsilon) { else if (axis * base_axis_z >= angle_epsilon) {
@ -357,7 +357,7 @@ void ComputeUVMappingProcess::ComputePlaneMapping(aiMesh* mesh,const aiVector3D&
for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt) { for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt) {
const aiVector3D& pos = mesh->mVertices[pnt]; const aiVector3D& pos = mesh->mVertices[pnt];
out[pnt].Set((pos.y - min.y) / diffu,(pos.x - min.x) / diffv,0.f); out[pnt].Set((pos.y - min.y) / diffu,(pos.x - min.x) / diffv,0.0);
} }
} }
// slower code path in case the mapping axis is not one of the coordinate system axes // slower code path in case the mapping axis is not one of the coordinate system axes
@ -372,7 +372,7 @@ void ComputeUVMappingProcess::ComputePlaneMapping(aiMesh* mesh,const aiVector3D&
// again the same, except we're applying a transformation now // again the same, except we're applying a transformation now
for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt) { for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt) {
const aiVector3D pos = mTrafo * mesh->mVertices[pnt]; const aiVector3D pos = mTrafo * mesh->mVertices[pnt];
out[pnt].Set((pos.x - min.x) / diffu,(pos.z - min.z) / diffv,0.f); out[pnt].Set((pos.x - min.x) / diffu,(pos.z - min.z) / diffv,0.0);
} }
} }

12
code/Exporter.cpp
View File

@ -534,9 +534,9 @@ bool ExportProperties :: SetPropertyInteger(const char* szName, int iValue)
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Set a configuration property // Set a configuration property
bool ExportProperties :: SetPropertyFloat(const char* szName, float iValue) bool ExportProperties :: SetPropertyFloat(const char* szName, ai_real iValue)
{ {
return SetGenericProperty<float>(mFloatProperties, szName,iValue); return SetGenericProperty<ai_real>(mFloatProperties, szName,iValue);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -563,10 +563,10 @@ int ExportProperties :: GetPropertyInteger(const char* szName,
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Get a configuration property // Get a configuration property
float ExportProperties :: GetPropertyFloat(const char* szName, ai_real ExportProperties :: GetPropertyFloat(const char* szName,
float iErrorReturn /*= 10e10*/) const ai_real iErrorReturn /*= 10e10*/) const
{ {
return GetGenericProperty<float>(mFloatProperties,szName,iErrorReturn); return GetGenericProperty<ai_real>(mFloatProperties,szName,iErrorReturn);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -603,7 +603,7 @@ bool ExportProperties :: HasPropertyBool(const char* szName) const
// Has a configuration property // Has a configuration property
bool ExportProperties :: HasPropertyFloat(const char* szName) const bool ExportProperties :: HasPropertyFloat(const char* szName) const
{ {
return HasGenericProperty<float>(mFloatProperties, szName); return HasGenericProperty<ai_real>(mFloatProperties, szName);
}; };
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------

4
code/FBXConverter.cpp
View File

@ -3037,7 +3037,7 @@ void Converter::InterpolateKeys( aiVectorKey* valOut, const KeyTimeList& keys, c
next_pos.resize( inputs.size(), 0 ); next_pos.resize( inputs.size(), 0 );
for( KeyTimeList::value_type time : keys ) { for( KeyTimeList::value_type time : keys ) {
float result[ 3 ] = { def_value.x, def_value.y, def_value.z }; ai_real result[ 3 ] = { def_value.x, def_value.y, def_value.z };
for ( size_t i = 0; i < count; ++i ) { for ( size_t i = 0; i < count; ++i ) {
const KeyFrameList& kfl = inputs[ i ]; const KeyFrameList& kfl = inputs[ i ];
@ -3060,7 +3060,7 @@ void Converter::InterpolateKeys( aiVectorKey* valOut, const KeyTimeList& keys, c
// do the actual interpolation in double-precision arithmetics // do the actual interpolation in double-precision arithmetics
// because it is a bit sensitive to rounding errors. // because it is a bit sensitive to rounding errors.
const double factor = timeB == timeA ? 0. : static_cast<double>( ( time - timeA ) / ( timeB - timeA ) ); const double factor = timeB == timeA ? 0. : static_cast<double>( ( time - timeA ) / ( timeB - timeA ) );
const float interpValue = static_cast<float>( valueA + ( valueB - valueA ) * factor ); const ai_real interpValue = static_cast<ai_real>( valueA + ( valueB - valueA ) * factor );
result[ std::get<2>(kfl) ] = interpValue; result[ std::get<2>(kfl) ] = interpValue;
} }

12
code/FindInvalidDataProcess.cpp
View File

@ -58,7 +58,7 @@ using namespace Assimp;
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Constructor to be privately used by Importer // Constructor to be privately used by Importer
FindInvalidDataProcess::FindInvalidDataProcess() FindInvalidDataProcess::FindInvalidDataProcess()
: configEpsilon(0.0f) : configEpsilon(0.0)
{ {
// nothing to do here // nothing to do here
} }
@ -221,16 +221,16 @@ inline bool ProcessArray(T*& in, unsigned int num,const char* name,
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename T> template <typename T>
AI_FORCE_INLINE bool EpsilonCompare(const T& n, const T& s, float epsilon); AI_FORCE_INLINE bool EpsilonCompare(const T& n, const T& s, ai_real epsilon);
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
AI_FORCE_INLINE bool EpsilonCompare(float n, float s, float epsilon) { AI_FORCE_INLINE bool EpsilonCompare(ai_real n, ai_real s, ai_real epsilon) {
return std::fabs(n-s)>epsilon; return std::fabs(n-s)>epsilon;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <> template <>
bool EpsilonCompare<aiVectorKey>(const aiVectorKey& n, const aiVectorKey& s, float epsilon) { bool EpsilonCompare<aiVectorKey>(const aiVectorKey& n, const aiVectorKey& s, ai_real epsilon) {
return return
EpsilonCompare(n.mValue.x,s.mValue.x,epsilon) && EpsilonCompare(n.mValue.x,s.mValue.x,epsilon) &&
EpsilonCompare(n.mValue.y,s.mValue.y,epsilon) && EpsilonCompare(n.mValue.y,s.mValue.y,epsilon) &&
@ -239,7 +239,7 @@ bool EpsilonCompare<aiVectorKey>(const aiVectorKey& n, const aiVectorKey& s, flo
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <> template <>
bool EpsilonCompare<aiQuatKey>(const aiQuatKey& n, const aiQuatKey& s, float epsilon) { bool EpsilonCompare<aiQuatKey>(const aiQuatKey& n, const aiQuatKey& s, ai_real epsilon) {
return return
EpsilonCompare(n.mValue.x,s.mValue.x,epsilon) && EpsilonCompare(n.mValue.x,s.mValue.x,epsilon) &&
EpsilonCompare(n.mValue.y,s.mValue.y,epsilon) && EpsilonCompare(n.mValue.y,s.mValue.y,epsilon) &&
@ -249,7 +249,7 @@ bool EpsilonCompare<aiQuatKey>(const aiQuatKey& n, const aiQuatKey& s, float eps
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename T> template <typename T>
inline bool AllIdentical(T* in, unsigned int num, float epsilon) inline bool AllIdentical(T* in, unsigned int num, ai_real epsilon)
{ {
if (num <= 1) { if (num <= 1) {
return true; return true;

2
code/FindInvalidDataProcess.h
View File

@ -97,7 +97,7 @@ public:
void ProcessAnimationChannel (aiNodeAnim* anim); void ProcessAnimationChannel (aiNodeAnim* anim);
private: private:
float configEpsilon; ai_real configEpsilon;
}; };
} // end of namespace Assimp } // end of namespace Assimp

16
code/GenVertexNormalsProcess.cpp
View File

@ -78,8 +78,8 @@ bool GenVertexNormalsProcess::IsActive( unsigned int pFlags) const
void GenVertexNormalsProcess::SetupProperties(const Importer* pImp) void GenVertexNormalsProcess::SetupProperties(const Importer* pImp)
{ {
// Get the current value of the AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE property // Get the current value of the AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE property
configMaxAngle = pImp->GetPropertyFloat(AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE,175.f); configMaxAngle = pImp->GetPropertyFloat(AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE,(ai_real)175.0);
configMaxAngle = AI_DEG_TO_RAD(std::max(std::min(configMaxAngle,175.0f),0.0f)); configMaxAngle = AI_DEG_TO_RAD(std::max(std::min(configMaxAngle,(ai_real)175.0),(ai_real)0.0));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -123,7 +123,7 @@ bool GenVertexNormalsProcess::GenMeshVertexNormals (aiMesh* pMesh, unsigned int
} }
// Allocate the array to hold the output normals // Allocate the array to hold the output normals
const float qnan = std::numeric_limits<float>::quiet_NaN(); const float qnan = std::numeric_limits<ai_real>::quiet_NaN();
pMesh->mNormals = new aiVector3D[pMesh->mNumVertices]; pMesh->mNormals = new aiVector3D[pMesh->mNumVertices];
// Compute per-face normals but store them per-vertex // Compute per-face normals but store them per-vertex
@ -154,13 +154,13 @@ bool GenVertexNormalsProcess::GenMeshVertexNormals (aiMesh* pMesh, unsigned int
// check whether we can reuse the SpatialSort of a previous step. // check whether we can reuse the SpatialSort of a previous step.
SpatialSort* vertexFinder = NULL; SpatialSort* vertexFinder = NULL;
SpatialSort _vertexFinder; SpatialSort _vertexFinder;
float posEpsilon = 1e-5f; ai_real posEpsilon = 1e-5;
if (shared) { if (shared) {
std::vector<std::pair<SpatialSort,float> >* avf; std::vector<std::pair<SpatialSort,ai_real> >* avf;
shared->GetProperty(AI_SPP_SPATIAL_SORT,avf); shared->GetProperty(AI_SPP_SPATIAL_SORT,avf);
if (avf) if (avf)
{ {
std::pair<SpatialSort,float>& blubb = avf->operator [] (meshIndex); std::pair<SpatialSort,ai_real>& blubb = avf->operator [] (meshIndex);
vertexFinder = &blubb.first; vertexFinder = &blubb.first;
posEpsilon = blubb.second; posEpsilon = blubb.second;
} }
@ -205,13 +205,13 @@ bool GenVertexNormalsProcess::GenMeshVertexNormals (aiMesh* pMesh, unsigned int
// Slower code path if a smooth angle is set. There are many ways to achieve // Slower code path if a smooth angle is set. There are many ways to achieve
// the effect, this one is the most straightforward one. // the effect, this one is the most straightforward one.
else { else {
const float fLimit = std::cos(configMaxAngle); const ai_real fLimit = std::cos(configMaxAngle);
for (unsigned int i = 0; i < pMesh->mNumVertices;++i) { for (unsigned int i = 0; i < pMesh->mNumVertices;++i) {
// Get all vertices that share this one ... // Get all vertices that share this one ...
vertexFinder->FindPositions( pMesh->mVertices[i] , posEpsilon, verticesFound); vertexFinder->FindPositions( pMesh->mVertices[i] , posEpsilon, verticesFound);
aiVector3D vr = pMesh->mNormals[i]; aiVector3D vr = pMesh->mNormals[i];
float vrlen = vr.Length(); ai_real vrlen = vr.Length();
aiVector3D pcNor; aiVector3D pcNor;
for (unsigned int a = 0; a < verticesFound.size(); ++a) { for (unsigned int a = 0; a < verticesFound.size(); ++a) {

5
code/GenVertexNormalsProcess.h
View File

@ -86,7 +86,7 @@ public:
// setter for configMaxAngle // setter for configMaxAngle
inline void SetMaxSmoothAngle(float f) inline void SetMaxSmoothAngle(ai_real f)
{ {
configMaxAngle =f; configMaxAngle =f;
} }
@ -104,10 +104,9 @@ public:
private: private:
/** Configuration option: maximum smoothing angle, in radians*/ /** Configuration option: maximum smoothing angle, in radians*/
float configMaxAngle; ai_real configMaxAngle;
}; };
} // end of namespace Assimp } // end of namespace Assimp
#endif // !!AI_GENVERTEXNORMALPROCESS_H_INC #endif // !!AI_GENVERTEXNORMALPROCESS_H_INC

72
code/IRRLoader.cpp
View File

@ -207,54 +207,54 @@ void IRRImporter::BuildSkybox(std::vector<aiMesh*>& meshes, std::vector<aiMateri
// by six single planes with different textures, so we'll // by six single planes with different textures, so we'll
// need to build six meshes. // need to build six meshes.
const float l = 10.f; // the size used by Irrlicht const ai_real l = 10.0; // the size used by Irrlicht
// FRONT SIDE // FRONT SIDE
meshes.push_back( BuildSingleQuadMesh( meshes.push_back( BuildSingleQuadMesh(
SkyboxVertex(-l,-l,-l, 0, 0, 1, 1.f,1.f), SkyboxVertex(-l,-l,-l, 0, 0, 1, 1.0,1.0),
SkyboxVertex( l,-l,-l, 0, 0, 1, 0.f,1.f), SkyboxVertex( l,-l,-l, 0, 0, 1, 0.0,1.0),
SkyboxVertex( l, l,-l, 0, 0, 1, 0.f,0.f), SkyboxVertex( l, l,-l, 0, 0, 1, 0.0,0.0),
SkyboxVertex(-l, l,-l, 0, 0, 1, 1.f,0.f)) ); SkyboxVertex(-l, l,-l, 0, 0, 1, 1.0,0.0)) );
meshes.back()->mMaterialIndex = materials.size()-6u; meshes.back()->mMaterialIndex = materials.size()-6u;
// LEFT SIDE // LEFT SIDE
meshes.push_back( BuildSingleQuadMesh( meshes.push_back( BuildSingleQuadMesh(
SkyboxVertex( l,-l,-l, -1, 0, 0, 1.f,1.f), SkyboxVertex( l,-l,-l, -1, 0, 0, 1.0,1.0),
SkyboxVertex( l,-l, l, -1, 0, 0, 0.f,1.f), SkyboxVertex( l,-l, l, -1, 0, 0, 0.0,1.0),
SkyboxVertex( l, l, l, -1, 0, 0, 0.f,0.f), SkyboxVertex( l, l, l, -1, 0, 0, 0.0,0.0),
SkyboxVertex( l, l,-l, -1, 0, 0, 1.f,0.f)) ); SkyboxVertex( l, l,-l, -1, 0, 0, 1.0,0.0)) );
meshes.back()->mMaterialIndex = materials.size()-5u; meshes.back()->mMaterialIndex = materials.size()-5u;
// BACK SIDE // BACK SIDE
meshes.push_back( BuildSingleQuadMesh( meshes.push_back( BuildSingleQuadMesh(
SkyboxVertex( l,-l, l, 0, 0, -1, 1.f,1.f), SkyboxVertex( l,-l, l, 0, 0, -1, 1.0,1.0),
SkyboxVertex(-l,-l, l, 0, 0, -1, 0.f,1.f), SkyboxVertex(-l,-l, l, 0, 0, -1, 0.0,1.0),
SkyboxVertex(-l, l, l, 0, 0, -1, 0.f,0.f), SkyboxVertex(-l, l, l, 0, 0, -1, 0.0,0.0),
SkyboxVertex( l, l, l, 0, 0, -1, 1.f,0.f)) ); SkyboxVertex( l, l, l, 0, 0, -1, 1.0,0.0)) );
meshes.back()->mMaterialIndex = materials.size()-4u; meshes.back()->mMaterialIndex = materials.size()-4u;
// RIGHT SIDE // RIGHT SIDE
meshes.push_back( BuildSingleQuadMesh( meshes.push_back( BuildSingleQuadMesh(
SkyboxVertex(-l,-l, l, 1, 0, 0, 1.f,1.f), SkyboxVertex(-l,-l, l, 1, 0, 0, 1.0,1.0),
SkyboxVertex(-l,-l,-l, 1, 0, 0, 0.f,1.f), SkyboxVertex(-l,-l,-l, 1, 0, 0, 0.0,1.0),
SkyboxVertex(-l, l,-l, 1, 0, 0, 0.f,0.f), SkyboxVertex(-l, l,-l, 1, 0, 0, 0.0,0.0),
SkyboxVertex(-l, l, l, 1, 0, 0, 1.f,0.f)) ); SkyboxVertex(-l, l, l, 1, 0, 0, 1.0,0.0)) );
meshes.back()->mMaterialIndex = materials.size()-3u; meshes.back()->mMaterialIndex = materials.size()-3u;
// TOP SIDE // TOP SIDE
meshes.push_back( BuildSingleQuadMesh( meshes.push_back( BuildSingleQuadMesh(
SkyboxVertex( l, l,-l, 0, -1, 0, 1.f,1.f), SkyboxVertex( l, l,-l, 0, -1, 0, 1.0,1.0),
SkyboxVertex( l, l, l, 0, -1, 0, 0.f,1.f), SkyboxVertex( l, l, l, 0, -1, 0, 0.0,1.0),
SkyboxVertex(-l, l, l, 0, -1, 0, 0.f,0.f), SkyboxVertex(-l, l, l, 0, -1, 0, 0.0,0.0),
SkyboxVertex(-l, l,-l, 0, -1, 0, 1.f,0.f)) ); SkyboxVertex(-l, l,-l, 0, -1, 0, 1.0,0.0)) );
meshes.back()->mMaterialIndex = materials.size()-2u; meshes.back()->mMaterialIndex = materials.size()-2u;
// BOTTOM SIDE // BOTTOM SIDE
meshes.push_back( BuildSingleQuadMesh( meshes.push_back( BuildSingleQuadMesh(
SkyboxVertex( l,-l, l, 0, 1, 0, 0.f,0.f), SkyboxVertex( l,-l, l, 0, 1, 0, 0.0,0.0),
SkyboxVertex( l,-l,-l, 0, 1, 0, 1.f,0.f), SkyboxVertex( l,-l,-l, 0, 1, 0, 1.0,0.0),
SkyboxVertex(-l,-l,-l, 0, 1, 0, 1.f,1.f), SkyboxVertex(-l,-l,-l, 0, 1, 0, 1.0,1.0),
SkyboxVertex(-l,-l, l, 0, 1, 0, 0.f,1.f)) ); SkyboxVertex(-l,-l, l, 0, 1, 0, 0.0,1.0)) );
meshes.back()->mMaterialIndex = materials.size()-1u; meshes.back()->mMaterialIndex = materials.size()-1u;
} }
@ -479,7 +479,7 @@ void IRRImporter::ComputeAnimations(Node* root, aiNode* real, std::vector<aiNode
aiVectorKey& key = anim->mPositionKeys[i]; aiVectorKey& key = anim->mPositionKeys[i];
key.mTime = i * tdelta; key.mTime = i * tdelta;
const float t = (float) ( in.speed * key.mTime ); const ai_real t = (ai_real) ( in.speed * key.mTime );
key.mValue = in.circleCenter + in.circleRadius * ((vecU * std::cos(t)) + (vecV * std::sin(t))); key.mValue = in.circleCenter + in.circleRadius * ((vecU * std::cos(t)) + (vecV * std::sin(t)));
} }
@ -498,7 +498,7 @@ void IRRImporter::ComputeAnimations(Node* root, aiNode* real, std::vector<aiNode
anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys]; anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys];
aiVector3D diff = in.direction - in.circleCenter; aiVector3D diff = in.direction - in.circleCenter;
const float lengthOfWay = diff.Length(); const ai_real lengthOfWay = diff.Length();
diff.Normalize(); diff.Normalize();
const double timeFactor = lengthOfWay / in.timeForWay; const double timeFactor = lengthOfWay / in.timeForWay;
@ -507,7 +507,7 @@ void IRRImporter::ComputeAnimations(Node* root, aiNode* real, std::vector<aiNode
for (unsigned int i = 0; i < anim->mNumPositionKeys;++i) { for (unsigned int i = 0; i < anim->mNumPositionKeys;++i) {
aiVectorKey& key = anim->mPositionKeys[i]; aiVectorKey& key = anim->mPositionKeys[i];
key.mTime = i * tdelta; key.mTime = i * tdelta;
key.mValue = in.circleCenter + diff * float(timeFactor * key.mTime); key.mValue = in.circleCenter + diff * ai_real(timeFactor * key.mTime);
} }
} }
break; break;
@ -542,8 +542,8 @@ void IRRImporter::ComputeAnimations(Node* root, aiNode* real, std::vector<aiNode
{ {
aiVectorKey& key = anim->mPositionKeys[i]; aiVectorKey& key = anim->mPositionKeys[i];
const float dt = (i * in.speed * 0.001f ); const ai_real dt = (i * in.speed * 0.001 );
const float u = dt - std::floor(dt); const ai_real u = dt - std::floor(dt);
const int idx = (int)std::floor(dt) % size; const int idx = (int)std::floor(dt) % size;
// get the 4 current points to evaluate the spline // get the 4 current points to evaluate the spline
@ -553,13 +553,13 @@ void IRRImporter::ComputeAnimations(Node* root, aiNode* real, std::vector<aiNode
const aiVector3D& p3 = in.splineKeys[ ClampSpline( idx + 2, size ) ].mValue; const aiVector3D& p3 = in.splineKeys[ ClampSpline( idx + 2, size ) ].mValue;
// compute polynomials // compute polynomials
const float u2 = u*u; const ai_real u2 = u*u;
const float u3 = u2*2; const ai_real u3 = u2*2;
const float h1 = 2.0f * u3 - 3.0f * u2 + 1.0f; const ai_real h1 = 2.0 * u3 - 3.0 * u2 + 1.0;
const float h2 = -2.0f * u3 + 3.0f * u3; const ai_real h2 = -2.0 * u3 + 3.0 * u3;
const float h3 = u3 - 2.0f * u3; const ai_real h3 = u3 - 2.0 * u3;
const float h4 = u3 - u2; const ai_real h4 = u3 - u2;
// compute the spline tangents // compute the spline tangents
const aiVector3D t1 = ( p2 - p0 ) * in.tightness; const aiVector3D t1 = ( p2 - p0 ) * in.tightness;

30
code/IRRLoader.h
View File

@ -116,9 +116,9 @@ private:
explicit Animator(AT t = UNKNOWN) explicit Animator(AT t = UNKNOWN)
: type (t) : type (t)
, speed (0.001f) , speed (0.001)
, direction (0.f,1.f,0.f) , direction (0.0,1.0,0.0)
, circleRadius (1.f) , circleRadius (1.0)
, tightness (0.5f) , tightness (0.5f)
, loop (true) , loop (true)
, timeForWay (100) , timeForWay (100)
@ -127,15 +127,15 @@ private:
// common parameters // common parameters
float speed; ai_real speed;
aiVector3D direction; aiVector3D direction;
// FLY_CIRCLE // FLY_CIRCLE
aiVector3D circleCenter; aiVector3D circleCenter;
float circleRadius; ai_real circleRadius;
// FOLLOW_SPLINE // FOLLOW_SPLINE
float tightness; ai_real tightness;
std::vector<aiVectorKey> splineKeys; std::vector<aiVectorKey> splineKeys;
// ROTATION (angles given in direction) // ROTATION (angles given in direction)
@ -166,11 +166,11 @@ private:
explicit Node(ET t) explicit Node(ET t)
: type (t) : type (t)
, scaling (1.f,1.f,1.f) // assume uniform scaling by default , scaling (1.0,1.0,1.0) // assume uniform scaling by default
, parent() , parent()
, framesPerSecond (0.f) , framesPerSecond (0.0)
, id() , id()
, sphereRadius (1.f) , sphereRadius (1.0)
, spherePolyCountX (100) , spherePolyCountX (100)
, spherePolyCountY (100) , spherePolyCountY (100)
{ {
@ -202,7 +202,7 @@ private:
// Animated meshes: frames per second // Animated meshes: frames per second
// 0.f if not specified // 0.f if not specified
float framesPerSecond; ai_real framesPerSecond;
// Meshes: path to the mesh to be loaded // Meshes: path to the mesh to be loaded
std::string meshPath; std::string meshPath;
@ -213,7 +213,7 @@ private:
std::vector< std::pair<aiMaterial*, unsigned int> > materials; std::vector< std::pair<aiMaterial*, unsigned int> > materials;
// Spheres: radius of the sphere to be generates // Spheres: radius of the sphere to be generates
float sphereRadius; ai_real sphereRadius;
// Spheres: Number of polygons in the x,y direction // Spheres: Number of polygons in the x,y direction
unsigned int spherePolyCountX,spherePolyCountY; unsigned int spherePolyCountX,spherePolyCountY;
@ -230,13 +230,13 @@ private:
{} {}
//! Construction from single vertex components //! Construction from single vertex components
SkyboxVertex(float px, float py, float pz, SkyboxVertex(ai_real px, ai_real py, ai_real pz,
float nx, float ny, float nz, ai_real nx, ai_real ny, ai_real nz,
float uvx, float uvy) ai_real uvx, ai_real uvy)
: position (px,py,pz) : position (px,py,pz)
, normal (nx,ny,nz) , normal (nx,ny,nz)
, uv (uvx,uvy,0.f) , uv (uvx,uvy,0.0)
{} {}
aiVector3D position, normal, uv; aiVector3D position, normal, uv;

10
code/Importer.cpp
View File

@ -1017,11 +1017,11 @@ bool Importer::SetPropertyInteger(const char* szName, int iValue)
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Set a configuration property // Set a configuration property
bool Importer::SetPropertyFloat(const char* szName, float iValue) bool Importer::SetPropertyFloat(const char* szName, ai_real iValue)
{ {
bool exising; bool exising;
ASSIMP_BEGIN_EXCEPTION_REGION(); ASSIMP_BEGIN_EXCEPTION_REGION();
exising = SetGenericProperty<float>(pimpl->mFloatProperties, szName,iValue); exising = SetGenericProperty<ai_real>(pimpl->mFloatProperties, szName,iValue);
ASSIMP_END_EXCEPTION_REGION(bool); ASSIMP_END_EXCEPTION_REGION(bool);
return exising; return exising;
} }
@ -1058,10 +1058,10 @@ int Importer::GetPropertyInteger(const char* szName,
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Get a configuration property // Get a configuration property
float Importer::GetPropertyFloat(const char* szName, ai_real Importer::GetPropertyFloat(const char* szName,
float iErrorReturn /*= 10e10*/) const ai_real iErrorReturn /*= 10e10*/) const
{ {
return GetGenericProperty<float>(pimpl->mFloatProperties,szName,iErrorReturn); return GetGenericProperty<ai_real>(pimpl->mFloatProperties,szName,iErrorReturn);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------

2
code/Importer.h
View File

@ -75,7 +75,7 @@ public:
// typedefs for our four configuration maps. // typedefs for our four configuration maps.
// We don't need more, so there is no need for a generic solution // We don't need more, so there is no need for a generic solution
typedef std::map<KeyType, int> IntPropertyMap; typedef std::map<KeyType, int> IntPropertyMap;
typedef std::map<KeyType, float> FloatPropertyMap; typedef std::map<KeyType, ai_real> FloatPropertyMap;
typedef std::map<KeyType, std::string> StringPropertyMap; typedef std::map<KeyType, std::string> StringPropertyMap;
typedef std::map<KeyType, aiMatrix4x4> MatrixPropertyMap; typedef std::map<KeyType, aiMatrix4x4> MatrixPropertyMap;

36
code/LWOMaterial.cpp
View File

@ -141,13 +141,13 @@ bool LWOImporter::HandleTextures(aiMaterial* pcMat, const TextureList& in, aiTex
aiVector3D v; aiVector3D v;
switch (texture.majorAxis) { switch (texture.majorAxis) {
case Texture::AXIS_X: case Texture::AXIS_X:
v = aiVector3D(1.f,0.f,0.f); v = aiVector3D(1.0,0.0,0.0);
break; break;
case Texture::AXIS_Y: case Texture::AXIS_Y:
v = aiVector3D(0.f,1.f,0.f); v = aiVector3D(0.0,1.0,0.0);
break; break;
default: // case Texture::AXIS_Z: default: // case Texture::AXIS_Z:
v = aiVector3D(0.f,0.f,1.f); v = aiVector3D(0.0,0.0,1.0);
break; break;
} }
@ -159,7 +159,7 @@ bool LWOImporter::HandleTextures(aiMaterial* pcMat, const TextureList& in, aiTex
trafo.mScaling.x = texture.wrapAmountW; trafo.mScaling.x = texture.wrapAmountW;
trafo.mScaling.y = texture.wrapAmountH; trafo.mScaling.y = texture.wrapAmountH;
static_assert(sizeof(aiUVTransform)/sizeof(float) == 5, "sizeof(aiUVTransform)/sizeof(float) == 5"); static_assert(sizeof(aiUVTransform)/sizeof(ai_real) == 5, "sizeof(aiUVTransform)/sizeof(ai_real) == 5");
pcMat->AddProperty(&trafo,1,AI_MATKEY_UVTRANSFORM(type,cur)); pcMat->AddProperty(&trafo,1,AI_MATKEY_UVTRANSFORM(type,cur));
} }
DefaultLogger::get()->debug("LWO2: Setting up non-UV mapping"); DefaultLogger::get()->debug("LWO2: Setting up non-UV mapping");
@ -286,17 +286,17 @@ void LWOImporter::ConvertMaterial(const LWO::Surface& surf,aiMaterial* pcMat)
{ {
float fGloss; float fGloss;
if (mIsLWO2) { if (mIsLWO2) {
fGloss = std::pow( surf.mGlossiness*10.0f+2.0f, 2.0f); fGloss = std::pow( surf.mGlossiness*10.0+2.0, 2.0);
} }
else else
{ {
if (16.0f >= surf.mGlossiness) if (16.0 >= surf.mGlossiness)
fGloss = 6.0f; fGloss = 6.0;
else if (64.0f >= surf.mGlossiness) else if (64.0 >= surf.mGlossiness)
fGloss = 20.0f; fGloss = 20.0;
else if (256.0f >= surf.mGlossiness) else if (256.0 >= surf.mGlossiness)
fGloss = 50.0f; fGloss = 50.0;
else fGloss = 80.0f; else fGloss = 80.0;
} }
pcMat->AddProperty(&surf.mSpecularValue,1,AI_MATKEY_SHININESS_STRENGTH); pcMat->AddProperty(&surf.mSpecularValue,1,AI_MATKEY_SHININESS_STRENGTH);
@ -306,17 +306,17 @@ void LWOImporter::ConvertMaterial(const LWO::Surface& surf,aiMaterial* pcMat)
else m = aiShadingMode_Gouraud; else m = aiShadingMode_Gouraud;
// specular color // specular color
aiColor3D clr = lerp( aiColor3D(1.f,1.f,1.f), surf.mColor, surf.mColorHighlights ); aiColor3D clr = lerp( aiColor3D(1.0,1.0,1.0), surf.mColor, surf.mColorHighlights );
pcMat->AddProperty(&clr,1,AI_MATKEY_COLOR_SPECULAR); pcMat->AddProperty(&clr,1,AI_MATKEY_COLOR_SPECULAR);
pcMat->AddProperty(&surf.mSpecularValue,1,AI_MATKEY_SHININESS_STRENGTH); pcMat->AddProperty(&surf.mSpecularValue,1,AI_MATKEY_SHININESS_STRENGTH);
// emissive color // emissive color
// luminosity is not really the same but it affects the surface in a similar way. Some scaling looks good. // luminosity is not really the same but it affects the surface in a similar way. Some scaling looks good.
clr.g = clr.b = clr.r = surf.mLuminosity*0.8f; clr.g = clr.b = clr.r = surf.mLuminosity*0.8;
pcMat->AddProperty<aiColor3D>(&clr,1,AI_MATKEY_COLOR_EMISSIVE); pcMat->AddProperty<aiColor3D>(&clr,1,AI_MATKEY_COLOR_EMISSIVE);
// opacity ... either additive or default-blended, please // opacity ... either additive or default-blended, please
if (0.f != surf.mAdditiveTransparency) { if (0.0 != surf.mAdditiveTransparency) {
const int add = aiBlendMode_Additive; const int add = aiBlendMode_Additive;
pcMat->AddProperty(&surf.mAdditiveTransparency,1,AI_MATKEY_OPACITY); pcMat->AddProperty(&surf.mAdditiveTransparency,1,AI_MATKEY_OPACITY);
@ -361,13 +361,13 @@ void LWOImporter::ConvertMaterial(const LWO::Surface& surf,aiMaterial* pcMat)
DefaultLogger::get()->warn("LWO2: Unknown surface shader: " + shader.functionName); DefaultLogger::get()->warn("LWO2: Unknown surface shader: " + shader.functionName);
} }
} }
if (surf.mMaximumSmoothAngle <= 0.0f) if (surf.mMaximumSmoothAngle <= 0.0)
m = aiShadingMode_Flat; m = aiShadingMode_Flat;
pcMat->AddProperty((int*)&m,1,AI_MATKEY_SHADING_MODEL); pcMat->AddProperty((int*)&m,1,AI_MATKEY_SHADING_MODEL);
// (the diffuse value is just a scaling factor) // (the diffuse value is just a scaling factor)
// If a diffuse texture is set, we set this value to 1.0 // If a diffuse texture is set, we set this value to 1.0
clr = (b && false ? aiColor3D(1.f,1.f,1.f) : surf.mColor); clr = (b && false ? aiColor3D(1.0,1.0,1.0) : surf.mColor);
clr.r *= surf.mDiffuseValue; clr.r *= surf.mDiffuseValue;
clr.g *= surf.mDiffuseValue; clr.g *= surf.mDiffuseValue;
clr.b *= surf.mDiffuseValue; clr.b *= surf.mDiffuseValue;
@ -497,7 +497,7 @@ void LWOImporter::FindVCChannels(const LWO::Surface& surf, LWO::SortedRep& sorte
for (unsigned int n = 0; n < face.mNumIndices; ++n) { for (unsigned int n = 0; n < face.mNumIndices; ++n) {
unsigned int idx = face.mIndices[n]; unsigned int idx = face.mIndices[n];
if (vc.abAssigned[idx] && ((aiColor4D*)&vc.rawData[0])[idx] != aiColor4D(0.f,0.f,0.f,1.f)) { if (vc.abAssigned[idx] && ((aiColor4D*)&vc.rawData[0])[idx] != aiColor4D(0.0,0.0,0.0,1.0)) {
if (next >= AI_MAX_NUMBER_OF_COLOR_SETS) { if (next >= AI_MAX_NUMBER_OF_COLOR_SETS) {
DefaultLogger::get()->error("LWO: Maximum number of vertex color channels for " DefaultLogger::get()->error("LWO: Maximum number of vertex color channels for "

17
code/MD3FileData.h
View File

@ -136,7 +136,7 @@ struct Frame
aiVector3D origin; aiVector3D origin;
//! radius of bounding sphere //! radius of bounding sphere
float radius; ai_real radius;
//! name of frame //! name of frame
char name[ AI_MD3_MAXFRAME ]; char name[ AI_MD3_MAXFRAME ];
@ -154,7 +154,7 @@ struct Tag
//! Local tag origin and orientation //! Local tag origin and orientation
aiVector3D origin; aiVector3D origin;
float orientation[3][3]; ai_real orientation[3][3];
} PACK_STRUCT; } PACK_STRUCT;
@ -231,7 +231,7 @@ struct Triangle
struct TexCoord struct TexCoord
{ {
//! UV coordinates //! UV coordinates
float U,V; ai_real U,V;
} PACK_STRUCT; } PACK_STRUCT;
@ -257,12 +257,12 @@ struct Vertex
* *
* @note This has been taken from q3 source (misc_model.c) * @note This has been taken from q3 source (misc_model.c)
*/ */
inline void LatLngNormalToVec3(uint16_t p_iNormal, float* p_afOut) inline void LatLngNormalToVec3(uint16_t p_iNormal, ai_real* p_afOut)
{ {
float lat = (float)(( p_iNormal >> 8u ) & 0xff); ai_real lat = (ai_real)(( p_iNormal >> 8u ) & 0xff);
float lng = (float)(( p_iNormal & 0xff )); ai_real lng = (ai_real)(( p_iNormal & 0xff ));
lat *= 3.141926f/128.0f; lat *= 3.141926/128.0;
lng *= 3.141926f/128.0f; lng *= 3.141926/128.0;
p_afOut[0] = std::cos(lat) * std::sin(lng); p_afOut[0] = std::cos(lat) * std::sin(lng);
p_afOut[1] = std::sin(lat) * std::sin(lng); p_afOut[1] = std::sin(lat) * std::sin(lng);
@ -313,4 +313,3 @@ inline void Vec3NormalToLatLng( const aiVector3D& p_vIn, uint16_t& p_iOut )
} }
#endif // !! AI_MD3FILEHELPER_H_INC #endif // !! AI_MD3FILEHELPER_H_INC

2
code/MD3Loader.cpp
View File

@ -1018,7 +1018,7 @@ void MD3Importer::InternReadFile( const std::string& pFile,
// Convert the normal vector to uncompressed float3 format // Convert the normal vector to uncompressed float3 format
aiVector3D& nor = pcMesh->mNormals[iCurrent]; aiVector3D& nor = pcMesh->mNormals[iCurrent];
LatLngNormalToVec3(pcVertices[pcTriangles->INDEXES[c]].NORMAL,(float*)&nor); LatLngNormalToVec3(pcVertices[pcTriangles->INDEXES[c]].NORMAL,(ai_real*)&nor);
// Read texture coordinates // Read texture coordinates
pcMesh->mTextureCoords[0][iCurrent].x = pcUVs[ pcTriangles->INDEXES[c]].U; pcMesh->mTextureCoords[0][iCurrent].x = pcUVs[ pcTriangles->INDEXES[c]].U;

6
code/MD5Loader.cpp
View File

@ -475,7 +475,7 @@ void MD5Importer::LoadMD5MeshFile ()
*pv = aiVector3D(); *pv = aiVector3D();
// there are models which have weights which don't sum to 1 ... // there are models which have weights which don't sum to 1 ...
float fSum = 0.0f; ai_real fSum = 0.0;
for (unsigned int jub = (*iter).mFirstWeight, w = jub; w < jub + (*iter).mNumWeights;++w) for (unsigned int jub = (*iter).mFirstWeight, w = jub; w < jub + (*iter).mNumWeights;++w)
fSum += meshSrc.mWeights[w].mWeight; fSum += meshSrc.mWeights[w].mWeight;
if (!fSum) { if (!fSum) {
@ -493,7 +493,7 @@ void MD5Importer::LoadMD5MeshFile ()
continue; continue;
} }
const float fNewWeight = desc.mWeight / fSum; const ai_real fNewWeight = desc.mWeight / fSum;
// transform the local position into worldspace // transform the local position into worldspace
MD5::BoneDesc& boneSrc = meshParser.mJoints[desc.mBone]; MD5::BoneDesc& boneSrc = meshParser.mJoints[desc.mBone];
@ -501,7 +501,7 @@ void MD5Importer::LoadMD5MeshFile ()
// use the original weight to compute the vertex position // use the original weight to compute the vertex position
// (some MD5s seem to depend on the invalid weight values ...) // (some MD5s seem to depend on the invalid weight values ...)
*pv += ((boneSrc.mPositionXYZ+v)* desc.mWeight); *pv += ((boneSrc.mPositionXYZ+v)* (ai_real)desc.mWeight);
aiBone* bone = mesh->mBones[boneSrc.mMap]; aiBone* bone = mesh->mBones[boneSrc.mMap];
*bone->mWeights++ = aiVertexWeight((unsigned int)(pv-mesh->mVertices),fNewWeight); *bone->mWeights++ = aiVertexWeight((unsigned int)(pv-mesh->mVertices),fNewWeight);

2
code/MDCLoader.cpp
View File

@ -408,7 +408,7 @@ void MDCImporter::InternReadFile(
// copy texture coordinates // copy texture coordinates
pcUVCur->x = pcUVs[quak].u; pcUVCur->x = pcUVs[quak].u;
pcUVCur->y = 1.0f-pcUVs[quak].v; // DX to OGL pcUVCur->y = 1.0-pcUVs[quak].v; // DX to OGL
} }
pcVertCur->x += pcFrame->localOrigin[0] ; pcVertCur->x += pcFrame->localOrigin[0] ;
pcVertCur->y += pcFrame->localOrigin[1] ; pcVertCur->y += pcFrame->localOrigin[1] ;

2
code/MDLMaterialLoader.cpp
View File

@ -657,7 +657,7 @@ void MDLImporter::ParseSkinLump_3DGS_MDL7(
if (is_not_qnan(clrTexture.r)) { if (is_not_qnan(clrTexture.r)) {
clrTemp.r *= clrTexture.a; clrTemp.r *= clrTexture.a;
} }
pcMatOut->AddProperty<float>(&clrTemp.r,1,AI_MATKEY_OPACITY); pcMatOut->AddProperty<ai_real>(&clrTemp.r,1,AI_MATKEY_OPACITY);
// read phong power // read phong power
int iShadingMode = (int)aiShadingMode_Gouraud; int iShadingMode = (int)aiShadingMode_Gouraud;

4
code/NFFLoader.cpp
View File

@ -965,7 +965,7 @@ void NFFImporter::InternReadFile( const std::string& pFile,
// compute the center point of the cone/cylinder - // compute the center point of the cone/cylinder -
// it is its local transformation origin // it is its local transformation origin
currentMesh.dir = center2-center1; currentMesh.dir = center2-center1;
currentMesh.center = center1+currentMesh.dir/2.f; currentMesh.center = center1+currentMesh.dir/(ai_real)2.0;
float f; float f;
if (( f = currentMesh.dir.Length()) < 10e-3f ) if (( f = currentMesh.dir.Length()) < 10e-3f )
@ -1159,7 +1159,7 @@ void NFFImporter::InternReadFile( const std::string& pFile,
++ppcChildren; ++ppcChildren;
} else { } else {
*pMeshes++ = m; *pMeshes++ = m;
} }
// copy vertex positions // copy vertex positions
mesh->mVertices = new aiVector3D[mesh->mNumVertices]; mesh->mVertices = new aiVector3D[mesh->mNumVertices];

8
code/OFFLoader.cpp
View File

@ -161,9 +161,9 @@ void OFFImporter::InternReadFile( const std::string& pFile,
aiVector3D& v = tempPositions[i]; aiVector3D& v = tempPositions[i];
sz = line; SkipSpaces(&sz); sz = line; SkipSpaces(&sz);
sz = fast_atoreal_move<float>(sz,(float&)v.x); SkipSpaces(&sz); sz = fast_atoreal_move<ai_real>(sz,(ai_real&)v.x); SkipSpaces(&sz);
sz = fast_atoreal_move<float>(sz,(float&)v.y); SkipSpaces(&sz); sz = fast_atoreal_move<ai_real>(sz,(ai_real&)v.y); SkipSpaces(&sz);
fast_atoreal_move<float>(sz,(float&)v.z); fast_atoreal_move<ai_real>(sz,(ai_real&)v.z);
} }
@ -242,7 +242,7 @@ void OFFImporter::InternReadFile( const std::string& pFile,
pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials]; pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials];
aiMaterial* pcMat = new aiMaterial(); aiMaterial* pcMat = new aiMaterial();
aiColor4D clr(0.6f,0.6f,0.6f,1.0f); aiColor4D clr(0.6,0.6,0.6,1.0);
pcMat->AddProperty(&clr,1,AI_MATKEY_COLOR_DIFFUSE); pcMat->AddProperty(&clr,1,AI_MATKEY_COLOR_DIFFUSE);
pScene->mMaterials[0] = pcMat; pScene->mMaterials[0] = pcMat;

2
code/ObjExporter.cpp
View File

@ -167,7 +167,7 @@ void ObjExporter::WriteMaterialFile()
mOutputMat << "Ke " << c.r << " " << c.g << " " << c.b << endl; mOutputMat << "Ke " << c.r << " " << c.g << " " << c.b << endl;
} }
float o; ai_real o;
if(AI_SUCCESS == mat->Get(AI_MATKEY_OPACITY,o)) { if(AI_SUCCESS == mat->Get(AI_MATKEY_OPACITY,o)) {
mOutputMat << "d " << o << endl; mOutputMat << "d " << o << endl;
} }

16
code/ObjFileData.h
View File

@ -191,21 +191,21 @@ struct Material
//! Emissive color //! Emissive color
aiColor3D emissive; aiColor3D emissive;
//! Alpha value //! Alpha value
float alpha; ai_real alpha;
//! Shineness factor //! Shineness factor
float shineness; ai_real shineness;
//! Illumination model //! Illumination model
int illumination_model; int illumination_model;
//! Index of refraction //! Index of refraction
float ior; ai_real ior;
//! Constructor //! Constructor
Material() Material()
: diffuse (0.6f,0.6f,0.6f) : diffuse (0.6,0.6,0.6)
, alpha (1.f) , alpha (1.0)
, shineness (0.0f) , shineness (0.0)
, illumination_model (1) , illumination_model (1)
, ior (1.f) , ior (1.0)
{ {
// empty // empty
for (size_t i = 0; i < TextureTypeCount; ++i) for (size_t i = 0; i < TextureTypeCount; ++i)
@ -244,7 +244,7 @@ struct Mesh {
bool m_hasVertexColors; bool m_hasVertexColors;
/// Constructor /// Constructor
explicit Mesh( const std::string &name ) explicit Mesh( const std::string &name )
: m_name( name ) : m_name( name )
, m_pMaterial(NULL) , m_pMaterial(NULL)
, m_uiNumIndices(0) , m_uiNumIndices(0)

8
code/ObjFileMtlImporter.cpp
View File

@ -164,7 +164,7 @@ void ObjFileMtlImporter::load()
} }
break; break;
case 'd': case 'd':
{ {
if( *(m_DataIt+1) == 'i' && *( m_DataIt + 2 ) == 's' && *( m_DataIt + 3 ) == 'p' ) { if( *(m_DataIt+1) == 'i' && *( m_DataIt + 2 ) == 's' && *( m_DataIt + 3 ) == 'p' ) {
// A displacement map // A displacement map
@ -232,7 +232,7 @@ void ObjFileMtlImporter::getColorRGBA( aiColor3D *pColor )
{ {
ai_assert( NULL != pColor ); ai_assert( NULL != pColor );
float r( 0.0f ), g( 0.0f ), b( 0.0f ); ai_real r( 0.0 ), g( 0.0 ), b( 0.0 );
m_DataIt = getFloat<DataArrayIt>( m_DataIt, m_DataItEnd, r ); m_DataIt = getFloat<DataArrayIt>( m_DataIt, m_DataItEnd, r );
pColor->r = r; pColor->r = r;
@ -255,10 +255,10 @@ void ObjFileMtlImporter::getIlluminationModel( int &illum_model )
// ------------------------------------------------------------------- // -------------------------------------------------------------------
// Loads a single float value. // Loads a single float value.
void ObjFileMtlImporter::getFloatValue( float &value ) void ObjFileMtlImporter::getFloatValue( ai_real &value )
{ {
m_DataIt = CopyNextWord<DataArrayIt>( m_DataIt, m_DataItEnd, m_buffer, BUFFERSIZE ); m_DataIt = CopyNextWord<DataArrayIt>( m_DataIt, m_DataItEnd, m_buffer, BUFFERSIZE );
value = (float) fast_atof(m_buffer); value = (ai_real) fast_atof(m_buffer);
} }
// ------------------------------------------------------------------- // -------------------------------------------------------------------

3
code/ObjFileMtlImporter.h
View File

@ -41,6 +41,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <vector> #include <vector>
#include <string> #include <string>
#include <assimp/defs.h>
struct aiColor3D; struct aiColor3D;
struct aiString; struct aiString;
@ -85,7 +86,7 @@ private:
/// Get illumination model from loaded data /// Get illumination model from loaded data
void getIlluminationModel( int &illum_model ); void getIlluminationModel( int &illum_model );
/// Gets a float value from data. /// Gets a float value from data.
void getFloatValue( float &value ); void getFloatValue( ai_real &value );
/// Creates a new material from loaded data. /// Creates a new material from loaded data.
void createMaterial(); void createMaterial();
/// Get texture name from loaded data. /// Get texture name from loaded data.

40
code/ObjFileParser.cpp
View File

@ -279,23 +279,23 @@ size_t ObjFileParser::getNumComponentsInLine() {
// ------------------------------------------------------------------- // -------------------------------------------------------------------
void ObjFileParser::getVector( std::vector<aiVector3D> &point3d_array ) { void ObjFileParser::getVector( std::vector<aiVector3D> &point3d_array ) {
size_t numComponents = getNumComponentsInLine(); size_t numComponents = getNumComponentsInLine();
float x, y, z; ai_real x, y, z;
if( 2 == numComponents ) { if( 2 == numComponents ) {
copyNextWord( m_buffer, Buffersize ); copyNextWord( m_buffer, Buffersize );
x = ( float ) fast_atof( m_buffer ); x = ( ai_real ) fast_atof( m_buffer );
copyNextWord( m_buffer, Buffersize ); copyNextWord( m_buffer, Buffersize );
y = ( float ) fast_atof( m_buffer ); y = ( ai_real ) fast_atof( m_buffer );
z = 0.0; z = 0.0;
} else if( 3 == numComponents ) { } else if( 3 == numComponents ) {
copyNextWord( m_buffer, Buffersize ); copyNextWord( m_buffer, Buffersize );
x = ( float ) fast_atof( m_buffer ); x = ( ai_real ) fast_atof( m_buffer );
copyNextWord( m_buffer, Buffersize ); copyNextWord( m_buffer, Buffersize );
y = ( float ) fast_atof( m_buffer ); y = ( ai_real ) fast_atof( m_buffer );
copyNextWord( m_buffer, Buffersize ); copyNextWord( m_buffer, Buffersize );
z = ( float ) fast_atof( m_buffer ); z = ( ai_real ) fast_atof( m_buffer );
} else { } else {
throw DeadlyImportError( "OBJ: Invalid number of components" ); throw DeadlyImportError( "OBJ: Invalid number of components" );
} }
@ -306,15 +306,15 @@ void ObjFileParser::getVector( std::vector<aiVector3D> &point3d_array ) {
// ------------------------------------------------------------------- // -------------------------------------------------------------------
// Get values for a new 3D vector instance // Get values for a new 3D vector instance
void ObjFileParser::getVector3( std::vector<aiVector3D> &point3d_array ) { void ObjFileParser::getVector3( std::vector<aiVector3D> &point3d_array ) {
float x, y, z; ai_real x, y, z;
copyNextWord(m_buffer, Buffersize); copyNextWord(m_buffer, Buffersize);
x = (float) fast_atof(m_buffer); x = (ai_real) fast_atof(m_buffer);
copyNextWord(m_buffer, Buffersize); copyNextWord(m_buffer, Buffersize);
y = (float) fast_atof(m_buffer); y = (ai_real) fast_atof(m_buffer);
copyNextWord( m_buffer, Buffersize ); copyNextWord( m_buffer, Buffersize );
z = ( float ) fast_atof( m_buffer ); z = ( ai_real ) fast_atof( m_buffer );
point3d_array.push_back( aiVector3D( x, y, z ) ); point3d_array.push_back( aiVector3D( x, y, z ) );
m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine ); m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
@ -323,26 +323,26 @@ void ObjFileParser::getVector3( std::vector<aiVector3D> &point3d_array ) {
// ------------------------------------------------------------------- // -------------------------------------------------------------------
// Get values for two 3D vectors on the same line // Get values for two 3D vectors on the same line
void ObjFileParser::getTwoVectors3( std::vector<aiVector3D> &point3d_array_a, std::vector<aiVector3D> &point3d_array_b ) { void ObjFileParser::getTwoVectors3( std::vector<aiVector3D> &point3d_array_a, std::vector<aiVector3D> &point3d_array_b ) {
float x, y, z; ai_real x, y, z;
copyNextWord(m_buffer, Buffersize); copyNextWord(m_buffer, Buffersize);
x = (float) fast_atof(m_buffer); x = (ai_real) fast_atof(m_buffer);
copyNextWord(m_buffer, Buffersize); copyNextWord(m_buffer, Buffersize);
y = (float) fast_atof(m_buffer); y = (ai_real) fast_atof(m_buffer);
copyNextWord( m_buffer, Buffersize ); copyNextWord( m_buffer, Buffersize );
z = ( float ) fast_atof( m_buffer ); z = ( ai_real ) fast_atof( m_buffer );
point3d_array_a.push_back( aiVector3D( x, y, z ) ); point3d_array_a.push_back( aiVector3D( x, y, z ) );
copyNextWord(m_buffer, Buffersize); copyNextWord(m_buffer, Buffersize);
x = (float) fast_atof(m_buffer); x = (ai_real) fast_atof(m_buffer);
copyNextWord(m_buffer, Buffersize); copyNextWord(m_buffer, Buffersize);
y = (float) fast_atof(m_buffer); y = (ai_real) fast_atof(m_buffer);
copyNextWord( m_buffer, Buffersize ); copyNextWord( m_buffer, Buffersize );
z = ( float ) fast_atof( m_buffer ); z = ( ai_real ) fast_atof( m_buffer );
point3d_array_b.push_back( aiVector3D( x, y, z ) ); point3d_array_b.push_back( aiVector3D( x, y, z ) );
@ -352,12 +352,12 @@ void ObjFileParser::getTwoVectors3( std::vector<aiVector3D> &point3d_array_a, st
// ------------------------------------------------------------------- // -------------------------------------------------------------------
// Get values for a new 2D vector instance // Get values for a new 2D vector instance
void ObjFileParser::getVector2( std::vector<aiVector2D> &point2d_array ) { void ObjFileParser::getVector2( std::vector<aiVector2D> &point2d_array ) {
float x, y; ai_real x, y;
copyNextWord(m_buffer, Buffersize); copyNextWord(m_buffer, Buffersize);
x = (float) fast_atof(m_buffer); x = (ai_real) fast_atof(m_buffer);
copyNextWord(m_buffer, Buffersize); copyNextWord(m_buffer, Buffersize);
y = (float) fast_atof(m_buffer); y = (ai_real) fast_atof(m_buffer);
point2d_array.push_back(aiVector2D(x, y)); point2d_array.push_back(aiVector2D(x, y));

4
code/ObjTools.h
View File

@ -196,12 +196,12 @@ inline char_t CopyNextWord( char_t it, char_t end, char *pBuffer, size_t length
* @return Current-iterator with new position * @return Current-iterator with new position
*/ */
template<class char_t> template<class char_t>
inline char_t getFloat( char_t it, char_t end, float &value ) inline char_t getFloat( char_t it, char_t end, ai_real &value )
{ {
static const size_t BUFFERSIZE = 1024; static const size_t BUFFERSIZE = 1024;
char buffer[ BUFFERSIZE ]; char buffer[ BUFFERSIZE ];
it = CopyNextWord<char_t>( it, end, buffer, BUFFERSIZE ); it = CopyNextWord<char_t>( it, end, buffer, BUFFERSIZE );
value = (float) fast_atof( buffer ); value = (ai_real) fast_atof( buffer );
return it; return it;
} }

62
code/PlyExporter.cpp
View File

@ -56,6 +56,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//using namespace Assimp; //using namespace Assimp;
namespace Assimp { namespace Assimp {
// make sure typeof returns consistent output across different platforms
// also consider using: typeid(VAR).name()
template <typename T> const char* typeof(T&) { return "unknown"; }
template<> const char* typeof(float&) { return "float"; }
template<> const char* typeof(double&) { return "double"; }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Worker function for exporting a scene to PLY. Prototyped and registered in Exporter.cpp // Worker function for exporting a scene to PLY. Prototyped and registered in Exporter.cpp
void ExportScenePly(const char* pFile,IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* pProperties) void ExportScenePly(const char* pFile,IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* pProperties)
@ -136,15 +142,21 @@ PlyExporter::PlyExporter(const char* _filename, const aiScene* pScene, bool bina
<< aiGetVersionMajor() << '.' << aiGetVersionMinor() << '.' << aiGetVersionMajor() << '.' << aiGetVersionMinor() << '.'
<< aiGetVersionRevision() << ")" << endl; << aiGetVersionRevision() << ")" << endl;
// TODO: probably want to check here rather than just assume something
// definitely not good to always write float even if we might have double precision
ai_real tmp = 0.0;
const char * typeName = typeof(tmp);
mOutput << "element vertex " << vertices << endl; mOutput << "element vertex " << vertices << endl;
mOutput << "property float x" << endl; mOutput << "property " << typeName << " x" << endl;
mOutput << "property float y" << endl; mOutput << "property " << typeName << " y" << endl;
mOutput << "property float z" << endl; mOutput << "property " << typeName << " z" << endl;
if(components & PLY_EXPORT_HAS_NORMALS) { if(components & PLY_EXPORT_HAS_NORMALS) {
mOutput << "property float nx" << endl; mOutput << "property " << typeName << " nx" << endl;
mOutput << "property float ny" << endl; mOutput << "property " << typeName << " ny" << endl;
mOutput << "property float nz" << endl; mOutput << "property " << typeName << " nz" << endl;
} }
// write texcoords first, just in case an importer does not support tangents // write texcoords first, just in case an importer does not support tangents
@ -154,37 +166,37 @@ PlyExporter::PlyExporter(const char* _filename, const aiScene* pScene, bool bina
// and texture coordinates). // and texture coordinates).
for (unsigned int n = PLY_EXPORT_HAS_TEXCOORDS, c = 0; (components & n) && c != AI_MAX_NUMBER_OF_TEXTURECOORDS; n <<= 1, ++c) { for (unsigned int n = PLY_EXPORT_HAS_TEXCOORDS, c = 0; (components & n) && c != AI_MAX_NUMBER_OF_TEXTURECOORDS; n <<= 1, ++c) {
if (!c) { if (!c) {
mOutput << "property float s" << endl; mOutput << "property " << typeName << " s" << endl;
mOutput << "property float t" << endl; mOutput << "property " << typeName << " t" << endl;
} }
else { else {
mOutput << "property float s" << c << endl; mOutput << "property " << typeName << " s" << c << endl;
mOutput << "property float t" << c << endl; mOutput << "property " << typeName << " t" << c << endl;
} }
} }
for (unsigned int n = PLY_EXPORT_HAS_COLORS, c = 0; (components & n) && c != AI_MAX_NUMBER_OF_COLOR_SETS; n <<= 1, ++c) { for (unsigned int n = PLY_EXPORT_HAS_COLORS, c = 0; (components & n) && c != AI_MAX_NUMBER_OF_COLOR_SETS; n <<= 1, ++c) {
if (!c) { if (!c) {
mOutput << "property float r" << endl; mOutput << "property " << typeName << " r" << endl;
mOutput << "property float g" << endl; mOutput << "property " << typeName << " g" << endl;
mOutput << "property float b" << endl; mOutput << "property " << typeName << " b" << endl;
mOutput << "property float a" << endl; mOutput << "property " << typeName << " a" << endl;
} }
else { else {
mOutput << "property float r" << c << endl; mOutput << "property " << typeName << " r" << c << endl;
mOutput << "property float g" << c << endl; mOutput << "property " << typeName << " g" << c << endl;
mOutput << "property float b" << c << endl; mOutput << "property " << typeName << " b" << c << endl;
mOutput << "property float a" << c << endl; mOutput << "property " << typeName << " a" << c << endl;
} }
} }
if(components & PLY_EXPORT_HAS_TANGENTS_BITANGENTS) { if(components & PLY_EXPORT_HAS_TANGENTS_BITANGENTS) {
mOutput << "property float tx" << endl; mOutput << "property " << typeName << " tx" << endl;
mOutput << "property float ty" << endl; mOutput << "property " << typeName << " ty" << endl;
mOutput << "property float tz" << endl; mOutput << "property " << typeName << " tz" << endl;
mOutput << "property float bx" << endl; mOutput << "property " << typeName << " bx" << endl;
mOutput << "property float by" << endl; mOutput << "property " << typeName << " by" << endl;
mOutput << "property float bz" << endl; mOutput << "property " << typeName << " bz" << endl;
} }
mOutput << "element face " << faces << endl; mOutput << "element face " << faces << endl;
@ -223,7 +235,7 @@ PlyExporter::~PlyExporter() {
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
void PlyExporter::WriteMeshVerts(const aiMesh* m, unsigned int components) void PlyExporter::WriteMeshVerts(const aiMesh* m, unsigned int components)
{ {
static const float inf = std::numeric_limits<float>::infinity(); static const ai_real inf = std::numeric_limits<ai_real>::infinity();
// If a component (for instance normal vectors) is present in at least one mesh in the scene, // 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. // then default values are written for meshes that do not contain this component.

40
code/PlyLoader.cpp
View File

@ -326,7 +326,7 @@ void PLYImporter::ConvertMeshes(std::vector<PLY::Face>* avFaces,
iNum += (unsigned int)(*avFaces)[aiSplit[p][i]].mIndices.size(); iNum += (unsigned int)(*avFaces)[aiSplit[p][i]].mIndices.size();
} }
p_pcOut->mNumVertices = iNum; p_pcOut->mNumVertices = iNum;
if( 0 == iNum ) { // nothing to do if( 0 == iNum ) { // nothing to do
delete[] aiSplit; // cleanup delete[] aiSplit; // cleanup
delete p_pcOut; delete p_pcOut;
return; return;
@ -481,13 +481,13 @@ void PLYImporter::LoadTextureCoordinates(std::vector<aiVector2D>* pvOut)
if (0xFFFFFFFF != aiPositions[0]) if (0xFFFFFFFF != aiPositions[0])
{ {
vOut.x = PLY::PropertyInstance::ConvertTo<float>( vOut.x = PLY::PropertyInstance::ConvertTo<ai_real>(
GetProperty((*i).alProperties, aiPositions[0]).avList.front(),aiTypes[0]); GetProperty((*i).alProperties, aiPositions[0]).avList.front(),aiTypes[0]);
} }
if (0xFFFFFFFF != aiPositions[1]) if (0xFFFFFFFF != aiPositions[1])
{ {
vOut.y = PLY::PropertyInstance::ConvertTo<float>( vOut.y = PLY::PropertyInstance::ConvertTo<ai_real>(
GetProperty((*i).alProperties, aiPositions[1]).avList.front(),aiTypes[1]); GetProperty((*i).alProperties, aiPositions[1]).avList.front(),aiTypes[1]);
} }
// and add them to our nice list // and add them to our nice list
@ -502,7 +502,7 @@ void PLYImporter::LoadVertices(std::vector<aiVector3D>* pvOut, bool p_bNormals)
{ {
ai_assert(NULL != pvOut); ai_assert(NULL != pvOut);
unsigned int aiPositions[3] = {0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF}; ai_uint aiPositions[3] = {0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF};
PLY::EDataType aiTypes[3] = {EDT_Char,EDT_Char,EDT_Char}; PLY::EDataType aiTypes[3] = {EDT_Char,EDT_Char,EDT_Char};
PLY::ElementInstanceList* pcList = NULL; PLY::ElementInstanceList* pcList = NULL;
unsigned int cnt = 0; unsigned int cnt = 0;
@ -591,19 +591,19 @@ void PLYImporter::LoadVertices(std::vector<aiVector3D>* pvOut, bool p_bNormals)
if (0xFFFFFFFF != aiPositions[0]) if (0xFFFFFFFF != aiPositions[0])
{ {
vOut.x = PLY::PropertyInstance::ConvertTo<float>( vOut.x = PLY::PropertyInstance::ConvertTo<ai_real>(
GetProperty((*i).alProperties, aiPositions[0]).avList.front(),aiTypes[0]); GetProperty((*i).alProperties, aiPositions[0]).avList.front(),aiTypes[0]);
} }
if (0xFFFFFFFF != aiPositions[1]) if (0xFFFFFFFF != aiPositions[1])
{ {
vOut.y = PLY::PropertyInstance::ConvertTo<float>( vOut.y = PLY::PropertyInstance::ConvertTo<ai_real>(
GetProperty((*i).alProperties, aiPositions[1]).avList.front(),aiTypes[1]); GetProperty((*i).alProperties, aiPositions[1]).avList.front(),aiTypes[1]);
} }
if (0xFFFFFFFF != aiPositions[2]) if (0xFFFFFFFF != aiPositions[2])
{ {
vOut.z = PLY::PropertyInstance::ConvertTo<float>( vOut.z = PLY::PropertyInstance::ConvertTo<ai_real>(
GetProperty((*i).alProperties, aiPositions[2]).avList.front(),aiTypes[2]); GetProperty((*i).alProperties, aiPositions[2]).avList.front(),aiTypes[2]);
} }
@ -615,7 +615,7 @@ void PLYImporter::LoadVertices(std::vector<aiVector3D>* pvOut, bool p_bNormals)
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Convert a color component to [0...1] // Convert a color component to [0...1]
float PLYImporter::NormalizeColorValue (PLY::PropertyInstance::ValueUnion val, ai_real PLYImporter::NormalizeColorValue (PLY::PropertyInstance::ValueUnion val,
PLY::EDataType eType) PLY::EDataType eType)
{ {
switch (eType) switch (eType)
@ -623,20 +623,20 @@ float PLYImporter::NormalizeColorValue (PLY::PropertyInstance::ValueUnion val,
case EDT_Float: case EDT_Float:
return val.fFloat; return val.fFloat;
case EDT_Double: case EDT_Double:
return (float)val.fDouble; return (ai_real)val.fDouble;
case EDT_UChar: case EDT_UChar:
return (float)val.iUInt / (float)0xFF; return (ai_real)val.iUInt / (ai_real)0xFF;
case EDT_Char: case EDT_Char:
return (float)(val.iInt+(0xFF/2)) / (float)0xFF; return (ai_real)(val.iInt+(0xFF/2)) / (ai_real)0xFF;
case EDT_UShort: case EDT_UShort:
return (float)val.iUInt / (float)0xFFFF; return (ai_real)val.iUInt / (ai_real)0xFFFF;
case EDT_Short: case EDT_Short:
return (float)(val.iInt+(0xFFFF/2)) / (float)0xFFFF; return (ai_real)(val.iInt+(0xFFFF/2)) / (ai_real)0xFFFF;
case EDT_UInt: case EDT_UInt:
return (float)val.iUInt / (float)0xFFFF; return (ai_real)val.iUInt / (ai_real)0xFFFF;
case EDT_Int: case EDT_Int:
return ((float)val.iInt / (float)0xFF) + 0.5f; return ((ai_real)val.iInt / (ai_real)0xFF) + 0.5f;
default: ; default: ;
}; };
return 0.0f; return 0.0f;
@ -727,7 +727,7 @@ void PLYImporter::LoadVertexColor(std::vector<aiColor4D>* pvOut)
} }
// assume 1.0 for the alpha channel ifit is not set // assume 1.0 for the alpha channel ifit is not set
if (0xFFFFFFFF == aiPositions[3])vOut.a = 1.0f; if (0xFFFFFFFF == aiPositions[3])vOut.a = 1.0;
else else
{ {
vOut.a = NormalizeColorValue(GetProperty((*i).alProperties, vOut.a = NormalizeColorValue(GetProperty((*i).alProperties,
@ -1076,14 +1076,14 @@ void PLYImporter::LoadMaterial(std::vector<aiMaterial*>* pvOut)
// handle phong power and shading mode // handle phong power and shading mode
int iMode; int iMode;
if (0xFFFFFFFF != iPhong) { if (0xFFFFFFFF != iPhong) {
float fSpec = PLY::PropertyInstance::ConvertTo<float>(GetProperty((*i).alProperties, iPhong).avList.front(),ePhong); ai_real fSpec = PLY::PropertyInstance::ConvertTo<ai_real>(GetProperty((*i).alProperties, iPhong).avList.front(),ePhong);
// if shininess is 0 (and the pow() calculation would therefore always // if shininess is 0 (and the pow() calculation would therefore always
// become 1, not depending on the angle), use gouraud lighting // become 1, not depending on the angle), use gouraud lighting
if (fSpec) { if (fSpec) {
// scale this with 15 ... hopefully this is correct // scale this with 15 ... hopefully this is correct
fSpec *= 15; fSpec *= 15;
pcHelper->AddProperty<float>(&fSpec, 1, AI_MATKEY_SHININESS); pcHelper->AddProperty<ai_real>(&fSpec, 1, AI_MATKEY_SHININESS);
iMode = (int)aiShadingMode_Phong; iMode = (int)aiShadingMode_Phong;
} }
@ -1094,8 +1094,8 @@ void PLYImporter::LoadMaterial(std::vector<aiMaterial*>* pvOut)
// handle opacity // handle opacity
if (0xFFFFFFFF != iOpacity) { if (0xFFFFFFFF != iOpacity) {
float fOpacity = PLY::PropertyInstance::ConvertTo<float>(GetProperty((*i).alProperties, iPhong).avList.front(),eOpacity); ai_real fOpacity = PLY::PropertyInstance::ConvertTo<ai_real>(GetProperty((*i).alProperties, iPhong).avList.front(),eOpacity);
pcHelper->AddProperty<float>(&fOpacity, 1, AI_MATKEY_OPACITY); pcHelper->AddProperty<ai_real>(&fOpacity, 1, AI_MATKEY_OPACITY);
} }
// The face order is absolutely undefined for PLY, so we have to // The face order is absolutely undefined for PLY, so we have to

2
code/PlyLoader.h
View File

@ -155,7 +155,7 @@ protected:
/** Static helper to parse a color channel value. The input value /** Static helper to parse a color channel value. The input value
* is normalized to 0-1. * is normalized to 0-1.
*/ */
static float NormalizeColorValue ( static ai_real NormalizeColorValue (
PLY::PropertyInstance::ValueUnion val, PLY::PropertyInstance::ValueUnion val,
PLY::EDataType eType); PLY::EDataType eType);

13
code/PlyParser.cpp
View File

@ -819,15 +819,18 @@ bool PLY::PropertyInstance::ParseValue(
break; break;
case EDT_Float: case EDT_Float:
// technically this should cast to float, but people tend to use float descriptors for double data
pCur = fast_atoreal_move<float>(pCur,out->fFloat); // this is the best way to not risk loosing precision on import and it doesn't hurt to do this
ai_real f;
pCur = fast_atoreal_move<ai_real>(pCur,f);
out->fFloat = (ai_real)f;
break; break;
case EDT_Double: case EDT_Double:
float f; double d;
pCur = fast_atoreal_move<float>(pCur,f); pCur = fast_atoreal_move<double>(pCur,d);
out->fDouble = (double)f; out->fDouble = (double)d;
break; break;
default: default:

5
code/PretransformVertices.cpp
View File

@ -690,9 +690,9 @@ void PretransformVertices::Execute( aiScene* pScene)
// find the dominant axis // find the dominant axis
aiVector3D d = max-min; aiVector3D d = max-min;
const float div = std::max(d.x,std::max(d.y,d.z))*0.5f; const ai_real div = std::max(d.x,std::max(d.y,d.z))*0.5;
d = min+d*0.5f; d = min + d * (ai_real)0.5;
for (unsigned int a = 0; a < pScene->mNumMeshes; ++a) { for (unsigned int a = 0; a < pScene->mNumMeshes; ++a) {
aiMesh* m = pScene->mMeshes[a]; aiMesh* m = pScene->mMeshes[a];
for (unsigned int i = 0; i < m->mNumVertices;++i) { for (unsigned int i = 0; i < m->mNumVertices;++i) {
@ -721,4 +721,3 @@ void PretransformVertices::Execute( aiScene* pScene)
DefaultLogger::get()->info(buffer); DefaultLogger::get()->info(buffer);
} }
} }

18
code/ProcessHelper.cpp
View File

@ -77,8 +77,8 @@ void ConvertListToStrings(const std::string& in, std::list<std::string>& out)
void FindAABBTransformed (const aiMesh* mesh, aiVector3D& min, aiVector3D& max, void FindAABBTransformed (const aiMesh* mesh, aiVector3D& min, aiVector3D& max,
const aiMatrix4x4& m) const aiMatrix4x4& m)
{ {
min = aiVector3D (10e10f, 10e10f, 10e10f); min = aiVector3D (10e10, 10e10, 10e10);
max = aiVector3D (-10e10f,-10e10f,-10e10f); max = aiVector3D (-10e10,-10e10,-10e10);
for (unsigned int i = 0;i < mesh->mNumVertices;++i) for (unsigned int i = 0;i < mesh->mNumVertices;++i)
{ {
const aiVector3D v = m * mesh->mVertices[i]; const aiVector3D v = m * mesh->mVertices[i];
@ -91,7 +91,7 @@ void FindAABBTransformed (const aiMesh* mesh, aiVector3D& min, aiVector3D& max,
void FindMeshCenter (aiMesh* mesh, aiVector3D& out, aiVector3D& min, aiVector3D& max) void FindMeshCenter (aiMesh* mesh, aiVector3D& out, aiVector3D& min, aiVector3D& max)
{ {
ArrayBounds(mesh->mVertices,mesh->mNumVertices, min,max); ArrayBounds(mesh->mVertices,mesh->mNumVertices, min,max);
out = min + (max-min)*0.5f; out = min + (max-min)*(ai_real)0.5;
} }
// ------------------------------------------------------------------------------- // -------------------------------------------------------------------------------
@ -114,7 +114,7 @@ void FindSceneCenter (aiScene* scene, aiVector3D& out, aiVector3D& min, aiVector
if (max[1] < tmax[1]) max[1] = tmax[1]; if (max[1] < tmax[1]) max[1] = tmax[1];
if (max[2] < tmax[2]) max[2] = tmax[2]; if (max[2] < tmax[2]) max[2] = tmax[2];
} }
out = min + (max-min)*0.5f; out = min + (max-min)*(ai_real)0.5;
} }
@ -123,7 +123,7 @@ void FindMeshCenterTransformed (aiMesh* mesh, aiVector3D& out, aiVector3D& min,
aiVector3D& max, const aiMatrix4x4& m) aiVector3D& max, const aiMatrix4x4& m)
{ {
FindAABBTransformed(mesh,min,max,m); FindAABBTransformed(mesh,min,max,m);
out = min + (max-min)*0.5f; out = min + (max-min)*(ai_real)0.5;
} }
// ------------------------------------------------------------------------------- // -------------------------------------------------------------------------------
@ -142,9 +142,9 @@ void FindMeshCenterTransformed (aiMesh* mesh, aiVector3D& out,
} }
// ------------------------------------------------------------------------------- // -------------------------------------------------------------------------------
float ComputePositionEpsilon(const aiMesh* pMesh) ai_real ComputePositionEpsilon(const aiMesh* pMesh)
{ {
const float epsilon = 1e-4f; const ai_real epsilon = 1e-4;
// calculate the position bounds so we have a reliable epsilon to check position differences against // calculate the position bounds so we have a reliable epsilon to check position differences against
aiVector3D minVec, maxVec; aiVector3D minVec, maxVec;
@ -153,11 +153,11 @@ float ComputePositionEpsilon(const aiMesh* pMesh)
} }
// ------------------------------------------------------------------------------- // -------------------------------------------------------------------------------
float ComputePositionEpsilon(const aiMesh* const* pMeshes, size_t num) ai_real ComputePositionEpsilon(const aiMesh* const* pMeshes, size_t num)
{ {
ai_assert( NULL != pMeshes ); ai_assert( NULL != pMeshes );
const float epsilon = 1e-4f; const ai_real epsilon = 1e-4;
// calculate the position bounds so we have a reliable epsilon to check position differences against // calculate the position bounds so we have a reliable epsilon to check position differences against
aiVector3D minVec, maxVec, mi, ma; aiVector3D minVec, maxVec, mi, ma;

8
code/ProcessHelper.h
View File

@ -231,7 +231,7 @@ inline void ArrayBounds(const T* in, unsigned int size, T& min, T& max)
* @param pColor1 First color * @param pColor1 First color
* @param pColor2 second color * @param pColor2 second color
* @return Quadratic color difference */ * @return Quadratic color difference */
inline float GetColorDifference( const aiColor4D& pColor1, const aiColor4D& pColor2) inline ai_real GetColorDifference( const aiColor4D& pColor1, const aiColor4D& pColor2)
{ {
const aiColor4D c (pColor1.r - pColor2.r, pColor1.g - pColor2.g, pColor1.b - pColor2.b, pColor1.a - pColor2.a); const aiColor4D c (pColor1.r - pColor2.r, pColor1.g - pColor2.g, pColor1.b - pColor2.b, pColor1.a - pColor2.a);
return c.r*c.r + c.g*c.g + c.b*c.b + c.a*c.a; return c.r*c.r + c.g*c.g + c.b*c.b + c.a*c.a;
@ -293,12 +293,12 @@ void FindMeshCenterTransformed (aiMesh* mesh, aiVector3D& out,const aiMatrix4x4&
// ------------------------------------------------------------------------------- // -------------------------------------------------------------------------------
// Compute a good epsilon value for position comparisons on a mesh // Compute a good epsilon value for position comparisons on a mesh
float ComputePositionEpsilon(const aiMesh* pMesh); ai_real ComputePositionEpsilon(const aiMesh* pMesh);
// ------------------------------------------------------------------------------- // -------------------------------------------------------------------------------
// Compute a good epsilon value for position comparisons on a array of meshes // Compute a good epsilon value for position comparisons on a array of meshes
float ComputePositionEpsilon(const aiMesh* const* pMeshes, size_t num); ai_real ComputePositionEpsilon(const aiMesh* const* pMeshes, size_t num);
// ------------------------------------------------------------------------------- // -------------------------------------------------------------------------------
@ -345,7 +345,7 @@ class ComputeSpatialSortProcess : public BaseProcess
void Execute( aiScene* pScene) void Execute( aiScene* pScene)
{ {
typedef std::pair<SpatialSort, float> _Type; typedef std::pair<SpatialSort, ai_real> _Type;
DefaultLogger::get()->debug("Generate spatially-sorted vertex cache"); DefaultLogger::get()->debug("Generate spatially-sorted vertex cache");
std::vector<_Type>* p = new std::vector<_Type>(pScene->mNumMeshes); std::vector<_Type>* p = new std::vector<_Type>(pScene->mNumMeshes);

22
code/SIBImporter.cpp
View File

@ -163,13 +163,13 @@ static aiColor3D ReadColor(StreamReaderLE* stream)
static void UnknownChunk(StreamReaderLE* stream, const SIBChunk& chunk) static void UnknownChunk(StreamReaderLE* stream, const SIBChunk& chunk)
{ {
char temp[5] = { char temp[5] = {
static_cast<char>(( chunk.Tag>>24 ) & 0xff), static_cast<char>(( chunk.Tag>>24 ) & 0xff),
static_cast<char>(( chunk.Tag>>16 ) & 0xff), static_cast<char>(( chunk.Tag>>16 ) & 0xff),
static_cast<char>(( chunk.Tag>>8 ) & 0xff), static_cast<char>(( chunk.Tag>>8 ) & 0xff),
static_cast<char>(chunk.Tag & 0xff), '\0' static_cast<char>(chunk.Tag & 0xff), '\0'
}; };
DefaultLogger::get()->warn((Formatter::format(), "SIB: Skipping unknown '",temp,"' chunk.")); DefaultLogger::get()->warn((Formatter::format(), "SIB: Skipping unknown '",temp,"' chunk."));
} }
@ -373,7 +373,7 @@ static void ConnectFaces(SIBMesh* mesh)
uint32_t *idx = &mesh->idx[mesh->faceStart[faceIdx]]; uint32_t *idx = &mesh->idx[mesh->faceStart[faceIdx]];
uint32_t numPoints = *idx++; uint32_t numPoints = *idx++;
uint32_t prev = idx[(numPoints-1)*N+POS]; uint32_t prev = idx[(numPoints-1)*N+POS];
for (uint32_t i=0;i<numPoints;i++,idx+=N) for (uint32_t i=0;i<numPoints;i++,idx+=N)
{ {
uint32_t next = idx[POS]; uint32_t next = idx[POS];
@ -398,7 +398,7 @@ static void ConnectFaces(SIBMesh* mesh)
static aiVector3D CalculateVertexNormal(SIBMesh* mesh, uint32_t faceIdx, uint32_t pos, static aiVector3D CalculateVertexNormal(SIBMesh* mesh, uint32_t faceIdx, uint32_t pos,
const std::vector<aiVector3D>& faceNormals) const std::vector<aiVector3D>& faceNormals)
{ {
// Creased edges complicate this. We need to find the start/end range of the // Creased edges complicate this. We need to find the start/end range of the
// ring of faces that touch this position. // ring of faces that touch this position.
// We do this in two passes. The first pass is to find the end of the range, // We do this in two passes. The first pass is to find the end of the range,
// the second is to work backwards to the start and calculate the final normal. // the second is to work backwards to the start and calculate the final normal.
@ -449,7 +449,7 @@ static aiVector3D CalculateVertexNormal(SIBMesh* mesh, uint32_t faceIdx, uint32_
prevFaceIdx = faceIdx; prevFaceIdx = faceIdx;
faceIdx = nextFaceIdx; faceIdx = nextFaceIdx;
} }
} }
// Normalize it. // Normalize it.
@ -610,7 +610,7 @@ static void ReadShape(SIB* sib, StreamReaderLE* stream)
obj.name = name; obj.name = name;
obj.axis = smesh.axis; obj.axis = smesh.axis;
obj.meshIdx = sib->meshes.size(); obj.meshIdx = sib->meshes.size();
// Now that we know the size of everything, // Now that we know the size of everything,
// we can build the final one-material-per-mesh data. // we can build the final one-material-per-mesh data.
for (size_t n=0;n<meshes.size();n++) for (size_t n=0;n<meshes.size();n++)
@ -697,8 +697,8 @@ static void ReadLightInfo(aiLight* light, StreamReaderLE* stream)
light->mColorDiffuse = ReadColor(stream); light->mColorDiffuse = ReadColor(stream);
light->mColorAmbient = ReadColor(stream); light->mColorAmbient = ReadColor(stream);
light->mColorSpecular = ReadColor(stream); light->mColorSpecular = ReadColor(stream);
float spotExponent = stream->GetF4(); ai_real spotExponent = stream->GetF4();
float spotCutoff = stream->GetF4(); ai_real spotCutoff = stream->GetF4();
light->mAttenuationConstant = stream->GetF4(); light->mAttenuationConstant = stream->GetF4();
light->mAttenuationLinear = stream->GetF4(); light->mAttenuationLinear = stream->GetF4();
light->mAttenuationQuadratic = stream->GetF4(); light->mAttenuationQuadratic = stream->GetF4();
@ -709,9 +709,9 @@ static void ReadLightInfo(aiLight* light, StreamReaderLE* stream)
// 99% and 1% percentiles. // 99% and 1% percentiles.
// OpenGL: I = cos(angle)^E // OpenGL: I = cos(angle)^E
// Solving: angle = acos(I^(1/E)) // Solving: angle = acos(I^(1/E))
float E = 1.0f / std::max(spotExponent, 0.00001f); ai_real E = 1.0 / std::max(spotExponent, (ai_real)0.00001);
float inner = acosf(powf(0.99f, E)); ai_real inner = acos(pow((ai_real)0.99, E));
float outer = acosf(powf(0.01f, E)); ai_real outer = acos(pow((ai_real)0.01, E));
// Apply the cutoff. // Apply the cutoff.
outer = std::min(outer, AI_DEG_TO_RAD(spotCutoff)); outer = std::min(outer, AI_DEG_TO_RAD(spotCutoff));

4
code/STLExporter.cpp
View File

@ -162,12 +162,12 @@ void STLExporter :: WriteMeshBinary(const aiMesh* m)
} }
nor.Normalize(); nor.Normalize();
} }
float nx = nor.x, ny = nor.y, nz = nor.z; ai_real nx = nor.x, ny = nor.y, nz = nor.z;
AI_SWAP4(nx); AI_SWAP4(ny); AI_SWAP4(nz); AI_SWAP4(nx); AI_SWAP4(ny); AI_SWAP4(nz);
mOutput.write((char *)&nx, 4); mOutput.write((char *)&ny, 4); mOutput.write((char *)&nz, 4); mOutput.write((char *)&nx, 4); mOutput.write((char *)&ny, 4); mOutput.write((char *)&nz, 4);
for(unsigned int a = 0; a < f.mNumIndices; ++a) { for(unsigned int a = 0; a < f.mNumIndices; ++a) {
const aiVector3D& v = m->mVertices[f.mIndices[a]]; const aiVector3D& v = m->mVertices[f.mIndices[a]];
float vx = v.x, vy = v.y, vz = v.z; ai_real vx = v.x, vy = v.y, vz = v.z;
AI_SWAP4(vx); AI_SWAP4(vy); AI_SWAP4(vz); AI_SWAP4(vx); AI_SWAP4(vy); AI_SWAP4(vz);
mOutput.write((char *)&vx, 4); mOutput.write((char *)&vy, 4); mOutput.write((char *)&vz, 4); mOutput.write((char *)&vx, 4); mOutput.write((char *)&vy, 4); mOutput.write((char *)&vz, 4);
} }

42
code/STLLoader.cpp
View File

@ -144,7 +144,7 @@ bool STLImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool
const char* tokens[] = {"STL","solid"}; const char* tokens[] = {"STL","solid"};
return SearchFileHeaderForToken(pIOHandler,pFile,tokens,2); return SearchFileHeaderForToken(pIOHandler,pFile,tokens,2);
} }
return false; return false;
} }
@ -189,7 +189,7 @@ void STLImporter::InternReadFile( const std::string& pFile,
this->mBuffer = &mBuffer2[0]; this->mBuffer = &mBuffer2[0];
// the default vertex color is light gray. // the default vertex color is light gray.
clrColorDefault.r = clrColorDefault.g = clrColorDefault.b = clrColorDefault.a = 0.6f; clrColorDefault.r = clrColorDefault.g = clrColorDefault.b = clrColorDefault.a = 0.6;
// allocate a single node // allocate a single node
pScene->mRootNode = new aiNode(); pScene->mRootNode = new aiNode();
@ -217,13 +217,13 @@ void STLImporter::InternReadFile( const std::string& pFile,
s.Set(AI_DEFAULT_MATERIAL_NAME); s.Set(AI_DEFAULT_MATERIAL_NAME);
pcMat->AddProperty(&s, AI_MATKEY_NAME); pcMat->AddProperty(&s, AI_MATKEY_NAME);
aiColor4D clrDiffuse(0.6f,0.6f,0.6f,1.0f); aiColor4D clrDiffuse(0.6,0.6,0.6,1.0);
if (bMatClr) { if (bMatClr) {
clrDiffuse = clrColorDefault; clrDiffuse = clrColorDefault;
} }
pcMat->AddProperty(&clrDiffuse,1,AI_MATKEY_COLOR_DIFFUSE); pcMat->AddProperty(&clrDiffuse,1,AI_MATKEY_COLOR_DIFFUSE);
pcMat->AddProperty(&clrDiffuse,1,AI_MATKEY_COLOR_SPECULAR); pcMat->AddProperty(&clrDiffuse,1,AI_MATKEY_COLOR_SPECULAR);
clrDiffuse = aiColor4D(0.05f,0.05f,0.05f,1.0f); clrDiffuse = aiColor4D(0.05,0.05,0.05,1.0);
pcMat->AddProperty(&clrDiffuse,1,AI_MATKEY_COLOR_AMBIENT); pcMat->AddProperty(&clrDiffuse,1,AI_MATKEY_COLOR_AMBIENT);
pScene->mNumMaterials = 1; pScene->mNumMaterials = 1;
@ -307,11 +307,11 @@ void STLImporter::LoadASCIIFile()
} }
sz += 7; sz += 7;
SkipSpaces(&sz); SkipSpaces(&sz);
sz = fast_atoreal_move<float>(sz, (float&)vn->x ); sz = fast_atoreal_move<ai_real>(sz, (ai_real&)vn->x );
SkipSpaces(&sz); SkipSpaces(&sz);
sz = fast_atoreal_move<float>(sz, (float&)vn->y ); sz = fast_atoreal_move<ai_real>(sz, (ai_real&)vn->y );
SkipSpaces(&sz); SkipSpaces(&sz);
sz = fast_atoreal_move<float>(sz, (float&)vn->z ); sz = fast_atoreal_move<ai_real>(sz, (ai_real&)vn->z );
normalBuffer.push_back(*vn); normalBuffer.push_back(*vn);
normalBuffer.push_back(*vn); normalBuffer.push_back(*vn);
} }
@ -332,11 +332,11 @@ void STLImporter::LoadASCIIFile()
SkipSpaces(&sz); SkipSpaces(&sz);
positionBuffer.push_back(aiVector3D()); positionBuffer.push_back(aiVector3D());
aiVector3D* vn = &positionBuffer.back(); aiVector3D* vn = &positionBuffer.back();
sz = fast_atoreal_move<float>(sz, (float&)vn->x ); sz = fast_atoreal_move<ai_real>(sz, (ai_real&)vn->x );
SkipSpaces(&sz); SkipSpaces(&sz);
sz = fast_atoreal_move<float>(sz, (float&)vn->y ); sz = fast_atoreal_move<ai_real>(sz, (ai_real&)vn->y );
SkipSpaces(&sz); SkipSpaces(&sz);
sz = fast_atoreal_move<float>(sz, (float&)vn->z ); sz = fast_atoreal_move<ai_real>(sz, (ai_real&)vn->z );
faceVertexCounter++; faceVertexCounter++;
} }
} }
@ -416,10 +416,10 @@ bool STLImporter::LoadBinaryFile()
// read the default vertex color for facets // read the default vertex color for facets
bIsMaterialise = true; bIsMaterialise = true;
DefaultLogger::get()->info("STL: Taking code path for Materialise files"); DefaultLogger::get()->info("STL: Taking code path for Materialise files");
clrColorDefault.r = (*sz2++) / 255.0f; clrColorDefault.r = (*sz2++) / 255.0;
clrColorDefault.g = (*sz2++) / 255.0f; clrColorDefault.g = (*sz2++) / 255.0;
clrColorDefault.b = (*sz2++) / 255.0f; clrColorDefault.b = (*sz2++) / 255.0;
clrColorDefault.a = (*sz2++) / 255.0f; clrColorDefault.a = (*sz2++) / 255.0;
break; break;
} }
} }
@ -480,18 +480,18 @@ bool STLImporter::LoadBinaryFile()
DefaultLogger::get()->info("STL: Mesh has vertex colors"); DefaultLogger::get()->info("STL: Mesh has vertex colors");
} }
aiColor4D* clr = &pMesh->mColors[0][i*3]; aiColor4D* clr = &pMesh->mColors[0][i*3];
clr->a = 1.0f; clr->a = 1.0;
if (bIsMaterialise) // this is reversed if (bIsMaterialise) // this is reversed
{ {
clr->r = (color & 0x31u) / 31.0f; clr->r = (color & 0x31u) / 31.0;
clr->g = ((color & (0x31u<<5))>>5u) / 31.0f; clr->g = ((color & (0x31u<<5))>>5u) / 31.0;
clr->b = ((color & (0x31u<<10))>>10u) / 31.0f; clr->b = ((color & (0x31u<<10))>>10u) / 31.0;
} }
else else
{ {
clr->b = (color & 0x31u) / 31.0f; clr->b = (color & 0x31u) / 31.0;
clr->g = ((color & (0x31u<<5))>>5u) / 31.0f; clr->g = ((color & (0x31u<<5))>>5u) / 31.0;
clr->r = ((color & (0x31u<<10))>>10u) / 31.0f; clr->r = ((color & (0x31u<<10))>>10u) / 31.0;
} }
// assign the color to all vertices of the face // assign the color to all vertices of the face
*(clr+1) = *clr; *(clr+1) = *clr;

5
code/SceneCombiner.cpp
View File

@ -1132,7 +1132,7 @@ void SceneCombiner::Copy( aiAnimation** _dest, const aiAnimation* src )
{ {
ai_assert( NULL != _dest ); ai_assert( NULL != _dest );
ai_assert( NULL != src ); ai_assert( NULL != src );
aiAnimation* dest = *_dest = new aiAnimation(); aiAnimation* dest = *_dest = new aiAnimation();
// get a flat copy // get a flat copy
@ -1246,6 +1246,9 @@ void SceneCombiner::Copy (aiMetadata** _dest, const aiMetadata* src)
case AI_FLOAT: case AI_FLOAT:
out.mData = new float(*static_cast<float*>(in.mData)); out.mData = new float(*static_cast<float*>(in.mData));
break; break;
case AI_DOUBLE:
out.mData = new double(*static_cast<double*>(in.mData));
break;
case AI_AISTRING: case AI_AISTRING:
out.mData = new aiString(*static_cast<aiString*>(in.mData)); out.mData = new aiString(*static_cast<aiString*>(in.mData));
break; break;

82
code/SkeletonMeshBuilder.cpp
View File

@ -96,31 +96,31 @@ void SkeletonMeshBuilder::CreateGeometry( const aiNode* pNode)
// find a suitable coordinate system // find a suitable coordinate system
const aiMatrix4x4& childTransform = pNode->mChildren[a]->mTransformation; const aiMatrix4x4& childTransform = pNode->mChildren[a]->mTransformation;
aiVector3D childpos( childTransform.a4, childTransform.b4, childTransform.c4); aiVector3D childpos( childTransform.a4, childTransform.b4, childTransform.c4);
float distanceToChild = childpos.Length(); ai_real distanceToChild = childpos.Length();
if( distanceToChild < 0.0001f) if( distanceToChild < 0.0001)
continue; continue;
aiVector3D up = aiVector3D( childpos).Normalize(); aiVector3D up = aiVector3D( childpos).Normalize();
aiVector3D orth( 1.0f, 0.0f, 0.0f); aiVector3D orth( 1.0, 0.0, 0.0);
if( std::fabs( orth * up) > 0.99f) if( std::fabs( orth * up) > 0.99)
orth.Set( 0.0f, 1.0f, 0.0f); orth.Set( 0.0, 1.0, 0.0);
aiVector3D front = (up ^ orth).Normalize(); aiVector3D front = (up ^ orth).Normalize();
aiVector3D side = (front ^ up).Normalize(); aiVector3D side = (front ^ up).Normalize();
unsigned int localVertexStart = mVertices.size(); unsigned int localVertexStart = mVertices.size();
mVertices.push_back( -front * distanceToChild * 0.1f); mVertices.push_back( -front * distanceToChild * (ai_real)0.1);
mVertices.push_back( childpos); mVertices.push_back( childpos);
mVertices.push_back( -side * distanceToChild * 0.1f); mVertices.push_back( -side * distanceToChild * (ai_real)0.1);
mVertices.push_back( -side * distanceToChild * 0.1f); mVertices.push_back( -side * distanceToChild * (ai_real)0.1);
mVertices.push_back( childpos); mVertices.push_back( childpos);
mVertices.push_back( front * distanceToChild * 0.1f); mVertices.push_back( front * distanceToChild * (ai_real)0.1);
mVertices.push_back( front * distanceToChild * 0.1f); mVertices.push_back( front * distanceToChild * (ai_real)0.1);
mVertices.push_back( childpos); mVertices.push_back( childpos);
mVertices.push_back( side * distanceToChild * 0.1f); mVertices.push_back( side * distanceToChild * (ai_real)0.1);
mVertices.push_back( side * distanceToChild * 0.1f); mVertices.push_back( side * distanceToChild * (ai_real)0.1);
mVertices.push_back( childpos); mVertices.push_back( childpos);
mVertices.push_back( -front * distanceToChild * 0.1f); mVertices.push_back( -front * distanceToChild * (ai_real)0.1);
mFaces.push_back( Face( localVertexStart + 0, localVertexStart + 1, localVertexStart + 2)); mFaces.push_back( Face( localVertexStart + 0, localVertexStart + 1, localVertexStart + 2));
mFaces.push_back( Face( localVertexStart + 3, localVertexStart + 4, localVertexStart + 5)); mFaces.push_back( Face( localVertexStart + 3, localVertexStart + 4, localVertexStart + 5));
@ -132,33 +132,33 @@ void SkeletonMeshBuilder::CreateGeometry( const aiNode* pNode)
{ {
// if the node has no children, it's an end node. Put a little knob there instead // if the node has no children, it's an end node. Put a little knob there instead
aiVector3D ownpos( pNode->mTransformation.a4, pNode->mTransformation.b4, pNode->mTransformation.c4); aiVector3D ownpos( pNode->mTransformation.a4, pNode->mTransformation.b4, pNode->mTransformation.c4);
float sizeEstimate = ownpos.Length() * 0.18f; ai_real sizeEstimate = ownpos.Length() * 0.18;
mVertices.push_back( aiVector3D( -sizeEstimate, 0.0f, 0.0f)); mVertices.push_back( aiVector3D( -sizeEstimate, 0.0, 0.0));
mVertices.push_back( aiVector3D( 0.0f, sizeEstimate, 0.0f)); mVertices.push_back( aiVector3D( 0.0, sizeEstimate, 0.0));
mVertices.push_back( aiVector3D( 0.0f, 0.0f, -sizeEstimate)); mVertices.push_back( aiVector3D( 0.0, 0.0, -sizeEstimate));
mVertices.push_back( aiVector3D( 0.0f, sizeEstimate, 0.0f)); mVertices.push_back( aiVector3D( 0.0, sizeEstimate, 0.0));
mVertices.push_back( aiVector3D( sizeEstimate, 0.0f, 0.0f)); mVertices.push_back( aiVector3D( sizeEstimate, 0.0, 0.0));
mVertices.push_back( aiVector3D( 0.0f, 0.0f, -sizeEstimate)); mVertices.push_back( aiVector3D( 0.0, 0.0, -sizeEstimate));
mVertices.push_back( aiVector3D( sizeEstimate, 0.0f, 0.0f)); mVertices.push_back( aiVector3D( sizeEstimate, 0.0, 0.0));
mVertices.push_back( aiVector3D( 0.0f, -sizeEstimate, 0.0f)); mVertices.push_back( aiVector3D( 0.0, -sizeEstimate, 0.0));
mVertices.push_back( aiVector3D( 0.0f, 0.0f, -sizeEstimate)); mVertices.push_back( aiVector3D( 0.0, 0.0, -sizeEstimate));
mVertices.push_back( aiVector3D( 0.0f, -sizeEstimate, 0.0f)); mVertices.push_back( aiVector3D( 0.0, -sizeEstimate, 0.0));
mVertices.push_back( aiVector3D( -sizeEstimate, 0.0f, 0.0f)); mVertices.push_back( aiVector3D( -sizeEstimate, 0.0, 0.0));
mVertices.push_back( aiVector3D( 0.0f, 0.0f, -sizeEstimate)); mVertices.push_back( aiVector3D( 0.0, 0.0, -sizeEstimate));
mVertices.push_back( aiVector3D( -sizeEstimate, 0.0f, 0.0f)); mVertices.push_back( aiVector3D( -sizeEstimate, 0.0, 0.0));
mVertices.push_back( aiVector3D( 0.0f, 0.0f, sizeEstimate)); mVertices.push_back( aiVector3D( 0.0, 0.0, sizeEstimate));
mVertices.push_back( aiVector3D( 0.0f, sizeEstimate, 0.0f)); mVertices.push_back( aiVector3D( 0.0, sizeEstimate, 0.0));
mVertices.push_back( aiVector3D( 0.0f, sizeEstimate, 0.0f)); mVertices.push_back( aiVector3D( 0.0, sizeEstimate, 0.0));
mVertices.push_back( aiVector3D( 0.0f, 0.0f, sizeEstimate)); mVertices.push_back( aiVector3D( 0.0, 0.0, sizeEstimate));
mVertices.push_back( aiVector3D( sizeEstimate, 0.0f, 0.0f)); mVertices.push_back( aiVector3D( sizeEstimate, 0.0, 0.0));
mVertices.push_back( aiVector3D( sizeEstimate, 0.0f, 0.0f)); mVertices.push_back( aiVector3D( sizeEstimate, 0.0, 0.0));
mVertices.push_back( aiVector3D( 0.0f, 0.0f, sizeEstimate)); mVertices.push_back( aiVector3D( 0.0, 0.0, sizeEstimate));
mVertices.push_back( aiVector3D( 0.0f, -sizeEstimate, 0.0f)); mVertices.push_back( aiVector3D( 0.0, -sizeEstimate, 0.0));
mVertices.push_back( aiVector3D( 0.0f, -sizeEstimate, 0.0f)); mVertices.push_back( aiVector3D( 0.0, -sizeEstimate, 0.0));
mVertices.push_back( aiVector3D( 0.0f, 0.0f, sizeEstimate)); mVertices.push_back( aiVector3D( 0.0, 0.0, sizeEstimate));
mVertices.push_back( aiVector3D( -sizeEstimate, 0.0f, 0.0f)); mVertices.push_back( aiVector3D( -sizeEstimate, 0.0, 0.0));
mFaces.push_back( Face( vertexStartIndex + 0, vertexStartIndex + 1, vertexStartIndex + 2)); mFaces.push_back( Face( vertexStartIndex + 0, vertexStartIndex + 1, vertexStartIndex + 2));
mFaces.push_back( Face( vertexStartIndex + 3, vertexStartIndex + 4, vertexStartIndex + 5)); mFaces.push_back( Face( vertexStartIndex + 3, vertexStartIndex + 4, vertexStartIndex + 5));
@ -187,7 +187,7 @@ void SkeletonMeshBuilder::CreateGeometry( const aiNode* pNode)
bone->mNumWeights = numVertices; bone->mNumWeights = numVertices;
bone->mWeights = new aiVertexWeight[numVertices]; bone->mWeights = new aiVertexWeight[numVertices];
for( unsigned int a = 0; a < numVertices; a++) for( unsigned int a = 0; a < numVertices; a++)
bone->mWeights[a] = aiVertexWeight( vertexStartIndex + a, 1.0f); bone->mWeights[a] = aiVertexWeight( vertexStartIndex + a, 1.0);
// HACK: (thom) transform all vertices to the bone's local space. Should be done before adding // HACK: (thom) transform all vertices to the bone's local space. Should be done before adding
// them to the array, but I'm tired now and I'm annoyed. // them to the array, but I'm tired now and I'm annoyed.
@ -232,8 +232,8 @@ aiMesh* SkeletonMeshBuilder::CreateMesh()
aiVector3D nor = ((mVertices[inface.mIndices[2]] - mVertices[inface.mIndices[0]]) ^ aiVector3D nor = ((mVertices[inface.mIndices[2]] - mVertices[inface.mIndices[0]]) ^
(mVertices[inface.mIndices[1]] - mVertices[inface.mIndices[0]])); (mVertices[inface.mIndices[1]] - mVertices[inface.mIndices[0]]));
if (nor.Length() < 1e-5f) /* ensure that FindInvalidData won't remove us ...*/ if (nor.Length() < 1e-5) /* ensure that FindInvalidData won't remove us ...*/
nor = aiVector3D(1.f,0.f,0.f); nor = aiVector3D(1.0,0.0,0.0);
for (unsigned int n = 0; n < 3; ++n) for (unsigned int n = 0; n < 3; ++n)
mesh->mNormals[inface.mIndices[n]] = nor; mesh->mNormals[inface.mIndices[n]] = nor;

27
code/SpatialSort.cpp
View File

@ -107,7 +107,7 @@ void SpatialSort::Append( const aiVector3D* pPositions, unsigned int pNumPositio
const aiVector3D* vec = reinterpret_cast<const aiVector3D*> (tempPointer + a * pElementOffset); const aiVector3D* vec = reinterpret_cast<const aiVector3D*> (tempPointer + a * pElementOffset);
// store position by index and distance // store position by index and distance
float distance = *vec * mPlaneNormal; ai_real distance = *vec * mPlaneNormal;
mPositions.push_back( Entry( a+initial, *vec, distance)); mPositions.push_back( Entry( a+initial, *vec, distance));
} }
@ -120,10 +120,10 @@ void SpatialSort::Append( const aiVector3D* pPositions, unsigned int pNumPositio
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Returns an iterator for all positions close to the given position. // Returns an iterator for all positions close to the given position.
void SpatialSort::FindPositions( const aiVector3D& pPosition, void SpatialSort::FindPositions( const aiVector3D& pPosition,
float pRadius, std::vector<unsigned int>& poResults) const ai_real pRadius, std::vector<unsigned int>& poResults) const
{ {
const float dist = pPosition * mPlaneNormal; const ai_real dist = pPosition * mPlaneNormal;
const float minDist = dist - pRadius, maxDist = dist + pRadius; const ai_real minDist = dist - pRadius, maxDist = dist + pRadius;
// clear the array in this strange fashion because a simple clear() would also deallocate // clear the array in this strange fashion because a simple clear() would also deallocate
// the array which we want to avoid // the array which we want to avoid
@ -160,7 +160,7 @@ void SpatialSort::FindPositions( const aiVector3D& pPosition,
// Mow start iterating from there until the first position lays outside of the distance range. // Mow start iterating from there until the first position lays outside of the distance range.
// Add all positions inside the distance range within the given radius to the result aray // Add all positions inside the distance range within the given radius to the result aray
std::vector<Entry>::const_iterator it = mPositions.begin() + index; std::vector<Entry>::const_iterator it = mPositions.begin() + index;
const float pSquared = pRadius*pRadius; const ai_real pSquared = pRadius*pRadius;
while( it->mDistance < maxDist) while( it->mDistance < maxDist)
{ {
if( (it->mPosition - pPosition).SquareLength() < pSquared) if( (it->mPosition - pPosition).SquareLength() < pSquared)
@ -182,23 +182,23 @@ namespace {
// and then use them to work with ULPs (Units in the Last Place, for high-precision // and then use them to work with ULPs (Units in the Last Place, for high-precision
// computations) or to compare them (integer comparisons are faster than floating-point // computations) or to compare them (integer comparisons are faster than floating-point
// comparisons on many platforms). // comparisons on many platforms).
typedef signed int BinFloat; typedef ai_int BinFloat;
// -------------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------------
// Converts the bit pattern of a floating-point number to its signed integer representation. // Converts the bit pattern of a floating-point number to its signed integer representation.
BinFloat ToBinary( const float & pValue) { BinFloat ToBinary( const ai_real & pValue) {
// If this assertion fails, signed int is not big enough to store a float on your platform. // If this assertion fails, signed int is not big enough to store a float on your platform.
// Please correct the declaration of BinFloat a few lines above - but do it in a portable, // Please correct the declaration of BinFloat a few lines above - but do it in a portable,
// #ifdef'd manner! // #ifdef'd manner!
static_assert( sizeof(BinFloat) >= sizeof(float), "sizeof(BinFloat) >= sizeof(float)"); static_assert( sizeof(BinFloat) >= sizeof(ai_real), "sizeof(BinFloat) >= sizeof(ai_real)");
#if defined( _MSC_VER) #if defined( _MSC_VER)
// If this assertion fails, Visual C++ has finally moved to ILP64. This means that this // If this assertion fails, Visual C++ has finally moved to ILP64. This means that this
// code has just become legacy code! Find out the current value of _MSC_VER and modify // code has just become legacy code! Find out the current value of _MSC_VER and modify
// the #if above so it evaluates false on the current and all upcoming VC versions (or // the #if above so it evaluates false on the current and all upcoming VC versions (or
// on the current platform, if LP64 or LLP64 are still used on other platforms). // on the current platform, if LP64 or LLP64 are still used on other platforms).
static_assert( sizeof(BinFloat) == sizeof(float), "sizeof(BinFloat) == sizeof(float)"); static_assert( sizeof(BinFloat) == sizeof(ai_real), "sizeof(BinFloat) == sizeof(ai_real)");
// This works best on Visual C++, but other compilers have their problems with it. // This works best on Visual C++, but other compilers have their problems with it.
const BinFloat binValue = reinterpret_cast<BinFloat const &>(pValue); const BinFloat binValue = reinterpret_cast<BinFloat const &>(pValue);
@ -206,7 +206,7 @@ namespace {
// On many compilers, reinterpreting a float address as an integer causes aliasing // On many compilers, reinterpreting a float address as an integer causes aliasing
// problems. This is an ugly but more or less safe way of doing it. // problems. This is an ugly but more or less safe way of doing it.
union { union {
float asFloat; ai_real asFloat;
BinFloat asBin; BinFloat asBin;
} conversion; } conversion;
conversion.asBin = 0; // zero empty space in case sizeof(BinFloat) > sizeof(float) conversion.asBin = 0; // zero empty space in case sizeof(BinFloat) > sizeof(float)
@ -308,13 +308,13 @@ void SpatialSort::FindIdenticalPositions( const aiVector3D& pPosition,
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
unsigned int SpatialSort::GenerateMappingTable(std::vector<unsigned int>& fill,float pRadius) const unsigned int SpatialSort::GenerateMappingTable(std::vector<unsigned int>& fill, ai_real pRadius) const
{ {
fill.resize(mPositions.size(),UINT_MAX); fill.resize(mPositions.size(),UINT_MAX);
float dist, maxDist; ai_real dist, maxDist;
unsigned int t=0; unsigned int t=0;
const float pSquared = pRadius*pRadius; const ai_real pSquared = pRadius*pRadius;
for (size_t i = 0; i < mPositions.size();) { for (size_t i = 0; i < mPositions.size();) {
dist = mPositions[i].mPosition * mPlaneNormal; dist = mPositions[i].mPosition * mPlaneNormal;
maxDist = dist + pRadius; maxDist = dist + pRadius;
@ -339,4 +339,3 @@ unsigned int SpatialSort::GenerateMappingTable(std::vector<unsigned int>& fill,f
#endif #endif
return t; return t;
} }

8
code/SpatialSort.h
View File

@ -117,7 +117,7 @@ public:
* @param poResults The container to store the indices of the found positions. * @param poResults The container to store the indices of the found positions.
* Will be emptied by the call so it may contain anything. * Will be emptied by the call so it may contain anything.
* @return An iterator to iterate over all vertices in the given area.*/ * @return An iterator to iterate over all vertices in the given area.*/
void FindPositions( const aiVector3D& pPosition, float pRadius, void FindPositions( const aiVector3D& pPosition, ai_real pRadius,
std::vector<unsigned int>& poResults) const; std::vector<unsigned int>& poResults) const;
// ------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------
@ -139,7 +139,7 @@ public:
* be counted in. * be counted in.
* @return Number of unique vertices (n). */ * @return Number of unique vertices (n). */
unsigned int GenerateMappingTable(std::vector<unsigned int>& fill, unsigned int GenerateMappingTable(std::vector<unsigned int>& fill,
float pRadius) const; ai_real pRadius) const;
protected: protected:
/** Normal of the sorting plane, normalized. The center is always at (0, 0, 0) */ /** Normal of the sorting plane, normalized. The center is always at (0, 0, 0) */
@ -151,10 +151,10 @@ protected:
{ {
unsigned int mIndex; ///< The vertex referred by this entry unsigned int mIndex; ///< The vertex referred by this entry
aiVector3D mPosition; ///< Position aiVector3D mPosition; ///< Position
float mDistance; ///< Distance of this vertex to the sorting plane ai_real mDistance; ///< Distance of this vertex to the sorting plane
Entry() { /** intentionally not initialized.*/ } Entry() { /** intentionally not initialized.*/ }
Entry( unsigned int pIndex, const aiVector3D& pPosition, float pDistance) Entry( unsigned int pIndex, const aiVector3D& pPosition, ai_real pDistance)
: mIndex( pIndex), mPosition( pPosition), mDistance( pDistance) : mIndex( pIndex), mPosition( pPosition), mDistance( pDistance)
{ } { }

148
code/StandardShapes.cpp
View File

@ -95,7 +95,7 @@ namespace Assimp {
void Subdivide(std::vector<aiVector3D>& positions) void Subdivide(std::vector<aiVector3D>& positions)
{ {
// assume this to be constant - (fixme: must be 1.0? I think so) // assume this to be constant - (fixme: must be 1.0? I think so)
const float fl1 = positions[0].Length(); const ai_real fl1 = positions[0].Length();
unsigned int origSize = (unsigned int)positions.size(); unsigned int origSize = (unsigned int)positions.size();
for (unsigned int i = 0 ; i < origSize ; i+=3) for (unsigned int i = 0 ; i < origSize ; i+=3)
@ -194,21 +194,21 @@ unsigned int StandardShapes::MakeIcosahedron(std::vector<aiVector3D>& positions)
{ {
positions.reserve(positions.size()+60); positions.reserve(positions.size()+60);
const float t = (1.f + 2.236067977f)/2.f; const ai_real t = (1.0 + 2.236067977)/2.0;
const float s = std::sqrt(1.f + t*t); const ai_real s = std::sqrt(1.0 + t*t);
const aiVector3D v0 = aiVector3D(t,1.f, 0.f)/s; const aiVector3D v0 = aiVector3D(t,1.0, 0.0)/s;
const aiVector3D v1 = aiVector3D(-t,1.f, 0.f)/s; const aiVector3D v1 = aiVector3D(-t,1.0, 0.0)/s;
const aiVector3D v2 = aiVector3D(t,-1.f, 0.f)/s; const aiVector3D v2 = aiVector3D(t,-1.0, 0.0)/s;
const aiVector3D v3 = aiVector3D(-t,-1.f, 0.f)/s; const aiVector3D v3 = aiVector3D(-t,-1.0, 0.0)/s;
const aiVector3D v4 = aiVector3D(1.f, 0.f, t)/s; const aiVector3D v4 = aiVector3D(1.0, 0.0, t)/s;
const aiVector3D v5 = aiVector3D(1.f, 0.f,-t)/s; const aiVector3D v5 = aiVector3D(1.0, 0.0,-t)/s;
const aiVector3D v6 = aiVector3D(-1.f, 0.f,t)/s; const aiVector3D v6 = aiVector3D(-1.0, 0.0,t)/s;
const aiVector3D v7 = aiVector3D(-1.f, 0.f,-t)/s; const aiVector3D v7 = aiVector3D(-1.0, 0.0,-t)/s;
const aiVector3D v8 = aiVector3D(0.f, t, 1.f)/s; const aiVector3D v8 = aiVector3D(0.0, t, 1.0)/s;
const aiVector3D v9 = aiVector3D(0.f,-t, 1.f)/s; const aiVector3D v9 = aiVector3D(0.0,-t, 1.0)/s;
const aiVector3D v10 = aiVector3D(0.f, t,-1.f)/s; const aiVector3D v10 = aiVector3D(0.0, t,-1.0)/s;
const aiVector3D v11 = aiVector3D(0.f,-t,-1.f)/s; const aiVector3D v11 = aiVector3D(0.0,-t,-1.0)/s;
ADD_TRIANGLE(v0,v8,v4); ADD_TRIANGLE(v0,v8,v4);
ADD_TRIANGLE(v0,v5,v10); ADD_TRIANGLE(v0,v5,v10);
@ -244,9 +244,9 @@ unsigned int StandardShapes::MakeDodecahedron(std::vector<aiVector3D>& positions
{ {
positions.reserve(positions.size()+108); positions.reserve(positions.size()+108);
const float a = 1.f / 1.7320508f; const ai_real a = 1.0 / 1.7320508;
const float b = std::sqrt((3.f-2.23606797f)/6.f); const ai_real b = std::sqrt((3.0-2.23606797f)/6.0);
const float c = std::sqrt((3.f+2.23606797f)/6.f); const ai_real c = std::sqrt((3.0+2.23606797f)/6.0);
const aiVector3D v0 = aiVector3D(a,a,a); const aiVector3D v0 = aiVector3D(a,a,a);
const aiVector3D v1 = aiVector3D(a,a,-a); const aiVector3D v1 = aiVector3D(a,a,-a);
@ -256,18 +256,18 @@ unsigned int StandardShapes::MakeDodecahedron(std::vector<aiVector3D>& positions
const aiVector3D v5 = aiVector3D(-a,a,-a); const aiVector3D v5 = aiVector3D(-a,a,-a);
const aiVector3D v6 = aiVector3D(-a,-a,a); const aiVector3D v6 = aiVector3D(-a,-a,a);
const aiVector3D v7 = aiVector3D(-a,-a,-a); const aiVector3D v7 = aiVector3D(-a,-a,-a);
const aiVector3D v8 = aiVector3D(b,c,0.f); const aiVector3D v8 = aiVector3D(b,c,0.0);
const aiVector3D v9 = aiVector3D(-b,c,0.f); const aiVector3D v9 = aiVector3D(-b,c,0.0);
const aiVector3D v10 = aiVector3D(b,-c,0.f); const aiVector3D v10 = aiVector3D(b,-c,0.0);
const aiVector3D v11 = aiVector3D(-b,-c,0.f); const aiVector3D v11 = aiVector3D(-b,-c,0.0);
const aiVector3D v12 = aiVector3D(c, 0.f, b); const aiVector3D v12 = aiVector3D(c, 0.0, b);
const aiVector3D v13 = aiVector3D(c, 0.f, -b); const aiVector3D v13 = aiVector3D(c, 0.0, -b);
const aiVector3D v14 = aiVector3D(-c, 0.f, b); const aiVector3D v14 = aiVector3D(-c, 0.0, b);
const aiVector3D v15 = aiVector3D(-c, 0.f, -b); const aiVector3D v15 = aiVector3D(-c, 0.0, -b);
const aiVector3D v16 = aiVector3D(0.f, b, c); const aiVector3D v16 = aiVector3D(0.0, b, c);
const aiVector3D v17 = aiVector3D(0.f, -b, c); const aiVector3D v17 = aiVector3D(0.0, -b, c);
const aiVector3D v18 = aiVector3D(0.f, b, -c); const aiVector3D v18 = aiVector3D(0.0, b, -c);
const aiVector3D v19 = aiVector3D(0.f, -b, -c); const aiVector3D v19 = aiVector3D(0.0, -b, -c);
ADD_PENTAGON(v0, v8, v9, v4, v16); ADD_PENTAGON(v0, v8, v9, v4, v16);
ADD_PENTAGON(v0, v12, v13, v1, v8); ADD_PENTAGON(v0, v12, v13, v1, v8);
@ -291,12 +291,12 @@ unsigned int StandardShapes::MakeOctahedron(std::vector<aiVector3D>& positions)
{ {
positions.reserve(positions.size()+24); positions.reserve(positions.size()+24);
const aiVector3D v0 = aiVector3D(1.0f, 0.f, 0.f) ; const aiVector3D v0 = aiVector3D(1.0, 0.0, 0.0) ;
const aiVector3D v1 = aiVector3D(-1.0f, 0.f, 0.f); const aiVector3D v1 = aiVector3D(-1.0, 0.0, 0.0);
const aiVector3D v2 = aiVector3D(0.f, 1.0f, 0.f); const aiVector3D v2 = aiVector3D(0.0, 1.0, 0.0);
const aiVector3D v3 = aiVector3D(0.f, -1.0f, 0.f); const aiVector3D v3 = aiVector3D(0.0, -1.0, 0.0);
const aiVector3D v4 = aiVector3D(0.f, 0.f, 1.0f); const aiVector3D v4 = aiVector3D(0.0, 0.0, 1.0);
const aiVector3D v5 = aiVector3D(0.f, 0.f, -1.0f); const aiVector3D v5 = aiVector3D(0.0, 0.0, -1.0);
ADD_TRIANGLE(v4,v0,v2); ADD_TRIANGLE(v4,v0,v2);
ADD_TRIANGLE(v4,v2,v1); ADD_TRIANGLE(v4,v2,v1);
@ -316,13 +316,13 @@ unsigned int StandardShapes::MakeTetrahedron(std::vector<aiVector3D>& positions)
{ {
positions.reserve(positions.size()+9); positions.reserve(positions.size()+9);
const float a = 1.41421f/3.f; const ai_real a = 1.41421/3.0;
const float b = 2.4494f/3.f; const ai_real b = 2.4494/3.0;
const aiVector3D v0 = aiVector3D(0.f,0.f,1.f); const aiVector3D v0 = aiVector3D(0.0,0.0,1.0);
const aiVector3D v1 = aiVector3D(2*a,0,-1.f/3.f); const aiVector3D v1 = aiVector3D(2*a,0,-1.0/3.0);
const aiVector3D v2 = aiVector3D(-a,b,-1.f/3.f); const aiVector3D v2 = aiVector3D(-a,b,-1.0/3.0);
const aiVector3D v3 = aiVector3D(-a,-b,-1.f/3.f); const aiVector3D v3 = aiVector3D(-a,-b,-1.0/3.0);
ADD_TRIANGLE(v0,v1,v2); ADD_TRIANGLE(v0,v1,v2);
ADD_TRIANGLE(v0,v2,v3); ADD_TRIANGLE(v0,v2,v3);
@ -337,16 +337,16 @@ unsigned int StandardShapes::MakeHexahedron(std::vector<aiVector3D>& positions,
bool polygons /*= false*/) bool polygons /*= false*/)
{ {
positions.reserve(positions.size()+36); positions.reserve(positions.size()+36);
const float length = 1.f/1.73205080f; const ai_real length = 1.0/1.73205080;
const aiVector3D v0 = aiVector3D(-1.f,-1.f,-1.f)*length; const aiVector3D v0 = aiVector3D(-1.0,-1.0,-1.0)*length;
const aiVector3D v1 = aiVector3D(1.f,-1.f,-1.f)*length; const aiVector3D v1 = aiVector3D(1.0,-1.0,-1.0)*length;
const aiVector3D v2 = aiVector3D(1.f,1.f,-1.f)*length; const aiVector3D v2 = aiVector3D(1.0,1.0,-1.0)*length;
const aiVector3D v3 = aiVector3D(-1.f,1.f,-1.f)*length; const aiVector3D v3 = aiVector3D(-1.0,1.0,-1.0)*length;
const aiVector3D v4 = aiVector3D(-1.f,-1.f,1.f)*length; const aiVector3D v4 = aiVector3D(-1.0,-1.0,1.0)*length;
const aiVector3D v5 = aiVector3D(1.f,-1.f,1.f)*length; const aiVector3D v5 = aiVector3D(1.0,-1.0,1.0)*length;
const aiVector3D v6 = aiVector3D(1.f,1.f,1.f)*length; const aiVector3D v6 = aiVector3D(1.0,1.0,1.0)*length;
const aiVector3D v7 = aiVector3D(-1.f,1.f,1.f)*length; const aiVector3D v7 = aiVector3D(-1.0,1.0,1.0)*length;
ADD_QUAD(v0,v3,v2,v1); ADD_QUAD(v0,v3,v2,v1);
ADD_QUAD(v0,v1,v5,v4); ADD_QUAD(v0,v1,v5,v4);
@ -382,8 +382,8 @@ void StandardShapes::MakeSphere(unsigned int tess,
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Build a cone // Build a cone
void StandardShapes::MakeCone(float height,float radius1, void StandardShapes::MakeCone(ai_real height,ai_real radius1,
float radius2,unsigned int tess, ai_real radius2,unsigned int tess,
std::vector<aiVector3D>& positions,bool bOpen /*= false */) std::vector<aiVector3D>& positions,bool bOpen /*= false */)
{ {
// Sorry, a cone with less than 3 segments makes ABSOLUTELY NO SENSE // Sorry, a cone with less than 3 segments makes ABSOLUTELY NO SENSE
@ -396,7 +396,7 @@ void StandardShapes::MakeCone(float height,float radius1,
radius1 = std::fabs(radius1); radius1 = std::fabs(radius1);
radius2 = std::fabs(radius2); radius2 = std::fabs(radius2);
float halfHeight = height / 2; ai_real halfHeight = height / 2.0;
// radius1 is always the smaller one // radius1 is always the smaller one
if (radius2 > radius1) if (radius2 > radius1)
@ -407,7 +407,7 @@ void StandardShapes::MakeCone(float height,float radius1,
else old = SIZE_MAX; else old = SIZE_MAX;
// Use a large epsilon to check whether the cone is pointy // Use a large epsilon to check whether the cone is pointy
if (radius1 < (radius2-radius1)*10e-3f)radius1 = 0.f; if (radius1 < (radius2-radius1)*10e-3)radius1 = 0.0;
// We will need 3*2 verts per segment + 3*2 verts per segment // We will need 3*2 verts per segment + 3*2 verts per segment
// if the cone is closed // if the cone is closed
@ -415,20 +415,20 @@ void StandardShapes::MakeCone(float height,float radius1,
positions.reserve(positions.size () + mem); positions.reserve(positions.size () + mem);
// Now construct all segments // Now construct all segments
const float angle_delta = (float)AI_MATH_TWO_PI / tess; const ai_real angle_delta = (ai_real)AI_MATH_TWO_PI / tess;
const float angle_max = (float)AI_MATH_TWO_PI; const ai_real angle_max = (ai_real)AI_MATH_TWO_PI;
float s = 1.f; // std::cos(angle == 0); ai_real s = 1.0; // std::cos(angle == 0);
float t = 0.f; // std::sin(angle == 0); ai_real t = 0.0; // std::sin(angle == 0);
for (float angle = 0.f; angle < angle_max; ) for (ai_real angle = 0.0; angle < angle_max; )
{ {
const aiVector3D v1 = aiVector3D (s * radius1, -halfHeight, t * radius1 ); const aiVector3D v1 = aiVector3D (s * radius1, -halfHeight, t * radius1 );
const aiVector3D v2 = aiVector3D (s * radius2, halfHeight, t * radius2 ); const aiVector3D v2 = aiVector3D (s * radius2, halfHeight, t * radius2 );
const float next = angle + angle_delta; const ai_real next = angle + angle_delta;
float s2 = std::cos(next); ai_real s2 = std::cos(next);
float t2 = std::sin(next); ai_real t2 = std::sin(next);
const aiVector3D v3 = aiVector3D (s2 * radius2, halfHeight, t2 * radius2 ); const aiVector3D v3 = aiVector3D (s2 * radius2, halfHeight, t2 * radius2 );
const aiVector3D v4 = aiVector3D (s2 * radius1, -halfHeight, t2 * radius1 ); const aiVector3D v4 = aiVector3D (s2 * radius1, -halfHeight, t2 * radius1 );
@ -445,7 +445,7 @@ void StandardShapes::MakeCone(float height,float radius1,
// generate the end 'cap' // generate the end 'cap'
positions.push_back(aiVector3D(s * radius2, halfHeight, t * radius2 )); positions.push_back(aiVector3D(s * radius2, halfHeight, t * radius2 ));
positions.push_back(aiVector3D(s2 * radius2, halfHeight, t2 * radius2 )); positions.push_back(aiVector3D(s2 * radius2, halfHeight, t2 * radius2 ));
positions.push_back(aiVector3D(0.f, halfHeight, 0.f)); positions.push_back(aiVector3D(0.0, halfHeight, 0.0));
if (radius1) if (radius1)
@ -453,7 +453,7 @@ void StandardShapes::MakeCone(float height,float radius1,
// generate the other end 'cap' // generate the other end 'cap'
positions.push_back(aiVector3D(s * radius1, -halfHeight, t * radius1 )); positions.push_back(aiVector3D(s * radius1, -halfHeight, t * radius1 ));
positions.push_back(aiVector3D(s2 * radius1, -halfHeight, t2 * radius1 )); positions.push_back(aiVector3D(s2 * radius1, -halfHeight, t2 * radius1 ));
positions.push_back(aiVector3D(0.f, -halfHeight, 0.f)); positions.push_back(aiVector3D(0.0, -halfHeight, 0.0));
} }
} }
@ -472,7 +472,7 @@ void StandardShapes::MakeCone(float height,float radius1,
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Build a circle // Build a circle
void StandardShapes::MakeCircle(float radius, unsigned int tess, void StandardShapes::MakeCircle(ai_real radius, unsigned int tess,
std::vector<aiVector3D>& positions) std::vector<aiVector3D>& positions)
{ {
// Sorry, a circle with less than 3 segments makes ABSOLUTELY NO SENSE // Sorry, a circle with less than 3 segments makes ABSOLUTELY NO SENSE
@ -484,21 +484,21 @@ void StandardShapes::MakeCircle(float radius, unsigned int tess,
// We will need 3 vertices per segment // We will need 3 vertices per segment
positions.reserve(positions.size()+tess*3); positions.reserve(positions.size()+tess*3);
const float angle_delta = (float)AI_MATH_TWO_PI / tess; const ai_real angle_delta = (ai_real)AI_MATH_TWO_PI / tess;
const float angle_max = (float)AI_MATH_TWO_PI; const ai_real angle_max = (ai_real)AI_MATH_TWO_PI;
float s = 1.f; // std::cos(angle == 0); ai_real s = 1.0; // std::cos(angle == 0);
float t = 0.f; // std::sin(angle == 0); ai_real t = 0.0; // std::sin(angle == 0);
for (float angle = 0.f; angle < angle_max; ) for (ai_real angle = 0.0; angle < angle_max; )
{ {
positions.push_back(aiVector3D(s * radius,0.f,t * radius)); positions.push_back(aiVector3D(s * radius,0.0,t * radius));
angle += angle_delta; angle += angle_delta;
s = std::cos(angle); s = std::cos(angle);
t = std::sin(angle); t = std::sin(angle);
positions.push_back(aiVector3D(s * radius,0.f,t * radius)); positions.push_back(aiVector3D(s * radius,0.0,t * radius));
positions.push_back(aiVector3D(0.f,0.f,0.f)); positions.push_back(aiVector3D(0.0,0.0,0.0));
} }
} }

6
code/StandardShapes.h
View File

@ -174,8 +174,8 @@ public:
* no 'end caps' * no 'end caps'
* @param positions Receives output triangles * @param positions Receives output triangles
*/ */
static void MakeCone(float height,float radius1, static void MakeCone(ai_real height,ai_real radius1,
float radius2,unsigned int tess, ai_real radius2,unsigned int tess,
std::vector<aiVector3D>& positions,bool bOpen= false); std::vector<aiVector3D>& positions,bool bOpen= false);
@ -189,7 +189,7 @@ public:
* @param tess Number of segments. * @param tess Number of segments.
* @param positions Receives output triangles. * @param positions Receives output triangles.
*/ */
static void MakeCircle(float radius, unsigned int tess, static void MakeCircle(ai_real radius, unsigned int tess,
std::vector<aiVector3D>& positions); std::vector<aiVector3D>& positions);
}; };

8
code/TargetAnimation.cpp
View File

@ -83,7 +83,7 @@ KeyIterator::KeyIterator(const std::vector<aiVectorKey>* _objPos,
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <class T> template <class T>
inline T Interpolate(const T& one, const T& two, float val) inline T Interpolate(const T& one, const T& two, ai_real val)
{ {
return one + (two-one)*val; return one + (two-one)*val;
} }
@ -134,7 +134,7 @@ void KeyIterator::operator ++()
const aiVectorKey& last = targetObjPos->at(nextTargetObjPos); const aiVectorKey& last = targetObjPos->at(nextTargetObjPos);
const aiVectorKey& first = targetObjPos->at(nextTargetObjPos-1); const aiVectorKey& first = targetObjPos->at(nextTargetObjPos-1);
curTargetPosition = Interpolate(first.mValue, last.mValue, (float) ( curTargetPosition = Interpolate(first.mValue, last.mValue, (ai_real) (
(curTime-first.mTime) / (last.mTime-first.mTime) )); (curTime-first.mTime) / (last.mTime-first.mTime) ));
} }
@ -155,7 +155,7 @@ void KeyIterator::operator ++()
const aiVectorKey& last = objPos->at(nextObjPos); const aiVectorKey& last = objPos->at(nextObjPos);
const aiVectorKey& first = objPos->at(nextObjPos-1); const aiVectorKey& first = objPos->at(nextObjPos-1);
curPosition = Interpolate(first.mValue, last.mValue, (float) ( curPosition = Interpolate(first.mValue, last.mValue, (ai_real) (
(curTime-first.mTime) / (last.mTime-first.mTime))); (curTime-first.mTime) / (last.mTime-first.mTime)));
} }
@ -220,7 +220,7 @@ void TargetAnimationHelper::Process(std::vector<aiVectorKey>* distanceTrack)
// diff vector // diff vector
aiVector3D diff = tposition - position; aiVector3D diff = tposition - position;
float f = diff.Length(); ai_real f = diff.Length();
// output distance vector // output distance vector
if (f) if (f)

68
code/Vertex.h
View File

@ -94,15 +94,15 @@ class Vertex
friend Vertex operator + (const Vertex&,const Vertex&); friend Vertex operator + (const Vertex&,const Vertex&);
friend Vertex operator - (const Vertex&,const Vertex&); friend Vertex operator - (const Vertex&,const Vertex&);
// friend Vertex operator + (const Vertex&,float); // friend Vertex operator + (const Vertex&,ai_real);
// friend Vertex operator - (const Vertex&,float); // friend Vertex operator - (const Vertex&,ai_real);
friend Vertex operator * (const Vertex&,float); friend Vertex operator * (const Vertex&,ai_real);
friend Vertex operator / (const Vertex&,float); friend Vertex operator / (const Vertex&,ai_real);
// friend Vertex operator + (float, const Vertex&); // friend Vertex operator + (ai_real, const Vertex&);
// friend Vertex operator - (float, const Vertex&); // friend Vertex operator - (ai_real, const Vertex&);
friend Vertex operator * (float, const Vertex&); friend Vertex operator * (ai_real, const Vertex&);
// friend Vertex operator / (float, const Vertex&); // friend Vertex operator / (ai_real, const Vertex&);
public: public:
@ -146,22 +146,22 @@ public:
/* /*
Vertex& operator += (float v) { Vertex& operator += (ai_real v) {
*this = *this+v; *this = *this+v;
return *this; return *this;
} }
Vertex& operator -= (float v) { Vertex& operator -= (ai_real v) {
*this = *this-v; *this = *this-v;
return *this; return *this;
} }
*/ */
Vertex& operator *= (float v) { Vertex& operator *= (ai_real v) {
*this = *this*v; *this = *this*v;
return *this; return *this;
} }
Vertex& operator /= (float v) { Vertex& operator /= (ai_real v) {
*this = *this/v; *this = *this/v;
return *this; return *this;
} }
@ -217,40 +217,40 @@ private:
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
/** This time binary arithmetics of v0 with a floating-point number */ /** This time binary arithmetics of v0 with a floating-point number */
template <template <typename, typename, typename> class op> static Vertex BinaryOp(const Vertex& v0, float f) { template <template <typename, typename, typename> class op> static Vertex BinaryOp(const Vertex& v0, ai_real f) {
// this is a heavy task for the compiler to optimize ... *pray* // this is a heavy task for the compiler to optimize ... *pray*
Vertex res; Vertex res;
res.position = op<aiVector3D,float,aiVector3D>()(v0.position,f); res.position = op<aiVector3D,ai_real,aiVector3D>()(v0.position,f);
res.normal = op<aiVector3D,float,aiVector3D>()(v0.normal,f); res.normal = op<aiVector3D,ai_real,aiVector3D>()(v0.normal,f);
res.tangent = op<aiVector3D,float,aiVector3D>()(v0.tangent,f); res.tangent = op<aiVector3D,ai_real,aiVector3D>()(v0.tangent,f);
res.bitangent = op<aiVector3D,float,aiVector3D>()(v0.bitangent,f); res.bitangent = op<aiVector3D,ai_real,aiVector3D>()(v0.bitangent,f);
for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) { for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
res.texcoords[i] = op<aiVector3D,float,aiVector3D>()(v0.texcoords[i],f); res.texcoords[i] = op<aiVector3D,ai_real,aiVector3D>()(v0.texcoords[i],f);
} }
for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_COLOR_SETS; ++i) { for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_COLOR_SETS; ++i) {
res.colors[i] = op<aiColor4D,float,aiColor4D>()(v0.colors[i],f); res.colors[i] = op<aiColor4D,ai_real,aiColor4D>()(v0.colors[i],f);
} }
return res; return res;
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
/** This time binary arithmetics of v0 with a floating-point number */ /** This time binary arithmetics of v0 with a floating-point number */
template <template <typename, typename, typename> class op> static Vertex BinaryOp(float f, const Vertex& v0) { template <template <typename, typename, typename> class op> static Vertex BinaryOp(ai_real f, const Vertex& v0) {
// this is a heavy task for the compiler to optimize ... *pray* // this is a heavy task for the compiler to optimize ... *pray*
Vertex res; Vertex res;
res.position = op<float,aiVector3D,aiVector3D>()(f,v0.position); res.position = op<ai_real,aiVector3D,aiVector3D>()(f,v0.position);
res.normal = op<float,aiVector3D,aiVector3D>()(f,v0.normal); res.normal = op<ai_real,aiVector3D,aiVector3D>()(f,v0.normal);
res.tangent = op<float,aiVector3D,aiVector3D>()(f,v0.tangent); res.tangent = op<ai_real,aiVector3D,aiVector3D>()(f,v0.tangent);
res.bitangent = op<float,aiVector3D,aiVector3D>()(f,v0.bitangent); res.bitangent = op<ai_real,aiVector3D,aiVector3D>()(f,v0.bitangent);
for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) { for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
res.texcoords[i] = op<float,aiVector3D,aiVector3D>()(f,v0.texcoords[i]); res.texcoords[i] = op<ai_real,aiVector3D,aiVector3D>()(f,v0.texcoords[i]);
} }
for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_COLOR_SETS; ++i) { for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_COLOR_SETS; ++i) {
res.colors[i] = op<float,aiColor4D,aiColor4D>()(f,v0.colors[i]); res.colors[i] = op<ai_real,aiColor4D,aiColor4D>()(f,v0.colors[i]);
} }
return res; return res;
} }
@ -279,41 +279,41 @@ AI_FORCE_INLINE Vertex operator - (const Vertex& v0,const Vertex& v1) {
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
/* /*
AI_FORCE_INLINE Vertex operator + (const Vertex& v0,float f) { AI_FORCE_INLINE Vertex operator + (const Vertex& v0,ai_real f) {
return Vertex::BinaryOp<Intern::plus>(v0,f); return Vertex::BinaryOp<Intern::plus>(v0,f);
} }
AI_FORCE_INLINE Vertex operator - (const Vertex& v0,float f) { AI_FORCE_INLINE Vertex operator - (const Vertex& v0,ai_real f) {
return Vertex::BinaryOp<Intern::minus>(v0,f); return Vertex::BinaryOp<Intern::minus>(v0,f);
} }
*/ */
AI_FORCE_INLINE Vertex operator * (const Vertex& v0,float f) { AI_FORCE_INLINE Vertex operator * (const Vertex& v0,ai_real f) {
return Vertex::BinaryOp<Intern::multiplies>(v0,f); return Vertex::BinaryOp<Intern::multiplies>(v0,f);
} }
AI_FORCE_INLINE Vertex operator / (const Vertex& v0,float f) { AI_FORCE_INLINE Vertex operator / (const Vertex& v0,ai_real f) {
return Vertex::BinaryOp<Intern::multiplies>(v0,1.f/f); return Vertex::BinaryOp<Intern::multiplies>(v0,1.f/f);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
/* /*
AI_FORCE_INLINE Vertex operator + (float f,const Vertex& v0) { AI_FORCE_INLINE Vertex operator + (ai_real f,const Vertex& v0) {
return Vertex::BinaryOp<Intern::plus>(f,v0); return Vertex::BinaryOp<Intern::plus>(f,v0);
} }
AI_FORCE_INLINE Vertex operator - (float f,const Vertex& v0) { AI_FORCE_INLINE Vertex operator - (ai_real f,const Vertex& v0) {
return Vertex::BinaryOp<Intern::minus>(f,v0); return Vertex::BinaryOp<Intern::minus>(f,v0);
} }
*/ */
AI_FORCE_INLINE Vertex operator * (float f,const Vertex& v0) { AI_FORCE_INLINE Vertex operator * (ai_real f,const Vertex& v0) {
return Vertex::BinaryOp<Intern::multiplies>(f,v0); return Vertex::BinaryOp<Intern::multiplies>(f,v0);
} }
/* /*
AI_FORCE_INLINE Vertex operator / (float f,const Vertex& v0) { AI_FORCE_INLINE Vertex operator / (ai_real f,const Vertex& v0) {
return Vertex::BinaryOp<Intern::divides>(f,v0); return Vertex::BinaryOp<Intern::divides>(f,v0);
} }
*/ */

4
code/XFileHelper.h
View File

@ -82,7 +82,7 @@ struct Material
std::string mName; std::string mName;
bool mIsReference; // if true, mName holds a name by which the actual material can be found in the material list bool mIsReference; // if true, mName holds a name by which the actual material can be found in the material list
aiColor4D mDiffuse; aiColor4D mDiffuse;
float mSpecularExponent; ai_real mSpecularExponent;
aiColor3D mSpecular; aiColor3D mSpecular;
aiColor3D mEmissive; aiColor3D mEmissive;
std::vector<TexEntry> mTextures; std::vector<TexEntry> mTextures;
@ -100,7 +100,7 @@ struct Material
struct BoneWeight struct BoneWeight
{ {
unsigned int mVertex; unsigned int mVertex;
float mWeight; ai_real mWeight;
}; };
/** Helper structure to represent a bone in a mesh */ /** Helper structure to represent a bone in a mesh */

7
code/XFileImporter.cpp
View File

@ -373,7 +373,7 @@ void XFileImporter::CreateMeshes( aiScene* pScene, aiNode* pNode, const std::vec
{ {
const XFile::Bone& obone = bones[c]; const XFile::Bone& obone = bones[c];
// set up a vertex-linear array of the weights for quick searching if a bone influences a vertex // set up a vertex-linear array of the weights for quick searching if a bone influences a vertex
std::vector<float> oldWeights( sourceMesh->mPositions.size(), 0.0f); std::vector<ai_real> oldWeights( sourceMesh->mPositions.size(), 0.0);
for( unsigned int d = 0; d < obone.mWeights.size(); d++) for( unsigned int d = 0; d < obone.mWeights.size(); d++)
oldWeights[obone.mWeights[d].mVertex] = obone.mWeights[d].mWeight; oldWeights[obone.mWeights[d].mVertex] = obone.mWeights[d].mWeight;
@ -383,8 +383,8 @@ void XFileImporter::CreateMeshes( aiScene* pScene, aiNode* pNode, const std::vec
for( unsigned int d = 0; d < orgPoints.size(); d++) for( unsigned int d = 0; d < orgPoints.size(); d++)
{ {
// does the new vertex stem from an old vertex which was influenced by this bone? // does the new vertex stem from an old vertex which was influenced by this bone?
float w = oldWeights[orgPoints[d]]; ai_real w = oldWeights[orgPoints[d]];
if( w > 0.0f) if( w > 0.0)
newWeights.push_back( aiVertexWeight( d, w)); newWeights.push_back( aiVertexWeight( d, w));
} }
@ -713,4 +713,3 @@ void XFileImporter::ConvertMaterials( aiScene* pScene, std::vector<XFile::Materi
} }
#endif // !! ASSIMP_BUILD_NO_X_IMPORTER #endif // !! ASSIMP_BUILD_NO_X_IMPORTER

14
code/XFileParser.cpp
View File

@ -1326,7 +1326,7 @@ unsigned int XFileParser::ReadInt()
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
float XFileParser::ReadFloat() ai_real XFileParser::ReadFloat()
{ {
if( mIsBinaryFormat) if( mIsBinaryFormat)
{ {
@ -1343,7 +1343,7 @@ float XFileParser::ReadFloat()
if( mBinaryFloatSize == 8) if( mBinaryFloatSize == 8)
{ {
if( End - P >= 8) { if( End - P >= 8) {
float result = (float) (*(double*) P); ai_real result = (ai_real) (*(double*) P);
P += 8; P += 8;
return result; return result;
} else { } else {
@ -1353,7 +1353,7 @@ float XFileParser::ReadFloat()
} else } else
{ {
if( End - P >= 4) { if( End - P >= 4) {
float result = *(float*) P; ai_real result = *(ai_real*) P;
P += 4; P += 4;
return result; return result;
} else { } else {
@ -1372,17 +1372,17 @@ float XFileParser::ReadFloat()
{ {
P += 9; P += 9;
CheckForSeparator(); CheckForSeparator();
return 0.0f; return 0.0;
} else } else
if( strncmp( P, "1.#QNAN0", 8) == 0) if( strncmp( P, "1.#QNAN0", 8) == 0)
{ {
P += 8; P += 8;
CheckForSeparator(); CheckForSeparator();
return 0.0f; return 0.0;
} }
float result = 0.0f; ai_real result = 0.0;
P = fast_atoreal_move<float>( P, result); P = fast_atoreal_move<ai_real>( P, result);
CheckForSeparator(); CheckForSeparator();

2
code/XFileParser.h
View File

@ -127,7 +127,7 @@ protected:
unsigned short ReadBinWord(); unsigned short ReadBinWord();
unsigned int ReadBinDWord(); unsigned int ReadBinDWord();
unsigned int ReadInt(); unsigned int ReadInt();
float ReadFloat(); ai_real ReadFloat();
aiVector2D ReadVector2(); aiVector2D ReadVector2();
aiVector3D ReadVector3(); aiVector3D ReadVector3();
aiColor3D ReadRGB(); aiColor3D ReadRGB();

45
code/fast_atof.h
View File

@ -19,6 +19,7 @@
#include <limits> #include <limits>
#include <stdint.h> #include <stdint.h>
#include <stdexcept> #include <stdexcept>
#include <assimp/defs.h>
#include "StringComparison.h" #include "StringComparison.h"
@ -350,51 +351,26 @@ inline const char* fast_atoreal_move(const char* c, Real& out, bool check_comma
// ------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------
// The same but more human. // The same but more human.
inline float fast_atof(const char* c) inline ai_real fast_atof(const char* c)
{ {
float ret; ai_real ret;
fast_atoreal_move<float>(c, ret); fast_atoreal_move<ai_real>(c, ret);
return ret; return ret;
} }
inline float fast_atof( const char* c, const char** cout) inline ai_real fast_atof( const char* c, const char** cout)
{ {
float ret; ai_real ret;
*cout = fast_atoreal_move<float>(c, ret); *cout = fast_atoreal_move<ai_real>(c, ret);
return ret; return ret;
} }
inline float fast_atof( const char** inout) inline ai_real fast_atof( const char** inout)
{ {
float ret; ai_real ret;
*inout = fast_atoreal_move<float>(*inout, ret); *inout = fast_atoreal_move<ai_real>(*inout, ret);
return ret;
}
inline double fast_atod(const char* c)
{
double ret;
fast_atoreal_move<double>(c, ret);
return ret;
}
inline double fast_atod( const char* c, const char** cout)
{
double ret;
*cout = fast_atoreal_move<double>(c, ret);
return ret;
}
inline double fast_atod( const char** inout)
{
double ret;
*inout = fast_atoreal_move<double>(*inout, ret);
return ret; return ret;
} }
@ -402,4 +378,3 @@ inline double fast_atod( const char** inout)
} // end of namespace Assimp } // end of namespace Assimp
#endif #endif

55
code/qnan.h
View File

@ -68,7 +68,21 @@ union _IEEESingle
uint32_t Exp : 8; uint32_t Exp : 8;
uint32_t Sign : 1; uint32_t Sign : 1;
} IEEE; } IEEE;
} ; };
// ---------------------------------------------------------------------------
/** Data structure to represent the bit pattern of a 64 Bit
* IEEE 754 floating-point number. */
union _IEEEDouble
{
double Double;
struct
{
uint64_t Frac : 52;
uint64_t Exp : 11;
uint64_t Sign : 1;
} IEEE;
};
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** Check whether a given float is qNaN. /** Check whether a given float is qNaN.
@ -87,11 +101,19 @@ AI_FORCE_INLINE bool is_qnan(float in)
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** Check whether a float is NOT qNaN. /** Check whether a given double is qNaN.
* @param in Input value */ * @param in Input value */
AI_FORCE_INLINE bool is_not_qnan(float in) AI_FORCE_INLINE bool is_qnan(double in)
{ {
return !is_qnan(in); // the straightforward solution does not work:
// return (in != in);
// compiler generates code like this
// load <in> to <register-with-different-width>
// compare <register-with-different-width> against <in>
// FIXME: Use <float> stuff instead? I think fpclassify needs C99
return (reinterpret_cast<_IEEEDouble*>(&in)->IEEE.Exp == (1u << 11)-1 &&
reinterpret_cast<_IEEEDouble*>(&in)->IEEE.Frac);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
@ -105,10 +127,29 @@ AI_FORCE_INLINE bool is_special_float(float in)
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** @brief Get a fresh qnan. */ /** @brief check whether a double is either NaN or (+/-) INF.
AI_FORCE_INLINE float get_qnan() *
* Denorms return false, they're treated like normal values.
* @param in Input value */
AI_FORCE_INLINE bool is_special_float(double in)
{ {
return std::numeric_limits<float>::quiet_NaN(); return (reinterpret_cast<_IEEEDouble*>(&in)->IEEE.Exp == (1u << 11)-1);
}
// ---------------------------------------------------------------------------
/** Check whether a float is NOT qNaN.
* @param in Input value */
template<class TReal>
AI_FORCE_INLINE bool is_not_qnan(TReal in)
{
return !is_qnan(in);
}
// ---------------------------------------------------------------------------
/** @brief Get a fresh qnan. */
AI_FORCE_INLINE ai_real get_qnan()
{
return std::numeric_limits<ai_real>::quiet_NaN();
} }
#endif // !! AI_QNAN_H_INCLUDED #endif // !! AI_QNAN_H_INCLUDED

8
include/assimp/Exporter.hpp
View File

@ -330,7 +330,7 @@ public:
// typedefs for our four configuration maps. // typedefs for our four configuration maps.
// We don't need more, so there is no need for a generic solution // We don't need more, so there is no need for a generic solution
typedef std::map<KeyType, int> IntPropertyMap; typedef std::map<KeyType, int> IntPropertyMap;
typedef std::map<KeyType, float> FloatPropertyMap; typedef std::map<KeyType, ai_real> FloatPropertyMap;
typedef std::map<KeyType, std::string> StringPropertyMap; typedef std::map<KeyType, std::string> StringPropertyMap;
typedef std::map<KeyType, aiMatrix4x4> MatrixPropertyMap; typedef std::map<KeyType, aiMatrix4x4> MatrixPropertyMap;
@ -380,7 +380,7 @@ public:
/** Set a floating-point configuration property. /** Set a floating-point configuration property.
* @see SetPropertyInteger() * @see SetPropertyInteger()
*/ */
bool SetPropertyFloat(const char* szName, float fValue); bool SetPropertyFloat(const char* szName, ai_real fValue);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Set a string configuration property. /** Set a string configuration property.
@ -425,8 +425,8 @@ public:
/** Get a floating-point configuration property /** Get a floating-point configuration property
* @see GetPropertyInteger() * @see GetPropertyInteger()
*/ */
float GetPropertyFloat(const char* szName, ai_real GetPropertyFloat(const char* szName,
float fErrorReturn = 10e10f) const; ai_real fErrorReturn = 10e10f) const;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Get a string configuration property /** Get a string configuration property

12
include/assimp/Importer.hpp
View File

@ -51,8 +51,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#endif // __cplusplus #endif // __cplusplus
// Public ASSIMP data structures // Public ASSIMP data structures
#include "types.h" #include <assimp/types.h>
#include "config.h" #include <assimp/config.h>
namespace Assimp { namespace Assimp {
// ======================================================================= // =======================================================================
@ -119,7 +119,7 @@ public:
/** /**
* @brief The upper limit for hints. * @brief The upper limit for hints.
*/ */
static const unsigned int MaxLenHint = 200; static const unsigned int MaxLenHint = 200;
public: public:
@ -224,7 +224,7 @@ public:
/** Set a floating-point configuration property. /** Set a floating-point configuration property.
* @see SetPropertyInteger() * @see SetPropertyInteger()
*/ */
bool SetPropertyFloat(const char* szName, float fValue); bool SetPropertyFloat(const char* szName, ai_real fValue);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Set a string configuration property. /** Set a string configuration property.
@ -269,8 +269,8 @@ public:
/** Get a floating-point configuration property /** Get a floating-point configuration property
* @see GetPropertyInteger() * @see GetPropertyInteger()
*/ */
float GetPropertyFloat(const char* szName, ai_real GetPropertyFloat(const char* szName,
float fErrorReturn = 10e10f) const; ai_real fErrorReturn = 10e10) const;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Get a string configuration property /** Get a string configuration property

12
include/assimp/anim.h
View File

@ -421,7 +421,7 @@ struct Interpolator
* The interpolation algorithm depends on the type of the operands. * The interpolation algorithm depends on the type of the operands.
* aiQuaternion's and aiQuatKey's SLERP, the rest does a simple * aiQuaternion's and aiQuatKey's SLERP, the rest does a simple
* linear interpolation. */ * linear interpolation. */
void operator () (T& out,const T& a, const T& b, float d) const { void operator () (T& out,const T& a, const T& b, ai_real d) const {
out = a + (b-a)*d; out = a + (b-a)*d;
} }
}; // ! Interpolator <T> }; // ! Interpolator <T>
@ -431,7 +431,7 @@ struct Interpolator
template <> template <>
struct Interpolator <aiQuaternion> { struct Interpolator <aiQuaternion> {
void operator () (aiQuaternion& out,const aiQuaternion& a, void operator () (aiQuaternion& out,const aiQuaternion& a,
const aiQuaternion& b, float d) const const aiQuaternion& b, ai_real d) const
{ {
aiQuaternion::Interpolate(out,a,b,d); aiQuaternion::Interpolate(out,a,b,d);
} }
@ -440,7 +440,7 @@ struct Interpolator <aiQuaternion> {
template <> template <>
struct Interpolator <unsigned int> { struct Interpolator <unsigned int> {
void operator () (unsigned int& out,unsigned int a, void operator () (unsigned int& out,unsigned int a,
unsigned int b, float d) const unsigned int b, ai_real d) const
{ {
out = d>0.5f ? b : a; out = d>0.5f ? b : a;
} }
@ -449,7 +449,7 @@ struct Interpolator <unsigned int> {
template <> template <>
struct Interpolator <aiVectorKey> { struct Interpolator <aiVectorKey> {
void operator () (aiVector3D& out,const aiVectorKey& a, void operator () (aiVector3D& out,const aiVectorKey& a,
const aiVectorKey& b, float d) const const aiVectorKey& b, ai_real d) const
{ {
Interpolator<aiVector3D> ipl; Interpolator<aiVector3D> ipl;
ipl(out,a.mValue,b.mValue,d); ipl(out,a.mValue,b.mValue,d);
@ -459,7 +459,7 @@ struct Interpolator <aiVectorKey> {
template <> template <>
struct Interpolator <aiQuatKey> { struct Interpolator <aiQuatKey> {
void operator () (aiQuaternion& out, const aiQuatKey& a, void operator () (aiQuaternion& out, const aiQuatKey& a,
const aiQuatKey& b, float d) const const aiQuatKey& b, ai_real d) const
{ {
Interpolator<aiQuaternion> ipl; Interpolator<aiQuaternion> ipl;
ipl(out,a.mValue,b.mValue,d); ipl(out,a.mValue,b.mValue,d);
@ -469,7 +469,7 @@ struct Interpolator <aiQuatKey> {
template <> template <>
struct Interpolator <aiMeshKey> { struct Interpolator <aiMeshKey> {
void operator () (unsigned int& out, const aiMeshKey& a, void operator () (unsigned int& out, const aiMeshKey& a,
const aiMeshKey& b, float d) const const aiMeshKey& b, ai_real d) const
{ {
Interpolator<unsigned int> ipl; Interpolator<unsigned int> ipl;
ipl(out,a.mValue,b.mValue,d); ipl(out,a.mValue,b.mValue,d);

5
include/assimp/color4.h
View File

@ -46,6 +46,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#define AI_COLOR4D_H_INC #define AI_COLOR4D_H_INC
#include "./Compiler/pushpack1.h" #include "./Compiler/pushpack1.h"
#include "defs.h"
#ifdef __cplusplus #ifdef __cplusplus
@ -90,12 +91,12 @@ public:
TReal r, g, b, a; TReal r, g, b, a;
} PACK_STRUCT; // !struct aiColor4D } PACK_STRUCT; // !struct aiColor4D
typedef aiColor4t<float> aiColor4D; typedef aiColor4t<ai_real> aiColor4D;
#else #else
struct aiColor4D { struct aiColor4D {
float r, g, b, a; ai_real r, g, b, a;
} PACK_STRUCT; } PACK_STRUCT;
#endif // __cplusplus #endif // __cplusplus

10
include/assimp/config.h → include/assimp/config.h.in
View File

@ -905,4 +905,14 @@ enum aiComponent
#define AI_CONFIG_EXPORT_XFILE_64BIT "EXPORT_XFILE_64BIT" #define AI_CONFIG_EXPORT_XFILE_64BIT "EXPORT_XFILE_64BIT"
// ---------- All the Build/Compile-time defines ------------
/** @brief Specifies if double precision is supported inside assimp
*
* Property type: Bool. Default value: undefined.
*/
#cmakedefine AI_DOUBLE_PRECISION 1
#endif // !! AI_CONFIG_H_INC #endif // !! AI_CONFIG_H_INC

20
include/assimp/defs.h
View File

@ -228,6 +228,21 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
# define ASSIMP_BUILD_DEBUG # define ASSIMP_BUILD_DEBUG
#endif #endif
//////////////////////////////////////////////////////////////////////////
/* Define AI_DOUBLE_PRECISION to compile assimp
* with double precision support (64-bit). */
//////////////////////////////////////////////////////////////////////////
#ifdef AI_DOUBLE_PRECISION
typedef double ai_real;
typedef signed long long int ai_int;
typedef unsigned long long int ai_uint;
#else // AI_DOUBLE_PRECISION
typedef float ai_real;
typedef signed int ai_int;
typedef unsigned int ai_uint;
#endif // AI_DOUBLE_PRECISION
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
/* Useful constants */ /* Useful constants */
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
@ -243,8 +258,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#define AI_MATH_HALF_PI_F (AI_MATH_PI_F * 0.5f) #define AI_MATH_HALF_PI_F (AI_MATH_PI_F * 0.5f)
/* Tiny macro to convert from radians to degrees and back */ /* Tiny macro to convert from radians to degrees and back */
#define AI_DEG_TO_RAD(x) ((x)*0.0174532925f) #define AI_DEG_TO_RAD(x) ((x)*(ai_real)0.0174532925)
#define AI_RAD_TO_DEG(x) ((x)*57.2957795f) #define AI_RAD_TO_DEG(x) ((x)*(ai_real)57.2957795)
/* Support for big-endian builds */ /* Support for big-endian builds */
#if defined(__BYTE_ORDER__) #if defined(__BYTE_ORDER__)
@ -269,5 +284,4 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#define AI_MAX_ALLOC(type) ((256U * 1024 * 1024) / sizeof(type)) #define AI_MAX_ALLOC(type) ((256U * 1024 * 1024) / sizeof(type))
#endif // !! AI_DEFINES_H_INC #endif // !! AI_DEFINES_H_INC

21
include/assimp/material.h
View File

@ -477,13 +477,14 @@ struct aiUVTransform
* rotation center is 0.5f|0.5f. The default value * rotation center is 0.5f|0.5f. The default value
* 0.f. * 0.f.
*/ */
float mRotation; ai_real mRotation;
#ifdef __cplusplus #ifdef __cplusplus
aiUVTransform() aiUVTransform()
: mScaling (1.f,1.f) : mTranslation (0.0,0.0)
, mRotation (0.f) , mScaling (1.0,1.0)
, mRotation (0.0)
{ {
// nothing to be done here ... // nothing to be done here ...
} }
@ -508,6 +509,14 @@ enum aiPropertyTypeInfo
*/ */
aiPTI_Float = 0x1, aiPTI_Float = 0x1,
/** Array of double-precision (64 Bit) floats
*
* It is possible to use aiGetMaterialInteger[Array]() (or the C++-API
* aiMaterial::Get()) to query properties stored in floating-point format.
* The material system performs the type conversion automatically.
*/
aiPTI_Double = 0x2,
/** The material property is an aiString. /** The material property is an aiString.
* *
* Arrays of strings aren't possible, aiGetMaterialString() (or the * Arrays of strings aren't possible, aiGetMaterialString() (or the
@ -817,6 +826,12 @@ public:
unsigned int type = 0, unsigned int type = 0,
unsigned int index = 0); unsigned int index = 0);
aiReturn AddProperty (const double* pInput,
unsigned int pNumValues,
const char* pKey,
unsigned int type = 0,
unsigned int index = 0);
aiReturn AddProperty (const aiUVTransform* pInput, aiReturn AddProperty (const aiUVTransform* pInput,
unsigned int pNumValues, unsigned int pNumValues,
const char* pKey, const char* pKey,

12
include/assimp/material.inl
View File

@ -201,6 +201,18 @@ inline aiReturn aiMaterial::AddProperty(const float* pInput,
pKey,type,index,aiPTI_Float); pKey,type,index,aiPTI_Float);
} }
// ---------------------------------------------------------------------------
inline aiReturn aiMaterial::AddProperty(const double* pInput,
const unsigned int pNumValues,
const char* pKey,
unsigned int type,
unsigned int index)
{
return AddBinaryProperty((const void*)pInput,
pNumValues * sizeof(float),
pKey,type,index,aiPTI_Double);
}
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
inline aiReturn aiMaterial::AddProperty(const aiUVTransform* pInput, inline aiReturn aiMaterial::AddProperty(const aiUVTransform* pInput,
const unsigned int pNumValues, const unsigned int pNumValues,

9
include/assimp/matrix3x3.h
View File

@ -47,6 +47,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#define AI_MATRIX3X3_H_INC #define AI_MATRIX3X3_H_INC
#include "./Compiler/pushpack1.h" #include "./Compiler/pushpack1.h"
#include "defs.h"
#ifdef __cplusplus #ifdef __cplusplus
@ -166,14 +167,14 @@ public:
TReal c1, c2, c3; TReal c1, c2, c3;
} PACK_STRUCT; } PACK_STRUCT;
typedef aiMatrix3x3t<float> aiMatrix3x3; typedef aiMatrix3x3t<ai_real> aiMatrix3x3;
#else #else
struct aiMatrix3x3 { struct aiMatrix3x3 {
float a1, a2, a3; ai_real a1, a2, a3;
float b1, b2, b3; ai_real b1, b2, b3;
float c1, c2, c3; ai_real c1, c2, c3;
} PACK_STRUCT; } PACK_STRUCT;
#endif // __cplusplus #endif // __cplusplus

11
include/assimp/matrix4x4.h
View File

@ -47,6 +47,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "vector3.h" #include "vector3.h"
#include "./Compiler/pushpack1.h" #include "./Compiler/pushpack1.h"
#include "defs.h"
#ifdef __cplusplus #ifdef __cplusplus
@ -229,15 +230,15 @@ public:
TReal d1, d2, d3, d4; TReal d1, d2, d3, d4;
} PACK_STRUCT; } PACK_STRUCT;
typedef aiMatrix4x4t<float> aiMatrix4x4; typedef aiMatrix4x4t<ai_real> aiMatrix4x4;
#else #else
struct aiMatrix4x4 { struct aiMatrix4x4 {
float a1, a2, a3, a4; ai_real a1, a2, a3, a4;
float b1, b2, b3, b4; ai_real b1, b2, b3, b4;
float c1, c2, c3, c4; ai_real c1, c2, c3, c4;
float d1, d2, d3, d4; ai_real d1, d2, d3, d4;
} PACK_STRUCT; } PACK_STRUCT;

11
include/assimp/metadata.h
View File

@ -68,8 +68,9 @@ typedef enum aiMetadataType
AI_INT = 1, AI_INT = 1,
AI_UINT64 = 2, AI_UINT64 = 2,
AI_FLOAT = 3, AI_FLOAT = 3,
AI_AISTRING = 4, AI_DOUBLE = 4,
AI_AIVECTOR3D = 5, AI_AISTRING = 5,
AI_AIVECTOR3D = 6,
#ifndef SWIG #ifndef SWIG
FORCE_32BIT = INT_MAX FORCE_32BIT = INT_MAX
@ -108,6 +109,7 @@ inline aiMetadataType GetAiType( bool ) { return AI_BOOL; }
inline aiMetadataType GetAiType( int ) { return AI_INT; } inline aiMetadataType GetAiType( int ) { return AI_INT; }
inline aiMetadataType GetAiType( uint64_t ) { return AI_UINT64; } inline aiMetadataType GetAiType( uint64_t ) { return AI_UINT64; }
inline aiMetadataType GetAiType( float ) { return AI_FLOAT; } inline aiMetadataType GetAiType( float ) { return AI_FLOAT; }
inline aiMetadataType GetAiType( double ) { return AI_DOUBLE; }
inline aiMetadataType GetAiType( aiString ) { return AI_AISTRING; } inline aiMetadataType GetAiType( aiString ) { return AI_AISTRING; }
inline aiMetadataType GetAiType( aiVector3D ) { return AI_AIVECTOR3D; } inline aiMetadataType GetAiType( aiVector3D ) { return AI_AIVECTOR3D; }
@ -172,6 +174,9 @@ struct aiMetadata
case AI_FLOAT: case AI_FLOAT:
delete static_cast<float*>(data); delete static_cast<float*>(data);
break; break;
case AI_DOUBLE:
delete static_cast<double*>(data);
break;
case AI_AISTRING: case AI_AISTRING:
delete static_cast<aiString*>(data); delete static_cast<aiString*>(data);
break; break;
@ -248,5 +253,3 @@ struct aiMetadata
}; };
#endif // AI_METADATA_H_INC #endif // AI_METADATA_H_INC

6
include/assimp/quaternion.h
View File

@ -47,6 +47,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifdef __cplusplus #ifdef __cplusplus
#include "defs.h"
template <typename TReal> class aiVector3t; template <typename TReal> class aiVector3t;
template <typename TReal> class aiMatrix3x3t; template <typename TReal> class aiMatrix3x3t;
@ -113,12 +115,12 @@ public:
TReal w, x, y, z; TReal w, x, y, z;
} ; } ;
typedef aiQuaterniont<float> aiQuaternion; typedef aiQuaterniont<ai_real> aiQuaternion;
#else #else
struct aiQuaternion { struct aiQuaternion {
float w, x, y, z; ai_real w, x, y, z;
}; };
#endif #endif

18
include/assimp/types.h
View File

@ -124,7 +124,7 @@ struct aiPlane
{ {
#ifdef __cplusplus #ifdef __cplusplus
aiPlane () : a(0.f), b(0.f), c(0.f), d(0.f) {} aiPlane () : a(0.f), b(0.f), c(0.f), d(0.f) {}
aiPlane (float _a, float _b, float _c, float _d) aiPlane (ai_real _a, ai_real _b, ai_real _c, ai_real _d)
: a(_a), b(_b), c(_c), d(_d) {} : a(_a), b(_b), c(_c), d(_d) {}
aiPlane (const aiPlane& o) : a(o.a), b(o.b), c(o.c), d(o.d) {} aiPlane (const aiPlane& o) : a(o.a), b(o.b), c(o.c), d(o.d) {}
@ -132,7 +132,7 @@ struct aiPlane
#endif // !__cplusplus #endif // !__cplusplus
//! Plane equation //! Plane equation
float a,b,c,d; ai_real a,b,c,d;
} PACK_STRUCT; // !struct aiPlane } PACK_STRUCT; // !struct aiPlane
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
@ -160,8 +160,8 @@ struct aiColor3D
{ {
#ifdef __cplusplus #ifdef __cplusplus
aiColor3D () : r(0.0f), g(0.0f), b(0.0f) {} aiColor3D () : r(0.0f), g(0.0f), b(0.0f) {}
aiColor3D (float _r, float _g, float _b) : r(_r), g(_g), b(_b) {} aiColor3D (ai_real _r, ai_real _g, ai_real _b) : r(_r), g(_g), b(_b) {}
explicit aiColor3D (float _r) : r(_r), g(_r), b(_r) {} explicit aiColor3D (ai_real _r) : r(_r), g(_r), b(_r) {}
aiColor3D (const aiColor3D& o) : r(o.r), g(o.g), b(o.b) {} aiColor3D (const aiColor3D& o) : r(o.r), g(o.g), b(o.b) {}
/** Component-wise comparison */ /** Component-wise comparison */
@ -200,30 +200,30 @@ struct aiColor3D
} }
/** Multiply with a scalar */ /** Multiply with a scalar */
aiColor3D operator*(float f) const { aiColor3D operator*(ai_real f) const {
return aiColor3D(r*f,g*f,b*f); return aiColor3D(r*f,g*f,b*f);
} }
/** Access a specific color component */ /** Access a specific color component */
float operator[](unsigned int i) const { ai_real operator[](unsigned int i) const {
return *(&r + i); return *(&r + i);
} }
/** Access a specific color component */ /** Access a specific color component */
float& operator[](unsigned int i) { ai_real& operator[](unsigned int i) {
return *(&r + i); return *(&r + i);
} }
/** Check whether a color is black */ /** Check whether a color is black */
bool IsBlack() const { bool IsBlack() const {
static const float epsilon = 10e-3f; static const ai_real epsilon = 10e-3;
return std::fabs( r ) < epsilon && std::fabs( g ) < epsilon && std::fabs( b ) < epsilon; return std::fabs( r ) < epsilon && std::fabs( g ) < epsilon && std::fabs( b ) < epsilon;
} }
#endif // !__cplusplus #endif // !__cplusplus
//! Red, green and blue color values //! Red, green and blue color values
float r, g, b; ai_real r, g, b;
} PACK_STRUCT; // !struct aiColor3D } PACK_STRUCT; // !struct aiColor3D
#include "./Compiler/poppack1.h" #include "./Compiler/poppack1.h"

5
include/assimp/vector2.h
View File

@ -52,6 +52,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#endif #endif
#include "./Compiler/pushpack1.h" #include "./Compiler/pushpack1.h"
#include "defs.h"
// ---------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------
/** Represents a two-dimensional vector. /** Represents a two-dimensional vector.
@ -99,12 +100,12 @@ public:
TReal x, y; TReal x, y;
} PACK_STRUCT; } PACK_STRUCT;
typedef aiVector2t<float> aiVector2D; typedef aiVector2t<ai_real> aiVector2D;
#else #else
struct aiVector2D { struct aiVector2D {
float x, y; ai_real x, y;
}; };
#endif // __cplusplus #endif // __cplusplus

5
include/assimp/vector3.h
View File

@ -52,6 +52,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#endif #endif
#include "./Compiler/pushpack1.h" #include "./Compiler/pushpack1.h"
#include "defs.h"
#ifdef __cplusplus #ifdef __cplusplus
@ -130,12 +131,12 @@ public:
} PACK_STRUCT; } PACK_STRUCT;
typedef aiVector3t<float> aiVector3D; typedef aiVector3t<ai_real> aiVector3D;
#else #else
struct aiVector3D { struct aiVector3D {
float x, y, z; ai_real x, y, z;
} PACK_STRUCT; } PACK_STRUCT;
#endif // __cplusplus #endif // __cplusplus

2
test/CMakeLists.txt
View File

@ -100,7 +100,7 @@ if(AddGTest_FOUND)
) )
add_definitions(-DASSIMP_TEST_MODELS_DIR="${CMAKE_CURRENT_LIST_DIR}/models") add_definitions(-DASSIMP_TEST_MODELS_DIR="${CMAKE_CURRENT_LIST_DIR}/models")
SET_PROPERTY( TARGET assimp PROPERTY DEBUG_POSTFIX ${CMAKE_DEBUG_POSTFIX} ) SET_PROPERTY( TARGET assimp PROPERTY DEBUG_POSTFIX ${CMAKE_DEBUG_POSTFIX} )
add_dependencies( unit gtest ) add_dependencies( unit gtest )

13
test/unit/utFastAtof.cpp
View File

@ -179,19 +179,10 @@ protected:
}; };
struct FastAtofWrapper { struct FastAtofWrapper {
float operator()(const char* str) { return Assimp::fast_atof(str); } ai_real operator()(const char* str) { return Assimp::fast_atof(str); }
};
struct FastAtodWrapper {
double operator()(const char* str) { return Assimp::fast_atod(str); }
}; };
TEST_F(FastAtofTest, FastAtof) TEST_F(FastAtofTest, FastAtof)
{ {
RunTest<float>(FastAtofWrapper()); RunTest<ai_real>(FastAtofWrapper());
}
TEST_F(FastAtofTest, FastAtod)
{
RunTest<double>(FastAtodWrapper());
} }

68
test/unit/utMatrix4x4.cpp
View File

@ -49,45 +49,45 @@ class utMatrix4x4Test : public ::testing::Test {
TEST_F( utMatrix4x4Test, badIndexOperatorTest ) { TEST_F( utMatrix4x4Test, badIndexOperatorTest ) {
aiMatrix4x4 m; aiMatrix4x4 m;
float *a0 = m[ 4 ]; ai_real *a0 = m[ 4 ];
EXPECT_EQ( NULL, a0 ); EXPECT_EQ( NULL, a0 );
} }
TEST_F( utMatrix4x4Test, indexOperatorTest ) { TEST_F( utMatrix4x4Test, indexOperatorTest ) {
aiMatrix4x4 m; aiMatrix4x4 m;
float *a0 = m[ 0 ]; ai_real *a0 = m[ 0 ];
EXPECT_FLOAT_EQ( 1.0f, *a0 ); EXPECT_FLOAT_EQ( 1.0, *a0 );
float *a1 = a0+1; ai_real *a1 = a0+1;
EXPECT_FLOAT_EQ( 0.0f, *a1 ); EXPECT_FLOAT_EQ( 0.0, *a1 );
float *a2 = a0 + 2; ai_real *a2 = a0 + 2;
EXPECT_FLOAT_EQ( 0.0f, *a2 ); EXPECT_FLOAT_EQ( 0.0, *a2 );
float *a3 = a0 + 3; ai_real *a3 = a0 + 3;
EXPECT_FLOAT_EQ( 0.0f, *a3 ); EXPECT_FLOAT_EQ( 0.0, *a3 );
float *a4 = m[ 1 ]; ai_real *a4 = m[ 1 ];
EXPECT_FLOAT_EQ( 0.0f, *a4 ); EXPECT_FLOAT_EQ( 0.0, *a4 );
float *a5 = a4 + 1; ai_real *a5 = a4 + 1;
EXPECT_FLOAT_EQ( 1.0f, *a5 ); EXPECT_FLOAT_EQ( 1.0, *a5 );
float *a6 = a4 + 2; ai_real *a6 = a4 + 2;
EXPECT_FLOAT_EQ( 0.0f, *a6 ); EXPECT_FLOAT_EQ( 0.0, *a6 );
float *a7 = a4 + 3; ai_real *a7 = a4 + 3;
EXPECT_FLOAT_EQ( 0.0f, *a7 ); EXPECT_FLOAT_EQ( 0.0, *a7 );
float *a8 = m[ 2 ]; ai_real *a8 = m[ 2 ];
EXPECT_FLOAT_EQ( 0.0f, *a8 ); EXPECT_FLOAT_EQ( 0.0, *a8 );
float *a9 = a8 + 1; ai_real *a9 = a8 + 1;
EXPECT_FLOAT_EQ( 0.0f, *a9 ); EXPECT_FLOAT_EQ( 0.0, *a9 );
float *a10 = a8 + 2; ai_real *a10 = a8 + 2;
EXPECT_FLOAT_EQ( 1.0f, *a10 ); EXPECT_FLOAT_EQ( 1.0, *a10 );
float *a11 = a8 + 3; ai_real *a11 = a8 + 3;
EXPECT_FLOAT_EQ( 0.0f, *a11 ); EXPECT_FLOAT_EQ( 0.0, *a11 );
float *a12 = m[ 3 ]; ai_real *a12 = m[ 3 ];
EXPECT_FLOAT_EQ( 0.0f, *a12 ); EXPECT_FLOAT_EQ( 0.0, *a12 );
float *a13 = a12 + 1; ai_real *a13 = a12 + 1;
EXPECT_FLOAT_EQ( 0.0f, *a13 ); EXPECT_FLOAT_EQ( 0.0, *a13 );
float *a14 = a12 + 2; ai_real *a14 = a12 + 2;
EXPECT_FLOAT_EQ( 0.0f, *a14 ); EXPECT_FLOAT_EQ( 0.0, *a14 );
float *a15 = a12 + 3; ai_real *a15 = a12 + 3;
EXPECT_FLOAT_EQ( 1.0f, *a15 ); EXPECT_FLOAT_EQ( 1.0, *a15 );
} }

31
tools/assimp_cmd/Info.cpp
View File

@ -7,8 +7,8 @@ Copyright (c) 2006-2016, assimp team
All rights reserved. All rights reserved.
Redistribution and use of this software in source and binary forms, Redistribution and use of this software in source and binary forms,
with or without modification, are permitted provided that the following with or without modification, are permitted provided that the following
conditions are met: conditions are met:
* Redistributions of source code must retain the above * Redistributions of source code must retain the above
@ -25,16 +25,16 @@ conditions are met:
derived from this software without specific prior derived from this software without specific prior
written permission of the assimp team. written permission of the assimp team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--------------------------------------------------------------------------- ---------------------------------------------------------------------------
*/ */
@ -44,7 +44,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "Main.h" #include "Main.h"
const char* AICMD_MSG_INFO_HELP_E = const char* AICMD_MSG_INFO_HELP_E =
"assimp info <file> [-r]\n" "assimp info <file> [-r]\n"
"\tPrint basic structure of a 3D model\n" "\tPrint basic structure of a 3D model\n"
"\t-r,--raw: No postprocessing, do a raw import\n"; "\t-r,--raw: No postprocessing, do a raw import\n";
@ -150,11 +150,11 @@ void FindSpecialPoints(const aiScene* scene,const aiNode* root,aiVector3D specia
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
void FindSpecialPoints(const aiScene* scene,aiVector3D special_points[3]) void FindSpecialPoints(const aiScene* scene,aiVector3D special_points[3])
{ {
special_points[0] = aiVector3D(1e10f,1e10f,1e10f); special_points[0] = aiVector3D(1e10,1e10,1e10);
special_points[1] = aiVector3D(-1e10f,-1e10f,-1e10f); special_points[1] = aiVector3D(-1e10,-1e10,-1e10);
FindSpecialPoints(scene,scene->mRootNode,special_points); FindSpecialPoints(scene,scene->mRootNode,special_points);
special_points[2] = 0.5f*(special_points[0]+special_points[1]); special_points[2] = (special_points[0]+special_points[1])*(ai_real)0.5;
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
@ -181,7 +181,7 @@ std::string FindPTypes(const aiScene* scene)
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
void PrintHierarchy(const aiNode* root, unsigned int maxnest, unsigned int maxline, void PrintHierarchy(const aiNode* root, unsigned int maxnest, unsigned int maxline,
unsigned int cline, unsigned int cnest=0) unsigned int cline, unsigned int cnest=0)
{ {
if (cline++ >= maxline || cnest >= maxnest) { if (cline++ >= maxline || cnest >= maxnest) {
@ -245,7 +245,7 @@ int Assimp_Info (const char* const* params, unsigned int num)
globalImporter->GetMemoryRequirements(mem); globalImporter->GetMemoryRequirements(mem);
static const char* format_string = static const char* format_string =
"Memory consumption: %i B\n" "Memory consumption: %i B\n"
"Nodes: %i\n" "Nodes: %i\n"
"Maximum depth %i\n" "Maximum depth %i\n"
@ -349,4 +349,3 @@ int Assimp_Info (const char* const* params, unsigned int num)
printf("\n"); printf("\n");
return 0; return 0;
} }