Exemplo n.º 1
0
        private IEnumerator GetModelForRequest(LoadCubeRequest loadRequest)
        {
            //var modelPath = loadRequest.Query.GetModelPath(loadRequest.LodIndex, loadRequest.X, loadRequest.Y, loadRequest.Z);
            var modelPath = pyriteQuery.GetModelPath(loadRequest.LodIndex, loadRequest.X, loadRequest.Y, loadRequest.Z);

            while (!Monitor.TryEnter(_eboCache))
            {
                yield return(null);
            }
            // If the geometry data is being loaded or this is the first request to load it add the request the dependency list
            if (!_eboCache.ContainsKey(modelPath) || _eboCache[modelPath] == null)
            {
                yield return(StartCoroutine(AddDependentRequest(loadRequest, modelPath)));

                if (!_eboCache.ContainsKey(modelPath))
                {
                    // Model data was not present in cache nor has any request started constructing it
                    //EboCacheMisses++;

                    _eboCache[modelPath] = null;
                    if (UseWwwForEbo)
                    {
                        var cachePath = CacheWebRequest.GetCacheFilePath(modelPath);
                        WWW modelWww;
                        if (CacheWebRequest.IsItemInCache(cachePath))
                        {
                            //FileCacheHits++;
                            modelWww = new WWW("file:///" + cachePath);
                            yield return(modelWww);
                        }
                        else
                        {
                            //FileCacheMisses++;
                            modelWww = new WWW(modelPath);
                            yield return(modelWww);

                            CacheWebRequest.AddToCache(cachePath, modelWww.bytes);
                        }

                        GeometryBuffer buffer =
                            new GeometryBuffer(_geometryBufferAltitudeTransform, true)
                        {
                            Buffer = modelWww.bytes
                        };
                        buffer.Process();
                        _eboCache[modelPath] = buffer;
                        yield return(StartCoroutine(SucceedGetGeometryBufferRequest(modelPath, buffer)));
                    }
                    else
                    {
                        CacheWebRequest.GetBytes(modelPath, modelResponse =>
                        {
                            lock (_eboCache)
                            {
                                if (modelResponse.Status == CacheWebRequest.CacheWebResponseStatus.Error)
                                {
                                    Debug.LogError("Error getting model [" + modelPath + "] " +
                                                   modelResponse.ErrorMessage);
                                    FailGetGeometryBufferRequest(loadRequest, modelPath);
                                }
                                else if (modelResponse.Status == CacheWebRequest.CacheWebResponseStatus.Cancelled)
                                {
                                    _eboCache.Remove(modelPath);
                                }
                                else
                                {
                                    if (modelResponse.IsCacheHit)
                                    {
                                        //FileCacheHits++;
                                    }
                                    else
                                    {
                                        //FileCacheMisses++;
                                    }

                                    GeometryBuffer buffer =
                                        new GeometryBuffer(_geometryBufferAltitudeTransform, true)
                                    {
                                        Buffer = modelResponse.Content
                                    };
                                    buffer.Process();
                                    _eboCache[modelPath] = buffer;
                                    SucceedGetGeometryBufferRequest(modelPath, buffer).Wait();
                                }
                            }
                        }, DependentRequestsExistBlocking);
                    }
                }
            }
            else // The model data was in the cache
            {
                // Model was constructed move request to next step
                //EboCacheHits++;
                loadRequest.GeometryBuffer = _eboCache[modelPath];
                MoveRequestForward(loadRequest);
            }
            Monitor.Exit(_eboCache);
        }
