Exemplo n.º 1
0
        private IEnumerator LoadMetadata(List <int> detailLevelsToFilter = null)
        {
            Debug.Log("Metadata query started against: " + _setUrl);
            WWW loader = WwwExtensions.CreateWWW(_setUrl);

            yield return(loader);

            var parsedContent = JSON.Parse(loader.GetDecompressedText());

            if (!parsedContent[StatusKey].Value.Equals(OkValue))
            {
                Debug.LogError("Failure getting set info for " + SetName);
                yield break;
            }
            loader = WwwExtensions.CreateWWW(_versionUrl);
            yield return(loader);

            parsedContent = JSON.Parse(loader.GetDecompressedText());
            if (!parsedContent[StatusKey].Value.Equals(OkValue))
            {
                Debug.LogError("Failure getting set version info for " + SetName + " - " + Version);
                yield break;
            }
            var parsedDetailLevels = parsedContent[ResultKey][DetailLevelsKey].AsArray;
            var sortedDetailLevels = new SortedDictionary <int, PyriteSetVersionDetailLevel>();

            for (var k = 0; k < parsedDetailLevels.Count; k++)
            {
                var detailLevel = new PyriteSetVersionDetailLevel
                {
                    Name  = parsedDetailLevels[k][NameKey],
                    Query = this
                };

                detailLevel.Value = Int32.Parse(detailLevel.Name.Substring(1));

                if (detailLevelsToFilter != null && detailLevelsToFilter.Contains(detailLevel.Value))
                {
                    Debug.Log("Skipping lod " + detailLevel.Value);
                    continue;
                }

                sortedDetailLevels[detailLevel.Value] = detailLevel;
                detailLevel.SetSize = new Vector3(
                    parsedDetailLevels[k][SetSizeKey][XKey].AsFloat,
                    parsedDetailLevels[k][SetSizeKey][YKey].AsFloat,
                    parsedDetailLevels[k][SetSizeKey][ZKey].AsFloat
                    );

                detailLevel.TextureSetSize = new Vector2(
                    parsedDetailLevels[k][TextureSetSizeKey][XKey].AsFloat,
                    parsedDetailLevels[k][TextureSetSizeKey][YKey].AsFloat
                    );

                detailLevel.ModelBoundsMax = new Vector3(
                    parsedDetailLevels[k][ModelBoundsKey][MaxKey][XKey].AsFloat,
                    parsedDetailLevels[k][ModelBoundsKey][MaxKey][YKey].AsFloat,
                    parsedDetailLevels[k][ModelBoundsKey][MaxKey][ZKey].AsFloat
                    );

                detailLevel.ModelBoundsMin = new Vector3(
                    parsedDetailLevels[k][ModelBoundsKey][MinKey][XKey].AsFloat,
                    parsedDetailLevels[k][ModelBoundsKey][MinKey][YKey].AsFloat,
                    parsedDetailLevels[k][ModelBoundsKey][MinKey][ZKey].AsFloat
                    );

                detailLevel.WorldBoundsMax = new Vector3(
                    parsedDetailLevels[k][WorldBoundsKey][MaxKey][XKey].AsFloat,
                    parsedDetailLevels[k][WorldBoundsKey][MaxKey][YKey].AsFloat,
                    parsedDetailLevels[k][WorldBoundsKey][MaxKey][ZKey].AsFloat
                    );

                detailLevel.WorldBoundsMin = new Vector3(
                    parsedDetailLevels[k][WorldBoundsKey][MinKey][XKey].AsFloat,
                    parsedDetailLevels[k][WorldBoundsKey][MinKey][YKey].AsFloat,
                    parsedDetailLevels[k][WorldBoundsKey][MinKey][ZKey].AsFloat
                    );

                detailLevel.WorldCubeScale = new Vector3(
                    parsedDetailLevels[k][WorldCubeScaleKey][XKey].AsFloat,
                    parsedDetailLevels[k][WorldCubeScaleKey][YKey].AsFloat,
                    parsedDetailLevels[k][WorldCubeScaleKey][ZKey].AsFloat);

                detailLevel.UpgradeDistance = detailLevel.WorldCubeScale.magnitude * _upgradeFactor + _upgradeConstant;

                detailLevel.DowngradeDistance = detailLevel.WorldCubeScale.magnitude * _downgradeFactor +
                                                _downgradeConstant;

                detailLevel.WorldBoundsSize =
                    detailLevel.WorldBoundsMax -
                    detailLevel.WorldBoundsMin;
            }

            DetailLevels = sortedDetailLevels.Values.ToArray();

            for (var i = DetailLevels.Length - 1; i > 0; i--)
            {
                if (DetailLevels[i].Value != DetailLevels[i - 1].Value + 1)
                {
                    DetailLevels[i].UpgradeDistance   *= 0.5f;
                    DetailLevels[i].DowngradeDistance *= 0.5f;
                }
            }
            Debug.Log("Metadata query completed.");
        }
