Exemple #1
0
        public void ForeachElemsTest()
        {
            var n = new ArrayNode();

            n.AddElement(new IntegerNode(42));
            n.AddElement(new StringNode("test"));

            Assert.That(n, Is.EquivalentTo(new INode[] {
                new IntegerNode(42),
                new StringNode("test"),
            }));
        }
Exemple #2
0
        public void ElementsModificationTest()
        {
            var n = new ArrayNode();

            Assert.AreEqual(null, n.Elems);

            // Addition
            n.AddElement(new IntegerNode(42));
            n.AddElement(new StringNode("test"));

            Assert.AreEqual(2, n.Elems.Count);

            Assert.AreEqual(new IntegerNode(42), n.Elems[0]);
            Assert.AreEqual(new StringNode("test"), n.Elems[1]);

            // Deletion
            n.RemoveElementAt(0);
            n.RemoveElementAt(0);
            n.RemoveElementAt(0); // Do not fail if removes non-existing keys

            Assert.AreEqual(0, n.Elems.Count);
        }
Exemple #3
0
        public static void RepairUniGLTFInvalidTargets(INode node)
        {
            // If (Root)["meshes"][i]["primitives"][j]["targets"][k]["extra"]["name"] exists,
            // re-assign them to (Root)["meshes"][i]["primitives"]["extras"]["targetNames"].
            var meshes = node["meshes"] as ArrayNode;

            if (meshes == null)
            {
                return;
            }

            foreach (var mesh in meshes)
            {
                var primitives = mesh["primitives"] as ArrayNode;
                if (primitives == null)
                {
                    continue;
                }

                foreach (var primitive in primitives)
                {
                    var targets = primitive["targets"] as ArrayNode;
                    if (targets == null)
                    {
                        continue;
                    }

                    var extrasRaw = primitive["extras"];
                    if (extrasRaw is UndefinedNode)
                    {
                        extrasRaw = new ObjectNode();
                        ((ObjectNode)primitive).AddElement("extras", extrasRaw);
                    }

                    ArrayNode targetNames = null;
                    var       extras      = extrasRaw as ObjectNode;
                    if (extras != null)
                    {
                        var targetNamesRaw = extras["targetNames"];
                        if (targetNamesRaw is UndefinedNode)
                        {
                            targetNamesRaw = new ArrayNode();
                            extras.AddElement("targetNames", targetNamesRaw);
                        }

                        targetNames = targetNamesRaw as ArrayNode;
                    }

                    if (targetNames == null)
                    {
                        continue;
                    }


                    foreach (var target in targets)
                    {
                        var tValue = target as ObjectNode;
                        if (tValue == null)
                        {
                            continue;
                        }

                        var deletionKeys = new List <string>();
                        foreach (var kv in tValue)
                        {
                            var key = kv.Key;

                            // Invalid extension
                            if (key == "extra")
                            {
                                deletionKeys.Add(key);

                                var name = target[key]["name"] as StringNode;
                                if (name == null)
                                {
                                    continue;
                                }

                                // Re-assign to primitive.extras.targetName
                                targetNames.AddElement(name);
                            }

                            // https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/schema/mesh.primitive.schema.json#L72
                            // Only `POSITION`, `NORMAL`, and `TANGENT` supported
                            if (key != "POSITION" && key != "NORMAL" && key != "TANGENT")
                            {
                                deletionKeys.Add(key);
                            }
                        }

                        foreach (var key in deletionKeys)
                        {
                            tValue.RemoveElement(key);
                        }
                    }
                }
            }
        }