Beispiel #1
0
 public static async Task <RuntimeGltfInstance> LoadAsync(string path,
                                                          bool doMigrate,
                                                          bool doNormalize,
                                                          IAwaitCaller awaitCaller = null,
                                                          IMaterialDescriptorGenerator materialGenerator = null,
                                                          MetaCallback metaCallback = null
                                                          )
 {
     using (var data = Vrm10Data.ParseOrMigrate(path, doMigrate, out Vrm10Data vrm1Data, out MigrationData migration))
     {
         if (vrm1Data == null)
         {
             return(default);
Beispiel #2
0
        public static async Task <RuntimeGltfInstance> LoadAsync(string path,
                                                                 IAwaitCaller awaitCaller = null,
                                                                 MaterialGeneratorCallback materialGeneratorCallback = null,
                                                                 MetaCallback metaCallback = null,
                                                                 bool loadAnimation        = false
                                                                 )
        {
            if (!File.Exists(path))
            {
                throw new FileNotFoundException(path);
            }

            if (awaitCaller == null)
            {
                Debug.LogWarning("VrmUtility.LoadAsync: awaitCaller argument is null. ImmediateCaller is used as the default fallback. When playing, we recommend RuntimeOnlyAwaitCaller.");
                awaitCaller = new ImmediateCaller();
            }

            using (GltfData data = new AutoGltfFileParser(path).Parse())
            {
                try
                {
                    var vrm = new VRMData(data);
                    IMaterialDescriptorGenerator materialGen = default;
                    if (materialGeneratorCallback != null)
                    {
                        materialGen = materialGeneratorCallback(vrm.VrmExtension);
                    }
                    using (var loader = new VRMImporterContext(vrm, materialGenerator: materialGen, loadAnimation: loadAnimation))
                    {
                        if (metaCallback != null)
                        {
                            var meta = await loader.ReadMetaAsync(awaitCaller, true);

                            metaCallback(meta);
                        }
                        return(await loader.LoadAsync(awaitCaller));
                    }
                }
                catch (NotVrm0Exception)
                {
                    // retry
                    Debug.LogWarning("file extension is vrm. but not vrm ?");
                    using (var loader = new UniGLTF.ImporterContext(data))
                    {
                        return(await loader.LoadAsync(awaitCaller));
                    }
                }
            }
        }
Beispiel #3
0
        public static async Task <RuntimeGltfInstance> LoadAsync(string path,
                                                                 IAwaitCaller awaitCaller = null,
                                                                 MaterialGeneratorCallback materialGeneratorCallback = null,
                                                                 MetaCallback metaCallback = null
                                                                 )
        {
            if (!File.Exists(path))
            {
                throw new FileNotFoundException(path);
            }

            using (GltfData data = new AutoGltfFileParser(path).Parse())
            {
                try
                {
                    var vrm = new VRMData(data);
                    IMaterialDescriptorGenerator materialGen = default;
                    if (materialGeneratorCallback != null)
                    {
                        materialGen = materialGeneratorCallback(vrm.VrmExtension);
                    }
                    using (var loader = new VRMImporterContext(vrm, materialGenerator: materialGen))
                    {
                        if (metaCallback != null)
                        {
                            var meta = await loader.ReadMetaAsync(new ImmediateCaller(), true);

                            metaCallback(meta);
                        }
                        return(await loader.LoadAsync(awaitCaller));
                    }
                }
                catch (NotVrm0Exception)
                {
                    // retry
                    Debug.LogWarning("file extension is vrm. but not vrm ?");
                    using (var loader = new UniGLTF.ImporterContext(data))
                    {
                        return(await loader.LoadAsync(awaitCaller));
                    }
                }
            }
        }
Beispiel #4
0
 public static Ice.DispatchStatus stopped___(MetaCallback obj__, IceInternal.Incoming inS__, Ice.Current current__)
 {
     checkMode__(Ice.OperationMode.Normal, current__.mode);
     IceInternal.BasicStream is__ = inS__.istr();
     is__.startReadEncaps();
     Murmur.ServerPrx srv;
     srv = Murmur.ServerPrxHelper.read__(is__);
     is__.endReadEncaps();
     obj__.stopped(srv, current__);
     return Ice.DispatchStatus.DispatchOK;
 }