public IEnumerator Apply(MapMagic.CoordRect rect, Terrain terrain, object dataBox, Func <float, bool> stop = null)
{
Dictionary <Transform, List <ObjectPool.Transition> > transitions = (Dictionary <Transform, List <ObjectPool.Transition> >)dataBox;
var wrapper = terrain.gameObject.GetOrAddComponent <TerrainWrapper>();
var MMTerrainLayer = wrapper.GetLayer <MMTerrainLayer>(LayerName, false, true);
MMTerrainLayer.Objects.Clear();
//float pixelSize = 1f * global::MapMagic.MapMagic.instance.terrainSize / global::MapMagic.MapMagic.instance.resolution;
//Rect terrainRect = new Rect(rect.offset.x * pixelSize, rect.offset.z * pixelSize, rect.size.x * pixelSize, rect.size.z * pixelSize);
var terrainSize = terrain.terrainData.size;
//adding
foreach (KeyValuePair <Transform, List <ObjectPool.Transition> > kvp in transitions)
{
Transform prefab = kvp.Key;
List <ObjectPool.Transition> transitionsList = kvp.Value;
foreach (var transition in transitionsList)
{
var terrainSpacePos = transition.pos - terrain.transform.localPosition /*- terrainSize/2*/;
var normalisedPos = new Vector3(terrainSpacePos.x / terrainSize.x, transition.pos.y,
terrainSpacePos.z / terrainSize.z);
var prefabObj = new PrefabObjectData()
{
AbsoluteHeight = false,
Guid = System.Guid.NewGuid().ToString(),
Prefab = prefab.gameObject,
Rotation = transition.rotation.eulerAngles,
Position = normalisedPos,
Scale = transition.scale,
ContainerMetadata = LayerName,
};
MMTerrainLayer.Objects.Add(prefabObj);
}
}
global::MapMagic.MapMagic.OnApplyCompleted -= MapMagicIntegrationUtilities.MapMagicOnOnApplyCompleted;
global::MapMagic.MapMagic.OnApplyCompleted += MapMagicIntegrationUtilities.MapMagicOnOnApplyCompleted;
wrapper.OnPostFinalise -= ApplyStampsToTerrain;
if (ApplyStamps)
{
wrapper.OnPostFinalise += ApplyStampsToTerrain;
}
wrapper.SetDirtyAbove(MMTerrainLayer);
yield break;
}
public override void Apply(ProceduralLayer layer, TerrainWrapper wrapper)
{
const float margin = 0.01f;
var seed = layer.Seed;
var rand = new Random(seed);
var tBounds = wrapper.Terrain.GetBounds();
var step = StepDistance / tBounds.size.x;
var cellCount = Mathf.CeilToInt(tBounds.size.x / MinDistance);
bool[,] proximityCheck = new bool[cellCount, cellCount];
int counter = 0;
for (var u = margin; u < 1 - margin; u += step)
{
if (counter > MaxCount)
{
break;
}
for (var v = margin; v < 1 - margin; v += step)
{
if (counter > MaxCount)
{
break;
}
var cellX = Mathf.FloorToInt(u * cellCount);
var cellY = Mathf.FloorToInt(v * cellCount);
if (proximityCheck[cellX, cellY])
{
continue;
}
var normalizedPos = new Vector2(u, v);
var normal = wrapper.GetNormalFromHeightmap(normalizedPos);
if (normal.y > RequiredY)
{
continue;
}
var prefab = Prefabs.Random();
var prefabEntry = new PrefabObjectData()
{
Guid = Guid.NewGuid().ToString(),
Prefab = prefab,
Position = normalizedPos.x0z() + Offset.GetRand(rand),
Rotation = Rotation.GetRand(rand),
Scale = Scale.GetRand(rand),
};
layer.Objects.Add(prefabEntry);
counter++;
proximityCheck[cellX, cellY] = true;
}
}
Debug.Log(string.Format("GradientObjectPlacer placed {0} objects.", counter));
}
public override void ProcessObjects(TerrainWrapper wrapper, LayerBase baseLayer, int stencilKey)
{
var layer = baseLayer as MMTerrainLayer;
if (layer == null)
{
Debug.LogWarning(string.Format("Attempted to write {0} to incorrect layer type! Expected Layer {1} to be {2}, but it was {3}", name, baseLayer.name, GetLayerType(), baseLayer.GetType()), this);
return;
}
if (Configuration == null || !Network)
{
return;
}
var config = Configuration.GetConfig <Config>();
if (config == null)
{
Debug.LogError("Invalid config for ConnectionObjectComponent " + name, this);
return;
}
if (config.Objects == null || config.Objects.Count == 0)
{
return;
}
var seed = NodeConnection.ThisNode.Seed;
var rand = new Random(seed);
var spline = NodeConnection.GetSpline();
var length = spline.Length;
var step = config.Distance;
var tSize = wrapper.Terrain.terrainData.size;
for (var i = config.InitialOffset; i < length; i += step.GetRand(rand))
{
var randIndex = Mathf.FloorToInt((float)rand.NextDouble() * config.Objects.Count);
var prefab = config.Objects[randIndex];
var roll = (float)rand.NextDouble();
if (roll > config.Chance)
{
continue;
}
var offset = config.LocalOffset.GetRand(rand);
var scale = config.Scale.GetRand(rand);
if (config.UniformScale)
{
scale = Vector3.one * scale.x;
}
var uniformT = i / length;
var splineOffset = config.SplineOffset.GetRand(rand) * (rand.Flip() ? -1 : 1);
var tangent = spline.GetTangent(uniformT).normalized;
var rotation = Quaternion.LookRotation(tangent) * Quaternion.Euler(config.Rotation.GetRand(rand));
var worldPos = spline.GetUniformPointOnSpline(uniformT);
worldPos += tangent * splineOffset;
worldPos += offset;
if (!config.AbsoluteHeight)
{
worldPos.y = offset.y;
}
var tPos = worldPos - wrapper.transform.position;
tPos = new Vector3(tPos.x / tSize.x, tPos.y, tPos.z / tSize.z);
var prefabObject = new PrefabObjectData()
{
AbsoluteHeight = config.AbsoluteHeight,
Guid = Guid.NewGuid().ToString(),
Position = tPos,
Scale = scale,
Rotation = rotation.eulerAngles,
Prefab = prefab,
ContainerMetadata = layer.name,
};
layer.Objects.Add(prefabObject);
}
}
protected override void CaptureInternal(Terrain terrain, Bounds bounds)
{
#if UNITY_EDITOR
BoundsMapping.Clear();
Objects.Clear();
var expandedBounds = bounds;
expandedBounds.Expand(Vector3.up * 5000);
var terrainPos = terrain.GetPosition();
var allTransforms = Object.FindObjectsOfType <Transform>();
var done = new HashSet <Transform>();
allTransforms = allTransforms.OrderBy(transform => TransformExtensions.GetHierarchyDepth(transform)).ToArray();
HashSet <Transform> ignores = new HashSet <Transform>();
for (int i = 0; i < allTransforms.Length; i++)
{
var transform = allTransforms[i];
if (done.Contains(transform) || ignores.Contains(transform))
{
continue;
}
if (transform.GetComponent <TerrainCollider>())
{
continue;
}
if (!expandedBounds.Contains(transform.position))
{
continue;
}
var ws = transform.GetComponentInAncestors <WorldStamp>();
if (ws)
{
//Debug.Log(string.Format("WorldStamp Object Capture : Ignored {0} as it contained a WorldStamp. Recursive WorldStamps are currently not supported.", transform), transform);
ignores.Add(transform);
var children = ws.transform.GetComponentsInChildren <Transform>(true);
foreach (var ignore in children)
{
ignores.Add(ignore);
}
continue;
}
var rn = transform.GetComponentInAncestors <RoadNetwork>();
if (rn)
{
ignores.Add(rn.transform);
var children = rn.transform.GetComponentsInChildren <Transform>(true);
foreach (var ignore in children)
{
ignores.Add(ignore);
}
continue;
}
var template = transform.GetComponentInAncestors <WorldStampTemplate>();
if (template)
{
ignores.Add(template.transform);
var children = template.transform.GetComponentsInChildren <Transform>(true);
foreach (var ignore in children)
{
ignores.Add(ignore);
}
continue;
}
var go = transform.gameObject;
if (Mask != (Mask | (1 << go.layer)))
{
continue;
}
var prefabRoot = PrefabUtility.GetPrefabObject(go);
if (prefabRoot == null)
{
//DebugHelper.DrawCube(collider.bounds.center, collider.bounds.extents, Quaternion.identity, Color.red, 30);
continue;
}
done.Add(transform);
var subTransforms = transform.GetComponentsInChildren <Transform>();
foreach (var childTransform in subTransforms)
{
done.Add(childTransform);
}
#if UNITY_2018_2_OR_NEWER
var prefabAsset = PrefabUtility.FindPrefabRoot(PrefabUtility.GetCorrespondingObjectFromSource(go) as GameObject);
#else
var prefabAsset = PrefabUtility.FindPrefabRoot(PrefabUtility.GetPrefabParent(go) as GameObject);
#endif
var root = PrefabUtility.FindPrefabRoot(go);
var relativePos = root.transform.position - bounds.min;
relativePos = new Vector3(relativePos.x / bounds.size.x, 0, relativePos.z / bounds.size.z);
if (RelativeMode == WorldStamp.EObjectRelativeMode.RelativeToTerrain)
{
var terrainHeightAtPoint = terrain.SampleHeight(root.transform.position);
relativePos.y = (root.transform.position.y - terrainHeightAtPoint);
}
else
{
relativePos.y = root.transform.position.y;
}
relativePos.y -= terrainPos.y;
var newData = new PrefabObjectData()
{
AbsoluteHeight = RelativeMode == WorldStamp.EObjectRelativeMode.RelativeToStamp,
Prefab = prefabAsset,
Position = relativePos,
Rotation = root.transform.rotation.eulerAngles,
Scale = root.transform.lossyScale,
Guid = GUID.Generate().ToString(),
};
var c = transform.GetComponentInChildren <Collider>();
if (c)
{
BoundsMapping[newData] = c.bounds;
}
else
{
var r = transform.GetComponentInChildren <Renderer>();
if (r)
{
BoundsMapping[newData] = r.bounds;
}
}
done.Add(root.transform);
var doneChildren = root.transform.GetComponentsInChildren <Transform>(true);
foreach (var item in doneChildren)
{
done.Add(item);
}
Objects.Add(newData);
}
#endif
}
public InstantiatedObjectData(PrefabObjectData data, LayerBase owner, GameObject instantiatedObj)
{
Data = data;
Owner = owner;
InstantiatedObject = instantiatedObj;
}
