#region 作成対象のエンティティを Enqueueif (Input.GetKeyDown(KeyCode.Space))
{
for (var x = -15; x <= 15; x++)
{
for (var z = -15; z <= 15; z++)
{
for (var y = -15; y <= 15; y++)
{
this.EnqueueCreateEntity(x, y, z);
}
}
}
}
#endregion
31 x 31 x 31 チャンクの生成状況 32.52 ms ループ
タイムライン
遅い…なんとか高速化できないか
高速化について、次のように、中央から順に周辺チャンクを結合していくループを回すのはどうかと考えた
#region 作成対象のチャンク情報を Enqueueif (Input.GetKeyDown(KeyCode.Space))
{
var perChunkRadius = 1;
for (var x = -perChunkRadius; x <= perChunkRadius; x++)
{
for (var z = -perChunkRadius; z <= perChunkRadius; z++)
{
for (var y = -perChunkRadius; y <= perChunkRadius; y++)
{
this.EnqueueCreateEntity(x, y, z, 0);
}
}
}
for (var level = perChunkRadius + 1; level <= 2; level++)
{
if (2 > level)
{
break;
}
var offset = 3;
var geta = level * offset - 3;
for (var x = -geta; x <= geta; x += offset)
{
for (var z = -geta; z <= geta; z += offset)
{
for (var y = -geta; y <= geta; y += offset)
{
if (0 != geta - Mathf.Abs(x) && 0 != geta - Mathf.Abs(y) && 0 != geta - Mathf.Abs(z))
{
continue;
}
for (var radiusX = -perChunkRadius; radiusX <= perChunkRadius; radiusX++)
{
for (var radiusZ = -perChunkRadius; radiusZ <= perChunkRadius; radiusZ++)
{
for (var radiusY = -perChunkRadius; radiusY <= perChunkRadius; radiusY++)
{
if (0 == radiusX && 0 == radiusY && 0 == radiusZ)
{
continue;
}
this.EnqueueCreateEntity(x + radiusX, y + radiusY, z + radiusZ, 0);
}
}
}
this.EnqueueCreateEntity(x, y, z, 1);
}
}
}
}
}
#endregion
usingstatic Unity.Mathematics.math;
/// <summary>Returns the result of rotating a vector by a unit quaternion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
publicstatic float3 rotate(quaternion q, float3 v)
{
float3 t = 2 * cross(q.value.xyz, v);
return v + q.value.w * t + cross(q.value.xyz, t);
}
仮で、すべての頂点を X 軸で 90 度回転させてみます。
コードはこんな感じかな？
for (int vertexIndex = 0; vertexIndex < vertexCount * 3; vertexIndex += 3)
{
var positionXIndex = verticesOffset + vertexIndex;
var pPosition = meshData.pVerticesVector3 + positionXIndex;
var q = Unity.Mathematics.quaternion.RotateX(PI / 2);
var p = float3(pPosition[0], pPosition[1], pPosition[2]);
var r = rotate(q, p);
pPosition[0] = r.x + x * ChunkManager.CubeSide;
pPosition[1] = r.y + y * ChunkManager.CubeSide;
pPosition[2] = r.z + z * ChunkManager.CubeSide;
}
# ポインターのポインターで世界を 8 byte アドレスに
今回は 8 x 8 x 8 要素のチャンクを作り、これを使い回す形で 8 x8x8 個のエンティティを作成しています。
チャンクにインデックスを振るなら byte にする
現在はエンティティを個別に識別するための要素は Vector3 の位置だけ
その x, y, z 要素はそれぞれ Chunk の SideX, Y, Z の整数倍となっているので、単純に割ってから 256 で余りを得るとインデックスになる
ただ、ランタイムで割り算は行いたくないので、ここはエンティティ作成時に byte index を設定することにする
コードを書く前に検算ですが、3次元を一次元配列にしている現在
x 方向に一つ足すと (byte.MaxValue + 1) * (byte.MaxValue + 1) 足すことを意味する
困ったことに x 方向に一つ足すべきなのかを判別する計算がわからない
今は chunkData 内の index でしかなく、もし境界の要素だったとして、そこから一つ足した場合でも chunkData 内に納まるインデックスだったら？
ね？
判別不可能でしょう。
そこで、chunkData 内の index を受け取るのをやめて、もっと情報量のボリュームがある三次元 index x, y, z を受け取るようにするのはどうか？
こうすると例えば y を一つたして chunk の y 最大を n 回オーバーするときに ppChunk 内でいくつ移動すればよいかがわかる
これにしましょう。 リファクタリングします。
staticbyte* GetDataPtr(ChunkMeshData meshData, int x, int y, int z)
{
if (0 <= x && ChunkManager.ChunkSizeX > x
&& 0 <= y && ChunkManager.ChunkSizeY > y
&& 0 <= z && ChunkManager.ChunkSizeZ > z)
{
var dataIndex = (x * ChunkManager.ChunkSizeZ * ChunkManager.ChunkSizeY + z * ChunkManager.ChunkSizeY + y);
var pChunkData = meshData.ppChunkData[meshData.chunkIndex];
return (byte*)(pChunkData + dataIndex);
}
// over chunk count x, y, z// else
{
// 困ったreturnnull;
}
}
using System.Collections.Generic;
using Unity.Burst;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Entities;
using Unity.Jobs;
using UnityEngine;
internalunsafeclass CreateMeshSystem : ComponentSystem
{
/// <summary>/// チャンク情報から頂点数をカウント/// </summary>
[BurstCompile]
unsafestruct CountVerticesJob : IJobParallelFor
{
internal NativeArray<ChunkMeshData> meshDataArray;
internalint verticesSourceCount;
publicvoid Execute(int entityIndex)
{
var meshData = this.meshDataArray[entityIndex];
meshData.vertexCount = 0;
for (int dataIndex = 0; dataIndex < meshData.chunkDataLength; dataIndex++)
{
var data = meshData.pChunkData[dataIndex];
if (1 == data)
{
meshData.vertexCount += this.verticesSourceCount;
}
}
this.meshDataArray[entityIndex] = meshData;
}
}
/// <summary>/// 頂点バッファに頂点データを塗る/// </summary>
[BurstCompile]
unsafestruct FillVerticesJob : IJobParallelFor
{
[NativeDisableUnsafePtrRestriction] [ReadOnly] internalfloat* pVerticesSourceVector3;
internal NativeArray<ChunkMeshData> meshDataArray;
publicvoid Execute(int entityIndex)
{
var meshData = this.meshDataArray[entityIndex];
for (int dataIndex = 0; dataIndex < meshData.chunkDataLength; dataIndex++)
{
var data = meshData.pChunkData[dataIndex];
if (1 == data)
{
UnsafeUtility.MemCpy(meshData.pVerticesVector3, this.pVerticesSourceVector3, size: meshData.vertexCount * 3 * sizeof(float));
}
}
}
}
protectedoverrideunsafevoid OnCreate()
{
base.OnCreate();
this.query = GetEntityQuery(new EntityQueryDesc
{
All = new[] { ComponentType.ReadOnly<CreateMeshMarker>(),
ComponentType.ReadWrite<ChunkMeshData>() },
});
#region モデルの形状を定義→NativeArray確保int[] indices = newint[]
{
0, 1, 2,
3, 4, 5,
0, 2, 4,
4, 3, 0,
2, 1, 5,
5, 4, 2,
1, 0, 3,
3, 5, 1
};
constfloat root3 = 1.732051f;
var vertices = new Vector3[] {
new Vector3(0f, 1f, 0f),
new Vector3(1f, 1f, -root3),
new Vector3(-1f, 1f, -root3),
new Vector3(0f, 0f, 0f),
new Vector3(-1f, 0f, -root3),
new Vector3(1f, 0f, -root3),
};
Vector3[] verticesSourceVector3 = new Vector3[indices.Length];
for (int indicesIndex = 0; indicesIndex < indices.Length; indicesIndex++)
{
verticesSourceVector3[indicesIndex] = vertices[indices[indicesIndex]];
}
this.pVerticesSourceVector3 = (float*)(this.nativeVerticesSource = new NativeArray<Vector3>(verticesSourceVector3, Allocator.Persistent)).GetUnsafePtr();
#endregion
}
protectedoverridevoid OnDestroy()
{
this.nativeVerticesSource.Dispose(); // NativeArray 開放base.OnDestroy();
}
protectedunsafeoverridevoid OnUpdate()
{
#region NativeArray 確保
var entities = this.query.ToEntityArray(Allocator.TempJob);
var meshDataArray = this.query.ToComponentDataArray<ChunkMeshData>(Allocator.TempJob);
#endregion #region メッシュの頂点数をカウント
var countVerticesJob = new CountVerticesJob
{
verticesSourceCount = this.nativeVerticesSource.Length,
meshDataArray = meshDataArray
};
var jobHandle = countVerticesJob.Schedule(arrayLength: meshDataArray.Length, innerloopBatchCount: 1);
jobHandle.Complete();
#endregion #region カウント数→頂点バッファを確保→バッファポインタを ComponentData に代入this.nativeEntityVerticesList.Clear();
for (int entityIndex = 0; entityIndex < entities.Length; entityIndex++)
{
var meshData = meshDataArray[entityIndex];
var nativeVertices = new NativeArray<Vector3>(meshData.vertexCount, Allocator.TempJob);
this.nativeEntityVerticesList.Add(nativeVertices);
meshData.pVerticesVector3 = (float*)nativeVertices.GetUnsafePtr();
meshDataArray[entityIndex] = meshData;
}
#endregion #region 頂点バッファに頂点データを塗る
var fillVerticesJob = new FillVerticesJob
{
pVerticesSourceVector3 = this.pVerticesSourceVector3,
meshDataArray = meshDataArray
};
var fillJobHandle = fillVerticesJob.Schedule(arrayLength: meshDataArray.Length, innerloopBatchCount: 1);
fillJobHandle.Complete();
#endregion #region 頂点バッファ→マネージド配列→メッシュ作成→メッシュ法線・接線の計算for (int entityIndex = 0; entityIndex < entities.Length; entityIndex++)
{
var entity = entities[entityIndex];
var vertices = this.nativeEntityVerticesList[entityIndex].ToArray();
var mesh = new Mesh();
mesh.vertices = vertices;
int[] triangles = newint[vertices.Length];
for (int vertexIndex = 0; vertexIndex < vertices.Length; vertexIndex++)
{
triangles[vertexIndex] = vertexIndex;
}
mesh.SetIndices(triangles, MeshTopology.Triangles, submesh: 0, calculateBounds: true);
mesh.RecalculateNormals();
mesh.RecalculateTangents();
var meshFilter = EntityManager.GetComponentObject<MeshFilter>(entity);
meshFilter.mesh = mesh;
this.nativeEntityVerticesList[entityIndex].Dispose();
}
this.nativeEntityVerticesList.Clear();
#endregion #region entity から marker の除去for (int entityIndex = 0; entityIndex < entities.Length; entityIndex++)
{
var entity = entities[entityIndex];
EntityManager.RemoveComponent(entity, ComponentType.ReadOnly<CreateMeshMarker>());
}
#endregion #region NativeArray 開放
meshDataArray.Dispose();
entities.Dispose();
#endregion
}
EntityQuery query;
NativeArray<Vector3> nativeVerticesSource;
float* pVerticesSourceVector3;
List<NativeArray<Vector3>> nativeEntityVerticesList = new List<NativeArray<Vector3>>();
}
with ECS で同じ結果を得られることを確認しました。
上記サンプルコードを実行したときの様子
カクつかない仕組みを作る
まずはカクつかせるようにメッシュを複雑にして entity の数を増やしてみましょう。
上記のコードを次の通り変更します。
publicclass ChunkManager
{
publicconstint ChunkSizeX = 16;
publicconstint ChunkSizeY = 16;
publicconstint ChunkSizeZ = 16;
publicconstfloat CubeSide = 2f;
}
#region チャンク情報の定義
var chunkData = newint[ChunkManager.ChunkSizeX * ChunkManager.ChunkSizeZ * ChunkManager.ChunkSizeY];
for (var x = 0; x < ChunkManager.ChunkSizeX; x++)
{
for (var z = 0; z < ChunkManager.ChunkSizeZ; z++)
{
for (var y = 0; y < ChunkManager.ChunkSizeY; y++)
{
var dataIndex = (x * ChunkManager.ChunkSizeZ * ChunkManager.ChunkSizeY + z * ChunkManager.ChunkSizeY + y);
chunkData[dataIndex] = 1;
}
}
}
this.nativeChunkData = new NativeArray<int>(chunkData, Allocator.Persistent);
#endregion
publicvoid Execute(int entityIndex)
{
var meshData = this.meshDataArray[entityIndex];
for (var x = 0; x < ChunkManager.ChunkSizeX; x++)
{
for (var z = 0; z < ChunkManager.ChunkSizeZ; z++)
{
for (var y = 0; y < ChunkManager.ChunkSizeY; y++)
{
var dataIndex = (x * ChunkManager.ChunkSizeZ * ChunkManager.ChunkSizeY + z * ChunkManager.ChunkSizeY + y);
var data = meshData.pChunkData[dataIndex];
if (1 == data)
{
var verticesOffset = dataIndex * this.verticesSourceCount;
UnsafeUtility.MemCpy(meshData.pVerticesVector3 + verticesOffset * 3, this.pVerticesSourceVector3, size: this.verticesSourceCount * 3 * sizeof(float));
for (int vertexIndex = 0; vertexIndex < this.verticesSourceCount; vertexIndex++)
{
var positionXIndex = (verticesOffset + vertexIndex) * 3;
meshData.pVerticesVector3[positionXIndex + 0] += x * ChunkManager.CubeSide;
meshData.pVerticesVector3[positionXIndex + 1] += y * ChunkManager.CubeSide;
meshData.pVerticesVector3[positionXIndex + 2] += z * ChunkManager.CubeSide;
}
}
}
}
}
}
16x16x16 のチャンクにしてみる
さらに entity を増やします。
コードはこんな変更をします。
privateunsafevoid CreateMeshObject(Vector3 position)
{
#region メッシュオブジェクト Entity の作成
var meshObject = Instantiate(this.prefabMeshObject, position, Quaternion.identity);
var meshEntity = meshObject.GetComponent<GameObjectEntity>();
meshEntity.EntityManager.AddComponent(meshEntity.Entity, ComponentType.ReadOnly<CreateMeshMarker>());
meshEntity.EntityManager.AddComponent(meshEntity.Entity, ComponentType.ReadWrite<ChunkMeshData>());
#endregion #region チャンク情報の設定
meshEntity.EntityManager.SetComponentData<ChunkMeshData>(meshEntity.Entity, new ChunkMeshData
{
pChunkData = (int*)this.nativeChunkData.GetUnsafePtr(),
chunkDataLength = this.nativeChunkData.Length
});
#endregion
var renderer = meshObject.GetComponent<MeshRenderer>();
renderer.material = new Material(this.meshShader);
}
privatevoid Update()
{
if (Input.GetKeyDown(KeyCode.Space))
{
for (var x = 0; x < ChunkManager.ChunkSizeX; x++)
{
for (var z = 0; z < ChunkManager.ChunkSizeZ; z++)
{
for (var y = 0; y < ChunkManager.ChunkSizeY; y++)
{
var position = new Vector3(ChunkManager.ChunkSizeX * x * 2, ChunkManager.ChunkSizeY * y, ChunkManager.ChunkSizeZ * z * 1.732f);
CreateMeshObject(position);
}
}
}
}
}
8x8x8 のチャンクを 8x8x8 個作成した様子
プロファイラを確認すると大変なスパイクが発生していることが確認できました。
スパイク時の Timeline (1132.64ms)
normal と tangent の計算に時間を要しているようです。
normal と tangent をあらかじめ与えてコピーするようにしてみたらどうなるでしょうか？
var credentials = new CognitoAWSCredentials(AmazonCognitoIDs.IdentityPoolId, AmazonCognitoIDs.CognitoPoolRegion);
credentials.AddLogin($"cognito-idp.{AmazonCognitoIDs.CognitoPoolRegion.SystemName}.amazonaws.com/{AmazonCognitoIDs.UserPoolId}", user.SessionTokens.IdToken);
公式ドキュメント作成者にお願いしたいこととして、どこの設定で何と接続されているかを具体的に強調してほしい。。。
つまりは、ここで設定された Cognito_＊_Auth_Role （＊印は ID プール名）という名前の権限設定が認証されたユーザーに与えられることになります！
続いて IAM （"あいあむ"と読む）のサービスにて Cognito_＊_Auth_Role の内容を確認して、S3 の Get, Put の操作を許可する権限を付与しましょう。
現在のままではサインインした後、AmazonS3Client 操作を行っても Status 400 Bad Request が返って来てしまいますので。。
using System;
using System.Collections.Generic;
using UnityEngine;
using Amazon.CognitoIdentityProvider;
using Amazon.CognitoIdentityProvider.Model;
using TMPro;
using UnityEngine.UI;
using UnityEngine.Events;
publicclass AmazonCognitoSignUpGUI : MonoBehaviour
{
#region UI Connection
[SerializeField] InputField inputFieldEmail;
[SerializeField] InputField inputFieldPassword;
[SerializeField] Button buttonSignup;
[SerializeField] TMP_Text textStatus;
#endregioninternal UnityAction onSingUpSuccess;
void Start()
{
this.buttonSignup.onClick.AddListener(this.OnSignup);
}
void OnSignup()
{
var client = new AmazonCognitoIdentityProviderClient(null, AmazonCognitoIDs.CognitoPoolRegion);
var signupRequest = new SignUpRequest
{
ClientId = AmazonCognitoIDs.UserPoolAppClientId,
Username = this.inputFieldEmail.text,
Password = this.inputFieldPassword.text,
UserAttributes = new List<AttributeType> {
new AttributeType {
Name = "email",
Value = this.inputFieldEmail.text
}
}
};
try
{
var result = client.SignUp(signupRequest);
this.textStatus.text = $"We have sent a code by email to {result.CodeDeliveryDetails.Destination}.\r\nEnter it above to confirm your account.";
this.onSingUpSuccess?.Invoke();
}
catch (Exception ex)
{
this.textStatus.text = ex.Message;
}
}
}
using Grpc.Core;
using MagicOnion.Hosting;
using MagicOnion.Server;
using Microsoft.Extensions.Hosting;
using System.Threading.Tasks;
namespace ChatApp.Server
{
class Program
{
static async Task Main(string[] args)
{
GrpcEnvironment.SetLogger(new Grpc.Core.Logging.ConsoleLogger());
await MagicOnionHost.CreateDefaultBuilder()
.UseMagicOnion(
new MagicOnionOptions(isReturnExceptionStackTraceInErrorDetail: true),
new ServerPort("0.0.0.0", 12345, ServerCredentials.Insecure))
.RunConsoleAsync();
}
}
}
