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

Merge branch 'master' into copyscene_fix

pull/4244/head
Kim Kulling 2021-12-13 21:19:08 +01:00 committed by GitHub
parent d619f7015a 0491eb3591
commit 003942aafe
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 77 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
code/AssetLib/X3D/X3DImporter_Geometry3D.cpp
View File

@ -879,7 +879,7 @@ void X3DImporter::readSphere(XmlNode &node) {
X3DNodeElementBase *ne(nullptr); X3DNodeElementBase *ne(nullptr);
MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use); MACRO_ATTRREAD_CHECKUSEDEF_RET(node, def, use);
XmlParser::getFloatAttribute(node, "radius", radius); XmlParser::getRealAttribute(node, "radius", radius);
XmlParser::getBoolAttribute(node, "solid", solid); XmlParser::getBoolAttribute(node, "solid", solid);
// if "USE" defined then find already defined element. // if "USE" defined then find already defined element.

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

@ -1410,7 +1410,7 @@ void glTF2Exporter::ExportMetadata() {
} }
} }
inline Ref<Accessor> GetSamplerInputRef(Asset &asset, std::string &animId, Ref<Buffer> &buffer, std::vector<float> &times) { inline Ref<Accessor> GetSamplerInputRef(Asset &asset, std::string &animId, Ref<Buffer> &buffer, std::vector<ai_real> &times) {
return ExportData(asset, animId, buffer, (unsigned int)times.size(), &times[0], AttribType::SCALAR, AttribType::SCALAR, ComponentType_FLOAT); return ExportData(asset, animId, buffer, (unsigned int)times.size(), &times[0], AttribType::SCALAR, AttribType::SCALAR, ComponentType_FLOAT);
} }

3
code/AssetLib/glTF2/glTF2Exporter.h
View File

