private unsafe void RenderMeshWithoutColors(
ArchetypeChunkSharedComponentType <RenderMesh> renderMeshType,
ArchetypeChunkComponentType <LocalToWorld> localToWorldType)
{
var chunks = this.renderMeshWithoutColors.CreateArchetypeChunkArray(Allocator.TempJob);
for (int i = 0; i < chunks.Length; i++)
{
var chunk = chunks[i];
var renderMesh = chunk.GetSharedComponentData(renderMeshType, this.EntityManager);
var localToWorldArray = chunk.GetNativeArray(localToWorldType);
var matrix4x4Array = new Matrix4x4[chunk.Count];
fixed(void *matrixPointer = &matrix4x4Array[0])
{
var localToWorldPointer = localToWorldArray.GetUnsafeReadOnlyPtr();
UnsafeUtility.MemCpy(matrixPointer, localToWorldPointer, sizeof(Matrix4x4) * chunk.Count);
}
Graphics.DrawMeshInstanced(renderMesh.Mesh, 0, renderMesh.Material, matrix4x4Array);
}
chunks.Dispose();
}
protected unsafe override JobHandle OnUpdate(JobHandle inputDeps)
{
var sys = World.GetExistingSystem <RendererBGFXSystem>();
if (!sys.Initialized)
{
return(inputDeps);
}
var chunks = m_query.CreateArchetypeChunkArray(Allocator.Temp);
NativeArray <Entity> sharedRenderToPass = new NativeArray <Entity>(chunks.Length, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
NativeArray <Entity> sharedLightingRef = new NativeArray <Entity>(chunks.Length, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
ArchetypeChunkSharedComponentType <RenderToPasses> renderToPassesType = GetArchetypeChunkSharedComponentType <RenderToPasses>();
ArchetypeChunkSharedComponentType <LightingRef> lightingRefType = GetArchetypeChunkSharedComponentType <LightingRef>();
// it really sucks we can't get shared components in the job itself
for (int i = 0; i < chunks.Length; i++)
{
sharedRenderToPass[i] = chunks[i].GetSharedComponentData <RenderToPasses>(renderToPassesType, EntityManager).e;
sharedLightingRef[i] = chunks[i].GetSharedComponentData <LightingRef>(lightingRefType, EntityManager).e;
}
chunks.Dispose();
var encodejob = new SubmitSimpleLitMeshJob {
LocalToWorldType = GetArchetypeChunkComponentType <LocalToWorld>(true),
MeshRendererType = GetArchetypeChunkComponentType <MeshRenderer>(true),
LitMeshType = GetArchetypeChunkComponentType <LitMeshReference>(true),
WorldBoundsType = GetArchetypeChunkComponentType <WorldBounds>(true),
WorldBoundingSphereType = GetArchetypeChunkComponentType <WorldBoundingSphere>(true),
ChunkWorldBoundingSphereType = GetArchetypeChunkComponentType <ChunkWorldBoundingSphere>(true),
ChunkWorldBoundsType = GetArchetypeChunkComponentType <ChunkWorldBounds>(true),
SharedRenderToPass = sharedRenderToPass,
SharedLightingRef = sharedLightingRef,
BufferRenderToPassesEntry = GetBufferFromEntity <RenderToPassesEntry>(true),
ComponentSimpleMeshBGFX = GetComponentDataFromEntity <SimpleMeshBGFX>(true),
ComponentMeshRenderData = GetComponentDataFromEntity <LitMeshRenderData>(true),
ComponentRenderPass = GetComponentDataFromEntity <RenderPass>(true),
ComponentLitMaterialBGFX = GetComponentDataFromEntity <LitMaterialBGFX>(true),
ComponentLightingBGFX = GetComponentDataFromEntity <LightingBGFX>(true),
ComponentFrustum = GetComponentDataFromEntity <Frustum>(true),
PerThreadData = sys.m_perThreadDataPtr,
MaxPerThreadData = sys.m_maxPerThreadData,
BGFXSystem = World.GetExistingSystem <RendererBGFXSystem>()
};
var encodejobHandle = encodejob.Schedule(m_query, inputDeps);
return(encodejobHandle);
}
protected override void OnUpdate()
{
ArchetypeChunkSharedComponentType <RenderMesh> renderMeshType = this.GetArchetypeChunkSharedComponentType <RenderMesh>();
ArchetypeChunkSharedComponentType <MatProps> matPropsType = this.GetArchetypeChunkSharedComponentType <MatProps>();
ArchetypeChunkComponentType <LocalToWorld> localToWorldType = this.GetArchetypeChunkComponentType <LocalToWorld>();
ArchetypeChunkComponentType <MeshColor> meshColorType = this.GetArchetypeChunkComponentType <MeshColor>();
ArchetypeChunkEntityType archetypeChunkEntityType = this.GetArchetypeChunkEntityType();
this.AddMatPropsForColorMesh(archetypeChunkEntityType);
this.withColorsMarker.Begin();
this.RenderMeshWithColors(renderMeshType, matPropsType, localToWorldType, meshColorType);
this.withColorsMarker.End();
this.withoutColorsMarker.Begin();
this.RenderMeshWithoutColors(renderMeshType, localToWorldType);
this.withoutColorsMarker.End();
}
private void NewMethod(FrozenRenderSceneTag tag, NativeArray <ArchetypeChunk> chunks,
NativeArray <int> sharedRendererCounts,
NativeArray <int> sortedChunkIndices, int sharedRenderCount,
ArchetypeChunkComponentType <RenderMeshFlippedWindingTag> meshInstanceFlippedTagType,
ArchetypeChunkSharedComponentType <EditorRenderData> editorRenderDataType,
ArchetypeChunkSharedComponentType <RenderMesh> RenderMeshType)
{
var job = new BatchingJob()
{
NativeEditorRenderDataIndex = new NativeList <int>(Allocator.TempJob),
NativeDataArray1 = new NativeList <int4>(Allocator.TempJob),
NativeFlipped = new NativeList <bool>(Allocator.TempJob),
SharedRendererCounts = sharedRendererCounts,
SortedChunkIndices = sortedChunkIndices,
Chunks = chunks,
SharedRenderCount = sharedRenderCount,
MeshInstanceFlippedTagType = meshInstanceFlippedTagType,
EditorRenderDataType = editorRenderDataType,
RenderMeshType = RenderMeshType
};
job.Run();
for (int i = 0; i < job.NativeDataArray1.Length; i++)
{
var editorDataIndex = job.NativeEditorRenderDataIndex[i];
EditorRenderData editorRenderData = m_DefaultEditorRenderData;
if (editorDataIndex != -1)
{
editorRenderData = EntityManager.GetSharedComponentData <EditorRenderData>(editorDataIndex);
}
var data1 = job.NativeDataArray1[i];
m_InstancedRenderMeshBatchGroup.AddBatch(tag, data1.x,
data1.z, chunks, sortedChunkIndices, data1.y,
data1.w, job.NativeFlipped[i],
editorRenderData);
}
job.Dispose();
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
ArchetypeChunkSharedComponentType <SpriteAsset> assetType = GetArchetypeChunkSharedComponentType <SpriteAsset>();
ArchetypeChunkComponentType <SpriteVertexData> spriteDataType = GetArchetypeChunkComponentType <SpriteVertexData>();
using (var chunkArray = m_SpriteAssetGroup.CreateArchetypeChunkArray(Unity.Collections.Allocator.TempJob))
{
foreach (var chunk in chunkArray)
{
var spriteDataArray = chunk.GetNativeArray(spriteDataType);
var asset = chunk.GetSharedComponentData(assetType, EntityManager);
var spriteData = SpriteUtility.GetSpriteVertexData(asset.Value);
spriteData.NativeMaterialId = chunk.GetSharedComponentIndex(assetType);
for (int i = 0; i < chunk.Count; i++)
{
spriteDataArray[i] = spriteData;
}
//chunk.SetChunkComponentData(spriteDataType, spriteData);
}
}
EntityManager.AddComponent(m_SpriteAssetGroup, typeof(SpriteAssetInitialized));
return(inputDeps);
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
ArchetypeChunkSharedComponentType <LegacyTextFontMaterial> materialType = GetArchetypeChunkSharedComponentType <LegacyTextFontMaterial>();
ArchetypeChunkComponentType <TextFontAsset> fontType = GetArchetypeChunkComponentType <TextFontAsset>();
using (var chunkArray = m_FontAssetGroup.CreateArchetypeChunkArray(Unity.Collections.Allocator.TempJob))
{
foreach (var chunk in chunkArray)
{
var fontAssetArray = chunk.GetNativeArray(fontType);
var nativeId = chunk.GetSharedComponentIndex(materialType);
for (int i = 0; i < chunk.Count; i++)
{
var fontData = fontAssetArray[i];
fontData.NativeMaterialId = nativeId;
fontAssetArray[i] = fontData;
}
//chunk.SetChunkComponentData(spriteDataType, spriteData);
}
}
EntityManager.AddComponent(m_FontAssetGroup, typeof(FontAssetInitialized));
return(inputDeps);
}
public void ScheduleTimeInitialize(ComponentSystemBase jobComponentSystem, bool isReadOnly)
{
_type = jobComponentSystem.GetArchetypeChunkSharedComponentType <T>();
_entityManager = jobComponentSystem.EntityManager;
}
private void OldMethod(FrozenRenderSceneTag tag, NativeArray <ArchetypeChunk> chunks,
NativeArray <int> sharedRendererCounts,
NativeArray <int> sortedChunkIndices, int sharedRenderCount,
ArchetypeChunkComponentType <RenderMeshFlippedWindingTag> meshInstanceFlippedTagType,
ArchetypeChunkSharedComponentType <EditorRenderData> editorRenderDataType,
ArchetypeChunkSharedComponentType <RenderMesh> RenderMeshType)
{
var sortedChunkIndex = 0;
for (int i = 0; i < sharedRenderCount; i++)
{
var startSortedChunkIndex = sortedChunkIndex;
var endSortedChunkIndex = startSortedChunkIndex + sharedRendererCounts[i];
while (sortedChunkIndex < endSortedChunkIndex)
{
var chunkIndex = sortedChunkIndices[sortedChunkIndex];
var chunk = chunks[chunkIndex];
var rendererSharedComponentIndex = chunk.GetSharedComponentIndex(RenderMeshType);
var editorRenderDataIndex = chunk.GetSharedComponentIndex(editorRenderDataType);
var editorRenderData = m_DefaultEditorRenderData;
if (editorRenderDataIndex != -1)
{
editorRenderData =
EntityManager.GetSharedComponentData <EditorRenderData>(editorRenderDataIndex);
}
var remainingEntitySlots = 1023;
var flippedWinding = chunk.Has(meshInstanceFlippedTagType);
int instanceCount = chunk.Count;
int startSortedIndex = sortedChunkIndex;
int batchChunkCount = 1;
remainingEntitySlots -= chunk.Count;
sortedChunkIndex++;
while (remainingEntitySlots > 0)
{
if (sortedChunkIndex >= endSortedChunkIndex)
{
break;
}
var nextChunkIndex = sortedChunkIndices[sortedChunkIndex];
var nextChunk = chunks[nextChunkIndex];
if (nextChunk.Count > remainingEntitySlots)
{
break;
}
var nextFlippedWinding = nextChunk.Has(meshInstanceFlippedTagType);
if (nextFlippedWinding != flippedWinding)
{
break;
}
#if UNITY_EDITOR
if (editorRenderDataIndex != nextChunk.GetSharedComponentIndex(editorRenderDataType))
{
break;
}
#endif
remainingEntitySlots -= nextChunk.Count;
instanceCount += nextChunk.Count;
batchChunkCount++;
sortedChunkIndex++;
}
m_InstancedRenderMeshBatchGroup.AddBatch(tag, rendererSharedComponentIndex, instanceCount, chunks,
sortedChunkIndices, startSortedIndex, batchChunkCount, flippedWinding, editorRenderData);
}
}
}
