bool EntityHasPointerEvent(IDCLEntity entity) { return(entity.components.ContainsKey(Models.CLASS_ID_COMPONENT.UUID_CALLBACK) || entity.components.ContainsKey(Models.CLASS_ID_COMPONENT.UUID_ON_UP) || entity.components.ContainsKey(Models.CLASS_ID_COMPONENT.UUID_ON_DOWN) || entity.components.ContainsKey(Models.CLASS_ID_COMPONENT.UUID_ON_CLICK)); }
public IEnumerator WorkCorrectlyWhenAttachedBeforeShape() { IDCLEntity entity = TestHelpers.CreateSceneEntity(scene); DCLTexture dclTexture = TestHelpers.CreateDCLTexture( scene, TestAssetsUtils.GetPath() + "/Images/atlas.png", DCLTexture.BabylonWrapMode.CLAMP, FilterMode.Bilinear); yield return(dclTexture.routine); BasicMaterial mat = TestHelpers.SharedComponentCreate <BasicMaterial, BasicMaterial.Model> (scene, CLASS_ID.BASIC_MATERIAL, new BasicMaterial.Model { texture = dclTexture.id, alphaTest = 0.5f }); yield return(mat.routine); TestHelpers.SharedComponentAttach(mat, entity); SphereShape shape = TestHelpers.SharedComponentCreate <SphereShape, SphereShape.Model>(scene, CLASS_ID.SPHERE_SHAPE, new SphereShape.Model { }); TestHelpers.SharedComponentAttach(shape, entity); Assert.IsTrue(entity.meshRootGameObject != null); Assert.IsTrue(entity.meshRootGameObject.GetComponent <MeshRenderer>() != null); Assert.AreEqual(entity.meshRootGameObject.GetComponent <MeshRenderer>().sharedMaterial, mat.material); }
protected virtual void OnEntityAdded(IDCLEntity e) { e.OnMeshesInfoUpdated += OnEntityMeshInfoUpdated; e.OnMeshesInfoCleaned += OnEntityMeshInfoCleaned; model.entities++; isDirty = true; }
public IEnumerator UnloadWhenEntityDestroyedBeforeFinishing() { GameObject meshRootGameObject = new GameObject(); string url = TestAssetsUtils.GetPath() + "/GLB/Trunk/Trunk.glb"; IDCLEntity entity = Substitute.For <IDCLEntity>(); entity.meshRootGameObject.Returns(meshRootGameObject); LoadWrapper_GLTF wrapper = Substitute.ForPartsOf <LoadWrapper_GLTF>(); wrapper.entity = entity; wrapper.customContentProvider = new ContentProvider(); bool loaded = false; bool failed = false; bool unloaded = false; wrapper.WhenForAnyArgs(x => x.Unload()).Do((info) => unloaded = true); wrapper.Load(url, loadWrapper => loaded = true, loadWrapper => failed = true); entity.OnCleanupEvent?.Invoke(entity); yield return(new WaitUntil(() => loaded || failed || unloaded)); Object.Destroy(meshRootGameObject); Assert.IsTrue(unloaded, "Unload should be called if entity is cleaned up while loading mesh"); }
public IEnumerator AlbedoTexture_AlbedoAlpha(float alpha) { yield return(InitVisualTestsScene($"PBRMaterialVisualTests_AlbedoTexture_AlbedoAlpha_{alpha.ToString(CultureInfo.InvariantCulture)}")); VisualTestHelpers.SetSSAOActive(true); Vector3 camTarget = new Vector3(5, 1, 5); VisualTestHelpers.RepositionVisualTestsCamera(VisualTestController.i.camera, new Vector3(4.6f, 1.8f, 0.6f), camTarget); DCLTexture texture = TestHelpers.CreateDCLTexture(scene, TestAssetsUtils.GetPath() + "/Images/avatar.png"); yield return(texture.routine); PlaneShape plane = TestHelpers.CreateEntityWithPlaneShape(scene, new Vector3(5, 1, 5), true); IDCLEntity planeEntity = plane.attachedEntities.FirstOrDefault(); TestHelpers.SetEntityTransform(scene, planeEntity, new Vector3(5, 1, 5), Quaternion.Euler(0, 0, 180), Vector3.one * 3); PBRMaterial planeMaterial = TestHelpers.AttachPBRMaterialToEntity(scene, planeEntity, new PBRMaterial.Model { transparencyMode = 2, albedoTexture = texture.id, albedoColor = new Color(1, 1, 1, alpha) }); yield return(plane.routine); yield return(planeMaterial.routine); yield return(null); yield return(VisualTestHelpers.TakeSnapshot()); }
DCLBuilderInWorldEntity SetupEntityToEdit(IDCLEntity entity, bool hasBeenCreated = false) { if (!convertedEntities.ContainsKey(GetConvertedUniqueKeyForEntity(entity))) { DCLBuilderInWorldEntity entityToEdit = Utils.GetOrCreateComponent <DCLBuilderInWorldEntity>(entity.gameObject); entityToEdit.Init(entity, editMaterial); convertedEntities.Add(entityToEdit.entityUniqueId, entityToEdit); entity.OnRemoved += RemoveConvertedEntity; entityToEdit.IsNew = hasBeenCreated; string entityName = entityToEdit.GetDescriptiveName(); var catalogItem = entityToEdit.GetCatalogItemAssociated(); if ((string.IsNullOrEmpty(entityName) || entityNameList.Contains(entityName)) && catalogItem != null) { entityName = GetNewNameForEntity(catalogItem); SetEntityName(entityToEdit, entityName); } else if (!string.IsNullOrEmpty(entityName) && !entityNameList.Contains(entityName)) { entityNameList.Add(entityName); } return(entityToEdit); } else { return(convertedEntities[GetConvertedUniqueKeyForEntity(entity)]); } }
private void OnShapeUpdated(IDCLEntity entity) { if (entity != null) { InitMaterial(entity.meshRootGameObject); } }
protected void OnRemoveEntity(IDCLEntity entity) { highPrioEntitiesToCheck.Remove(entity); entitiesToCheck.Remove(entity); persistentEntities.Remove(entity); feedbackStyle.ApplyFeedback(entity.meshesInfo, true); }
public void RemoveChild(IDCLEntity entity) { if (children.ContainsKey(entity.entityId)) { children.Remove(entity.entityId); } }
public void AddChild(IDCLEntity entity) { if (!children.ContainsKey(entity.entityId)) { children.Add(entity.entityId, entity); } }
//TODO: When refactoring these tests to split them by shape, replicate this on them public IEnumerator UpdateWithCollisionInMultipleEntities(int entitiesCount, bool withCollision) { Environment.i.world.sceneBoundsChecker.Stop(); // Arrange: set inverse of withCollision to trigger is dirty later BaseShape shapeComponent = TestHelpers.SharedComponentCreate <BoxShape, BaseShape.Model>(scene, CLASS_ID.BOX_SHAPE, new BaseShape.Model { withCollisions = !withCollision }); yield return(shapeComponent.routine); List <IDCLEntity> entities = new List <IDCLEntity>(); for (int i = 0; i < entitiesCount; i++) { IDCLEntity entity = TestHelpers.CreateSceneEntity(scene, $"entity{i}"); TestHelpers.SharedComponentAttach(shapeComponent, entity); entities.Add(entity); } // Act: Update withCollision shapeComponent.UpdateFromModel(new BoxShape.Model { withCollisions = withCollision }); yield return(shapeComponent.routine); // Assert: foreach (IDCLEntity entity in entities) { for (int i = 0; i < entity.meshesInfo.colliders.Count; i++) { Assert.AreEqual(withCollision, entity.meshesInfo.colliders[i].enabled); } } }
public void Initialize(IDCLEntity entity) { Renderer[] rendererList = entity?.meshesInfo?.renderers; if (rendererList == null || rendererList.Length == 0) { return; } IShape shape = entity.meshesInfo.currentShape; if (lastShape == shape) { return; } this.ownerEntity = entity; lastShape = shape; DestroyColliders(); if (shape == null) { return; } colliders = new Collider[rendererList.Length]; for (int i = 0; i < colliders.Length; i++) { colliders[i] = CreateColliders(rendererList[i]); } }
public DCLBuilderInWorldEntity CreateEmptyEntity(ParcelScene parcelScene, Vector3 entryPoint, Vector3 editionGOPosition, bool notifyEntityList = true) { IDCLEntity newEntity = parcelScene.CreateEntity(Guid.NewGuid().ToString()); DCLTransform.model.position = WorldStateUtils.ConvertUnityToScenePosition(entryPoint, parcelScene); Vector3 pointToLookAt = Camera.main.transform.position; pointToLookAt.y = editionGOPosition.y; Quaternion lookOnLook = Quaternion.LookRotation(editionGOPosition - pointToLookAt); DCLTransform.model.rotation = lookOnLook; DCLTransform.model.scale = newEntity.gameObject.transform.lossyScale; parcelScene.EntityComponentCreateOrUpdateWithModel(newEntity.entityId, CLASS_ID_COMPONENT.TRANSFORM, DCLTransform.model); DCLBuilderInWorldEntity convertedEntity = SetupEntityToEdit(newEntity, true); hudController?.UpdateSceneLimitInfo(); if (notifyEntityList) { EntityListChanged(); } return(convertedEntity); }
public void AddOrUpdateEntityCollider(IDCLEntity entity, Collider collider) { if (!collidersByEntity.ContainsKey(entity)) { collidersByEntity.Add(entity, new List <Collider>()); } List <Collider> collidersList = collidersByEntity[entity]; if (!collidersList.Contains(collider)) { collidersList.Add(collider); } ColliderInfo info = new ColliderInfo(); info.entity = entity; info.meshName = collider.transform.parent != null ? collider.transform.parent.name : ""; info.scene = entity.scene; AddOrUpdateColliderInfo(collider, info); // Note (Zak): avoid adding the event multiple times entity.OnCleanupEvent -= OnEntityCleanUpEvent; entity.OnCleanupEvent += OnEntityCleanUpEvent; }
protected bool IsHighPrioEntity(IDCLEntity entity) { Vector3 scale = entity.gameObject.transform.lossyScale; Vector3 position = entity.gameObject.transform.localPosition; return(scale.x > TRIGGER_HIGHPRIO_VALUE || scale.y > TRIGGER_HIGHPRIO_VALUE || scale.z > TRIGGER_HIGHPRIO_VALUE || position.x > TRIGGER_HIGHPRIO_VALUE || position.y > TRIGGER_HIGHPRIO_VALUE || position.z > TRIGGER_HIGHPRIO_VALUE); }
public void EntityDuplicate() { IDCLEntity duplicateEntity = entityHandler.DuplicateEntity(entity).rootEntity; BIWEntity convertedEntity = entityHandler.GetConvertedEntity(duplicateEntity); Assert.IsNotNull(convertedEntity); }
public void EntityDuplicate() { IDCLEntity duplicateEntity = entityHandler.DuplicateEntity(entity); DCLBuilderInWorldEntity convertedEntity = entityHandler.GetConvertedEntity(duplicateEntity); Assert.IsNotNull(convertedEntity); }
private DCLBuilderEntity AddBuilderEntityComponent(IDCLEntity entity) { DCLBuilderEntity builderComponent = Utils.GetOrCreateComponent <DCLBuilderEntity>(entity.gameObject); builderComponent.SetEntity(entity); return(builderComponent); }
public void LookAtEntity(IDCLEntity entity) { if (entity.meshRootGameObject == null || entity.meshesInfo == null || BuilderInWorldUtils.IsBoundInsideCamera(entity.meshesInfo.mergedBounds)) { return; } Vector3 pointToLook = entity.gameObject.transform.position; if (entity.meshesInfo.renderers.Length > 0) { Vector3 midPointFromEntityMesh = Vector3.zero; foreach (Renderer render in entity.renderers) { midPointFromEntityMesh += render.bounds.center; } midPointFromEntityMesh /= entity.renderers.Length; pointToLook = midPointFromEntityMesh; } freeCameraController.SmoothLookAt(pointToLook); }
protected override void AttachShape(IDCLEntity entity) { if (string.IsNullOrEmpty(model.src)) { #if UNITY_EDITOR Debug.LogError($"NFT SHAPE with url '{model.src}' couldn't be loaded."); #endif return; } entity.meshesInfo.meshRootGameObject = NFTShapeFactory.InstantiateLoaderController(model.style); entity.meshesInfo.currentShape = this; entity.meshRootGameObject.name = componentName + " mesh"; entity.meshRootGameObject.transform.SetParent(entity.gameObject.transform); entity.meshRootGameObject.transform.ResetLocalTRS(); entity.OnShapeUpdated += UpdateBackgroundColor; var loadableShape = GetOrAddLoaderForEntity <LoadWrapper_NFT>(entity); loadableShape.entity = entity; loadableShape.component = this; loadableShape.initialVisibility = model.visible; loadableShape.withCollisions = model.withCollisions; loadableShape.backgroundColor = model.color; loadableShape.Load(model.src, OnLoadCompleted, OnLoadFailed); }
//TODO: When refactoring these tests to split them by shape, replicate this on them public IEnumerator UpdateVisibilityInMultipleEntities(int entitiesCount, bool visible) { Environment.i.world.sceneBoundsChecker.Stop(); // Arrange: set inverse of visible to trigger is dirty later BaseShape shapeComponent = TestHelpers.SharedComponentCreate <BoxShape, BaseShape.Model>(scene, CLASS_ID.BOX_SHAPE, new BaseShape.Model { visible = !visible }); yield return(shapeComponent.routine); List <IDCLEntity> entities = new List <IDCLEntity>(); for (int i = 0; i < entitiesCount; i++) { IDCLEntity entity = TestHelpers.CreateSceneEntity(scene, $"entity{i}"); TestHelpers.SharedComponentAttach(shapeComponent, entity); entities.Add(entity); } // Act: Update visible shapeComponent.UpdateFromModel(new BoxShape.Model { visible = visible, withCollisions = true, isPointerBlocker = true }); yield return(shapeComponent.routine); // Assert: foreach (IDCLEntity entity in entities) { for (int i = 0; i < entity.meshesInfo.renderers.Length; i++) { Assert.AreEqual(visible, entity.meshesInfo.renderers[i].enabled); } } }
private void OnShapeUpdated(IDCLEntity entity) { isShapeComponentSet = true; OnEntityShapeUpdated?.Invoke(this); // We don't want animation to be running on editor meshAnimations = GetComponentsInChildren <Animation>(); if (hasSmartItemComponent) { DefaultAnimationStop(); } else { DefaultAnimationSample(0); } if (hasGizmoComponent) { gameObject.transform.localScale = Vector3.zero; StartCoroutine(ScaleAnimationRoutine(0.3f)); } else if (isTransformComponentSet) { gameObject.transform.localScale = scaleTarget; ProcessEntityShape(entity); } if (OnShapeLoaded != null) { OnShapeLoaded(); OnShapeLoaded = null; } }
void CleanUpEntityRecursively(IDCLEntity entity, bool removeImmediatelyFromEntitiesList) { // Iterate through all entity children using (var iterator = entity.children.GetEnumerator()) { while (iterator.MoveNext()) { CleanUpEntityRecursively(iterator.Current.Value, removeImmediatelyFromEntitiesList); } } OnEntityRemoved?.Invoke(entity); if (Environment.i.world.sceneBoundsChecker.enabled) { entity.OnShapeUpdated -= Environment.i.world.sceneBoundsChecker.AddEntityToBeChecked; Environment.i.world.sceneBoundsChecker.RemoveEntityToBeChecked(entity); } if (removeImmediatelyFromEntitiesList) { // Every entity ends up being removed through here entity.Cleanup(); entities.Remove(entity.entityId); } else { Environment.i.platform.parcelScenesCleaner.MarkForCleanup(entity); } }
protected virtual void OnEntityRemoved(IDCLEntity e) { SubstractMetrics(e); e.OnMeshesInfoUpdated -= OnEntityMeshInfoUpdated; e.OnMeshesInfoCleaned -= OnEntityMeshInfoCleaned; model.entities--; isDirty = true; }
private void ProcessEntityShape(IDCLEntity entity) { if (entity.meshRootGameObject && entity.meshesInfo.renderers.Length > 0) { CreateColliders(entity.meshesInfo); SetCollidersActive(true); } }
public static string ConvertEntityToJSON(IDCLEntity entity) { EntityData builderInWorldEntityData = new EntityData(); builderInWorldEntityData.entityId = entity.entityId; foreach (KeyValuePair <CLASS_ID_COMPONENT, IEntityComponent> keyValuePair in entity.components) { if (keyValuePair.Key == CLASS_ID_COMPONENT.TRANSFORM) { EntityData.TransformComponent entityComponentModel = new EntityData.TransformComponent(); entityComponentModel.position = WorldStateUtils.ConvertUnityToScenePosition(entity.gameObject.transform.position, entity.scene); entityComponentModel.rotation = entity.gameObject.transform.localRotation.eulerAngles; entityComponentModel.scale = entity.gameObject.transform.localScale; builderInWorldEntityData.transformComponent = entityComponentModel; } else { ProtocolV2.GenericComponent entityComponentModel = new ProtocolV2.GenericComponent(); entityComponentModel.componentId = (int)keyValuePair.Key; entityComponentModel.data = keyValuePair.Value.GetModel(); builderInWorldEntityData.components.Add(entityComponentModel); } } foreach (KeyValuePair <Type, ISharedComponent> keyValuePair in entity.sharedComponents) { if (keyValuePair.Value.GetClassId() == (int)CLASS_ID.NFT_SHAPE) { EntityData.NFTComponent nFTComponent = new EntityData.NFTComponent(); NFTShape.Model model = (NFTShape.Model)keyValuePair.Value.GetModel(); nFTComponent.id = keyValuePair.Value.id; nFTComponent.color = new ColorRepresentation(model.color); nFTComponent.assetId = model.assetId; nFTComponent.src = model.src; nFTComponent.style = model.style; builderInWorldEntityData.nftComponent = nFTComponent; } else { ProtocolV2.GenericComponent entityComponentModel = new ProtocolV2.GenericComponent(); entityComponentModel.componentId = keyValuePair.Value.GetClassId(); entityComponentModel.data = keyValuePair.Value.GetModel(); entityComponentModel.classId = keyValuePair.Value.id; builderInWorldEntityData.sharedComponents.Add(entityComponentModel); } } return(JsonConvert.SerializeObject(builderInWorldEntityData)); }
void ApplyAction(string entityIdToApply, object value, ActionType actionType, bool isUndo) { switch (actionType) { case ActionType.MOVE: Vector3 convertedPosition = (Vector3)value; builderInWorldEntityHandler.GetEntity(entityIdToApply).rootEntity.gameObject.transform.position = convertedPosition; break; case ActionType.ROTATE: Vector3 convertedAngles = (Vector3)value; builderInWorldEntityHandler.GetEntity(entityIdToApply).rootEntity.gameObject.transform.eulerAngles = convertedAngles; break; case ActionType.SCALE: Vector3 convertedScale = (Vector3)value; IDCLEntity entityToApply = builderInWorldEntityHandler.GetEntity(entityIdToApply).rootEntity; Transform parent = entityToApply.gameObject.transform.parent; entityToApply.gameObject.transform.localScale = new Vector3(convertedScale.x / parent.localScale.x, convertedScale.y / parent.localScale.y, convertedScale.z / parent.localScale.z); break; case ActionType.CREATE: string entityString = (string)value; if (isUndo) { builderInWorldEntityHandler.DeleteEntity(entityString); } else { builderInWorldEntityHandler.CreateEntityFromJSON(entityString); } break; case ActionType.DELETE: string deletedEntityString = (string)value; if (isUndo) { builderInWorldEntityHandler.CreateEntityFromJSON(deletedEntityString); } else { builderInWorldEntityHandler.DeleteEntity(deletedEntityString); } break; case ActionType.CHANGE_FLOOR: string catalogItemToApply = (string)value; CatalogItem floorObject = JsonConvert.DeserializeObject <CatalogItem>(catalogItemToApply); builderInWorldEntityHandler.DeleteFloorEntities(); biwFloorHandler.CreateFloor(floorObject); break; } }
public DCLBuilderInWorldEntity GetConvertedEntity(IDCLEntity entity) { if (convertedEntities.ContainsKey(GetConvertedUniqueKeyForEntity(entity))) { return(convertedEntities[GetConvertedUniqueKeyForEntity(entity)]); } return(null); }
public void Setup(string button, string feedbackText, IDCLEntity entity) { text.text = feedbackText; this.entity = entity; ConfigureIcon(button); canvas.enabled = enabled && isHovered; }
private void OnAvatarShapeUpdated(IDCLEntity entity, AvatarShape avatarShape) { if (rootEntity != entity) { return; } OnShapeUpdated(rootEntity); }