private static void CompletePathSearch(int jobIndex, Entity entityRequest, NavMeshQuery query, EntityCommandBuffer.Concurrent commandBuffer, int pathSize, int maximumPoolSize, NavMeshPathfindingRequestData request, DynamicBuffer <PathBufferElement> agentPathBuffer) { var resultPath = new NativeArray <PolygonId>(pathSize, Allocator.Temp); query.GetPathResult(resultPath); //Extract path from PolygonId list var straightPathCount = 0; var straightPath = ExtractPath(query, request.Start, request.Destination, resultPath, maximumPoolSize, ref straightPathCount); //Put the result path into buffer for (int i = 0; i < straightPathCount; i++) { agentPathBuffer.Add(new PathBufferElement { Value = straightPath[i].position }); } straightPath.Dispose(); resultPath.Dispose(); request.Status = PathSearchStatus.Finished; commandBuffer.SetComponent(jobIndex, entityRequest, request); }
private void PopulateMesh(WorldSpaceRect rect, ElementScale scale, WorldSpaceMask mask, TextRenderer settings, float4 color, ref DynamicBuffer <TextData> textBuffer, ref DynamicBuffer <ControlVertexData> vertices, ref DynamicBuffer <ControlVertexIndex> triangles) { _VerticalAlignmentOptions verticalAlignment = (_VerticalAlignmentOptions)settings.Alignment; _HorizontalAlignmentOptions horizontalAlignment = (_HorizontalAlignmentOptions)settings.Alignment; var font = FontAssetFromEntity[settings.Font]; var glyphData = FontGlyphDataFromEntity[settings.Font]; float2 canvasScale = settings.Size * scale.Value / font.PointSize; float stylePadding = 1.25f + (settings.Bold ? font.BoldStyle / 4.0f : font.NormalStyle / 4.0f); float styleSpaceMultiplier = 1.0f + (settings.Bold ? font.BoldSpace * 0.01f : font.NormalSpace * 0.01f); NativeList <TextUtils.TextLineInfo> lines = new NativeList <TextUtils.TextLineInfo>(Allocator.Temp); TextUtils.CalculateLines(ref rect, canvasScale, styleSpaceMultiplier, ref glyphData, ref textBuffer, lines); float textBlockHeight = lines.Length * font.LineHeight * canvasScale.y; float2 alignedStartPosition = TextUtils.GetAlignedStartPosition(ref rect, ref settings, ref font, textBlockHeight, canvasScale); float2 currentCharacter = alignedStartPosition; int lineIdx = 0; for (int i = 0; i < textBuffer.Length; i++) { if (lineIdx < lines.Length && i == lines[lineIdx].CharacterOffset) { currentCharacter = new float2(TextUtils.GetAlignedLinePosition(ref rect, lines[lineIdx].LineWidth, horizontalAlignment), alignedStartPosition.y - font.LineHeight * canvasScale.y * lineIdx); lineIdx++; } var character = textBuffer[i].Value; if (character == (ushort)'\n') { // It's handled in GetLinesOffsets continue; } if (TextUtils.GetGlyph(character, ref glyphData, out FontGlyphData ch)) { int startIndex = vertices.Length; float2 uv2 = new float2(ch.Scale, ch.Scale) * math.select(canvasScale, -canvasScale, settings.Bold); float2 vMin = currentCharacter + new float2(ch.Metrics.horizontalBearingX - stylePadding, ch.Metrics.horizontalBearingY - ch.Metrics.height - stylePadding) * canvasScale; float2 vMax = vMin + new float2(ch.Metrics.width + stylePadding * 2.0f, ch.Metrics.height + stylePadding * 2.0f) * canvasScale; float4 uv = new float4(ch.Rect.x - stylePadding, ch.Rect.y - stylePadding, (ch.Rect.x + ch.Rect.width + stylePadding), (ch.Rect.y + ch.Rect.height + stylePadding)) / new float4(font.AtlasSize, font.AtlasSize); RectMaskCut cut = SpriteUtility.GetRectangleMaskCut(vMin, vMax, uv.xy, uv.zw, ref mask); var cutSize = cut.Max + cut.Min; if (!(cutSize.x > vMax.x - vMin.x) && !(cutSize.y > vMax.y - vMin.y)) { float4 vertexPos = new float4(vMin + cut.Min, vMax - cut.Max); uv.xy = uv.xy + cut.UvMin; uv.zw = uv.zw - cut.UvMax; triangles.Add(new ControlVertexIndex() { Value = startIndex + 2 }); triangles.Add(new ControlVertexIndex() { Value = startIndex + 1 }); triangles.Add(new ControlVertexIndex() { Value = startIndex }); triangles.Add(new ControlVertexIndex() { Value = startIndex + 3 }); triangles.Add(new ControlVertexIndex() { Value = startIndex + 2 }); triangles.Add(new ControlVertexIndex() { Value = startIndex }); vertices.Add(new ControlVertexData() { Position = new float3(vertexPos.xy, 0.0f), Normal = new float3(0.0f, 0.0f, -1.0f), TexCoord0 = uv.xy, TexCoord1 = uv2, Color = color }); vertices.Add(new ControlVertexData() { Position = new float3(vertexPos.zy, 0.0f), Normal = new float3(0.0f, 0.0f, -1.0f), TexCoord0 = uv.zy, TexCoord1 = uv2, Color = color }); vertices.Add(new ControlVertexData() { Position = new float3(vertexPos.zw, 0.0f), Normal = new float3(0.0f, 0.0f, -1.0f), TexCoord0 = uv.zw, TexCoord1 = uv2, Color = color }); vertices.Add(new ControlVertexData() { Position = new float3(vertexPos.xw, 0.0f), Normal = new float3(0.0f, 0.0f, -1.0f), TexCoord0 = uv.xw, TexCoord1 = uv2, Color = color }); } currentCharacter += (new float2(ch.Metrics.horizontalAdvance * styleSpaceMultiplier, 0.0f) * canvasScale); } } }
private static DynamicBuffer <VoxelBufferElement> GenerateTerrain( DynamicBuffer <VoxelBufferElement> voxelBuffer, in Translation translation
/// <summary> /// set the buffer elements of the given aBuffer /// </summary> /// <param name="ecb"></param> /// <param name="aBuffer"></param> /// <param name="bBuffer"></param> public static void SetBuffer(EntityCommandBuffer.ParallelWriter ecb, ref DynamicBuffer <FloatBufferElement> aBuffer, DynamicBuffer <FloatBufferElement> bBuffer) { aBuffer.Clear(); aBuffer.CopyFrom(bBuffer); }
public void DynamicBuffer_Default_IsCreated_IsFalse() { DynamicBuffer <EcsIntElement> buffer = default; Assert.False(buffer.IsCreated); }
public static void CalculateLines(ref WorldSpaceRect rect, float2 canvasScale, float styleSpaceMultiplier, ref DynamicBuffer <FontGlyphData> glyphData, ref DynamicBuffer <TextData> textBuffer, NativeList <TextLineInfo> ret) { float maxLineWidth = rect.Max.x - rect.Min.x; CurrentLineData currentLine = default; for (int i = 0; i < textBuffer.Length; i++) { var character = textBuffer[i].Value; if (character == '\n') { ret.Add(new TextLineInfo() { CharacterOffset = currentLine.CharacterOffset, LineWidth = currentLine.LineWidth, }); currentLine.CharacterOffset = i + 1; currentLine.LineWidth = 0.0f; currentLine.LineWordIndex = 0; currentLine.WordCharacterCount = 0; currentLine.WordWidth = 0.0f; continue; } if (character == ' ') { currentLine.LineWordIndex++; currentLine.WordCharacterCount = -1; currentLine.WordWidth = 0.0f; } if (GetGlyph(character, ref glyphData, out var ch)) { if (((ch.Metrics.width * styleSpaceMultiplier * canvasScale.x) < rect.Width)) { currentLine.WordCharacterCount++; float characterWidth = ch.Metrics.horizontalAdvance * styleSpaceMultiplier * canvasScale.x; currentLine.LineWidth += characterWidth; currentLine.WordWidth += characterWidth; if (currentLine.LineWidth > maxLineWidth) { if (currentLine.LineWordIndex != 0) { ret.Add(new TextLineInfo() { CharacterOffset = currentLine.CharacterOffset, LineWidth = currentLine.LineWidth - currentLine.WordWidth, }); currentLine.CharacterOffset = i - currentLine.WordCharacterCount + 1; currentLine.LineWidth = 0.0f; currentLine.WordWidth = 0.0f; i = i - currentLine.WordCharacterCount + 1; currentLine.LineWordIndex = 0; currentLine.WordCharacterCount = 0; } else { ret.Add(new TextLineInfo() { CharacterOffset = currentLine.CharacterOffset, LineWidth = currentLine.LineWidth, }); currentLine.CharacterOffset = i; currentLine.LineWidth = 0.0f; currentLine.WordWidth = 0.0f; currentLine.LineWordIndex = 0; currentLine.WordCharacterCount = 0; } } continue; } ret.Add(new TextLineInfo() { CharacterOffset = currentLine.CharacterOffset, LineWidth = currentLine.LineWidth, }); currentLine.CharacterOffset = i; currentLine.LineWidth = 0.0f; currentLine.WordWidth = 0.0f; currentLine.LineWordIndex = 0; currentLine.WordCharacterCount = 0; } } ret.Add(new TextLineInfo() { CharacterOffset = currentLine.CharacterOffset, LineWidth = currentLine.LineWidth }); }
public void Serialization(DynamicBuffer oBuffer) { oBuffer.WriteUTF8(Content); }
public static ref TSnapshot GetLastBaseline <TSnapshot>(this DynamicBuffer <TSnapshot> snapshotBuffer) where TSnapshot : struct, ISnapshotData <TSnapshot> { if (snapshotBuffer.Length == 0) { snapshotBuffer.Add(default); // needed or else we will read out of range on first execution
protected override void OnUpdate() { // Acquire an ECB and convert it to a concurrent one to be able // to use it from a parallel job. var ecb = ecbSystem.CreateCommandBuffer(); BufferFromEntity <TileMapBufferElement> lookup = GetBufferFromEntity <TileMapBufferElement>(); Entities.WithAny <TileMapGeneration.T_MeshGen>().ForEach( (Entity entity, int entityInQueryIndex, in MapGenRequirement mapGenReq) => { DynamicBuffer <TileMapBufferElement> tileMapBuffers = lookup[entity]; if (tileMapBuffers.Length > 0) { MapMeshGenerator mapMeshGenerator = GetMapMeshGenerator(in mapGenReq, in tileMapBuffers, TileType.wall); RenderMesh tileMapRenderMesh = mapMeshGenerator.generateRenderMesh( Resources.Load("testMaterial", typeof(UnityEngine.Material)) as UnityEngine.Material, mapMeshGenerator.createTileMesh()); //TODO: Make it read the materail from a material registry instead var meshCoillider = MapGenPhysics.createMeshCollider(mapMeshGenerator.vertices.ToArray(), mapMeshGenerator.triangles.ToArray()); var tileMeshEntity = ecb.CreateEntity(); ecb.AddComponent(tileMeshEntity, new PhysicsCollider { Value = meshCoillider }); /* ecb.AddComponent(tileMeshEntity, new Parent {Value=entity}); */ ecb.AddComponent(tileMeshEntity, new LocalToWorld { }); ecb.AddSharedComponent(tileMeshEntity, tileMapRenderMesh); ecb.AddComponent(tileMeshEntity, new RenderBounds { Value = new AABB { Center = 0, Extents = 10000000 //for testing purpose } }); ecb.AddComponent(tileMeshEntity, new Translation { }); RenderMesh wallRenderMesh = mapMeshGenerator.generateRenderMesh( Resources.Load("testMaterial", typeof(UnityEngine.Material)) as UnityEngine.Material, mapMeshGenerator.CreateWallMesh(5)); //TODO: Make it read the materail from a material registry instead var wallMeshCoillider = MapGenPhysics.createMeshCollider(mapMeshGenerator.wallVertices.ToArray(), mapMeshGenerator.wallTriangles.ToArray()); var wallMeshEntity = ecb.CreateEntity(); ecb.AddComponent(wallMeshEntity, new PhysicsCollider { Value = wallMeshCoillider }); /* ecb.AddComponent(tileMeshEntity, new Parent {Value=entity}); */ ecb.AddComponent(wallMeshEntity, new LocalToWorld { }); ecb.AddSharedComponent(wallMeshEntity, wallRenderMesh); ecb.AddComponent(wallMeshEntity, new RenderBounds { Value = new AABB { Center = 0, Extents = 10000000 //for testing purpose } }); ecb.AddComponent(wallMeshEntity, new Translation { }); //----------------------------------------------------------------- /* MapMeshGenerator floorMeshGenerator = GetMapMeshGenerator(in mapGenReq, in tileMapBuffers, TileType.floor); * RenderMesh floorRenderMesh = floorMeshGenerator.generateRenderMesh( * Resources.Load("testMaterial", typeof(UnityEngine.Material)) as UnityEngine.Material, * floorMeshGenerator.createTileMesh()); * //TODO: Make it read the materail from a material registry instead * * var floorMeshCoillider = MapGenPhysics.createMeshCollider(floorMeshGenerator.vertices.ToArray(), floorMeshGenerator.triangles.ToArray()); * * var floorMeshEntity = ecb.CreateEntity(); * ecb.AddComponent(floorMeshEntity, new PhysicsCollider { Value = floorMeshCoillider }); *//* ecb.AddComponent(tileMeshEntity, new Parent {Value=entity}); *//* * ecb.AddComponent(floorMeshEntity, new LocalToWorld { }); * ecb.AddSharedComponent(floorMeshEntity, floorRenderMesh); * ecb.AddComponent(floorMeshEntity, new RenderBounds * { * Value = * new AABB * { * Center = 0, * Extents = 10000000//for testing purpose * } * }); * ecb.AddComponent(floorMeshEntity, new Translation { }); * */ ecb.RemoveComponent <TileMapGeneration.T_MeshGen>(entity); //mesh Generation finished ecb.AddComponent <TileMapGeneration.T_SpawnFlagGen>(entity); //Request starting spawn flag generation } } ).WithoutBurst().Run();//TODO : make it parrallel one day ecbSystem.AddJobHandleForProducer(this.Dependency); }
/// <summary> /// Adds a native version of <see cref="List{T}.AddRange(IEnumerable{T})"/>. /// </summary> /// <typeparam name="T">The type.</typeparam> /// <param name="list">The <see cref="List{T}"/> to add to.</param> /// <param name="dynamicBuffer">The dynamic buffer to add to the list.</param> public static unsafe void AddRange <T>(this List <T> list, DynamicBuffer <T> dynamicBuffer) where T : struct { list.AddRange(dynamicBuffer.GetUnsafePtr(), dynamicBuffer.Length); }
public void RetrieveSkinnedMeshData(Mesh uMesh, Entity meshEntity, EntityManager entityManager, bool isLit) { //There's no need to generate special vertex data for gpu skinning if (uMesh.bindposes.Length <= MeshSkinningConfig.GPU_SKINNING_MAX_BONES) { if (isLit) { RetrieveLitMeshData(uMesh); } else { RetrieveSimpleMeshData(uMesh); } return; } List <int> duplicateVertexIndex = new List <int>(); List <Vector4> duplicateBoneIndex = new List <Vector4>(); Dictionary <int, Vector4> existingVertex2NewBoneIndex = new Dictionary <int, Vector4>(); Dictionary <int, int> boneIndexCounter = new Dictionary <int, int>(); List <Vector2> gpuDrawRange = new List <Vector2>(); BoneWeight[] boneWeights = uMesh.boneWeights; int[] triangles = uMesh.triangles; //Separate mesh into different draw range for gpu skinning use for (int subMeshIndex = 0; subMeshIndex < uMesh.subMeshCount; subMeshIndex++) { UnityEngine.Rendering.SubMeshDescriptor uSubMeshDescriptor = uMesh.GetSubMesh(subMeshIndex); int curIndex = uSubMeshDescriptor.indexStart; int lastIndex = uSubMeshDescriptor.indexStart; int endIndex = curIndex + uSubMeshDescriptor.indexCount; while (curIndex < endIndex) { int curBoneCount = boneIndexCounter.Count; for (int offset = 0; offset < 3; offset++) { int vertexIndex = triangles[curIndex + offset]; BoneWeight boneWeight = boneWeights[vertexIndex]; curBoneCount += CalcToBeAddBoneIndexCount(boneIndexCounter, boneWeight); } if (curBoneCount > MeshSkinningConfig.GPU_SKINNING_MAX_BONES) { gpuDrawRange.Add(new Vector2(curIndex, subMeshIndex)); Debug.Log("GPU SkinnedMesh Draw Range[" + lastIndex + ":" + curIndex + "] BoneCount:" + boneIndexCounter.Count); lastIndex = curIndex; boneIndexCounter.Clear(); } else { for (int offset = 0; offset < 3; offset++) { int vertexIndex = triangles[curIndex + offset]; BoneWeight curBoneWeight = boneWeights[vertexIndex]; //restore the new bone index and set it to the mesh later Vector4 newBoneIndex = new Vector4(); newBoneIndex.x = GetNewBoneIndex(boneIndexCounter, curBoneWeight.weight0, curBoneWeight.boneIndex0); newBoneIndex.y = GetNewBoneIndex(boneIndexCounter, curBoneWeight.weight1, curBoneWeight.boneIndex1); newBoneIndex.z = GetNewBoneIndex(boneIndexCounter, curBoneWeight.weight2, curBoneWeight.boneIndex2); newBoneIndex.w = GetNewBoneIndex(boneIndexCounter, curBoneWeight.weight3, curBoneWeight.boneIndex3); Vector4 existingNewBoneIndex = new Vector4(); bool isExist = existingVertex2NewBoneIndex.TryGetValue(vertexIndex, out existingNewBoneIndex); if (isExist && newBoneIndex != existingNewBoneIndex) { bool needAdd = true; int newVertexIndex = 0; for (int j = 0; j < duplicateVertexIndex.Count; j++) { if (duplicateVertexIndex[j] == vertexIndex && duplicateBoneIndex[j] == newBoneIndex) { newVertexIndex = uMesh.vertexCount + j; triangles[curIndex + offset] = newVertexIndex; needAdd = false; break; } } if (needAdd) { duplicateVertexIndex.Add(vertexIndex); duplicateBoneIndex.Add(newBoneIndex); newVertexIndex = uMesh.vertexCount + duplicateVertexIndex.Count - 1; triangles[curIndex + offset] = newVertexIndex; existingVertex2NewBoneIndex[newVertexIndex] = newBoneIndex; } } else { existingVertex2NewBoneIndex[vertexIndex] = newBoneIndex; } } curIndex += 3; } } if (lastIndex != curIndex) { gpuDrawRange.Add(new Vector2(curIndex, subMeshIndex)); Debug.Log("GPU SkinnedMesh Draw Range[" + lastIndex + ":" + curIndex + "] BoneCount:" + boneIndexCounter.Count); } } Debug.Log("GPU SkinnedMesh Duplicate VertexCount:" + duplicateVertexIndex.Count); Debug.Log("GPU SkinnedMesh DrawCalls: " + gpuDrawRange.Count); //generate UMeshDataCache and adding duplicate vertices into UMeshDataCache int newVertexCount = uMesh.vertexCount + duplicateVertexIndex.Count; if (isLit) { RetrieveLitMeshData(uMesh, newVertexCount); } else { RetrieveSimpleMeshData(uMesh, newVertexCount); } for (int i = 0; i < duplicateVertexIndex.Count; i++) { int curVertexIndex = uMesh.vertexCount + i; int originalVertexIndex = duplicateVertexIndex[i]; uPositions[curVertexIndex] = uPositions[originalVertexIndex]; uUVs[curVertexIndex] = uUVs[originalVertexIndex]; uBoneWeights[curVertexIndex] = uBoneWeights[originalVertexIndex]; uBoneIndices[curVertexIndex] = uBoneIndices[originalVertexIndex]; if (!isLit) { continue; } uNormals[curVertexIndex] = uNormals[originalVertexIndex]; uTangents[curVertexIndex] = uTangents[originalVertexIndex]; uBiTangents[curVertexIndex] = uBiTangents[originalVertexIndex]; uColors[curVertexIndex] = uColors[originalVertexIndex]; } //Update the indices, some of the triangles reference to the duplicate vertex for (int i = 0; i < triangles.Length; i++) { uIndices[i] = Convert.ToUInt16(triangles[i]); } //Restore the original vertex bone index for switching GPU skinning to CPU skinning in the runtime DynamicBuffer <OriginalVertexBoneIndex> obiBuffer = entityManager.AddBuffer <OriginalVertexBoneIndex>(meshEntity); for (int i = 0; i < newVertexCount; i++) { Vector4 uBoneIndex = uBoneIndices[i]; obiBuffer.Add(new OriginalVertexBoneIndex { BoneIndex = new float4(uBoneIndex.x, uBoneIndex.y, uBoneIndex.z, uBoneIndex.w) }); Vector4 newBoneIndex = existingVertex2NewBoneIndex[i]; uBoneIndices[i] = newBoneIndex; } //Add GPUSkinnedMeshDrawRange for SkinnedMeshRendererConversion use. DynamicBuffer <GPUSkinnedMeshDrawRange> gsmdrBuffer = entityManager.AddBuffer <GPUSkinnedMeshDrawRange>(meshEntity); for (int i = 0; i < gpuDrawRange.Count; i++) { gsmdrBuffer.Add(new GPUSkinnedMeshDrawRange { TriangleIndex = (int)gpuDrawRange[i].x, SubMeshIndex = (int)gpuDrawRange[i].y, }); } }
public void OnlyTriggerEffectOfActiveSkill([Values(AbilityState.CooledDown, AbilityState.CoolingDown, AbilityState.Casting)] AbilityState state) { // Arrange Entity caster = _entityManager.CreateEntity(); _entityManager.AddComponentData(caster, new Target() { Value = Entity.Null }); _entityManager.AddComponentData(caster, new TestResource() { Value = 20 }); Ability ability = new Ability(1, 1, new Range()) { State = AbilityState.Active }; DynamicBuffer <AbilityBuffer> abilityBuffer = _entityManager.AddBuffer <AbilityBuffer>(caster); abilityBuffer.Add(new AbilityBuffer() { Ability = ability }); abilityBuffer.Add(new AbilityBuffer() { Ability = new Ability(1, 1, new Range()) { State = state } }); DynamicBuffer <TestEffectBuffer> testEffectBuffer = _entityManager.AddBuffer <TestEffectBuffer>(caster); testEffectBuffer.Add(new TestEffectBuffer() { AbilityIndex = 0, Effect = new TestEffect() { Affects = EffectAffectType.Target, Value = 1 } }); testEffectBuffer.Add(new TestEffectBuffer() { AbilityIndex = 1, Effect = new TestEffect() { Affects = EffectAffectType.Target, Value = 1 } }); _world.WithSystem <TestEffectTriggerSystem>(); //Act _world.UpdateSystem <TestEffectTriggerSystem>(); _world.CompleteAllJobs(); //Assert TestEffectConsumerSystem conusmerSystem = _world.GetReference().GetExistingSystem <TestEffectConsumerSystem>(); NativeStream.Reader reader = conusmerSystem.GetEffectReader(); Assert.AreEqual(1, conusmerSystem.GetEffectReader().ComputeItemCount()); reader.BeginForEachIndex(0); TestEffectContext ctx = reader.Read <TestEffectContext>(); Assert.AreEqual(Entity.Null, ctx.Target); Assert.AreEqual(EffectAffectType.Target, ctx.Effect.Affects); Assert.AreEqual(1, ctx.Effect.Value); Assert.AreEqual(20, ctx.testResourceValue); reader.EndForEachIndex(); }
protected int UpdateOneDisplayListCamera(Entity e, ref Camera2D cam, ref DisplayListCamera dlcCam, ref LocalToWorld tx, float primaryAspect) { var mgr = EntityManager; // get list and sorted list buffers DynamicBuffer <DisplayListEntry> dest = mgr.GetBuffer <DisplayListEntry>(e); DynamicBuffer <SortedEntity> destSorted = mgr.GetBuffer <SortedEntity>(e); dest.Clear(); destSorted.Clear(); #if DEBUG if (!(cam.rect.x >= 0.0f && cam.rect.y >= 0.0f && cam.rect.x + cam.rect.width <= 1.0f && cam.rect.y + cam.rect.height <= 1.0f)) { Debug.LogFormat("The camera {0} has an invalid rect field ({1},{2},{3},{4}). Fixing by clamping it to the unit rectangle (0,0,1,1) in DEVELOPMENT build only.", e, cam.rect.x, cam.rect.y, cam.rect.width, cam.rect.height); cam.rect.Clamp(new Rect(0, 0, 1, 1)); } if (cam.rect.IsEmpty()) { Debug.LogFormat("The camera {0} has an empty rect field. Fixing by setting it to identity in DEVELOPMENT build only.", e); cam.rect = new Rect(0, 0, 1, 1); } if (cam.halfVerticalSize <= 0) { Debug.LogFormat("The camera {0} has an invalid halfVerticalSize size of {1}. Nothing will render for it.", e, cam.halfVerticalSize); return(0); } float mas = MaxAbsScale(tx.Value); if (!(mas > .99f && mas < 1.01f)) { Debug.LogFormat("The entity {0} with a Camera2D has a maximum absolute scaling factor of {1}. Cameras can not be scaled for rendering. Rendering and picking with this camera will likely be wrong.", e, mas); } #endif // get camera sorting axis if (mgr.HasComponent <Camera2DAxisSort>(e)) { var axissort = mgr.GetComponentData <Camera2DAxisSort>(e); dlcCam.sortingDot.xyz = -axissort.axis; dlcCam.sortingDot.w = 0; } else { dlcCam.sortingDot.x = 0.0f; dlcCam.sortingDot.y = 0.0f; dlcCam.sortingDot.z = -1.0f; dlcCam.sortingDot.w = 0.0f; } // copy transform matrix dlcCam.world = tx.Value; dlcCam.inverseWorld = math.inverse(dlcCam.world); // initialize 2d clipping if (mgr.HasComponent <Camera2DRenderToTexture>(e)) { var rtt = mgr.GetComponentData <Camera2DRenderToTexture>(e); float localAspect = (float)rtt.width / (float)rtt.height; dlcCam.clip2D.x = cam.halfVerticalSize * localAspect; dlcCam.clip2D.y = cam.halfVerticalSize; } else { dlcCam.clip2D.x = cam.halfVerticalSize * primaryAspect; dlcCam.clip2D.y = cam.halfVerticalSize; } // initialize near/far clipping if (mgr.HasComponent <Camera2DClippingPlanes>(e)) { var clipz = mgr.GetComponentData <Camera2DClippingPlanes>(e); dlcCam.clipZNear = clipz.near; dlcCam.clipZFar = clipz.far; } else { dlcCam.clipZNear = float.MinValue; dlcCam.clipZFar = float.MaxValue; } #if DEBUG if (dlcCam.clipZNear >= dlcCam.clipZFar) { Debug.LogFormat("The camera {0} has an invalid z clip range [{1}...{2}]. Nothing will render for it.", e, dlcCam.clipZNear, dlcCam.clipZFar); return(0); } #endif // add all items for (int i = 0; i < dlMakerReg.Count; i++) { AddItemsToListByType(dlMakerReg[i], dlcCam, cam, dest, destSorted); } // sort in c++ unsafe { SortExternal(dest.GetUnsafePtr(), destSorted.GetUnsafePtr(), dest.Length); } return(dest.Length); }
protected override void OnUpdate() { var detectors = _entityQuery.ToComponentDataArray <DetectorComponent>(Allocator.TempJob); var entities = _entityQuery.ToEntityArray(Allocator.TempJob); for (var i = 0; i < detectors.Length; i++) { var detector = detectors[i]; var triggersSet = new NativeHashMap <int, bool>(MaxColliders, Allocator.Temp); DynamicBuffer <ColliderId> buffer = EntityManager.GetBuffer <ColliderId>(entities[i]); for (var index = 0; index < buffer.Length; index++) { ColliderId colliderId = buffer[index]; _triggersCache[index] = colliderId.Value; triggersSet.Add(colliderId.Value, false); } if (_detectorTriggers.TryGetValue(entities[i], out HashSet <int> triggerIds)) { int removeOldTriggersCount = 0; var removeOldTriggers = new NativeArray <int>(MaxColliders, Allocator.Temp); foreach (var id in triggerIds) { // in new triggers there is no old if (!triggersSet.ContainsKey(id)) { removeOldTriggers[removeOldTriggersCount++] = id; #if UNITY_EDITOR Debug.Log("Trigger exit::" + id); #endif TryRemoveComponentsFromTriggers(EntityManager, entities[i], id); } } for (var k = 0; k < removeOldTriggersCount; k++) { triggerIds.Remove(removeOldTriggers[k]); } for (int j = 0; j < detector.TriggersCount; j++) { var triggerId = _triggersCache[j]; if (!triggerIds.Contains(triggerId)) { triggerIds.Add(triggerId); #if UNITY_EDITOR Debug.Log("Trigger enter::" + triggerId); #endif TryAddComponentsFromTriggers(EntityManager, entities[i]); } } removeOldTriggers.Dispose(); } else { for (int j = 0; j < detector.TriggersCount; j++) { var triggerId = _triggersCache[j]; _detectorTriggers.Add(entities[i], new HashSet <int> { triggerId }); #if UNITY_EDITOR Debug.Log("Trigger enter::" + triggerId); #endif TryAddComponentsFromTriggers(EntityManager, entities[i]); } } triggersSet.Dispose(); detectors[i] = detector; } _entityQuery.CopyFromComponentDataArray(detectors); detectors.Dispose(); entities.Dispose(); }
/// <summary> /// /// </summary> /// <param name="a_collisionChecksEntities"></param> /// <param name="a_rayData"></param> /// <param name="a_rayMaxDistanceData"></param> /// <param name="a_isCollidingData"></param> /// <param name="collisionInstancesBufferElement"></param> /// <param name="canDebugAllChecks">Debug Log all checks, or only one (first one)</param> /// <param name="canDebugAllrays">Draw all, or only single ray (first one).</param> static public void _DebugRays(EntityCommandBuffer ecb, EntityArray a_collisionChecksEntities, ComponentDataFromEntity <RayData> a_rayData, ComponentDataFromEntity <RayMaxDistanceData> a_rayMaxDistanceData, ComponentDataFromEntity <IsCollidingData> a_isCollidingData, BufferFromEntity <CollisionInstancesBufferElement> collisionInstancesBufferElement, ComponentDataFromEntity <RayEntityPair4CollisionData> a_rayEntityPair4CollisionData, bool canDebugAllChecks, bool canDebugAllrays) { // Debug // ! Ensure test this only with single, or at most few ray entiities. // if ( !canDebugAllrays ) // Debug all, or only one check int i_debugCollisionChecksCount = canDebugAllChecks ? a_collisionChecksEntities.Length : 1; for (int i_collisionChecksIndex = 0; i_collisionChecksIndex < i_debugCollisionChecksCount; i_collisionChecksIndex++) { Entity octreeRayEntity = a_collisionChecksEntities [i_collisionChecksIndex]; Entity octreeRayEntity2; if (!a_rayData.Exists(octreeRayEntity)) { RayEntityPair4CollisionData rayEntityPair4CollisionData = a_rayEntityPair4CollisionData [octreeRayEntity]; octreeRayEntity2 = rayEntityPair4CollisionData.ray2CheckEntity; } else { octreeRayEntity2 = octreeRayEntity; } // Draw all available rays, or signle ray if (canDebugAllrays) { RayData rayData = a_rayData [octreeRayEntity2]; RayMaxDistanceData rayMaxDistanceData = a_rayMaxDistanceData [octreeRayEntity2]; Debug.DrawLine(rayData.ray.origin, rayData.ray.origin + rayData.ray.direction * rayMaxDistanceData.f, Color.red); } else if (i_collisionChecksIndex == 0) { RayData rayData = a_rayData [octreeRayEntity2]; RayMaxDistanceData rayMaxDistanceData = a_rayMaxDistanceData [octreeRayEntity2]; Debug.DrawLine(rayData.ray.origin, rayData.ray.origin + rayData.ray.direction * rayMaxDistanceData.f, Color.red); } //} // Last known instances collisions count. IsCollidingData isCollidingData = a_isCollidingData [octreeRayEntity]; if (isCollidingData.i_collisionsCount > 0) { // Debug.Log ( "Octree: Last known instances collisions count #" + isCollidingData.i_collisionsCount ) ; // Stores reference to detected colliding instance. DynamicBuffer <CollisionInstancesBufferElement> a_collisionInstancesBuffer = collisionInstancesBufferElement [octreeRayEntity]; string s_collidingIDs = ""; CollisionInstancesBufferElement collisionInstancesBuffer; for (int i = 0; i < isCollidingData.i_collisionsCount; i++) { collisionInstancesBuffer = a_collisionInstancesBuffer [i]; s_collidingIDs += collisionInstancesBuffer.i_ID + ", "; } CollisionInstancesBufferElement closestCollisionInstance = a_collisionInstancesBuffer [isCollidingData.i_nearestInstanceCollisionIndex]; Entity closestInstanceEntity = new Entity() { Index = closestCollisionInstance.i_ID, Version = closestCollisionInstance.i_version }; // Test highlight Highlight.SwitchMethods._Switch(ecb, closestInstanceEntity); Debug.Log("Is colliding with #" + isCollidingData.i_collisionsCount + " instances of IDs: " + s_collidingIDs + "; Nearest collided instance is at " + isCollidingData.f_nearestDistance + "m, with ID #" + a_collisionInstancesBuffer [isCollidingData.i_nearestInstanceCollisionIndex].i_ID); } } // for }
internal static void InitEmitterConeSource(EntityManager mgr, Entity emitter, DynamicBuffer <Particle> particles, int offset, Range speed, float randomizePos, float randomizeDir, float4x4 matrix, ref Random rand) { var source = mgr.GetComponentData <EmitterConeSource>(emitter); source.Angle = math.clamp(source.Angle, 0.0f, 90.0f); float coneAngle = math.radians(source.Angle); for (var i = offset; i < particles.Length; i++) { var particle = particles[i]; float angle = rand.Random01() * 2.0f * math.PI; float radiusNormalized = math.sqrt(rand.Random01()); float3 localPositionOnConeBase; localPositionOnConeBase.x = math.cos(angle); localPositionOnConeBase.y = math.sin(angle); localPositionOnConeBase.z = 0.0f; localPositionOnConeBase *= radiusNormalized; particle.position = GetParticlePosition(localPositionOnConeBase * source.Radius, randomizePos, matrix, ref rand); float directionRadius = math.sin(coneAngle); float directionHeight = math.cos(coneAngle); float3 direction = new float3(localPositionOnConeBase.x * directionRadius, localPositionOnConeBase.y * directionRadius, directionHeight); particle.velocity = GetParticleVelocity(ref direction, speed, randomizeDir, matrix, ref rand); particle.rotation = GetParticleRotation(mgr, emitter, direction, ref rand); particles[i] = particle; } }
public static void Collide(ref BallData ball, ref NativeQueue <EventData> .ParallelWriter events, ref CollisionEventData collEvent, ref DynamicBuffer <BallInsideOfBufferElement> insideOfs, ref TriggerAnimationData animationData, in Collider coll)
internal static void InitEmitterSphereSource(EntityManager mgr, Entity emitter, DynamicBuffer <Particle> particles, int offset, float radius, bool hemisphere, Range speed, float randomizePos, float randomizeDir, float4x4 matrix, ref Random rand) { for (var i = offset; i < particles.Length; i++) { var particle = particles[i]; float3 positionOnUnitSphere = rand.NextFloat3Direction(); // For sphere, z ranges from [-1, 1]. For hemisphere, z ranges from [0, 1]. if (hemisphere) { positionOnUnitSphere.z = math.abs(positionOnUnitSphere.z); } // Create more points toward the outer part of the sphere float3 position = positionOnUnitSphere * math.pow(rand.Random01(), 1.0f / 3.0f) * radius; particle.position = GetParticlePosition(position, randomizePos, matrix, ref rand); particle.velocity = GetParticleVelocity(ref positionOnUnitSphere, speed, randomizeDir, matrix, ref rand); particle.rotation = GetParticleRotation(mgr, emitter, positionOnUnitSphere, ref rand); particles[i] = particle; } }
public void Deserialization(DynamicBuffer oBuffer) { Content = oBuffer.ReadUTF8(); }
internal static void InitEmitterRectangleSource(EntityManager mgr, Entity emitter, DynamicBuffer <Particle> particles, int offset, Range speed, float randomizePos, float randomizeDir, float4x4 matrix, ref Random rand) { // Unit rectangle centered at the origin float2 bottomLeft = new float2(-0.5f, -0.5f); float2 topRight = new float2(0.5f, 0.5f); float3 direction = new float3(0, 0, 1); for (var i = offset; i < particles.Length; i++) { var particle = particles[i]; var position = new float3(rand.NextFloat2(bottomLeft, topRight), 0.0f); particle.position = GetParticlePosition(position, randomizePos, matrix, ref rand); particle.velocity = GetParticleVelocity(ref direction, speed, randomizeDir, matrix, ref rand); particle.rotation = GetParticleRotation(mgr, emitter, direction, ref rand); particles[i] = particle; } }
Mesh MakeMesh(DynamicBuffer <MeshVert> vertices, DynamicBuffer <MeshTri> triangles, DynamicBuffer <MeshUv> uvs) { // Convert vertices and uvs Vector3[] verticesArray = new Vector3[vertices.Length]; int[] trianglesArray = new int[triangles.Length]; Vector2[] uvsArray = new Vector2[uvs.Length]; for (int i = 0; i < vertices.Length; i++) { verticesArray[i] = vertices[i].vertex; uvsArray[i] = uvs[i].uv; } for (int i = 0; i < triangles.Length; i++) { trianglesArray[i] = triangles[i].triangle; } Mesh mesh = new Mesh(); mesh.vertices = verticesArray; mesh.uv = uvsArray; mesh.SetTriangles(trianglesArray, 0); mesh.RecalculateNormals(); return(mesh); }
internal static void InitEmitterCircleSource(EntityManager mgr, Entity emitter, DynamicBuffer <Particle> particles, int offset, Range speed, float randomizePos, float randomizeDir, float4x4 matrix, ref Random rand) { var radius = mgr.GetComponentData <EmitterCircleSource>(emitter).Radius; for (var i = offset; i < particles.Length; i++) { var particle = particles[i]; float randomAngle = rand.NextFloat((float)-math.PI, (float)math.PI); float radiusNormalized = math.sqrt(rand.Random01()); radius *= radiusNormalized; var positionNormalized = new float3(math.sin(randomAngle), math.cos(randomAngle), 0.0f); particle.position = GetParticlePosition(positionNormalized * radius, randomizePos, matrix, ref rand); particle.velocity = GetParticleVelocity(ref positionNormalized, speed, randomizeDir, matrix, ref rand); particle.rotation = GetParticleRotation(mgr, emitter, positionNormalized, ref rand); particles[i] = particle; } }
public void CreateAllPasses(int w, int h, Entity eCam, Entity eNode) { Camera cam = EntityManager.GetComponentData <Camera>(eCam); CameraMask cameraMask = new CameraMask { mask = ulong.MaxValue }; if (EntityManager.HasComponent <CameraMask>(eCam)) { cameraMask = EntityManager.GetComponentData <CameraMask>(eCam); } Entity ePassOpaque = EntityManager.CreateEntity(); EntityManager.AddComponentData(ePassOpaque, new RenderPass { inNode = eNode, sorting = RenderPassSort.Unsorted, projectionTransform = float4x4.identity, viewTransform = float4x4.identity, passType = RenderPassType.Opaque, viewId = 0xffff, scissor = new RenderPassRect(), viewport = new RenderPassRect { x = 0, y = 0, w = (ushort)w, h = (ushort)h }, clearFlags = RenderPassClear.Depth | (cam.clearFlags == CameraClearFlags.SolidColor ? RenderPassClear.Color : 0), clearRGBA = RendererBGFXSystem.PackColorBGFX(cam.backgroundColor), clearDepth = 1.0f, clearStencil = 0 }); SetPassComponents(ePassOpaque, cameraMask, eCam); Entity ePassTransparent = EntityManager.CreateEntity(); EntityManager.AddComponentData(ePassTransparent, new RenderPass { inNode = eNode, sorting = RenderPassSort.SortZLess, projectionTransform = float4x4.identity, viewTransform = float4x4.identity, passType = RenderPassType.Transparent, viewId = 0xffff, scissor = new RenderPassRect(), viewport = new RenderPassRect { x = 0, y = 0, w = (ushort)w, h = (ushort)h }, clearFlags = 0, clearRGBA = 0, clearDepth = 1.0f, clearStencil = 0 }); SetPassComponents(ePassTransparent, cameraMask, eCam); Entity ePassSprites = EntityManager.CreateEntity(); EntityManager.AddComponentData(ePassSprites, new RenderPass { inNode = eNode, sorting = RenderPassSort.Sorted, projectionTransform = float4x4.identity, viewTransform = float4x4.identity, passType = RenderPassType.Sprites, viewId = 0xffff, scissor = new RenderPassRect(), viewport = new RenderPassRect { x = 0, y = 0, w = (ushort)w, h = (ushort)h }, clearFlags = 0, clearRGBA = 0, clearDepth = 1.0f, clearStencil = 0 }); SetPassComponents(ePassSprites, cameraMask, eCam); EntityManager.AddBuffer <SortSpritesEntry>(ePassSprites); Entity ePassUI = EntityManager.CreateEntity(); EntityManager.AddComponentData(ePassUI, new RenderPass { inNode = eNode, sorting = RenderPassSort.Sorted, projectionTransform = float4x4.identity, viewTransform = float4x4.identity, passType = RenderPassType.UI, viewId = 0xffff, scissor = new RenderPassRect(), viewport = new RenderPassRect { x = 0, y = 0, w = (ushort)w, h = (ushort)h }, clearFlags = 0, clearRGBA = 0, clearDepth = 1.0f, clearStencil = 0 }); SetPassComponents(ePassUI, cameraMask, eCam); // add passes to node, in order DynamicBuffer <RenderPassRef> passRefs = EntityManager.GetBuffer <RenderPassRef>(eNode); passRefs.Add(new RenderPassRef { e = ePassOpaque }); passRefs.Add(new RenderPassRef { e = ePassTransparent }); passRefs.Add(new RenderPassRef { e = ePassSprites }); passRefs.Add(new RenderPassRef { e = ePassUI }); }
private void Start() { Vector3 topLeftScreen = Camera.main.ScreenToWorldPoint(new Vector3(0, Screen.height, Camera.main.transform.position.y)); Vector3 gridExtents = Camera.main.ScreenToWorldPoint(new Vector3(Screen.width, 0, Camera.main.transform.position.y)); Vector2 cellSize = new Vector2((gridExtents.x - topLeftScreen.x) / (cellsMultiplier - 2), (topLeftScreen.z - gridExtents.z) / (cellsMultiplier - 2)); float2 gridPosition = new float2 { x = topLeftScreen.x - cellSize.x, y = topLeftScreen.z + cellSize.y }; // Cursor.lockState = CursorLockMode.Locked; EntityManager entityManager = World.Active.EntityManager; // Cell EntityArchetype entityArcheType = entityManager.CreateArchetype( typeof(CellBounds), typeof(Units), typeof(NeighboringCells) ); int totalCells = cellsMultiplier * cellsMultiplier; // Array of all the cells in the grid NativeArray <Entity> cells = new NativeArray <Entity>(totalCells, Allocator.Temp); entityManager.CreateEntity(entityArcheType, cells); for (int i = 0; i < cells.Length; i++) { Entity cell = cells[i]; // Calculate the bounds of the current cell CellBounds cellBounds = new CellBounds { minX = gridPosition.x + (cellSize.x * (i % cellsMultiplier)), maxX = gridPosition.x + (cellSize.x * (i % cellsMultiplier)) + cellSize.x, minZ = gridPosition.y - (cellSize.y * (math.floor(i / cellsMultiplier))), maxZ = gridPosition.y - (cellSize.y * (math.floor(i / cellsMultiplier))) - cellSize.y }; entityManager.SetComponentData(cell, cellBounds); entityManager.AddBuffer <Units>(cell); entityManager.AddBuffer <NeighboringCells>(cell); Debug.DrawLine(new Vector3(cellBounds.minX, 0, cellBounds.minZ), new Vector3(cellBounds.maxX, 0, cellBounds.minZ), Color.red, Mathf.Infinity); Debug.DrawLine(new Vector3(cellBounds.maxX, 0, cellBounds.minZ), new Vector3(cellBounds.maxX, 0, cellBounds.maxZ), Color.red, Mathf.Infinity); Debug.DrawLine(new Vector3(cellBounds.minX, 0, cellBounds.maxZ), new Vector3(cellBounds.maxX, 0, cellBounds.maxZ), Color.red, Mathf.Infinity); Debug.DrawLine(new Vector3(cellBounds.minX, 0, cellBounds.minZ), new Vector3(cellBounds.minX, 0, cellBounds.maxZ), Color.red, Mathf.Infinity); } // Create an array of the cell bounds. This is so we can calculate the neighboring cells to each cell EntityQuery entityQuery = entityManager.CreateEntityQuery(ComponentType.ReadOnly <CellBounds>()); NativeArray <CellBounds> cellBoundsArray = entityQuery.ToComponentDataArray <CellBounds>(Allocator.TempJob); // Loop through all the cells to assign their neighboring cells for (int i = 0; i < cells.Length; i++) { // Extract the neighboring cells buffer from the current cell Entity cell = cells[i]; DynamicBuffer <NeighboringCells> neighboringCellsBuffer = entityManager.GetBuffer <NeighboringCells>(cell); int cellIndex = i - (cellsMultiplier + 1); // Upper left neighbor if (cellIndex > -1 && cellBoundsArray[cellIndex].maxX == cellBoundsArray[i].minX) { neighboringCellsBuffer.Add(new NeighboringCells { value = cellIndex }); } // Upper neighbor cellIndex = i - cellsMultiplier; if (cellIndex > -1) { neighboringCellsBuffer.Add(new NeighboringCells { value = cellIndex }); } // Upper right neighbor cellIndex = i - (cellsMultiplier - 1); if (cellIndex > -1 && cellBoundsArray[cellIndex].minX == cellBoundsArray[i].maxX) { neighboringCellsBuffer.Add(new NeighboringCells { value = cellIndex }); } // Left neighbor cellIndex = i - 1; if (cellIndex > -1 && cellBoundsArray[cellIndex].maxX == cellBoundsArray[i].minX) { neighboringCellsBuffer.Add(new NeighboringCells { value = cellIndex }); } // Right neighbor cellIndex = i + 1; if (cellIndex <= totalCells - 1 && cellBoundsArray[i].maxX == cellBoundsArray[cellIndex].minX) { neighboringCellsBuffer.Add(new NeighboringCells { value = cellIndex }); } // Lower left neighbor cellIndex = i + (cellsMultiplier - 1); if (cellIndex <= totalCells - 1 && cellBoundsArray[i].minX == cellBoundsArray[cellIndex].maxX) { neighboringCellsBuffer.Add(new NeighboringCells { value = cellIndex }); } // Lower neighbor cellIndex = i + cellsMultiplier; if (cellIndex <= totalCells - 1) { neighboringCellsBuffer.Add(new NeighboringCells { value = cellIndex }); } // Lower right neighbor cellIndex = i + (cellsMultiplier + 1); if (cellIndex <= totalCells - 1 && cellBoundsArray[i].maxX == cellBoundsArray[cellIndex].minX) { neighboringCellsBuffer.Add(new NeighboringCells { value = cellIndex }); } } cellBoundsArray.Dispose(); cells.Dispose(); // Player entityArcheType = entityManager.CreateArchetype( typeof(Player), typeof(Translation), typeof(RenderMesh), typeof(LocalToWorld), typeof(Rotation), typeof(Velocity), typeof(Rotate), typeof(RotateSpeed), typeof(Size), typeof(CellIndex) ); Entity player = entityManager.CreateEntity(entityArcheType); entityManager.SetSharedComponentData(player, new RenderMesh { mesh = playerMesh, material = material }); entityManager.SetComponentData(player, new Translation { Value = new float3 { x = 0, y = 0, z = 0 } }); entityManager.SetComponentData(player, new Size { value = new float3 { x = 1, y = 1, z = 1 } }); entityManager.SetComponentData(player, new RotateSpeed { value = 0.05f }); entityManager.SetComponentData(player, new CellIndex { value = -1 }); // Bullet entityArcheType = entityManager.CreateArchetype( typeof(Bullet), typeof(Translation), typeof(RenderMesh), typeof(LocalToWorld), typeof(Velocity), typeof(Scale), typeof(Size), typeof(Disabled), typeof(CellIndex) ); NativeArray <Entity> bulletsArray = new NativeArray <Entity>(22, Allocator.Temp); entityManager.CreateEntity(entityArcheType, bulletsArray); for (int i = 0; i < bulletsArray.Length; i++) { Entity bullet = bulletsArray[i]; entityManager.SetSharedComponentData(bullet, new RenderMesh { mesh = bulletMesh, material = material }); entityManager.SetComponentData(bullet, new Scale { Value = 0.1f }); entityManager.SetComponentData(bullet, new Size { value = new float3 { x = 0.1f, y = 0.1f, z = 0.1f } }); entityManager.SetComponentData(bullet, new CellIndex { value = -1 }); } bulletsArray.Dispose(); // Enemy entityArcheType = entityManager.CreateArchetype( typeof(Enemy), typeof(Translation), typeof(RenderMesh), typeof(LocalToWorld), typeof(Rotation), typeof(Velocity), typeof(Size), typeof(Disabled), typeof(CellIndex) ); NativeArray <Entity> enemiesArray = new NativeArray <Entity>(1000, Allocator.Temp); entityManager.CreateEntity(entityArcheType, enemiesArray); float2 extents = new float2 { x = gridExtents.x + (cellSize.x * 0.5f), y = math.abs(gridExtents.z) + (cellSize.y * 0.5f) }; for (int i = 0; i < enemiesArray.Length; i++) { Entity enemy = enemiesArray[i]; entityManager.SetSharedComponentData(enemy, new RenderMesh { mesh = enemyMesh, material = material }); entityManager.SetComponentData(enemy, new Size { value = new float3 { x = 1, y = 1, z = 1 } }); entityManager.SetComponentData(enemy, new CellIndex { value = -1 }); entityManager.SetComponentData(enemy, new Translation { Value = GetEnemyPosition(extents) }); } enemiesArray.Dispose(); }
private void ShowAdd() { DynamicBuffer <int> buffer = new DynamicBuffer <int>(); DynamicBuffer <int> secondBuffer = new DynamicBuffer <int>(); #region dynamicbuffer.add buffer.Add(5); #endregion #region dynamicbuffer.addrange int[] source = { 1, 2, 3, 4, 5 }; NativeArray <int> newElements = new NativeArray <int>(source, Allocator.Persistent); buffer.AddRange(newElements); #endregion #region dynamicbuffer.asnativearray int[] intArray = { 1, 2, 3, 4, 5 }; NativeArray <int> .Copy(intArray, buffer.AsNativeArray()); #endregion #region dynamicbuffer.capacity #endregion #region dynamicbuffer.clear buffer.Clear(); #endregion #region dynamicbuffer.copyfrom.dynamicbuffer buffer.CopyFrom(secondBuffer); #endregion #region dynamicbuffer.copyfrom.nativearray int[] sourceArray = { 1, 2, 3, 4, 5 }; NativeArray <int> nativeArray = new NativeArray <int>(source, Allocator.Persistent); buffer.CopyFrom(nativeArray); #endregion #region dynamicbuffer.copyfrom.array int[] integerArray = { 1, 2, 3, 4, 5 }; buffer.CopyFrom(integerArray); #endregion #region dynamicbuffer.getenumerator foreach (var element in buffer) { //Use element... } #endregion #region dynamicbuffer.getunsafeptr #endregion int insertionIndex = 2; #region dynamicbuffer.insert if (insertionIndex < buffer.Length) { buffer.Insert(insertionIndex, 6); } #endregion #region dynamicbuffer.iscreated #endregion #region dynamicbuffer.length for (int i = 0; i < buffer.Length; i++) { buffer[i] = i * i; } #endregion #region dynamicbuffer.removeat if (insertionIndex < buffer.Length) { buffer.RemoveAt(insertionIndex); } #endregion int start = 1; #region dynamicbuffer.removerange buffer.RemoveRange(start, 5); #endregion #region dynamicbuffer.reserve buffer.EnsureCapacity(buffer.Capacity + 10); #endregion #region dynamicbuffer.resizeuninitialized buffer.ResizeUninitialized(buffer.Length + 10); #endregion #region dynamicbuffer.indexoperator for (int i = 0; i < buffer.Length; i++) { buffer[i] = i * i; } #endregion #region dynamicbuffer.tonativearray NativeArray <int> copy = buffer.ToNativeArray(Allocator.Persistent); #endregion #region dynamicbuffer.trimexcess if (buffer.Capacity > buffer.Length) { buffer.TrimExcess(); } #endregion }
private void BuildCommandBuffer(DynamicBuffer <MeshVertex> vertexArray, DynamicBuffer <MeshVertexIndex> indexArray, DynamicBuffer <SubMeshInfo> subMeshArray, Mesh unityMesh, CommandBuffer canvasCommandBuffer) { using (new ProfilerSample("RenderSystem.SetVertexBuffer")) { //unityMesh.Clear(true); unityMesh.SetVertexBufferParams(vertexArray.Length, m_MeshDescriptors[0], m_MeshDescriptors[1], m_MeshDescriptors[2], m_MeshDescriptors[3], m_MeshDescriptors[4]); } using (new ProfilerSample("UploadMesh")) { unityMesh.SetVertexBufferData(vertexArray.AsNativeArray(), 0, 0, vertexArray.Length, 0); unityMesh.SetIndexBufferParams(indexArray.Length, IndexFormat.UInt32); unityMesh.SetIndexBufferData(indexArray.AsNativeArray(), 0, 0, indexArray.Length); unityMesh.subMeshCount = subMeshArray.Length; for (int i = 0; i < subMeshArray.Length; i++) { var subMesh = subMeshArray[i]; var descr = new SubMeshDescriptor() { baseVertex = 0, bounds = default,
public void Execute(DynamicBuffer <ObserverDestroyVisibleActorBuffer> observerDestroyVisibleActorBuffer, DynamicBuffer <NetworkReliableOutBuffer> outBuffer) { for (int i = 0; i < observerDestroyVisibleActorBuffer.Length; ++i) { var actorEntity = observerDestroyVisibleActorBuffer[i].actorEntity; var s = new ActorDestroySerialize { actorId = actorEntity.Index }; s._DoSerialize(outBuffer); //actorServerSystem.actorSpawner.OnDestroySerializeInServer(actorEntity, broadcastBuffer); } }
/// <summary> /// Returns an array of objects that intersect with the specified ray, if any. Otherwise returns an empty array. See also: IsColliding. /// </summary> /// <param name="i_nodeIndex">Internal octree node index.</param> /// <param name="checkRay">Ray to check. Passing by ref as it improves performance with structs.</param> /// <param name="l_resultInstanceIDs">List result.</param> /// <param name="i_nearestIndex">Nerest collision index from the lits.</param> /// <param name="f_nearestDistance">Nerest collision distance.</param> /// <param name="maxDistance">Distance to check.</param> /// <returns>Instances index, that intersect with the specified ray.</returns> static public bool _GetNodeColliding(RootNodeData rootNodeData, int i_nodeIndex, Ray checkRay, ref DynamicBuffer <CollisionInstancesBufferElement> a_collisionInstancesBuffer, ref IsCollidingData isCollidingData, DynamicBuffer <NodeBufferElement> a_nodesBuffer, DynamicBuffer <NodeChildrenBufferElement> a_nodeChildrenBuffer, DynamicBuffer <NodeInstancesIndexBufferElement> a_nodeInstancesIndexBuffer, DynamicBuffer <InstanceBufferElement> a_instanceBuffer, float f_maxDistance = float.PositiveInfinity) { float f_distance; NodeBufferElement nodeBuffer = a_nodesBuffer [i_nodeIndex]; if (!nodeBuffer.bounds.IntersectRay(checkRay, out f_distance) || f_distance > f_maxDistance) { return(isCollidingData.i_collisionsCount > 0 ? true : false); } if (nodeBuffer.i_instancesCount > 0) { int i_nodeInstancesIndexOffset = i_nodeIndex * rootNodeData.i_instancesAllowedCount; CollisionInstancesBufferElement collisionInstancesBuffer = new CollisionInstancesBufferElement(); // Check against any objects in this node for (int i = 0; i < rootNodeData.i_instancesAllowedCount; i++) { NodeInstancesIndexBufferElement nodeInstancesIndexBuffer = a_nodeInstancesIndexBuffer [i_nodeInstancesIndexOffset + i]; // Get index of instance int i_instanceIndex = nodeInstancesIndexBuffer.i; // Check if instance exists, and if has intersecting bounds. if (i_instanceIndex >= 0) { InstanceBufferElement instanceBuffer = a_instanceBuffer [i_instanceIndex]; if (instanceBuffer.bounds.IntersectRay(checkRay, out f_distance) && f_distance <= f_maxDistance) { if (f_distance < isCollidingData.f_nearestDistance) { isCollidingData.f_nearestDistance = f_distance; isCollidingData.i_nearestInstanceCollisionIndex = isCollidingData.i_collisionsCount; } // Is expected, that the required length is no greater than current length + 1 // And is not negative. int i_collisionsCount = isCollidingData.i_collisionsCount; collisionInstancesBuffer.i_ID = instanceBuffer.i_ID; collisionInstancesBuffer.i_version = instanceBuffer.i_entityVersion; // Optional, used when Id is used as entity index // Assign colliding instance ID to buffer. if (a_collisionInstancesBuffer.Length <= i_collisionsCount) { // Expand buffer if needed a_collisionInstancesBuffer.Add(collisionInstancesBuffer); } else { a_collisionInstancesBuffer [i_collisionsCount] = collisionInstancesBuffer; } isCollidingData.i_collisionsCount++; } } } } // Check children for collisions // Check if having children if (nodeBuffer.i_childrenCount > 0) { int i_nodeChildrenIndexOffset = i_nodeIndex * 8; // We checked that is having children. for (int i = 0; i < 8; i++) { NodeChildrenBufferElement nodeChildrenBuffer = a_nodeChildrenBuffer [i_nodeChildrenIndexOffset + i]; int i_nodeChildIndex = nodeChildrenBuffer.i_nodesIndex; // Check if node exists if (i_nodeChildIndex >= 0) { _GetNodeColliding(rootNodeData, i_nodeChildIndex, checkRay, ref a_collisionInstancesBuffer, ref isCollidingData, a_nodesBuffer, a_nodeChildrenBuffer, a_nodeInstancesIndexBuffer, a_instanceBuffer, f_maxDistance); } } } return(isCollidingData.i_collisionsCount > 0 ? true : false); }
public static void Add(ref DynamicBuffer <PublicEntityRef> buffer, PublicEntityRef entityref) { int i = FindInsertionPoint(ref buffer, entityref); buffer.Insert(i, entityref); }
Entity CreateFrontBufferRenderNode(int w, int h) { Entity eNode = EntityManager.CreateEntity(); EntityManager.AddComponentData(eNode, new RenderNode { }); EntityManager.AddComponentData(eNode, new RenderNodePrimarySurface { }); var passRect = new RenderPassRect { x = 0, y = 0, w = (ushort)w, h = (ushort)h }; Entity ePassBlit = EntityManager.CreateEntity(); EntityManager.AddComponentData(ePassBlit, new RenderPass { inNode = eNode, sorting = RenderPassSort.Unsorted, projectionTransform = float4x4.identity, viewTransform = float4x4.identity, passType = RenderPassType.FullscreenQuad, viewId = 0xffff, scissor = new RenderPassRect(), viewport = passRect, targetRect = passRect, clearFlags = RenderPassClear.Color, clearDepth = 1.0f, clearStencil = 0, clearRGBA = 0xff, shadowMask = ulong.MaxValue, cameraMask = ulong.MaxValue }); EntityManager.AddComponent <RenderPassAutoSizeToNode>(ePassBlit); EntityManager.AddComponent <RenderPassClearColorFromBorder>(ePassBlit); Entity ePassDebug = EntityManager.CreateEntity(); EntityManager.AddComponentData(ePassDebug, new RenderPass { inNode = eNode, sorting = RenderPassSort.Sorted, projectionTransform = float4x4.identity, viewTransform = float4x4.identity, passType = RenderPassType.DebugOverlay, viewId = 0xffff, scissor = new RenderPassRect(), viewport = passRect, targetRect = passRect, clearFlags = 0, clearDepth = 1.0f, clearStencil = 0, shadowMask = ulong.MaxValue, cameraMask = ulong.MaxValue }); EntityManager.AddComponent <RenderPassAutoSizeToNode>(ePassDebug); DynamicBuffer <RenderNodeRef> nodeRefs = EntityManager.AddBuffer <RenderNodeRef>(eNode); DynamicBuffer <RenderPassRef> passRefs = EntityManager.AddBuffer <RenderPassRef>(eNode); passRefs.Add(new RenderPassRef { e = ePassBlit }); passRefs.Add(new RenderPassRef { e = ePassDebug }); return(eNode); }