public void CreateOneKey()
{
var node = new Scenes.NodeBuilder("someNode");
var tb = node.UseTranslation().UseTrackBuilder("track1");
tb.SetPoint(0, new Vector3(1, 2, 3));
var scene = new Scenes.SceneBuilder();
scene.AddNode(node);
var glTF = scene.ToGltf2();
var options = new Runtime.RuntimeOptions {
IsolateMemory = true
};
var runtime = Runtime.SceneTemplate.Create(glTF.DefaultScene, options);
var instance = runtime.CreateInstance();
var instanceNode = instance.Armature.LogicalNodes.First(n => n.Name == "someNode");
instanceNode.SetAnimationFrame(0, 7);
var nodeMatrix = instanceNode.LocalMatrix;
Assert.AreEqual(new Vector3(1, 2, 3), nodeMatrix.Translation);
}
public static MonoGameDeviceContent <MonoGameModelTemplate> CreateDeviceModel(GraphicsDevice device, Schema2.ModelRoot srcModel, LoaderContext context = null)
{
if (context == null)
{
context = new BasicEffectsLoaderContext(device);
}
context.Reset();
var options = new Runtime.RuntimeOptions {
IsolateMemory = true
};
var templates = srcModel.LogicalScenes
.Select(item => SceneTemplate.Create(item, options))
.ToArray();
var srcMeshes = templates
.SelectMany(item => item.LogicalMeshIds)
.Distinct()
.Select(idx => srcModel.LogicalMeshes[idx]);
foreach (var srcMesh in srcMeshes)
{
context._WriteMesh(srcMesh);
}
var dstMeshes = context.CreateRuntimeModels();
var mdl = new MonoGameModelTemplate(templates, srcModel.DefaultScene.LogicalIndex, dstMeshes);
return(new MonoGameDeviceContent <MonoGameModelTemplate>(mdl, context.Disposables.ToArray()));
}
private static (SceneTemplate, WeakReference <Schema2.ModelRoot>) LoadModelTemplate(string path)
{
var model = Schema2.ModelRoot.Load(path);
var options = new Runtime.RuntimeOptions {
IsolateMemory = true
};
var template = SceneTemplate.Create(model.DefaultScene, options);
return(template, new WeakReference <Schema2.ModelRoot>(model));
}
public static MeshBuilder <Materials.MaterialBuilder, TvG, TvM, VertexEmpty> ToStaticMeshBuilder <TvG, TvM>(this Scene srcScene, Runtime.RuntimeOptions options, Animation animation, float time)
where TvG : struct, IVertexGeometry
where TvM : struct, IVertexMaterial
{
var materials = new Dictionary <Material, Materials.MaterialBuilder>();
Materials.MaterialBuilder convertMaterial(Material srcMaterial)
{
if (materials.TryGetValue(srcMaterial, out Materials.MaterialBuilder dstMaterial))
{
return(dstMaterial);
}
dstMaterial = new Materials.MaterialBuilder();
srcMaterial.CopyTo(dstMaterial);
// if we find an exiting match, we will use it instead.
var oldMaterial = materials.Values.FirstOrDefault(item => Materials.MaterialBuilder.AreEqualByContent(dstMaterial, item));
if (oldMaterial != null)
{
dstMaterial = oldMaterial;
}
return(materials[srcMaterial] = dstMaterial);
}
return(srcScene.ToStaticMeshBuilder <Materials.MaterialBuilder, TvG, TvM>(convertMaterial, options, animation, time));
}
/// <summary>
/// Evaluates the current <paramref name="srcScene"/> at a given <paramref name="animation"/> and <paramref name="time"/>
/// and creates a static <see cref="MeshBuilder{TMaterial, TvG, TvM, TvS}"/>
/// </summary>
/// <typeparam name="TMaterial">Any material type</typeparam>
/// <typeparam name="TvG">A subtype of <see cref="IVertexGeometry"/></typeparam>
/// <typeparam name="TvM">A subtype of <see cref="IVertexMaterial"/></typeparam>
/// <param name="srcScene">The source <see cref="Scene"/> to evaluate.</param>
/// <param name="materialFunc">A function to convert <see cref="Material"/> into <typeparamref name="TMaterial"/>.</param>
/// <param name="options">Evaluation options.</param>
/// <param name="animation">The source <see cref="Animation"/> to evaluate.</param>
/// <param name="time">A time point, in seconds, within <paramref name="animation"/>.</param>
/// <returns>A new <see cref="MeshBuilder{TMaterial, TvG, TvM, TvS}"/> containing the evaluated geometry.</returns>
public static MeshBuilder <TMaterial, TvG, TvM, VertexEmpty> ToStaticMeshBuilder <TMaterial, TvG, TvM>(this Scene srcScene, Converter <Material, TMaterial> materialFunc, Runtime.RuntimeOptions options, Animation animation, float time)
where TvG : struct, IVertexGeometry
where TvM : struct, IVertexMaterial
{
var mesh = new MeshBuilder <TMaterial, TvG, TvM, VertexEmpty>();
if (srcScene == null)
{
return(mesh);
}
if (animation != null)
{
Guard.MustShareLogicalParent(srcScene, animation, nameof(animation));
}
Guard.NotNull(materialFunc, nameof(materialFunc));
foreach (var tri in srcScene.EvaluateTriangles <VertexPositionNormal, VertexColor1Texture1>(options, animation, time))
{
var material = materialFunc(tri.Material);
mesh.UsePrimitive(material).AddTriangle(tri.A, tri.B, tri.C);
}
return(mesh);
}
