protected override void OnUpdate()
{
Entities.ForEach((DotsNavPlane plane, DotsNavLocalAvoidance localAvoidance) =>
{
var entity = GetPrimaryEntity(localAvoidance);
localAvoidance.Entity = entity;
localAvoidance.World = DstEntityManager.World;
DstEntityManager.AddComponentData(entity, new ObstacleTreeComponent());
var boxEntity = CreateAdditionalEntity(localAvoidance);
DstEntityManager.AddComponentData(boxEntity, new ObstacleTreeElementComponent {
Tree = entity
});
var box = DstEntityManager.AddBuffer <VertexElement>(boxEntity);
float2 extent = plane.Size / 2;
box.Add(-extent);
box.Add(new float2(-extent.x, extent.y));
box.Add(extent);
box.Add(new float2(extent.x, -extent.y));
box.Add(-extent);
DstEntityManager.AddComponentData(entity, new DynamicTreeComponent());
if (localAvoidance.DrawObstacleTree)
{
DstEntityManager.AddComponentData(entity, new DrawComponent {
Color = plane.ConstrainedColor
});
}
});
}
void ConvertText(TextMeshProUGUI text)
{
var entity = GetPrimaryEntity(text);
var fontAsset = GetPrimaryEntity(text.font);
DstEntityManager.AddComponentData(entity, new TextRenderer()
{
Font = fontAsset,
Size = text.fontSize,
Alignment = text.alignment,
Bold = (text.fontStyle & FontStyles.Bold) == FontStyles.Bold,
Italic = (text.fontStyle & FontStyles.Italic) == FontStyles.Italic
});
var textBuffer = DstEntityManager.AddBuffer <TextData>(entity);
var content = text.text;
textBuffer.ResizeUninitialized(content.Length);
unsafe
{
fixed(char *textPtr = content)
UnsafeUtility.MemCpy(textBuffer.GetUnsafePtr(), textPtr, content.Length * sizeof(char));
}
DstEntityManager.AddBuffer <ControlVertexData>(entity);
DstEntityManager.AddBuffer <ControlVertexIndex>(entity);
DstEntityManager.AddComponentData(entity, new RebuildElementMeshFlag()
{
Rebuild = true
});
ConvertGraphic(text);
}
protected override void OnUpdate()
{
Entities.ForEach((PoseTracer poseTracer) =>
{
if (poseTracer.HistorySize == 0)
{
UnityEngine.Debug.LogWarning($"{this} has parameter HistorySize set to 0, no trace will be generated. Either disable or remove the component to remove the trace.");
return;
}
var entity = GetPrimaryEntity(poseTracer);
DstEntityManager.AddComponentData(entity, new PoseTracerComponent
{
FramesLeftUntilDraw = 0,
FramePeriod = poseTracer.FramePeriod,
});
DstEntityManager.AddBuffer <PoseTracerElement>(entity);
for (int i = 0; i < poseTracer.HistorySize; i++)
{
var color = Color.Lerp(poseTracer.Color, poseTracer.EndColor, ((float)i) / ((float)poseTracer.HistorySize));
DstEntityManager.GetBuffer <PoseTracerElement>(entity).Add(new PoseTracerElement
{
SegmentColor = color,
EndPosition = poseTracer.transform.position,
});
}
});
}
protected override void OnUpdate()
{
Entities.ForEach((DeformDebugComponent deformMesh) =>
{
Debug.Assert(deformMesh.GetComponentsInChildren <SkinnedMeshRenderer>().Length == 1, "More than one SMR in DeformDebug component children");
var meshRenderer = deformMesh.GetComponentInChildren <SkinnedMeshRenderer>();
var entity = GetPrimaryEntity(meshRenderer);
var bones = meshRenderer.bones;
DstEntityManager.AddBuffer <RotatingBoneTransform>(entity);
DstEntityManager.AddBuffer <ModifiedTransform>(entity);
var rotatingBonesArray = DstEntityManager.GetBuffer <RotatingBoneTransform>(entity);
var movedTransformsArray = DstEntityManager.GetBuffer <ModifiedTransform>(entity);
rotatingBonesArray.ResizeUninitialized(bones.Length);
movedTransformsArray.ResizeUninitialized(bones.Length);
for (int boneIndex = 0; boneIndex != bones.Length; ++boneIndex)
{
var bone = meshRenderer.bones[boneIndex];
var boneMovementComponent = new RotatingBoneTransform
{
Value = meshRenderer.bones[boneIndex].localToWorldMatrix
};
var rotationObject = bone.GetComponent <RotateTransformComponent>();
boneMovementComponent.DoTheThing = rotationObject != null;
if (rotationObject)
{
boneMovementComponent.Degrees = rotationObject.Degrees;
}
rotatingBonesArray[boneIndex] = boneMovementComponent;
}
var sharedMesh = meshRenderer.sharedMesh;
if (sharedMesh.boneWeights.Length > 0 && sharedMesh.bindposes.Length > 0)
{
DstEntityManager.AddBuffer <BindPose>(entity);
var bindPoseArray = DstEntityManager.GetBuffer <BindPose>(entity);
bindPoseArray.ResizeUninitialized(bones.Length);
for (int boneIndex = 0; boneIndex != bones.Length; ++boneIndex)
{
var bindPose = meshRenderer.sharedMesh.bindposes[boneIndex];
bindPoseArray[boneIndex] = new BindPose {
Value = bindPose
};
}
}
if (sharedMesh.blendShapeCount > 0)
{
DstEntityManager.AddComponentData(entity, new UpdateBlendWeightData {
Value = 0.3f
});
}
});
}
protected override void OnUpdate()
{
Entities.ForEach((Image image) => {
var texture = image.sprite != null ? image.sprite.texture : Texture2D.whiteTexture;
var material = image.material != null ? image.material : Canvas.GetDefaultCanvasMaterial();
var entity = GetPrimaryEntity(image);
var rectSize = image.rectTransform.Int2Size();
DstEntityManager.AddComponentData(entity, new LinkedTextureEntity {
Value = GetPrimaryEntity(texture)
});
DstEntityManager.AddComponentData(entity, new LinkedMaterialEntity {
Value = GetPrimaryEntity(material)
});
DstEntityManager.AddComponentData(entity, new AppliedColor {
Value = image.color
});
var spriteTexture = image.sprite;
var spriteRes = spriteTexture != null ?
new int2(spriteTexture.texture.width, spriteTexture.texture.height) :
rectSize;
DstEntityManager.AddComponentData(entity, new DefaultSpriteResolution {
Value = spriteRes
});
var spriteData = SpriteData.FromSprite(image.sprite);
DstEntityManager.AddComponentData(entity, spriteData);
// TODO: Does not handle image slicing
DstEntityManager.AddBuffer <LocalVertexData>(entity).ResizeUninitialized(4);
DstEntityManager.AddBuffer <LocalTriangleIndexElement>(entity).ResizeUninitialized(6);
// Mark that the image has to be built.
DstEntityManager.AddComponent <BuildUIElementTag>(entity);
var type = image.type;
switch (type)
{
case Image.Type.Simple:
break;
case Image.Type.Filled:
SetFill(image, entity);
break;
default:
throw new System.NotSupportedException($"Only Simple/Filled Image types are supported so far for {image.name}");
}
// If the image is inactive, then we want to make sure the image gets offsetted.
if (!image.gameObject.activeInHierarchy || !image.enabled)
{
DstEntityManager.AddComponent <UpdateVertexColorTag>(entity);
}
});
}
private void ConvertCanvas(Canvas canvas)
{
var entity = GetPrimaryEntity(canvas);
CanvasSortLayer image = new CanvasSortLayer
{
Value = canvas.sortingOrder
};
DstEntityManager.AddComponentData(entity, image);
DstEntityManager.AddComponent(entity, typeof(RebuildCanvasHierarchyFlag));
DstEntityManager.AddBuffer <MeshVertex>(entity);
DstEntityManager.AddBuffer <MeshVertexIndex>(entity);
DstEntityManager.AddBuffer <SubMeshInfo>(entity);
if (canvas.renderMode != RenderMode.ScreenSpaceCamera)
{
throw new InvalidOperationException($"Canvas ({canvas}) render mode ({canvas.renderMode}) is not supported yet");
}
if (canvas.worldCamera == null)
{
throw new InvalidOperationException($"Target camera is null or destroyed. Canvas {canvas}");
}
var proxy = canvas.worldCamera.GetComponent <CameraImageRenderProxy>();
if (proxy == null)
{
proxy = canvas.worldCamera.gameObject.AddComponent <CameraImageRenderProxy>();
}
DstEntityManager.AddSharedComponentData(entity, new CanvasTargetCamera()
{
Target = proxy
});
}
private void ConvertCanvas(Canvas canvas)
{
var entity = GetPrimaryEntity(canvas);
CanvasSortLayer image = new CanvasSortLayer
{
Value = canvas.sortingOrder
};
DstEntityManager.AddComponentData(entity, image);
DstEntityManager.AddComponent(entity, typeof(RebuildCanvasHierarchyFlag));
DstEntityManager.AddBuffer <MeshVertex>(entity);
DstEntityManager.AddBuffer <MeshVertexIndex>(entity);
DstEntityManager.AddBuffer <SubMeshInfo>(entity);
if (canvas.renderMode == RenderMode.WorldSpace)
{
throw new InvalidOperationException($"Canvas ({canvas}) render mode ({canvas.renderMode}) is not supported yet");
}
if (canvas.renderMode == RenderMode.ScreenSpaceCamera)
{
SetUpScreenSpaceCamera(canvas, entity);
}
else if (canvas.renderMode == RenderMode.ScreenSpaceOverlay)
{
SetUpScreenSpaceOverlay(canvas, entity);
}
}
protected override void OnUpdate()
{
Entities.ForEach((SkinnedMesh meshRenderer) =>
{
var entity = GetPrimaryEntity(meshRenderer.SkinnedMeshRenderer);
Entity rigEntity = GetPrimaryEntity(meshRenderer.Rig);
var animatedSkinMatricesArray = DstEntityManager.AddBuffer <AnimatedLocalToRoot>(rigEntity);
animatedSkinMatricesArray.ResizeUninitialized(meshRenderer.Rig.Bones.Length);
DstEntityManager.AddComponentData(entity, new SkinnedMeshRigEntity {
Value = rigEntity
});
DstEntityManager.AddComponentData(entity, new LocalToWorld());
DstEntityManager.AddComponentData(entity, new BoneIndexOffset());
DstEntityManager.AddBuffer <SkinnedMeshToRigIndex>(entity);
DstEntityManager.AddBuffer <BindPose>(entity);
DstEntityManager.AddBuffer <SkinMatrix>(entity);
var skeletonIndexArray = DstEntityManager.GetBuffer <SkinnedMeshToRigIndex>(entity);
var bindPoseArray = DstEntityManager.GetBuffer <BindPose>(entity);
var skinMatrices = DstEntityManager.GetBuffer <SkinMatrix>(entity);
var smBones = meshRenderer.SkinnedMeshRenderer.bones;
skeletonIndexArray.ResizeUninitialized(smBones.Length);
bindPoseArray.ResizeUninitialized(smBones.Length);
skinMatrices.ResizeUninitialized(smBones.Length);
var skBones = meshRenderer.Rig.Bones;
for (int j = 0; j != smBones.Length; ++j)
{
var remap = new SkinnedMeshToRigIndex {
Value = -1
};
for (int k = 0; k != skBones.Length; ++k)
{
if (smBones[j] == skBones[k])
{
remap.Value = k;
break;
}
}
skeletonIndexArray[j] = remap;
var bindPose = meshRenderer.SkinnedMeshRenderer.sharedMesh.bindposes[j];
bindPoseArray[j] = new BindPose {
Value = bindPose
};
var skinMat = math.mul(meshRenderer.SkinnedMeshRenderer.bones[j].localToWorldMatrix, bindPose);
skinMatrices[j] = new SkinMatrix {
Value = new float3x4(skinMat.c0.xyz, skinMat.c1.xyz, skinMat.c2.xyz, skinMat.c3.xyz)
};
}
});
}
protected override void OnUpdate()
{
Entities.ForEach((TextMeshProUGUI text) => {
var fontAsset = text.font;
if (fontAsset != null)
{
var fontAssetEntity = GetPrimaryEntity(fontAsset);
DstEntityManager.AddComponentData(fontAssetEntity, new FontID {
Value = fontAsset.GetInstanceID()
});
DstEntityManager.AddComponentData(fontAssetEntity,
fontAsset.faceInfo.ToFontFaceInfo(
new float2(fontAsset.normalStyle, fontAsset.normalSpacingOffset),
new float2(fontAsset.boldStyle, fontAsset.boldSpacing),
new int2(fontAsset.atlasWidth, fontAsset.atlasHeight)
));
var buffer = DstEntityManager.AddBuffer <GlyphElement>(fontAssetEntity);
buffer.Capacity = fontAsset.characterLookupTable.Count;
buffer.ResizeUninitialized(buffer.Capacity);
var i = 0;
foreach (var entry in fontAsset.characterLookupTable)
{
var metrics = entry.Value.glyph.metrics;
var rect = entry.Value.glyph.glyphRect;
var rawUV = new float4(
new float2(rect.x, rect.y), // Min
new float2(rect.x + rect.width, rect.y + rect.height) // Max
);
buffer[i] = new GlyphElement {
Unicode = (ushort)entry.Key,
Advance = metrics.horizontalAdvance,
Bearings = new float2(metrics.horizontalBearingX, metrics.horizontalBearingY),
Size = new float2(metrics.width, metrics.height),
Scale = entry.Value.scale,
Style = text.fontStyle,
RawUV = rawUV,
#if UNITY_EDITOR
Char = (char)entry.Key
#endif
};
i++;
}
}
});
}
protected override void OnUpdate()
{
Entities.ForEach((EcsTestMonoBehaviourComponent authoring) =>
{
var buffer = DstEntityManager.AddBuffer <MockDynamicBufferData>(GetPrimaryEntity(authoring));
foreach (var authoringInstance in authoring.gameObject.GetComponents <EcsTestMonoBehaviourComponent>())
{
buffer.Add(new MockDynamicBufferData {
Value = authoringInstance.SomeValue
});
}
});
}
protected override void OnUpdate()
{
Entities.ForEach((TextMeshPro textMesh, MeshFilter meshFilter) => {
// We must disable the text mesh for it to be skipped by MeshRenderer conversion system
meshFilter.mesh = null;
var font = textMesh.font;
var entity = GetPrimaryEntity(textMesh);
if (!m_textFontAssets.TryGetValue(font, out var fontEntity))
{
fontEntity = TextUtility.CreateTextFontAsset(DstEntityManager, font);
m_textFontAssets.Add(font, fontEntity);
}
DstEntityManager.AddSharedComponentData(entity, new FontMaterial {
Value = font.material
});
var materialId = DstEntityManager.GetSharedComponentDataIndex <FontMaterial>(entity);
DstEntityManager.AddComponentData(entity, new TextRenderer()
{
Font = fontEntity,
MaterialId = materialId,
Size = textMesh.fontSize,
Alignment = textMesh.alignment,
Bold = (textMesh.fontStyle & FontStyles.Bold) == FontStyles.Bold,
Italic = (textMesh.fontStyle & FontStyles.Italic) == FontStyles.Italic
});
DstEntityManager.AddComponentData(entity, new TextData {
Value = textMesh.text
});
DstEntityManager.AddComponentData(entity, new VertexColor()
{
Value = textMesh.color.ToFloat4()
});
DstEntityManager.AddComponentData(entity, new VertexColorMultiplier()
{
Value = new float4(1.0f, 1.0f, 1.0f, 1.0f)
});
DstEntityManager.AddBuffer <Vertex>(entity);
DstEntityManager.AddBuffer <VertexIndex>(entity);
DstEntityManager.AddBuffer <TextLine>(entity);
if (!DstEntityManager.HasComponent <RenderBounds>(entity))
{
// RenderBounds will be calculated on TextMeshBuildSystem
DstEntityManager.AddComponentData(entity, default(RenderBounds));
}
});
}
protected override void OnUpdate()
{
Entities.ForEach((DotsNavObstacle obstacle) =>
{
var entity = GetPrimaryEntity(obstacle);
obstacle.Entity = entity;
obstacle.World = DstEntityManager.World;
var values = DstEntityManager.AddBuffer <VertexElement>(entity);
for (int i = 0; i < obstacle.Vertices.Length; i++)
{
values.Add((float2)obstacle.Vertices[i]);
}
});
}
protected override void OnUpdate()
{
Entities.ForEach((WeaponDatabaseAuthoring weaponDatabaseAuth) =>
{
var entity = GetPrimaryEntity(weaponDatabaseAuth);
var weaponDatabase = DstEntityManager.AddBuffer <WeaponDataEntry>(entity);
foreach (var entry in weaponDatabaseAuth.weaponPrefabs)
{
var weaponPrefab = GetPrimaryEntity(entry);
weaponDatabase.Add(new WeaponDataEntry {
prefab = weaponPrefab
});
}
});
}
private void ConvertImage(Image image)
{
var entity = GetPrimaryEntity(image);
var sprite = image.sprite ?? DefaultSprite;
var assetEntity = GetPrimaryEntity(sprite);
SpriteImage spriteImage = new SpriteImage
{
Asset = assetEntity
};
DstEntityManager.AddComponentData(entity, spriteImage);
DstEntityManager.AddBuffer <ControlVertexData>(entity);
DstEntityManager.AddBuffer <ControlVertexIndex>(entity);
DstEntityManager.AddComponent(entity, typeof(ElementVertexPointerInMesh));
DstEntityManager.AddComponent(entity, typeof(RebuildElementMeshFlag));
}
protected override void OnUpdate()
{
Entities.ForEach((GateInputs1 inputs1) =>
{
var gateEntity = GetPrimaryEntity(inputs1);
var inputsBuffer = DstEntityManager.AddBuffer <NodeInput>(gateEntity);
inputsBuffer.Capacity = 1;
inputsBuffer.Add(new NodeInput {
InputEntity = GetPrimaryEntity(inputs1.inputNode.gameObject)
});
CreateWireEntities(inputs1, inputs1.wirePrefab, inputs1.attachTransform.position, inputs1.inputNode);
});
Entities.ForEach((GateInputs2 inputs2) =>
{
var gateEntity = GetPrimaryEntity(inputs2);
var inputsBuffer = DstEntityManager.AddBuffer <NodeInput>(gateEntity);
inputsBuffer.Capacity = 2;
inputsBuffer.Add(new NodeInput {
InputEntity = GetPrimaryEntity(inputs2.inputNodeL.gameObject)
});
inputsBuffer.Add(new NodeInput {
InputEntity = GetPrimaryEntity(inputs2.inputNodeR.gameObject)
});
CreateWireEntities(inputs2, inputs2.wirePrefab, inputs2.attachTransformL.position, inputs2.inputNodeL);
CreateWireEntities(inputs2, inputs2.wirePrefab, inputs2.attachTransformR.position, inputs2.inputNodeR);
});
Entities.ForEach((GateInputsN inputsN) =>
{
var gateEntity = GetPrimaryEntity(inputsN);
var inputsBuffer = DstEntityManager.AddBuffer <NodeInput>(gateEntity);
inputsBuffer.Capacity = inputsN.inputNodes.Length;
foreach (var inputNode in inputsN.inputNodes)
{
inputsBuffer.Add(new NodeInput {
InputEntity = GetPrimaryEntity(inputNode.gameObject)
});
}
CreateWireEntities(inputsN, inputsN.wirePrefab, inputsN.attachTransform.position, inputsN.inputNodes);
});
}
protected override void OnUpdate()
{
Entities.ForEach((BoidAuthoring boidAuthoring) =>
{
var entity = GetPrimaryEntity(boidAuthoring);
DstEntityManager.AddSharedComponentData(entity, new Boid
{
CellRadius = boidAuthoring.CellRadius,
SeparationWeight = boidAuthoring.SeparationWeight,
AlignmentWeight = boidAuthoring.AlignmentWeight,
TargetWeight = boidAuthoring.TargetWeight,
OuterDetectionRadius = boidAuthoring.OuterDetectionRadius,
InnerDetectionRadius = boidAuthoring.InnerDetectionRadius,
MoveSpeed = boidAuthoring.MoveSpeed,
WanderRadius = boidAuthoring.WanderRadius,
WanderWeight = boidAuthoring.WanderWeight,
VisionAngle = boidAuthoring.VisionAngle,
NavigationRayCount = boidAuthoring.NavigationRayCount,
});
DynamicBuffer <Float3BufferElement> buffer = DstEntityManager.AddBuffer <Float3BufferElement>(entity);
DynamicBuffer <float3> floatBuffer = buffer.Reinterpret <float3>();
for (int i = 0; i < boidAuthoring.NavigationRayCount; i++)
{
float turnFraction = 0.6180f;
float t = i / (boidAuthoring.NavigationRayCount - 1f);
float phi = math.acos(1f - 2f * t);
float theta = 2 * math.PI * turnFraction * i;
float x = math.sin(phi) * math.cos(theta);
float y = math.sin(phi) * math.sin(theta);
float z = math.cos(phi);
float3 p = new float3(x, y, z);
if (math.acos(math.dot(p, new float3(0, 0, 1))) < boidAuthoring.VisionAngle)
{
floatBuffer.Add(p);
}
}
// Remove default transform system components
DstEntityManager.RemoveComponent <Translation>(entity);
DstEntityManager.RemoveComponent <Rotation>(entity);
});
}
protected override void OnUpdate()
{
Entities.ForEach((Image image) => {
TextureBin.TryLoadTextureBin("TextureBin", out TextureBin textureBin);
var texture = image.sprite != null ? image.sprite.texture : Texture2D.whiteTexture;
var imageIndex = textureBin.Add(texture);
var entity = GetPrimaryEntity(image);
var material = image.material != null ? image.material : Canvas.GetDefaultCanvasMaterial();
DstEntityManager.AddComponentObject(entity, material);
// TODO: Internally this would need a look up table...
// DstEntityManager.AddSharedComponentData(entity, new MaterialID { Value = material.GetInstanceID() });
var rectSize = image.rectTransform.Int2Size();
DstEntityManager.AddComponentData(entity, new TextureKey {
Value = imageIndex
});
DstEntityManager.AddComponentData(entity, new AppliedColor {
Value = image.color
});
DstEntityManager.AddComponentData(entity, new Dimensions {
Value = rectSize
});
var spriteTexture = image.sprite;
var spriteRes = spriteTexture != null ?
new int2(spriteTexture.texture.width, spriteTexture.texture.height) :
rectSize;
DstEntityManager.AddComponentData(entity, new DefaultSpriteResolution {
Value = spriteRes
});
var spriteData = SpriteData.FromSprite(image.sprite);
DstEntityManager.AddComponentData(entity, spriteData);
// TODO: Does not handle image slicing
DstEntityManager.AddBuffer <MeshVertexData>(entity).ResizeUninitialized(4);
DstEntityManager.AddBuffer <TriangleIndexElement>(entity).ResizeUninitialized(6);
});
}
private void Convert(RectTransform transform)
{
var entity = GetPrimaryEntity(transform);
DstEntityManager.AddComponentData(entity, new DotsUI.Core.RectTransform()
{
AnchorMin = transform.anchorMin,
AnchorMax = transform.anchorMax,
Pivot = transform.pivot,
Position = transform.anchoredPosition,
SizeDelta = transform.sizeDelta,
});
DstEntityManager.AddComponent(entity, typeof(WorldSpaceRect));
DstEntityManager.AddComponent(entity, typeof(WorldSpaceMask));
DstEntityManager.RemoveComponent(entity, typeof(Translation));
DstEntityManager.RemoveComponent(entity, typeof(Rotation));
DstEntityManager.RemoveComponent(entity, typeof(NonUniformScale));
if (transform.childCount != 0)
{
var childBuffer = DstEntityManager.AddBuffer <Child>(entity);
for (int i = 0; i < transform.childCount; i++)
{
var child = transform.GetChild(i);
if (child is RectTransform rectChild)
{
childBuffer.Add(new Child
{
Value = GetPrimaryEntity(rectChild)
});
}
}
}
if (HasPrimaryEntity(transform.parent))
{
DstEntityManager.AddComponentData(entity, new PreviousParent()
{
Value = GetPrimaryEntity(transform.parent)
});
}
}
protected override void OnUpdate()
{
Entities.ForEach((DotsNavAgent agent, DotsNavPathFindingAgent pathFindingAgent) =>
{
var entity = GetPrimaryEntity(pathFindingAgent);
DstEntityManager.AddComponentData(entity, new PathQueryComponent {
State = PathQueryState.Inactive
});
DstEntityManager.AddComponentData(entity, new DirectionComponent());
DstEntityManager.AddBuffer <PathSegmentElement>(entity);
DstEntityManager.AddBuffer <TriangleElement>(entity);
DstEntityManager.AddComponentData(entity, new AgentDrawComponent {
Draw = true
});
DstEntityManager.AddComponentData(entity, new NavmeshAgentComponent {
Navmesh = agent.Plane.Entity
});
});
}
private void ConvertInputField(TMP_InputField inputField)
{
var entity = GetPrimaryEntity(inputField);
DstEntityManager.AddComponentData(entity, new DotsUI.Input.KeyboardInputReceiver());
DstEntityManager.AddBuffer <DotsUI.Input.KeyboardInputBuffer>(entity);
Entity target = TryGetPrimaryEntity(inputField.textComponent);
Entity placeholder = TryGetPrimaryEntity(inputField.placeholder);
DstEntityManager.AddComponentData(entity, new DotsUI.Controls.InputField()
{
Target = target,
Placeholder = placeholder
});
DstEntityManager.AddComponentData(entity, new DotsUI.Controls.InputFieldCaretState()
{
CaretPosition = 0
});
}
protected override void OnUpdate()
{
Entities.ForEach((DotsNavPlane plane, DotsNavNavmesh navmesh) =>
{
var entity = GetPrimaryEntity(navmesh);
navmesh.Entity = entity;
navmesh.World = DstEntityManager.World;
DstEntityManager.AddComponentData(entity, new NavmeshComponent
(
plane.Size,
navmesh.ExpectedVerts,
navmesh.MergePointDistance,
navmesh.CollinearMargin
));
DstEntityManager.AddBuffer <DestroyedTriangleElement>(entity);
DstEntityManager.AddComponentData(entity, new NavmeshDrawComponent
{
DrawMode = navmesh.DrawMode,
ConstrainedColor = plane.ConstrainedColor,
UnconstrainedColor = plane.UnconstrainedColor
});
});
}
protected override void OnUpdate()
{
Entities.ForEach((DotsNavAgent agent) =>
{
var entity = GetPrimaryEntity(agent);
agent.World = DstEntityManager.World;
agent.Entity = entity;
Assert.IsTrue(agent.Radius > 0, "Radius must be larger than 0");
DstEntityManager.AddComponentData(entity, new Data.AgentComponent
{
Radius = agent.Radius,
State = AgentState.Inactive
});
DstEntityManager.AddComponentData(entity, new AgentDirectionComponent());
DstEntityManager.AddBuffer <PathSegmentElement>(entity);
DstEntityManager.AddBuffer <TriangleElement>(entity);
DstEntityManager.AddComponentData(entity, new AgentDrawComponent {
Draw = true
});
});
}
protected override void OnUpdate()
{
Entities.ForEach((UnityEngine.AudioClip audioClip) =>
{
var entity = GetPrimaryEntity(audioClip);
AudioClip tinyAudioClip = new AudioClip();
tinyAudioClip.loadType = (audioClip.loadType == UnityEngine.AudioClipLoadType.CompressedInMemory) ? AudioClipLoadType.CompressedInMemory : AudioClipLoadType.DecompressOnPlay;
tinyAudioClip.channels = audioClip.channels;
tinyAudioClip.samples = audioClip.samples;
tinyAudioClip.frequency = audioClip.frequency;
DstEntityManager.AddComponentData<AudioClip>(entity, tinyAudioClip);
DstEntityManager.AddComponent<AudioClipUsage>(entity);
DstEntityManager.AddBuffer<AudioClipCompressed>(entity);
DstEntityManager.AddBuffer<AudioClipUncompressed>(entity);
DstEntityManager.AddComponent<AudioClipLoadFromFile>(entity);
var exportGuid = GetGuidForAssetExport(audioClip);
DstEntityManager.AddComponent<AudioClipLoadFromFileAudioFile>(entity);
DstEntityManager.SetBufferFromString<AudioClipLoadFromFileAudioFile>(entity, "Data/" + exportGuid.ToString());
});
}
private void ConvertTextMeshPro(TextMeshProUGUI tmp)
{
var entity = GetPrimaryEntity(tmp);
var fontAsset = GetPrimaryEntity(tmp.font);
//if (tmp.font == null)
//{
// Debug.LogError($"TextMeshProConverter - font asset cannot be null reference. Object: {tmp}", tmp);
// return;
//}
//if (!TryGetAssetEntity(new LegacyTextFontAsset{ Asset = tmp.font, FontMaterial = tmp.font.material }, out var fontAsset))
//{
// fontAsset = TextUtils.CreateFontAssetFromTmp(DstEntityManager, tmp.font);
//}
DstEntityManager.AddComponentData(entity, new TextRenderer()
{
Font = fontAsset,
Size = tmp.fontSize,
Alignment = tmp.alignment,
Bold = (tmp.fontStyle & FontStyles.Bold) == FontStyles.Bold,
Italic = (tmp.fontStyle & FontStyles.Italic) == FontStyles.Italic
});
var textBuffer = DstEntityManager.AddBuffer <TextData>(entity);
var content = tmp.text;
textBuffer.ResizeUninitialized(content.Length);
unsafe
{
fixed(char *textPtr = content)
UnsafeUtility.MemCpy(textBuffer.GetUnsafePtr(), textPtr, content.Length * sizeof(char));
}
DstEntityManager.AddBuffer <ControlVertexData>(entity);
DstEntityManager.AddBuffer <ControlVertexIndex>(entity);
DstEntityManager.AddComponent(entity, typeof(RebuildElementMeshFlag));
}
void Convert(Component animationComponent)
{
var animationClips = TinyAnimationConversionState.GetAllAnimationClips(animationComponent);
if (animationClips.Length == 0)
{
return;
}
var rootGameObject = animationComponent.gameObject;
var gameObjectEntity = TryGetPrimaryEntity(rootGameObject);
if (gameObjectEntity == Entity.Null)
{
throw new Exception($"Could not get a conversion entity for {animationComponent.GetType().Name} on {rootGameObject}.");
}
DstEntityManager.AddBuffer <TinyAnimationClipRef>(gameObjectEntity);
foreach (var clip in animationClips)
{
Convert(rootGameObject, clip, gameObjectEntity);
}
var clipReferences = DstEntityManager.GetBuffer <TinyAnimationClipRef>(gameObjectEntity);
var currentClipEntity = clipReferences[0].Value;
DstEntityManager.AddComponentData(gameObjectEntity, new TinyAnimationPlayer {
CurrentClip = currentClipEntity, CurrentIndex = 0
});
if (PlaysAutomatically(animationComponent))
{
DstEntityManager.AddComponent <UpdateAnimationTimeTag>(currentClipEntity);
DstEntityManager.AddComponent <ApplyAnimationResultTag>(currentClipEntity);
}
}
private void ConvertImage(Image image)
{
var assetQuery = DstEntityManager.CreateEntityQuery(ComponentType.ReadOnly <SpriteAsset>());
var entity = GetPrimaryEntity(image);
var sprite = image.sprite ?? m_DefaultSprite;
var asset = new SpriteAsset()
{
Value = sprite,
};
assetQuery.SetFilter(asset);
Entity assetEntity;
if (assetQuery.CalculateEntityCount() == 0)
{
assetEntity = DstEntityManager.CreateEntity(typeof(SpriteAsset), typeof(SpriteVertexData));
DstEntityManager.SetSharedComponentData(assetEntity, new SpriteAsset {
Value = sprite
});
}
else
{
using (var assetEntityArray = assetQuery.ToEntityArray(Allocator.TempJob))
assetEntity = assetEntityArray[0];
}
SpriteImage spriteImage = new SpriteImage
{
Asset = assetEntity
};
DstEntityManager.AddComponentData(entity, spriteImage);
DstEntityManager.AddBuffer <ControlVertexData>(entity);
DstEntityManager.AddBuffer <ControlVertexIndex>(entity);
DstEntityManager.AddComponent(entity, typeof(ElementVertexPointerInMesh));
DstEntityManager.AddComponent(entity, typeof(RebuildElementMeshFlag));
}
private void AddTextData(Entity e, string text)
{
var length = text.Length;
var txtBuffer = DstEntityManager.AddBuffer <CharElement>(e);
txtBuffer.ResizeUninitialized(length);
for (int i = 0; i < length; i++)
{
txtBuffer[i] = text[i];
}
var vertexBuffer = DstEntityManager.AddBuffer <LocalVertexData>(e);
vertexBuffer.ResizeUninitialized(text.Length);
for (int i = 0; i < text.Length; i++)
{
vertexBuffer[i] = default;
}
var indexBuffer = DstEntityManager.AddBuffer <LocalTriangleIndexElement>(e);
}
protected override void OnUpdate()
{
Entities.ForEach((DeformationsSampleAuthoring deformMesh, SkinnedMeshRenderer renderer) =>
{
var entity = GetPrimaryEntity(renderer);
// Only execute this if we have a valid skinning setup
var bones = renderer.bones;
var hasSkinning = bones.Length > 0 && renderer.sharedMesh.bindposes.Length > 0;
if (hasSkinning)
{
// Setup Reference to root
var rootBone = renderer.rootBone ? renderer.rootBone : renderer.transform;
var rootEntity = GetPrimaryEntity(rootBone);
DstEntityManager.AddComponentData(entity, new RootEntity {
Value = rootEntity
});
// World to local is required for root space conversion of the SkinMatrices
DstEntityManager.AddComponent <WorldToLocal>(rootEntity);
DstEntityManager.AddComponent <RootTag>(rootEntity);
DstEntityManager.AddBuffer <BoneEntity>(entity);
var boneEntityArray = DstEntityManager.GetBuffer <BoneEntity>(entity);
boneEntityArray.ResizeUninitialized(bones.Length);
for (int boneIndex = 0; boneIndex < bones.Length; ++boneIndex)
{
var bone = renderer.bones[boneIndex];
var boneEntity = GetPrimaryEntity(bone);
boneEntityArray[boneIndex] = new BoneEntity {
Value = boneEntity
};
}
// Store the bindpose for each bone
DstEntityManager.AddBuffer <BindPose>(entity);
var bindPoseArray = DstEntityManager.GetBuffer <BindPose>(entity);
bindPoseArray.ResizeUninitialized(bones.Length);
for (int boneIndex = 0; boneIndex != bones.Length; ++boneIndex)
{
var bindPose = renderer.sharedMesh.bindposes[boneIndex];
bindPoseArray[boneIndex] = new BindPose {
Value = bindPose
};
}
// Add tags to the bones so we can find them later
// when computing the SkinMatrices
for (int boneIndex = 0; boneIndex < bones.Length; ++boneIndex)
{
var bone = renderer.bones[boneIndex];
var boneEntity = GetPrimaryEntity(bone);
DstEntityManager.AddComponentData(boneEntity, new BoneTag());
}
}
// Override the material color of the deformation materials
var c = deformMesh.Color.linear;
var color = new float4(c.r, c.g, c.b, c.a);
foreach (var rendererEntity in GetEntities(renderer))
{
if (DstEntityManager.HasComponent <RenderMesh>(rendererEntity))
{
DstEntityManager.AddComponentData(rendererEntity, new HDRPMaterialPropertyBaseColor {
Value = color
});
}
}
});
}
protected override void OnUpdate()
{
var materials = new List <Material>(10);
var context = new RenderMeshConversionContext(DstEntityManager, this)
{
AttachToPrimaryEntityForSingleMaterial = false,
};
Entities.ForEach((SkinnedMeshRenderer meshRenderer) =>
{
meshRenderer.GetSharedMaterials(materials);
foreach (var material in materials)
{
if (material == null)
{
continue;
}
var supportsSkinning = material.HasProperty(s_SkinMatrixIndexProperty) || material.HasProperty(s_ComputeMeshIndexProperty);
if (!supportsSkinning)
{
string errorMsg = "";
errorMsg += $"Shader [{material.shader.name}] on [{meshRenderer.name}] does not support skinning. This can result in incorrect rendering.{System.Environment.NewLine}";
errorMsg += $"Please see documentation for Linear Blend Skinning Node and Compute Deformation Node in Shader Graph.{System.Environment.NewLine}";
Debug.LogWarning(errorMsg, meshRenderer);
}
}
var mesh = meshRenderer.sharedMesh;
var root = meshRenderer.rootBone ? meshRenderer.rootBone : meshRenderer.transform;
var hasSkinning = mesh == null ? false : mesh.boneWeights.Length > 0 && mesh.bindposes.Length > 0;
var hasBlendShapes = mesh == null ? false : mesh.blendShapeCount > 0;
var deformedEntity = GetPrimaryEntity(meshRenderer);
// Convert Renderers as normal MeshRenderers.
// No need to process light maps as skinned objects are never light mapped.
context.Convert(meshRenderer, mesh, materials, root);
foreach (var rendererEntity in GetEntities(meshRenderer))
{
if (DstEntityManager.HasComponent <RenderMesh>(rendererEntity))
{
// Add relevant deformation tags to converted render entities and link them to the DeformedEntity.
#if ENABLE_COMPUTE_DEFORMATIONS
DstEntityManager.AddComponentData(rendererEntity, new DeformedMeshIndex());
#endif
DstEntityManager.AddComponentData(rendererEntity, new DeformedEntity {
Value = deformedEntity
});
DstEntityManager.AddComponentData(rendererEntity, new RenderBounds {
Value = meshRenderer.localBounds.ToAABB()
});
if (hasSkinning)
{
DstEntityManager.AddComponent <SkinningTag>(rendererEntity);
}
if (hasBlendShapes)
{
DstEntityManager.AddComponent <BlendShapeTag>(rendererEntity);
}
}
}
// Fill the blend shape weights.
if (hasBlendShapes && !DstEntityManager.HasComponent <BlendShapeWeight>(deformedEntity))
{
DstEntityManager.AddBuffer <BlendShapeWeight>(deformedEntity);
var weights = DstEntityManager.GetBuffer <BlendShapeWeight>(deformedEntity);
weights.ResizeUninitialized(meshRenderer.sharedMesh.blendShapeCount);
for (int i = 0; i < weights.Length; ++i)
{
weights[i] = new BlendShapeWeight {
Value = meshRenderer.GetBlendShapeWeight(i)
};
}
}
// Fill the skin matrices with bindpose skin matrices.
if (hasSkinning && !DstEntityManager.HasComponent <SkinMatrix>(deformedEntity))
{
var bones = meshRenderer.bones;
var rootMatrixInv = root.localToWorldMatrix.inverse;
DstEntityManager.AddBuffer <SkinMatrix>(deformedEntity);
var skinMatrices = DstEntityManager.GetBuffer <SkinMatrix>(deformedEntity);
skinMatrices.ResizeUninitialized(bones.Length);
for (int i = 0; i < bones.Length; ++i)
{
var bindPose = meshRenderer.sharedMesh.bindposes[i];
var boneMatRootSpace = math.mul(rootMatrixInv, bones[i].localToWorldMatrix);
var skinMatRootSpace = math.mul(boneMatRootSpace, bindPose);
skinMatrices[i] = new SkinMatrix {
Value = new float3x4(skinMatRootSpace.c0.xyz, skinMatRootSpace.c1.xyz, skinMatRootSpace.c2.xyz, skinMatRootSpace.c3.xyz)
};
}
}
});
context.EndConversion();
}
void ConvertAttahments(RigBasedAssetAuthoring assetAuthoring, Entity assetEntity, RigComponent rigComponent, BlobAssetReference <RigDefinition> rig)
{
var attachmentInfos = new List <AttachmentData>();
var rigComponentBones = new List <Transform>(rigComponent.Bones);
for (int nBone = 0; nBone < rigComponentBones.Count; nBone++)
{
var localBone = rigComponentBones[nBone];
for (int nChild = 0; nChild < localBone.childCount; nChild++)
{
var child = localBone.GetChild(nChild);
// Ignore children that are also bones
if (rigComponentBones.Contains(child))
{
// GameDebug.Log("bone" + child + " should not be attached");
continue;
}
attachmentInfos.Add(new AttachmentData {
go = child.gameObject,
boneIndex = nBone,
});
}
}
if (attachmentInfos.Count > 0)
{
DstEntityManager.AddBuffer <RigBasedAsset.Attachment>(assetEntity);
}
// Find objects attached to bones
for (int i = 0; i < attachmentInfos.Count; i++)
{
var attachmentInfo = attachmentInfos[i];
var attachmentEntity = GetPrimaryEntity(attachmentInfo.go);
var assetAttachments = DstEntityManager.GetBuffer <RigBasedAsset.Attachment>(assetEntity);
assetAttachments.Add(new RigBasedAsset.Attachment()
{
Value = attachmentEntity
});
DstEntityManager.AddComponentData(attachmentEntity, new RigAttacher.AttachEntity()
{
Value = attachmentEntity,
});
// Remove from parent
if (DstEntityManager.HasComponent <Parent>(attachmentEntity))
{
DstEntityManager.RemoveComponent <Parent>(attachmentEntity);
}
if (DstEntityManager.HasComponent <LocalToParent>(attachmentEntity))
{
DstEntityManager.RemoveComponent <LocalToParent>(attachmentEntity);
}
if (!DstEntityManager.HasComponent <Static>(attachmentEntity))
{
DstEntityManager.AddComponent <Static>(attachmentEntity);
}
// Add rig attacher
var boneRef = RuntimeBoneReference.Default;
boneRef.BoneIndex = attachmentInfo.boneIndex;
boneRef.ReferenceRig = rig;
RigAttacher.AddRigAttacher(attachmentEntity, DstEntityManager, boneRef);
GameDebug.Log(" Found attrachment:{0} on bone:{1} rig:{2}", attachmentInfo.go, boneRef.BoneIndex, rigComponent);
}
}
