niko
1161 lines
36 KiB
C#
1161 lines
36 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using BlockSpace.Account;
|
|
using BlockSpace.Worlds;
|
|
using UnityEngine;
|
|
|
|
namespace BlockSpace.Voxels
|
|
{
|
|
[DisallowMultipleComponent]
|
|
public sealed class InventoryController : MonoBehaviour
|
|
{
|
|
private enum InventoryMode
|
|
{
|
|
Avatars = 0,
|
|
Creations = 1
|
|
}
|
|
|
|
private const float ButtonPressCooldown = 0.2f;
|
|
|
|
private const float ButtonShrinkDuration = 0.08f;
|
|
|
|
private const float ButtonSettleDuration = 0.12f;
|
|
|
|
private const float ButtonPressedScale = 0.84f;
|
|
|
|
private const float ButtonOvershootScale = 1.04f;
|
|
|
|
private const string ButtonThockResourcePath = "Thock";
|
|
|
|
private const float AvatarVoxelSizeScale = 0.5f;
|
|
|
|
private const float CreationPreviewMaxSize = 3f;
|
|
|
|
[SerializeField]
|
|
private VoxelGroupManager groupManager;
|
|
|
|
[SerializeField]
|
|
private VRVoxelBrush voxelBrush;
|
|
|
|
[SerializeField]
|
|
private string backendBaseUrl = "https://blockspacebackend-production.up.railway.app";
|
|
|
|
[Header("Buttons")]
|
|
[SerializeField]
|
|
private Collider avatarsButton;
|
|
|
|
[SerializeField]
|
|
private Collider creationsButton;
|
|
|
|
[SerializeField]
|
|
private Collider backButton;
|
|
|
|
[SerializeField]
|
|
private Collider nextButton;
|
|
|
|
[SerializeField]
|
|
private Collider saveButton;
|
|
|
|
[SerializeField]
|
|
private Collider loadButton;
|
|
|
|
[Header("Previews")]
|
|
[SerializeField]
|
|
private Transform creationPreviewRoot;
|
|
|
|
[SerializeField]
|
|
private Transform previewHead;
|
|
|
|
[SerializeField]
|
|
private Transform previewLeft;
|
|
|
|
[SerializeField]
|
|
private Transform previewRight;
|
|
|
|
[SerializeField]
|
|
private AudioClip buttonThockClip;
|
|
|
|
[SerializeField]
|
|
private bool debugLogs;
|
|
|
|
private readonly Dictionary<Transform, Vector3> buttonBaseScales = new Dictionary<Transform, Vector3>();
|
|
|
|
private readonly Dictionary<Transform, Coroutine> buttonAnimationCoroutines = new Dictionary<Transform, Coroutine>();
|
|
|
|
private readonly Dictionary<string, Transform> transformCache = new Dictionary<string, Transform>(StringComparer.OrdinalIgnoreCase);
|
|
|
|
private InventoryMode mode;
|
|
|
|
private readonly List<string> ids = new List<string>();
|
|
|
|
private int slotIndex;
|
|
|
|
private string equippedAvatarId = string.Empty;
|
|
|
|
private bool slotsDirty = true;
|
|
|
|
private float nextButtonPressTime;
|
|
|
|
private bool avatarsInsidePrev;
|
|
|
|
private bool creationsInsidePrev;
|
|
|
|
private bool backInsidePrev;
|
|
|
|
private bool nextInsidePrev;
|
|
|
|
private bool saveInsidePrev;
|
|
|
|
private bool loadInsidePrev;
|
|
|
|
private VoxelGroup previewCreationGroup;
|
|
|
|
private readonly List<VoxelGroup> previewCreationGroups = new List<VoxelGroup>();
|
|
|
|
private VoxelGroup previewHeadGroup;
|
|
|
|
private VoxelGroup previewLeftGroup;
|
|
|
|
private VoxelGroup previewRightGroup;
|
|
|
|
private bool warnedMissingAvatarPreviewRoots;
|
|
|
|
private bool warnedMissingCreationPreviewRoot;
|
|
|
|
private InventoryBackendClient client;
|
|
|
|
private int previewRequestToken;
|
|
|
|
public void Configure(VoxelGroupManager manager, VRVoxelBrush brush)
|
|
{
|
|
if (manager != null)
|
|
{
|
|
groupManager = manager;
|
|
}
|
|
if (brush != null)
|
|
{
|
|
voxelBrush = brush;
|
|
}
|
|
ResolveSceneReferences();
|
|
EnsureButtonAudioAssigned();
|
|
EnsurePreviewGroups();
|
|
client = new InventoryBackendClient(backendBaseUrl);
|
|
slotsDirty = true;
|
|
}
|
|
|
|
private void Awake()
|
|
{
|
|
ResolveSceneReferences();
|
|
EnsureButtonAudioAssigned();
|
|
EnsurePreviewGroups();
|
|
client = new InventoryBackendClient(backendBaseUrl);
|
|
}
|
|
|
|
private void OnDisable()
|
|
{
|
|
StopAllCoroutines();
|
|
ResetAllButtonScales();
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
ResolveSceneReferences();
|
|
EnsurePreviewGroups();
|
|
if (!(groupManager == null))
|
|
{
|
|
HandleButton(avatarsButton, ref avatarsInsidePrev, delegate
|
|
{
|
|
SwitchMode(InventoryMode.Avatars);
|
|
});
|
|
HandleButton(creationsButton, ref creationsInsidePrev, delegate
|
|
{
|
|
SwitchMode(InventoryMode.Creations);
|
|
});
|
|
HandleButton(backButton, ref backInsidePrev, PrevSlot);
|
|
HandleButton(nextButton, ref nextInsidePrev, NextSlot);
|
|
HandleButton(saveButton, ref saveInsidePrev, SaveCurrentSlot);
|
|
HandleButton(loadButton, ref loadInsidePrev, LoadCurrentSlot);
|
|
if (slotsDirty)
|
|
{
|
|
slotsDirty = false;
|
|
StartCoroutine(RefreshSlots());
|
|
}
|
|
}
|
|
}
|
|
|
|
private void SwitchMode(InventoryMode newMode)
|
|
{
|
|
if (mode != newMode)
|
|
{
|
|
mode = newMode;
|
|
slotIndex = 0;
|
|
if (mode == InventoryMode.Avatars)
|
|
{
|
|
ApplyEmptyCreationPreview();
|
|
}
|
|
else
|
|
{
|
|
ApplyEmptyAvatarPreview();
|
|
}
|
|
slotsDirty = true;
|
|
}
|
|
}
|
|
|
|
private void PrevSlot()
|
|
{
|
|
if (ids.Count <= 0)
|
|
{
|
|
slotIndex = 0;
|
|
return;
|
|
}
|
|
slotIndex = (slotIndex - 1 + ids.Count) % ids.Count;
|
|
UpdatePreviewsForSelectedSlot();
|
|
}
|
|
|
|
private void NextSlot()
|
|
{
|
|
if (ids.Count <= 0)
|
|
{
|
|
slotIndex = 0;
|
|
return;
|
|
}
|
|
slotIndex = (slotIndex + 1) % ids.Count;
|
|
UpdatePreviewsForSelectedSlot();
|
|
}
|
|
|
|
private void SaveCurrentSlot()
|
|
{
|
|
string userFolderId = BlockSpaceAccountPrefs.GetUserFolderId();
|
|
if (string.IsNullOrEmpty(userFolderId) || client == null || (mode == InventoryMode.Creations && (groupManager == null || !groupManager.CreatorMode || groupManager.EditingLocked)))
|
|
{
|
|
return;
|
|
}
|
|
string orCreateSelectedId = GetOrCreateSelectedId();
|
|
if (!string.IsNullOrEmpty(orCreateSelectedId))
|
|
{
|
|
if (mode == InventoryMode.Avatars)
|
|
{
|
|
StartCoroutine(SaveAvatarSlot(userFolderId, orCreateSelectedId));
|
|
}
|
|
else
|
|
{
|
|
StartCoroutine(SaveCreationSlot(userFolderId, orCreateSelectedId));
|
|
}
|
|
}
|
|
}
|
|
|
|
private void LoadCurrentSlot()
|
|
{
|
|
string userFolderId = BlockSpaceAccountPrefs.GetUserFolderId();
|
|
if (!string.IsNullOrEmpty(userFolderId) && client != null && (mode != InventoryMode.Creations || (!(groupManager == null) && groupManager.CreatorMode && !groupManager.EditingLocked)) && TryGetSelectedId(out var id) && !string.IsNullOrEmpty(id))
|
|
{
|
|
if (mode == InventoryMode.Avatars)
|
|
{
|
|
StartCoroutine(LoadAndEquipAvatar(userFolderId, id));
|
|
}
|
|
else
|
|
{
|
|
StartCoroutine(LoadCreationIntoWorld(userFolderId, id));
|
|
}
|
|
}
|
|
}
|
|
|
|
private IEnumerator RefreshSlots()
|
|
{
|
|
string playerId = BlockSpaceAccountPrefs.GetUserFolderId();
|
|
if (string.IsNullOrEmpty(playerId) || client == null)
|
|
{
|
|
ids.Clear();
|
|
yield break;
|
|
}
|
|
InventoryBackendClient.ListResponse response = null;
|
|
if (mode == InventoryMode.Avatars)
|
|
{
|
|
yield return client.ListAvatars(playerId, delegate(InventoryBackendClient.ListResponse r)
|
|
{
|
|
response = r;
|
|
});
|
|
}
|
|
else
|
|
{
|
|
yield return client.ListCreations(playerId, delegate(InventoryBackendClient.ListResponse r)
|
|
{
|
|
response = r;
|
|
});
|
|
}
|
|
ids.Clear();
|
|
if (response != null && response.ok && response.ids != null)
|
|
{
|
|
ids.AddRange(response.ids);
|
|
}
|
|
ids.Add(string.Empty);
|
|
equippedAvatarId = ((response != null) ? (response.equippedId ?? string.Empty) : string.Empty);
|
|
if (debugLogs)
|
|
{
|
|
Debug.Log($"InventoryController: mode={mode} playerIdLen={playerId.Length} ids={ids.Count} equipped={equippedAvatarId}");
|
|
}
|
|
slotIndex = Mathf.Clamp(slotIndex, 0, Mathf.Max(0, ids.Count - 1));
|
|
UpdatePreviewsForSelectedSlot();
|
|
if (mode != InventoryMode.Avatars || !BlockSpaceAccountPrefs.IsLinked)
|
|
{
|
|
yield break;
|
|
}
|
|
bool flag = false;
|
|
for (int num = 0; num < ids.Count; num++)
|
|
{
|
|
if (!string.IsNullOrEmpty(ids[num]))
|
|
{
|
|
flag = true;
|
|
break;
|
|
}
|
|
}
|
|
if (flag || !AvatarVoxelStorage.TryLoadLocal(out var localPayload) || !AvatarPayloadHasVoxels(localPayload))
|
|
{
|
|
yield break;
|
|
}
|
|
string newId = MakeNewId();
|
|
InventoryBackendClient.PutResponse put = null;
|
|
yield return client.UploadAvatar(playerId, newId, AvatarVoxelStorage.Serialize(localPayload), delegate(InventoryBackendClient.PutResponse r)
|
|
{
|
|
put = r;
|
|
});
|
|
if (put != null && put.ok && put.saved)
|
|
{
|
|
InventoryBackendClient.EquipResponse equip = null;
|
|
yield return client.EquipAvatar(playerId, newId, delegate(InventoryBackendClient.EquipResponse r)
|
|
{
|
|
equip = r;
|
|
});
|
|
PhotonVoxelAvatar localOwnedInstance = PhotonVoxelAvatar.LocalOwnedInstance;
|
|
if (localOwnedInstance != null)
|
|
{
|
|
localOwnedInstance.ApplyAndBroadcastAvatar(localPayload);
|
|
}
|
|
if (PlayerPrefs.HasKey("BlockSpace.Avatar.Payload"))
|
|
{
|
|
PlayerPrefs.DeleteKey("BlockSpace.Avatar.Payload");
|
|
PlayerPrefs.Save();
|
|
}
|
|
slotsDirty = true;
|
|
}
|
|
}
|
|
|
|
private static bool AvatarPayloadHasVoxels(AvatarVoxelPayload payload)
|
|
{
|
|
if (payload == null)
|
|
{
|
|
return false;
|
|
}
|
|
if (!GroupDataHasVoxels(payload.headBody) && !GroupDataHasVoxels(payload.left))
|
|
{
|
|
return GroupDataHasVoxels(payload.right);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private static bool AvatarPayloadHasAnyBase64(AvatarVoxelPayload payload)
|
|
{
|
|
if (payload == null)
|
|
{
|
|
return false;
|
|
}
|
|
if (string.IsNullOrEmpty(payload.headBody?.voxelsBase64) && string.IsNullOrEmpty(payload.left?.voxelsBase64))
|
|
{
|
|
return !string.IsNullOrEmpty(payload.right?.voxelsBase64);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private static int AvatarPayloadBase64TotalLength(AvatarVoxelPayload payload)
|
|
{
|
|
if (payload == null)
|
|
{
|
|
return 0;
|
|
}
|
|
return (payload.headBody?.voxelsBase64 ?? string.Empty).Length + (payload.left?.voxelsBase64 ?? string.Empty).Length + (payload.right?.voxelsBase64 ?? string.Empty).Length;
|
|
}
|
|
|
|
private static bool GroupDataHasVoxels(AvatarVoxelGroupData group)
|
|
{
|
|
if (group == null)
|
|
{
|
|
return false;
|
|
}
|
|
if (group.sizeX <= 0 || group.sizeY <= 0 || group.sizeZ <= 0)
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private IEnumerator SaveAvatarSlot(string playerId, string avatarId)
|
|
{
|
|
AvatarCustomizerController avatarCustomizerController = UnityEngine.Object.FindObjectOfType<AvatarCustomizerController>();
|
|
PhotonVoxelAvatar runtime = PhotonVoxelAvatar.LocalOwnedInstance;
|
|
AvatarVoxelPayload editorPayload = null;
|
|
VoxelGroup headBody = null;
|
|
VoxelGroup left = null;
|
|
VoxelGroup right = null;
|
|
if (avatarCustomizerController != null && avatarCustomizerController.TryGetEditorGroups(out headBody, out left, out right))
|
|
{
|
|
editorPayload = AvatarVoxelStorage.CapturePayload(headBody, left, right);
|
|
}
|
|
AvatarVoxelPayload avatarVoxelPayload = ((runtime != null) ? runtime.CaptureRuntimePayload() : null);
|
|
AvatarVoxelPayload payload;
|
|
AvatarVoxelPayload localPayload = (AvatarVoxelStorage.TryLoadLocal(out payload) ? payload : null);
|
|
AvatarVoxelPayload payload2 = (AvatarPayloadHasAnyBase64(editorPayload) ? editorPayload : (AvatarPayloadHasAnyBase64(avatarVoxelPayload) ? avatarVoxelPayload : (AvatarPayloadHasAnyBase64(localPayload) ? localPayload : (AvatarPayloadHasVoxels(editorPayload) ? editorPayload : (AvatarPayloadHasVoxels(avatarVoxelPayload) ? avatarVoxelPayload : (AvatarPayloadHasVoxels(localPayload) ? localPayload : (editorPayload ?? avatarVoxelPayload ?? localPayload ?? AvatarVoxelStorage.CreateEmptyPayload())))))));
|
|
if (runtime != null && AvatarPayloadBase64TotalLength(payload2) <= 0 && !runtime.HasRuntimeGroups)
|
|
{
|
|
float waited = 0f;
|
|
while (waited < 1.5f && !runtime.HasRuntimeGroups)
|
|
{
|
|
waited += 0.1f;
|
|
yield return new WaitForSeconds(0.1f);
|
|
}
|
|
avatarVoxelPayload = runtime.CaptureRuntimePayload();
|
|
if (AvatarPayloadHasAnyBase64(avatarVoxelPayload))
|
|
{
|
|
payload2 = avatarVoxelPayload;
|
|
}
|
|
else if (AvatarPayloadHasAnyBase64(localPayload))
|
|
{
|
|
payload2 = localPayload;
|
|
}
|
|
}
|
|
string text = AvatarVoxelStorage.Serialize(payload2);
|
|
if (text == "{}" || text.Length <= 4 || AvatarPayloadBase64TotalLength(payload2) <= 0)
|
|
{
|
|
Debug.LogWarning($"InventoryController: refusing to upload empty avatar payload slot={avatarId} jsonLen={text.Length} base64Total={AvatarPayloadBase64TotalLength(payload2)}");
|
|
yield break;
|
|
}
|
|
if (debugLogs)
|
|
{
|
|
int num = ((headBody != null && headBody.voxels != null) ? headBody.voxels.Length : 0);
|
|
int num2 = ((left != null && left.voxels != null) ? left.voxels.Length : 0);
|
|
int num3 = ((right != null && right.voxels != null) ? right.voxels.Length : 0);
|
|
int num4 = Mathf.Max(0, payload2.headBody?.sizeX ?? 0) * Mathf.Max(0, payload2.headBody?.sizeY ?? 0) * Mathf.Max(0, payload2.headBody?.sizeZ ?? 0);
|
|
int num5 = Mathf.Max(0, payload2.left?.sizeX ?? 0) * Mathf.Max(0, payload2.left?.sizeY ?? 0) * Mathf.Max(0, payload2.left?.sizeZ ?? 0);
|
|
int num6 = Mathf.Max(0, payload2.right?.sizeX ?? 0) * Mathf.Max(0, payload2.right?.sizeY ?? 0) * Mathf.Max(0, payload2.right?.sizeZ ?? 0);
|
|
int length = (payload2.headBody?.voxelsBase64 ?? string.Empty).Length;
|
|
int num7 = AvatarPayloadBase64TotalLength(payload2);
|
|
string text2 = ((payload2 == editorPayload) ? "editor" : ((payload2 == avatarVoxelPayload) ? "runtime" : ((payload2 == localPayload) ? "local" : "other")));
|
|
Debug.Log($"InventoryController: saving avatar slot={avatarId} chosen={text2} editor(head={num},left={num2},right={num3}) payloadExpected(head={num4},left={num5},right={num6}) headB64Len={length} b64Total={num7} jsonLen={text.Length}");
|
|
}
|
|
AvatarVoxelStorage.SaveLocal(payload2);
|
|
InventoryBackendClient.PutResponse put = null;
|
|
yield return client.UploadAvatar(playerId, avatarId, text, delegate(InventoryBackendClient.PutResponse r)
|
|
{
|
|
put = r;
|
|
});
|
|
if (put != null && put.ok && put.saved)
|
|
{
|
|
slotsDirty = true;
|
|
if (debugLogs)
|
|
{
|
|
string roundTrip = string.Empty;
|
|
yield return client.DownloadAvatar(playerId, avatarId, delegate(string t)
|
|
{
|
|
roundTrip = t;
|
|
});
|
|
int num8 = ((roundTrip != null) ? Encoding.UTF8.GetByteCount(roundTrip) : 0);
|
|
int num9 = 0;
|
|
if (!string.IsNullOrEmpty(roundTrip) && AvatarVoxelStorage.TryDeserialize(roundTrip, out var payload3))
|
|
{
|
|
num9 = (payload3.headBody?.voxelsBase64 ?? string.Empty).Length;
|
|
}
|
|
Debug.Log($"InventoryController: avatar roundtrip bytes={num8} headB64Len={num9}");
|
|
}
|
|
}
|
|
else if (debugLogs)
|
|
{
|
|
Debug.LogWarning(string.Format("InventoryController: UploadAvatar failed ok={0} saved={1} err={2}", put != null && put.ok, put != null && put.saved, (put != null) ? put.error : "null"));
|
|
}
|
|
}
|
|
|
|
private IEnumerator LoadAndEquipAvatar(string playerId, string avatarId)
|
|
{
|
|
string json = string.Empty;
|
|
yield return client.DownloadAvatar(playerId, avatarId, delegate(string t)
|
|
{
|
|
json = t;
|
|
});
|
|
if (!string.IsNullOrWhiteSpace(json) && AvatarVoxelStorage.TryDeserialize(json, out var payload))
|
|
{
|
|
AvatarCustomizerController avatarCustomizerController = UnityEngine.Object.FindObjectOfType<AvatarCustomizerController>();
|
|
if (avatarCustomizerController != null && avatarCustomizerController.TryGetEditorGroups(out var headBody, out var left, out var right))
|
|
{
|
|
AvatarVoxelStorage.ApplyPayload(payload, headBody, left, right, groupManager, useLocalGridTransform: true);
|
|
}
|
|
PhotonVoxelAvatar localOwnedInstance = PhotonVoxelAvatar.LocalOwnedInstance;
|
|
if (localOwnedInstance != null)
|
|
{
|
|
localOwnedInstance.ApplyAndBroadcastAvatar(payload);
|
|
}
|
|
InventoryBackendClient.EquipResponse equip = null;
|
|
yield return client.EquipAvatar(playerId, avatarId, delegate(InventoryBackendClient.EquipResponse r)
|
|
{
|
|
equip = r;
|
|
});
|
|
slotsDirty = true;
|
|
}
|
|
}
|
|
|
|
private IEnumerator SaveCreationSlot(string playerId, string creationId)
|
|
{
|
|
VRGroupSelector instance = VRGroupSelector.Instance;
|
|
List<VoxelGroup> list = ((instance != null) ? instance.GetSelectedGroupsSnapshot() : new List<VoxelGroup>());
|
|
NodeGraphManager instance2 = NodeGraphManager.Instance;
|
|
List<Node> list2 = ((instance2 != null) ? instance2.GetSelectedNodesSnapshot() : new List<Node>());
|
|
bool num = list != null && list.Count > 0;
|
|
bool flag = list2 != null && list2.Count > 0;
|
|
if (!num && !flag)
|
|
{
|
|
yield break;
|
|
}
|
|
HashSet<int> hashSet = null;
|
|
if (flag)
|
|
{
|
|
hashSet = new HashSet<int>();
|
|
for (int i = 0; i < list2.Count; i++)
|
|
{
|
|
if (list2[i] != null)
|
|
{
|
|
hashSet.Add(list2[i].NodeId);
|
|
}
|
|
}
|
|
}
|
|
byte[] gzipBytes = WorldGroupsCodec.EncodeGzip(list, (instance2 != null) ? instance2.BuildWorldNodeRecords(hashSet) : null, (instance2 != null) ? instance2.BuildWorldWireRecords(hashSet, BuildGroupSaveIndexMap(list)) : null);
|
|
InventoryBackendClient.PutResponse put = null;
|
|
yield return client.UploadCreation(playerId, creationId, gzipBytes, delegate(InventoryBackendClient.PutResponse r)
|
|
{
|
|
put = r;
|
|
});
|
|
if (put != null && put.ok && put.saved)
|
|
{
|
|
slotsDirty = true;
|
|
}
|
|
}
|
|
|
|
private IEnumerator LoadCreationIntoWorld(string playerId, string creationId)
|
|
{
|
|
byte[] gzip = null;
|
|
yield return client.DownloadCreation(playerId, creationId, delegate(byte[] b)
|
|
{
|
|
gzip = b;
|
|
});
|
|
if (gzip == null)
|
|
{
|
|
gzip = Array.Empty<byte>();
|
|
}
|
|
if (!WorldGroupsCodec.TryDecodeGzip(gzip, out WorldGroupsCodec.WorldSaveData saveData) || groupManager == null || !TryGetSpawnGridPosition(out var gridPosition))
|
|
{
|
|
yield break;
|
|
}
|
|
List<WorldGroupsCodec.WorldGroupRecord> list = saveData.groupRecords ?? new List<WorldGroupsCodec.WorldGroupRecord>();
|
|
List<WorldGroupsCodec.WorldNodeRecord> list2 = saveData.nodeRecords ?? new List<WorldGroupsCodec.WorldNodeRecord>();
|
|
if (list.Count == 0 && list2.Count == 0)
|
|
{
|
|
yield break;
|
|
}
|
|
float voxelSize = groupManager.VoxelSize;
|
|
Vector3 vector = ((list.Count > 0) ? new Vector3((float)list[0].position.x * voxelSize, (float)list[0].position.y * voxelSize, (float)list[0].position.z * voxelSize) : list2[0].position);
|
|
for (int num = 1; num < list.Count; num++)
|
|
{
|
|
Vector3 rhs = new Vector3((float)list[num].position.x * voxelSize, (float)list[num].position.y * voxelSize, (float)list[num].position.z * voxelSize);
|
|
vector = Vector3.Min(vector, rhs);
|
|
}
|
|
for (int num2 = 0; num2 < list2.Count; num2++)
|
|
{
|
|
vector = Vector3.Min(vector, list2[num2].position);
|
|
}
|
|
Dictionary<int, int> dictionary = new Dictionary<int, int>();
|
|
for (int num3 = 0; num3 < list.Count; num3++)
|
|
{
|
|
WorldGroupsCodec.WorldGroupRecord worldGroupRecord = list[num3];
|
|
VoxelGroupManager.SavedGroupData data = new VoxelGroupManager.SavedGroupData
|
|
{
|
|
position = worldGroupRecord.position,
|
|
packedRotation = worldGroupRecord.packedRotation,
|
|
size = worldGroupRecord.size,
|
|
voxels = worldGroupRecord.voxels
|
|
};
|
|
Vector3 vector2 = new Vector3((float)worldGroupRecord.position.x * voxelSize, (float)worldGroupRecord.position.y * voxelSize, (float)worldGroupRecord.position.z * voxelSize);
|
|
Vector3Int vector3Int = new Vector3Int(Mathf.RoundToInt((vector2.x - vector.x) / voxelSize), Mathf.RoundToInt((vector2.y - vector.y) / voxelSize), Mathf.RoundToInt((vector2.z - vector.z) / voxelSize));
|
|
VoxelGroup voxelGroup = groupManager.SpawnSavedGroup(data, gridPosition + vector3Int);
|
|
if (voxelGroup != null)
|
|
{
|
|
dictionary[num3] = voxelGroup.id;
|
|
}
|
|
}
|
|
if (list2.Count > 0)
|
|
{
|
|
NodeGraphManager instance = NodeGraphManager.Instance;
|
|
if (instance != null)
|
|
{
|
|
instance.ApplySavedGraph(positionOffset: new Vector3((float)gridPosition.x * voxelSize, (float)gridPosition.y * voxelSize, (float)gridPosition.z * voxelSize) - vector, nodeRecords: list2, wireRecords: saveData.wireRecords, clearExisting: false, broadcast: true, savedGroupIndexToRuntimeId: dictionary);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static Dictionary<int, int> BuildGroupSaveIndexMap(IList<VoxelGroup> groups)
|
|
{
|
|
Dictionary<int, int> dictionary = new Dictionary<int, int>();
|
|
if (groups == null)
|
|
{
|
|
return dictionary;
|
|
}
|
|
for (int i = 0; i < groups.Count; i++)
|
|
{
|
|
VoxelGroup voxelGroup = groups[i];
|
|
if (voxelGroup != null)
|
|
{
|
|
dictionary[voxelGroup.id] = i;
|
|
}
|
|
}
|
|
return dictionary;
|
|
}
|
|
|
|
private void UpdatePreviewsForSelectedSlot()
|
|
{
|
|
previewRequestToken++;
|
|
if (mode == InventoryMode.Avatars)
|
|
{
|
|
ApplyEmptyAvatarPreview();
|
|
StartCoroutine(UpdateAvatarPreviews());
|
|
}
|
|
else
|
|
{
|
|
ApplyEmptyCreationPreview();
|
|
StartCoroutine(UpdateCreationPreview());
|
|
}
|
|
}
|
|
|
|
private IEnumerator UpdateAvatarPreviews()
|
|
{
|
|
EnsurePreviewGroups();
|
|
int token = previewRequestToken;
|
|
string userFolderId = BlockSpaceAccountPrefs.GetUserFolderId();
|
|
if (string.IsNullOrEmpty(userFolderId) || client == null)
|
|
{
|
|
yield break;
|
|
}
|
|
if (!TryGetSelectedId(out var id) || string.IsNullOrEmpty(id))
|
|
{
|
|
ApplyEmptyAvatarPreview();
|
|
yield break;
|
|
}
|
|
ApplyEmptyAvatarPreview();
|
|
string json = string.Empty;
|
|
yield return client.DownloadAvatar(userFolderId, id, delegate(string t)
|
|
{
|
|
json = t;
|
|
});
|
|
if (token != previewRequestToken)
|
|
{
|
|
yield break;
|
|
}
|
|
if (string.IsNullOrWhiteSpace(json) || !AvatarVoxelStorage.TryDeserialize(json, out var payload))
|
|
{
|
|
if (debugLogs)
|
|
{
|
|
string text = json ?? string.Empty;
|
|
if (text.Length > 120)
|
|
{
|
|
text = text.Substring(0, 120);
|
|
}
|
|
Debug.LogWarning($"InventoryController: avatar download/parse failed id={id} jsonLen={(json ?? string.Empty).Length} snippet={text}");
|
|
}
|
|
ApplyEmptyAvatarPreview();
|
|
yield break;
|
|
}
|
|
if (debugLogs)
|
|
{
|
|
int num = Mathf.Max(0, payload.headBody?.sizeX ?? 0) * Mathf.Max(0, payload.headBody?.sizeY ?? 0) * Mathf.Max(0, payload.headBody?.sizeZ ?? 0);
|
|
int num2 = Mathf.Max(0, payload.left?.sizeX ?? 0) * Mathf.Max(0, payload.left?.sizeY ?? 0) * Mathf.Max(0, payload.left?.sizeZ ?? 0);
|
|
int num3 = Mathf.Max(0, payload.right?.sizeX ?? 0) * Mathf.Max(0, payload.right?.sizeY ?? 0) * Mathf.Max(0, payload.right?.sizeZ ?? 0);
|
|
Debug.Log($"InventoryController: avatarId={id} headExpected={num} leftExpected={num2} rightExpected={num3} headB64Len={(payload.headBody?.voxelsBase64 ?? string.Empty).Length}");
|
|
}
|
|
ApplyAvatarPreviewPayload(payload);
|
|
}
|
|
|
|
private IEnumerator UpdateCreationPreview()
|
|
{
|
|
EnsurePreviewGroups();
|
|
int token = previewRequestToken;
|
|
string userFolderId = BlockSpaceAccountPrefs.GetUserFolderId();
|
|
if (string.IsNullOrEmpty(userFolderId) || client == null)
|
|
{
|
|
yield break;
|
|
}
|
|
if (!TryGetSelectedId(out var id) || string.IsNullOrEmpty(id))
|
|
{
|
|
ApplyEmptyCreationPreview();
|
|
yield break;
|
|
}
|
|
ApplyEmptyCreationPreview();
|
|
byte[] gzip = null;
|
|
yield return client.DownloadCreation(userFolderId, id, delegate(byte[] b)
|
|
{
|
|
gzip = b;
|
|
});
|
|
if (token == previewRequestToken)
|
|
{
|
|
if (gzip == null)
|
|
{
|
|
gzip = Array.Empty<byte>();
|
|
}
|
|
if (!WorldGroupsCodec.TryDecodeGzip(gzip, out WorldGroupsCodec.WorldSaveData saveData) || saveData.groupRecords == null || saveData.groupRecords.Count == 0)
|
|
{
|
|
ApplyEmptyCreationPreview();
|
|
}
|
|
else
|
|
{
|
|
ApplyCreationPreviewRecords(saveData.groupRecords);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ApplyCreationPreviewRecords(List<WorldGroupsCodec.WorldGroupRecord> records)
|
|
{
|
|
if (creationPreviewRoot == null || groupManager == null)
|
|
{
|
|
return;
|
|
}
|
|
EnsurePreviewGroups();
|
|
Vector3Int vector3Int = records[0].position;
|
|
Vector3Int vector3Int2 = records[0].position + records[0].size;
|
|
for (int i = 1; i < records.Count; i++)
|
|
{
|
|
Vector3Int position = records[i].position;
|
|
Vector3Int rhs = records[i].position + records[i].size;
|
|
vector3Int = Vector3Int.Min(vector3Int, position);
|
|
vector3Int2 = Vector3Int.Max(vector3Int2, rhs);
|
|
}
|
|
while (previewCreationGroups.Count < records.Count)
|
|
{
|
|
int count = previewCreationGroups.Count;
|
|
GameObject obj = new GameObject($"CreationGroupPreview_{count}");
|
|
obj.transform.SetParent(creationPreviewRoot, worldPositionStays: false);
|
|
VoxelGroup voxelGroup = obj.AddComponent<VoxelGroup>();
|
|
voxelGroup.id = (ushort)(62500 + count);
|
|
voxelGroup.SetOwner(groupManager);
|
|
voxelGroup.SetUseLocalGridTransform(useLocalGrid: true);
|
|
voxelGroup.SetColliderGeneration(enabled: false);
|
|
previewCreationGroups.Add(voxelGroup);
|
|
}
|
|
for (int j = records.Count; j < previewCreationGroups.Count; j++)
|
|
{
|
|
if (previewCreationGroups[j] != null)
|
|
{
|
|
previewCreationGroups[j].OverwriteData(Vector3Int.zero, 0, Vector3Int.zero, new byte[0], queueRebuild: false);
|
|
previewCreationGroups[j].SetVoxelSizeScale(1f, rebuild: false);
|
|
previewCreationGroups[j].RebuildMesh();
|
|
}
|
|
}
|
|
for (int k = 0; k < records.Count; k++)
|
|
{
|
|
WorldGroupsCodec.WorldGroupRecord worldGroupRecord = records[k];
|
|
VoxelGroup voxelGroup2 = previewCreationGroups[k];
|
|
if (!(voxelGroup2 == null))
|
|
{
|
|
Vector3Int gridPosition = worldGroupRecord.position - vector3Int;
|
|
voxelGroup2.SetUseLocalGridTransform(useLocalGrid: true);
|
|
voxelGroup2.SetColliderGeneration(enabled: false);
|
|
voxelGroup2.SetOwner(groupManager);
|
|
voxelGroup2.OverwriteData(gridPosition, worldGroupRecord.packedRotation, worldGroupRecord.size, worldGroupRecord.voxels, queueRebuild: false);
|
|
voxelGroup2.SetVoxelSizeScale(1f, rebuild: false);
|
|
voxelGroup2.RebuildMesh();
|
|
}
|
|
}
|
|
Vector3 vector = vector3Int2 - vector3Int;
|
|
float num = ((groupManager != null) ? groupManager.VoxelSize : 0.125f);
|
|
float num2 = Mathf.Max(vector.x, Mathf.Max(vector.y, vector.z)) * num;
|
|
float num3 = ((num2 > 0.0001f) ? Mathf.Min(1f, 3f / num2) : 1f);
|
|
creationPreviewRoot.localScale = Vector3.one * num3;
|
|
}
|
|
|
|
private void ApplyEmptyCreationPreview()
|
|
{
|
|
for (int i = 0; i < previewCreationGroups.Count; i++)
|
|
{
|
|
if (previewCreationGroups[i] != null)
|
|
{
|
|
previewCreationGroups[i].OverwriteData(Vector3Int.zero, 0, Vector3Int.zero, new byte[0], queueRebuild: false);
|
|
previewCreationGroups[i].RebuildMesh();
|
|
}
|
|
}
|
|
if (creationPreviewRoot != null)
|
|
{
|
|
creationPreviewRoot.localScale = Vector3.one;
|
|
}
|
|
}
|
|
|
|
private void ApplyAvatarPreviewPayload(AvatarVoxelPayload payload)
|
|
{
|
|
if (!(groupManager == null))
|
|
{
|
|
EnsurePreviewGroups();
|
|
if (previewHeadGroup != null)
|
|
{
|
|
AvatarVoxelStorage.ApplyGroupData(previewHeadGroup, payload.headBody, groupManager, useLocalGridTransform: true);
|
|
}
|
|
if (previewLeftGroup != null)
|
|
{
|
|
AvatarVoxelStorage.ApplyGroupData(previewLeftGroup, payload.left, groupManager, useLocalGridTransform: true);
|
|
}
|
|
if (previewRightGroup != null)
|
|
{
|
|
AvatarVoxelStorage.ApplyGroupData(previewRightGroup, payload.right, groupManager, useLocalGridTransform: true);
|
|
}
|
|
if (previewHeadGroup != null)
|
|
{
|
|
previewHeadGroup.SetVoxelSizeScale(0.5f, rebuild: false);
|
|
previewHeadGroup.RebuildMesh();
|
|
}
|
|
if (previewLeftGroup != null)
|
|
{
|
|
previewLeftGroup.SetVoxelSizeScale(0.5f, rebuild: false);
|
|
previewLeftGroup.RebuildMesh();
|
|
}
|
|
if (previewRightGroup != null)
|
|
{
|
|
previewRightGroup.SetVoxelSizeScale(0.5f, rebuild: false);
|
|
previewRightGroup.RebuildMesh();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ApplyEmptyAvatarPreview()
|
|
{
|
|
EnsurePreviewGroups();
|
|
if (!(previewHeadGroup == null))
|
|
{
|
|
previewHeadGroup.OverwriteData(Vector3Int.zero, 0, Vector3Int.zero, new byte[0], queueRebuild: false);
|
|
previewLeftGroup.OverwriteData(Vector3Int.zero, 0, Vector3Int.zero, new byte[0], queueRebuild: false);
|
|
previewRightGroup.OverwriteData(Vector3Int.zero, 0, Vector3Int.zero, new byte[0], queueRebuild: false);
|
|
previewHeadGroup.RebuildMesh();
|
|
previewLeftGroup.RebuildMesh();
|
|
previewRightGroup.RebuildMesh();
|
|
}
|
|
}
|
|
|
|
private void ResolveSceneReferences()
|
|
{
|
|
if (groupManager == null)
|
|
{
|
|
groupManager = ((VoxelGroupManager.Instance != null) ? VoxelGroupManager.Instance : UnityEngine.Object.FindObjectOfType<VoxelGroupManager>());
|
|
}
|
|
if (voxelBrush == null)
|
|
{
|
|
voxelBrush = ((VRVoxelBrush.Instance != null) ? VRVoxelBrush.Instance : UnityEngine.Object.FindObjectOfType<VRVoxelBrush>());
|
|
}
|
|
if (avatarsButton == null)
|
|
{
|
|
avatarsButton = FindCollider("Avatars");
|
|
}
|
|
if (creationsButton == null)
|
|
{
|
|
creationsButton = FindCollider("Creations");
|
|
}
|
|
if (backButton == null)
|
|
{
|
|
backButton = FindCollider("Back");
|
|
}
|
|
if (nextButton == null)
|
|
{
|
|
nextButton = FindCollider("Next");
|
|
}
|
|
if (saveButton == null)
|
|
{
|
|
saveButton = FindCollider("Save");
|
|
}
|
|
if (loadButton == null)
|
|
{
|
|
loadButton = FindCollider("Load");
|
|
}
|
|
if (creationPreviewRoot == null)
|
|
{
|
|
creationPreviewRoot = FindTransform("Preview");
|
|
}
|
|
if (previewRight == null)
|
|
{
|
|
previewRight = FindTransform("PrevR");
|
|
}
|
|
if (previewHead == null)
|
|
{
|
|
previewHead = FindTransform("PrevH");
|
|
}
|
|
if (previewLeft == null)
|
|
{
|
|
previewLeft = FindTransform("PrevL");
|
|
}
|
|
}
|
|
|
|
private Collider FindCollider(string name)
|
|
{
|
|
Transform transform = base.transform.Find("UI/" + name);
|
|
if (transform == null)
|
|
{
|
|
GameObject gameObject = GameObject.Find(name);
|
|
transform = ((gameObject != null) ? gameObject.transform : null);
|
|
}
|
|
if (!(transform != null))
|
|
{
|
|
return null;
|
|
}
|
|
return transform.GetComponent<Collider>();
|
|
}
|
|
|
|
private Transform FindTransform(string name)
|
|
{
|
|
if (string.IsNullOrEmpty(name))
|
|
{
|
|
return null;
|
|
}
|
|
if (transformCache.TryGetValue(name, out var value) && value != null)
|
|
{
|
|
return value;
|
|
}
|
|
Transform transform = base.transform.Find(name);
|
|
if (transform != null)
|
|
{
|
|
transformCache[name] = transform;
|
|
return transform;
|
|
}
|
|
Transform[] componentsInChildren = GetComponentsInChildren<Transform>(includeInactive: true);
|
|
foreach (Transform transform2 in componentsInChildren)
|
|
{
|
|
if (transform2 != null && string.Equals(transform2.name, name, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
transformCache[name] = transform2;
|
|
return transform2;
|
|
}
|
|
}
|
|
GameObject gameObject = GameObject.Find(name);
|
|
if (gameObject != null)
|
|
{
|
|
transformCache[name] = gameObject.transform;
|
|
return gameObject.transform;
|
|
}
|
|
Transform[] array = UnityEngine.Object.FindObjectsOfType<Transform>(includeInactive: true);
|
|
foreach (Transform transform3 in array)
|
|
{
|
|
if (transform3 != null && string.Equals(transform3.name, name, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
transformCache[name] = transform3;
|
|
return transform3;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private void EnsureButtonAudioAssigned()
|
|
{
|
|
if (!(buttonThockClip != null))
|
|
{
|
|
buttonThockClip = Resources.Load<AudioClip>("Thock");
|
|
}
|
|
}
|
|
|
|
private void EnsurePreviewGroups()
|
|
{
|
|
if (!(groupManager == null))
|
|
{
|
|
if (creationPreviewRoot == null)
|
|
{
|
|
creationPreviewRoot = FindTransform("Preview");
|
|
}
|
|
if (previewRight == null)
|
|
{
|
|
previewRight = FindTransform("PrevR");
|
|
}
|
|
if (previewHead == null)
|
|
{
|
|
previewHead = FindTransform("PrevH");
|
|
}
|
|
if (previewLeft == null)
|
|
{
|
|
previewLeft = FindTransform("PrevL");
|
|
}
|
|
if (creationPreviewRoot != null && previewCreationGroups.Count == 0)
|
|
{
|
|
GameObject gameObject = new GameObject("CreationGroupPreview_0");
|
|
gameObject.transform.SetParent(creationPreviewRoot, worldPositionStays: false);
|
|
previewCreationGroup = gameObject.AddComponent<VoxelGroup>();
|
|
previewCreationGroup.id = 62500;
|
|
previewCreationGroup.SetOwner(groupManager);
|
|
previewCreationGroup.SetUseLocalGridTransform(useLocalGrid: true);
|
|
previewCreationGroup.SetColliderGeneration(enabled: false);
|
|
previewCreationGroups.Add(previewCreationGroup);
|
|
}
|
|
else if (creationPreviewRoot == null && !warnedMissingCreationPreviewRoot)
|
|
{
|
|
warnedMissingCreationPreviewRoot = true;
|
|
Debug.LogWarning("InventoryController: could not find Creation Preview root named 'Preview'. Creation previews will be hidden until it exists.");
|
|
}
|
|
previewHeadGroup = EnsurePreviewGroupOn(previewHead, previewHeadGroup, 62000);
|
|
previewLeftGroup = EnsurePreviewGroupOn(previewLeft, previewLeftGroup, 62001);
|
|
previewRightGroup = EnsurePreviewGroupOn(previewRight, previewRightGroup, 62002);
|
|
if (!warnedMissingAvatarPreviewRoots && (previewHead == null || previewLeft == null || previewRight == null))
|
|
{
|
|
warnedMissingAvatarPreviewRoots = true;
|
|
Debug.LogWarning("InventoryController: could not find one or more avatar preview roots ('PrevH', 'PrevL', 'PrevR'). Avatar previews will be hidden until they exist.");
|
|
}
|
|
}
|
|
}
|
|
|
|
private VoxelGroup EnsurePreviewGroupOn(Transform root, VoxelGroup existing, ushort id)
|
|
{
|
|
if (root == null || groupManager == null)
|
|
{
|
|
return existing;
|
|
}
|
|
VoxelGroup voxelGroup = ((existing != null) ? existing : root.GetComponent<VoxelGroup>());
|
|
if (voxelGroup == null)
|
|
{
|
|
voxelGroup = root.gameObject.AddComponent<VoxelGroup>();
|
|
}
|
|
voxelGroup.id = id;
|
|
voxelGroup.SetOwner(groupManager);
|
|
voxelGroup.SetUseLocalGridTransform(useLocalGrid: true);
|
|
voxelGroup.SetColliderGeneration(enabled: false);
|
|
voxelGroup.SetVoxelSizeScale(0.5f);
|
|
return voxelGroup;
|
|
}
|
|
|
|
private void HandleButton(Collider button, ref bool insidePrevious, Action action)
|
|
{
|
|
bool flag = IsHandInside(button, (voxelBrush != null) ? voxelBrush.LeftHandAnchor : null) || IsHandInside(button, (voxelBrush != null) ? voxelBrush.RightHandAnchor : null);
|
|
if (flag && !insidePrevious)
|
|
{
|
|
PlayButtonEnterAnimation(button);
|
|
if (Time.unscaledTime >= nextButtonPressTime)
|
|
{
|
|
nextButtonPressTime = Time.unscaledTime + 0.2f;
|
|
PlayButtonClickFeedback(button);
|
|
action?.Invoke();
|
|
}
|
|
}
|
|
insidePrevious = flag;
|
|
}
|
|
|
|
private static bool IsHandInside(Collider button, Transform hand)
|
|
{
|
|
if (button == null || hand == null)
|
|
{
|
|
return false;
|
|
}
|
|
return button.bounds.Contains(hand.position);
|
|
}
|
|
|
|
private void PlayButtonEnterAnimation(Collider button)
|
|
{
|
|
if (!(button == null))
|
|
{
|
|
Transform transform = button.transform;
|
|
if (!buttonBaseScales.TryGetValue(transform, out var value))
|
|
{
|
|
value = transform.localScale;
|
|
buttonBaseScales.Add(transform, value);
|
|
}
|
|
if (buttonAnimationCoroutines.TryGetValue(transform, out var value2) && value2 != null)
|
|
{
|
|
StopCoroutine(value2);
|
|
}
|
|
transform.localScale = value;
|
|
buttonAnimationCoroutines[transform] = StartCoroutine(AnimateButtonScale(transform, value));
|
|
}
|
|
}
|
|
|
|
private IEnumerator AnimateButtonScale(Transform buttonTransform, Vector3 baseScale)
|
|
{
|
|
if (!(buttonTransform == null))
|
|
{
|
|
float startTime = Time.unscaledTime;
|
|
while (Time.unscaledTime - startTime < 0.08f)
|
|
{
|
|
float t = Mathf.Clamp01((Time.unscaledTime - startTime) / 0.08f);
|
|
buttonTransform.localScale = Vector3.Lerp(baseScale, baseScale * 0.84f, t);
|
|
yield return null;
|
|
}
|
|
startTime = Time.unscaledTime;
|
|
while (Time.unscaledTime - startTime < 0.12f)
|
|
{
|
|
float num = Mathf.Clamp01((Time.unscaledTime - startTime) / 0.12f);
|
|
float num2 = Mathf.Sin(num * MathF.PI);
|
|
Vector3 a = Vector3.Lerp(baseScale * 0.84f, baseScale, num);
|
|
buttonTransform.localScale = Vector3.LerpUnclamped(a, baseScale * 1.04f, num2 * 0.15f);
|
|
yield return null;
|
|
}
|
|
buttonTransform.localScale = baseScale;
|
|
}
|
|
}
|
|
|
|
private void PlayButtonClickFeedback(Collider button)
|
|
{
|
|
if (!(buttonThockClip == null) && !(button == null))
|
|
{
|
|
AudioSource.PlayClipAtPoint(buttonThockClip, button.bounds.center, 1f);
|
|
}
|
|
}
|
|
|
|
private void ResetAllButtonScales()
|
|
{
|
|
foreach (KeyValuePair<Transform, Vector3> buttonBaseScale in buttonBaseScales)
|
|
{
|
|
if (buttonBaseScale.Key != null)
|
|
{
|
|
buttonBaseScale.Key.localScale = buttonBaseScale.Value;
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool TryGetSelectedId(out string id)
|
|
{
|
|
id = string.Empty;
|
|
if (slotIndex < 0 || slotIndex >= ids.Count)
|
|
{
|
|
return false;
|
|
}
|
|
id = ids[slotIndex] ?? string.Empty;
|
|
return true;
|
|
}
|
|
|
|
private string GetOrCreateSelectedId()
|
|
{
|
|
if (!TryGetSelectedId(out var id))
|
|
{
|
|
return string.Empty;
|
|
}
|
|
if (!string.IsNullOrEmpty(id))
|
|
{
|
|
return id;
|
|
}
|
|
string text = MakeNewId();
|
|
ids[slotIndex] = text;
|
|
return text;
|
|
}
|
|
|
|
private static string MakeNewId()
|
|
{
|
|
return DateTime.UtcNow.ToString("yyyyMMddHHmmssfff");
|
|
}
|
|
|
|
private bool TryGetSpawnGridPosition(out Vector3Int gridPosition)
|
|
{
|
|
gridPosition = Vector3Int.zero;
|
|
VRVoxelBrush vRVoxelBrush = ((voxelBrush != null) ? voxelBrush : VRVoxelBrush.Instance);
|
|
if (vRVoxelBrush != null && vRVoxelBrush.TryGetSpawnGridPosition(out gridPosition))
|
|
{
|
|
return true;
|
|
}
|
|
float num = ((groupManager != null) ? groupManager.VoxelSize : 0.125f);
|
|
Vector3 vector = ((Camera.main != null) ? Camera.main.transform.position : base.transform.position) + ((Camera.main != null) ? Camera.main.transform.forward : base.transform.forward).normalized * 2f;
|
|
gridPosition = new Vector3Int(Mathf.RoundToInt(vector.x / num), Mathf.RoundToInt(vector.y / num), Mathf.RoundToInt(vector.z / num));
|
|
return true;
|
|
}
|
|
}
|
|
}
|