Exemple #1
0
        private void ProcessLoadRequest(SAssetLoadRequest loadRequest)
        {
            Scene scene = m_importer.ImportFile(loadRequest.filename, PostProcessPreset.TargetRealTimeMaximumQuality | PostProcessPreset.ConvertToLeftHanded);

            if (loadRequest.type == EAssetType.Mesh)
            {
                if (scene.HasMeshes)
                {
                    CMeshAsset      meshAsset  = (CMeshAsset)loadRequest.targetAsset;
                    CMeshLoadingJob loadingJob = new CMeshLoadingJob(scene, Path.GetDirectoryName(loadRequest.filename));
                    LoadMeshInternal(0, meshAsset, loadingJob, loadRequest.assetPath, Path.GetFileNameWithoutExtension(loadRequest.filename));
                }
            }
            else if (loadRequest.type == EAssetType.Model)
            {
                if (scene.HasMeshes)
                {
                    CModelAsset modelAsset = (CModelAsset)loadRequest.targetAsset;
                    LoadModelInternal(loadRequest.filename, scene, modelAsset, loadRequest.assetPath);
                    modelAsset.Name = Path.GetFileNameWithoutExtension(loadRequest.filename);
                    if (CAssetRegistry.Instance.RequestRegisterAsset(modelAsset, loadRequest.assetPath + "Models/", out CModelAsset existingAsset))
                    {
                        existingAsset.WaitUntilLoaded();
                        modelAsset.CopyFrom(existingAsset);
                    }
                }
            }
            AssetLoadedCallback(loadRequest);
        }
Exemple #2
0
        public CModelAsset LoadModelAsset(string filename, bool bAlwaysImport = false)
        {
            // Block new loads and wait for our current load to finish
            m_bIsLoading = true;
            m_currentLoadTask?.Wait();

            // Load the asset synchronous
            CModelAsset outAsset = new CModelAsset();

            if (!bAlwaysImport && TryGetExistingAsset(filename, "Assets/Models", outAsset, out CModelAsset existingAsset))
            {
                m_bIsLoading = false;
                return(existingAsset);
            }

            Scene scene = m_importer.ImportFile(filename, PostProcessPreset.TargetRealTimeMaximumQuality | PostProcessPreset.ConvertToLeftHanded);

            if (scene.HasMeshes)
            {
                LoadModelInternal(filename, scene, outAsset, "Assets/");
            }

            outAsset.Name = Path.GetFileNameWithoutExtension(filename);
            if (CAssetRegistry.Instance.RequestRegisterAsset(outAsset, "Assets/Models/", out CModelAsset existingModel, bAlwaysImport))
            {
                existingModel.WaitUntilLoaded();
                outAsset.CopyFrom(existingModel);
            }

            outAsset.LoadFinished();
            // Unblock loader
            m_bIsLoading = false;
            // Continue loading request
            StartNextLoadRequest();

            return(outAsset);
        }