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.");
}
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();
}
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();
}
}
}
}
