public void convert(string name, ParameterParser args, Stream from, Stream to)
{
var obj = SkeletalAnimation.ReadNew(from);
byte[] buffer = Encoding.Default.GetBytes(Utils.convertToJSON(obj));
to.Write(buffer, 0, buffer.Length);
}
public void read()
{
MemoryStream stream = new MemoryStream(sampleData, false);
SkeletalAnimation ani = SkeletalAnimation.ReadNew(stream);
testAnimation(ani);
}
/// <summary>
/// Bind the material, this will call BeginInstance on the backend
/// It is up to the caller to call EndInstance
/// </summary>
/// <param name="backend"></param>
/// <param name="world"></param>
/// <param name="worldView"></param>
/// <param name="itWorldView"></param>
/// <param name="modelViewProjection"></param>
public void BindPerObject(Backend backend, ref Matrix4 world, ref Matrix4 worldView, ref Matrix4 itWorld, ref Matrix4 modelViewProjection, SkeletalAnimation.SkeletonInstance skeleton)
{
backend.BindShaderVariable(Handles.ModelViewProjection, ref modelViewProjection);
backend.BindShaderVariable(Handles.World, ref world);
backend.BindShaderVariable(Handles.WorldView, ref worldView);
backend.BindShaderVariable(Handles.ItWorld, ref itWorld);
if (skeleton != null)
{
backend.BindShaderVariable(Handles.Bones, ref skeleton.FinalBoneTransforms);
}
}
public void write()
{
MemoryStream readStream = new MemoryStream(sampleData, false);
SkeletalAnimation ani = SkeletalAnimation.ReadNew(readStream);
MemoryStream writeStream = new MemoryStream();
ani.Write(writeStream);
MemoryStream rereadStream = new MemoryStream(writeStream.ToArray(), false);
SkeletalAnimation rereadAni = SkeletalAnimation.ReadNew(rereadStream);
testAnimation(rereadAni);
}
private void testAnimation(SkeletalAnimation ani)
{
Assert.NotNull(ani);
Assert.AreEqual(4, ani.flags);
Assert.AreEqual(3.0f, ani.duration, TOLERANCE);
Assert.AreEqual(3, ani.BoneCount);
Assert.AreEqual(3, ani.boneFrames.Length);
Assert.AreEqual(3, ani.boneFrames[0].Length);
Assert.AreEqual(1.0f, ani.boneFrames[0][0].rot.X, TOLERANCE);
Assert.AreEqual(2.0f, ani.boneFrames[0][0].rot.Y, TOLERANCE);
Assert.AreEqual(3.0f, ani.boneFrames[0][0].rot.Z, TOLERANCE);
Assert.AreEqual(4.0f, ani.boneFrames[0][0].rot.W, TOLERANCE);
Assert.AreEqual(5.0f, ani.boneFrames[0][0].pos.X, TOLERANCE);
Assert.AreEqual(6.0f, ani.boneFrames[0][0].pos.Y, TOLERANCE);
Assert.AreEqual(7.0f, ani.boneFrames[0][0].pos.Z, TOLERANCE);
Assert.AreEqual(0.0f, ani.boneFrames[0][0].time, TOLERANCE);
testNullKeyFrame(ani.boneFrames[0][1]);
Assert.AreEqual(1.0f, ani.boneFrames[0][1].time, TOLERANCE);
testNullKeyFrame(ani.boneFrames[0][2]);
Assert.AreEqual(2.0f, ani.boneFrames[0][2].time, TOLERANCE);
Assert.AreEqual(2, ani.boneFrames[1].Length);
testNullKeyFrame(ani.boneFrames[1][0]);
Assert.AreEqual(0.0f, ani.boneFrames[1][0].time, TOLERANCE);
Assert.AreEqual(8.0f, ani.boneFrames[1][1].rot.X, TOLERANCE);
Assert.AreEqual(9.0f, ani.boneFrames[1][1].rot.Y, TOLERANCE);
Assert.AreEqual(10.0f, ani.boneFrames[1][1].rot.Z, TOLERANCE);
Assert.AreEqual(11.0f, ani.boneFrames[1][1].rot.W, TOLERANCE);
Assert.AreEqual(12.0f, ani.boneFrames[1][1].pos.X, TOLERANCE);
Assert.AreEqual(13.0f, ani.boneFrames[1][1].pos.Y, TOLERANCE);
Assert.AreEqual(14.0f, ani.boneFrames[1][1].pos.Z, TOLERANCE);
Assert.AreEqual(1.5, ani.boneFrames[1][1].time);
Assert.AreEqual(1, ani.boneFrames[2].Length);
testNullKeyFrame(ani.boneFrames[2][0]);
Assert.AreEqual(0.0f, ani.boneFrames[2][0].time, TOLERANCE);
}
public Model(Renderer Renderer, H3DModel BaseModel)
{
this.Renderer = Renderer;
this.BaseModel = BaseModel;
Meshes0 = new List <Mesh>();
Meshes1 = new List <Mesh>();
Meshes2 = new List <Mesh>();
Meshes3 = new List <Mesh>();
Shaders = new List <Shader>();
ShaderHashes = new Dictionary <int, int>();
InverseTransforms = new Matrix4[BaseModel.Skeleton.Count];
for (int Bone = 0; Bone < BaseModel.Skeleton.Count; Bone++)
{
InverseTransforms[Bone] = BaseModel.Skeleton[Bone].InverseTransform.ToMatrix4();
}
UpdateShaders();
AddMeshes(Meshes0, BaseModel.MeshesLayer0);
AddMeshes(Meshes1, BaseModel.MeshesLayer1);
AddMeshes(Meshes2, BaseModel.MeshesLayer2);
AddMeshes(Meshes3, BaseModel.MeshesLayer3);
SkeletalAnim = new SkeletalAnimation(BaseModel.Skeleton);
MaterialAnim = new MaterialAnimation(BaseModel.Materials);
VisibilityAnim = new VisibilityAnimation(
BaseModel.MeshNodesTree,
BaseModel.MeshNodesVisibility);
Transform = Matrix4.Identity;
UpdateAnimationTransforms();
}
protected override void RenderImGui()
{
if (ImGui.BeginMenuBar())
{
ImGui.PushStyleColor(ImGuiCol.Button, new Vector4(0.3f, 0.3f, 0.3f, 1f));
if (ImGui.Button("Open OBJ"))
{
var explorer = new FileExplorer <ObjMeshAsset>(asset => { DisplayObject.Entity = asset.Entity; });
_toolsRoot.AddLegacyWindow(explorer);
}
if (ImGui.Button("Open EM3"))
{
var explorer = new FileExplorer <EmotionMeshAsset>(asset => { DisplayObject.Entity = asset.Entity; });
_toolsRoot.AddLegacyWindow(explorer);
}
if (ImGui.Button("Open Sprite Stack Texture"))
{
var explorer = new FileExplorer <SpriteStackTexture>(asset =>
{
_toolsRoot.AddLegacyWindow(new Vec2Modal(size =>
{
MeshEntity entity = asset.GetSpriteStackEntity(size);
DisplayObject.Entity = entity;
}, "Sprite Stack Settings", "Individual Frame Size", new Vector2(32, 32)));
});
_toolsRoot.AddLegacyWindow(explorer);
}
ImGui.EndMenuBar();
}
ImGui.Checkbox("Show Terrain", ref _showTerrain);
Vector3 pos = DisplayObject.Position;
if (ImGui.DragFloat3("Position", ref pos))
{
DisplayObject.Position = pos;
}
float scale = DisplayObject.Scale;
if (ImGui.DragFloat("Scale", ref scale))
{
DisplayObject.Scale = scale;
}
Vector3 rot = DisplayObject.RotationDeg;
if (ImGui.DragFloat3("Rotation", ref rot))
{
DisplayObject.RotationDeg = rot;
}
if (DisplayObject.Entity != null && DisplayObject.Entity.Animations != null && ImGui.BeginCombo("Animation", DisplayObject.CurrentAnimation))
{
if (ImGui.Button("None"))
{
DisplayObject.SetAnimation(null);
}
for (var i = 0; i < DisplayObject.Entity.Animations.Length; i++)
{
SkeletalAnimation anim = DisplayObject.Entity.Animations[i];
if (ImGui.Button($"{anim.Name}"))
{
DisplayObject.SetAnimation(anim.Name);
}
}
ImGui.EndCombo();
}
}