Exemplo n.º 2
0
        IEnumerator Load()
        {
            tempPosition       = transform.position;
            transform.position = Vector3.zero;

            pyriteQuery = new PyriteQuery(this,
                                          SetName,
                                          ModelVersion,
                                          PyriteServer,
                                          UpgradeFactor,
                                          UpgradeConstant,
                                          DowngradeFactor,
                                          DowngradeConstant);
            yield return(StartCoroutine(pyriteQuery.LoadAll(FilterDetailLevels ? DetailLevelsToFilter : null)));

            pyriteLevel = pyriteQuery.DetailLevels[DetailLevel];
            var setSize = pyriteLevel.SetSize;

            if (DebugLogs)
            {
                Debug.Log("Set Size " + setSize);
            }

            var adjustedPos = new Vector3(
                -CameraRig.transform.position.x,
                -CameraRig.transform.position.z,
                CameraRig.transform.position.y - WorldYOffset);

            cubeCamPos = pyriteLevel.GetCubeForWorldCoordinates(adjustedPos);

            var worldObject = new GameObject("OctreeParent") as GameObject;

            worldObject.transform.position = Vector3.zero;
            worldObject.transform.rotation = Quaternion.identity;
            OctreeTracking = new GameObject("OctreeTracking") as GameObject;
            OctreeTracking.transform.position = Vector3.zero;
            OctreeTracking.transform.rotation = Quaternion.identity;

            if (ShowCubes)
            {
                foreach (var i in pyriteLevel.Octree.AllItems())
                {
                    var pCube   = CreateCubeFromCubeBounds(i);
                    var cubePos = pyriteLevel.GetWorldCoordinatesForCube(pCube);

                    var adjustedCubePos = new Vector3(
                        -cubePos.x,
                        cubePos.z + WorldYOffset,
                        -cubePos.y);
                    var loc = Instantiate(TranslucentCube, adjustedCubePos, Quaternion.identity) as GameObject;
                    loc.name = string.Format("Mesh:{0},{1},{2}", pCube.X, pCube.Y, pCube.Z);
                    loc.transform.localScale = new Vector3(
                        pyriteLevel.WorldCubeScale.x,
                        pyriteLevel.WorldCubeScale.z,
                        pyriteLevel.WorldCubeScale.y);
                    loc.transform.parent = worldObject.transform;
                }
            }

            transform.position = tempPosition;
            LoadCamCubes();
        }
