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

propagating precision requirments into operations

pull/947/head
Chris Russ 2016-07-15 15:38:29 +10:00
parent 5adb0e899c
commit fa1d6d8c55
36 changed files with 437 additions and 411 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

18
code/BlenderTessellator.cpp
View File

@ -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 );

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);
} }
} }

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

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;

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;

2
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 )

2
code/PretransformVertices.cpp
View File

@ -692,7 +692,7 @@ void PretransformVertices::Execute( aiScene* pScene)
aiVector3D d = max-min; aiVector3D d = max-min;
const ai_real div = std::max(d.x,std::max(d.y,d.z))*0.5; 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) {

10
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;
} }
// ------------------------------------------------------------------------------- // -------------------------------------------------------------------------------

10
code/SIBImporter.cpp
View File

@ -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));

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;

4
code/SpatialSort.cpp
View File

@ -182,7 +182,7 @@ 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.
@ -308,7 +308,7 @@ 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);
ai_real dist, maxDist; ai_real dist, maxDist;

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)

6
include/assimp/Importer.hpp
View File

@ -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

2
include/assimp/defs.h
View File

@ -267,11 +267,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifdef AI_DOUBLE_PRECISION #ifdef AI_DOUBLE_PRECISION
typedef double ai_real; typedef double ai_real;
typedef signed long long int ai_int;
/* 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.0174532925) #define AI_DEG_TO_RAD(x) ((x)*0.0174532925)
#define AI_RAD_TO_DEG(x) ((x)*57.2957795) #define AI_RAD_TO_DEG(x) ((x)*57.2957795)
#else #else
typedef float ai_real; typedef float ai_real;
typedef signed int ai_int;
/* 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)*0.0174532925f)
#define AI_RAD_TO_DEG(x) ((x)*57.2957795f) #define AI_RAD_TO_DEG(x) ((x)*57.2957795f)

14
include/assimp/material.h
View File

@ -509,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
@ -818,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,

66
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 );
} }

7
tools/assimp_cmd/Info.cpp
View File

@ -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;
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
@ -349,4 +349,3 @@ int Assimp_Info (const char* const* params, unsigned int num)
printf("\n"); printf("\n");
return 0; return 0;
} }