@ -66,7 +66,9 @@ class Ref;
} }
namespace glTF2 { namespace glTF2 {
class Asset; class Asset;
struct TexProperty; struct TexProperty;
struct TextureInfo; struct TextureInfo;
struct NormalTextureInfo; struct NormalTextureInfo;
@ -84,6 +86,7 @@ struct MaterialIOR;
typedef float(vec2)[2]; typedef float(vec2)[2];
typedef float(vec3)[3]; typedef float(vec3)[3];
typedef float(vec4)[4]; typedef float(vec4)[4];
} // namespace glTF2 } // namespace glTF2
namespace Assimp { namespace Assimp {

3
include/assimp/SkeletonMeshBuilder.h
View File

@ -6,7 +6,6 @@ Open Asset Import Library (assimp)
Copyright (c) 2006-2021, assimp team Copyright (c) 2006-2021, assimp team
All rights reserved. All rights reserved.
Redistribution and use of this software in source and binary forms, Redistribution and use of this software in source and binary forms,
@ -102,7 +101,7 @@ protected:
/** Creates a dummy material and returns it. */ /** Creates a dummy material and returns it. */
aiMaterial *CreateMaterial(); aiMaterial *CreateMaterial();
protected: private:
/** space to assemble the mesh data: points */ /** space to assemble the mesh data: points */
std::vector<aiVector3D> mVertices; std::vector<aiVector3D> mVertices;

2
include/assimp/color4.h
View File

@ -5,8 +5,6 @@ Open Asset Import Library (assimp)
Copyright (c) 2006-2021, assimp team Copyright (c) 2006-2021, assimp team
All rights reserved. All rights reserved.
Redistribution and use of this software in source and binary forms, Redistribution and use of this software in source and binary forms,

1
include/assimp/light.h
View File

@ -255,5 +255,4 @@ struct aiLight {
} }
#endif #endif
#endif // !! AI_LIGHT_H_INC #endif // !! AI_LIGHT_H_INC

90
include/assimp/material.inl
View File

@ -44,21 +44,17 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#pragma once #pragma once
#ifndef AI_MATERIAL_INL_INC
#define AI_MATERIAL_INL_INC
#ifdef __GNUC__ #ifdef __GNUC__
# pragma GCC system_header # pragma GCC system_header
#endif #endif
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
AI_FORCE_INLINE AI_FORCE_INLINE aiPropertyTypeInfo ai_real_to_property_type_info(float) {
aiPropertyTypeInfo ai_real_to_property_type_info(float) {
return aiPTI_Float; return aiPTI_Float;
} }
AI_FORCE_INLINE AI_FORCE_INLINE aiPropertyTypeInfo ai_real_to_property_type_info(double) {
aiPropertyTypeInfo ai_real_to_property_type_info(double) {
return aiPTI_Double; return aiPTI_Double;
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
@ -66,8 +62,7 @@ aiPropertyTypeInfo ai_real_to_property_type_info(double) {
//! @cond never //! @cond never
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
AI_FORCE_INLINE AI_FORCE_INLINE aiReturn aiMaterial::GetTexture( aiTextureType type,
aiReturn aiMaterial::GetTexture( aiTextureType type,
unsigned int index, unsigned int index,
C_STRUCT aiString* path, C_STRUCT aiString* path,
aiTextureMapping* mapping /*= NULL*/, aiTextureMapping* mapping /*= NULL*/,
@ -79,15 +74,13 @@ aiReturn aiMaterial::GetTexture( aiTextureType type,
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
AI_FORCE_INLINE AI_FORCE_INLINE unsigned int aiMaterial::GetTextureCount(aiTextureType type) const {
unsigned int aiMaterial::GetTextureCount(aiTextureType type) const {
return ::aiGetMaterialTextureCount(this,type); return ::aiGetMaterialTextureCount(this,type);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template <typename Type> template <typename Type>
AI_FORCE_INLINE AI_FORCE_INLINE aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
unsigned int idx, Type* pOut, unsigned int idx, Type* pOut,
unsigned int* pMax) const { unsigned int* pMax) const {
unsigned int iNum = pMax ? *pMax : 1; unsigned int iNum = pMax ? *pMax : 1;
@ -105,7 +98,7 @@ aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
return AI_FAILURE; return AI_FAILURE;
} }
iNum = std::min((size_t)iNum,prop->mDataLength / sizeof(Type)); iNum = static_cast<unsigned int>(std::min(static_cast<size_t>(iNum),prop->mDataLength / sizeof(Type)));
::memcpy(pOut,prop->mData,iNum * sizeof(Type)); ::memcpy(pOut,prop->mData,iNum * sizeof(Type));
if (pMax) { if (pMax) {
*pMax = iNum; *pMax = iNum;
@ -116,8 +109,7 @@ aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template <typename Type> template <typename Type>
AI_FORCE_INLINE AI_FORCE_INLINE aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
unsigned int idx,Type& pOut) const { unsigned int idx,Type& pOut) const {
const aiMaterialProperty* prop; const aiMaterialProperty* prop;
const aiReturn ret = ::aiGetMaterialProperty(this,pKey,type,idx, const aiReturn ret = ::aiGetMaterialProperty(this,pKey,type,idx,
@ -138,34 +130,29 @@ aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
AI_FORCE_INLINE AI_FORCE_INLINE aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
unsigned int idx,ai_real* pOut, unsigned int idx,ai_real* pOut,
unsigned int* pMax) const { unsigned int* pMax) const {
return ::aiGetMaterialFloatArray(this,pKey,type,idx,pOut,pMax); return ::aiGetMaterialFloatArray(this,pKey,type,idx,pOut,pMax);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
AI_FORCE_INLINE AI_FORCE_INLINE aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
unsigned int idx,int* pOut, unsigned int idx,int* pOut,
unsigned int* pMax) const { unsigned int* pMax) const {
return ::aiGetMaterialIntegerArray(this,pKey,type,idx,pOut,pMax); return ::aiGetMaterialIntegerArray(this,pKey,type,idx,pOut,pMax);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
AI_FORCE_INLINE AI_FORCE_INLINE aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
unsigned int idx,ai_real& pOut) const { unsigned int idx,ai_real& pOut) const {
return aiGetMaterialFloat(this,pKey,type,idx,&pOut); return aiGetMaterialFloat(this,pKey,type,idx,&pOut);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
AI_FORCE_INLINE AI_FORCE_INLINE aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
unsigned int idx,int& pOut) const { unsigned int idx,int& pOut) const {
return aiGetMaterialInteger(this,pKey,type,idx,&pOut); return aiGetMaterialInteger(this,pKey,type,idx,&pOut);
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
AI_FORCE_INLINE AI_FORCE_INLINE aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
unsigned int idx,aiColor4D& pOut) const { unsigned int idx,aiColor4D& pOut) const {
return aiGetMaterialColor(this,pKey,type,idx,&pOut); return aiGetMaterialColor(this,pKey,type,idx,&pOut);
} }
@ -190,14 +177,10 @@ AI_FORCE_INLINE aiReturn aiMaterial::Get(const char* pKey,unsigned int type,
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<class TYPE> template<class TYPE>
aiReturn aiMaterial::AddProperty (const TYPE* pInput, aiReturn aiMaterial::AddProperty (const TYPE* pInput,
const unsigned int pNumValues, const unsigned int pNumValues, const char* pKey, unsigned int type,
const char* pKey, unsigned int index) {
unsigned int type, return AddBinaryProperty((const void*)pInput, pNumValues * sizeof(TYPE),
unsigned int index)
{
return AddBinaryProperty((const void*)pInput,
pNumValues * sizeof(TYPE),
pKey,type,index,aiPTI_Buffer); pKey,type,index,aiPTI_Buffer);
} }
@ -213,8 +196,7 @@ AI_FORCE_INLINE aiReturn aiMaterial::AddProperty(const float* pInput,
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
AI_FORCE_INLINE AI_FORCE_INLINE aiReturn aiMaterial::AddProperty(const double* pInput,
aiReturn aiMaterial::AddProperty(const double* pInput,
const unsigned int pNumValues, const unsigned int pNumValues,
const char* pKey, const char* pKey,
unsigned int type, unsigned int type,
@ -225,8 +207,7 @@ aiReturn aiMaterial::AddProperty(const double* pInput,
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
AI_FORCE_INLINE AI_FORCE_INLINE aiReturn aiMaterial::AddProperty(const aiUVTransform* pInput,
aiReturn aiMaterial::AddProperty(const aiUVTransform* pInput,
const unsigned int pNumValues, const unsigned int pNumValues,
const char* pKey, const char* pKey,
unsigned int type, unsigned int type,
@ -237,8 +218,7 @@ aiReturn aiMaterial::AddProperty(const aiUVTransform* pInput,
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
AI_FORCE_INLINE AI_FORCE_INLINE aiReturn aiMaterial::AddProperty(const aiColor4D* pInput,
aiReturn aiMaterial::AddProperty(const aiColor4D* pInput,
const unsigned int pNumValues, const unsigned int pNumValues,
const char* pKey, const char* pKey,
unsigned int type, unsigned int type,
@ -249,8 +229,7 @@ aiReturn aiMaterial::AddProperty(const aiColor4D* pInput,
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
AI_FORCE_INLINE AI_FORCE_INLINE aiReturn aiMaterial::AddProperty(const aiColor3D* pInput,
aiReturn aiMaterial::AddProperty(const aiColor3D* pInput,
const unsigned int pNumValues, const unsigned int pNumValues,
const char* pKey, const char* pKey,
unsigned int type, unsigned int type,
@ -261,8 +240,7 @@ aiReturn aiMaterial::AddProperty(const aiColor3D* pInput,
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
AI_FORCE_INLINE AI_FORCE_INLINE aiReturn aiMaterial::AddProperty(const aiVector3D* pInput,
aiReturn aiMaterial::AddProperty(const aiVector3D* pInput,
const unsigned int pNumValues, const unsigned int pNumValues,
const char* pKey, const char* pKey,
unsigned int type, unsigned int type,
@ -273,8 +251,7 @@ aiReturn aiMaterial::AddProperty(const aiVector3D* pInput,
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
AI_FORCE_INLINE AI_FORCE_INLINE aiReturn aiMaterial::AddProperty(const int* pInput,
aiReturn aiMaterial::AddProperty(const int* pInput,
const unsigned int pNumValues, const unsigned int pNumValues,
const char* pKey, const char* pKey,
unsigned int type, unsigned int type,
@ -293,8 +270,7 @@ aiReturn aiMaterial::AddProperty(const int* pInput,
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<> template<>
AI_FORCE_INLINE AI_FORCE_INLINE aiReturn aiMaterial::AddProperty<float>(const float* pInput,
aiReturn aiMaterial::AddProperty<float>(const float* pInput,
const unsigned int pNumValues, const unsigned int pNumValues,
const char* pKey, const char* pKey,
unsigned int type, unsigned int type,
@ -306,8 +282,7 @@ aiReturn aiMaterial::AddProperty<float>(const float* pInput,
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<> template<>
AI_FORCE_INLINE AI_FORCE_INLINE aiReturn aiMaterial::AddProperty<double>(const double* pInput,
aiReturn aiMaterial::AddProperty<double>(const double* pInput,
const unsigned int pNumValues, const unsigned int pNumValues,
const char* pKey, const char* pKey,
unsigned int type, unsigned int type,
@ -319,8 +294,7 @@ aiReturn aiMaterial::AddProperty<double>(const double* pInput,
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<> template<>
AI_FORCE_INLINE AI_FORCE_INLINE aiReturn aiMaterial::AddProperty<aiUVTransform>(const aiUVTransform* pInput,
aiReturn aiMaterial::AddProperty<aiUVTransform>(const aiUVTransform* pInput,
const unsigned int pNumValues, const unsigned int pNumValues,
const char* pKey, const char* pKey,
unsigned int type, unsigned int type,
@ -332,8 +306,7 @@ aiReturn aiMaterial::AddProperty<aiUVTransform>(const aiUVTransform* pInput,
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<> template<>
AI_FORCE_INLINE AI_FORCE_INLINE aiReturn aiMaterial::AddProperty<aiColor4D>(const aiColor4D* pInput,
aiReturn aiMaterial::AddProperty<aiColor4D>(const aiColor4D* pInput,
const unsigned int pNumValues, const unsigned int pNumValues,
const char* pKey, const char* pKey,
unsigned int type, unsigned int type,
@ -345,8 +318,7 @@ aiReturn aiMaterial::AddProperty<aiColor4D>(const aiColor4D* pInput,
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<> template<>
AI_FORCE_INLINE AI_FORCE_INLINE aiReturn aiMaterial::AddProperty<aiColor3D>(const aiColor3D* pInput,
aiReturn aiMaterial::AddProperty<aiColor3D>(const aiColor3D* pInput,
const unsigned int pNumValues, const unsigned int pNumValues,
const char* pKey, const char* pKey,
unsigned int type, unsigned int type,
@ -358,8 +330,7 @@ aiReturn aiMaterial::AddProperty<aiColor3D>(const aiColor3D* pInput,
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<> template<>
AI_FORCE_INLINE AI_FORCE_INLINE aiReturn aiMaterial::AddProperty<aiVector3D>(const aiVector3D* pInput,
aiReturn aiMaterial::AddProperty<aiVector3D>(const aiVector3D* pInput,
const unsigned int pNumValues, const unsigned int pNumValues,
const char* pKey, const char* pKey,
unsigned int type, unsigned int type,
@ -371,8 +342,7 @@ aiReturn aiMaterial::AddProperty<aiVector3D>(const aiVector3D* pInput,
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<> template<>
AI_FORCE_INLINE AI_FORCE_INLINE aiReturn aiMaterial::AddProperty<int>(const int* pInput,
aiReturn aiMaterial::AddProperty<int>(const int* pInput,
const unsigned int pNumValues, const unsigned int pNumValues,
const char* pKey, const char* pKey,
unsigned int type, unsigned int type,
@ -383,5 +353,3 @@ aiReturn aiMaterial::AddProperty<int>(const int* pInput,
} }
//! @endcond //! @endcond
#endif //! AI_MATERIAL_INL_INC

19
include/assimp/texture.h
View File

@ -92,22 +92,19 @@ struct aiTexel {
#ifdef __cplusplus #ifdef __cplusplus
//! Comparison operator //! Comparison operator
bool operator== (const aiTexel& other) const bool operator== (const aiTexel& other) const {
{
return b == other.b && r == other.r && return b == other.b && r == other.r &&
g == other.g && a == other.a; g == other.g && a == other.a;
} }
//! Inverse comparison operator //! Inverse comparison operator
bool operator!= (const aiTexel& other) const bool operator!= (const aiTexel& other) const {
{
return b != other.b || r != other.r || return b != other.b || r != other.r ||
g != other.g || a != other.a; g != other.g || a != other.a;
} }
//! Conversion to a floating-point 4d color //! Conversion to a floating-point 4d color
operator aiColor4D() const operator aiColor4D() const {
{
return aiColor4D(r/255.f,g/255.f,b/255.f,a/255.f); return aiColor4D(r/255.f,g/255.f,b/255.f,a/255.f);
} }
#endif // __cplusplus #endif // __cplusplus
@ -202,11 +199,11 @@ struct aiTexture {
} }
// Construction // Construction
aiTexture() AI_NO_EXCEPT aiTexture() AI_NO_EXCEPT :
: mWidth(0) mWidth(0),
, mHeight(0) mHeight(0),
, pcData(nullptr) pcData(nullptr),
, mFilename() { mFilename() {
memset(achFormatHint, 0, sizeof(achFormatHint)); memset(achFormatHint, 0, sizeof(achFormatHint));
} }

2
include/assimp/vector2.h
View File

@ -5,8 +5,6 @@ Open Asset Import Library (assimp)
Copyright (c) 2006-2021, assimp team Copyright (c) 2006-2021, assimp team
All rights reserved. All rights reserved.
Redistribution and use of this software in source and binary forms, Redistribution and use of this software in source and binary forms,

92
include/assimp/vector3.inl
View File

@ -54,8 +54,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
/** Transformation of a vector by a 3x3 matrix */ /** Transformation of a vector by a 3x3 matrix */
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE AI_FORCE_INLINE aiVector3t<TReal> operator * (const aiMatrix3x3t<TReal>& pMatrix, const aiVector3t<TReal>& pVector) {
aiVector3t<TReal> operator * (const aiMatrix3x3t<TReal>& pMatrix, const aiVector3t<TReal>& pVector) {
aiVector3t<TReal> res; aiVector3t<TReal> res;
res.x = pMatrix.a1 * pVector.x + pMatrix.a2 * pVector.y + pMatrix.a3 * pVector.z; res.x = pMatrix.a1 * pVector.x + pMatrix.a2 * pVector.y + pMatrix.a3 * pVector.z;
res.y = pMatrix.b1 * pVector.x + pMatrix.b2 * pVector.y + pMatrix.b3 * pVector.z; res.y = pMatrix.b1 * pVector.x + pMatrix.b2 * pVector.y + pMatrix.b3 * pVector.z;
@ -66,8 +65,7 @@ aiVector3t<TReal> operator * (const aiMatrix3x3t<TReal>& pMatrix, const aiVector
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
/** Transformation of a vector by a 4x4 matrix */ /** Transformation of a vector by a 4x4 matrix */
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE AI_FORCE_INLINE aiVector3t<TReal> operator * (const aiMatrix4x4t<TReal>& pMatrix, const aiVector3t<TReal>& pVector) {
aiVector3t<TReal> operator * (const aiMatrix4x4t<TReal>& pMatrix, const aiVector3t<TReal>& pVector) {
aiVector3t<TReal> res; aiVector3t<TReal> res;
res.x = pMatrix.a1 * pVector.x + pMatrix.a2 * pVector.y + pMatrix.a3 * pVector.z + pMatrix.a4; res.x = pMatrix.a1 * pVector.x + pMatrix.a2 * pVector.y + pMatrix.a3 * pVector.z + pMatrix.a4;
res.y = pMatrix.b1 * pVector.x + pMatrix.b2 * pVector.y + pMatrix.b3 * pVector.z + pMatrix.b4; res.y = pMatrix.b1 * pVector.x + pMatrix.b2 * pVector.y + pMatrix.b3 * pVector.z + pMatrix.b4;
@ -82,36 +80,35 @@ aiVector3t<TReal>::operator aiVector3t<TOther> () const {
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE AI_FORCE_INLINE void aiVector3t<TReal>::Set( TReal pX, TReal pY, TReal pZ) {
void aiVector3t<TReal>::Set( TReal pX, TReal pY, TReal pZ) {
x = pX; x = pX;
y = pY; y = pY;
z = pZ; z = pZ;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE AI_FORCE_INLINE TReal aiVector3t<TReal>::SquareLength() const {
TReal aiVector3t<TReal>::SquareLength() const {
return x*x + y*y + z*z; return x*x + y*y + z*z;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE AI_FORCE_INLINE TReal aiVector3t<TReal>::Length() const {
TReal aiVector3t<TReal>::Length() const {
return std::sqrt( SquareLength()); return std::sqrt( SquareLength());
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE aiVector3t<TReal>& aiVector3t<TReal>::Normalize() {
aiVector3t<TReal>& aiVector3t<TReal>::Normalize() { const TReal l = Length();
if (l == 0) {
return *this;
}
*this /= Length(); *this /= Length();
return *this; return *this;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE AI_FORCE_INLINE aiVector3t<TReal>& aiVector3t<TReal>::NormalizeSafe() {
aiVector3t<TReal>& aiVector3t<TReal>::NormalizeSafe() {
TReal len = Length(); TReal len = Length();
if ( len > static_cast< TReal >( 0 ) ) { if ( len > static_cast< TReal >( 0 ) ) {
*this /= len; *this /= len;
@ -120,8 +117,7 @@ aiVector3t<TReal>& aiVector3t<TReal>::NormalizeSafe() {
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE AI_FORCE_INLINE const aiVector3t<TReal>& aiVector3t<TReal>::operator += (const aiVector3t<TReal>& o) {
const aiVector3t<TReal>& aiVector3t<TReal>::operator += (const aiVector3t<TReal>& o) {
x += o.x; x += o.x;
y += o.y; y += o.y;
z += o.z; z += o.z;
@ -130,8 +126,7 @@ const aiVector3t<TReal>& aiVector3t<TReal>::operator += (const aiVector3t<TReal>
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE AI_FORCE_INLINE const aiVector3t<TReal>& aiVector3t<TReal>::operator -= (const aiVector3t<TReal>& o) {
const aiVector3t<TReal>& aiVector3t<TReal>::operator -= (const aiVector3t<TReal>& o) {
x -= o.x; x -= o.x;
y -= o.y; y -= o.y;
z -= o.z; z -= o.z;
@ -140,8 +135,7 @@ const aiVector3t<TReal>& aiVector3t<TReal>::operator -= (const aiVector3t<TReal>
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE AI_FORCE_INLINE const aiVector3t<TReal>& aiVector3t<TReal>::operator *= (TReal f) {
const aiVector3t<TReal>& aiVector3t<TReal>::operator *= (TReal f) {
x *= f; x *= f;
y *= f; y *= f;
z *= f; z *= f;
@ -150,8 +144,7 @@ const aiVector3t<TReal>& aiVector3t<TReal>::operator *= (TReal f) {
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE AI_FORCE_INLINE const aiVector3t<TReal>& aiVector3t<TReal>::operator /= (TReal f) {
const aiVector3t<TReal>& aiVector3t<TReal>::operator /= (TReal f) {
if ( f == static_cast<TReal>(0.0)) { if ( f == static_cast<TReal>(0.0)) {
return *this; return *this;
} }
@ -164,20 +157,17 @@ const aiVector3t<TReal>& aiVector3t<TReal>::operator /= (TReal f) {
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE AI_FORCE_INLINE aiVector3t<TReal>& aiVector3t<TReal>::operator *= (const aiMatrix3x3t<TReal>& mat){
aiVector3t<TReal>& aiVector3t<TReal>::operator *= (const aiMatrix3x3t<TReal>& mat){
return (*this = mat * (*this)); return (*this = mat * (*this));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE AI_FORCE_INLINE aiVector3t<TReal>& aiVector3t<TReal>::operator *= (const aiMatrix4x4t<TReal>& mat){
aiVector3t<TReal>& aiVector3t<TReal>::operator *= (const aiMatrix4x4t<TReal>& mat){
return (*this = mat * (*this)); return (*this = mat * (*this));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE AI_FORCE_INLINE TReal aiVector3t<TReal>::operator[](unsigned int i) const {
TReal aiVector3t<TReal>::operator[](unsigned int i) const {
switch (i) { switch (i) {
case 0: case 0:
return x; return x;
@ -192,9 +182,7 @@ TReal aiVector3t<TReal>::operator[](unsigned int i) const {
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE AI_FORCE_INLINE TReal& aiVector3t<TReal>::operator[](unsigned int i) {
TReal& aiVector3t<TReal>::operator[](unsigned int i) {
// return *(&x + i);
switch (i) { switch (i) {
case 0: case 0:
return x; return x;
@ -209,20 +197,17 @@ TReal& aiVector3t<TReal>::operator[](unsigned int i) {
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE AI_FORCE_INLINE bool aiVector3t<TReal>::operator== (const aiVector3t<TReal>& other) const {
bool aiVector3t<TReal>::operator== (const aiVector3t<TReal>& other) const {
return x == other.x && y == other.y && z == other.z; return x == other.x && y == other.y && z == other.z;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE AI_FORCE_INLINE bool aiVector3t<TReal>::operator!= (const aiVector3t<TReal>& other) const {
bool aiVector3t<TReal>::operator!= (const aiVector3t<TReal>& other) const {
return x != other.x || y != other.y || z != other.z; return x != other.x || y != other.y || z != other.z;
} }
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
template<typename TReal> template<typename TReal>
AI_FORCE_INLINE AI_FORCE_INLINE bool aiVector3t<TReal>::Equal(const aiVector3t<TReal>& other, TReal epsilon) const {
bool aiVector3t<TReal>::Equal(const aiVector3t<TReal>& other, TReal epsilon) const {
return return
std::abs(x - other.x) <= epsilon && std::abs(x - other.x) <= epsilon &&
std::abs(y - other.y) <= epsilon && std::abs(y - other.y) <= epsilon &&
@ -230,77 +215,66 @@ bool aiVector3t<TReal>::Equal(const aiVector3t<TReal>& other, TReal epsilon) con
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE AI_FORCE_INLINE bool aiVector3t<TReal>::operator < (const aiVector3t<TReal>& other) const {
bool aiVector3t<TReal>::operator < (const aiVector3t<TReal>& other) const {
return x != other.x ? x < other.x : y != other.y ? y < other.y : z < other.z; return x != other.x ? x < other.x : y != other.y ? y < other.y : z < other.z;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE AI_FORCE_INLINE const aiVector3t<TReal> aiVector3t<TReal>::SymMul(const aiVector3t<TReal>& o) {
const aiVector3t<TReal> aiVector3t<TReal>::SymMul(const aiVector3t<TReal>& o) {
return aiVector3t<TReal>(x*o.x,y*o.y,z*o.z); return aiVector3t<TReal>(x*o.x,y*o.y,z*o.z);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// symmetric addition // symmetric addition
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE AI_FORCE_INLINE aiVector3t<TReal> operator + (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
aiVector3t<TReal> operator + (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
return aiVector3t<TReal>( v1.x + v2.x, v1.y + v2.y, v1.z + v2.z); return aiVector3t<TReal>( v1.x + v2.x, v1.y + v2.y, v1.z + v2.z);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// symmetric subtraction // symmetric subtraction
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE AI_FORCE_INLINE aiVector3t<TReal> operator - (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
aiVector3t<TReal> operator - (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
return aiVector3t<TReal>( v1.x - v2.x, v1.y - v2.y, v1.z - v2.z); return aiVector3t<TReal>( v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// scalar product // scalar product
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE AI_FORCE_INLINE TReal operator * (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
TReal operator * (const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
return v1.x*v2.x + v1.y*v2.y + v1.z*v2.z; return v1.x*v2.x + v1.y*v2.y + v1.z*v2.z;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// scalar multiplication // scalar multiplication
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE AI_FORCE_INLINE aiVector3t<TReal> operator * ( TReal f, const aiVector3t<TReal>& v) {
aiVector3t<TReal> operator * ( TReal f, const aiVector3t<TReal>& v) {
return aiVector3t<TReal>( f*v.x, f*v.y, f*v.z); return aiVector3t<TReal>( f*v.x, f*v.y, f*v.z);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// and the other way around // and the other way around
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE AI_FORCE_INLINE aiVector3t<TReal> operator * ( const aiVector3t<TReal>& v, TReal f) {
aiVector3t<TReal> operator * ( const aiVector3t<TReal>& v, TReal f) {
return aiVector3t<TReal>( f*v.x, f*v.y, f*v.z); return aiVector3t<TReal>( f*v.x, f*v.y, f*v.z);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// scalar division // scalar division
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE AI_FORCE_INLINE aiVector3t<TReal> operator / ( const aiVector3t<TReal>& v, TReal f) {
aiVector3t<TReal> operator / ( const aiVector3t<TReal>& v, TReal f) {
return v * (1/f); return v * (1/f);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// vector division // vector division
template <typename TReal> template <typename TReal>
AI_FORCE_INLINE AI_FORCE_INLINE aiVector3t<TReal> operator / ( const aiVector3t<TReal>& v, const aiVector3t<TReal>& v2) {
aiVector3t<TReal> operator / ( const aiVector3t<TReal>& v, const aiVector3t<TReal>& v2) {
return aiVector3t<TReal>(v.x / v2.x,v.y / v2.y,v.z / v2.z); return aiVector3t<TReal>(v.x / v2.x,v.y / v2.y,v.z / v2.z);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// cross product // cross product
template<typename TReal> template<typename TReal>
AI_FORCE_INLINE AI_FORCE_INLINE aiVector3t<TReal> operator ^ ( const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
aiVector3t<TReal> operator ^ ( const aiVector3t<TReal>& v1, const aiVector3t<TReal>& v2) {
return aiVector3t<TReal>( v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x); return aiVector3t<TReal>( v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// vector negation // vector negation
template<typename TReal> template<typename TReal>
AI_FORCE_INLINE AI_FORCE_INLINE aiVector3t<TReal> operator - ( const aiVector3t<TReal>& v) {
aiVector3t<TReal> operator - ( const aiVector3t<TReal>& v) {
return aiVector3t<TReal>( -v.x, -v.y, -v.z); return aiVector3t<TReal>( -v.x, -v.y, -v.z);
} }

2
test/unit/utMaterialSystem.cpp
View File

@ -73,7 +73,7 @@ TEST_F(MaterialSystemTest, testFloatArrayProperty) {
pf[0] = pf[1] = pf[2] = pf[3] = 12.0f; pf[0] = pf[1] = pf[2] = pf[3] = 12.0f;
EXPECT_EQ(AI_SUCCESS, pcMat->Get("testKey2", 0, 0, pf, &pMax)); EXPECT_EQ(AI_SUCCESS, pcMat->Get("testKey2", 0, 0, pf, &pMax));
EXPECT_EQ(sizeof(pf) / sizeof(float), pMax); EXPECT_EQ(sizeof(pf) / sizeof(float), static_cast<size_t>(pMax));
EXPECT_TRUE(!pf[0] && 1.0f == pf[1] && 2.0f == pf[2] && 3.0f == pf[3]); EXPECT_TRUE(!pf[0] && 1.0f == pf[1] && 2.0f == pf[2] && 3.0f == pf[3]);
} }