Improved FBX model support

Author: bfiete

BeefLibs/Beefy2D/src/geom/Vector3.bf

@@ -267,9 +267,9 @@ namespace Beefy.geom
 
         public static Vector3 TransformNormal(Vector3 normal, Matrix4 matrix)
         {
-            return Vector3((normal.mX * matrix.m11) + (normal.mY * matrix.m21) + (normal.mZ * matrix.m31),
-                                 (normal.mX * matrix.m12) + (normal.mY * matrix.m22) + (normal.mZ * matrix.m32),
-                                 (normal.mX * matrix.m13) + (normal.mY * matrix.m23) + (normal.mZ * matrix.m33));
+            return Vector3((normal.mX * matrix.m00) + (normal.mY * matrix.m01) + (normal.mZ * matrix.m02),
+                                 (normal.mX * matrix.m10) + (normal.mY * matrix.m11) + (normal.mZ * matrix.m12),
+                                 (normal.mX * matrix.m20) + (normal.mY * matrix.m21) + (normal.mZ * matrix.m22));
         }
 
         public static bool operator ==(Vector3 value1, Vector3 value2)

BeefLibs/Beefy2D/src/gfx/Model.bf

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections;
 using System.Text;
 using System.Threading.Tasks;
@@ -117,6 +117,9 @@ namespace Beefy.gfx
 		[CallingConvention(.Stdcall), CLink]
 		extern static void ModelDef_SetBaseDir(void* nativeModel, char8* baseDir);
 
+		[CallingConvention(.Stdcall), CLink]
+		extern static void ModelDef_Scale(void* nativeModel, Vector3 scale);
+
 		[CallingConvention(.Stdcall), CLink]
 		extern static char8* ModelDef_GetInfo(void* nativeModel);
 
@@ -129,6 +132,9 @@ namespace Beefy.gfx
         [CallingConvention(.Stdcall), CLink]
         extern static int32 ModelDef_GetJointCount(void* nativeModel);
 
+        [CallingConvention(.Stdcall), CLink]
+        extern static int32 ModelDef_GetJointParent(void* nativeModel, int32 jointIdx);
+
         [CallingConvention(.Stdcall), CLink]
         extern static int32 ModelDef_GetAnimCount(void* nativeModel);
 
@@ -200,6 +206,11 @@ namespace Beefy.gfx
 			ModelDef_GetBounds(mNativeModelDef, out min, out max);
 		}
 
+		public int32 GetJointParent(int32 jointIdx)
+		{
+			return ModelDef_GetJointParent(mNativeModelDef, jointIdx);
+		}
+
 		public void Compact()
 		{
 			ModelDef_Compact(mNativeModelDef);
@@ -210,6 +221,11 @@ namespace Beefy.gfx
 			ModelDef_SetBaseDir(mNativeModelDef, baseDir.ToScopeCStr!());
 		}
 
+		public void Scale(Vector3 scale)
+		{
+			ModelDef_Scale(mNativeModelDef, scale);
+		}
+
 		public void SetTextures(int meshIdx, int primitivesIdx, Span<char8*> paths)
 		{
 			ModelDef_SetTextures(mNativeModelDef, (.)meshIdx, (.)primitivesIdx, paths.Ptr, (.)paths.Length);
@@ -224,7 +240,7 @@ namespace Beefy.gfx
 		public bool RayIntersect(Matrix4 worldMtx, Vector3 origin, Vector3 vec, out Vector3 outIntersect, out float outDistance)
 		{
 			return ModelDef_RayIntersect(mNativeModelDef, worldMtx, origin, vec, out outIntersect, out outDistance);
-		}	
+		}
     }
 
     public class ModelInstance : RenderCmd

BeefySysLib/fbx/FBXReader.cpp

@@ -1491,6 +1491,9 @@ bool FBXReader::ReadFile(const StringImpl& fileName, bool loadAnims)
 			for (int row = 0; row < 4; row++)
 				for (int col = 0; col < 4; col++)
 					joint->mPoseInvMatrix.mMat[row][col] = (float) invGlobalMtx.Get(col, row);
+			joint->mBindPoseLocal.mTrans = Vector3((float)fbxJoint->posx, (float)fbxJoint->posy, (float)fbxJoint->posz);
+			joint->mBindPoseLocal.mScale = Vector3(fbxJoint->scalex, fbxJoint->scaley, fbxJoint->scalez);
+			joint->mBindPoseLocal.mQuat = Quaternion((float)fbxJoint->quatx, (float)fbxJoint->quaty, (float)fbxJoint->quatz, (float)fbxJoint->quatw);
 		}
 	}
 

