public void Iteration(ref EntityChunk chunk, int index)
{
if (chunk.TryGetComponent(index, out C_UICanvas canvas))
{
canvas.canvas.TriggerMouseEvent(mouseData);
}
}
public void Iteration(ref EntityChunk chunk, int index)
{
if (chunk.TryGetComponent(index, out C_Position position))
{
position.value.y += (MathUtils.Sin((float)EntygineApp.EngineTime)) * 0.01f;
chunk.SetComponent(index, position);
}
}
public void Iteration(ref EntityChunk chunk, int index)
{
chunk.TryGetComponent(index, out C_Camera camera);
Vector2 floatingSize = (ImGui.GetContentRegionAvail() - imageSize) / 2f;
ImGui.SetCursorPos(ImGui.GetCursorPos() + floatingSize);
ImGui.Image((IntPtr)camera.cameraData.FinalFramebuffer.ColorBuffer, imageSize, new Vector2(0, 0), new Vector2(1, -1));
}
public void Iteration(ref EntityChunk chunk)
{
if (!chunk.TryGetComponents <C_Camera>(out ComponentArray cameras) || !chunk.TryGetComponents <C_Transform>(out ComponentArray transforms))
{
return;
}
CameraData[] cameraDatas = new CameraData[chunk.Count];
Matrix4[] cameraTransforms = new Matrix4[chunk.Count];
for (int c = 0; c < chunk.Count; c++)
{
C_Camera cam = cameras.Get <C_Camera>(c);
if (cam.cameraData.Framebuffer == null)
{
Vec2i res = AppScreen.Resolution;
var fb = new Framebuffer(res, "Camera FBO");
fb.AddColorBuffer(true);
fb.AddDepthBuffer(true);
cam.cameraData.SetFramebuffer(fb);
var ffb = new Framebuffer(res, "Camera Final FBO");
ffb.AddColorBuffer(false);
cam.cameraData.SetFinalFramebuffer(ffb);
chunk.SetComponent(c, cam);
}
else if (cam.cameraData.Framebuffer.Size != AppScreen.Resolution)
{
cam.cameraData.Framebuffer.ChangeSize(AppScreen.Resolution);
cam.cameraData.FinalFramebuffer.ChangeSize(AppScreen.Resolution);
}
//if(cam.cameraData.ColorTargetTexture == null)
//{
// Vec2i res = AppScreen.Resolution;
// cam.cameraData.SetColorTargetTexture(new Texture2D(res.x, res.y, "Camera Color FBO"));
// cam.cameraData.SetDepthTargetTexture(new DepthTexture(res.x, res.y, "Camera Depth"));
// chunk.SetComponent(c, cam);
//}
//else if (cam.cameraData.ColorTargetTexture.Size != AppScreen.Resolution)
//{
// cam.cameraData.ColorTargetTexture.SetSize(AppScreen.Resolution);
// cam.cameraData.DepthTargetTexture.SetSize(AppScreen.Resolution);
//}
cameraDatas[c] = cam.cameraData;
cameraTransforms[c] = transforms.Get <C_Transform>(c).value;
}
RenderPipelineCore.Draw(cameraDatas, cameraTransforms);
}
public void Iteration(ref EntityChunk chunk)
{
if (!RenderPipelineCore.TryGetContext(out UICanvasRenderData canvasData))
{
return;
}
canvasData.ClearCanvas();
for (int i = 0; i < chunk.Count; i++)
{
if (chunk.TryGetComponent(i, out C_UICanvas canvas))
{
canvasData.AddCanvas(canvas.canvas);
}
}
}
protected override void OnDraw()
{
EntityWorld world = EntityWorld.Active;
StructArray <EntityChunk> chunks = world.EntityManager.GetChunks();
for (int i = 0; i < chunks.Count; i++)
{
ref EntityChunk chunk = ref chunks[i];
bool open = ImGui.TreeNode($"[{i}] Chunk: {chunk.Count}/{chunk.Capacity}");
if (ImGui.IsItemHovered())
{
ImGui.SetTooltip(chunk.Archetype.ToString());
}
if (open)
{
ImGuiTableFlags tFlags = ImGuiTableFlags.RowBg | ImGuiTableFlags.Resizable;
if (ImGui.BeginTable("Entities", 2, tFlags))
{
ImGui.TableSetupColumn("Id");
ImGui.TableSetupColumn("Version");
ImGui.TableHeadersRow();
for (int e = 0; e < chunk.Count; e++)
{
Entity entity = chunk.GetEntity(e);
ImGui.TableNextRow();
ImGui.TableNextColumn();
bool isSelected = ObjectSelections.CurrentObj?.Equals(entity) ?? false;
if (ImGui.Selectable($"##{e}", isSelected, ImGuiSelectableFlags.SpanAllColumns))
{
ObjectSelections.SelectObject(entity);
}
ImGui.SameLine();
ImGui.Text(entity.id.ToString());
ImGui.TableNextColumn();
ImGui.Text(entity.version.ToString());
}
ImGui.Separator();
ImGui.EndTable();
}
ImGui.TreePop();
}
}
public void Iteration(ref EntityChunk chunk, int index)
{
if (!chunk.GetEntity(index).Equals(entity))
{
return;
}
chunk.GetComponentsFromEntity(entity, out List <IComponent> components);
for (int i = 0; i < components.Count; i++)
{
var currComp = components[i];
if (ImGui.CollapsingHeader(currComp.GetType().Name, ImGuiTreeNodeFlags.DefaultOpen))
{
var drawer = drawers.QueryDrawer(currComp);
drawer.SetComponentContext(currComp);
drawer.Draw();
}
}
}
internal void SpawnEntites(int _Chunk)
{
EntityChunk _ToBeSpawned = entitiesToSpawn[_Chunk];
foreach (Entity _Entity in _ToBeSpawned.entitiesToSpawn)
{
if (_Entity._Enemy && _Entity._Pos) //If there is a enemy to spawn and a position to spawn it at.
{
if (PhotonNetwork.IsConnected)
{
PhotonNetwork.InstantiateSceneObject(_Entity._Enemy.name, _Entity._Pos.position, _Entity._Pos.rotation);
photonView.RPC("SetParticles", RpcTarget.All, _Entity._Pos.position, _Entity._Pos.eulerAngles);
}
else
{
Instantiate(_Entity._Enemy, _Entity._Pos.position, _Entity._Pos.rotation);
SetParticles(_Entity._Pos.position, _Entity._Pos.rotation.eulerAngles);
}
}
}
}
public void Iteration(ref EntityChunk chunk)
{
if (!chunk.TryGetSharedComponent(out SC_RenderMesh renderMesh))
{
return;
}
if (!RenderPipelineCore.TryGetContext(out Rendering.GeometryRenderData geometryData))
{
return;
}
if (!geometryData.TryGetRenderMeshGroup(renderMesh.id, out Rendering.MeshRenderGroup group))
{
renderMesh.id = geometryData.CreateRenderMeshGroup(renderMesh.value, out group);
}
else
{
group.MeshRender = renderMesh.value;
}
chunk.SetSharedComponent(renderMesh);
}
public void Iteration(ref EntityChunk chunk, int index)
{
if (!chunk.TryGetComponent(index, out C_EditorCamera editorCamera) || !chunk.TryGetComponent(index, out C_Transform transform))
{
return;
}
editorCamera.speed += speedDelta * deltaTime;
editorCamera.speed = MathHelper.Clamp(editorCamera.speed, 0, 100);
editorCamera.focusDistance -= distDelta * deltaTime * 100;
editorCamera.yaw += rotDelta.X * deltaTime * editorCamera.sensitivity;
editorCamera.pitch += rotDelta.Y * deltaTime * editorCamera.sensitivity;
Vector3 dir = new Vector3(
(float)MathHelper.Cos(MathHelper.DegreesToRadians(editorCamera.yaw)) * (float)MathHelper.Cos(MathHelper.DegreesToRadians(editorCamera.pitch))
, (float)MathHelper.Sin(MathHelper.DegreesToRadians(editorCamera.pitch))
, (float)MathHelper.Sin(MathHelper.DegreesToRadians(editorCamera.yaw)) * (float)MathHelper.Cos(MathHelper.DegreesToRadians(editorCamera.pitch)));
Vector3 right = Vector3.Normalize(Vector3.Cross(dir, Vector3.UnitY));
Vector3 up = Vector3.Normalize(Vector3.Cross(right, dir));
Vector3 posDeltaRelative = -right * posDelta.X + dir * posDelta.Z + Vector3.UnitY * posDelta.Y;
posDeltaRelative *= deltaTime;
editorCamera.focusPoint += posDeltaRelative * editorCamera.speed;
transform.value = Matrix4.LookAt(editorCamera.focusPoint + dir * editorCamera.focusDistance, editorCamera.focusPoint, up);
//DevGizmos.DrawPoint((Vec3f)editorCamera.focusPoint);
DevGizmos.DrawLine((Vec3f)editorCamera.focusPoint, (Vec3f)editorCamera.focusPoint + Vec3f.Right);
chunk.SetComponent(index, transform);
chunk.SetComponent(index, editorCamera);
}
public void Iteration(ref EntityChunk chunk)
{
if (!chunk.TryGetSharedComponent(out SC_RenderMesh renderMesh))
{
return;
}
if (!RenderPipelineCore.TryGetContext(out Rendering.GeometryRenderData geometryData))
{
return;
}
if (geometryData.TryGetRenderMeshGroup(renderMesh.id, out Rendering.MeshRenderGroup group))
{
group.ClearTransforms();
for (int i = 0; i < chunk.Count; i++)
{
if (chunk.TryGetComponent(i, out C_Transform transform))
{
group.AddTransform(transform.value);
}
}
}
}
protected override Task <ResultStatus> DoCommandOverride(ICommandContext commandContext)
{
var contentManager = new ContentManager();
var device = GraphicsDevice.New();
var fallbackMaterial = Material.New(device, new MaterialDescriptor
{
Attributes =
{
Diffuse = new MaterialDiffuseMapFeature(new ComputeTextureColor()),
DiffuseModel = new MaterialDiffuseLambertModelFeature()
}
});
var loadSettings = new ContentManagerLoaderSettings
{
ContentFilter = ContentManagerLoaderSettings.NewContentFilterByType(typeof(Mesh), typeof(Material))
};
IList <Entity> allEntities = new List <Entity>();
if (Parameters.Prefab != null)
{
var prefab = Package.Session.FindAssetFromProxyObject(Parameters.Prefab)?.Asset as PrefabAsset;
if (prefab != null)
{
allEntities = prefab.Hierarchy.Parts.Values.Select(x => x.Entity).ToList();
}
}
var prefabModel = new Model();
//The objective is to create 1 mesh per material/shadow params
//1. We group by materials
//2. Create a mesh per material (might need still more meshes if 16bit indexes or more then 32bit)
var materials = new Dictionary <MaterialInstance, List <EntityChunk> >();
var loadedModel = new List <Model>();
foreach (var subEntity in allEntities)
{
var modelComponent = subEntity.Get <ModelComponent>();
if (modelComponent?.Model == null || (modelComponent.Skeleton != null && modelComponent.Skeleton.Nodes.Length != 1) || !modelComponent.Enabled)
{
continue;
}
var modelAsset = Package.Session.FindAssetFromProxyObject(modelComponent.Model);
if (modelAsset == null)
{
continue;
}
var model = contentManager.Load <Model>(modelAsset.Location, loadSettings);
loadedModel.Add(model);
if (model == null ||
model.Meshes.Any(x => x.Draw.PrimitiveType != PrimitiveType.TriangleList || x.Draw.VertexBuffers == null || x.Draw.VertexBuffers.Length != 1) ||
model.Materials.Any(x => x.Material != null && x.Material.Passes.Any(pass => pass.HasTransparency)) ||
modelComponent.Materials.Values.Any(x => x.Passes.Any(pass => pass.HasTransparency))) //For now we limit only to TriangleList types and interleaved vertex buffers, also we skip transparent
{
commandContext.Logger.Info($"Skipped entity {subEntity.Name} since it's not compatible with PrefabModel.");
continue;
}
for (var index = 0; index < model.Materials.Count; index++)
{
var material = model.Materials[index];
var mat = ExtractMaterialInstance(material, index, modelComponent, fallbackMaterial);
var chunk = new EntityChunk {
Entity = subEntity, Model = model, MaterialIndex = index
};
if (materials.TryGetValue(mat, out var entities))
{
entities.Add(chunk);
}
else
{
materials.Add(mat, new List <EntityChunk> {
chunk
});
}
}
}
foreach (var material in materials)
{
ProcessMaterial(contentManager, material.Value, material.Key, prefabModel);
}
// split the meshes if necessary
prefabModel.Meshes = SplitExtensions.SplitMeshes(prefabModel.Meshes, renderingSettings.DefaultGraphicsProfile > GraphicsProfile.Level_9_3);
//handle boundng box/sphere
var modelBoundingBox = prefabModel.BoundingBox;
var modelBoundingSphere = prefabModel.BoundingSphere;
foreach (var mesh in prefabModel.Meshes)
{
var vertexBuffers = mesh.Draw.VertexBuffers;
if (vertexBuffers.Length > 0)
{
// Compute local mesh bounding box (no node transformation)
var matrix = Matrix.Identity;
mesh.BoundingBox = vertexBuffers[0].ComputeBounds(ref matrix, out mesh.BoundingSphere);
// Compute model bounding box (includes node transformation)
BoundingSphere meshBoundingSphere;
var meshBoundingBox = vertexBuffers[0].ComputeBounds(ref matrix, out meshBoundingSphere);
BoundingBox.Merge(ref modelBoundingBox, ref meshBoundingBox, out modelBoundingBox);
BoundingSphere.Merge(ref modelBoundingSphere, ref meshBoundingSphere, out modelBoundingSphere);
}
mesh.Draw.CompactIndexBuffer();
}
prefabModel.BoundingBox = modelBoundingBox;
prefabModel.BoundingSphere = modelBoundingSphere;
//save
contentManager.Save(Url, prefabModel);
foreach (var model in loadedModel.NotNull())
{
contentManager.Unload(model);
}
device.Dispose();
return(Task.FromResult(ResultStatus.Successful));
}
protected override Task <ResultStatus> DoCommandOverride(ICommandContext commandContext)
{
var contentManager = new ContentManager();
var device = GraphicsDevice.New();
var fallbackMaterial = Material.New(device, new MaterialDescriptor
{
Attributes =
{
Diffuse = new MaterialDiffuseMapFeature(new ComputeTextureColor()),
DiffuseModel = new MaterialDiffuseLambertModelFeature()
}
});
var loadSettings = new ContentManagerLoaderSettings
{
ContentFilter = ContentManagerLoaderSettings.NewContentFilterByType(typeof(Mesh), typeof(Skeleton), typeof(Material), typeof(Prefab))
};
Prefab prefab;
if (Parameters.Prefab == null)
{
prefab = new Prefab();
}
else
{
prefab = contentManager.Load <Prefab>(Parameters.Prefab.Location, loadSettings);
if (prefab == null)
{
throw new Exception("Failed to load prefab.");
}
}
var prefabModel = new Model();
//The objective is to create 1 mesh per material/shadow params
//1. We group by materials
//2. Create a mesh per material (might need still more meshes if 16bit indexes or more then 32bit)
var materials = new Dictionary <MaterialInstance, List <EntityChunk> >();
var validEntities = new List <Entity>();
foreach (var rootEntity in prefab.Entities)
{
//collect sub entities as well
var collected = IterateTree(rootEntity, subEntity => subEntity.GetChildren()).ToArray();
//first pass, check if compatible with prefabmodel
foreach (var subEntity in collected)
{
//todo for now we collect everything with a model component
var modelComponent = subEntity.Get <ModelComponent>();
if (modelComponent?.Model == null || (modelComponent.Skeleton != null && modelComponent.Skeleton.Nodes.Length != 1))
{
continue;
}
var modelAsset = contentManager.Load <Model>(AttachedReferenceManager.GetUrl(modelComponent.Model), loadSettings);
if (modelAsset == null ||
modelAsset.Meshes.Any(x => x.Draw.PrimitiveType != PrimitiveType.TriangleList || x.Draw.VertexBuffers == null || x.Draw.VertexBuffers.Length != 1) ||
modelAsset.Materials.Any(x => x.Material != null && x.Material.HasTransparency) ||
modelComponent.Materials.Values.Any(x => x.HasTransparency)) //For now we limit only to TriangleList types and interleaved vertex buffers, also we skip transparent
{
commandContext.Logger.Info($"Skipped entity {subEntity.Name} since it's not compatible with PrefabModel.");
continue;
}
validEntities.Add(subEntity);
}
}
foreach (var subEntity in validEntities)
{
var modelComponent = subEntity.Get <ModelComponent>();
var modelAsset = contentManager.Load <Model>(AttachedReferenceManager.GetUrl(modelComponent.Model), loadSettings);
for (var index = 0; index < modelAsset.Materials.Count; index++)
{
var material = modelAsset.Materials[index];
var mat = ExtractMaterialInstance(material, index, modelComponent, fallbackMaterial);
var chunk = new EntityChunk {
Entity = subEntity, Model = modelAsset, MaterialIndex = index
};
List <EntityChunk> entities;
if (materials.TryGetValue(mat, out entities))
{
entities.Add(chunk);
}
else
{
materials.Add(mat, new List <EntityChunk> {
chunk
});
}
}
}
foreach (var material in materials)
{
ProcessMaterial(contentManager, material.Value, material.Key, prefabModel);
}
// split the meshes if necessary
prefabModel.Meshes = SplitExtensions.SplitMeshes(prefabModel.Meshes, renderingSettings.DefaultGraphicsProfile > GraphicsProfile.Level_9_3);
//handle boundng box/sphere
var modelBoundingBox = prefabModel.BoundingBox;
var modelBoundingSphere = prefabModel.BoundingSphere;
foreach (var mesh in prefabModel.Meshes)
{
var vertexBuffers = mesh.Draw.VertexBuffers;
if (vertexBuffers.Length > 0)
{
// Compute local mesh bounding box (no node transformation)
var matrix = Matrix.Identity;
mesh.BoundingBox = vertexBuffers[0].ComputeBounds(ref matrix, out mesh.BoundingSphere);
// Compute model bounding box (includes node transformation)
BoundingSphere meshBoundingSphere;
var meshBoundingBox = vertexBuffers[0].ComputeBounds(ref matrix, out meshBoundingSphere);
BoundingBox.Merge(ref modelBoundingBox, ref meshBoundingBox, out modelBoundingBox);
BoundingSphere.Merge(ref modelBoundingSphere, ref meshBoundingSphere, out modelBoundingSphere);
}
mesh.Draw.CompactIndexBuffer();
}
prefabModel.BoundingBox = modelBoundingBox;
prefabModel.BoundingSphere = modelBoundingSphere;
//save
contentManager.Save(Url, prefabModel);
device.Dispose();
return(Task.FromResult(ResultStatus.Successful));
}
