void SpawnNodeItem(NodeSpawnData data, NodeListExecutionContext context)
{
GameObject dungeonItem = null;
var nodeData = data.nodeData;
if (nodeData is GameObjectPropTypeData)
{
var gameObjectProp = nodeData as GameObjectPropTypeData;
dungeonItem = context.SceneProvider.AddGameObject(gameObjectProp, data.transform, context.objectInstantiator);
}
else if (nodeData is GameObjectArrayPropTypeData)
{
var gameObjectArrayProp = nodeData as GameObjectArrayPropTypeData;
int count = gameObjectArrayProp.Templates.Length;
int index = Mathf.FloorToInt(random.GetNextUniformFloat() * count) % count;
dungeonItem = context.SceneProvider.AddGameObjectFromArray(gameObjectArrayProp, index, data.transform, context.objectInstantiator);
}
else if (nodeData is SpritePropTypeData)
{
var spriteProp = nodeData as SpritePropTypeData;
dungeonItem = context.SceneProvider.AddSprite(spriteProp, data.transform, context.objectInstantiator);
}
TagDungeonItemUserData(dungeonItem, data.socket.cellId);
}
void ExecuteNodesUnderMarker(NodeListExecutionData data, NodeListExecutionContext context, List <NodeSpawnData> spawnDataList)
{
var socket = data.socket;
var nodeDataList = data.nodeDataList;
foreach (PropTypeData nodeData in nodeDataList)
{
bool insertMesh = false;
Matrix4x4 transform = socket.Transform * nodeData.Offset;
if (nodeData.UseSelectionRule && nodeData.SelectorRuleClassName != null)
{
var selectorRule = context.instanceCache.GetInstance(nodeData.SelectorRuleClassName) as SelectorRule;
if (selectorRule != null)
{
// Run the selection rule logic to determine if we need to insert this mesh in the scene
insertMesh = selectorRule.CanSelect(socket, transform, model, random.UniformRandom);
}
}
else
{
// Perform probability based selection logic
float probability = context.srandom.GetNextUniformFloat();
insertMesh = (probability < nodeData.Affinity);
}
if (insertMesh && nodeData.useSpatialConstraint && nodeData.spatialConstraint != null)
{
Matrix4x4 spatialOffset;
PropSocket[] markersToRemove;
if (!ProcessSpatialConstraint(context.constraintProcessor, nodeData.spatialConstraint, socket, out spatialOffset, out markersToRemove))
{
// Fails spatial constraint
insertMesh = false;
}
else
{
// Apply the offset
var markerOffset = socket.Transform;
if (nodeData.spatialConstraint != null && !nodeData.spatialConstraint.applyMarkerRotation)
{
var markerPosition = Matrix.GetTranslation(ref markerOffset);
var markerScale = Matrix.GetScale(ref markerOffset);
markerOffset = Matrix4x4.TRS(markerPosition, Quaternion.identity, markerScale);
}
transform = markerOffset * spatialOffset * nodeData.Offset;
foreach (var markerToRemove in markersToRemove)
{
markerToRemove.markForDeletion = true;
}
}
}
if (insertMesh)
{
// Attach this prop to the socket
// Apply transformation logic, if specified
if (nodeData.UseTransformRule && nodeData.TransformRuleClassName != null && nodeData.TransformRuleClassName.Length > 0)
{
var transformer = context.instanceCache.GetInstance(nodeData.TransformRuleClassName) as TransformationRule;
if (transformer != null)
{
Vector3 _position, _scale;
Quaternion _rotation;
transformer.GetTransform(socket, model, transform, random.UniformRandom, out _position, out _rotation, out _scale);
var offset = Matrix4x4.TRS(_position, _rotation, _scale);
transform = transform * offset;
}
}
// Create a spawn request
var spawnData = new NodeSpawnData();
spawnData.nodeData = nodeData;
spawnData.transform = transform;
spawnData.socket = socket;
spawnDataList.Add(spawnData);
// Add child sockets if any
foreach (PropChildSocketData ChildSocket in nodeData.ChildSockets)
{
Matrix4x4 childTransform = transform * ChildSocket.Offset;
var childMarker = EmitMarker(ChildSocket.SocketType, childTransform, socket.gridPosition, socket.cellId);
data.socket.childMarkers.Add(childMarker);
}
if (nodeData.ConsumeOnAttach)
{
// Attach no more on this socket
break;
}
}
}
}