BeefySysLib/gfx/ModelDef.cpp

@@ -69,9 +69,14 @@ BF_EXPORT void ModelDef_GetBounds(ModelDef* modelDef, Vector3& min, Vector3& max
 	modelDef->GetBounds(min, max);
 }
 
-BF_EXPORT void ModelDef_SetBaseDir(ModelDef* modelDef, char* baseDIr)
+BF_EXPORT void ModelDef_SetBaseDir(ModelDef* modelDef, char* baseDir)
 {
-	modelDef->mLoadDir = baseDIr;
+	modelDef->mLoadDir = baseDir;
+}
+
+BF_EXPORT void ModelDef_Scale(ModelDef* modelDef, Vector3 scale)
+{
+	modelDef->Scale(scale);
 }
 
 BF_EXPORT const char* BF_CALLTYPE ModelDef_GetInfo(ModelDef* modelDef)
@@ -145,6 +150,11 @@ BF_EXPORT const char* BF_CALLTYPE ModelDefAnimation_GetName(ModelAnimation* mode
 	return modelAnimation->mName.c_str();
 }
 
+BF_EXPORT int BF_CALLTYPE ModelDef_GetJointParent(ModelDef* modelDef, int jointIdx)
+{
+	return modelDef->mJoints[jointIdx].mParentIdx;
+}
+
 BF_EXPORT void BF_CALLTYPE ModelDefAnimation_Clip(ModelAnimation* modelAnimation, int startFrame, int numFrames)
 {	
 	modelAnimation->mFrames.RemoveRange(0, startFrame);
@@ -164,6 +174,115 @@ ModelDef::~ModelDef()
 	}
 }
 
