Minor fixes

src/models.c

@@ -1109,7 +1109,7 @@ ModelAnimation *LoadModelAnimations(const char *filename, int *animCount)
             {
                 if (animations[a].bones[i].parent >= 0)
                 {
-                    animations[a].framePoses[frame][i].rotation = QuaternionMultiply(animations[a].framePoses[frame][animations[a].bones[i].parent].rotation, animations[a].framePoses[frame][i].rotation);
+                    animations[a].framePoses[frame][i].rotation = QuaternionMultiplyQ(animations[a].framePoses[frame][animations[a].bones[i].parent].rotation, animations[a].framePoses[frame][i].rotation);
                     animations[a].framePoses[frame][i].translation = Vector3RotateByQuaternion(animations[a].framePoses[frame][i].translation, animations[a].framePoses[frame][animations[a].bones[i].parent].rotation);
                     animations[a].framePoses[frame][i].translation = Vector3AddV(animations[a].framePoses[frame][i].translation, animations[a].framePoses[frame][animations[a].bones[i].parent].translation);
                     animations[a].framePoses[frame][i].scale = Vector3MultiplyV(animations[a].framePoses[frame][i].scale, animations[a].framePoses[frame][animations[a].bones[i].parent].scale);
@@ -1167,7 +1167,7 @@ void UpdateModelAnimation(Model model, ModelAnimation anim, int frame)
                 animVertex = (Vector3){ model.meshes[m].vertices[vCounter], model.meshes[m].vertices[vCounter + 1], model.meshes[m].vertices[vCounter + 2] };
                 animVertex = Vector3MultiplyV(animVertex, outScale);
                 animVertex = Vector3SubtractV(animVertex, inTranslation);
-                animVertex = Vector3RotateByQuaternion(animVertex, QuaternionMultiply(outRotation, QuaternionInvert(inRotation)));
+                animVertex = Vector3RotateByQuaternion(animVertex, QuaternionMultiplyQ(outRotation, QuaternionInvert(inRotation)));
                 animVertex = Vector3AddV(animVertex, outTranslation);
                 model.meshes[m].animVertices[vCounter] = animVertex.x;
                 model.meshes[m].animVertices[vCounter + 1] = animVertex.y;
@@ -1176,7 +1176,7 @@ void UpdateModelAnimation(Model model, ModelAnimation anim, int frame)
                 // Normals processing
                 // NOTE: We use meshes.baseNormals (default normal) to calculate meshes.normals (animated normals)
                 animNormal = (Vector3){ model.meshes[m].normals[vCounter], model.meshes[m].normals[vCounter + 1], model.meshes[m].normals[vCounter + 2] };
-                animNormal = Vector3RotateByQuaternion(animNormal, QuaternionMultiply(outRotation, QuaternionInvert(inRotation)));
+                animNormal = Vector3RotateByQuaternion(animNormal, QuaternionMultiplyQ(outRotation, QuaternionInvert(inRotation)));
                 model.meshes[m].animNormals[vCounter] = animNormal.x;
                 model.meshes[m].animNormals[vCounter + 1] = animNormal.y;
                 model.meshes[m].animNormals[vCounter + 2] = animNormal.z;
@@ -3313,7 +3313,7 @@ static Model LoadIQM(const char *fileName)
     {
         if (model.bones[i].parent >= 0)
         {
-            model.bindPose[i].rotation = QuaternionMultiply(model.bindPose[model.bones[i].parent].rotation, model.bindPose[i].rotation);
+            model.bindPose[i].rotation = QuaternionMultiplyQ(model.bindPose[model.bones[i].parent].rotation, model.bindPose[i].rotation);
             model.bindPose[i].translation = Vector3RotateByQuaternion(model.bindPose[i].translation, model.bindPose[model.bones[i].parent].rotation);
             model.bindPose[i].translation = Vector3AddV(model.bindPose[i].translation, model.bindPose[model.bones[i].parent].translation);
             model.bindPose[i].scale = Vector3MultiplyV(model.bindPose[i].scale, model.bindPose[model.bones[i].parent].scale);

src/raymath.h

@@ -1110,34 +1110,6 @@ RMDEF Quaternion QuaternionSubtract(Quaternion q, float sub)
     return result;
 }
 
-// Multiply two quaternions
-RMDEF Quaternion QuaternionMultiplyQ(Quaternion q1, Quaternion q2)
-{
-    Quaternion result = {q1.x * q2.x, q1.y * q2.y, q1.z * q2.z, q1.w * q2.w};
-    return result;
-}
-
-// Multiply quaternion by float value
-RMDEF Quaternion QuaternionMultiply(Quaternion q, float sub)
-{
-    Quaternion result = {q.x * sub, q.y * sub, q.z * sub, q.w * sub};
-    return result;
-}
-
-// Divide two quaternions
-RMDEF Quaternion QuaternionDivideQ(Quaternion q1, Quaternion q2)
-{
-    Quaternion result = {q1.x / q2.x, q1.y / q2.y, q1.z / q2.z, q1.w / q2.w};
-    return result;
-}
-
-// Divide quaternion by float value
-RMDEF Quaternion QuaternionDivide(Quaternion q, float sub)
-{
-    Quaternion result = {q.x / sub, q.y / sub, q.z / sub, q.w / sub};
-    return result;
-}
-
 // Returns identity quaternion
 RMDEF Quaternion QuaternionIdentity(void)
 {
@@ -1191,7 +1163,7 @@ RMDEF Quaternion QuaternionInvert(Quaternion q)
 }
 
 // Calculate two quaternion multiplication
-RMDEF Quaternion QuaternionMultiply(Quaternion q1, Quaternion q2)
+RMDEF Quaternion QuaternionMultiplyQ(Quaternion q1, Quaternion q2)
 {
     Quaternion result = { 0 };
 
@@ -1206,6 +1178,35 @@ RMDEF Quaternion QuaternionMultiply(Quaternion q1, Quaternion q2)
     return result;
 }
 
+// Multiply quaternion by float value
+RMDEF Quaternion QuaternionMultiply(Quaternion q, float mul)
+{
+    Quaternion result = { 0 };
+
+    float qax = q.x, qay = q.y, qaz = q.z, qaw = q.w;
+
+    result.x = qax * mul + qaw * mul + qay * mul - qaz * mul;
+    result.y = qay * mul + qaw * mul + qaz * mul - qax * mul;
+    result.z = qaz * mul + qaw * mul + qax * mul - qay * mul;
+    result.w = qaw * mul - qax * mul - qay * mul - qaz * mul;
+
+    return result;
+}
+
+// Divide two quaternions
+RMDEF Quaternion QuaternionDivideQ(Quaternion q1, Quaternion q2)
+{
+    Quaternion result = {q1.x / q2.x, q1.y / q2.y, q1.z / q2.z, q1.w / q2.w};
+    return result;
+}
+
+// Divide quaternion by float value
+RMDEF Quaternion QuaternionDivide(Quaternion q, float div)
+{
+    Quaternion result = {q.x / div, q.y / div, q.z / div, q.w / div};
+    return result;
+}
+
 // Calculate linear interpolation between two quaternions
 RMDEF Quaternion QuaternionLerp(Quaternion q1, Quaternion q2, float amount)
 {