private void CheckOutline()
{
if (outlinerOptimizationCounter >= 10 && isOutlineCheckActive)
{
if (!BuilderInWorldUtils.IsPointerOverUIElement())
{
DCLBuilderInWorldEntity entity = GetEntityOnPointer();
if (!isMultiSelectionActive)
{
outlinerController.CancelAllOutlines();
}
else
{
outlinerController.CancelUnselectedOutlines();
}
if (entity != null && !entity.IsSelected)
{
outlinerController.OutlineEntity(entity);
}
}
outlinerOptimizationCounter = 0;
}
else
{
outlinerOptimizationCounter++;
}
}
private void Awake()
{
for (int i = 0; i < shortcutsButtons.Length; i++)
{
int buttonIndex = i;
shortcutsButtons[buttonIndex].onClick.AddListener(() => QuickBarObjectSelected(buttonIndex));
}
for (int i = 0; i < shortcutsEventTriggers.Length; i++)
{
int triggerIndex = i;
BuilderInWorldUtils.ConfigureEventTrigger(shortcutsEventTriggers[triggerIndex], EventTriggerType.Drop, (eventData) =>
{
SetIndexToDrop(triggerIndex);
SceneObjectDropped(eventData);
});
}
quickBar1InputAction.OnTriggered += OnQuickBar1InputTriggedered;
quickBar2InputAction.OnTriggered += OnQuickBar2InputTriggedered;
quickBar3InputAction.OnTriggered += OnQuickBar3InputTriggedered;
quickBar4InputAction.OnTriggered += OnQuickBar4InputTriggedered;
quickBar5InputAction.OnTriggered += OnQuickBar5InputTriggedered;
quickBar6InputAction.OnTriggered += OnQuickBar6InputTriggedered;
quickBar7InputAction.OnTriggered += OnQuickBar7InputTriggedered;
quickBar8InputAction.OnTriggered += OnQuickBar8InputTriggedered;
quickBar9InputAction.OnTriggered += OnQuickBar9InputTriggedered;
}
void RotateSelection(float angleToRotate)
{
currentYRotationAdded += angleToRotate;
editionGO.transform.Rotate(Vector3.up, angleToRotate);
snapGO.transform.Rotate(Vector3.up, angleToRotate);
snapGO.transform.rotation = Quaternion.Euler(BuilderInWorldUtils.SnapFilterEulerAngles(snapGO.transform.rotation.eulerAngles, snapRotationDegresFactor));
}
private void MouseClick(int buttonID, Vector3 position)
{
if (!isEditModeActive)
{
return;
}
if (Time.timeSinceLevelLoad < nexTimeToReceiveInput)
{
return;
}
if (!BuilderInWorldUtils.IsPointerOverUIElement())
{
HUDController.i.builderInWorldMainHud.HideExtraBtns();
}
if (Utils.isCursorLocked || biwModeController.IsGodModeActive())
{
if (buttonID == 0)
{
MouseClickDetected();
InputDone();
return;
}
outlinerController.CheckOutline();
}
}
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);
}
private void Awake()
{
mainButton.onClick.AddListener(() => OnPointerClick(dummyActionTrigger));
toggleCatalogInputAction.OnTriggered += OnPointerClick;
BuilderInWorldUtils.ConfigureEventTrigger(catalogButtonEventTrigger, EventTriggerType.PointerEnter, (eventData) => OnPointerEnter((PointerEventData)eventData));
BuilderInWorldUtils.ConfigureEventTrigger(catalogButtonEventTrigger, EventTriggerType.PointerExit, (eventData) => OnPointerExit());
}
public void Init()
{
if (isInit)
{
return;
}
isInit = true;
InitGameObjects();
HUDConfiguration hudConfig = new HUDConfiguration();
hudConfig.active = true;
hudConfig.visible = false;
HUDController.i.CreateHudElement <BuildModeHUDController>(hudConfig, HUDController.HUDElementID.BUILDER_IN_WORLD_MAIN);
HUDController.i.CreateHudElement <BuilderInWorldInititalHUDController>(hudConfig, HUDController.HUDElementID.BUILDER_IN_WORLD_INITIAL);
HUDController.i.builderInWorldMainHud.Initialize();
HUDController.i.builderInWorldInititalHud.OnEnterEditMode += TryStartEnterEditMode;
HUDController.i.builderInWorldMainHud.OnTutorialAction += StartTutorial;
HUDController.i.builderInWorldMainHud.OnLogoutAction += ExitEditMode;
ConfigureLoadingController();
InitControllers();
CommonScriptableObjects.builderInWorldNotNecessaryUIVisibilityStatus.Set(true);
catalogAsyncOp = BuilderInWorldUtils.MakeGetCall(BuilderInWorldSettings.BASE_URL_ASSETS_PACK, CatalogReceived);
isCatalogLoading = true;
BuilderInWorldNFTController.i.Initialize();
BuilderInWorldNFTController.i.OnNFTUsageChange += OnNFTUsageChange;
}
private void OnDestroy()
{
mainButton.onClick.RemoveAllListeners();
toggleCatalogInputAction.OnTriggered -= OnPointerClick;
BuilderInWorldUtils.RemoveEventTrigger(catalogButtonEventTrigger, EventTriggerType.PointerEnter);
BuilderInWorldUtils.RemoveEventTrigger(catalogButtonEventTrigger, EventTriggerType.PointerExit);
}
private void EndBoundMultiSelection()
{
isDoingSquareMultiSelection = false;
mousePressed = false;
freeCameraController.SetCameraCanMove(true);
List <DCLBuilderInWorldEntity> allEntities = null;
if (!isVoxelBoundMultiSelection)
{
allEntities = builderInWorldEntityHandler.GetAllEntitiesFromCurrentScene();
}
else
{
allEntities = builderInWorldEntityHandler.GetAllVoxelsEntities();
}
foreach (DCLBuilderInWorldEntity entity in allEntities)
{
if (entity.isVoxel && !isVoxelBoundMultiSelection)
{
continue;
}
if (entity.rootEntity.meshRootGameObject && entity.rootEntity.meshesInfo.renderers.Length > 0)
{
if (BuilderInWorldUtils.IsWithInSelectionBounds(entity.rootEntity.meshesInfo.mergedBounds.center, lastMousePosition, Input.mousePosition))
{
builderInWorldEntityHandler.SelectEntity(entity);
}
}
}
outlinerController.SetOutlineCheckActive(true);
outlinerController.CancelAllOutlines();
}
public void SetContent(List <DCLBuilderInWorldEntity> entityList)
{
this.entityList = entityList;
filteredList = BuilderInWorldUtils.FilterEntitiesBySmartItemComponentAndActions(entityList);
GenerateEntityDropdownContent();
SelectedEntity(0);
}
public void SetContent(SmartItemActionEvent actionEvent)
{
this.actionEvent = actionEvent;
filteredList = BuilderInWorldUtils.FilterEntitiesBySmartItemComponentAndActions(actionEvent.entityList);
GenerateEntityDropdownContent();
SelectedEntity(0);
}
private void Update()
{
if (isPlacingNewObject)
{
if (!voxelController.IsActive())
{
SetEditObjectAtMouse();
}
else
{
voxelController.SetEditObjectLikeVoxel();
}
}
else if (isSquareMultiSelectionInputActive && isMouseDragging)
{
List <DCLBuilderInWorldEntity> allEntities = null;
if (!isTypeOfBoundSelectionSelected || !isVoxelBoundMultiSelection)
{
allEntities = builderInWorldEntityHandler.GetAllEntitiesFromCurrentScene();
}
else if (isVoxelBoundMultiSelection)
{
allEntities = builderInWorldEntityHandler.GetAllVoxelsEntities();
}
foreach (DCLBuilderInWorldEntity entity in allEntities)
{
if (entity.isVoxel && !isVoxelBoundMultiSelection && isTypeOfBoundSelectionSelected)
{
continue;
}
if (entity.rootEntity.meshRootGameObject && entity.rootEntity.meshesInfo.renderers.Length > 0)
{
if (BuilderInWorldUtils.IsWithInSelectionBounds(entity.rootEntity.meshesInfo.mergedBounds.center, lastMousePosition, Input.mousePosition))
{
if (!isTypeOfBoundSelectionSelected && !entity.IsLocked)
{
if (entity.isVoxel)
{
isVoxelBoundMultiSelection = true;
}
else
{
isVoxelBoundMultiSelection = false;
}
isTypeOfBoundSelectionSelected = true;
}
outlinerController.OutlineEntity(entity);
}
else
{
outlinerController.CancelEntityOutline(entity);
}
}
}
}
}
public void AddEventAction()
{
List <DCLBuilderInWorldEntity> alreadyFilterList = BuilderInWorldUtils.FilterEntitiesBySmartItemComponentAndActions(entitiesList);
if (alreadyFilterList.Count > 0)
{
actionsListView.AddActionEventAdapter(entitiesList);
}
}
public void UndoEditionGOLastStep()
{
if (undoGO == null || editionGO == null)
{
return;
}
BuilderInWorldUtils.CopyGameObjectStatus(undoGO, editionGO, false, false);
}
private void OnGUI()
{
if (mousePressed && isDoingSquareMultiSelection)
{
var rect = BuilderInWorldUtils.GetScreenRect(lastMousePosition, Input.mousePosition);
BuilderInWorldUtils.DrawScreenRect(rect, new Color(1f, 1f, 1f, 0.5f));
BuilderInWorldUtils.DrawScreenRectBorder(rect, 1, Color.white);
}
}
private void EndBoundMultiSelection()
{
freeCameraController.SetCameraCanMove(true);
List <DCLBuilderInWorldEntity> allEntities = null;
if (!isVoxelBoundMultiSelection)
{
allEntities = builderInWorldEntityHandler.GetAllEntitiesFromCurrentScene();
}
else
{
allEntities = builderInWorldEntityHandler.GetAllVoxelsEntities();
}
List <DCLBuilderInWorldEntity> selectedInsideBoundsEntities = new List <DCLBuilderInWorldEntity>();
int alreadySelectedEntities = 0;
if (!isMultiSelectionActive)
{
builderInWorldEntityHandler.DeselectEntities();
}
foreach (DCLBuilderInWorldEntity entity in allEntities)
{
if ((entity.isVoxel && !isVoxelBoundMultiSelection) ||
!entity.IsVisible)
{
continue;
}
if (entity.rootEntity.meshRootGameObject && entity.rootEntity.meshesInfo.renderers.Length > 0)
{
if (BuilderInWorldUtils.IsWithInSelectionBounds(entity.rootEntity.meshesInfo.mergedBounds.center, lastMousePosition, Input.mousePosition) &&
!entity.IsLocked)
{
if (entity.IsSelected)
{
alreadySelectedEntities++;
}
builderInWorldEntityHandler.SelectEntity(entity);
selectedInsideBoundsEntities.Add(entity);
}
}
}
if (selectedInsideBoundsEntities.Count == alreadySelectedEntities && alreadySelectedEntities > 0)
{
foreach (DCLBuilderInWorldEntity entity in selectedInsideBoundsEntities)
{
builderInWorldEntityHandler.DeselectEntity(entity);
}
}
outlinerController.CancelAllOutlines();
}
private void Awake()
{
CreateSlotToDrag();
for (int i = 0; i < shortcutsButtons.Length; i++)
{
int buttonIndex = i;
shortcutsButtons[buttonIndex].onClick.AddListener(() => QuickBarObjectSelected(buttonIndex));
}
for (int i = 0; i < shortcutsEventTriggers.Length; i++)
{
int triggerIndex = i;
BuilderInWorldUtils.ConfigureEventTrigger(shortcutsEventTriggers[triggerIndex], EventTriggerType.BeginDrag, (eventData) =>
{
BeginDragSlot(triggerIndex);
});
BuilderInWorldUtils.ConfigureEventTrigger(shortcutsEventTriggers[triggerIndex], EventTriggerType.Drag, (eventData) =>
{
DragSlot(eventData, triggerIndex);
});
BuilderInWorldUtils.ConfigureEventTrigger(shortcutsEventTriggers[triggerIndex], EventTriggerType.EndDrag, (eventData) =>
{
EndDragSlot(triggerIndex);
});
BuilderInWorldUtils.ConfigureEventTrigger(shortcutsEventTriggers[triggerIndex], EventTriggerType.Drop, (eventData) =>
{
SetIndexToDrop(triggerIndex);
if (lastIndexToBeginDrag != -1)
{
SceneObjectDroppedFromQuickBar(lastIndexToBeginDrag, triggerIndex, shortcutsImgs[lastIndexToBeginDrag].image.texture);
CancelCurrentDragging();
}
else
{
SceneObjectDroppedFromCatalog(eventData);
}
});
}
quickBar1InputAction.OnTriggered += OnQuickBar1InputTriggedered;
quickBar2InputAction.OnTriggered += OnQuickBar2InputTriggedered;
quickBar3InputAction.OnTriggered += OnQuickBar3InputTriggedered;
quickBar4InputAction.OnTriggered += OnQuickBar4InputTriggedered;
quickBar5InputAction.OnTriggered += OnQuickBar5InputTriggedered;
quickBar6InputAction.OnTriggered += OnQuickBar6InputTriggedered;
quickBar7InputAction.OnTriggered += OnQuickBar7InputTriggedered;
quickBar8InputAction.OnTriggered += OnQuickBar8InputTriggedered;
quickBar9InputAction.OnTriggered += OnQuickBar9InputTriggedered;
}
private void MouseWheel(float axisValue)
{
if (!canInputBeMade)
{
return;
}
if (!BuilderInWorldUtils.IsPointerOverUIElement())
{
OnMouseWheel?.Invoke(axisValue);
}
}
private bool CanDrag()
{
if (!canInputBeMade ||
currentClickIsOnUi ||
BuilderInWorldUtils.IsPointerOverUIElement())
{
return(false);
}
return(true);
}
public DCLBuilderInWorldEntity DuplicateEntity(DCLBuilderInWorldEntity entityToDuplicate)
{
IDCLEntity entity = SceneUtils.DuplicateEntity(sceneToEdit, entityToDuplicate.rootEntity);
BuilderInWorldUtils.CopyGameObjectStatus(entityToDuplicate.gameObject, entity.gameObject, false, false);
DCLBuilderInWorldEntity convertedEntity = SetupEntityToEdit(entity);
NotifyEntityIsCreated(entity);
EntityListChanged();
return(convertedEntity);
}
private void MouseDrag(int buttonId, Vector3 mousePosition, float axisX, float axisY)
{
if (!canInputBeMade)
{
return;
}
if (!BuilderInWorldUtils.IsPointerOverUIElement())
{
OnMouseDrag?.Invoke(buttonId, mousePosition, axisX, axisY);
}
}
public override void SelectedEntity(DCLBuilderInWorldEntity selectedEntity)
{
base.SelectedEntity(selectedEntity);
initialRotation = editionGO.transform.rotation;
SetObjectIfSnapOrNot();
currentYRotationAdded = 0;
BuilderInWorldUtils.CopyGameObjectStatus(editionGO, snapGO, false);
}
public DecentralandEntity DuplicateEntity(DCLBuilderInWorldEntity entityToDuplicate)
{
DecentralandEntity entity = sceneToEdit.DuplicateEntity(entityToDuplicate.rootEntity);
BuilderInWorldUtils.CopyGameObjectStatus(entityToDuplicate.gameObject, entity.gameObject, false, false);
SetupEntityToEdit(entity);
NotifyEntityIsCreated(entity);
EntityListChanged();
return(entity);
}
public void SetContent(SmartItemActionEvent actionEvent)
{
this.actionEvent = actionEvent;
filteredList = BuilderInWorldUtils.FilterEntitiesBySmartItemComponentAndActions(actionEvent.entityList);
GenerateEntityDropdownContent();
foreach (DCLBuilderInWorldEntity entity in filteredList)
{
GetThumbnail(entity);
}
SelectedEntity(entityDropDown.value);
}
public IEnumerator SceneObjectFloorObject()
{
SceneObject sceneObject = BuilderInWorldUtils.CreateFloorSceneObject();
LoadParcelScenesMessage.UnityParcelScene data = scene.sceneData;
data.contents = new List <ContentServerUtils.MappingPair>();
data.baseUrl = BuilderInWorldSettings.BASE_URL_CATALOG;
foreach (KeyValuePair <string, string> content in sceneObject.contents)
{
ContentServerUtils.MappingPair mappingPair = new ContentServerUtils.MappingPair();
mappingPair.file = content.Key;
mappingPair.hash = content.Value;
bool found = false;
foreach (ContentServerUtils.MappingPair mappingPairToCheck in data.contents)
{
if (mappingPairToCheck.file == mappingPair.file)
{
found = true;
break;
}
}
if (!found)
{
data.contents.Add(mappingPair);
}
}
Environment.i.world.sceneController.UpdateParcelScenesExecute(data);
string entityId = "1";
TestHelpers.CreateSceneEntity(scene, entityId);
TestHelpers.CreateAndSetShape(scene, entityId, DCL.Models.CLASS_ID.GLTF_SHAPE, JsonConvert.SerializeObject(
new
{
assetId = BuilderInWorldSettings.FLOOR_TEXTURE_VALUE,
src = BuilderInWorldSettings.FLOOR_MODEL
}));;
LoadWrapper gltfShape = GLTFShape.GetLoaderForEntity(scene.entities[entityId]);
yield return(new WaitUntil(() => gltfShape.alreadyLoaded));
Assert.IsTrue(
scene.entities[entityId].gameObject.GetComponentInChildren <UnityGLTF.InstantiatedGLTFObject>() != null,
"Floor should be loaded, is the SceneObject not working anymore?");
}
public void EnterEditMode()
{
BuilderInWorldNFTController.i.ClearNFTs();
ParcelSettings.VISUAL_LOADING_ENABLED = false;
inputController.isBuildModeActivate = true;
FindSceneToEdit();
sceneToEdit.SetEditMode(true);
cursorGO.SetActive(false);
parcelUnityMiddlePoint = BuilderInWorldUtils.CalculateUnityMiddlePoint(sceneToEdit);
if (HUDController.i.builderInWorldMainHud != null)
{
HUDController.i.builderInWorldMainHud.SetVisibility(true);
HUDController.i.builderInWorldMainHud.SetParcelScene(sceneToEdit);
HUDController.i.builderInWorldMainHud.RefreshCatalogContent();
HUDController.i.builderInWorldMainHud.RefreshCatalogAssetPack();
}
CommonScriptableObjects.builderInWorldNotNecessaryUIVisibilityStatus.Set(false);
DCLCharacterController.OnPositionSet += ExitAfterCharacterTeleport;
StartBiwControllers();
Environment.i.world.sceneController.ActivateBuilderInWorldEditScene();
if (IsNewScene())
{
SetupNewScene();
biwFloorHandler.OnAllParcelsFloorLoaded -= OnAllParcelsFloorLoaded;
biwFloorHandler.OnAllParcelsFloorLoaded += OnAllParcelsFloorLoaded;
}
else
{
initialLoadingController.Hide();
inputController.isInputActive = true;
}
isBuilderInWorldActivated = true;
foreach (var groundVisual in groundVisualsGO)
{
groundVisual.SetActive(false);
}
previousSkyBoxMaterial = RenderSettings.skybox;
RenderSettings.skybox = skyBoxMaterial;
}
public void EndMultiVoxelSelection()
{
List <DCLBuilderInWorldEntity> voxelEntities = builderInWorldEntityHandler.GetAllVoxelsEntities();
foreach (DCLBuilderInWorldEntity voxelEntity in voxelEntities)
{
if (BuilderInWorldUtils.IsWithInSelectionBounds(voxelEntity.gameObject.transform, lastMousePosition, Input.mousePosition))
{
builderInWorldEntityHandler.SelectEntity(voxelEntity);
}
}
outlinerController.SetOutlineCheckActive(true);
outlinerController.CancelAllOutlines();
}
private void MouseDown(int buttonId, Vector3 mousePosition)
{
lastTimeMouseDown = Time.unscaledTime;
lastMousePosition = mousePosition;
if (!canInputBeMade)
{
return;
}
if (!BuilderInWorldUtils.IsPointerOverUIElement() && !BuilderInWorldUtils.IsPointerOverMaskElement(layerToStopClick))
{
OnMouseDown?.Invoke(buttonId, mousePosition);
}
}
private void MouseDown(int buttonId, Vector3 mousePosition)
{
lastTimeMouseDown = Time.unscaledTime;
lastMousePosition = mousePosition;
currentClickIsOnUi = BuilderInWorldUtils.IsPointerOverUIElement();
if (!canInputBeMade)
{
return;
}
if (!currentClickIsOnUi)
{
OnMouseDown?.Invoke(buttonId, mousePosition);
}
}
public IDCLEntity CreateEntityFromJSON(string entityJson)
{
EntityData data = BuilderInWorldUtils.ConvertJSONToEntityData(entityJson);
IDCLEntity newEntity = sceneToEdit.CreateEntity(data.entityId);
if (data.transformComponent != null)
{
DCLTransform.model.position = data.transformComponent.position;
DCLTransform.model.rotation = Quaternion.Euler(data.transformComponent.rotation);
DCLTransform.model.scale = data.transformComponent.scale;
sceneToEdit.EntityComponentCreateOrUpdateWithModel(newEntity.entityId, CLASS_ID_COMPONENT.TRANSFORM, DCLTransform.model);
}
foreach (ProtocolV2.GenericComponent component in data.components)
{
sceneToEdit.EntityComponentCreateOrUpdateWithModel(newEntity.entityId, (CLASS_ID_COMPONENT)component.componentId, component.data);
}
foreach (ProtocolV2.GenericComponent component in data.sharedComponents)
{
sceneToEdit.SharedComponentAttach(newEntity.entityId, component.classId);
}
if (data.nftComponent != null)
{
NFTShape nftShape = (NFTShape)sceneToEdit.SharedComponentCreate(data.nftComponent.id, Convert.ToInt32(CLASS_ID.NFT_SHAPE));
nftShape.model = new NFTShape.Model();
nftShape.model.color = data.nftComponent.color.ToColor();
nftShape.model.src = data.nftComponent.src;
nftShape.model.assetId = data.nftComponent.assetId;
sceneToEdit.SharedComponentAttach(newEntity.entityId, nftShape.id);
}
SetupEntityToEdit(newEntity, true);
EntityListChanged();
return(newEntity);
}