+void ModelDef::Scale(const Vector3& scale)
+{
+	// For quaternion component flipping under axis reflection: sign of each scale component.
+	float signX = (scale.mX < 0.0f) ? -1.0f : 1.0f;
+	float signY = (scale.mY < 0.0f) ? -1.0f : 1.0f;
+	float signZ = (scale.mZ < 0.0f) ? -1.0f : 1.0f;
+
+	// Mesh vertices: positions scale directly; normals transform by S^{-T} = S^{-1} (inverse
+	// of a diagonal scale); tangents are geometric directions and transform the same as positions.
+	for (auto& mesh : mMeshes)
+	{
+		for (auto& prims : mesh.mPrimitives)
+		{
+			for (auto& vtx : prims.mVertices)
+			{
+				vtx.mPosition *= scale;
+				vtx.mNormal = Vector3::Normalize(Vector3(
+					vtx.mNormal.mX / scale.mX,
+					vtx.mNormal.mY / scale.mY,
+					vtx.mNormal.mZ / scale.mZ));
+				vtx.mTangent = Vector3::Normalize(vtx.mTangent * scale);
+			}
+		}
+	}
+
+	// Bone inverse bind-pose matrices transform as S * M * S^{-1}.
+	// For a diagonal scale S, element (i,j) scales by scale[i] / scale[j],
+	// where scale[3] = 1 (homogeneous row/column left unchanged).
+	float scaleArr[4] = { scale.mX, scale.mY, scale.mZ, 1.0f };
+	for (auto& joint : mJoints)
+	{
+		for (int row = 0; row < 4; row++)
+			for (int col = 0; col < 4; col++)
+				joint.mPoseInvMatrix.mMat[row][col] *= scaleArr[row] / scaleArr[col];
+
+		joint.mBindPoseLocal.mTrans *= scale;
+		joint.mBindPoseLocal.mQuat = Quaternion(
+			signY * signZ * joint.mBindPoseLocal.mQuat.mX,
+			signX * signZ * joint.mBindPoseLocal.mQuat.mY,
+			signX * signY * joint.mBindPoseLocal.mQuat.mZ,
+			joint.mBindPoseLocal.mQuat.mW);
+	}
+
+	// Animation frame data: local joint translations are the translation column of
+	// S * L * S^{-1}, which equals S * mTrans.  Under axis reflections the rotation
+	// changes as S * R * S^{-1}; its quaternion form is q_new = (w, sy*sz*x, sx*sz*y, sx*sy*z).
+	for (auto& anim : mAnims)
+	{
+		for (auto& frame : anim.mFrames)
+		{
+			for (auto& jt : frame.mJointTranslations)
+			{
+				jt.mTrans *= scale;
+				jt.mQuat = Quaternion(
+					signY * signZ * jt.mQuat.mX,
+					signX * signZ * jt.mQuat.mY,
+					signX * signY * jt.mQuat.mZ,
+					jt.mQuat.mW);
+			}
+		}
+	}
+
+	// Scene node translations.
+	for (auto& node : mNodes)
+		node.mTranslation *= scale;
+
+	// BVH geometry and derived bounds.
+	if ((mFlags & Flags_HasBVH) != 0)
+	{
+		for (auto& bvVtx : mBVVertices)
+			bvVtx *= scale;
+
+		float maxAbsScale = fabs(scale.mX);
+		if (fabs(scale.mY) > maxAbsScale) maxAbsScale = fabs(scale.mY);
+		if (fabs(scale.mZ) > maxAbsScale) maxAbsScale = fabs(scale.mZ);
+
+		for (auto& bvNode : mBVNodes)
+		{
+			bvNode.mBoundSphere.mCenter *= scale;
+			bvNode.mBoundSphere.mRadius *= maxAbsScale;
+
+			Vector3 newMin = bvNode.mBoundAABB.mMin * scale;
+			Vector3 newMax = bvNode.mBoundAABB.mMax * scale;
+			bvNode.mBoundAABB.mMin = Vector3(
+				(newMin.mX < newMax.mX) ? newMin.mX : newMax.mX,
+				(newMin.mY < newMax.mY) ? newMin.mY : newMax.mY,
+				(newMin.mZ < newMax.mZ) ? newMin.mZ : newMax.mZ);
+			bvNode.mBoundAABB.mMax = Vector3(
+				(newMin.mX > newMax.mX) ? newMin.mX : newMax.mX,
+				(newMin.mY > newMax.mY) ? newMin.mY : newMax.mY,
+				(newMin.mZ > newMax.mZ) ? newMin.mZ : newMax.mZ);
+		}
+	}
+
+	if ((mFlags & Flags_HasBounds) != 0)
+	{
+		Vector3 newMin = mBounds.mMin * scale;
+		Vector3 newMax = mBounds.mMax * scale;
+		mBounds.mMin = Vector3(
+			(newMin.mX < newMax.mX) ? newMin.mX : newMax.mX,
+			(newMin.mY < newMax.mY) ? newMin.mY : newMax.mY,
+			(newMin.mZ < newMax.mZ) ? newMin.mZ : newMax.mZ);
+		mBounds.mMax = Vector3(
+			(newMin.mX > newMax.mX) ? newMin.mX : newMax.mX,
+			(newMin.mY > newMax.mY) ? newMin.mY : newMax.mY,
+			(newMin.mZ > newMax.mZ) ? newMin.mZ : newMax.mZ);
+	}
+}
+
 void ModelDef::Compact()
 {
 	for (auto& mesh : mMeshes)
@@ -276,9 +395,9 @@ static int partition(float a[], int left, int right, int pIndex)
 	return pIndex;
 }
 
-// Returns the k'th smallest element in the list within `left…right`
+// Returns the k'th smallest element in the list within `left�right`
 // (i.e., `left <= k <= right`). The search space within the array is
-// changing for each round – but the list is still the same size.
+// changing for each round � but the list is still the same size.
 // Thus, `k` does not need to be updated with each round.
 static float quickselect(float A[], int left, int right, int k)
 {

BeefySysLib/gfx/ModelDef.h

@@ -57,6 +57,16 @@ class ModelJoint
 	String mName;
 	int mParentIdx;
 	Matrix4 mPoseInvMatrix;
+	ModelJointTranslation mBindPoseLocal;
+
+public:
+	ModelJoint()
+	{
+		mParentIdx = -1;
+		mBindPoseLocal.mTrans = Vector3(0, 0, 0);
+		mBindPoseLocal.mScale = Vector3(1, 1, 1);
+		mBindPoseLocal.mQuat = Quaternion(0, 0, 0, 1);
+	}
 };
 
 class ModelMetalicRoughness
@@ -238,6 +248,7 @@ class ModelDef
 	ModelDef();
 	~ModelDef();
 
+	void Scale(const Vector3& scale);
 	void Compact();
 	void GetBounds(Vector3& min, Vector3& max);
 

BeefySysLib/gfx/ModelInstance.cpp

