Example #1
0
        public ExportResult Export(GroupDisplayData datas)
        {
            ExportStats    stats    = new ExportStats();
            BabylonOutputs outputs  = new BabylonOutputs();
            string         tempPath = Path.GetTempPath();

            var prims = new List <object>();

            Tuple <string, object, List <object> > rootPrim = SerializeCombinedFaces(null, datas.RootPrim, "png", tempPath, outputs, stats);

            prims.Add(rootPrim.Item2);

            foreach (var data in datas.Prims.Where(p => p != datas.RootPrim))
            {
                prims.Add(SerializeCombinedFaces(rootPrim.Item1, data, "png", tempPath, outputs, stats).Item2);
            }

            var res = PackageResult(datas.ObjectName, datas.CreatorName, outputs, prims);

            stats.ConcreteCount = 1;
            stats.TextureCount  = res.TextureFiles.Count;
            res.Stats           = stats;

            return(res);
        }
Example #2
0
        private ulong GetGroupHash(GroupDisplayData group)
        {
            ulong groupHash = 5381;

            foreach (var prim in group.Prims)
            {
                groupHash = Murmur2.Hash(prim.ShapeHash, groupHash);
                groupHash = Murmur2.Hash(prim.MaterialHash, groupHash);
            }

            return(groupHash);
        }
        public ExportResult Export(GroupDisplayData datas)
        {
            ExportResult result = new ExportResult();
            Dictionary <UUID, TrackedTexture> materialTracker = new Dictionary <UUID, TrackedTexture>();
            string tempPath = Path.GetTempPath();

            foreach (var data in datas.Prims)
            {
                result.Combine(ExportSingle(data, materialTracker, UUID.Random(), "png", result.TextureFiles, tempPath));
            }

            result.ObjectName  = datas.ObjectName;
            result.CreatorName = datas.CreatorName;

            return(result);
        }
        public void TestSerializeDeserialize()
        {
            var sops = new[]
            {
                Util.RandomSOP("sop1", 1),
                Util.RandomSOP("sop2", 2),
                Util.RandomSOP("sop3", 3)
            };

            var group = new SceneObjectGroup(sops[0]);

            group.AddPart(sops[1]);
            group.AddPart(sops[2]);

            var loaderParams     = new GroupLoader.LoaderParams();
            GroupDisplayData gdd = GroupLoader.Instance.GroupDisplayDataFromSOG(UUID.Zero, loaderParams, group, null, null, null);
            var formatter        = new BabylonFlatbufferFormatter();

            var rawResult = formatter.Export(gdd);
            var result    = rawResult.FaceBlob;

            CompareLogic comp = new CompareLogic
            {
                Config =
                {
                    CompareStaticFields     = false,
                    CompareStaticProperties = false,
                    MembersToIgnore         = PrimCompareIgnoreList
                }
            };

            var fbGroup =
                BabylonFileFlatbuffer.GetRootAsBabylonFileFlatbuffer(new ByteBuffer(result.Item1, result.Item2));

            Assert.NotNull(fbGroup);
        }
        static int Main(string[] args)
        {
            try
            {
                var extra = _options.Parse(args);
                if (extra.Count != 0)
                {
                    Console.Error.WriteLine($"Invalid option: {extra[0]}");
                    PrintUsage();
                    return(1);
                }
            }
            catch (OptionException)
            {
                PrintUsage();
                return(2);
            }

            int errcode;

            if (!CheckBasicOptions(args, out errcode))
            {
                return(errcode);
            }

            GroupLoader.LoaderParams parms = new GroupLoader.LoaderParams
            {
                PrimLimit = Convert.ToInt32(_primLimit),
                Checks    = (GroupLoader.LoaderChecks)Convert.ToInt16(_checks)
            };

            ExpLib.Init();

            GroupDisplayData        data        = null;
            List <GroupDisplayData> multiGroups = null;

            if (_stream)
            {
                string input = Console.In.ReadToEnd();
                data = GroupLoader.Instance.LoadFromXML(input, parms);
            }
            else if (_xmlFile != null)
            {
                string input = File.ReadAllText(_xmlFile);
                data = GroupLoader.Instance.LoadFromXML(input, parms);
            }
            else if (_aggrDir != null)
            {
                multiGroups = new List <GroupDisplayData>();
                var dirList = Directory.EnumerateFiles(_aggrDir, "*.xml");
                foreach (var file in dirList)
                {
                    string input = File.ReadAllText(file);
                    multiGroups.Add(GroupLoader.Instance.LoadFromXML(input, parms));
                }
            }
            else if (_userId != UUID.Zero && _invItemId != UUID.Zero)
            {
                data = GroupLoader.Instance.Load(_userId, _invItemId, parms);
            }
            else
            {
                Console.Error.WriteLine("Either stream, file, aggregation, or userid and invitemid are required parameters");
                PrintUsage();
                return(5);
            }

            IExportFormatter formatter = ExportFormatterFactory.Instance.Get(_formatter);
            ExportResult     res       = multiGroups != null?formatter.Export(multiGroups) : formatter.Export(data);

            Console.Out.WriteLine($"Scene Statistics:\n\n" +
                                  $"Concrete objects: {res.Stats.ConcreteCount}\n" +
                                  $"Instanced objects: {res.Stats.InstanceCount}\n" +
                                  $"Unique submeshes: {res.Stats.SubmeshCount}\n" +
                                  $"Concrete primitives: {res.Stats.PrimCount}\n" +
                                  $"Unique textures: {res.Stats.TextureCount}\n");

            //sort the prim and face stats
            var sortedGroupsByPrimCount    = res.Stats.GroupsByPrimCount.OrderByDescending(o => o.Item2);
            var sortedGroupsBySubmeshCount = res.Stats.GroupsBySubmeshCount.OrderByDescending(o => o.Item2);

            //top 10
            Console.Out.WriteLine("Top 10 groups by prim count");
            foreach (var grp in sortedGroupsByPrimCount.Take(10))
            {
                Console.Out.WriteLine($"{grp.Item2} {grp.Item1}");
            }

            Console.Out.WriteLine();

            Console.Out.WriteLine("Top 10 groups by submesh count");
            foreach (var grp in sortedGroupsBySubmeshCount.Take(10))
            {
                Console.Out.WriteLine($"{grp.Item2} {grp.Item1}");
            }

            Console.Out.WriteLine();

            PackagerParams pp = new PackagerParams {
                Direct = _direct
            };

            IPackager packager = PackagerFactory.Instance.Get(_packager);

            packager.CreatePackage(res, _outputDir, pp);

            ExpLib.ShutDown();

            return(0);
        }