|
|
@@ -39,19 +39,17 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
|
|
----------------------------------------------------------------------
|
|
|
*/
|
|
|
-#ifndef ASSIMP_BUILD_NO_GLOBALSCALE_PROCESS
|
|
|
-
|
|
|
#include "ScaleProcess.h"
|
|
|
|
|
|
#include <assimp/scene.h>
|
|
|
#include <assimp/postprocess.h>
|
|
|
|
|
|
+
|
|
|
namespace Assimp {
|
|
|
|
|
|
ScaleProcess::ScaleProcess()
|
|
|
: BaseProcess()
|
|
|
, mScale( AI_CONFIG_GLOBAL_SCALE_FACTOR_DEFAULT ) {
|
|
|
- // empty
|
|
|
}
|
|
|
|
|
|
ScaleProcess::~ScaleProcess() {
|
|
|
@@ -71,10 +69,18 @@ bool ScaleProcess::IsActive( unsigned int pFlags ) const {
|
|
|
}
|
|
|
|
|
|
void ScaleProcess::SetupProperties( const Importer* pImp ) {
|
|
|
- mScale = pImp->GetPropertyFloat( AI_CONFIG_GLOBAL_SCALE_FACTOR_KEY, 0 );
|
|
|
+ mScale = pImp->GetPropertyFloat( AI_CONFIG_GLOBAL_SCALE_FACTOR_KEY, 1.0f );
|
|
|
}
|
|
|
|
|
|
void ScaleProcess::Execute( aiScene* pScene ) {
|
|
|
+ if(mScale == 1.0f) {
|
|
|
+ return; // nothing to scale
|
|
|
+ }
|
|
|
+
|
|
|
+ ai_assert( mScale != 0 );
|
|
|
+ ai_assert( nullptr != pScene );
|
|
|
+ ai_assert( nullptr != pScene->mRootNode );
|
|
|
+
|
|
|
if ( nullptr == pScene ) {
|
|
|
return;
|
|
|
}
|
|
|
@@ -82,22 +88,113 @@ void ScaleProcess::Execute( aiScene* pScene ) {
|
|
|
if ( nullptr == pScene->mRootNode ) {
|
|
|
return;
|
|
|
}
|
|
|
+
|
|
|
+ // Process animations and update position transform to new unit system
|
|
|
+ for( unsigned int animationID = 0; animationID < pScene->mNumAnimations; animationID++ )
|
|
|
+ {
|
|
|
+ aiAnimation* animation = pScene->mAnimations[animationID];
|
|
|
+
|
|
|
+ for( unsigned int animationChannel = 0; animationChannel < animation->mNumChannels; animationChannel++)
|
|
|
+ {
|
|
|
+ aiNodeAnim* anim = animation->mChannels[animationChannel];
|
|
|
+
|
|
|
+ for( unsigned int posKey = 0; posKey < anim->mNumPositionKeys; posKey++)
|
|
|
+ {
|
|
|
+ aiVectorKey& vectorKey = anim->mPositionKeys[posKey];
|
|
|
+ vectorKey.mValue *= mScale;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ for( unsigned int meshID = 0; meshID < pScene->mNumMeshes; meshID++)
|
|
|
+ {
|
|
|
+ aiMesh *mesh = pScene->mMeshes[meshID];
|
|
|
+
|
|
|
+ // Reconstruct mesh vertexes to the new unit system
|
|
|
+ for( unsigned int vertexID = 0; vertexID < mesh->mNumVertices; vertexID++)
|
|
|
+ {
|
|
|
+ aiVector3D& vertex = mesh->mVertices[vertexID];
|
|
|
+ vertex *= mScale;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ // bone placement / scaling
|
|
|
+ for( unsigned int boneID = 0; boneID < mesh->mNumBones; boneID++)
|
|
|
+ {
|
|
|
+ // Reconstruct matrix by transform rather than by scale
|
|
|
+ // This prevent scale values being changed which can
|
|
|
+ // be meaningful in some cases
|
|
|
+ // like when you want the modeller to see 1:1 compatibility.
|
|
|
+ aiBone* bone = mesh->mBones[boneID];
|
|
|
+
|
|
|
+ aiVector3D pos, scale;
|
|
|
+ aiQuaternion rotation;
|
|
|
+
|
|
|
+ bone->mOffsetMatrix.Decompose( scale, rotation, pos);
|
|
|
+
|
|
|
+ aiMatrix4x4 translation;
|
|
|
+ aiMatrix4x4::Translation( pos * mScale, translation );
|
|
|
+
|
|
|
+ aiMatrix4x4 scaling;
|
|
|
+ aiMatrix4x4::Scaling( aiVector3D(scale), scaling );
|
|
|
+
|
|
|
+ aiMatrix4x4 RotMatrix = aiMatrix4x4 (rotation.GetMatrix());
|
|
|
+
|
|
|
+ bone->mOffsetMatrix = translation * RotMatrix * scaling;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ // animation mesh processing
|
|
|
+ // convert by position rather than scale.
|
|
|
+ for( unsigned int animMeshID = 0; animMeshID < mesh->mNumAnimMeshes; animMeshID++)
|
|
|
+ {
|
|
|
+ aiAnimMesh * animMesh = mesh->mAnimMeshes[animMeshID];
|
|
|
+
|
|
|
+ for( unsigned int vertexID = 0; vertexID < animMesh->mNumVertices; vertexID++)
|
|
|
+ {
|
|
|
+ aiVector3D& vertex = animMesh->mVertices[vertexID];
|
|
|
+ vertex *= mScale;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
|
|
|
traverseNodes( pScene->mRootNode );
|
|
|
}
|
|
|
|
|
|
-void ScaleProcess::traverseNodes( aiNode *node ) {
|
|
|
+void ScaleProcess::traverseNodes( aiNode *node, unsigned int nested_node_id ) {
|
|
|
applyScaling( node );
|
|
|
+
|
|
|
+ for( size_t i = 0; i < node->mNumChildren; i++)
|
|
|
+ {
|
|
|
+ // recurse into the tree until we are done!
|
|
|
+ traverseNodes( node->mChildren[i], nested_node_id+1 );
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
void ScaleProcess::applyScaling( aiNode *currentNode ) {
|
|
|
if ( nullptr != currentNode ) {
|
|
|
- currentNode->mTransformation.a1 = currentNode->mTransformation.a1 * mScale;
|
|
|
- currentNode->mTransformation.b2 = currentNode->mTransformation.b2 * mScale;
|
|
|
- currentNode->mTransformation.c3 = currentNode->mTransformation.c3 * mScale;
|
|
|
+ // Reconstruct matrix by transform rather than by scale
|
|
|
+ // This prevent scale values being changed which can
|
|
|
+ // be meaningful in some cases
|
|
|
+ // like when you want the modeller to
|
|
|
+ // see 1:1 compatibility.
|
|
|
+
|
|
|
+ aiVector3D pos, scale;
|
|
|
+ aiQuaternion rotation;
|
|
|
+ currentNode->mTransformation.Decompose( scale, rotation, pos);
|
|
|
+
|
|
|
+ aiMatrix4x4 translation;
|
|
|
+ aiMatrix4x4::Translation( pos * mScale, translation );
|
|
|
+
|
|
|
+ aiMatrix4x4 scaling;
|
|
|
+
|
|
|
+ // note: we do not use mScale here, this is on purpose.
|
|
|
+ aiMatrix4x4::Scaling( scale, scaling );
|
|
|
+
|
|
|
+ aiMatrix4x4 RotMatrix = aiMatrix4x4 (rotation.GetMatrix());
|
|
|
+
|
|
|
+ currentNode->mTransformation = translation * RotMatrix * scaling;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
} // Namespace Assimp
|
|
|
-
|
|
|
-#endif // !! ASSIMP_BUILD_NO_GLOBALSCALE_PROCESS
|
Kim Kulling