@@ -6,7 +6,9 @@ ModelInstance::ModelInstance(ModelDef* modelDef)
 {
 	mNext = NULL;
 	mModelDef = modelDef;
-	mJointTranslations.Resize(mModelDef->mJoints.size());	
+	mJointTranslations.Resize(mModelDef->mJoints.size());
+	for (int i = 0; i < (int)mModelDef->mJoints.size(); i++)
+		mJointTranslations[i] = mModelDef->mJoints[i].mBindPoseLocal;
 	mMeshesVisible.Insert(0, true, mModelDef->mMeshes.size());
 }
 

BeefySysLib/platform/win/DXRenderDevice.cpp

@@ -1469,11 +1469,7 @@ void Beefy::DXModelInstance::CommandQueued(DrawLayer* drawLayer)
 	BF_ASSERT(mRenderState->mShader->mVertexSize == sizeof(DXModelVertex));
 	drawLayer->mCurTextures[0] = NULL;
 
-#ifndef BF_NO_FBX
-	if (mModelDef->mAnims.IsEmpty())
-		return;
-	ModelAnimation* fbxAnim = &mModelDef->mAnims[0];
-
+#ifndef BF_NO_FBX	
 	Matrix4 jointsMatrices[BF_MAX_NUM_BONES];
 	for (int jointIdx = 0; jointIdx < (int)mJointTranslations.size(); jointIdx++)
 	{
@@ -1522,40 +1518,44 @@ void Beefy::DXModelInstance::CommandQueued(DrawLayer* drawLayer)
 				ModelVertex* srcVtxData = &modelPrims->mVertices[vtxIdx];
 
 				Vector3 vtx(0, 0, 0);
+				Vector3 normal(0, 0, 0);
+				Vector3 tangent(0, 0, 0);
 
 				float totalWeight = 0;
 
-				//TODO:
-				vtx = srcVtxData->mPosition;
-
-				/*for (int weightIdx = 0; weightIdx < srcVtxData->mNumBoneWeights; weightIdx++)
+				for (int weightIdx = 0; weightIdx < srcVtxData->mNumBoneWeights; weightIdx++)
 				{
 					int jointIdx = srcVtxData->mBoneIndices[weightIdx];
 					float boneWeight = srcVtxData->mBoneWeights[weightIdx];
 
 					Matrix4* mtx = &jointsMatrices[jointIdx];
-					Vector3 origVec = srcVtxData->mPosition;
 
-					Vector3 transVec = Vector3::Transform(origVec, *mtx);
-					transVec = transVec * boneWeight;
-					vtx = vtx + transVec;
+					vtx = vtx + Vector3::Transform(srcVtxData->mPosition, *mtx) * boneWeight;
+
+					Vector3 origNormal = srcVtxData->mNormal;
+					normal = normal + Vector3(
+						mtx->m00 * origNormal.mX + mtx->m01 * origNormal.mY + mtx->m02 * origNormal.mZ,
+						mtx->m10 * origNormal.mX + mtx->m11 * origNormal.mY + mtx->m12 * origNormal.mZ,
+						mtx->m20 * origNormal.mX + mtx->m21 * origNormal.mY + mtx->m22 * origNormal.mZ) * boneWeight;
+
+					Vector3 origTangent = srcVtxData->mTangent;
+					tangent = tangent + Vector3(
+						mtx->m00 * origTangent.mX + mtx->m01 * origTangent.mY + mtx->m02 * origTangent.mZ,
+						mtx->m10 * origTangent.mX + mtx->m11 * origTangent.mY + mtx->m12 * origTangent.mZ,
+						mtx->m20 * origTangent.mX + mtx->m21 * origTangent.mY + mtx->m22 * origTangent.mZ) * boneWeight;
 
 					totalWeight += boneWeight;
 				}
 				BF_ASSERT(fabs(totalWeight - 1.0) < 0.1f);
-				*/				
-
-
-				
 
 				DXModelVertex* destVtx = dxVtxData + vtxIdx;
 
-				//destVtx->mPosition = srcVtxData->mPosition;
 				destVtx->mPosition = vtx;
+				destVtx->mNormal = Vector3::Normalize(normal);
+				destVtx->mTangent = Vector3::Normalize(tangent);
 				destVtx->mTexCoords = srcVtxData->mTexCoords;
-				destVtx->mBumpTexCoords = srcVtxData->mTexCoords;
+				destVtx->mBumpTexCoords = srcVtxData->mBumpTexCoords;
 				destVtx->mColor = 0xFFFFFFFF; //TODO: Color
-				destVtx->mTangent = srcVtxData->mTangent;
 			}
 
 			dxRenderDevice->mD3DDeviceContext->Unmap(dxPrims->mD3DVertexBuffer, 0);