Exemplo n.º 3
0
        protected virtual IEnumerator Load()
        {
            _pyriteQuery = new PyriteQuery(this, SetName, ModelVersion, PyriteServer, UpgradeFactor, UpgradeConstant,
                                           DowngradeFactor, DowngradeConstant);
            yield return(StartCoroutine(_pyriteQuery.LoadAll(FilterDetailLevels ? DetailLevelsToFilter : null)));

            var initialDetailLevelIndex = DetailLevel - 1;

            if (UseCameraDetection)
            {
                initialDetailLevelIndex = _pyriteQuery.DetailLevels.Length - 1;
            }

            _pyriteLevel = _pyriteQuery.DetailLevels[initialDetailLevelIndex];

            var allOctCubes = _pyriteQuery.DetailLevels[initialDetailLevelIndex].Octree.AllItems();

            foreach (var octCube in allOctCubes)
            {
                var pCube   = CreateCubeFromCubeBounds(octCube);
                var x       = pCube.X;
                var y       = pCube.Y;
                var z       = pCube.Z;
                var cubePos = _pyriteLevel.GetWorldCoordinatesForCube(pCube);
                _geometryBufferAltitudeTransform = 0 - _pyriteLevel.ModelBoundsMin.z;

                if (UseCameraDetection)
                {
                    var detectionCube = ObjectPooler.Current.GetPooledObject(PlaceHolderCube);
                    detectionCube.transform.position = new Vector3(-cubePos.x,
                                                                   cubePos.z + _geometryBufferAltitudeTransform, -cubePos.y);
                    detectionCube.transform.rotation = Quaternion.identity;
                    var meshRenderer = detectionCube.GetComponent <MeshRenderer>();
                    meshRenderer.enabled = true;
                    detectionCube.GetComponent <IsRendered>()
                    .SetCubePosition(x, y, z, initialDetailLevelIndex, _pyriteQuery, this);

                    detectionCube.transform.localScale = new Vector3(
                        _pyriteLevel.WorldCubeScale.x,
                        _pyriteLevel.WorldCubeScale.z,
                        _pyriteLevel.WorldCubeScale.y);

                    detectionCube.SetActive(true);
                }
                else
                {
                    var loadRequest = new LoadCubeRequest(x, y, z, initialDetailLevelIndex, _pyriteQuery, null);
                    yield return(StartCoroutine(EnqueueLoadCubeRequest(loadRequest)));
                }
            }

            if (CameraRig != null)
            {
                // Hardcodes the coordinate inversions which are parameterized on the geometry buffer

                var min = new Vector3(
                    -_pyriteLevel.ModelBoundsMin.x,
                    _pyriteLevel.ModelBoundsMin.z + _geometryBufferAltitudeTransform,
                    -_pyriteLevel.ModelBoundsMin.y);
                var max = new Vector3(
                    -_pyriteLevel.ModelBoundsMax.x,
                    _pyriteLevel.ModelBoundsMax.z + _geometryBufferAltitudeTransform,
                    -_pyriteLevel.ModelBoundsMax.y);

                //Kainiemi: Some mechanism needed to inform InputManager about the transform change
                var inputManager = CameraRig.GetComponent <PyriteDemoClient.InputManager>();
                if (inputManager != null)
                {
                    // Give input manager position limits based on model bounds
                    var highestLod = _pyriteQuery.DetailLevels.First();
                    var lowestLod  = _pyriteQuery.DetailLevels.Last();
                    inputManager.SetInputLimits(
                        new Vector3(highestLod.ModelBoundsMin.x + lowestLod.WorldCubeScale.x / 2,
                                    highestLod.ModelBoundsMin.z + _geometryBufferAltitudeTransform +
                                    lowestLod.WorldCubeScale.z / 3,
                                    highestLod.ModelBoundsMin.y + lowestLod.WorldCubeScale.y / 2),
                        new Vector3(highestLod.ModelBoundsMax.x - lowestLod.WorldCubeScale.x / 2,
                                    highestLod.ModelBoundsMax.z + _geometryBufferAltitudeTransform +
                                    (lowestLod.WorldCubeScale.z * 1.5f),
                                    highestLod.ModelBoundsMax.y - lowestLod.WorldCubeScale.y / 2));

                    if (AutomateCameraPositionOnLoad)
                    {
                        var newCameraPosition = min + (max - min) / 1.5f;
                        newCameraPosition           += new Vector3(0, (max - min).y * 2f, 0);
                        CameraRig.transform.position = newCameraPosition;
                        inputManager.NotifyOnTransformChange(CameraRig.transform.position);
                    }
                    else
                    {
                        inputManager.NotifyReadyForControl();
                    }
                }
            }
        }