// Sets player to gound level at position in specified terrain
// Terrain data must already be loaded
// LocalGPS must be attached to your player game object
private void PositionPlayerToTerrain(int mapPixelX, int mapPixelY, Vector3 position)
{
// Get terrain key
int key = TerrainHelper.MakeTerrainKey(mapPixelX, mapPixelY);
if (!terrainIndexDict.ContainsKey(key))
{
return;
}
// Get terrain
Terrain terrain = terrainArray[terrainIndexDict[key]].terrainObject.GetComponent <Terrain>();
// Sample height at this position
CapsuleCollider collider = LocalPlayerGPS.gameObject.GetComponent <CapsuleCollider>();
if (collider)
{
Vector3 pos = new Vector3(position.x, 0, position.z);
float height = terrain.SampleHeight(pos + terrain.transform.position);
pos.y = height + collider.height * 1.5f;
// Move player to this position and align to ground using raycast
LocalPlayerGPS.transform.position = pos;
FixStanding(LocalPlayerGPS.transform, collider.height);
}
else
{
throw new Exception("StreamingWorld: Could not find CapsuleCollider peered with LocalPlayerGPS.");
}
}
// Fully init central terrain so player can be dropped into world as soon as possible
private void InitPlayerTerrain()
{
if (!init)
{
return;
}
#if SHOW_LAYOUT_TIMES
System.Diagnostics.Stopwatch stopwatch = System.Diagnostics.Stopwatch.StartNew();
long startTime = stopwatch.ElapsedMilliseconds;
#endif
CollectLocations(true);
int playerTerrainIndex = terrainIndexDict[TerrainHelper.MakeTerrainKey(MapPixelX, MapPixelY)];
UpdateTerrainData(terrainArray[playerTerrainIndex]);
terrainArray[playerTerrainIndex].updateData = false;
UpdateTerrainNature(terrainArray[playerTerrainIndex]);
terrainArray[playerTerrainIndex].updateNature = false;
StartCoroutine(UpdateLocation(playerTerrainIndex, false));
terrainArray[playerTerrainIndex].updateLocation = false;
#if SHOW_LAYOUT_TIMES
long totalTime = stopwatch.ElapsedMilliseconds - startTime;
DaggerfallUnity.LogMessage(string.Format("Time to init player terrain: {0}ms", totalTime), true);
#endif
}
// Finds next available terrain in array
private int FindNextAvailableTerrain()
{
// Evaluate terrain array
int found = -1;
for (int i = 0; i < terrainArray.Length; i++)
{
// A null terrain has never been instantiated and is free
if (terrainArray[i].terrainObject == null)
{
found = i;
break;
}
// Inactive terrain object can be evaluated for recycling based
// on distance from current map pixel
if (!terrainArray[i].active)
{
// If terrain out of range then recycle
if (!IsInRange(terrainArray[i].mapPixelX, terrainArray[i].mapPixelY))
{
found = i;
break;
}
}
}
// Was a terrain found?
if (found != -1)
{
// If we are recycling an inactive terrain, remove it from dictionary first
int key = TerrainHelper.MakeTerrainKey(terrainArray[found].mapPixelX, terrainArray[found].mapPixelY);
if (terrainIndexDict.ContainsKey(key))
{
terrainIndexDict.Remove(key);
}
return(found);
}
else
{
// Unable to find an available terrain
// This should never happen unless TerrainDistance too high or maxTerrainArray too low
DaggerfallUnity.LogMessage("StreamingWorld: Unable to find free terrain. Check maxTerrainArray is sized appropriately and you are collecting terrains. This can also happen when player movement speed too high.", true);
if (Application.isEditor)
{
Debug.Break();
}
else
{
Application.Quit();
}
return(-1);
}
}
// Gets transform of the terrain player is standing on
private Transform GetPlayerTerrainTransform()
{
int key = TerrainHelper.MakeTerrainKey(MapPixelX, MapPixelY);
if (!terrainIndexDict.ContainsKey(key))
{
return(null);
}
return(terrainArray[terrainIndexDict[key]].terrainObject.transform);
}
// Gets terrain at map pixel coordinates, or null if not found
private Terrain GetTerrain(int mapPixelX, int mapPixelY)
{
int key = TerrainHelper.MakeTerrainKey(mapPixelX, mapPixelY);
if (terrainIndexDict.ContainsKey(key))
{
return(terrainArray[terrainIndexDict[key]].terrainObject.GetComponent <Terrain>());
}
return(null);
}
/// <summary>
/// Returns terrain GameObject from mapPixel, or null if
/// no terrain objects are mapped to that pixel
/// </summary>
public GameObject GetTerrainFromPixel(int mapPixelX, int mapPixelY)//##Lypyl
{
//Get Key for terrain lookup
int key = TerrainHelper.MakeTerrainKey(mapPixelX, mapPixelY);
if (terrainIndexDict.ContainsKey(key))
{
return(terrainArray[terrainIndexDict[key]].terrainObject);
}
else
{
return(null);
}
}
// Place a single terrain and mark it for update
private void PlaceTerrain(int mapPixelX, int mapPixelY)
{
// Do nothing if out of range
if (mapPixelX < MapsFile.MinMapPixelX || mapPixelX >= MapsFile.MaxMapPixelX ||
mapPixelY < MapsFile.MinMapPixelY || mapPixelY >= MapsFile.MaxMapPixelY)
{
return;
}
// Get terrain key
int key = TerrainHelper.MakeTerrainKey(mapPixelX, mapPixelY);
// If terrain is available
if (terrainIndexDict.ContainsKey(key))
{
// Terrain exists, check if active
int index = terrainIndexDict[key];
if (terrainArray[index].active)
{
// Terrain already active in scene, nothing to do
return;
}
else
{
// Terrain inactive but available, re-activate terrain
terrainArray[index].active = true;
terrainArray[index].terrainObject.SetActive(true);
terrainArray[index].billboardBatchObject.SetActive(true);
}
return;
}
// Need to place a new terrain, find next available terrain
// This will either find a fresh terrain or recycle an old one
int nextTerrain = FindNextAvailableTerrain();
if (nextTerrain == -1)
{
return;
}
// Setup new terrain
terrainArray[nextTerrain].active = true;
terrainArray[nextTerrain].updateHeights = true;
terrainArray[nextTerrain].updateNature = true;
terrainArray[nextTerrain].mapPixelX = mapPixelX;
terrainArray[nextTerrain].mapPixelY = mapPixelY;
if (!terrainArray[nextTerrain].terrainObject)
{
// Create game objects for new terrain
// This is only done once then recycled
CreateTerrainGameObjects(
mapPixelX,
mapPixelY,
out terrainArray[nextTerrain].terrainObject,
out terrainArray[nextTerrain].billboardBatchObject);
}
// Apply local transform
float scale = MapsFile.WorldMapTerrainDim * MeshReader.GlobalScale;
int xdif = mapPixelX - mapOrigin.X;
int ydif = mapPixelY - mapOrigin.Y;
Vector3 localPosition = new Vector3(xdif * scale, 0, -ydif * scale);
terrainArray[nextTerrain].terrainObject.transform.localPosition = localPosition;
// Add new terrain index to dictionary
terrainIndexDict.Add(key, nextTerrain);
// Check if terrain has a location, if so it will be added on next update
ContentReader.MapSummary mapSummary;
if (dfUnity.ContentReader.HasLocation(mapPixelX, mapPixelY, out mapSummary))
{
terrainArray[nextTerrain].hasLocation = true;
}
}
// Update terrain data
// Spreads loading across several frames to reduce gameplay stalls
// This can also be done using true multi-threading, but at much greater
// complexity for only minor visible gains.
// Only yields after initial init complete
private IEnumerator UpdateTerrains()
{
// First stage updates terrain heightmaps
for (int i = 0; i < terrainArray.Length; i++)
{
if (terrainArray[i].active && terrainArray[i].updateHeights)
{
UpdateTerrainHeights(terrainArray[i]);
terrainArray[i].updateHeights = false;
if (!init)
{
yield return(new WaitForEndOfFrame());
}
}
}
// Wait for physics update when streaming
if (!init)
{
yield return(new WaitForFixedUpdate());
}
// Second stage updates terrain nature
for (int i = 0; i < terrainArray.Length; i++)
{
if (terrainArray[i].active && terrainArray[i].updateNature)
{
UpdateTerrainNature(terrainArray[i]);
terrainArray[i].updateNature = false;
if (!init)
{
yield return(new WaitForEndOfFrame());
}
}
}
// Get key for central player terrain
int playerKey = TerrainHelper.MakeTerrainKey(MapPixelX, MapPixelY);
// Third stage updates location if present
// Vast majority of terrains will not have a location
// Locations are not optimised as yet and are quite heavy on drawcalls
for (int i = 0; i < terrainArray.Length; i++)
{
// Get key for this terrain
int key = TerrainHelper.MakeTerrainKey(terrainArray[i].mapPixelX, terrainArray[i].mapPixelY);
if (terrainArray[i].active && terrainArray[i].hasLocation)
{
// Create location if not present
if (!locationDict.ContainsKey(key))
{
// Create location object
DFLocation location;
GameObject locationObject = CreateLocationGameObject(i, out location);
if (!locationObject)
{
continue;
}
// Add location object to dictionary
locationDict.Add(key, locationObject);
// Create location beacon
// This is parented to location and shares its lifetime
if (AddLocationBeacon)
{
const float beaconHeight = 900f;
const float beaconOffset = (MapsFile.WorldMapTerrainDim * MeshReader.GlobalScale) / 2f;
GameObject locationMarker = (GameObject)GameObject.Instantiate(Resources.Load <GameObject>("LocationBeacon"));
locationMarker.hideFlags = HideFlags.HideAndDontSave;
locationMarker.transform.parent = locationObject.transform;
locationMarker.transform.localPosition = new Vector3(beaconOffset, beaconHeight, beaconOffset);
}
// Add one nature batch for entire location
// This is parented to location and shares its lifetime
GameObject natureBatchObject = new GameObject("NatureBatch");
natureBatchObject.hideFlags = HideFlags.HideAndDontSave;
natureBatchObject.transform.parent = locationObject.transform;
natureBatchObject.transform.localPosition = Vector3.zero;
DaggerfallBillboardBatch natureBatch = natureBatchObject.AddComponent <DaggerfallBillboardBatch>();
int natureArchive = ClimateSwaps.GetNatureArchive(LocalPlayerGPS.ClimateSettings.NatureSet, dfUnity.WorldTime.Now.SeasonValue);
natureBatch.SetMaterial(natureArchive);
// RMB blocks are laid out in centre of terrain to align with ground
int width = location.Exterior.ExteriorData.Width;
int height = location.Exterior.ExteriorData.Height;
float offsetX = ((8 * RMBLayout.RMBSide) - (width * RMBLayout.RMBSide)) / 2;
float offsetZ = ((8 * RMBLayout.RMBSide) - (height * RMBLayout.RMBSide)) / 2;
Vector3 origin = new Vector3(offsetX, 2.0f * MeshReader.GlobalScale, offsetZ);
// Perform layout and yield after each block is placed
DaggerfallLocation dfLocation = locationObject.GetComponent <DaggerfallLocation>();
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
// Set origin for billboard batch add
// This causes next additions to be offset by this position
Vector3 blockOrigin = origin + new Vector3((x * RMBLayout.RMBSide), 0, (y * RMBLayout.RMBSide));
natureBatch.origin = blockOrigin;
// Add block and yield
string blockName = dfUnity.ContentReader.BlockFileReader.CheckName(dfUnity.ContentReader.MapFileReader.GetRmbBlockName(ref location, x, y));
GameObject go = RMBLayout.CreateGameObject(blockName, true, natureBatch);
go.hideFlags = HideFlags.HideAndDontSave;
go.transform.parent = locationObject.transform;
go.transform.localPosition = blockOrigin;
dfLocation.ApplyClimateSettings();
if (!init)
{
yield return(new WaitForEndOfFrame());
}
}
}
// If this is the player terrain we may need to reposition player
if (playerKey == key && repositionPlayer)
{
// Position to location and use start marker for large cities
bool useStartMarker = (dfLocation.Summary.LocationType == DFRegion.LocationTypes.TownCity);
PositionPlayerToLocation(MapPixelX, MapPixelY, dfLocation, origin, width, height, useStartMarker);
repositionPlayer = false;
}
// Apply nature batch
natureBatch.Apply();
}
}
else if (terrainArray[i].active)
{
if (playerKey == key && repositionPlayer)
{
PositionPlayerToTerrain(MapPixelX, MapPixelY, Vector3.zero);
repositionPlayer = false;
}
}
}
// If this is an init we can use the load time to unload unused assets
// Keeps memory usage much lower over time
if (init)
{
Resources.UnloadUnusedAssets();
}
// Finish by collecting stale data and setting neighbours
CollectTerrains();
CollectLocations();
UpdateNeighbours();
}
public virtual void LayoutNature(DaggerfallTerrain dfTerrain, DaggerfallBillboardBatch dfBillboardBatch, float terrainScale, int terrainDist)
{
// Location Rect is expanded slightly to give extra clearance around locations
Rect rect = dfTerrain.MapData.locationRect;
if (rect.x > 0 && rect.y > 0)
{
rect.xMin -= natureClearance;
rect.xMax += natureClearance;
rect.yMin -= natureClearance;
rect.yMax += natureClearance;
}
// Chance scaled based on map pixel height
// This tends to produce sparser lowlands and denser highlands
// Adjust or remove clamp range to influence nature generation
float elevationScale = (dfTerrain.MapData.worldHeight / 128f);
elevationScale = Mathf.Clamp(elevationScale, 0.4f, 1.0f);
// Chance scaled by base climate type
float climateScale = 1.0f;
DFLocation.ClimateSettings climate = MapsFile.GetWorldClimateSettings(dfTerrain.MapData.worldClimate);
switch (climate.ClimateType)
{
case DFLocation.ClimateBaseType.Desert: // Just lower desert for now
climateScale = 0.25f;
break;
}
float chanceOnDirt = baseChanceOnDirt * elevationScale * climateScale;
float chanceOnGrass = baseChanceOnGrass * elevationScale * climateScale;
float chanceOnStone = baseChanceOnStone * elevationScale * climateScale;
// Get terrain
Terrain terrain = dfTerrain.gameObject.GetComponent <Terrain>();
if (!terrain)
{
return;
}
// Get terrain data
TerrainData terrainData = terrain.terrainData;
if (!terrainData)
{
return;
}
// Remove exiting billboards
dfBillboardBatch.Clear();
MeshReplacement.ClearNatureGameObjects(terrain);
// Seed random with terrain key
Random.InitState(TerrainHelper.MakeTerrainKey(dfTerrain.MapPixelX, dfTerrain.MapPixelY));
// Just layout some random flats spread evenly across entire map pixel area
// Flats are aligned with tiles, max 16129 billboards per batch
Vector2 tilePos = Vector2.zero;
int tDim = MapsFile.WorldMapTileDim;
int hDim = DaggerfallUnity.Instance.TerrainSampler.HeightmapDimension;
float scale = terrainData.heightmapScale.x * (float)hDim / (float)tDim;
float maxTerrainHeight = DaggerfallUnity.Instance.TerrainSampler.MaxTerrainHeight;
float beachLine = DaggerfallUnity.Instance.TerrainSampler.BeachElevation;
for (int y = 0; y < tDim; y++)
{
for (int x = 0; x < tDim; x++)
{
// Reject based on steepness
float steepness = terrainData.GetSteepness((float)x / tDim, (float)y / tDim);
if (steepness > maxSteepness)
{
continue;
}
// Reject if inside location rect (expanded slightly to give extra clearance around locations)
tilePos.x = x;
tilePos.y = y;
if (rect.x > 0 && rect.y > 0 && rect.Contains(tilePos))
{
continue;
}
// Chance also determined by tile type
int tile = dfTerrain.MapData.tilemapSamples[x, y] & 0x3F;
if (tile == 1)
{ // Dirt
if (Random.Range(0f, 1f) > chanceOnDirt)
{
continue;
}
}
else if (tile == 2)
{ // Grass
if (Random.Range(0f, 1f) > chanceOnGrass)
{
continue;
}
}
else if (tile == 3)
{ // Stone
if (Random.Range(0f, 1f) > chanceOnStone)
{
continue;
}
}
else
{ // Anything else
continue;
}
int hx = (int)Mathf.Clamp(hDim * ((float)x / (float)tDim), 0, hDim - 1);
int hy = (int)Mathf.Clamp(hDim * ((float)y / (float)tDim), 0, hDim - 1);
float height = dfTerrain.MapData.heightmapSamples[hy, hx] * maxTerrainHeight; // x & y swapped in heightmap for TerrainData.SetHeights()
// Reject if too close to water
if (height < beachLine)
{
continue;
}
// Sample height and position billboard
Vector3 pos = new Vector3(x * scale, 0, y * scale);
float height2 = terrain.SampleHeight(pos + terrain.transform.position);
pos.y = height2 - (steepness / slopeSinkRatio);
// Add to batch unless a mesh replacement is found
int record = Random.Range(1, 32);
if (terrainDist > 1 || !MeshReplacement.ImportNatureGameObject(dfBillboardBatch.TextureArchive, record, terrain, x, y))
{
dfBillboardBatch.AddItem(record, pos);
}
else if (!NatureMeshUsed)
{
NatureMeshUsed = true; // Signal that nature mesh has been used to initiate extra terrain updates
}
}
}
// Apply new batch
dfBillboardBatch.Apply();
}
private IEnumerator UpdateLocation(int index, bool allowYield)
{
int key = TerrainHelper.MakeTerrainKey(terrainArray[index].mapPixelX, terrainArray[index].mapPixelY);
int playerKey = TerrainHelper.MakeTerrainKey(MapPixelX, MapPixelY);
bool isPlayerTerrain = (key == playerKey);
if (terrainArray[index].active && terrainArray[index].hasLocation && terrainArray[index].updateLocation)
{
// Disable update flag
terrainArray[index].updateLocation = false;
// Create location object
DFLocation location;
GameObject locationObject = CreateLocationGameObject(index, out location);
if (locationObject)
{
// Add location object to dictionary
LocationDesc locationDesc = new LocationDesc();
locationDesc.locationObject = locationObject;
locationDesc.mapPixelX = terrainArray[index].mapPixelX;
locationDesc.mapPixelY = terrainArray[index].mapPixelY;
locationList.Add(locationDesc);
// Create billboard batch game objects for this location
// Streaming world always batches for performance, regardless of options
int natureArchive = ClimateSwaps.GetNatureArchive(LocalPlayerGPS.ClimateSettings.NatureSet, dfUnity.WorldTime.Now.SeasonValue);
TextureAtlasBuilder miscBillboardAtlas = dfUnity.MaterialReader.MiscBillboardAtlas;
DaggerfallBillboardBatch natureBillboardBatch = GameObjectHelper.CreateBillboardBatchGameObject(natureArchive, locationObject.transform);
DaggerfallBillboardBatch lightsBillboardBatch = GameObjectHelper.CreateBillboardBatchGameObject(TextureReader.LightsTextureArchive, locationObject.transform);
DaggerfallBillboardBatch animalsBillboardBatch = GameObjectHelper.CreateBillboardBatchGameObject(TextureReader.AnimalsTextureArchive, locationObject.transform);
DaggerfallBillboardBatch miscBillboardBatch = GameObjectHelper.CreateBillboardBatchGameObject(miscBillboardAtlas.AtlasMaterial, locationObject.transform);
// Set hide flags
natureBillboardBatch.hideFlags = HideFlags.HideAndDontSave;
lightsBillboardBatch.hideFlags = HideFlags.HideAndDontSave;
animalsBillboardBatch.hideFlags = HideFlags.HideAndDontSave;
miscBillboardBatch.hideFlags = HideFlags.HideAndDontSave;
// RMB blocks are laid out in centre of terrain to align with ground
int width = location.Exterior.ExteriorData.Width;
int height = location.Exterior.ExteriorData.Height;
float offsetX = ((8 * RMBLayout.RMBSide) - (width * RMBLayout.RMBSide)) / 2;
float offsetZ = ((8 * RMBLayout.RMBSide) - (height * RMBLayout.RMBSide)) / 2;
Vector3 origin = new Vector3(offsetX, 2.0f * MeshReader.GlobalScale, offsetZ);
// Get location data
DaggerfallLocation dfLocation = locationObject.GetComponent <DaggerfallLocation>();
// Perform layout and yield after each block is placed
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
// Set block origin for billboard batches
// This causes next additions to be offset by this position
Vector3 blockOrigin = origin + new Vector3((x * RMBLayout.RMBSide), 0, (y * RMBLayout.RMBSide));
natureBillboardBatch.BlockOrigin = blockOrigin;
lightsBillboardBatch.BlockOrigin = blockOrigin;
animalsBillboardBatch.BlockOrigin = blockOrigin;
miscBillboardBatch.BlockOrigin = blockOrigin;
// Add block and yield
string blockName = dfUnity.ContentReader.BlockFileReader.CheckName(dfUnity.ContentReader.MapFileReader.GetRmbBlockName(ref location, x, y));
GameObject go = GameObjectHelper.CreateRMBBlockGameObject(
blockName,
false,
dfUnity.Option_CityBlockPrefab,
natureBillboardBatch,
lightsBillboardBatch,
animalsBillboardBatch,
miscBillboardAtlas,
miscBillboardBatch);
go.hideFlags = HideFlags.HideAndDontSave;
go.transform.parent = locationObject.transform;
go.transform.localPosition = blockOrigin;
dfLocation.ApplyClimateSettings();
if (allowYield)
{
yield return(new WaitForEndOfFrame());
}
}
}
// If this is the player terrain we may need to reposition player
if (isPlayerTerrain && repositionPlayer)
{
// Position to location and use start marker for large cities
bool useStartMarker = (dfLocation.Summary.LocationType == DFRegion.LocationTypes.TownCity);
PositionPlayerToLocation(MapPixelX, MapPixelY, dfLocation, origin, width, height, useStartMarker);
repositionPlayer = false;
}
// Apply billboard batches
natureBillboardBatch.Apply();
lightsBillboardBatch.Apply();
animalsBillboardBatch.Apply();
miscBillboardBatch.Apply();
}
}
else if (terrainArray[index].active)
{
if (playerKey == key && repositionPlayer)
{
PositionPlayerToTerrain(MapPixelX, MapPixelY, Vector3.zero);
repositionPlayer = false;
}
}
}