Exemplo n.º 2
0
        private IEnumerator GetMaterialForRequest(LoadCubeRequest loadRequest)
        {
            //var pyriteLevel = loadRequest.Query.DetailLevels[loadRequest.LodIndex];
            //var textureCoordinates = pyriteLevel.TextureCoordinatesForCube(loadRequest.X, loadRequest.Y);
            //var texturePath = loadRequest.Query.GetTexturePath(loadRequest.LodIndex, (int)textureCoordinates.x, (int)textureCoordinates.y);

            var pyriteLevel        = pyriteQuery.DetailLevels[loadRequest.LodIndex];
            var textureCoordinates = pyriteLevel.TextureCoordinatesForCube(loadRequest.X, loadRequest.Y);
            var texturePath        = pyriteQuery.GetTexturePath(loadRequest.LodIndex, (int)textureCoordinates.x, (int)textureCoordinates.y);

            while (!Monitor.TryEnter(MaterialDataCache))
            {
                yield return(null);
            }
            // If the material data is not in the cache or in the middle of being constructed add this request as a dependency
            if (!MaterialDataCache.ContainsKey(texturePath) || MaterialDataCache[texturePath] == null)
            {
                // Add this request to list of requests that is waiting for the data
                yield return(StartCoroutine(AddDependentRequest(loadRequest, texturePath)));

                // Check if this is the first request for material (or it isn't in the cache)
                if (!MaterialDataCache.ContainsKey(texturePath))
                {
                    if (UseWwwForTextures)
                    {
                        // Material data was not in cache nor being constructed
                        // Set to null to signal to other tasks that the key is in the process
                        // of being filled
                        MaterialDataCache[texturePath] = null;
                        var materialData = CubeBuilderHelpers.GetDefaultMaterialData(
                            (int)textureCoordinates.x,
                            (int)textureCoordinates.y,
                            loadRequest.LodIndex,
                            texturePath);
                        var cachePath = CacheWebRequest.GetCacheFilePath(texturePath);
                        if (!CacheFill)
                        {
                            WWW textureWww; // = new WWW(texturePath);
                            if (CacheWebRequest.IsItemInCache(cachePath))
                            {
                                textureWww = new WWW("file:///" + cachePath);
                                yield return(textureWww);
                            }
                            else
                            {
                                textureWww = new WWW(texturePath);
                                yield return(textureWww);

                                CacheWebRequest.AddToCache(cachePath, textureWww.bytes);
                            }
                            materialData.DiffuseTex      = textureWww.texture;
                            materialData.DiffuseTex.name = materialData.Name;
                        }
                        MaterialDataCache[texturePath] = materialData;
                        MaterialDataCache.AddRef(texturePath);
                        // Move forward dependent requests that wanted this material data
                        yield return(StartCoroutine(SucceedGetMaterialDataRequests(texturePath, materialData)));
                    }
                    else
                    {
                        // Material data was not in cache nor being constructed
                        // Set to null to signal to other tasks that the key is in the process
                        // of being filled
                        MaterialDataCache[texturePath] = null;
                        var materialData = CubeBuilderHelpers.GetDefaultMaterialData(
                            (int)textureCoordinates.x,
                            (int)textureCoordinates.y,
                            loadRequest.LodIndex,
                            texturePath);
                        _partiallyConstructedMaterialDatas[texturePath] = materialData;

                        CacheWebRequest.GetBytes(texturePath, textureResponse =>
                        {
                            CheckIfBackgroundThread();
                            if (textureResponse.Status == CacheWebRequest.CacheWebResponseStatus.Error)
                            {
                                Debug.LogError("Error getting texture [" + texturePath + "] " + textureResponse.ErrorMessage);
                                FailGetMaterialDataRequest(loadRequest, texturePath);
                            }
                            else if (textureResponse.Status == CacheWebRequest.CacheWebResponseStatus.Cancelled)
                            {
                                lock (MaterialDataCache)
                                {
                                    MaterialDataCache.Remove(texturePath);
                                }
                            }
                            else
                            {
                                if (textureResponse.IsCacheHit)
                                {
                                    //FileCacheHits++;
                                }
                                else
                                {
                                    //FileCacheMisses++;
                                }
                                _texturesReadyForMaterialDataConstruction.ConcurrentEnqueue(
                                    new KeyValuePair <string, byte[]>(texturePath, textureResponse.Content)).Wait();
                            }
                        }, DependentRequestsExistBlocking);
                    }
                }
            }
            else // The material was in the cache
            {
                // Material data ready get it and move on
                //MaterialCacheHits++;
                loadRequest.MaterialData = MaterialDataCache[texturePath];
                MaterialDataCache.AddRef(texturePath);
                MoveRequestForward(loadRequest);
            }
            Monitor.Exit(MaterialDataCache);
        }