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);
}
});
}
protected override void OnUpdate()
{
Entities.ForEach((UnityEngine.RectTransform urc) =>
{
var e = GetPrimaryEntity(urc);
var ucanvas = urc.gameObject.GetComponent <UnityEngine.Canvas>();
if (ucanvas != null && ucanvas)
{
ConvertCanvas(ucanvas, e, urc);
}
else
{
DstEntityManager.AddComponentData(e, new Tiny.UI.RectTransform
{
AnchorMin = urc.anchorMin,
AnchorMax = urc.anchorMax,
SizeDelta = urc.sizeDelta,
AnchoredPosition = urc.anchoredPosition,
Pivot = urc.pivot,
SiblingIndex = urc.GetSiblingIndex()
});
DstEntityManager.AddComponentData(e, new RectParent()
{
Value = GetPrimaryEntity(urc.parent)
});
DstEntityManager.AddComponent <Tiny.UI.RectTransform>(e);
DstEntityManager.AddComponent <RectTransformResult>(e);
}
});
}
protected override void OnUpdate()
{
// UI text conversion
Entities.ForEach((TextMeshProUGUI displayText) =>
{
// We are converting an entity (textEntity) and creating another (eSubText).
// Why?
// We want to use the Rectangle Transform system to also position text, rather
// than introduce something special. So we need a parent element that is the frame
// of the text (textEntity) and a child element that has a pivet on the text string
// itself. Systems later will process the child element.
var textEntity = GetPrimaryEntity(displayText);
// Sub-text child transform
SceneSection sceneSection = DstEntityManager.GetSharedComponentData <SceneSection>(textEntity);
var eSubText = DstEntityManager.CreateEntity();
DstEntityManager.AddSharedComponentData(eSubText, sceneSection);
DstEntityManager.AddComponentData(eSubText, new Tiny.UI.RectTransform
{
AnchorMin = 0.5f,
AnchorMax = 0.5f,
SizeDelta = 1f,
AnchoredPosition = 0f,
Pivot = 0.5f
});
DstEntityManager.AddComponentData(eSubText, new UIName()
{
Name = displayText.name
});
DstEntityManager.AddComponentData(eSubText, new RectParent()
{
Value = textEntity
});
DstEntityManager.AddComponentData(eSubText, new Unity.Tiny.Rendering.CameraMask
{
mask = (ulong)(1 << displayText.gameObject.layer)
});
DstEntityManager.AddComponent <RectTransformResult>(eSubText);
var fontAsset = GetPrimaryEntity(displayText.font);
DstEntityManager.AddComponentData(eSubText, new Tiny.Text.TextRenderer
{
FontMaterial = fontAsset,
MeshColor = displayText.color.linear.ToTiny(),
Size = displayText.fontSize * 10,
HorizontalAlignment = ConvertHorizontalAlignment(displayText.alignment),
VerticalAlignment = ConvertVerticalAlignment(displayText.alignment),
});
var text = displayText.text;
DstEntityManager.AddBufferFromString <TextRendererString>(eSubText, text);
DstEntityManager.AddComponent <LocalToWorld>(eSubText);
});
}
protected override void OnUpdate()
{
Entities.ForEach((UnityEngine.Texture2D texture) =>
{
var entity = GetPrimaryEntity(texture);
string textPath = AssetDatabase.GetAssetPath(texture);
TextureImporter importer = (TextureImporter)TextureImporter.GetAtPath(textPath);
TextureImporterSettings textureImporterSettings = new TextureImporterSettings();
importer.ReadTextureSettings(textureImporterSettings);
DstEntityManager.AddComponentData(entity, new Image2D()
{
imagePixelWidth = texture.width,
imagePixelHeight = texture.height,
status = ImageStatus.Invalid,
flags = Texture2DExportUtils.GetTextureFlags(textureImporterSettings, texture)
});
DstEntityManager.AddComponent <Image2DLoadFromFile>(entity);
var exportGuid = GetGuidForAssetExport(texture);
DstEntityManager.AddComponentData(entity, new Image2DLoadFromFileGuids()
{
imageAsset = exportGuid,
maskAsset = Guid.Empty
});
});
}
protected override void OnUpdate( )
{
Entities.ForEach(( OwnerControlledPhysicsBody ownerControlledPhysicsBody ) =>
{
var entity = GetPrimaryEntity(ownerControlledPhysicsBody);
var physicsBodyPrefab = GetPrimaryEntity(ownerControlledPhysicsBody.physicsBody);
DstEntityManager.AddComponent <PhysicsSnapshot>(entity);
DstEntityManager.AddComponent <PhysicsSnapshotBufferElement>(entity);
DstEntityManager.AddComponentData(entity, new MassFromPhysicsBody
{
Value = DstEntityManager.GetComponentData <PhysicsMass>(physicsBodyPrefab)
});
DstEntityManager.AddComponentData(entity, new PhysicsBodyVelocity
{
Value = DstEntityManager.GetComponentData <PhysicsVelocity>(physicsBodyPrefab)
});
DstEntityManager.AddComponentData(entity, new PhysicsSnapshotSyncData
{
SendIntervalInSeconds = 1f / ownerControlledPhysicsBody.stateUpdatesToSendPerSecond
});
DstEntityManager.AddComponentData(entity, new SimulationBodyPrefabReference
{
Value = physicsBodyPrefab
});
DstEntityManager.AddComponent <SimulationBodyOwner>(entity);
});
}
protected override void OnUpdate()
{
// only difference between toggle and button in dots runtime is the additional Toggleable component
Entities.ForEach((RectTransform urc, Button button) =>
{
var e = GetPrimaryEntity(button);
var buttonColors = button.colors;
DstEntityManager.AddComponentData(e, new Selectable
{
Graphic = GetPrimaryEntity(button.targetGraphic),
IsInteractable = button.IsInteractable(),
NormalColor = buttonColors.normalColor.linear.ToTiny(),
HighlightedColor = buttonColors.highlightedColor.linear.ToTiny(),
PressedColor = buttonColors.pressedColor.linear.ToTiny(),
SelectedColor = buttonColors.selectedColor.linear.ToTiny(),
DisabledColor = buttonColors.disabledColor.linear.ToTiny(),
});
var uiName = new UIName()
{
Name = button.name
};
DstEntityManager.AddComponentData(e, uiName);
if (button.name.Length > uiName.Name.Capacity)
{
Debug.LogWarning($"UIName '{button.name}' is too long and is being truncated. It may not be found correctly at runtime.");
}
DstEntityManager.AddComponent <UIState>(e);
});
}
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()
{
var boards = GetEntityQuery(typeof(BoardAuthoring)).ToComponentArray <BoardAuthoring>();
foreach (var board in boards)
{
for (var i = 0; i < board.ColumnCount; i++)
{
for (var j = 0; j < board.RowCount; j++)
{
var gemEntity = CreateAdditionalEntity(board);
DstEntityManager.AddComponentData(gemEntity, new GridPositionComponent()
{
Value = new float2(i, j)
});
DstEntityManager.AddComponentData(gemEntity, new GemPrefabBufferRefComponent()
{
PrefabsRef = GetPrimaryEntity(board.GemPrefabs)
});
DstEntityManager.AddComponent(gemEntity, typeof(EmptyComponent));
DstEntityManager.AddComponent(gemEntity, typeof(GemType));
}
}
}
}
private void ConvertButton(Button button)
{
var entity = GetPrimaryEntity(button);
DstEntityManager.AddComponent(entity, typeof(Controls.Button));
ConvertSelectable(button);
}
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
});
}
protected override void OnUpdate()
{
Entities.ForEach((UnityEngine.SkinnedMeshRenderer uSkinnedMeshRenderer) =>
{
var sharedMaterials = uSkinnedMeshRenderer.sharedMaterials;
UnityEngine.Mesh uMesh = uSkinnedMeshRenderer.sharedMesh;
var meshEntity = GetPrimaryEntity(uMesh);
for (int i = 0; i < uMesh.subMeshCount; i++)
{
// Find the target material entity to be used for this submesh
Entity targetMaterial = MeshRendererConversion.FindTargetMaterialEntity(this, sharedMaterials, i);
var isLit = DstEntityManager.HasComponent <LitMaterial>(targetMaterial);
var isSimple = DstEntityManager.HasComponent <SimpleMaterial>(targetMaterial);
if (isSimple)
{
Debug.Log("Unlit material was not supported in SkinnedMeshRenderer:" + uMesh.name);
continue;
}
if (isLit)
{
if (uSkinnedMeshRenderer.bones.Length > MeshSkinningConfig.GPU_SKINNING_MAX_BONES)
{
DstEntityManager.AddComponent <NeedGenerateGPUSkinnedMeshRenderer>(meshEntity);
}
DstEntityManager.AddComponent <LitMeshRenderData>(meshEntity);
// Remove simple data if it was there, we don't need it
DstEntityManager.RemoveComponent <SimpleMeshRenderData>(meshEntity);
}
}
});
}
protected override void OnUpdate()
{
Entities.ForEach((VehicleMechanics m) =>
{
var entity = GetPrimaryEntity(m);
foreach (var wheel in m.wheels)
{
var wheelEntity = GetPrimaryEntity(wheel);
DstEntityManager.AddComponentData(wheelEntity, new Wheel
{
Vehicle = entity,
GraphicalRepresentation = GetPrimaryEntity(wheel.transform.GetChild(0)), // assume wheel has a single child with rotating graphic
// TODO assume for now that driving/steering wheels also appear in this list
UsedForSteering = (byte)(m.steeringWheels.Contains(wheel) ? 1 : 0),
UsedForDriving = (byte)(m.driveWheels.Contains(wheel) ? 1 : 0)
});
}
DstEntityManager.AddComponent <VehicleBody>(entity);
DstEntityManager.AddComponentData(entity, new VehicleConfiguration
{
wheelBase = m.wheelBase,
wheelFrictionRight = m.wheelFrictionRight,
wheelFrictionForward = m.wheelFrictionForward,
wheelMaxImpulseRight = m.wheelMaxImpulseRight,
wheelMaxImpulseForward = m.wheelMaxImpulseForward,
suspensionLength = m.suspensionLength,
suspensionStrength = m.suspensionStrength,
suspensionDamping = m.suspensionDamping,
invWheelCount = 1f / m.wheels.Count,
drawDebugInformation = (byte)(m.drawDebugInformation ? 1 : 0)
});
});
}
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,
ObstacleAversionDistance = boidAuthoring.ObstacleAversionDistance,
MoveSpeed = boidAuthoring.MoveSpeed
});
// Remove default transform system components
DstEntityManager.RemoveComponent <Translation>(entity);
DstEntityManager.RemoveComponent <Rotation>(entity);
// Add world render bounds components so they do not need to be added at initialization time.
DstEntityManager.AddComponent(entity, ComponentType.ChunkComponent <ChunkWorldRenderBounds>());
DstEntityManager.AddComponent <WorldRenderBounds>(entity);
});
}
protected override void OnUpdate()
{
Entities.ForEach((DotsNavAgent agent, DotsNavLocalAvoidanceAgent localAvoidanceAgent) =>
{
var tree = agent.Plane.Entity;
var entity = GetPrimaryEntity(localAvoidanceAgent);
DstEntityManager.AddComponentData(entity, new DynamicTreeElementComponent {
Tree = tree
});
DstEntityManager.AddComponentData(entity, new ObstacleTreeAgentComponent {
Tree = tree
});
DstEntityManager.AddComponentData(entity, new RVOSettingsComponent
{
NeighbourDist = localAvoidanceAgent.NeighbourDist,
TimeHorizon = localAvoidanceAgent.TimeHorizon,
TimeHorizonObst = localAvoidanceAgent.TimeHorizonObst,
MaxNeighbours = localAvoidanceAgent.MaxNeighbours,
});
DstEntityManager.AddComponentData(entity, new MaxSpeedComponent {
Value = localAvoidanceAgent.MaxSpeed
});
DstEntityManager.AddComponent <VelocityObstacleComponent>(entity);
DstEntityManager.AddComponent <PreferredVelocityComponent>(entity);
DstEntityManager.AddComponent <VelocityComponent>(entity);
});
}
protected override void OnUpdate()
{
Entities.ForEach((TextMeshProUGUI text) => {
var entity = GetPrimaryEntity(text);
DstEntityManager.AddComponentData(entity, new AppliedColor {
Value = text.color
});
DstEntityManager.AddComponentData(entity, new TextFontID {
Value = text.font.GetInstanceID()
});
DstEntityManager.AddComponentData(entity, new TextOptions {
Size = (ushort)text.fontSize,
Style = text.fontStyle,
Alignment = text.alignment.FromTextAnchor()
});
DstEntityManager.AddComponentData(entity, new LinkedMaterialEntity {
Value = GetPrimaryEntity(text.materialForRendering)
});
// Marks that the text element needs to be built
DstEntityManager.AddComponent <BuildUIElementTag>(entity);
AddTextData(entity, text.text);
if (!text.gameObject.activeInHierarchy || !text.enabled)
{
DstEntityManager.AddComponent <UpdateVertexColorTag>(entity);
}
});
}
protected override void OnUpdate()
{
Entities.ForEach((UnityEngine.SkinnedMeshRenderer uSkinnedMeshRenderer) =>
{
var sharedMaterials = uSkinnedMeshRenderer.sharedMaterials;
UnityEngine.Mesh uMesh = uSkinnedMeshRenderer.sharedMesh;
var meshEntity = GetPrimaryEntity(uMesh);
for (int i = 0; i < uMesh.subMeshCount; i++)
{
// Find the target material entity to be used for this submesh
Entity targetMaterial = MeshRendererConversion.FindTargetMaterialEntity(this, sharedMaterials, i);
if (DstEntityManager.HasComponent <LitMaterial>(targetMaterial))
{
DstEntityManager.AddComponent <LitMeshRenderData>(meshEntity);
DstEntityManager.RemoveComponent <SimpleMeshRenderData>(meshEntity);
}
else if (DstEntityManager.HasComponent <SimpleMaterial>(targetMaterial))
{
if (!DstEntityManager.HasComponent <LitMeshRenderData>(meshEntity))
{
DstEntityManager.AddComponent <SimpleMeshRenderData>(meshEntity);
}
}
}
});
}
Entity ConstructScreenSpaceCamera(Entity e, UnityEngine.RectTransform urc)
{
SceneSection sceneSection = DstEntityManager.GetSharedComponentData <SceneSection>(e);
Entity eCam = DstEntityManager.CreateEntity();
DstEntityManager.AddSharedComponentData(eCam, sceneSection);
var sizeDelta = urc.sizeDelta;
var camera = new Unity.Tiny.Rendering.Camera
{
clearFlags = Tiny.Rendering.CameraClearFlags.DepthOnly,
backgroundColor = new Unity.Tiny.Color(0, 0, 0, 0),
viewportRect = new Tiny.Rect(0, 0, 1, 1),
depth = 0.0f,
fov = sizeDelta.y * 0.5f,
mode = ProjectionMode.Orthographic,
clipZNear = 0,
clipZFar = 102,
aspect = sizeDelta.x / sizeDelta.y
};
DstEntityManager.AddComponentData(eCam, camera);
DstEntityManager.AddComponentData(eCam,
new Unity.Tiny.Rendering.CameraMask {
mask = (ulong)(1 << urc.gameObject.layer)
});
// For CameraSettings2D
float3 customSortAxisSetting = new float3(0, 0, 1.0f);
if (UnityEngine.Rendering.GraphicsSettings.transparencySortMode ==
UnityEngine.TransparencySortMode.CustomAxis)
{
customSortAxisSetting = UnityEngine.Rendering.GraphicsSettings.transparencySortAxis;
}
DstEntityManager.AddComponentData(eCam, new Unity.Tiny.Rendering.CameraSettings2D
{
customSortAxis = customSortAxisSetting
});
// tag the camera as auto aspect
DstEntityManager.AddComponentData(eCam, new CameraAutoAspectFromNode {
Node = Entity.Null
});
DstEntityManager.AddComponentData(eCam, new LocalToWorld {
Value = float4x4.identity
});
DstEntityManager.AddComponentData(eCam,
new Translation {
Value = new float3(sizeDelta.x / 2, sizeDelta.y / 2, -10)
});
DstEntityManager.AddComponentData(eCam, new Rotation {
Value = quaternion.identity
});
DstEntityManager.AddComponent <UICamera>(eCam);
return(eCam);
}
// Adds this to every entity since it is a universal system
protected override void OnUpdate()
{
Entities.ForEach((Transform gameObject) =>
{
var entity = GetPrimaryEntity(gameObject);
DstEntityManager.AddComponent <TagsBitField>(entity);
});
}
protected override void OnUpdate()
{
Entities.ForEach((Oscillate_Authoring oscillate) =>
{
var entity = GetPrimaryEntity(oscillate);
DstEntityManager.AddComponent <Oscillate>(entity);
});
}
protected override void OnUpdate()
{
Entities.ForEach((Transform t) =>
{
var e = GetPrimaryEntity(t);
DstEntityManager.AddComponent <EcsTestData>(e);
});
}
protected override void OnUpdate()
{
Entities.ForEach((Transform t) =>
{
var e = CreateAdditionalEntity(t);
DstEntityManager.AddComponent <TestEntityData>(e);
});
}
protected override void OnUpdate()
{
Entities.ForEach((VehicleMechanics m) =>
{
var entity = GetPrimaryEntity(m);
foreach (var wheel in m.wheels)
{
var wheelEntity = GetPrimaryEntity(wheel);
// Assumed hierarchy:
// - chassis
// - mechanics
// - suspension
// - wheel (rotates about yaw axis and translates along suspension up)
// - graphic (rotates about pitch axis)
RigidTransform worldFromSuspension = new RigidTransform
{
pos = wheel.transform.parent.position,
rot = wheel.transform.parent.rotation
};
RigidTransform worldFromChassis = new RigidTransform
{
pos = wheel.transform.parent.parent.parent.position,
rot = wheel.transform.parent.parent.parent.rotation
};
var chassisFromSuspension = math.mul(math.inverse(worldFromChassis), worldFromSuspension);
DstEntityManager.AddComponentData(wheelEntity, new Wheel
{
Vehicle = entity,
GraphicalRepresentation = GetPrimaryEntity(wheel.transform.GetChild(0)), // assume wheel has a single child with rotating graphic
// TODO assume for now that driving/steering wheels also appear in this list
UsedForSteering = (byte)(m.steeringWheels.Contains(wheel) ? 1 : 0),
UsedForDriving = (byte)(m.driveWheels.Contains(wheel) ? 1 : 0),
ChassisFromSuspension = chassisFromSuspension
});
}
DstEntityManager.AddComponent <VehicleBody>(entity);
DstEntityManager.AddComponentData(entity, new VehicleConfiguration
{
wheelBase = m.wheelBase,
wheelFrictionRight = m.wheelFrictionRight,
wheelFrictionForward = m.wheelFrictionForward,
wheelMaxImpulseRight = m.wheelMaxImpulseRight,
wheelMaxImpulseForward = m.wheelMaxImpulseForward,
suspensionLength = m.suspensionLength,
suspensionStrength = m.suspensionStrength,
suspensionDamping = m.suspensionDamping,
invWheelCount = 1f / m.wheels.Count,
drawDebugInformation = (byte)(m.drawDebugInformation ? 1 : 0)
});
});
}
protected override void OnUpdate()
{
Entities
.ForEach((LostBoxAuthoring lostBox) =>
{
var entity = GetPrimaryEntity(lostBox);
DstEntityManager.AddComponent(entity, typeof(LostBoxComponent));
});
}
private void ConvertSprite(Sprite sprite)
{
var assetEntity = GetPrimaryEntity(sprite);
DstEntityManager.AddSharedComponentData(assetEntity, new SpriteAsset {
Value = sprite
});
DstEntityManager.AddComponent <SpriteVertexData>(assetEntity);
}
protected override void OnUpdate()
{
Entities.ForEach((Sink sink, ParticleSystem ps, ParticleSystemRenderer psr) =>
{
// Every scene needs a Sink, so it can drive the DAG sorting.
var sinkEntity = GetPrimaryEntity(sink);
DstEntityManager.AddComponent <DagIsStale>(sinkEntity);
DstEntityManager.AddComponentObject(sinkEntity, ps);
DstEntityManager.AddComponentObject(sinkEntity, psr);
});
}
protected override void OnUpdate()
{
Entities.ForEach((UnityEngine.AudioClip audioClip) =>
{
var entity = GetPrimaryEntity(audioClip);
DstEntityManager.AddComponent <AudioClip>(entity);
DstEntityManager.AddComponent <AudioClipLoadFromFile>(entity);
DstEntityManager.AddComponent <AudioClipLoadFromFileAudioFile>(entity);
var exportGuid = GetGuidForAssetExport(audioClip);
DstEntityManager.SetBufferFromString <AudioClipLoadFromFileAudioFile>(entity, "Data/" + exportGuid.ToString("N"));
});
}
protected override void OnUpdate()
{
Entities.ForEach((AddFour_Authoring comp) =>
{
var entity = GetPrimaryEntity(comp);
DstEntityManager.AddComponent <AddFour>(entity);
if (!DstEntityManager.HasComponent <AddSomething>(entity))
{
DstEntityManager.AddComponent <AddSomething>(entity);
}
});
}
protected override void OnUpdate()
{
Entities.ForEach((UnityEngine.MeshRenderer uMeshRenderer) =>
{
if ((uMeshRenderer.hideFlags & HideFlags.HideAndDontSave) == HideFlags.HideAndDontSave)
{
return;
}
UnityEngine.Mesh uMesh = uMeshRenderer.gameObject.GetComponent <MeshFilter>().sharedMesh;
var sharedMaterials = uMeshRenderer.sharedMaterials;
var meshEntity = GetPrimaryEntity(uMesh);
for (int i = 0; i < uMesh.subMeshCount; i++)
{
// Find the target material entity to be used for this submesh
Entity targetMaterial = FindTargetMaterialEntity(this, sharedMaterials, i);
var isLit = DstEntityManager.HasComponent <LitMaterial>(targetMaterial);
var isSimple = DstEntityManager.HasComponent <SimpleMaterial>(targetMaterial);
// We only handle these two materials here
if (isLit || isSimple)
{
CheckForSubMeshLimitations(uMesh, i);
Entity subMeshRenderer = ConvertSubmesh(this, uMeshRenderer, uMesh, meshEntity, i, targetMaterial);
if (isLit)
{
DstEntityManager.AddComponent <LitMeshRenderer>(subMeshRenderer);
DstEntityManager.AddComponent <LitMeshRenderData>(meshEntity);
// Remove simple data if it was there, we don't need it
DstEntityManager.RemoveComponent <SimpleMeshRenderData>(meshEntity);
}
else
{
DstEntityManager.AddComponent <SimpleMeshRenderer>(subMeshRenderer);
// Remove simple data if we have lit already
if (!DstEntityManager.HasComponent <LitMeshRenderData>(meshEntity))
{
DstEntityManager.AddComponent <SimpleMeshRenderData>(meshEntity);
}
}
}
}
});
}
private void ConvertGraphic(Graphic graphic)
{
var entity = GetPrimaryEntity(graphic);
DstEntityManager.AddComponentData(entity, new VertexColorValue()
{
Value = graphic.color.ToFloat4()
});
DstEntityManager.AddComponentData(entity, new VertexColorMultiplier()
{
Value = new float4(1.0f, 1.0f, 1.0f, 1.0f)
});
DstEntityManager.AddComponent(entity, typeof(ElementVertexPointerInMesh));
}
protected override void OnUpdate()
{
Entities
.ForEach((PlayerAuthoring playerAuthoring) =>
{
var entity = GetPrimaryEntity(playerAuthoring);
var cameraFollowComponent = new CameraFollowComponent
{
CameraFollowOffset = new float3(0, 10, -10),
CameraSmoothSpeed = 0.25f
};
DstEntityManager.AddComponent(entity, typeof(MovementComponent));
DstEntityManager.AddComponentData(entity, cameraFollowComponent);
});
}
