private void GizmoRotate(GizmoMode mode, float newAngle)
{
if (_control != null)
{
var model = _control.Model;
var animation = _editor.CurrentAnim;
if (animation == null || _control.SelectedMesh == null)
{
return;
}
var meshIndex = model.Meshes.IndexOf(_control.SelectedMesh);
var rotationVector = _editor.CurrentKeyFrame.Rotations[meshIndex];
var delta = 0f;
var axis = Vector3.Zero;
switch (mode)
{
case GizmoMode.RotateX: delta = newAngle - rotationVector.X; axis = Vector3.UnitX; break;
case GizmoMode.RotateY: delta = newAngle - rotationVector.Y; axis = Vector3.UnitY; break;
case GizmoMode.RotateZ: delta = newAngle - rotationVector.Z; axis = Vector3.UnitZ; break;
}
var quat = _editor.CurrentKeyFrame.Quaternions[meshIndex] * Quaternion.CreateFromAxisAngle(axis, delta);
_editor.UpdateTransform(meshIndex, MathC.QuaternionToEuler(quat), _editor.CurrentKeyFrame.Translations[0]);
_control.Model.BuildAnimationPose(_editor.CurrentKeyFrame);
_control.Invalidate();
}
}
public void UpdateTransform(int meshIndex, Vector3 newRot, Vector3 newPos)
{
if (CurrentAnim == null || CurrentKeyFrame == null)
{
return;
}
// Backup everything and push undo on first occurence of editing
if (!MadeChanges || _backupPos.Count == 0 || _backupRot.Count == 0)
{
_initialPos = CurrentKeyFrame.Translations[0];
_initialRot = CurrentKeyFrame.Rotations[meshIndex];
_backupPos.Clear();
_backupRot.Clear();
ActiveFrames.ForEach(f => { _backupRot.Add(f.Rotations[meshIndex]); _backupPos.Add(f.Translations[0]); });
Tool.UndoManager.PushAnimationChanged(this, CurrentAnim);
MadeChanges = true;
}
// Calculate deltas for other frames processing
var deltaPos = newPos - _initialPos;
var deltaRot = newRot - _initialRot;
// Define animation properties
bool evolve = TransformMode != AnimTransformMode.Simple && ActiveFrames.Count > 1;
bool smooth = TransformMode == AnimTransformMode.Smooth || TransformMode == AnimTransformMode.SmoothReverse || TransformMode == AnimTransformMode.Symmetric;
bool reverse = TransformMode == AnimTransformMode.LinearReverse || TransformMode == AnimTransformMode.SmoothReverse;
bool loop = TransformMode == AnimTransformMode.Symmetric || TransformMode == AnimTransformMode.SymmetricLinear;
// Calculate evolution
float frameCount = loop || reverse ? Selection.Y - Selection.X : CurrentFrameIndex - Selection.X;
float currentStep = 0;
int index = 0;
foreach (var keyframe in ActiveFrames)
{
float midFrame = loop ? CurrentFrameIndex - Selection.X : (reverse ? CurrentFrameIndex : frameCount);
float bias = (currentStep <= midFrame) ? (reverse ? 1.0f : currentStep / midFrame) : (frameCount - currentStep) / (frameCount - midFrame);
// Single-pass smoothstep doesn't look organic on fast animations, hence we're using 2-pass smootherstep here.
float weight = smooth ? (float)MathC.SmoothStep(0, 1, MathC.SmoothStep(0, 1, bias)) : bias;
// Apply deltas to backed-up transforms
var currPos = _backupPos[index] + deltaPos;
var currRot = _backupRot[index] + deltaRot;
var translationVector = currPos;
if (evolve)
{
translationVector = Vector3.Lerp(_backupPos[index], translationVector, weight);
}
// Foolproof stuff in case user hardly messes with transform during playback...
if (float.IsNaN(translationVector.X))
{
translationVector.X = _backupPos[index].X;
}
if (float.IsNaN(translationVector.Y))
{
translationVector.Y = _backupPos[index].Y;
}
if (float.IsNaN(translationVector.Z))
{
translationVector.Z = _backupPos[index].Z;
}
keyframe.Translations[0] = translationVector;
keyframe.TranslationsMatrices[0] = Matrix4x4.CreateTranslation(translationVector);
var rotVector = currRot;
Quaternion finalQuat;
if (evolve)
{
// Calculate source and destination quats and decide on direction based on dot product.
var srcQuat = Quaternion.CreateFromYawPitchRoll(_backupRot[index].Y, _backupRot[index].X, _backupRot[index].Z);
var destQuat = Quaternion.CreateFromYawPitchRoll(currRot.Y, currRot.X, currRot.Z);
if (Quaternion.Dot(srcQuat, destQuat) < 0)
{
Quaternion.Negate(srcQuat);
}
finalQuat = Quaternion.Lerp(srcQuat, destQuat, weight);
}
else
{
finalQuat = Quaternion.CreateFromYawPitchRoll(rotVector.Y, rotVector.X, rotVector.Z);
}
// We're not converting quat to rotations because we have to check-up for NaNs
var rotationVector = MathC.QuaternionToEuler(finalQuat);
// Foolproof stuff in case user hardly messes with transform during playback...
if (float.IsNaN(rotationVector.X))
{
rotationVector.X = _backupRot[index].X;
}
if (float.IsNaN(rotationVector.Y))
{
rotationVector.Y = _backupRot[index].Y;
}
if (float.IsNaN(rotationVector.Z))
{
rotationVector.Z = _backupRot[index].Z;
}
// NaNs filtered out, now we can put actual data.
keyframe.Quaternions[meshIndex] = Quaternion.CreateFromYawPitchRoll(rotationVector.Y, rotationVector.X, rotationVector.Z);
keyframe.Rotations[meshIndex] = rotationVector;
index++;
currentStep++; if (currentStep > frameCount)
{
currentStep = frameCount;
}
}
}
public override IOModel ImportFromFile(string filename)
{
string path = Path.GetDirectoryName(filename);
// Use Assimp.NET for importing model
AssimpContext context = new AssimpContext();
context.SetConfig(new NormalSmoothingAngleConfig(90.0f));
Scene scene = context.ImportFile(filename, PostProcessPreset.TargetRealTimeMaximumQuality);
var newModel = new IOModel();
var textures = new Dictionary <int, Texture>();
if (_settings.ProcessGeometry)
{
var tmpList = new List <IOMesh>();
// Create the list of materials to load
for (int i = 0; i < scene.Materials.Count; i++)
{
var mat = scene.Materials[i];
var material = new IOMaterial(mat.HasName ? mat.Name : "Material_" + i);
var diffusePath = mat.HasTextureDiffuse ? mat.TextureDiffuse.FilePath : null;
if (string.IsNullOrWhiteSpace(diffusePath))
{
continue;
}
// Don't add materials with missing textures
var texture = GetTexture(path, diffusePath);
if (texture == null)
{
logger.Warn("Texture for material " + mat.Name + " is missing. Meshes referencing this material won't be imported.");
continue;
}
else
{
textures.Add(i, texture);
}
// Create the new material
material.Texture = textures[i];
material.AdditiveBlending = (mat.HasBlendMode && mat.BlendMode == global::Assimp.BlendMode.Additive) || mat.Opacity < 1.0f;
material.DoubleSided = mat.HasTwoSided && mat.IsTwoSided;
material.Shininess = mat.HasShininess ? (int)mat.Shininess : 0;
newModel.Materials.Add(material);
}
var lastBaseVertex = 0;
// Loop for each mesh loaded in scene
foreach (var mesh in scene.Meshes)
{
// Discard nullmeshes
if (!mesh.HasFaces || !mesh.HasVertices || mesh.VertexCount < 3 ||
mesh.TextureCoordinateChannelCount == 0 || !mesh.HasTextureCoords(0))
{
logger.Warn("Mesh \"" + (mesh.Name ?? "") + "\" has no faces, no texture coordinates or wrong vertex count.");
continue;
}
// Import only textured meshes with valid materials
Texture faceTexture;
if (!textures.TryGetValue(mesh.MaterialIndex, out faceTexture))
{
logger.Warn("Mesh \"" + (mesh.Name ?? "") + "\" does have material index " + mesh.MaterialIndex + " which is unsupported or can't be found.");
continue;
}
// Make sure we have appropriate material in list. If not, skip mesh and warn user.
var material = newModel.Materials.FirstOrDefault(mat => mat.Name.Equals(scene.Materials[mesh.MaterialIndex].Name));
if (material == null)
{
logger.Warn("Can't find material with specified index (" + mesh.MaterialIndex + "). Probably you're missing textures or using non-diffuse materials only for this mesh.");
continue;
}
// Assimp's mesh is our IOSubmesh so we import meshes with just one submesh
var newMesh = new IOMesh(mesh.Name);
var newSubmesh = new IOSubmesh(material);
newMesh.Submeshes.Add(material, newSubmesh);
bool hasColors = _settings.UseVertexColor && mesh.VertexColorChannelCount > 0 && mesh.HasVertexColors(0);
bool hasNormals = mesh.HasNormals;
// Additional integrity checks
if ((mesh.VertexCount != mesh.TextureCoordinateChannels[0].Count) ||
(hasColors && mesh.VertexCount != mesh.VertexColorChannels[0].Count) ||
(hasNormals && mesh.VertexCount != mesh.Normals.Count))
{
logger.Warn("Mesh \"" + (mesh.Name ?? "") + "\" data structure is inconsistent.");
continue;
}
// Source data
var positions = mesh.Vertices;
var normals = mesh.Normals;
var texCoords = mesh.TextureCoordinateChannels[0];
var colors = mesh.VertexColorChannels[0];
for (int i = 0; i < mesh.VertexCount; i++)
{
// Create position
var position = new Vector3(positions[i].X, positions[i].Y, positions[i].Z);
position = ApplyAxesTransforms(position);
newMesh.Positions.Add(position);
// Create normal
if (hasNormals)
{
var normal = new Vector3(normals[i].X, normals[i].Y, normals[i].Z);
normal = ApplyAxesTransforms(normal);
newMesh.Normals.Add(normal);
}
else
{
newMesh.CalculateNormals();
}
// Create UV
var currentUV = new Vector2(texCoords[i].X, texCoords[i].Y);
if (faceTexture != null)
{
currentUV = ApplyUVTransform(currentUV, faceTexture.Image.Width, faceTexture.Image.Height);
}
newMesh.UV.Add(currentUV);
// Create colors
if (hasColors)
{
var color = ApplyColorTransform(new Vector4(colors[i].R, colors[i].G, colors[i].B, colors[i].A));
newMesh.Colors.Add(color);
}
}
// Add polygons
foreach (var face in mesh.Faces)
{
if (face.IndexCount == 3)
{
var poly = new IOPolygon(IOPolygonShape.Triangle);
poly.Indices.Add(lastBaseVertex + face.Indices[0]);
poly.Indices.Add(lastBaseVertex + face.Indices[1]);
poly.Indices.Add(lastBaseVertex + face.Indices[2]);
if (_settings.InvertFaces)
{
poly.Indices.Reverse();
}
newSubmesh.Polygons.Add(poly);
}
else if (face.IndexCount == 4)
{
var poly = new IOPolygon(IOPolygonShape.Quad);
poly.Indices.Add(lastBaseVertex + face.Indices[0]);
poly.Indices.Add(lastBaseVertex + face.Indices[1]);
poly.Indices.Add(lastBaseVertex + face.Indices[2]);
poly.Indices.Add(lastBaseVertex + face.Indices[3]);
if (_settings.InvertFaces)
{
poly.Indices.Reverse();
}
newSubmesh.Polygons.Add(poly);
}
}
tmpList.Add(newMesh);
}
// Sort meshes by name, if specified
if (_settings.SortByName)
{
tmpList = tmpList.OrderBy(m => m.Name, new CustomComparer <string>(NaturalComparer.Do)).ToList();
}
foreach (var mesh in tmpList)
{
newModel.Meshes.Add(mesh);
}
}
if (_settings.ProcessAnimations &&
scene.HasAnimations && scene.AnimationCount > 0)
{
// Find all mesh nodes to count against animation nodes
var meshNameList = CollectMeshNodeNames(scene.RootNode);
// Sort animations by name, if specified
if (_settings.SortByName)
{
meshNameList = meshNameList.OrderBy(s => s, new CustomComparer <string>(NaturalComparer.Do)).ToList();
}
// Loop through all animations and add appropriate ones.
// Integrity check: there should be meshes and mesh count should be equal to unique mesh name count.
if (scene.MeshCount <= 0 || scene.MeshCount != meshNameList.Count)
{
logger.Warn("Actual number of meshes doesn't correspond to mesh list. Animations won't be imported.");
}
else
{
for (int i = 0; i < scene.AnimationCount; i++)
{
var anim = scene.Animations[i];
// Integrity check: support only time-based node animations
if (!anim.HasNodeAnimations || anim.DurationInTicks <= 0)
{
logger.Warn("Anim " + i + " isn't a valid type of animation for TR formats.");
continue;
}
// Guess possible maximum frame and time
var frameCount = 0;
double maximumTime = 0;
foreach (var node in anim.NodeAnimationChannels)
{
if (node.HasPositionKeys)
{
var maxNodeTime = node.PositionKeys.Max(key => key.Time);
maximumTime = maximumTime >= maxNodeTime ? maximumTime : maxNodeTime;
frameCount = frameCount >= node.PositionKeyCount ? frameCount : node.PositionKeyCount;
}
if (node.HasRotationKeys)
{
var maxNodeTime = node.RotationKeys.Max(key => key.Time);
maximumTime = maximumTime >= maxNodeTime ? maximumTime : maxNodeTime;
frameCount = frameCount >= node.RotationKeyCount ? frameCount : node.RotationKeyCount;
}
}
// Calculate time multiplier
var timeMult = (double)(frameCount - 1) / anim.DurationInTicks;
// Integrity check: maximum frame time shouldn't excess duration
if (timeMult * maximumTime >= frameCount)
{
logger.Warn("Anim " + i + " has frames outside of time limits and won't be imported.");
continue;
}
IOAnimation ioAnim = new IOAnimation(string.IsNullOrEmpty(anim.Name) ? "Imported animation " + i : anim.Name,
scene.MeshCount);
// Precreate frames and set them to identity
for (int j = 0; j < frameCount; j++)
{
ioAnim.Frames.Add(new IOFrame());
}
// Precreate rotations and set them to identity
// I am using generic foreach here instead of linq foreach because for some reason it
// returns wrong amount of angles during enumeration with Enumerable.Repeat.
foreach (var frame in ioAnim.Frames)
{
var angleList = Enumerable.Repeat(Vector3.Zero, scene.MeshCount);
frame.Angles.AddRange(angleList);
}
// Search through all nodes and put data into corresponding frames.
// It's not clear what should we do in case if multiple nodes refer to same mesh, but sometimes
// it happens, e. g. in case of fbx format. In this case, we'll just add to existing values for now.
foreach (var chan in anim.NodeAnimationChannels)
{
// Look if this channel belongs to any mesh in list.
// If so, attribute it to appropriate frame.
var chanIndex = meshNameList.IndexOf(item => chan.NodeName.Contains(item));
// Integrity check: no appropriate mesh found
if (chanIndex < 0)
{
logger.Warn("Anim " + i + " channel " + chan.NodeName + " has no corresponding mesh in meshtree and will be ignored");
continue;
}
// Apply translation only if found channel belongs to root mesh.
if (chanIndex == 0 && chan.HasPositionKeys && chan.PositionKeyCount > 0)
{
foreach (var key in chan.PositionKeys)
{
// Integrity check: frame shouldn't fall out of keyframe array bounds.
var frameIndex = (int)Math.Round(key.Time * timeMult, MidpointRounding.AwayFromZero);
if (frameIndex >= frameCount)
{
logger.Warn("Anim " + i + " channel " + chan.NodeName + " has a key outside of time limits and will be ignored.");
continue;
}
float rX = key.Value.X;
float rY = key.Value.Y;
float rZ = key.Value.Z;
if (_settings.SwapXY)
{
var temp = rX; rX = rY; rY = temp;
}
if (_settings.SwapXZ)
{
var temp = rX; rX = rZ; rZ = temp;
}
if (_settings.SwapYZ)
{
var temp = rY; rY = rZ; rZ = temp;
}
if (_settings.FlipX)
{
rX = -rX;
}
if (_settings.FlipY)
{
rY = -rY;
}
if (_settings.FlipZ)
{
rZ = -rZ;
}
ioAnim.Frames[frameIndex].Offset += new Vector3(rX, rY, rZ);
}
}
if (chan.HasRotationKeys && chan.RotationKeyCount > 0)
{
foreach (var key in chan.RotationKeys)
{
// Integrity check: frame shouldn't fall out of keyframe array bounds.
var frameIndex = (int)Math.Round(key.Time * timeMult, MidpointRounding.AwayFromZero);
if (frameIndex >= frameCount)
{
logger.Warn("Anim " + i + " channel " + chan.NodeName + " has a key outside of time limits and will be ignored.");
continue;
}
// Convert quaternions back to rotations.
// This is similar to TRViewer's conversion routine.
var quatI = System.Numerics.Quaternion.Identity;
var quat = new System.Numerics.Quaternion(key.Value.X,
key.Value.Z,
key.Value.Y,
-key.Value.W);
quatI *= quat;
var eulers = MathC.QuaternionToEuler(quatI);
var rotation = new Vector3(eulers.X * 180.0f / (float)Math.PI,
eulers.Y * 180.0f / (float)Math.PI,
eulers.Z * 180.0f / (float)Math.PI);
ioAnim.Frames[frameIndex].Angles[chanIndex] += MathC.NormalizeAngle(rotation);
}
}
}
newModel.Animations.Add(ioAnim);
}
}
}
return(newModel);
}
