public Material_AlphaBlend(List <string> imageList)
{
var baseColorTexture = new Texture {
Source = UseTexture(imageList, "BaseColor_Plane")
};
// Track the common properties for use in the readme.
CommonProperties.Add(new Property(PropertyName.AlphaMode, MaterialAlphaMode.Blend.ToReadmeString()));
Model CreateModel(Action <List <Property>, Runtime.MeshPrimitive, PbrMetallicRoughness> setProperties)
{
var properties = new List <Property>();
Runtime.MeshPrimitive meshPrimitive = MeshPrimitive.CreateSinglePlane(includeTextureCoords: false);
// Apply the common properties to the gltf.
meshPrimitive.Material = new Runtime.Material
{
PbrMetallicRoughness = new PbrMetallicRoughness
{
MetallicFactor = 0
},
AlphaMode = MaterialAlphaMode.Blend,
};
// Apply the properties that are specific to this gltf.
setProperties(properties, meshPrimitive, meshPrimitive.Material.PbrMetallicRoughness);
// Create the gltf object.
return(new Model
{
Properties = properties,
GLTF = CreateGLTF(() => new Scene
{
Nodes = new[]
{
new Node
{
Mesh = new Runtime.Mesh
{
MeshPrimitives = new[]
{
meshPrimitive
}
},
},
},
}),
});
}
void SetNoMetallicRoughness(List <Property> properties, Runtime.MeshPrimitive meshPrimitive)
{
meshPrimitive.Material.PbrMetallicRoughness = null;
}
void SetBaseColorFactor(List <Property> properties, PbrMetallicRoughness metallicRoughness)
{
var baseColorFactorValue = new Vector4(1.0f, 1.0f, 1.0f, 0.7f);
metallicRoughness.BaseColorFactor = baseColorFactorValue;
properties.Add(new Property(PropertyName.BaseColorFactor, baseColorFactorValue.ToReadmeString()));
}
void SetBaseColorTexture(List <Property> properties, PbrMetallicRoughness metallicRoughness)
{
metallicRoughness.BaseColorTexture = new TextureInfo {
Texture = baseColorTexture
};
properties.Add(new Property(PropertyName.BaseColorTexture, baseColorTexture.Source.ToReadmeString()));
}
void SetVertexColor(List <Property> properties, Runtime.MeshPrimitive meshPrimitive)
{
meshPrimitive.Colors = Data.Create
(
new[]
{
new Vector4(0.3f, 0.3f, 0.3f, 0.4f),
new Vector4(0.3f, 0.3f, 0.3f, 0.2f),
new Vector4(0.3f, 0.3f, 0.3f, 0.8f),
new Vector4(0.3f, 0.3f, 0.3f, 0.6f),
}
);
properties.Add(new Property(PropertyName.VertexColor, $"Vector4 Float"));
}
Models = new List <Model>
{
CreateModel((properties, meshPrimitive, metallicRoughness) =>
{
SetVertexColor(properties, meshPrimitive);
SetNoMetallicRoughness(properties, meshPrimitive);
}),
CreateModel((properties, meshPrimitive, metallicRoughness) =>
{
meshPrimitive.TexCoords0 = Data.Create(MeshPrimitive.GetSinglePlaneTexCoords());
SetBaseColorTexture(properties, metallicRoughness);
}),
CreateModel((properties, meshPrimitive, metallicRoughness) =>
{
SetBaseColorFactor(properties, metallicRoughness);
}),
CreateModel((properties, meshPrimitive, metallicRoughness) =>
{
meshPrimitive.TexCoords0 = Data.Create(MeshPrimitive.GetSinglePlaneTexCoords());
SetVertexColor(properties, meshPrimitive);
SetBaseColorTexture(properties, metallicRoughness);
}),
CreateModel((properties, meshPrimitive, metallicRoughness) =>
{
SetVertexColor(properties, meshPrimitive);
SetBaseColorFactor(properties, metallicRoughness);
}),
CreateModel((properties, meshPrimitive, metallicRoughness) =>
{
meshPrimitive.TexCoords0 = Data.Create(MeshPrimitive.GetSinglePlaneTexCoords());
SetBaseColorTexture(properties, metallicRoughness);
SetBaseColorFactor(properties, metallicRoughness);
}),
CreateModel((properties, meshPrimitive, metallicRoughness) =>
{
meshPrimitive.TexCoords0 = Data.Create(MeshPrimitive.GetSinglePlaneTexCoords());
SetVertexColor(properties, meshPrimitive);
SetBaseColorTexture(properties, metallicRoughness);
SetBaseColorFactor(properties, metallicRoughness);
}),
};
GenerateUsedPropertiesList();
}
public Compatibility(List <string> imageList)
{
NoSampleImages = true;
// There are no common properties in this model group.
Model CreateModel(Action <List <Property>, Asset, List <string>, List <string>, Runtime.MeshPrimitive> setProperties,
Action <Schema.Gltf> postRuntimeChanges = null, Dictionary <Type, Type> schemaTypeMapping = null, bool?setLoadableTag = true)
{
var properties = new List <Property>();
var gltf = CreateGLTF(() => new Scene());
Runtime.MeshPrimitive meshPrimitive = MeshPrimitive.CreateSinglePlane(includeTextureCoords: false);
var extensionsUsed = new List <string>();
var extensionsRequired = new List <string>();
// Apply the properties that are specific to this gltf.
setProperties(properties, gltf.Asset, extensionsUsed, extensionsRequired, meshPrimitive);
// Create the gltf object.
if (extensionsUsed.Any())
{
gltf.ExtensionsUsed = extensionsUsed;
}
if (extensionsRequired.Any())
{
gltf.ExtensionsRequired = extensionsRequired;
}
gltf.Scenes.First().Nodes = new List <Node>
{
new Node
{
Mesh = new Runtime.Mesh
{
MeshPrimitives = new List <Runtime.MeshPrimitive>
{
meshPrimitive
}
},
},
};
var model = new Model
{
Properties = properties,
GLTF = gltf
};
model.Loadable = setLoadableTag;
model.PostRuntimeChanges = postRuntimeChanges;
if (schemaTypeMapping != null)
{
model.CreateSchemaInstance = type =>
{
if (schemaTypeMapping.TryGetValue(type, out Type mappedType))
{
type = mappedType;
}
return(Activator.CreateInstance(type));
};
}
return(model);
}
Property SetMinVersion(Asset asset)
{
return(new Property(PropertyName.MinVersion, asset.MinVersion = "2.1"));
}
Property SetVersionCurrent(Asset asset)
{
return(new Property(PropertyName.Version, asset.Version = "2.0"));
}
Property SetVersionFuture(Asset asset)
{
return(new Property(PropertyName.Version, asset.Version = "2.1"));
}
void SetPostRuntimeAtRoot(Schema.Gltf gltf)
{
// Add an simulated feature at the root level.
var experimentalGltf = (ExperimentalGltf)gltf;
experimentalGltf.Lights = new[]
{
new ExperimentalLight
{
Color = new[] { 0.3f, 0.4f, 0.5f }
}
};
}
void SetPostRuntimeInProperty(Schema.Gltf gltf)
{
// Add an simulated feature into an existing property.
var experimentalNode = (ExperimentalNode)gltf.Nodes[0];
experimentalNode.Light = 0;
}
void SetPostRuntimeWithFallback(Schema.Gltf gltf)
{
// Add an simulated feature with a fallback option.
gltf.Materials = new Schema.Material[]
{
new ExperimentalMaterial
{
AlphaMode = Schema.Material.AlphaModeEnum.BLEND,
AlphaMode2 = ExperimentalAlphaMode2.QUANTUM,
}
};
}
var experimentalSchemaTypeMapping = new Dictionary <Type, Type>
{
{ typeof(Schema.Gltf), typeof(ExperimentalGltf) },
{ typeof(Schema.Node), typeof(ExperimentalNode) },
{ typeof(Schema.Material), typeof(ExperimentalMaterial) },
};
var shouldLoad = ":white_check_mark:";
Models = new List <Model>
{
CreateModel((properties, asset, extensionsUsed, extensionsRequired, meshPrimitive) =>
{
properties.Add(SetVersionCurrent(asset));
properties.Add(new Property(PropertyName.ModelShouldLoad, shouldLoad));
}),
CreateModel((properties, asset, extensionsUsed, extensionsRequired, meshPrimitive) =>
{
properties.Add(SetVersionFuture(asset));
properties.Add(new Property(PropertyName.Description, "Light object added at root"));
properties.Add(new Property(PropertyName.ModelShouldLoad, shouldLoad));
}, SetPostRuntimeAtRoot, experimentalSchemaTypeMapping),
CreateModel((properties, asset, extensionsUsed, extensionsRequired, meshPrimitive) =>
{
properties.Add(SetVersionFuture(asset));
properties.Add(new Property(PropertyName.Description, "Light property added to node object"));
properties.Add(new Property(PropertyName.ModelShouldLoad, shouldLoad));
}, SetPostRuntimeInProperty, experimentalSchemaTypeMapping),
CreateModel((properties, asset, extensionsUsed, extensionsRequired, meshPrimitive) =>
{
properties.Add(SetVersionFuture(asset));
properties.Add(new Property(PropertyName.Description, "Alpha mode updated with a new enum value, and a fallback value"));
properties.Add(new Property(PropertyName.ModelShouldLoad, shouldLoad));
}, SetPostRuntimeWithFallback, experimentalSchemaTypeMapping),
CreateModel((properties, asset, extensionsUsed, extensionsRequired, meshPrimitive) =>
{
properties.Add(SetMinVersion(asset));
properties.Add(SetVersionFuture(asset));
properties.Add(new Property(PropertyName.Description, "Requires a specific version or higher"));
properties.Add(new Property(PropertyName.ModelShouldLoad, "Only in version 2.1 or higher"));
}, null, null, setLoadableTag: false),
CreateModel((properties, asset, extensionsUsed, extensionsRequired, meshPrimitive) =>
{
properties.Add(SetVersionCurrent(asset));
var emptyTexture = new Texture();
var extension = new FAKE_materials_quantumRendering
{
PlanckFactor = new Vector4(0.2f, 0.2f, 0.2f, 0.8f),
CopenhagenTexture = new TextureInfo
{
Texture = emptyTexture
},
EntanglementFactor = new Vector3(0.4f, 0.4f, 0.4f),
ProbabilisticFactor = 0.3f,
SuperpositionCollapseTexture = new TextureInfo
{
Texture = emptyTexture
},
};
meshPrimitive.Material = new Runtime.Material
{
Extensions = new List <Extension>
{
extension
}
};
extensionsUsed.Add(extension.Name);
extensionsRequired.Add(extension.Name);
properties.Add(new Property(PropertyName.Description, "Extension required"));
properties.Add(new Property(PropertyName.ModelShouldLoad, ":x:"));
}, null, null, setLoadableTag: false),
CreateModel((properties, asset, extensionsUsed, extensionsRequired, meshPrimitive) =>
{
properties.Add(SetVersionCurrent(asset));
var extension = new KHR_materials_pbrSpecularGlossiness
{
SpecularFactor = new Vector3(0.04f, 0.04f, 0.04f),
GlossinessFactor = 0.0f,
};
meshPrimitive.Material = new Runtime.Material
{
// Metallic-Roughness
PbrMetallicRoughness = new PbrMetallicRoughness
{
MetallicFactor = 0.0f
},
// Specular-Glossiness
Extensions = new[] { extension },
};
extensionsUsed.Add(extension.Name);
properties.Add(new Property(PropertyName.Description, "Specular Glossiness extension used but not required"));
properties.Add(new Property(PropertyName.ModelShouldLoad, shouldLoad));
}),
};
GenerateUsedPropertiesList();
}
public Runtime.GLTF SetModelAttributes(Runtime.GLTF wrapper, Runtime.Material material, List <Property> combo, ref glTFLoader.Schema.Gltf gltf)
{
// Determines which of the primitives will have the material and attributes applied to it
var splitType = combo.Find(e => e.propertyGroup == 1);
foreach (Property property in combo)
{
if (property.name == Propertyname.Primitives_Split1 ||
property.name == Propertyname.Primitives_Split2 ||
property.name == Propertyname.Primitives_Split3 ||
property.name == Propertyname.Primitives_Split4)
{
// Same plane, but split into two triangle primitives
var primitive0 = specialProperties.Find(e => e.name == Propertyname.Primitive_0);
var primitive1 = specialProperties.Find(e => e.name == Propertyname.Primitive_1);
Runtime.MeshPrimitive prim0 = new Runtime.MeshPrimitive
{
Positions = primitive0.value.Positions,
Indices = primitive0.value.Indices,
};
Runtime.MeshPrimitive prim1 = new Runtime.MeshPrimitive
{
Positions = primitive1.value.Positions,
Indices = primitive1.value.Indices,
};
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives = new List <Runtime.MeshPrimitive>
{
prim0,
prim1
};
}
if (property.name == Propertyname.BaseColorTexture)
{
if (material.MetallicRoughnessMaterial == null)
{
material.MetallicRoughnessMaterial = new Runtime.PbrMetallicRoughness();
material.MetallicRoughnessMaterial.BaseColorTexture = new Runtime.Texture();
}
material.MetallicRoughnessMaterial.BaseColorTexture.Source = property.value;
material.MetallicRoughnessMaterial.BaseColorTexture.TexCoordIndex = 0;
}
if (property.name == Propertyname.NormalTexture)
{
if (material.NormalTexture == null)
{
material.NormalTexture = new Runtime.Texture();
}
material.NormalTexture.Source = property.value;
material.NormalTexture.TexCoordIndex = 0;
}
// Attributes set for only the first primitive
if (splitType.name == Propertyname.Primitives_Split1)
{
if (property.name == Propertyname.VertexNormal)
{
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].Normals = property.value;
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].Normals = null;
}
else if (property.name == Propertyname.VertexTangent)
{
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].Tangents = property.value;
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].Tangents = null;
}
else if (property.name == Propertyname.VertexColor_Vector4_Float)
{
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].Colors = property.value;
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].Colors = null;
}
else if (ReadmeStringHelper.GenerateNameWithSpaces(property.name.ToString()) ==
ReadmeStringHelper.GenerateNameWithSpaces(Propertyname.Primitive0VertexUV0.ToString())) // All UV0
{
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].TextureCoordSets = new List <List <Vector2> >();
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].TextureCoordSets = null;
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].TextureCoordSets.Add(
specialProperties.Find(e => e.name == Propertyname.Primitive0VertexUV0).value);
}
else if (ReadmeStringHelper.GenerateNameWithSpaces(property.name.ToString()) ==
ReadmeStringHelper.GenerateNameWithSpaces(Propertyname.Primitive0VertexUV1.ToString())) // All UV1
{
if (wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].TextureCoordSets == null)
{
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].TextureCoordSets = new List <List <Vector2> >();
}
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].TextureCoordSets.Add(
specialProperties.Find(e => e.name == Propertyname.Primitive0VertexUV1).value);
}
}
// Attributes set for only the second primitive
else if (splitType.name == Propertyname.Primitives_Split2)
{
if (property.name == Propertyname.VertexNormal)
{
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].Normals = null;
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].Normals = property.value;
}
else if (property.name == Propertyname.VertexTangent)
{
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].Tangents = null;
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].Tangents = property.value;
}
else if (property.name == Propertyname.VertexColor_Vector4_Float)
{
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].Colors = null;
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].Colors = property.value;
}
else if (ReadmeStringHelper.GenerateNameWithSpaces(property.name.ToString()) ==
ReadmeStringHelper.GenerateNameWithSpaces(Propertyname.Primitive1VertexUV0.ToString())) // All UV0
{
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].TextureCoordSets = null;
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].TextureCoordSets = new List <List <Vector2> >();
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].TextureCoordSets.Add(
specialProperties.Find(e => e.name == Propertyname.Primitive1VertexUV0).value);
}
else if (ReadmeStringHelper.GenerateNameWithSpaces(property.name.ToString()) ==
ReadmeStringHelper.GenerateNameWithSpaces(Propertyname.Primitive1VertexUV1.ToString())) // All UV1
{
if (wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].TextureCoordSets == null)
{
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].TextureCoordSets = new List <List <Vector2> >();
}
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].TextureCoordSets.Add(
specialProperties.Find(e => e.name == Propertyname.Primitive1VertexUV1).value);
}
}
// Attributes set for both of the primitives
else if (splitType.name == Propertyname.Primitives_Split3)
{
if (property.name == Propertyname.VertexNormal)
{
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].Normals = property.value;
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].Normals = property.value;
}
else if (property.name == Propertyname.VertexTangent)
{
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].Tangents = property.value;
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].Tangents = property.value;
}
else if (property.name == Propertyname.VertexColor_Vector4_Float)
{
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].Colors = property.value;
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].Colors = property.value;
}
else if (property.name == Propertyname.Primitive0VertexUV0)
{
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].TextureCoordSets = new List <List <Vector2> >();
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].TextureCoordSets.Add(
specialProperties.Find(e => e.name == Propertyname.Primitive0VertexUV0).value);
}
else if (property.name == Propertyname.Primitive1VertexUV0)
{
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].TextureCoordSets = new List <List <Vector2> >();
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].TextureCoordSets.Add(
specialProperties.Find(e => e.name == Propertyname.Primitive1VertexUV0).value);
}
else if (property.name == Propertyname.Primitive0VertexUV1)
{
if (wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].TextureCoordSets == null)
{
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].TextureCoordSets = new List <List <Vector2> >();
}
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].TextureCoordSets.Add(
specialProperties.Find(e => e.name == Propertyname.Primitive0VertexUV1).value);
}
else if (property.name == Propertyname.Primitive1VertexUV1)
{
if (wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].TextureCoordSets == null)
{
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].TextureCoordSets = new List <List <Vector2> >();
}
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].TextureCoordSets.Add(
specialProperties.Find(e => e.name == Propertyname.Primitive1VertexUV1).value);
}
}
// Attributes set for neither of the primitives
else if (splitType.name == Propertyname.Primitives_Split4)
{
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].Normals = null;
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].Normals = null;
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].Tangents = null;
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].Tangents = null;
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].Colors = null;
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].Colors = null;
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].TextureCoordSets = null;
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].TextureCoordSets = null;
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].TextureCoordSets = null;
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].TextureCoordSets = null;
}
}
// Material needs to be a deep copy here, or both primitives will get the same Mat.
if (material.MetallicRoughnessMaterial != null)
{
if (splitType.name == Propertyname.Primitives_Split1 ||
splitType.name == Propertyname.Primitives_Split3)
{
var mat = DeepCopy.CloneObject(material);
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].Material = mat;
}
if (splitType.name == Propertyname.Primitives_Split2 ||
splitType.name == Propertyname.Primitives_Split3)
{
var mat = DeepCopy.CloneObject(material);
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].Material = mat;
}
}
// Use the second UV if it has been set
if (splitType.name != Propertyname.Primitives_Split4)
{
var prim0UV1 = combo.Find(e => e.name == Propertyname.Primitive0VertexUV1);
var prim1UV1 = combo.Find(e => e.name == Propertyname.Primitive1VertexUV1);
if (prim0UV1 != null)
{
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].
Material.MetallicRoughnessMaterial.BaseColorTexture.TexCoordIndex = 1;
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].
Material.NormalTexture.TexCoordIndex = 1;
}
if (prim1UV1 != null)
{
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].
Material.MetallicRoughnessMaterial.BaseColorTexture.TexCoordIndex = 1;
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].
Material.NormalTexture.TexCoordIndex = 1;
}
}
return(wrapper);
}
public Mesh_PrimitivesUV(List <string> textures, List <string> figures) : base(textures, figures)
{
modelGroupName = ModelGroupName.Mesh_PrimitivesUV;
onlyBinaryProperties = false;
noPrerequisite = false;
Runtime.Image figureIndicesPrimitive0 = new Runtime.Image
{
Uri = figures.Find(e => e.Contains("Indices_Primitive0"))
};
Runtime.Image figureIndicesPrimitive1 = new Runtime.Image
{
Uri = figures.Find(e => e.Contains("Indices_Primitive1"))
};
Runtime.Image figureUVSpace2 = new Runtime.Image
{
Uri = figures.Find(e => e.Contains("UVSpace2"))
};
Runtime.Image figureUVSpace3 = new Runtime.Image
{
Uri = figures.Find(e => e.Contains("UVSpace3"))
};
Runtime.Image figureUVSpace4 = new Runtime.Image
{
Uri = figures.Find(e => e.Contains("UVSpace4"))
};
Runtime.Image figureUVSpace5 = new Runtime.Image
{
Uri = figures.Find(e => e.Contains("UVSpace5"))
};
Runtime.Image baseColorTexture = new Runtime.Image
{
Uri = textures.Find(e => e.Contains("BaseColor_Plane"))
};
Runtime.Image normalTexture = new Runtime.Image
{
Uri = textures.Find(e => e.Contains("Normal_Plane"))
};
usedTextures.Add(baseColorTexture);
usedTextures.Add(normalTexture);
usedFigures.Add(figureIndicesPrimitive0);
usedFigures.Add(figureIndicesPrimitive1);
usedFigures.Add(figureUVSpace2);
usedFigures.Add(figureUVSpace3);
usedFigures.Add(figureUVSpace4);
usedFigures.Add(figureUVSpace5);
List <Vector3> primitive0Positions = new List <Vector3>()
{
new Vector3(-0.5f, -0.5f, 0.0f),
new Vector3(0.5f, 0.5f, 0.0f),
new Vector3(-0.5f, 0.5f, 0.0f)
};
List <Vector3> primitive1Positions = new List <Vector3>()
{
new Vector3(-0.5f, -0.5f, 0.0f),
new Vector3(0.5f, -0.5f, 0.0f),
new Vector3(0.5f, 0.5f, 0.0f)
};
List <int> primitiveTriangleIndices = new List <int>
{
0, 1, 2,
};
Runtime.MeshPrimitive primitive0Mesh = new Runtime.MeshPrimitive
{
Positions = primitive0Positions,
Indices = primitiveTriangleIndices,
};
Runtime.MeshPrimitive primitive1Mesh = new Runtime.MeshPrimitive
{
Positions = primitive1Positions,
Indices = primitiveTriangleIndices,
};
List <Vector4> vertexColors = new List <Vector4>()
{
new Vector4(0.0f, 1.0f, 0.0f, 0.2f),
new Vector4(1.0f, 0.0f, 0.0f, 0.2f),
new Vector4(0.0f, 0.0f, 1.0f, 0.2f)
};
List <Vector3> normals = new List <Vector3>()
{
new Vector3(0.0f, 0.0f, 1.0f),
new Vector3(0.0f, 0.0f, 1.0f),
new Vector3(0.0f, 0.0f, 1.0f)
};
List <Vector4> tangents = new List <Vector4>()
{
new Vector4(1.0f, 0.0f, 0.0f, 1.0f),
new Vector4(1.0f, 0.0f, 0.0f, 1.0f),
new Vector4(1.0f, 0.0f, 0.0f, 1.0f)
};
List <Vector2> textureCoords0Prim0 = new List <Vector2>()
{
new Vector2(0.0f, 1.0f),
new Vector2(1.0f, 0.0f),
new Vector2(0.0f, 0.0f)
};
List <Vector2> textureCoords1Prim0 = new List <Vector2>()
{
new Vector2(0.5f, 0.5f),
new Vector2(1.0f, 0.0f),
new Vector2(0.5f, 0.0f)
};
List <Vector2> textureCoords0Prim2 = new List <Vector2>()
{
new Vector2(0.0f, 1.0f),
new Vector2(1.0f, 1.0f),
new Vector2(1.0f, 0.0f)
};
List <Vector2> textureCoords1Prim2 = new List <Vector2>()
{
new Vector2(0.5f, 0.5f),
new Vector2(1.0f, 0.5f),
new Vector2(1.0f, 0.0f)
};
requiredProperty = new List <Property>
{
new Property(Propertyname.VertexNormal, normals),
new Property(Propertyname.VertexTangent, tangents),
new Property(Propertyname.VertexColor_Vector4_Float, vertexColors),
new Property(Propertyname.NormalTexture, normalTexture),
new Property(Propertyname.BaseColorTexture, baseColorTexture),
};
properties = new List <Property>
{
new Property(Propertyname.Primitive0VertexUV0, ":white_check_mark:"),
new Property(Propertyname.Primitive0VertexUV1, ":white_check_mark:"),
new Property(Propertyname.Primitive1VertexUV0, ":white_check_mark:"),
new Property(Propertyname.Primitive1VertexUV1, ":white_check_mark:"),
};
specialProperties = new List <Property>
{
new Property(Propertyname.Primitives_Split4, "No attributes set", group: 1),
new Property(Propertyname.Primitives_Split3, "Attributes set on both", group: 1),
new Property(Propertyname.Primitives_Split1, "Primitive 0 attributes set", group: 1),
new Property(Propertyname.Primitives_Split2, "Primitive 1 attributes set", group: 1),
new Property(Propertyname.Primitive_0, primitive0Mesh),
new Property(Propertyname.Primitive_1, primitive1Mesh),
new Property(Propertyname.Primitive0VertexUV0, textureCoords0Prim0),
new Property(Propertyname.Primitive0VertexUV1, textureCoords1Prim0),
new Property(Propertyname.Primitive1VertexUV0, textureCoords0Prim2),
new Property(Propertyname.Primitive1VertexUV1, textureCoords1Prim2),
};
var normal = requiredProperty.Find(e => e.name == Propertyname.VertexNormal);
var normTex = requiredProperty.Find(e => e.name == Propertyname.NormalTexture);
var tangent = requiredProperty.Find(e => e.name == Propertyname.VertexTangent);
var color = requiredProperty.Find(e => e.name == Propertyname.VertexColor_Vector4_Float);
var uv0Prim0 = properties.Find(e => e.name == Propertyname.Primitive0VertexUV0);
var uv1Prim0 = properties.Find(e => e.name == Propertyname.Primitive0VertexUV1);
var uv0Prim1 = properties.Find(e => e.name == Propertyname.Primitive1VertexUV0);
var uv1Prim1 = properties.Find(e => e.name == Propertyname.Primitive1VertexUV1);
var pbrTexture = requiredProperty.Find(e => e.name == Propertyname.BaseColorTexture);
specialCombos.Add(new List <Property>()
{
uv0Prim0,
uv1Prim0,
uv0Prim1,
specialProperties[1], // Both attributes set
normal,
tangent,
color,
normTex,
pbrTexture
});
specialCombos.Add(new List <Property>()
{
uv0Prim0,
uv0Prim1,
uv1Prim1,
specialProperties[1], // Both attributes set
normal,
tangent,
color,
normTex,
pbrTexture
});
foreach (var property in properties)
{
removeCombos.Add(new List <Property>()
{
property,
});
}
foreach (var property in specialProperties)
{
if (property.propertyGroup == 1 &&
property.name != Propertyname.Primitives_Split4)
{
specialCombos.Add(new List <Property>()
{
uv0Prim0,
uv0Prim1,
property,
normal,
tangent,
color,
normTex,
pbrTexture
});
specialCombos.Add(new List <Property>()
{
uv0Prim0,
uv0Prim1,
uv1Prim0,
uv1Prim1,
property,
normal,
tangent,
color,
normTex,
pbrTexture
});
// Look at the last two special combos and remove UV 0/1 as appropriate
for (int x = specialCombos.Count - 2; x < specialCombos.Count; x++)
{
if (property.name == Propertyname.Primitives_Split1)
{
specialCombos[x].Remove(uv0Prim1);
specialCombos[x].Remove(uv1Prim1);
}
else if (property.name == Propertyname.Primitives_Split2)
{
specialCombos[x].Remove(uv0Prim0);
specialCombos[x].Remove(uv1Prim0);
}
}
}
}
}
public Mesh_PrimitiveMode(List <string> imageList)
{
UseFigure(imageList, "Indices");
UseFigure(imageList, "Indices_Points");
// There are no common properties in this model group that are reported in the readme.
Model CreateModel(Action <List <Property>, Runtime.MeshPrimitive> setProperties)
{
var properties = new List <Property>();
Runtime.MeshPrimitive meshPrimitive = MeshPrimitive.CreateSinglePlane(includeTextureCoords: false, includeIndices: false);
// Apply the properties that are specific to this gltf.
setProperties(properties, meshPrimitive);
meshPrimitive.Material = new Runtime.Material
{
PbrMetallicRoughness = new PbrMetallicRoughness
{
MetallicFactor = 0
},
};
// Create the gltf object.
return(new Model
{
Properties = properties,
GLTF = CreateGLTF(() => new Scene
{
Nodes = new List <Node>
{
new Node
{
Mesh = new Runtime.Mesh
{
MeshPrimitives = new List <Runtime.MeshPrimitive>
{
meshPrimitive
}
},
},
},
}),
});
}
void SetModePoints(List <Property> properties, Runtime.MeshPrimitive meshPrimitive)
{
var pointPositions = new List <Vector3>();
var cornerPoints = new[]
{
new Vector3(0.5f, -0.5f, 0.0f),
new Vector3(-0.5f, -0.5f, 0.0f),
new Vector3(-0.5f, 0.5f, 0.0f),
new Vector3(0.5f, 0.3f, 0.0f),
new Vector3(0.5f, -0.5f, 0.0f)
};
for (var corner = 0; corner < 4; corner++)
{
for (float x = 256; x > 0; x--)
{
Vector3 startPoint = cornerPoints[corner];
Vector3 endPoint = cornerPoints[corner + 1];
float fractionOfLine = x / 256f;
pointPositions.Add(GetPointOnLine(startPoint, endPoint, fractionOfLine));
}
}
meshPrimitive.Mode = MeshPrimitiveMode.Points;
meshPrimitive.Positions = Data.Create(pointPositions);
properties.Add(new Property(PropertyName.Mode, meshPrimitive.Mode.ToReadmeString()));
}
void SetModeLines(List <Property> properties, Runtime.MeshPrimitive meshPrimitive)
{
if (meshPrimitive.Indices == null)
{
meshPrimitive.Positions.Values = new[]
{
new Vector3(0.5f, -0.5f, 0.0f),
new Vector3(-0.5f, -0.5f, 0.0f),
new Vector3(-0.5f, -0.5f, 0.0f),
new Vector3(-0.5f, 0.5f, 0.0f),
new Vector3(-0.5f, 0.5f, 0.0f),
new Vector3(0.5f, 0.3f, 0.0f),
new Vector3(0.5f, 0.3f, 0.0f),
new Vector3(0.5f, -0.5f, 0.0f),
};
}
meshPrimitive.Mode = MeshPrimitiveMode.Lines;
properties.Add(new Property(PropertyName.Mode, meshPrimitive.Mode.ToReadmeString()));
}
void SetModeLineLoop(List <Property> properties, Runtime.MeshPrimitive meshPrimitive)
{
if (meshPrimitive.Indices == null)
{
meshPrimitive.Positions.Values = new[]
{
new Vector3(0.5f, -0.5f, 0.0f),
new Vector3(0.5f, 0.3f, 0.0f),
new Vector3(-0.5f, 0.5f, 0.0f),
new Vector3(-0.5f, -0.5f, 0.0f),
};
}
meshPrimitive.Mode = MeshPrimitiveMode.LineLoop;
properties.Add(new Property(PropertyName.Mode, meshPrimitive.Mode.ToReadmeString()));
}
void SetModeLineStrip(List <Property> properties, Runtime.MeshPrimitive meshPrimitive)
{
if (meshPrimitive.Indices == null)
{
meshPrimitive.Positions.Values = new[]
{
new Vector3(0.5f, -0.5f, 0.0f),
new Vector3(0.5f, 0.3f, 0.0f),
new Vector3(-0.5f, 0.5f, 0.0f),
new Vector3(-0.5f, -0.5f, 0.0f),
new Vector3(0.5f, -0.5f, 0.0f),
};
}
meshPrimitive.Mode = MeshPrimitiveMode.LineStrip;
properties.Add(new Property(PropertyName.Mode, meshPrimitive.Mode.ToReadmeString()));
}
void SetModeTriangleStrip(List <Property> properties, Runtime.MeshPrimitive meshPrimitive)
{
if (meshPrimitive.Indices == null)
{
meshPrimitive.Positions.Values = new[]
{
new Vector3(0.5f, -0.5f, 0.0f),
new Vector3(0.5f, 0.5f, 0.0f),
new Vector3(-0.5f, -0.5f, 0.0f),
new Vector3(-0.5f, 0.5f, 0.0f),
};
}
meshPrimitive.Mode = MeshPrimitiveMode.TriangleStrip;
properties.Add(new Property(PropertyName.Mode, meshPrimitive.Mode.ToReadmeString()));
}
void SetModeTriangleFan(List <Property> properties, Runtime.MeshPrimitive meshPrimitive)
{
if (meshPrimitive.Indices == null)
{
meshPrimitive.Positions.Values = new[]
{
new Vector3(0.5f, -0.5f, 0.0f),
new Vector3(0.5f, 0.5f, 0.0f),
new Vector3(-0.5f, 0.5f, 0.0f),
new Vector3(-0.5f, -0.5f, 0.0f),
};
}
meshPrimitive.Mode = MeshPrimitiveMode.TriangleFan;
properties.Add(new Property(PropertyName.Mode, meshPrimitive.Mode.ToReadmeString()));
}
void SetModeTriangles(List <Property> properties, Runtime.MeshPrimitive meshPrimitive)
{
if (meshPrimitive.Indices == null)
{
meshPrimitive.Positions.Values = new[]
{
new Vector3(-0.5f, -0.5f, 0.0f),
new Vector3(0.5f, -0.5f, 0.0f),
new Vector3(0.5f, 0.5f, 0.0f),
new Vector3(-0.5f, -0.5f, 0.0f),
new Vector3(0.5f, 0.5f, 0.0f),
new Vector3(-0.5f, 0.5f, 0.0f),
};
}
meshPrimitive.Mode = MeshPrimitiveMode.Triangles;
properties.Add(new Property(PropertyName.Mode, meshPrimitive.Mode.ToReadmeString()));
}
void SetIndicesPoints(List <Property> properties, Runtime.MeshPrimitive meshPrimitive)
{
var indices = new List <int>();
var count = meshPrimitive.Positions.Values.Count();
for (int index = 0; index < count; index++)
{
indices.Add(index);
}
meshPrimitive.Indices = Data.Create(indices);
properties.Add(new Property(PropertyName.IndicesValues, $"[0 - {count - 1}]"));
}
void SetIndicesLines(List <Property> properties, Runtime.MeshPrimitive meshPrimitive)
{
meshPrimitive.Positions.Values = GetSinglePlaneNonReversiblePositions();
meshPrimitive.Indices = Data.Create(new[]
{
0, 3,
3, 2,
2, 1,
1, 0,
});
properties.Add(new Property(PropertyName.IndicesValues, meshPrimitive.Indices.Values.ToReadmeString()));
}
void SetIndicesLineLoop(List <Property> properties, Runtime.MeshPrimitive meshPrimitive)
{
meshPrimitive.Positions.Values = GetSinglePlaneNonReversiblePositions();
meshPrimitive.Indices = Data.Create(new[] { 0, 3, 2, 1 });
properties.Add(new Property(PropertyName.IndicesValues, meshPrimitive.Indices.Values.ToReadmeString()));
}
void SetIndicesTriangleFan(List <Property> properties, Runtime.MeshPrimitive meshPrimitive)
{
meshPrimitive.Positions = Data.Create(MeshPrimitive.GetSinglePlanePositions());
meshPrimitive.Indices = Data.Create(new[] { 0, 3, 2, 1 });
properties.Add(new Property(PropertyName.IndicesValues, meshPrimitive.Indices.Values.ToReadmeString()));
}
void SetIndicesLineStrip(List <Property> properties, Runtime.MeshPrimitive meshPrimitive)
{
meshPrimitive.Positions.Values = GetSinglePlaneNonReversiblePositions();
meshPrimitive.Indices = Data.Create(new[] { 0, 3, 2, 1, 0 });
properties.Add(new Property(PropertyName.IndicesValues, meshPrimitive.Indices.Values.ToReadmeString()));
}
void SetIndicesTriangleStrip(List <Property> properties, Runtime.MeshPrimitive meshPrimitive)
{
meshPrimitive.Positions = Data.Create(MeshPrimitive.GetSinglePlanePositions());
meshPrimitive.Indices = Data.Create(new[] { 0, 3, 1, 2 });
properties.Add(new Property(PropertyName.IndicesValues, meshPrimitive.Indices.Values.ToReadmeString()));
}
void SetIndicesTriangles(List <Property> properties, Runtime.MeshPrimitive meshPrimitive)
{
meshPrimitive.Positions = Data.Create(MeshPrimitive.GetSinglePlanePositions());
meshPrimitive.Indices = Data.Create(MeshPrimitive.GetSinglePlaneIndices());
properties.Add(new Property(PropertyName.IndicesValues, meshPrimitive.Indices.Values.ToReadmeString()));
}
void SetIndicesComponentTypeInt(List <Property> properties, Runtime.MeshPrimitive meshPrimitive)
{
meshPrimitive.Indices.OutputType = DataType.UnsignedInt;
properties.Add(new Property(PropertyName.IndicesComponentType, meshPrimitive.Indices.OutputType.ToReadmeString()));
}
void SetIndicesComponentTypeByte(List <Property> properties, Runtime.MeshPrimitive meshPrimitive)
{
meshPrimitive.Indices.OutputType = DataType.UnsignedByte;
properties.Add(new Property(PropertyName.IndicesComponentType, meshPrimitive.Indices.OutputType.ToReadmeString()));
}
void SetIndicesComponentTypeShort(List <Property> properties, Runtime.MeshPrimitive meshPrimitive)
{
meshPrimitive.Indices.OutputType = DataType.UnsignedShort;
properties.Add(new Property(PropertyName.IndicesComponentType, meshPrimitive.Indices.OutputType.ToReadmeString()));
}
Models = new List <Model>
{
CreateModel((properties, meshPrimitive) =>
{
SetModePoints(properties, meshPrimitive);
}),
CreateModel((properties, meshPrimitive) =>
{
SetModeLines(properties, meshPrimitive);
}),
CreateModel((properties, meshPrimitive) =>
{
SetModeLineLoop(properties, meshPrimitive);
}),
CreateModel((properties, meshPrimitive) =>
{
SetModeLineStrip(properties, meshPrimitive);
}),
CreateModel((properties, meshPrimitive) =>
{
SetModeTriangleStrip(properties, meshPrimitive);
}),
CreateModel((properties, meshPrimitive) =>
{
SetModeTriangleFan(properties, meshPrimitive);
}),
CreateModel((properties, meshPrimitive) =>
{
SetModeTriangles(properties, meshPrimitive);
}),
CreateModel((properties, meshPrimitive) =>
{
SetModePoints(properties, meshPrimitive);
SetIndicesPoints(properties, meshPrimitive);
SetIndicesComponentTypeInt(properties, meshPrimitive);
}),
CreateModel((properties, meshPrimitive) =>
{
SetModeLines(properties, meshPrimitive);
SetIndicesLines(properties, meshPrimitive);
SetIndicesComponentTypeInt(properties, meshPrimitive);
}),
CreateModel((properties, meshPrimitive) =>
{
SetModeLineLoop(properties, meshPrimitive);
SetIndicesLineLoop(properties, meshPrimitive);
SetIndicesComponentTypeInt(properties, meshPrimitive);
}),
CreateModel((properties, meshPrimitive) =>
{
SetModeLineStrip(properties, meshPrimitive);
SetIndicesLineStrip(properties, meshPrimitive);
SetIndicesComponentTypeInt(properties, meshPrimitive);
}),
CreateModel((properties, meshPrimitive) =>
{
SetModeTriangleStrip(properties, meshPrimitive);
SetIndicesTriangleStrip(properties, meshPrimitive);
SetIndicesComponentTypeInt(properties, meshPrimitive);
}),
CreateModel((properties, meshPrimitive) =>
{
SetModeTriangleFan(properties, meshPrimitive);
SetIndicesTriangleFan(properties, meshPrimitive);
SetIndicesComponentTypeInt(properties, meshPrimitive);
}),
CreateModel((properties, meshPrimitive) =>
{
SetModeTriangles(properties, meshPrimitive);
SetIndicesTriangles(properties, meshPrimitive);
SetIndicesComponentTypeInt(properties, meshPrimitive);
}),
CreateModel((properties, meshPrimitive) =>
{
SetModeTriangles(properties, meshPrimitive);
SetIndicesTriangles(properties, meshPrimitive);
SetIndicesComponentTypeByte(properties, meshPrimitive);
}),
CreateModel((properties, meshPrimitive) =>
{
SetModeTriangles(properties, meshPrimitive);
SetIndicesTriangles(properties, meshPrimitive);
SetIndicesComponentTypeShort(properties, meshPrimitive);
}),
};
GenerateUsedPropertiesList();
}
public Animation_SkinType(List <string> imageList)
{
// There are no common properties in this model group that are reported in the readme.
Model CreateModel(Action <List <Property>, Runtime.MeshPrimitive> setProperties)
{
var properties = new List <Property>();
List <Node> nodes = Nodes.CreateFoldingPlaneSkin("skinA", 2, 3);
var animations = new List <Animation>();
Runtime.MeshPrimitive meshPrimitive = nodes[0].Mesh.MeshPrimitives.First();
var closeCameraTranslation = new Manifest.Camera(new Vector3(0.5f, 0.0f, 0.6f));
// Apply the common properties to the gltf.
AnimateWithRotation(animations, nodes);
// Apply the properties that are specific to this gltf.
setProperties(properties, meshPrimitive);
// Create the gltf object.
return(new Model
{
Properties = properties,
GLTF = CreateGLTF(() => new Scene
{
Nodes = nodes
}, animations: animations),
Animated = true,
Camera = closeCameraTranslation,
});
}
void AnimateWithRotation(List <Animation> animations, List <Node> nodes)
{
animations.Add(
new Animation
{
Channels = new List <AnimationChannel>
{
new AnimationChannel
{
Target = new AnimationChannelTarget
{
Node = nodes[1].Children.First(),
Path = AnimationChannelTargetPath.Rotation,
}
}
}
}
);
animations[0].Channels.First().Sampler = new AnimationSampler
{
Interpolation = AnimationSamplerInterpolation.Linear,
Input = Data.Create(new[]
{
0.0f,
1.0f,
2.0f,
}),
Output = Data.Create(new[]
{
Quaternion.Identity,
Quaternion.CreateFromYawPitchRoll(0.0f, FloatMath.ToRadians(90.0f), 0.0f),
Quaternion.Identity,
}),
};
}
void JointsAreByte(Runtime.MeshPrimitive meshPrimitive)
{
meshPrimitive.Joints.OutputType = DataType.UnsignedByte;
}
void JointsAreShort(Runtime.MeshPrimitive meshPrimitive)
{
meshPrimitive.Joints.OutputType = DataType.UnsignedShort;
}
void WeightsAreFloat(Runtime.MeshPrimitive meshPrimitive)
{
meshPrimitive.Weights.OutputType = DataType.Float;
}
void WeightsAreByte(Runtime.MeshPrimitive meshPrimitive)
{
meshPrimitive.Weights.OutputType = DataType.NormalizedUnsignedByte;
}
void WeightsAreShort(Runtime.MeshPrimitive meshPrimitive)
{
meshPrimitive.Weights.OutputType = DataType.NormalizedUnsignedShort;
}
Models = new List <Model>
{
CreateModel((properties, meshPrimitive) =>
{
JointsAreByte(meshPrimitive);
WeightsAreFloat(meshPrimitive);
properties.Add(new Property(PropertyName.JointsComponentType, "Byte"));
properties.Add(new Property(PropertyName.WeightComponentType, "Float"));
}),
CreateModel((properties, meshPrimitive) =>
{
JointsAreByte(meshPrimitive);
WeightsAreByte(meshPrimitive);
properties.Add(new Property(PropertyName.JointsComponentType, "Byte"));
properties.Add(new Property(PropertyName.WeightComponentType, "Byte"));
}),
CreateModel((properties, meshPrimitive) =>
{
JointsAreByte(meshPrimitive);
WeightsAreShort(meshPrimitive);
properties.Add(new Property(PropertyName.JointsComponentType, "Byte"));
properties.Add(new Property(PropertyName.WeightComponentType, "Short"));
}),
CreateModel((properties, meshPrimitive) =>
{
JointsAreShort(meshPrimitive);
WeightsAreFloat(meshPrimitive);
properties.Add(new Property(PropertyName.JointsComponentType, "Short"));
properties.Add(new Property(PropertyName.WeightComponentType, "Float"));
}),
};
GenerateUsedPropertiesList();
}
public Mesh_Primitives(List <string> textures, List <string> figures) : base(textures, figures)
{
modelGroupName = ModelGroupName.Mesh_Primitives;
onlyBinaryProperties = false;
noPrerequisite = false;
Runtime.Image figureIndicesPrimitive0 = new Runtime.Image
{
Uri = figures.Find(e => e.Contains("Indices_Primitive0"))
};
Runtime.Image figureIndicesPrimitive1 = new Runtime.Image
{
Uri = figures.Find(e => e.Contains("Indices_Primitive1"))
};
Runtime.Image figureUVSpace2 = new Runtime.Image
{
Uri = figures.Find(e => e.Contains("UVSpace2"))
};
Runtime.Image figureUVSpace3 = new Runtime.Image
{
Uri = figures.Find(e => e.Contains("UVSpace3"))
};
Runtime.Image baseColorTexture = new Runtime.Image
{
Uri = textures.Find(e => e.Contains("BaseColor_Plane"))
};
Runtime.Image normalTexture = new Runtime.Image
{
Uri = textures.Find(e => e.Contains("Normal_Plane"))
};
usedTextures.Add(baseColorTexture);
usedTextures.Add(normalTexture);
usedFigures.Add(figureIndicesPrimitive0);
usedFigures.Add(figureIndicesPrimitive1);
usedFigures.Add(figureUVSpace2);
usedFigures.Add(figureUVSpace3);
List <Vector3> primitive0Positions = new List <Vector3>()
{
new Vector3(-0.5f, -0.5f, 0.0f),
new Vector3(0.5f, 0.5f, 0.0f),
new Vector3(-0.5f, 0.5f, 0.0f)
};
List <Vector3> primitive1Positions = new List <Vector3>()
{
new Vector3(-0.5f, -0.5f, 0.0f),
new Vector3(0.5f, -0.5f, 0.0f),
new Vector3(0.5f, 0.5f, 0.0f)
};
List <int> primitiveTriangleIndices = new List <int>
{
0, 1, 2,
};
Runtime.MeshPrimitive primitive0Mesh = new Runtime.MeshPrimitive
{
Positions = primitive0Positions,
Indices = primitiveTriangleIndices,
};
Runtime.MeshPrimitive primitive1Mesh = new Runtime.MeshPrimitive
{
Positions = primitive1Positions,
Indices = primitiveTriangleIndices,
};
List <Vector4> vertexColors = new List <Vector4>()
{
new Vector4(0.0f, 1.0f, 0.0f, 0.2f),
new Vector4(1.0f, 0.0f, 0.0f, 0.2f),
new Vector4(0.0f, 0.0f, 1.0f, 0.2f)
};
List <Vector3> normals = new List <Vector3>()
{
new Vector3(0.0f, 0.0f, 1.0f),
new Vector3(0.0f, 0.0f, 1.0f),
new Vector3(0.0f, 0.0f, 1.0f)
};
List <Vector4> tangents = new List <Vector4>()
{
new Vector4(1.0f, 0.0f, 0.0f, 1.0f),
new Vector4(1.0f, 0.0f, 0.0f, 1.0f),
new Vector4(1.0f, 0.0f, 0.0f, 1.0f)
};
List <Vector2> textureCoords0Prim0 = new List <Vector2>()
{
new Vector2(0.0f, 1.0f),
new Vector2(1.0f, 0.0f),
new Vector2(0.0f, 0.0f)
};
List <Vector2> textureCoords0Prim2 = new List <Vector2>()
{
new Vector2(0.0f, 1.0f),
new Vector2(1.0f, 1.0f),
new Vector2(1.0f, 0.0f)
};
requiredProperty = new List <Property>
{
new Property(Propertyname.Primitive0VertexUV0, "UV 0 mapping"),
new Property(Propertyname.Primitive1VertexUV0, "UV 0 mapping"),
};
properties = new List <Property>
{
new Property(Propertyname.VertexNormal, normals),
new Property(Propertyname.VertexTangent, tangents),
new Property(Propertyname.VertexColor_Vector4_Float, vertexColors),
new Property(Propertyname.NormalTexture, normalTexture),
new Property(Propertyname.BaseColorTexture, baseColorTexture),
};
specialProperties = new List <Property>
{
new Property(Propertyname.Primitives_Split1, primitive0Mesh, group: 1),
new Property(Propertyname.Primitives_Split2, primitive1Mesh, group: 1),
new Property(Propertyname.Primitive0VertexUV0, textureCoords0Prim0),
new Property(Propertyname.Primitive1VertexUV0, textureCoords0Prim2),
};
var normTex = properties.Find(e => e.name == Propertyname.NormalTexture);
var normal = properties.Find(e => e.name == Propertyname.VertexNormal);
var tangent = properties.Find(e => e.name == Propertyname.VertexTangent);
var pbrTexture = properties.Find(e => e.name == Propertyname.BaseColorTexture);
var color = properties.Find(e => e.name == Propertyname.VertexColor_Vector4_Float);
specialCombos.Add(new List <Property>()
{
normal,
tangent,
normTex,
pbrTexture
});
specialCombos.Add(new List <Property>()
{
normal,
pbrTexture
});
removeCombos.Add(new List <Property>()
{
normal
});
removeCombos.Add(new List <Property>()
{
tangent
});
removeCombos.Add(new List <Property>()
{
normTex
});
}
public Animation_Skin(List <string> imageList)
{
UseFigure(imageList, "skinA");
UseFigure(imageList, "skinB");
UseFigure(imageList, "skinC");
UseFigure(imageList, "skinD");
UseFigure(imageList, "skinE");
UseFigure(imageList, "skinF");
var closeCamera = new Manifest.Camera(new Vector3(0.5f, 0.0f, 0.6f));
var distantCamera = new Manifest.Camera(new Vector3(1.5f, 0.0f, 1.0f));
var skinBCamera = new Manifest.Camera(new Vector3(0.5f, 0.6f, 1.1f));
// There are no common properties in this model group that are reported in the readme.
Model CreateModel(Action <List <Property>, List <Animation>, List <Node> > setProperties, Action <Model> setCamera, Action <glTFLoader.Schema.Gltf> postRuntimeChanges = null)
{
var properties = new List <Property>();
var nodes = new List <Node>();
var animations = new List <Animation>();
var animated = true;
// There are no common properties in this model group.
// Apply the properties that are specific to this gltf.
setProperties(properties, animations, nodes);
// If no animations are used, null out that property.
if (!animations.Any())
{
animations = null;
animated = false;
}
// Create the gltf object.
var model = new Model
{
Properties = properties,
GLTF = CreateGLTF(() => new Scene
{
Nodes = nodes
}, animations: animations),
Animated = animated,
};
if (postRuntimeChanges != null)
{
model.PostRuntimeChanges = postRuntimeChanges;
}
setCamera(model);
return(model);
}
void AddRotationAnimationChannel(List <AnimationChannel> channelList, Node targetNode, Quaternion pitchValue, Quaternion restValue)
{
channelList.Add(
new AnimationChannel
{
Target = new AnimationChannelTarget
{
Node = targetNode,
Path = AnimationChannelTargetPath.Rotation,
},
Sampler = new AnimationSampler
{
Interpolation = AnimationSamplerInterpolation.Linear,
Input = Data.Create(new[]
{
0.0f,
1.0f,
2.0f,
}),
Output = Data.Create(new[]
{
restValue,
pitchValue,
restValue,
}),
},
});
}
Animation CreateFoldingAnimation(Node jointRootNode, List <AnimationChannel> channelList = null)
{
if (channelList == null)
{
channelList = new List <AnimationChannel>();
}
Node nodeCheck = jointRootNode;
float pitchValue = FloatMath.ToRadians(-90.0f);
var nodeList = new List <Node>
{
jointRootNode,
};
while (nodeCheck.Children != null)
{
foreach (var node in nodeCheck.Children)
{
nodeList.Add(node);
}
nodeCheck = nodeCheck.Children.First();
}
for (var nodeIndex = 1; nodeIndex < nodeList.Count(); nodeIndex++)
{
float rotateValueModifier = 1.0f;
if (nodeIndex == 1)
{
rotateValueModifier = 0.5f;
}
else if (nodeIndex % 2 == 0)
{
rotateValueModifier = -1.0f;
}
AddRotationAnimationChannel(channelList, nodeList[nodeIndex], Quaternion.CreateFromYawPitchRoll(0.0f, pitchValue * rotateValueModifier, 0.0f), Quaternion.Identity);
}
return(new Animation
{
Channels = channelList
});
}
Models = new List <Model>
{
CreateModel((properties, animations, nodes) =>
{
foreach (Node node in Nodes.CreateFoldingPlaneSkin("skinA", 2, 3))
{
nodes.Add(node);
}
properties.Add(new Property(PropertyName.Description, "`skinA`."));
}, (model) => { model.Camera = closeCamera; }),
CreateModel((properties, animations, nodes) =>
{
foreach (Node node in Nodes.CreateFoldingPlaneSkin("skinA", 2, 3))
{
nodes.Add(node);
}
animations.Add(CreateFoldingAnimation(nodes[1]));
properties.Add(new Property(PropertyName.Description, "`skinA` where `joint1` is animating with a rotation."));
}, (model) => { model.Camera = closeCamera; }),
CreateModel((properties, animations, nodes) =>
{
var tempNodeList = Nodes.CreateFoldingPlaneSkin("skinA", 2, 3);
// Give the skin node a rotation
tempNodeList[0].Rotation = Quaternion.CreateFromYawPitchRoll((FloatMath.Pi / 4.0f), 0.0f, 0.0f);
// Create a new parent node and give it a rotation
tempNodeList[0] = new Node
{
Name = "jointParent",
Rotation = Quaternion.CreateFromYawPitchRoll((FloatMath.Pi / 4.0f), 0.0f, 0.0f),
Children = new List <Node>
{
tempNodeList[0]
}
};
foreach (Node node in tempNodeList)
{
nodes.Add(node);
}
properties.Add(new Property(PropertyName.Description, "`skinA` where the skinned node has a transform and a parent node with a transform. Both transforms should be ignored."));
}, (model) => { model.Camera = closeCamera; }),
// Removed Animation_Skin_03 due to a change in the spec that disallows this situation.
// Left commented out because this will likely be re-added as a negative test in the future.
// CreateModel((properties, animations, nodes) =>
//{
// foreach (Node node in Nodes.CreateFoldingPlaneSkin("skinA", 2, 3))
// {
// nodes.Add(node);
// }
// properties.Add(new Property(PropertyName.Description, "`skinA`. The skin joints are not referenced by the scene nodes."));
// }, (model) => { model.Camera = closeCamera; }, (gltf) => {gltf.Scenes.First().Nodes = new []{0,};}),
CreateModel((properties, animations, nodes) =>
{
foreach (Node node in Nodes.CreateFoldingPlaneSkin("skinA", 2, 3))
{
nodes.Add(node);
}
nodes[0].Skin.InverseBindMatrices = null;
properties.Add(new Property(PropertyName.Description, "`skinA` without inverse bind matrices."));
}, (model) => { model.Camera = closeCamera; }),
CreateModel((properties, animations, nodes) =>
{
foreach (Node node in Nodes.CreateFoldingPlaneSkin("skinA", 2, 3))
{
nodes.Add(node);
}
animations.Add(CreateFoldingAnimation(nodes[1]));
// Attach a node with a mesh to the end of the joint hierarchy
Node nodeCheck = nodes[1];
while (nodeCheck.Children != null)
{
nodeCheck = nodeCheck.Children.First();
}
nodeCheck.Children = new List <Node>
{
new Node
{
Mesh = Mesh.CreateTriangle()
}
};
properties.Add(new Property(PropertyName.Description, "`skinA` where `joint1` is animated with a rotation and `joint1` has a triangle mesh attached to it."));
}, (model) => { model.Camera = closeCamera; }),
CreateModel((properties, animations, nodes) =>
{
foreach (Node node in Nodes.CreateFoldingPlaneSkin("skinA", 2, 3))
{
nodes.Add(node);
}
// Create a set of positions for the second mesh that are offset from the first mesh.
Runtime.MeshPrimitive originalMeshPrimitive = nodes[0].Mesh.MeshPrimitives.First();
var offsetPositions = new List <Vector3>();
foreach (Vector3 position in originalMeshPrimitive.Positions.Values)
{
var offsetPosition = position;
offsetPosition.X += 0.6f;
offsetPositions.Add(offsetPosition);
}
// Create a second mesh
nodes.Add(new Node
{
Name = "plane2",
Skin = nodes[0].Skin,
Mesh = new Runtime.Mesh
{
MeshPrimitives = new[]
{
new Runtime.MeshPrimitive
{
Joints = originalMeshPrimitive.Joints,
Weights = originalMeshPrimitive.Weights,
Positions = Data.Create(offsetPositions),
Indices = originalMeshPrimitive.Indices,
Material = new Runtime.Material
{
DoubleSided = true,
PbrMetallicRoughness = new PbrMetallicRoughness
{
BaseColorFactor = new Vector4(0.0f, 0.0f, 1.0f, 1.0f)
}
}
}
}
}
});
properties.Add(new Property(PropertyName.Description, "`skinA` where there are two meshes sharing a single skin."));
}, (model) => { model.Camera = distantCamera; }),
CreateModel((properties, animations, nodes) =>
{
foreach (Node node in Nodes.CreateFoldingPlaneSkin("skinA", 2, 3))
{
nodes.Add(node);
}
// Make joint1 a root joint
nodes.Add(nodes[1].Children.First());
nodes[1].Children = null;
// Compensate for no longer inheriting from joint0
nodes[2].Rotation = Quaternion.Multiply((Quaternion)nodes[2].Rotation, (Quaternion)nodes[1].Rotation);
nodes[2].Translation = null;
nodes[0].Skin.InverseBindMatrices = Data.Create(new[]
{
nodes[0].Skin.InverseBindMatrices.Values.First(),
Matrix4x4.Identity
});
properties.Add(new Property(PropertyName.Description, "`skinA` where `joint1` is a root node and not a child of `joint0`."));
}, (model) => { model.Camera = closeCamera; }),
CreateModel((properties, animations, nodes) =>
{
foreach (Node node in Nodes.CreatePlaneWithSkinB())
{
nodes.Add(node);
}
// Animate the joints
Node nodeJoint0 = nodes[1];
Node nodeJoint1 = nodeJoint0.Children.First();
var channelList = new List <AnimationChannel>();
float rotationValue = FloatMath.ToRadians(-15.0f);
AddRotationAnimationChannel(channelList, nodeJoint1, Quaternion.CreateFromYawPitchRoll(0.0f, 0.0f, rotationValue), Quaternion.CreateFromYawPitchRoll(0.0f, 0.0f, 0.0f));
animations.Add(new Animation
{
Channels = channelList
});
properties.Add(new Property(PropertyName.Description, "`skinB` which is made up of two skins. `joint1` is referenced by both skins and is animating with a rotation."));
}, (model) => { model.Camera = skinBCamera; }),
CreateModel((properties, animations, nodes) =>
{
foreach (Node node in Nodes.CreateFoldingPlaneSkin("skinC", 5, 5))
{
nodes.Add(node);
}
// Rotate each joint node, except the root which already has the desired rotation
Node nodeCheck = nodes[1].Children.First();
float rotationRadian = FloatMath.ToRadians(-10.0f);
Quaternion rotation = Quaternion.CreateFromYawPitchRoll(0.0f, rotationRadian, 0.0f);
nodeCheck.Rotation = rotation;
while (nodeCheck.Children != null)
{
foreach (var node in nodeCheck.Children)
{
node.Rotation = rotation;
}
nodeCheck = nodeCheck.Children.First();
}
// Rebuild the inverseBindMatrix for each joint (except the root) to work with the new rotation
var inverseBindMatrixList = nodes[0].Skin.InverseBindMatrices.Values.Select((value, index) =>
{
Matrix4x4.Invert(Matrix4x4.CreateRotationX(rotationRadian * (index + 1)), out Matrix4x4 invertedRotation);
return(Matrix4x4.Multiply(value, invertedRotation));
});
properties.Add(new Property(PropertyName.Description, "`skinC` where all of the joints have a local rotation of -10 degrees, except the root which is rotated -90 degrees."));
}, (model) => { model.Camera = distantCamera; }),
CreateModel((properties, animations, nodes) =>
{
foreach (Node node in Nodes.CreateFoldingPlaneSkin("skinD", 5, 6, 3, false))
{
nodes.Add(node);
}
animations.Add(CreateFoldingAnimation(nodes[1]));
// Remove animation for the transform node
animations[0].Channels = new List <AnimationChannel>
{
animations[0].Channels.First(),
animations[0].Channels.ElementAt(1),
animations[0].Channels.ElementAt(3),
};
// Add the mesh to the transform node
nodes[1].Children.First().Children.First().Children.First().Mesh = Mesh.CreateTriangle();
properties.Add(new Property(PropertyName.Description, "`skinD` where each joint is animating with a rotation. There is a transform node in the joint hierarchy that is not a joint. That node has a mesh attached to it in order to show its location."));
}, (model) => { model.Camera = distantCamera; }),
CreateModel((properties, animations, nodes) =>
{
foreach (Node node in Nodes.CreatePlaneWithSkinE())
{
nodes.Add(node);
}
properties.Add(new Property(PropertyName.Description, "`skinE`."));
}, (model) => { model.Camera = distantCamera; }),
// Removing this model for now, since no viewer currently supports models that have >4 jointweights per vertex.
//CreateModel((properties, animations, nodes) =>
//{
// foreach (Runtime.Node node in Nodes.CreateFoldingPlaneSkin("skinF", 8, 9, vertexVerticalSpacingMultiplier: 0.5f))
// {
// nodes.Add(node);
// }
// // Rotate each joint node, except the root which already has the desired rotation
// Runtime.Node nodeCheck = nodes[1].Children.First();
// float rotationRadian = FloatMath.ConvertDegreesToRadians(-10.0f);
// Quaternion rotationQuaternion = Quaternion.CreateFromYawPitchRoll(0.0f, rotationRadian, 0.0f);
// nodeCheck.Rotation = rotationQuaternion;
// while (nodeCheck.Children != null)
// {
// foreach (Runtime.Node node in nodeCheck.Children)
// {
// node.Rotation = rotationQuaternion;
// }
// nodeCheck = nodeCheck.Children.First();
// }
// // Rebuild the inverseBindMatrix for each joint (except the root) to work with the new rotation
// var skinJointList = (List<Runtime.SkinJoint>)nodes[0].Skin.SkinJoints;
// for (var skinJointIndex = 1; skinJointIndex < skinJointList.Count(); skinJointIndex++)
// {
// Matrix4x4 translationInverseBindMatrix = skinJointList.ElementAt(skinJointIndex).InverseBindMatrix;
// Matrix4x4.Invert(Matrix4x4.CreateRotationX(rotationRadian * (skinJointIndex + 1)) , out Matrix4x4 invertedRotation);
// skinJointList.ElementAt(skinJointIndex).InverseBindMatrix = Matrix4x4.Multiply(translationInverseBindMatrix, invertedRotation);
// }
// // Rebuild weights to include every joint instead of just the ones with a weight > 0
// var weightList = (List<List<Runtime.JointWeight>>)nodes[0].Mesh.MeshPrimitives.First().VertexJointWeights;
// for (var weightIndex = 0; weightIndex < weightList.Count(); weightIndex++)
// {
// var jointWeight = new List<Runtime.JointWeight>();
// for (var skinJointIndex = 0; skinJointIndex < skinJointList.Count; skinJointIndex++)
// {
// int weightToUse = 0;
// // Set the weight to 1 if the skinJoint is at the same level as the vertex.
// // Or Set the weight to 1 if the vertex is further out than the last skinjoint and the last skinjoint is being set.
// if (skinJointIndex == (weightIndex / 2) || (((weightIndex / 2) > skinJointList.Count - 1) && (skinJointIndex == skinJointList.Count - 1)) )
// {
// weightToUse = 1;
// }
// jointWeight.Add(new Runtime.JointWeight
// {
// Joint = skinJointList[skinJointIndex],
// Weight = weightToUse,
// });
// }
// weightList[weightIndex] = jointWeight;
// }
// properties.Add(new Property(PropertyName.Description, "`skinF`. Each vertex has weights for more than four joints."));
//}, (model) => { model.Camera = distantCamera; }),
CreateModel((properties, animations, nodes) =>
{
var skinA1 = Nodes.CreateFoldingPlaneSkin("skinA", 2, 3);
var skinA2 = Nodes.CreateFoldingPlaneSkin("skinA", 2, 3);
// Set the same mesh on both nodes.
skinA2[0].Mesh = skinA1[0].Mesh;
// Offset one of the models so they aren't overlapping.
Vector3 translation = skinA2[1].Translation.Value;
skinA2[1].Translation = new Vector3(translation.X + 0.6f, translation.Y, translation.Z);
foreach (Node node in skinA1)
{
nodes.Add(node);
}
foreach (Node node in skinA2)
{
nodes.Add(node);
}
properties.Add(new Property(PropertyName.Description, "Two instances of `skinA` sharing a mesh but with separate skins."));
}, (model) => { model.Camera = distantCamera; }),
};
GenerateUsedPropertiesList();
}
public Mesh_PrimitiveVertexColor(List <string> imageList)
{
// There are no common properties in this model group that are reported in the readme.
var colors = new[]
{
new Vector3(0.0f, 1.0f, 0.0f),
new Vector3(1.0f, 0.0f, 0.0f),
new Vector3(1.0f, 1.0f, 0.0f),
new Vector3(0.0f, 0.0f, 1.0f),
};
Data <Vector3> GetColors3()
{
return(Data.Create(colors));
}
Data <Vector4> GetColors4()
{
return(Data.Create(colors.Select(color => new Vector4(color, 0.2f))));
}
Model CreateModel(Action <List <Property>, Runtime.MeshPrimitive> setProperties)
{
var properties = new List <Property>();
Runtime.MeshPrimitive meshPrimitive = MeshPrimitive.CreateSinglePlane(includeTextureCoords: false);
// Apply the properties that are specific to this gltf.
setProperties(properties, meshPrimitive);
// Create the gltf object.
return(new Model
{
Properties = properties,
GLTF = CreateGLTF(() => new Scene
{
Nodes = new List <Node>
{
new Node
{
Mesh = new Runtime.Mesh
{
MeshPrimitives = new List <Runtime.MeshPrimitive>
{
meshPrimitive
}
},
},
},
}),
});
}
Models = new List <Model>
{
CreateModel((properties, meshPrimitive) =>
{
meshPrimitive.Colors = GetColors3();
meshPrimitive.Colors.OutputType = DataType.Float;
properties.Add(new Property(PropertyName.VertexColor, $"Vector3 {meshPrimitive.Colors.OutputType.ToReadmeString()}"));
}),
CreateModel((properties, meshPrimitive) =>
{
meshPrimitive.Colors = GetColors3();
meshPrimitive.Colors.OutputType = DataType.NormalizedUnsignedByte;
properties.Add(new Property(PropertyName.VertexColor, $"Vector3 {meshPrimitive.Colors.OutputType.ToReadmeString()}"));
}),
CreateModel((properties, meshPrimitive) =>
{
meshPrimitive.Colors = GetColors3();
meshPrimitive.Colors.OutputType = DataType.NormalizedUnsignedShort;
properties.Add(new Property(PropertyName.VertexColor, $"Vector3 {meshPrimitive.Colors.OutputType.ToReadmeString()}"));
}),
CreateModel((properties, meshPrimitive) =>
{
meshPrimitive.Colors = GetColors4();
meshPrimitive.Colors.OutputType = DataType.Float;
properties.Add(new Property(PropertyName.VertexColor, $"Vector4 {meshPrimitive.Colors.OutputType.ToReadmeString()}"));
}),
CreateModel((properties, meshPrimitive) =>
{
meshPrimitive.Colors = GetColors4();
meshPrimitive.Colors.OutputType = DataType.NormalizedUnsignedByte;
properties.Add(new Property(PropertyName.VertexColor, $"Vector4 {meshPrimitive.Colors.OutputType.ToReadmeString()}"));
}),
CreateModel((properties, meshPrimitive) =>
{
meshPrimitive.Colors = GetColors4();
meshPrimitive.Colors.OutputType = DataType.NormalizedUnsignedShort;
properties.Add(new Property(PropertyName.VertexColor, $"Vector4 {meshPrimitive.Colors.OutputType.ToReadmeString()}"));
}),
};
GenerateUsedPropertiesList();
}
public Runtime.GLTF SetModelAttributes(Runtime.GLTF wrapper, Runtime.Material material, List <Property> combo, ref glTFLoader.Schema.Gltf gltf)
{
// Same plane, but split into two triangle primitives
var primitive1 = specialProperties.Find(e => e.name == Propertyname.Primitives_Split1);
var primitive2 = specialProperties.Find(e => e.name == Propertyname.Primitives_Split2);
Runtime.MeshPrimitive prim0 = new Runtime.MeshPrimitive
{
Positions = primitive1.value.Positions,
Indices = primitive1.value.Indices,
};
Runtime.MeshPrimitive prim2 = new Runtime.MeshPrimitive
{
Positions = primitive2.value.Positions,
Indices = primitive2.value.Indices,
};
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives = new List <Runtime.MeshPrimitive>
{
prim0,
prim2
};
foreach (Property property in combo)
{
if (property.name == Propertyname.BaseColorTexture)
{
if (material.MetallicRoughnessMaterial == null)
{
material.MetallicRoughnessMaterial = new Runtime.PbrMetallicRoughness();
material.MetallicRoughnessMaterial.BaseColorTexture = new Runtime.Texture();
}
material.MetallicRoughnessMaterial.BaseColorTexture.Source = property.value;
material.MetallicRoughnessMaterial.BaseColorTexture.TexCoordIndex = 0;
}
if (property.name == Propertyname.NormalTexture)
{
if (material.NormalTexture == null)
{
material.NormalTexture = new Runtime.Texture();
}
material.NormalTexture.Source = property.value;
material.NormalTexture.TexCoordIndex = 0;
}
if (property.name == Propertyname.VertexNormal)
{
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].Normals = property.value;
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].Normals = property.value;
}
else if (property.name == Propertyname.VertexTangent)
{
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].Tangents = property.value;
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].Tangents = property.value;
}
else if (property.name == Propertyname.VertexColor_Vector4_Float)
{
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].Colors = property.value;
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].Colors = property.value;
}
else if (property.name == Propertyname.Primitive0VertexUV0)
{
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].TextureCoordSets = new List <List <Vector2> >();
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].TextureCoordSets.Add(
specialProperties.Find(e => e.name == Propertyname.Primitive0VertexUV0).value);
}
else if (property.name == Propertyname.Primitive1VertexUV0)
{
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].TextureCoordSets = new List <List <Vector2> >();
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].TextureCoordSets.Add(
specialProperties.Find(e => e.name == Propertyname.Primitive1VertexUV0).value);
}
}
if (material.MetallicRoughnessMaterial != null)
{
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].Material = material;
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].Material = material;
}
return(wrapper);
}
public Buffer_Interleaved(List <string> imageList)
{
var baseColorTexture = new Texture {
Source = UseTexture(imageList, "BaseColor_Grey")
};
// Track the common properties for use in the readme.
CommonProperties.Add(new Property(PropertyName.BaseColorTexture, baseColorTexture.Source.ToReadmeString()));
Model CreateModel(Action <List <Property>, Runtime.MeshPrimitive> setProperties)
{
var properties = new List <Property>();
Runtime.MeshPrimitive meshPrimitive = MeshPrimitive.CreateSinglePlane();
// Apply the common properties to the gltf.
meshPrimitive.Interleave = true;
meshPrimitive.Colors = Data.Create
(
new[]
{
new Vector3(0.0f, 1.0f, 0.0f),
new Vector3(1.0f, 0.0f, 0.0f),
new Vector3(1.0f, 1.0f, 0.0f),
new Vector3(0.0f, 0.0f, 1.0f),
}
);
meshPrimitive.Material = new Runtime.Material
{
PbrMetallicRoughness = new PbrMetallicRoughness
{
BaseColorTexture = new TextureInfo {
Texture = baseColorTexture
},
},
};
// Apply the properties that are specific to this gltf.
setProperties(properties, meshPrimitive);
// Create the gltf object.
return(new Model
{
Properties = properties,
GLTF = CreateGLTF(() => new Scene
{
Nodes = new[]
{
new Node
{
Mesh = new Runtime.Mesh
{
MeshPrimitives = new[]
{
meshPrimitive
}
},
},
},
}),
});
}
void SetUvTypeFloat(List <Property> properties, Runtime.MeshPrimitive meshPrimitive)
{
meshPrimitive.TexCoords0.OutputType = DataType.Float;
properties.Add(new Property(PropertyName.VertexUV0, meshPrimitive.TexCoords0.OutputType.ToReadmeString()));
}
void SetUvTypeByte(List <Property> properties, Runtime.MeshPrimitive meshPrimitive)
{
meshPrimitive.TexCoords0.OutputType = DataType.NormalizedUnsignedByte;
properties.Add(new Property(PropertyName.VertexUV0, meshPrimitive.TexCoords0.OutputType.ToReadmeString()));
}
void SetUvTypeShort(List <Property> properties, Runtime.MeshPrimitive meshPrimitive)
{
meshPrimitive.TexCoords0.OutputType = DataType.NormalizedUnsignedShort;
properties.Add(new Property(PropertyName.VertexUV0, meshPrimitive.TexCoords0.OutputType.ToReadmeString()));
}
void SetColorTypeFloat(List <Property> properties, Runtime.MeshPrimitive meshPrimitive)
{
meshPrimitive.Colors.OutputType = DataType.Float;
properties.Add(new Property(PropertyName.VertexColor, $"Vector3 {meshPrimitive.Colors.OutputType.ToReadmeString()}"));
}
void SetColorTypeByte(List <Property> properties, Runtime.MeshPrimitive meshPrimitive)
{
meshPrimitive.Colors.OutputType = DataType.NormalizedUnsignedByte;
properties.Add(new Property(PropertyName.VertexColor, $"Vector3 {meshPrimitive.Colors.OutputType.ToReadmeString()}"));
}
void SetColorTypeShort(List <Property> properties, Runtime.MeshPrimitive meshPrimitive)
{
meshPrimitive.Colors.OutputType = DataType.NormalizedUnsignedShort;
properties.Add(new Property(PropertyName.VertexColor, $"Vector3 {meshPrimitive.Colors.OutputType.ToReadmeString()}"));
}
Models = new List <Model>
{
CreateModel((properties, meshPrimitive) =>
{
SetUvTypeFloat(properties, meshPrimitive);
SetColorTypeFloat(properties, meshPrimitive);
}),
CreateModel((properties, meshPrimitive) =>
{
SetUvTypeFloat(properties, meshPrimitive);
SetColorTypeByte(properties, meshPrimitive);
}),
CreateModel((properties, meshPrimitive) =>
{
SetUvTypeFloat(properties, meshPrimitive);
SetColorTypeShort(properties, meshPrimitive);
}),
CreateModel((properties, meshPrimitive) =>
{
SetUvTypeByte(properties, meshPrimitive);
SetColorTypeFloat(properties, meshPrimitive);
}),
CreateModel((properties, meshPrimitive) =>
{
SetUvTypeShort(properties, meshPrimitive);
SetColorTypeFloat(properties, meshPrimitive);
}),
};
GenerateUsedPropertiesList();
}
public Mesh_Primitives(List <string> imageList) : base(imageList)
{
modelGroupName = ModelGroupName.Mesh_Primitives;
onlyBinaryProperties = false;
noPrerequisite = false;
Runtime.Image figureIndicesPrimitive0 = new Runtime.Image
{
Uri = imageList.Find(e => e.Contains("Indices_Primitive0"))
};
Runtime.Image figureIndicesPrimitive1 = new Runtime.Image
{
Uri = imageList.Find(e => e.Contains("Indices_Primitive1"))
};
usedFigures.Add(figureIndicesPrimitive0);
usedFigures.Add(figureIndicesPrimitive1);
List <Vector3> primitive0Positions = new List <Vector3>()
{
new Vector3(-0.5f, -0.5f, 0.0f),
new Vector3(0.5f, 0.5f, 0.0f),
new Vector3(-0.5f, 0.5f, 0.0f)
};
List <Vector3> primitive1Positions = new List <Vector3>()
{
new Vector3(-0.5f, -0.5f, 0.0f),
new Vector3(0.5f, -0.5f, 0.0f),
new Vector3(0.5f, 0.5f, 0.0f)
};
List <int> primitiveTriangleIndices = new List <int>
{
0, 1, 2,
};
Runtime.MeshPrimitive primitive0Mesh = new Runtime.MeshPrimitive
{
Positions = primitive0Positions,
Indices = primitiveTriangleIndices,
};
Runtime.MeshPrimitive primitive1Mesh = new Runtime.MeshPrimitive
{
Positions = primitive1Positions,
Indices = primitiveTriangleIndices,
};
Vector4 colors0 = new Vector4(0.0f, 1.0f, 0.0f, 1.0f);
Vector4 colors1 = new Vector4(0.0f, 0.0f, 1.0f, 1.0f);
requiredProperty = new List <Property>
{
new Property(Propertyname.Material0WithBaseColorFactor, colors0),
new Property(Propertyname.Material1WithBaseColorFactor, colors1),
};
properties = new List <Property>
{
new Property(Propertyname.Primitive0_Material0BaseColorFactor, "Material 0", group: 2),
new Property(Propertyname.Primitive0_Material1BaseColorFactor, "Material 1", group: 2),
new Property(Propertyname.Primitive1_Material0BaseColorFactor, "Material 0", group: 3),
new Property(Propertyname.Primitive1_Material1BaseColorFactor, "Material 1", group: 3),
};
specialProperties = new List <Property>
{
new Property(Propertyname.Primitives_Split1, primitive0Mesh, group: 1),
new Property(Propertyname.Primitives_Split2, primitive1Mesh, group: 1),
};
var pri0mat0 = properties.Find(e => e.name == Propertyname.Primitive0_Material0BaseColorFactor);
var pri0mat1 = properties.Find(e => e.name == Propertyname.Primitive0_Material1BaseColorFactor);
var pri1mat0 = properties.Find(e => e.name == Propertyname.Primitive1_Material0BaseColorFactor);
var pri1mat1 = properties.Find(e => e.name == Propertyname.Primitive1_Material1BaseColorFactor);
specialCombos.Add(new List <Property>()
{
pri0mat1,
pri1mat0
});
specialCombos.Add(new List <Property>()
{
pri0mat0,
pri1mat1
});
foreach (var property in properties) // Removes the automatic combos
{
removeCombos.Add(new List <Property>()
{
property
});
}
}
public Runtime.GLTF SetModelAttributes(Runtime.GLTF wrapper, Runtime.Material material0, List <Property> combo, ref glTFLoader.Schema.Gltf gltf)
{
// Same plane, but split into two triangle primitives
var primitive1 = specialProperties.Find(e => e.name == Propertyname.Primitives_Split1);
var primitive2 = specialProperties.Find(e => e.name == Propertyname.Primitives_Split2);
Runtime.MeshPrimitive prim0 = new Runtime.MeshPrimitive
{
Positions = primitive1.value.Positions,
Indices = primitive1.value.Indices,
};
Runtime.MeshPrimitive prim2 = new Runtime.MeshPrimitive
{
Positions = primitive2.value.Positions,
Indices = primitive2.value.Indices,
};
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives = new List <Runtime.MeshPrimitive>
{
prim0,
prim2
};
// Make a second material
var material1 = DeepCopy.CloneObject(material0);
// Set the base color factor on both materials
material0.MetallicRoughnessMaterial = new Runtime.PbrMetallicRoughness();
material1.MetallicRoughnessMaterial = new Runtime.PbrMetallicRoughness();
material0.MetallicRoughnessMaterial.BaseColorFactor = requiredProperty.Find(e => e.name == Propertyname.Material0WithBaseColorFactor).value;
material1.MetallicRoughnessMaterial.BaseColorFactor = requiredProperty.Find(e => e.name == Propertyname.Material1WithBaseColorFactor).value;
foreach (Property property in combo)
{
switch (property.name)
{
case Propertyname.Primitive0_Material0BaseColorFactor:
{
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].Material = material0;
break;
}
case Propertyname.Primitive0_Material1BaseColorFactor:
{
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].Material = material1;
break;
}
case Propertyname.Primitive1_Material0BaseColorFactor:
{
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].Material = material0;
break;
}
case Propertyname.Primitive1_Material1BaseColorFactor:
{
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].Material = material1;
break;
}
}
}
return(wrapper);
}
public Material_Mixed(List <string> textures, List <string> figures) : base(textures, figures)
{
modelGroupName = ModelGroupName.Material_Mixed;
onlyBinaryProperties = false;
var baseColorTexture = new Runtime.Image
{
Uri = textures.Find(e => e.Contains("BaseColor_X"))
};
Runtime.Image figureUVSpace2 = new Runtime.Image
{
Uri = figures.Find(e => e.Contains("UVSpace2"))
};
Runtime.Image figureUVSpace3 = new Runtime.Image
{
Uri = figures.Find(e => e.Contains("UVSpace3"))
};
usedTextures.Add(baseColorTexture);
usedFigures.Add(figureUVSpace2);
usedFigures.Add(figureUVSpace3);
List <Vector3> primitive0Positions = new List <Vector3>()
{
new Vector3(-0.5f, -0.5f, 0.0f),
new Vector3(0.5f, 0.5f, 0.0f),
new Vector3(-0.5f, 0.5f, 0.0f)
};
List <Vector3> primitive1Positions = new List <Vector3>()
{
new Vector3(-0.5f, -0.5f, 0.0f),
new Vector3(0.5f, -0.5f, 0.0f),
new Vector3(0.5f, 0.5f, 0.0f)
};
List <int> primitiveTriangleIndices = new List <int>
{
0, 1, 2,
};
Runtime.MeshPrimitive primitive0Mesh = new Runtime.MeshPrimitive
{
Positions = primitive0Positions,
Indices = primitiveTriangleIndices,
};
Runtime.MeshPrimitive primitive1Mesh = new Runtime.MeshPrimitive
{
Positions = primitive1Positions,
Indices = primitiveTriangleIndices,
};
List <Vector2> textureCoords0Prim0 = new List <Vector2>()
{
new Vector2(0.0f, 1.0f),
new Vector2(1.0f, 0.0f),
new Vector2(0.0f, 0.0f)
};
List <Vector2> textureCoords0Prim2 = new List <Vector2>()
{
new Vector2(0.0f, 1.0f),
new Vector2(1.0f, 1.0f),
new Vector2(1.0f, 0.0f)
};
requiredProperty = new List <Property>
{
new Property(Propertyname.ExtensionUsed_SpecularGlossiness, "Specular Glossiness", group: 1),
new Property(Propertyname.BaseColorTexture, baseColorTexture)
};
properties = new List <Property>
{
new Property(Propertyname.SpecularGlossinessOnMaterial0_Yes, null, group: 2),
new Property(Propertyname.SpecularGlossinessOnMaterial0_No, ":x:", group: 2),
new Property(Propertyname.SpecularGlossinessOnMaterial1_Yes, null, group: 3),
new Property(Propertyname.SpecularGlossinessOnMaterial1_No, ":x:", group: 3),
};
specialProperties = new List <Property>
{
new Property(Propertyname.Primitives_Split1, primitive0Mesh, group: 4),
new Property(Propertyname.Primitives_Split2, primitive1Mesh, group: 4),
new Property(Propertyname.Primitive0VertexUV0, textureCoords0Prim0),
new Property(Propertyname.Primitive1VertexUV0, textureCoords0Prim2),
};
var mat0Yes = properties.Find(e => e.name == Propertyname.SpecularGlossinessOnMaterial0_Yes);
var mat0No = properties.Find(e => e.name == Propertyname.SpecularGlossinessOnMaterial0_No);
var mat1Yes = properties.Find(e => e.name == Propertyname.SpecularGlossinessOnMaterial1_Yes);
var mat1No = properties.Find(e => e.name == Propertyname.SpecularGlossinessOnMaterial1_No);
specialCombos.Add(new List <Property>()
{
mat0No,
mat1No
});
specialCombos.Add(new List <Property>()
{
mat0Yes,
mat1No
});
removeCombos.Add(new List <Property>()
{
mat0Yes
});
removeCombos.Add(new List <Property>()
{
mat0No
});
removeCombos.Add(new List <Property>()
{
mat1Yes
});
removeCombos.Add(new List <Property>()
{
mat1No
});
}
public Texture_Sampler(List <string> imageList)
{
var baseColorImage = UseTexture(imageList, "BaseColor_Plane");
// Track the common properties for use in the readme.
CommonProperties.Add(new Property(PropertyName.BaseColorTexture, baseColorImage.ToReadmeString()));
Model CreateModel(Action <List <Property>, Runtime.Sampler> setProperties)
{
var properties = new List <Property>();
Runtime.MeshPrimitive meshPrimitive = MeshPrimitive.CreateSinglePlane();
meshPrimitive.Material = new Runtime.Material
{
PbrMetallicRoughness = new Runtime.PbrMetallicRoughness
{
BaseColorTexture = new Runtime.TextureInfo
{
Texture = new Runtime.Texture
{
Source = baseColorImage,
Sampler = new Runtime.Sampler()
}
},
},
};
// Apply the common properties to the gltf.
meshPrimitive.TexCoords0 = Runtime.Data.Create
(
new[]
{
new Vector2(1.3f, 1.3f),
new Vector2(-0.3f, 1.3f),
new Vector2(-0.3f, -0.3f),
new Vector2(1.3f, -0.3f)
}
);
// Apply the properties that are specific to this gltf.
setProperties(properties, meshPrimitive.Material.PbrMetallicRoughness.BaseColorTexture.Texture.Sampler);
// Create the gltf object.
return(new Model
{
Properties = properties,
GLTF = CreateGLTF(() => new Runtime.Scene
{
Nodes = new List <Runtime.Node>
{
new Runtime.Node
{
Mesh = new Runtime.Mesh
{
MeshPrimitives = new List <Runtime.MeshPrimitive>
{
meshPrimitive
}
},
},
},
}),
});
}
void SetWrapT(List <Property> properties, Runtime.Sampler sampler, Runtime.SamplerWrap enumValue)
{
sampler.WrapT = enumValue;
properties.Add(new Property(PropertyName.WrapT, enumValue.ToReadmeString()));
}
void SetWrapS(List <Property> properties, Runtime.Sampler sampler, Runtime.SamplerWrap enumValue)
{
sampler.WrapS = enumValue;
properties.Add(new Property(PropertyName.WrapS, sampler.WrapS.ToReadmeString()));
}
void SetMagFilter(List <Property> properties, Runtime.Sampler sampler, Runtime.SamplerMagFilter enumValue)
{
sampler.MagFilter = enumValue;
properties.Add(new Property(PropertyName.MagFilter, enumValue.ToReadmeString()));
}
void SetMinFilter(List <Property> properties, Runtime.Sampler sampler, Runtime.SamplerMinFilter enumValue)
{
sampler.MinFilter = enumValue;
properties.Add(new Property(PropertyName.MinFilter, enumValue.ToReadmeString()));
}
Models = new List <Model>
{
CreateModel((properties, sampler) =>
{
// There are no properties set on this model.
}),
CreateModel((properties, sampler) =>
{
SetWrapT(properties, sampler, Runtime.SamplerWrap.ClampToEdge);
}),
CreateModel((properties, sampler) =>
{
SetWrapT(properties, sampler, Runtime.SamplerWrap.MirroredRepeat);
}),
CreateModel((properties, sampler) =>
{
SetWrapS(properties, sampler, Runtime.SamplerWrap.ClampToEdge);
}),
CreateModel((properties, sampler) =>
{
SetWrapS(properties, sampler, Runtime.SamplerWrap.MirroredRepeat);
}),
CreateModel((properties, sampler) =>
{
SetMagFilter(properties, sampler, Runtime.SamplerMagFilter.Nearest);
}),
CreateModel((properties, sampler) =>
{
SetMagFilter(properties, sampler, Runtime.SamplerMagFilter.Linear);
}),
CreateModel((properties, sampler) =>
{
SetMinFilter(properties, sampler, Runtime.SamplerMinFilter.Nearest);
}),
CreateModel((properties, sampler) =>
{
SetMinFilter(properties, sampler, Runtime.SamplerMinFilter.Linear);
}),
CreateModel((properties, sampler) =>
{
SetMinFilter(properties, sampler, Runtime.SamplerMinFilter.NearestMipmapNearest);
}),
CreateModel((properties, sampler) =>
{
SetMinFilter(properties, sampler, Runtime.SamplerMinFilter.LinearMipmapNearest);
}),
CreateModel((properties, sampler) =>
{
SetMinFilter(properties, sampler, Runtime.SamplerMinFilter.NearestMipmapLinear);
}),
CreateModel((properties, sampler) =>
{
SetMinFilter(properties, sampler, Runtime.SamplerMinFilter.LinearMipmapLinear);
}),
CreateModel((properties, sampler) =>
{
SetWrapT(properties, sampler, Runtime.SamplerWrap.ClampToEdge);
SetWrapS(properties, sampler, Runtime.SamplerWrap.ClampToEdge);
SetMagFilter(properties, sampler, Runtime.SamplerMagFilter.Nearest);
SetMinFilter(properties, sampler, Runtime.SamplerMinFilter.Nearest);
}),
};
GenerateUsedPropertiesList();
}
public Runtime.GLTF SetModelAttributes(Runtime.GLTF wrapper, Runtime.Material material, List <Property> combo, ref glTFLoader.Schema.Gltf gltf)
{
foreach (var req in requiredProperty)
{
if (req.name == Propertyname.ExtensionUsed_SpecularGlossiness)
{
// Initialize SpecGloss for every set
material.Extensions = new List <Runtime.Extensions.Extension>();
material.Extensions.Add(new Runtime.Extensions.PbrSpecularGlossiness());
if (wrapper.ExtensionsUsed == null)
{
wrapper.ExtensionsUsed = new List <string>();
}
wrapper.ExtensionsUsed = wrapper.ExtensionsUsed.Union(
new string[] { "KHR_materials_pbrSpecularGlossiness" }).ToList();
}
else if (req.name == Propertyname.BaseColorTexture)
{
// Apply the fallback MetallicRoughness for every set
material.MetallicRoughnessMaterial = new Runtime.PbrMetallicRoughness
{
BaseColorTexture = new Runtime.Texture
{
Source = req.value
}
};
}
}
var material2 = DeepCopy.CloneObject(material);
Runtime.MeshPrimitive prim0 = null;
Runtime.MeshPrimitive prim1 = null;
foreach (var property in specialProperties)
{
if (property.name == Propertyname.Primitives_Split1)
{
prim0 = new Runtime.MeshPrimitive
{
Positions = property.value.Positions,
Indices = property.value.Indices,
};
}
else if (property.name == Propertyname.Primitives_Split2)
{
prim1 = new Runtime.MeshPrimitive
{
Positions = property.value.Positions,
Indices = property.value.Indices,
};
}
else if (property.propertyGroup == 0
)
{
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives = new List <Runtime.MeshPrimitive>
{
prim0,
prim1
};
}
if (property.name == Propertyname.Primitive0VertexUV0)
{
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].TextureCoordSets = new List <List <Vector2> >();
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].TextureCoordSets.Add(
specialProperties.Find(e => e.name == Propertyname.Primitive0VertexUV0).value);
}
else if (property.name == Propertyname.Primitive1VertexUV0)
{
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].TextureCoordSets = new List <List <Vector2> >();
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].TextureCoordSets.Add(
specialProperties.Find(e => e.name == Propertyname.Primitive1VertexUV0).value);
}
}
foreach (Property property in combo)
{
switch (property.name)
{
case Propertyname.SpecularGlossinessOnMaterial0_Yes:
// Default. No changes needed
break;
case Propertyname.SpecularGlossinessOnMaterial0_No:
material.Extensions = null;
break;
case Propertyname.SpecularGlossinessOnMaterial1_Yes:
// Default. No changes needed
break;
case Propertyname.SpecularGlossinessOnMaterial1_No:
material2.Extensions = null;
break;
}
}
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[0].Material = material;
wrapper.Scenes[0].Nodes[0].Mesh.MeshPrimitives[1].Material = material2;
return(wrapper);
}
public Material(List <string> imageList)
{
var emissiveTexture = new Texture {
Source = UseTexture(imageList, "Emissive_Plane")
};
var normalTexture = new Texture {
Source = UseTexture(imageList, "Normal_Plane")
};
var occlusionTexture = new Texture {
Source = UseTexture(imageList, "Occlusion_Plane")
};
// Track the common properties for use in the readme.
var metallicFactorValue = 0.0f;
var baseColorFactorValue = new Vector4(0.2f, 0.2f, 0.2f, 1.0f);
CommonProperties.Add(new Property(PropertyName.MetallicFactor, metallicFactorValue.ToReadmeString()));
CommonProperties.Add(new Property(PropertyName.BaseColorFactor, baseColorFactorValue.ToReadmeString()));
Model CreateModel(Action <List <Property>, Runtime.MeshPrimitive, Runtime.Material> setProperties)
{
var properties = new List <Property>();
Runtime.MeshPrimitive meshPrimitive = MeshPrimitive.CreateSinglePlane(includeTextureCoords: false);
// Apply the common properties to the gltf.
meshPrimitive.Material = new Runtime.Material
{
PbrMetallicRoughness = new Runtime.PbrMetallicRoughness
{
MetallicFactor = metallicFactorValue,
BaseColorFactor = baseColorFactorValue,
}
};
// Apply the properties that are specific to this gltf.
setProperties(properties, meshPrimitive, meshPrimitive.Material);
// Create the gltf object.
return(new Model
{
Properties = properties,
GLTF = CreateGLTF(() => new Scene
{
Nodes = new List <Node>
{
new Node
{
Mesh = new Runtime.Mesh
{
MeshPrimitives = new List <Runtime.MeshPrimitive>
{
meshPrimitive
}
},
},
},
}),
});
}
void SetNormalTexture(List <Property> properties, Runtime.MeshPrimitive meshPrimitive)
{
meshPrimitive.Normals = Data.Create(MeshPrimitive.GetSinglePlaneNormals());
meshPrimitive.Material.NormalTexture = new NormalTextureInfo {
Texture = normalTexture
};
properties.Add(new Property(PropertyName.NormalTexture, normalTexture.Source.ToReadmeString()));
}
void SetNormalScale(List <Property> properties, Runtime.Material material)
{
material.NormalTexture.Scale = 10.0f;
properties.Add(new Property(PropertyName.NormalTextureScale, material.NormalTexture.Scale.ToReadmeString()));
}
void SetOcclusionTexture(List <Property> properties, Runtime.Material material)
{
material.OcclusionTexture = new OcclusionTextureInfo {
Texture = occlusionTexture
};
properties.Add(new Property(PropertyName.OcclusionTexture, occlusionTexture.Source.ToReadmeString()));
}
void SetOcclusionStrength(List <Property> properties, Runtime.Material material)
{
material.OcclusionTexture.Strength = 0.5f;
properties.Add(new Property(PropertyName.OcclusionTextureStrength, material.OcclusionTexture.Strength.ToReadmeString()));
}
void SetEmissiveTexture(List <Property> properties, Runtime.Material material)
{
material.EmissiveTexture = new TextureInfo {
Texture = emissiveTexture
};
properties.Add(new Property(PropertyName.EmissiveTexture, emissiveTexture.Source.ToReadmeString()));
}
void SetEmissiveFactor(List <Property> properties, Runtime.Material material)
{
var emissiveFactorValue = new Vector3(1.0f, 1.0f, 1.0f);
material.EmissiveFactor = emissiveFactorValue;
properties.Add(new Property(PropertyName.EmissiveFactor, emissiveFactorValue.ToReadmeString()));
}
Models = new List <Model>
{
CreateModel((properties, meshPrimitive, material) =>
{
// There are no properties set on this model.
}),
CreateModel((properties, meshPrimitive, material) =>
{
meshPrimitive.TexCoords0 = Data.Create(MeshPrimitive.GetSinglePlaneTexCoords());
SetNormalTexture(properties, meshPrimitive);
}),
CreateModel((properties, meshPrimitive, material) =>
{
meshPrimitive.TexCoords0 = Data.Create(MeshPrimitive.GetSinglePlaneTexCoords());
SetOcclusionTexture(properties, material);
}),
CreateModel((properties, meshPrimitive, material) =>
{
SetEmissiveFactor(properties, material);
}),
CreateModel((properties, meshPrimitive, material) =>
{
meshPrimitive.TexCoords0 = Data.Create(MeshPrimitive.GetSinglePlaneTexCoords());
SetNormalTexture(properties, meshPrimitive);
SetNormalScale(properties, material);
}),
CreateModel((properties, meshPrimitive, material) =>
{
meshPrimitive.TexCoords0 = Data.Create(MeshPrimitive.GetSinglePlaneTexCoords());
SetOcclusionTexture(properties, material);
SetOcclusionStrength(properties, material);
}),
CreateModel((properties, meshPrimitive, material) =>
{
meshPrimitive.TexCoords0 = Data.Create(MeshPrimitive.GetSinglePlaneTexCoords());
SetEmissiveTexture(properties, material);
SetEmissiveFactor(properties, material);
}),
CreateModel((properties, meshPrimitive, material) =>
{
meshPrimitive.TexCoords0 = Data.Create(MeshPrimitive.GetSinglePlaneTexCoords());
SetNormalTexture(properties, meshPrimitive);
SetNormalScale(properties, material);
SetOcclusionTexture(properties, material);
SetOcclusionStrength(properties, material);
SetEmissiveTexture(properties, material);
SetEmissiveFactor(properties, material);
}),
};
GenerateUsedPropertiesList();
}
