private IEnumerator SendRaycastQueryMessage <T, T2>
(
WebInterface.SceneEvent <T> sceneEvent,
T response,
System.Func <WebInterface.SceneEvent <T>, bool> OnMessageReceived
)
where T2 : WebInterface.RaycastHitInfo
where T : WebInterface.RaycastResponse <T2>
{
string targetEventType = "SceneEvent";
sceneEvent.sceneId = scene.sceneData.id;
sceneEvent.payload = response;
sceneEvent.eventType = "raycastResponse";
yield return(TestHelpers.ExpectMessageToKernel(
targetEventType,
sceneEvent,
() =>
{
// Note (Zak): we send several times the same message to ensure it's
// only processed once (lossy messages)
sceneController.SendSceneMessage(System.Convert.ToBase64String(sendSceneMessage.ToByteArray()));
sceneController.SendSceneMessage(System.Convert.ToBase64String(sendSceneMessage.ToByteArray()));
sceneController.SendSceneMessage(System.Convert.ToBase64String(sendSceneMessage.ToByteArray()));
},
OnMessageReceived));
}
private bool AreSceneEventsEqual <T, T2>(WebInterface.SceneEvent <T> s1, WebInterface.SceneEvent <T> s2) where T2 : WebInterface.RaycastHitInfo where T : WebInterface.RaycastResponse <T2>
{
Assert.IsTrue(s1.eventType == s2.eventType);
Assert.IsTrue(s1.sceneId == s2.sceneId);
if (s1.eventType != s2.eventType ||
s1.sceneId != s2.sceneId)
{
return(false);
}
return(AreRaycastResponsesEqual(s1.payload, s2.payload));
}
void ChangeEntityComponent(EntitySingleComponentPayload payload, ParcelScene scene)
{
modifyEntityComponentEvent.payload = payload;
WebInterface.SceneEvent <ModifyEntityComponentEvent> sceneEvent = new WebInterface.SceneEvent <ModifyEntityComponentEvent>();
sceneEvent.sceneId = scene.sceneData.id;
sceneEvent.eventType = BuilderInWorldSettings.STATE_EVENT_NAME;
sceneEvent.payload = modifyEntityComponentEvent;
//Note (Adrian): We use Newtonsoft instead of JsonUtility because we need to deal with super classes, JsonUtility doesn't encode them
string message = JsonConvert.SerializeObject(sceneEvent, Formatting.None, new JsonSerializerSettings
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
});
WebInterface.BuilderInWorldMessage(BuilderInWorldSettings.SCENE_EVENT_NAME, message);
}
public static IEnumerator TestUIOnPointerUpEventPropagation(string sceneId, string eventUuid, RectTransform uiObject, System.Action <bool> callback)
{
// We need to populate the event data with the 'pointerPressRaycast' pointing to the 'clicked' object
PointerEventData pointerEventData = new PointerEventData(EventSystem.current);
RaycastResult raycastResult = new RaycastResult();
raycastResult.gameObject = uiObject.gameObject;
pointerEventData.pointerPressRaycast = raycastResult;
string targetEventType = "SceneEvent";
var onPointerUpEvent = new WebInterface.OnPointerUpEvent();
onPointerUpEvent.uuid = eventUuid;
var sceneEvent = new WebInterface.SceneEvent <WebInterface.OnPointerUpEvent>();
sceneEvent.sceneId = sceneId;
sceneEvent.payload = onPointerUpEvent;
sceneEvent.eventType = "uuidEvent";
string eventJSON = JsonUtility.ToJson(sceneEvent);
bool eventTriggered = false;
yield return(TestHelpers.WaitForMessageFromEngine(targetEventType, eventJSON,
() =>
{
ExecuteEvents.ExecuteHierarchy(raycastResult.gameObject, pointerEventData,
ExecuteEvents.pointerDownHandler);
},
() =>
{
eventTriggered = true;
}));
yield return(null);
// Callback!
if (callback != null)
{
callback(eventTriggered);
}
}
void SendNewEntityToKernel(string sceneId, string entityId, ComponentPayload[] componentsPayload)
{
AddEntityEvent addEntityEvent = new AddEntityEvent();
entityPayload.entityId = entityId;
entityPayload.components = componentsPayload;
addEntityEvent.payload = entityPayload;
WebInterface.SceneEvent <AddEntityEvent> sceneEvent = new WebInterface.SceneEvent <AddEntityEvent>();
sceneEvent.sceneId = sceneId;
sceneEvent.eventType = BuilderInWorldSettings.STATE_EVENT_NAME;
sceneEvent.payload = addEntityEvent;
//Note(Adrian): We use Newtonsoft instead of JsonUtility because we need to deal with super classes, JsonUtility doesn't encode them
string message = JsonConvert.SerializeObject(sceneEvent);
WebInterface.BuilderInWorldMessage(BuilderInWorldSettings.SCENE_EVENT_NAME, message);
}
public IEnumerator TestOnClickEvent()
{
yield return(InputTextCreate());
//------------------------------------------------------------------------
// Test click events
TMPro.TMP_InputField inputField = textInput.referencesContainer.inputField;
string targetEventType = "SceneEvent";
var onClickEvent = new WebInterface.OnClickEvent();
onClickEvent.uuid = textInput.model.onClick;
var sceneEvent = new WebInterface.SceneEvent <WebInterface.OnClickEvent>();
sceneEvent.sceneId = scene.sceneData.id;
sceneEvent.payload = onClickEvent;
sceneEvent.eventType = "uuidEvent";
string eventJSON = JsonUtility.ToJson(sceneEvent);
bool eventTriggered = false;
yield return(TestHelpers.WaitForMessageFromEngine(targetEventType, eventJSON,
() =>
{
UnityEngine.EventSystems.EventSystem.current.SetSelectedGameObject(inputField.gameObject, null);
inputField.ActivateInputField();
inputField.Select();
},
() =>
{
eventTriggered = true;
}));
yield return(null);
Assert.IsTrue(eventTriggered);
}
public void EntityTransformReport(IDCLEntity entity, ParcelScene scene)
{
entitySingleComponentPayload.entityId = entity.entityId;
entitySingleComponentPayload.componentId = (int)CLASS_ID_COMPONENT.TRANSFORM;
entityTransformComponentModel.position = WorldStateUtils.ConvertUnityToScenePosition(entity.gameObject.transform.position, scene);
entityTransformComponentModel.rotation = new QuaternionRepresentation(entity.gameObject.transform.rotation);
entityTransformComponentModel.scale = entity.gameObject.transform.localScale;
entitySingleComponentPayload.data = entityTransformComponentModel;
modifyEntityComponentEvent.payload = entitySingleComponentPayload;
WebInterface.SceneEvent <ModifyEntityComponentEvent> sceneEvent = new WebInterface.SceneEvent <ModifyEntityComponentEvent>();
sceneEvent.sceneId = scene.sceneData.id;
sceneEvent.eventType = BuilderInWorldSettings.STATE_EVENT_NAME;
sceneEvent.payload = modifyEntityComponentEvent;
//Note (Adrian): We use Newtonsoft instead of JsonUtility because we need to deal with super classes, JsonUtility doesn't encode them
string message = JsonConvert.SerializeObject(sceneEvent);
WebInterface.BuilderInWorldMessage(BuilderInWorldSettings.SCENE_EVENT_NAME, message);
}
public IEnumerator HitFirst()
{
ConfigureRaycastQuery("HitFirst");
List <DecentralandEntity> entities = new List <DecentralandEntity>();
Vector3 pos = new Vector3(5, 0, 10);
for (int i = 0; i < ENTITIES_COUNT; i++)
{
BoxShape shape = TestHelpers.CreateEntityWithBoxShape(scene, pos);
yield return(shape.routine);
DecentralandEntity entity = shape.attachedEntities.First();
TestHelpers.SetEntityTransform(scene, entity, pos, Quaternion.identity, new Vector3(5, 10, 1));
yield return(null);
DCL.CollidersManager.i.ConfigureColliders(entity.meshRootGameObject, true, false, entity);
entities.Add(entity);
pos.z -= 2;
}
WebInterface.RaycastHitFirstResponse response = new WebInterface.RaycastHitFirstResponse();
response.queryType = raycastQuery.QueryType;
response.queryId = raycastQuery.QueryId;
response.payload = new WebInterface.RaycastHitEntity();
response.payload.ray = new WebInterface.RayInfo();
response.payload.ray.origin = new Vector3(raycastQuery.Ray.Origin.X, raycastQuery.Ray.Origin.Y, raycastQuery.Ray.Origin.Z);
response.payload.ray.distance = raycastQuery.Ray.Distance;
response.payload.ray.direction = new Vector3(raycastQuery.Ray.Direction.X, raycastQuery.Ray.Direction.Y, raycastQuery.Ray.Direction.Z);
response.payload.entity = new WebInterface.HitEntityInfo();
response.payload.entity.entityId = entities[0].entityId;
var sceneEvent = new WebInterface.SceneEvent <WebInterface.RaycastHitFirstResponse>();
bool eventTriggered = false;
int responseCount = 0;
yield return(SendRaycastQueryMessage <WebInterface.RaycastHitFirstResponse, WebInterface.RaycastHitEntity>(
sceneEvent, response,
(raycastResponse) =>
{
responseCount++;
Assert.IsTrue(responseCount == 1, "This raycast query should be lossy and therefore excecuted once.");
Assert.IsTrue(raycastResponse != null);
Assert.IsTrue(raycastResponse.payload.payload.entity.entityId == sceneEvent.payload.payload.entity.entityId);
if (raycastResponse != null &&
AreSceneEventsEqual <WebInterface.RaycastHitFirstResponse, WebInterface.RaycastHitEntity>(raycastResponse, sceneEvent) &&
raycastResponse.payload.payload.entity.entityId == sceneEvent.payload.payload.entity.entityId)
{
eventTriggered = true;
return true;
}
return false;
}));
Assert.IsTrue(eventTriggered);
}