mirror of
https://github.com/aharabada/glitchy-engine-beef.git
synced 2026-09-05 13:01:52 +00:00
933 lines
28 KiB
Beef
933 lines
28 KiB
Beef
using ImGui;
|
|
using GlitchyEngine.World;
|
|
using System;
|
|
using GlitchyEngine.Math;
|
|
using System.Collections;
|
|
using GlitchyEngine.Renderer;
|
|
using GlitchyEngine;
|
|
using GlitchyEngine.Content;
|
|
using GlitchyEngine.Scripting;
|
|
using GlitchyEngine.Core;
|
|
using Mono;
|
|
|
|
namespace GlitchyEditor.EditWindows
|
|
{
|
|
using internal GlitchyEngine.World.TransformComponent;
|
|
|
|
class ComponentEditWindow : EditorWindow
|
|
{
|
|
public const String s_WindowTitle = "Components";
|
|
|
|
private EntityHierarchyWindow _entityHierarchyWindow;
|
|
|
|
private List<(Type, ComponentAttribute attribute)> _componentTypes = new .() ~ delete _;
|
|
|
|
public this(EntityHierarchyWindow entityHierarchyWindow)
|
|
{
|
|
_entityHierarchyWindow = entityHierarchyWindow;
|
|
|
|
for (let type in Type.Types)
|
|
{
|
|
if (let componentAttribute = type.GetCustomAttribute<ComponentAttribute>())
|
|
{
|
|
_componentTypes.Add((type, componentAttribute));
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override void InternalShow()
|
|
{
|
|
ImGui.PushStyleVar(.WindowMinSize, ImGui.Vec2(1000, 100));
|
|
|
|
if(!ImGui.Begin(s_WindowTitle, &_open, .None))
|
|
{
|
|
ImGui.PopStyleVar();
|
|
ImGui.End();
|
|
return;
|
|
}
|
|
|
|
if (_entityHierarchyWindow.SelectionSize == 1)
|
|
{
|
|
Entity entity = _entityHierarchyWindow.GetSelectedEntity(0);
|
|
ShowComponents(entity);
|
|
}
|
|
|
|
ImGui.PopStyleVar();
|
|
ImGui.End();
|
|
}
|
|
|
|
private void ShowComponents(Entity entity)
|
|
{
|
|
ShowNameComponentEditor(entity);
|
|
|
|
ShowComponentEditor<TransformComponent>("Transform", entity, => ShowTransformComponentEditor);
|
|
ShowComponentEditor<CameraComponent>("Camera", entity, => ShowCameraComponentEditor, => ShowComponentContextMenu<CameraComponent>);
|
|
ShowComponentEditor<SpriteRendererComponent>("Sprite Renderer", entity, => ShowSpriteRendererComponentEditor, => ShowComponentContextMenu<SpriteRendererComponent>);
|
|
ShowComponentEditor<CircleRendererComponent>("Circle Renderer", entity, => ShowCircleRendererComponentEditor, => ShowComponentContextMenu<CircleRendererComponent>);
|
|
ShowComponentEditor<MeshRendererComponent>("Mesh Renderer", entity, => ShowMeshRendererComponentEditor, => ShowComponentContextMenu<MeshRendererComponent>);
|
|
ShowComponentEditor<LightComponent>("Light", entity, => ShowLightComponentEditor, => ShowComponentContextMenu<LightComponent>);
|
|
ShowComponentEditor<MeshComponent>("Mesh", entity, => ShowMeshComponentEditor, => ShowComponentContextMenu<MeshComponent>);
|
|
ShowComponentEditor<Rigidbody2DComponent>("Rigidbody 2D", entity, => ShowRigidBody2DComponentEditor, => ShowComponentContextMenu<Rigidbody2DComponent>);
|
|
ShowComponentEditor<BoxCollider2DComponent>("Box collider 2D", entity, => ShowBoxCollider2DComponentEditor, => ShowComponentContextMenu<BoxCollider2DComponent>);
|
|
ShowComponentEditor<CircleCollider2DComponent>("Circle collider 2D", entity, => ShowCircleCollider2DComponentEditor, => ShowComponentContextMenu<CircleCollider2DComponent>);
|
|
ShowComponentEditor<PolygonCollider2DComponent>("Polygon collider 2D", entity, => ShowPolygonCollider2DComponentEditor, => ShowComponentContextMenu<PolygonCollider2DComponent>);
|
|
ShowComponentEditor<ScriptComponent>("Script Component", entity, => ShowScriptComponentEditor, => ShowComponentContextMenu<ScriptComponent>);
|
|
|
|
ShowAddComponentButton(entity);
|
|
}
|
|
|
|
public void DrawSceneGUI(Entity entity)
|
|
{
|
|
DrawComponenSceneGUI<PolygonCollider2DComponent>(entity, => ShowPolygonColliderSceneGUI);
|
|
}
|
|
|
|
static void ShowPolygonColliderSceneGUI(Entity entity, PolygonCollider2DComponent* collider)
|
|
{
|
|
for (int i < collider.VertexCount)
|
|
{
|
|
Matrix localToWorld = entity.Transform.WorldTransform * Matrix.Translation(collider.Offset.X, collider.Offset.Y, 0);
|
|
Matrix transform = Matrix.Translation(float3(collider.Vertices[i], 0)) * localToWorld;
|
|
|
|
if (Handles.ShowGizmo(ref transform, .TRANSLATE_X | .TRANSLATE_Y, true, id: (int32)i))
|
|
{
|
|
transform = localToWorld.Invert() * transform;
|
|
|
|
collider.Vertices[i] = transform.Translation.XY;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void DrawComponenSceneGUI<TComponent>(Entity entity, function void(Entity, TComponent*) showSceneGUI) where TComponent: struct, new
|
|
{
|
|
if (!entity.HasComponent<TComponent>())
|
|
return;
|
|
|
|
TComponent* component = entity.GetComponent<TComponent>();
|
|
|
|
showSceneGUI(entity, component);
|
|
}
|
|
|
|
private static void ShowComponentContextMenu<TComponent>(Entity entity, TComponent* component) where TComponent: struct, new
|
|
{
|
|
if (ImGui.Selectable("Remove Component"))
|
|
entity.RemoveComponent<TComponent>();
|
|
}
|
|
|
|
private static void ShowComponentEditor<TComponent>(String header, Entity entity, function void(Entity, TComponent*) showComponentEditor, function void(Entity, TComponent*) showComponentContextMenu = null) where TComponent: struct, new
|
|
{
|
|
if (!entity.HasComponent<TComponent>())
|
|
return;
|
|
|
|
TComponent* component = entity.GetComponent<TComponent>();
|
|
|
|
ImGui.PushID(header);
|
|
|
|
bool nodeOpen = ImGui.TreeNodeEx(header.CStr(), .DefaultOpen | .AllowItemOverlap | .Framed | .SpanFullWidth);
|
|
|
|
if (showComponentContextMenu != null)
|
|
{
|
|
ImGui.SameLine(ImGui.GetWindowContentRegionMax().x - ImGui.CalcTextSize("...").x - 2 * ImGui.GetStyle().FramePadding.x);
|
|
|
|
if (ImGui.SmallButton("..."))
|
|
{
|
|
ImGui.OpenPopup("component_popup");
|
|
}
|
|
|
|
if (ImGui.BeginPopup("component_popup"))
|
|
{
|
|
showComponentContextMenu(entity, component);
|
|
|
|
ImGui.EndPopup();
|
|
}
|
|
}
|
|
|
|
if (nodeOpen)
|
|
{
|
|
if (entity.TryGetComponent<TComponent>(let actualComponent))
|
|
showComponentEditor(entity, actualComponent);
|
|
|
|
ImGui.TreePop();
|
|
}
|
|
|
|
ImGui.PopID();
|
|
}
|
|
|
|
private static void ShowNameComponentEditor(Entity entity)
|
|
{
|
|
if (!entity.HasComponent<NameComponent>())
|
|
return;
|
|
|
|
char8[256] nameBuffer = default;
|
|
|
|
NameComponent* component = entity.GetComponent<NameComponent>();
|
|
|
|
StringView name = null;
|
|
|
|
if(component != null)
|
|
{
|
|
name = component.Name;
|
|
}
|
|
else
|
|
{
|
|
name = scope:: $"Entity {entity.Handle.[Friend]Index}";
|
|
}
|
|
|
|
// Copy name to buffer
|
|
Internal.MemCpy(&nameBuffer, name.Ptr, Math.Min(nameBuffer.Count, name.Length));
|
|
|
|
if(ImGui.InputText("Name", &nameBuffer, nameBuffer.Count))
|
|
{
|
|
if(component == null)
|
|
{
|
|
component = entity.AddComponent<NameComponent>();
|
|
}
|
|
|
|
component.Name = StringView(&nameBuffer);
|
|
}
|
|
}
|
|
|
|
private static void ShowTransformComponentEditor(Entity entity, TransformComponent* transform)
|
|
{
|
|
float textWidth = ImGui.CalcTextSize("Position".CStr()).x;
|
|
textWidth = Math.Max(textWidth, ImGui.CalcTextSize("Rotation".CStr()).x);
|
|
textWidth = Math.Max(textWidth, ImGui.CalcTextSize("Scale".CStr()).x);
|
|
|
|
textWidth += ImGui.GetStyle().FramePadding.x * 3.0f;
|
|
|
|
float3 position = transform.Position;
|
|
if (ImGui.EditFloat3("Position", ref position, .Zero, 0.1f, textWidth))
|
|
{
|
|
transform.Position = position;
|
|
|
|
// if necessary reposition Rigidbody2D
|
|
if (entity.TryGetComponent<Rigidbody2DComponent>(let rigidbody2D))
|
|
{
|
|
rigidbody2D.SetPosition(position.XY);
|
|
}
|
|
}
|
|
|
|
float3 rotationEuler = MathHelper.ToDegrees(transform.EditorRotationEuler);
|
|
|
|
bool3 componentEditable = true;
|
|
|
|
if (entity.HasComponent<Rigidbody2DComponent>())
|
|
{
|
|
componentEditable.XY = false;
|
|
rotationEuler.XY = 0;
|
|
}
|
|
|
|
if (ImGui.EditFloat3("Rotation", ref rotationEuler, .Zero, 0.1f, textWidth, componentEnabled: componentEditable))
|
|
{
|
|
transform.EditorRotationEuler = MathHelper.ToRadians(rotationEuler);
|
|
|
|
// if necessary reposition Rigidbody2D
|
|
if (entity.TryGetComponent<Rigidbody2DComponent>(let rigidbody2D))
|
|
{
|
|
rigidbody2D.SetAngle(rotationEuler.Z);
|
|
}
|
|
}
|
|
|
|
float3 scale = transform.Scale;
|
|
if (ImGui.EditFloat3("Scale", ref scale, .One, 0.1f, textWidth))
|
|
transform.Scale = scale;
|
|
}
|
|
|
|
static String[] strings = new String[]("Orthographic", "Perspective", "Perspective (Infinite)") ~ delete _;
|
|
|
|
private static void ShowCameraComponentEditor(Entity entity, CameraComponent* cameraComponent)
|
|
{
|
|
ImGui.Checkbox("Primary", &cameraComponent.Primary);
|
|
|
|
var camera = ref cameraComponent.Camera;
|
|
|
|
String typeName = strings[camera.ProjectionType.Underlying];
|
|
|
|
if (ImGui.BeginCombo("Projection", typeName.CStr()))
|
|
{
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
bool isSelected = (typeName == strings[i]);
|
|
|
|
if (ImGui.Selectable(strings[i], isSelected))
|
|
{
|
|
camera.ProjectionType = (.)i;
|
|
}
|
|
|
|
if (isSelected)
|
|
ImGui.SetItemDefaultFocus();
|
|
}
|
|
|
|
ImGui.EndCombo();
|
|
}
|
|
|
|
if (camera.ProjectionType == .Perspective)
|
|
{
|
|
float fovY = MathHelper.ToDegrees(camera.PerspectiveFovY);
|
|
if (ImGui.DragFloat("Fov Y", &fovY, 0.1f))
|
|
camera.PerspectiveFovY = MathHelper.ToRadians(fovY);
|
|
|
|
float near = camera.PerspectiveNearPlane;
|
|
if (ImGui.DragFloat("Near", &near, 0.1f))
|
|
camera.PerspectiveNearPlane = near;
|
|
|
|
float far = camera.PerspectiveFarPlane;
|
|
if (ImGui.DragFloat("Far", &far, 0.1f))
|
|
camera.PerspectiveFarPlane = far;
|
|
}
|
|
else if (camera.ProjectionType == .InfinitePerspective)
|
|
{
|
|
float fovY = MathHelper.ToDegrees(camera.PerspectiveFovY);
|
|
if (ImGui.DragFloat("Vertical FOV", &fovY, 0.1f))
|
|
camera.PerspectiveFovY = MathHelper.ToRadians(fovY);
|
|
|
|
float near = camera.PerspectiveNearPlane;
|
|
if (ImGui.DragFloat("Near", &near, 0.1f))
|
|
camera.PerspectiveNearPlane = near;
|
|
}
|
|
else if (camera.ProjectionType == .Orthographic)
|
|
{
|
|
float size = camera.OrthographicHeight;
|
|
if (ImGui.DragFloat("Size", &size, 0.1f))
|
|
camera.OrthographicHeight = size;
|
|
|
|
float near = camera.OrthographicNearPlane;
|
|
if (ImGui.DragFloat("Near", &near, 0.1f))
|
|
camera.OrthographicNearPlane = near;
|
|
|
|
float far = camera.OrthographicFarPlane;
|
|
if (ImGui.DragFloat("Far", &far, 0.1f))
|
|
camera.OrthographicFarPlane = far;
|
|
}
|
|
|
|
bool fixedAspectRatio = camera.FixedAspectRatio;
|
|
if (ImGui.Checkbox("Fixed Aspect Ratio", &fixedAspectRatio))
|
|
camera.FixedAspectRatio = fixedAspectRatio;
|
|
|
|
if (fixedAspectRatio)
|
|
{
|
|
float aspect = camera.AspectRatio;
|
|
if (ImGui.DragFloat("Aspect Ratio", &aspect, 0.1f))
|
|
camera.AspectRatio = aspect;
|
|
}
|
|
}
|
|
|
|
private static void ShowSpriteRendererComponentEditor(Entity entity, SpriteRendererComponent* spriteRendererComponent)
|
|
{
|
|
ColorRGBA spriteColor = ColorRGBA.LinearToSRGB(spriteRendererComponent.Color);
|
|
if (ImGui.ColorEdit4("Color", ref spriteColor))
|
|
spriteRendererComponent.Color = ColorRGBA.SRgbToLinear(spriteColor);
|
|
|
|
ImGui.Button("Texture");
|
|
|
|
if (ImGui.BeginDragDropTarget())
|
|
{
|
|
ImGui.Payload* payload = ImGui.AcceptDragDropPayload(.ContentBrowserItem);
|
|
|
|
if (payload != null)
|
|
{
|
|
Log.EngineLogger.Warning("");
|
|
|
|
StringView path = .((char8*)payload.Data, (int)payload.DataSize);
|
|
|
|
spriteRendererComponent.Sprite = Content.LoadAsset(path);
|
|
}
|
|
|
|
ImGui.EndDragDropTarget();
|
|
}
|
|
|
|
|
|
ImGui.EditVector<4>("UV Transform", ref *(float[4]*)&spriteRendererComponent.UvTransform);
|
|
}
|
|
|
|
private static void ShowCircleRendererComponentEditor(Entity entity, CircleRendererComponent* circleRendererComponent)
|
|
{
|
|
ColorRGBA spriteColor = ColorRGBA.LinearToSRGB(circleRendererComponent.Color);
|
|
if (ImGui.ColorEdit4("Color", ref spriteColor))
|
|
circleRendererComponent.Color = ColorRGBA.SRgbToLinear(spriteColor);
|
|
|
|
ImGui.Button("Texture");
|
|
|
|
if (ImGui.BeginDragDropTarget())
|
|
{
|
|
ImGui.Payload* payload = ImGui.AcceptDragDropPayload(.ContentBrowserItem);
|
|
|
|
if (payload != null)
|
|
{
|
|
Log.EngineLogger.Warning("");
|
|
|
|
StringView path = .((char8*)payload.Data, (int)payload.DataSize);
|
|
|
|
circleRendererComponent.Sprite = Content.LoadAsset(path);
|
|
}
|
|
|
|
ImGui.EndDragDropTarget();
|
|
}
|
|
|
|
|
|
ImGui.EditVector<4>("UV Transform", ref *(float[4]*)&circleRendererComponent.UvTransform);
|
|
|
|
ImGui.DragFloat("Inner Radius", &circleRendererComponent.InnerRadius, 0.1f, 0.0f, 1.0f);
|
|
}
|
|
|
|
private static void ShowMeshRendererComponentEditor(Entity entity, MeshRendererComponent* meshRendererComponent)
|
|
{
|
|
ImGui.TextUnformatted("Material:");
|
|
ImGui.SameLine();
|
|
|
|
Material material = meshRendererComponent.Material;
|
|
|
|
StringView identifier = material?.Identifier ?? "None";
|
|
ImGui.Button(identifier.ToScopeCStr!());
|
|
|
|
if (ImGui.BeginDragDropTarget())
|
|
{
|
|
ImGui.Payload* payload = ImGui.AcceptDragDropPayload(.ContentBrowserItem);
|
|
|
|
if (payload != null)
|
|
{
|
|
StringView fullpath = .((char8*)payload.Data, (int)payload.DataSize);
|
|
|
|
meshRendererComponent.Material = Content.LoadAsset(fullpath);
|
|
}
|
|
|
|
ImGui.EndDragDropTarget();
|
|
}
|
|
|
|
/*Effect effect = material?.Effect;
|
|
|
|
if (effect == null)
|
|
return;*/
|
|
|
|
// Show a preview of the material here!
|
|
}
|
|
|
|
private static void ShowRigidBody2DComponentEditor(Entity entity, Rigidbody2DComponent* rigidBodyComponent)
|
|
{
|
|
const String[?] bodyTypeStrings = .("Static", "Dynamic", "Kinematic");
|
|
String bodyTypeName = bodyTypeStrings[rigidBodyComponent.BodyType.Underlying];
|
|
|
|
if (ImGui.BeginCombo("Type", bodyTypeName.CStr()))
|
|
{
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
bool isSelected = (bodyTypeName == bodyTypeStrings[i]);
|
|
|
|
if (ImGui.Selectable(bodyTypeStrings[i], isSelected))
|
|
{
|
|
rigidBodyComponent.BodyType = (.)i;
|
|
}
|
|
|
|
if (isSelected)
|
|
ImGui.SetItemDefaultFocus();
|
|
}
|
|
|
|
ImGui.EndCombo();
|
|
}
|
|
|
|
|
|
ImGui.Checkbox("Fixed Rotation", &rigidBodyComponent.FixedRotation);
|
|
}
|
|
|
|
private static void ShowBoxCollider2DComponentEditor(Entity entity, BoxCollider2DComponent* boxCollider)
|
|
{
|
|
float textWidth = ImGui.CalcTextSize("Offset".CStr()).x;
|
|
textWidth += ImGui.GetStyle().FramePadding.x * 3.0f;
|
|
|
|
|
|
float2 offset = boxCollider.Offset;
|
|
if (ImGui.EditFloat2("Offset", ref offset, .Zero, 0.1f, textWidth))
|
|
boxCollider.Offset = offset;
|
|
|
|
float2 size = boxCollider.Size;
|
|
if (ImGui.EditFloat2("Size", ref size, .Zero, 0.1f, textWidth, float2(0.01f, 0.01f), float.PositiveInfinity.XX))
|
|
boxCollider.Size = size;
|
|
|
|
float density = boxCollider.Density;
|
|
if (ImGui.DragFloat("Density", &density, 0.0f, 0.1f, textWidth))
|
|
boxCollider.Density = density;
|
|
|
|
float friction = boxCollider.Friction;
|
|
if (ImGui.DragFloat("Friction", &friction, 0.0f, 0.1f, textWidth))
|
|
boxCollider.Friction = friction;
|
|
|
|
float restitution = boxCollider.Restitution;
|
|
if (ImGui.DragFloat("Restitution", &restitution, 0.0f, 0.1f, textWidth))
|
|
boxCollider.Restitution = restitution;
|
|
|
|
float restitutionThreshold = boxCollider.RestitutionThreshold;
|
|
if (ImGui.DragFloat("RestitutionThreshold", &restitutionThreshold, 0.0f, 0.1f, textWidth))
|
|
boxCollider.RestitutionThreshold = restitutionThreshold;
|
|
}
|
|
|
|
private static void ShowCircleCollider2DComponentEditor(Entity entity, CircleCollider2DComponent* circleCollider)
|
|
{
|
|
float textWidth = ImGui.CalcTextSize("Offset".CStr()).x;
|
|
textWidth += ImGui.GetStyle().FramePadding.x * 3.0f;
|
|
|
|
float2 offset = circleCollider.Offset;
|
|
if (ImGui.EditFloat2("Offset", ref offset, .Zero, 0.1f, textWidth))
|
|
circleCollider.Offset = offset;
|
|
|
|
float radius = circleCollider.Radius;
|
|
if (ImGui.DragFloat("Radius", &radius, 0.0f, 0.1f, textWidth))
|
|
circleCollider.Radius = radius;
|
|
|
|
float density = circleCollider.Density;
|
|
if (ImGui.DragFloat("Density", &density, 0.0f, 0.1f, textWidth))
|
|
circleCollider.Density = density;
|
|
|
|
float friction = circleCollider.Friction;
|
|
if (ImGui.DragFloat("Friction", &friction, 0.0f, 0.1f, textWidth))
|
|
circleCollider.Friction = friction;
|
|
|
|
float restitution = circleCollider.Restitution;
|
|
if (ImGui.DragFloat("Restitution", &restitution, 0.0f, 0.1f, textWidth))
|
|
circleCollider.Restitution = restitution;
|
|
|
|
float restitutionThreshold = circleCollider.RestitutionThreshold;
|
|
if (ImGui.DragFloat("RestitutionThreshold", &restitutionThreshold, 0.0f, 0.1f, textWidth))
|
|
circleCollider.RestitutionThreshold = restitutionThreshold;
|
|
}
|
|
|
|
private static void ShowPolygonCollider2DComponentEditor(Entity entity, PolygonCollider2DComponent* polygonCollider)
|
|
{
|
|
float textWidth = ImGui.CalcTextSize("Offset".CStr()).x;
|
|
textWidth += ImGui.GetStyle().FramePadding.x * 3.0f;
|
|
|
|
float2 offset = polygonCollider.Offset;
|
|
if (ImGui.EditFloat2("Offset", ref offset, .Zero, 0.1f, textWidth))
|
|
polygonCollider.Offset = offset;
|
|
|
|
// TODO: Handles in editor, etc...
|
|
if (ImGui.CollapsingHeader("Vertices"))
|
|
{
|
|
for (int i < polygonCollider.VertexCount)
|
|
{
|
|
ImGui.EditFloat2(scope $"{i}", ref polygonCollider.Vertices[i]);
|
|
}
|
|
}
|
|
|
|
ImGui.BeginDisabled(polygonCollider.VertexCount >= 8);
|
|
if (ImGui.Button("Add Vertex"))
|
|
polygonCollider.VertexCount++;
|
|
ImGui.EndDisabled();
|
|
|
|
ImGui.BeginDisabled(polygonCollider.VertexCount <= 3);
|
|
if (ImGui.Button("Remove Vertex"))
|
|
polygonCollider.VertexCount--;
|
|
ImGui.EndDisabled();
|
|
|
|
float density = polygonCollider.Density;
|
|
if (ImGui.DragFloat("Density", &density, 0.0f, 0.1f, textWidth))
|
|
polygonCollider.Density = density;
|
|
|
|
float friction = polygonCollider.Friction;
|
|
if (ImGui.DragFloat("Friction", &friction, 0.0f, 0.1f, textWidth))
|
|
polygonCollider.Friction = friction;
|
|
|
|
float restitution = polygonCollider.Restitution;
|
|
if (ImGui.DragFloat("Restitution", &restitution, 0.0f, 0.1f, textWidth))
|
|
polygonCollider.Restitution = restitution;
|
|
|
|
float restitutionThreshold = polygonCollider.RestitutionThreshold;
|
|
if (ImGui.DragFloat("RestitutionThreshold", &restitutionThreshold, 0.0f, 0.1f, textWidth))
|
|
polygonCollider.RestitutionThreshold = restitutionThreshold;
|
|
}
|
|
|
|
private static void ShowScriptComponentEditor(Entity entity, ScriptComponent* scriptComponent)
|
|
{
|
|
static char8[64] buffer = .();
|
|
|
|
StringView search = StringView();
|
|
|
|
char8* scriptLabel = scriptComponent.ScriptClassName.ToScopeCStr!() ?? "Select Script...";
|
|
|
|
if (ImGui.Button(scriptLabel))
|
|
ImGui.OpenPopup("SelectScript");
|
|
|
|
if (ImGui.BeginPopup("SelectScript"))
|
|
{
|
|
ImGui.InputText("##ScriptSearch", &buffer, buffer.Count);
|
|
|
|
search = StringView(&buffer);
|
|
|
|
for (let (className, scriptClass) in ScriptEngine.EntityClasses)
|
|
{
|
|
if (!search.IsWhiteSpace && !className.Contains(search, true))
|
|
continue;
|
|
|
|
if (ImGui.Selectable(className.ToScopeCStr!(),
|
|
className == scriptComponent.ScriptClassName))
|
|
{
|
|
scriptComponent.ScriptClassName = scriptClass.FullName;
|
|
|
|
ScriptEngine.CreateScriptFieldMap(entity);
|
|
}
|
|
}
|
|
ImGui.EndPopup();
|
|
}
|
|
|
|
ScriptEngine.ShowScriptEditor(entity, scriptComponent);
|
|
}
|
|
|
|
private static void ShowEnumSelector(ScriptFieldInstance* field, StringView fieldName, ScriptClass scriptClass)
|
|
{
|
|
ScriptField scriptField = scriptClass.Fields[fieldName];
|
|
SharpEnum enumType = scriptField.SharpType as SharpEnum;
|
|
|
|
Log.EngineLogger.Assert(enumType != null, "Enum must have a SharpEnum!");
|
|
|
|
// Simply get Enum as a uint64
|
|
var fieldValue = field.GetData<uint64>();
|
|
|
|
StringView valueName = "<Invalid Value>";
|
|
|
|
if (enumType.Values.TryGetValue(fieldValue, let enumValue))
|
|
valueName = enumValue.Name;
|
|
|
|
if (ImGui.BeginCombo(fieldName.Ptr, valueName.Ptr))
|
|
{
|
|
for (let (entryValue, enumEntry) in enumType.Values)
|
|
{
|
|
if (ImGui.Selectable(enumEntry.Name.Ptr, fieldValue == entryValue))
|
|
field.SetData(entryValue);
|
|
}
|
|
|
|
ImGui.EndCombo();
|
|
}
|
|
}
|
|
|
|
private static Entity? ShowEntitySelector()
|
|
{
|
|
static char8[128] entitySearch = .();
|
|
|
|
Entity? result = null;
|
|
|
|
if (ImGui.BeginPopup("ENTITY_SELECTOR"))
|
|
{
|
|
ImGui.TextUnformatted("Search:");
|
|
ImGui.SameLine();
|
|
|
|
if (ImGui.InputText("##entitySearcher", &entitySearch, (uint64)entitySearch.Count))
|
|
{
|
|
|
|
}
|
|
|
|
ImGui.EndPopup();
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static void ShowEntityReceiver(ScriptFieldInstance* field, StringView fieldName, ScriptClass scriptClass)
|
|
{
|
|
var entityId = field.GetData<UUID>();
|
|
|
|
Result<Entity> fieldEntity = Editor.Instance.CurrentScene.GetEntityByID(entityId);
|
|
|
|
String entityName = scope .(32);
|
|
|
|
if (entityId == UUID(0))
|
|
entityName.Set("None");
|
|
else if (fieldEntity case .Ok(Entity e))
|
|
entityName.Set(e.Name);
|
|
else
|
|
entityName..Clear().AppendF($"Missing entity ({entityId})");
|
|
|
|
ImGui.Text($"{fieldName}: ");
|
|
ImGui.SameLine();
|
|
|
|
if (ImGui.Button(entityName))
|
|
{
|
|
if (fieldEntity case .Ok)
|
|
Editor.Instance.EntityHierarchyWindow.HighlightEntity(fieldEntity);
|
|
}
|
|
|
|
if (ImGui.BeginDragDropTarget())
|
|
{
|
|
ImGui.Payload* peekPayload = ImGui.AcceptDragDropPayload(.Entity, .AcceptPeekOnly);
|
|
|
|
bool allowDrop = false;
|
|
|
|
if (peekPayload != null)
|
|
{
|
|
Entity draggedEntity = *(Entity*)peekPayload.Data;
|
|
|
|
ScriptClass draggedScriptClass = ScriptEngine.[Friend]s_EntityRoot;
|
|
|
|
if (draggedEntity.TryGetComponent<ScriptComponent>(let draggedScript))
|
|
{
|
|
var draggedClassName = draggedScript.ScriptClassName;
|
|
draggedScriptClass = ScriptEngine.GetScriptClass(draggedClassName);
|
|
|
|
}
|
|
|
|
// TODO: I don't like the fact, that we are using mono directly
|
|
|
|
ScriptField scriptField = scriptClass.Fields[fieldName];
|
|
var fieldMonoClass = Mono.mono_type_get_class(scriptField.GetMonoType());
|
|
|
|
allowDrop = draggedScriptClass.[Friend]IsSubclass(fieldMonoClass);
|
|
}
|
|
|
|
if (allowDrop)
|
|
{
|
|
ImGui.Payload* payload = ImGui.AcceptDragDropPayload(.Entity);
|
|
|
|
if (payload != null)
|
|
{
|
|
Log.EngineLogger.AssertDebug(payload.DataSize == sizeof(Entity));
|
|
|
|
Entity droppedEntity = *(Entity*)payload.Data;
|
|
|
|
if (droppedEntity.IsValid)
|
|
field.SetData<UUID>(droppedEntity.UUID);
|
|
}
|
|
}
|
|
|
|
ImGui.EndDragDropTarget();
|
|
}
|
|
}
|
|
|
|
//private static Entity?
|
|
|
|
private static void ShowComponentReceiver(ScriptFieldInstance* field, StringView fieldName, ScriptClass scriptClass)
|
|
{
|
|
var entityId = field.GetData<UUID>();
|
|
|
|
Result<Entity> fieldEntity = Editor.Instance.CurrentScene.GetEntityByID(entityId);
|
|
|
|
String entityName = scope .(32);
|
|
|
|
if (entityId == UUID(0))
|
|
entityName.Set("None");
|
|
else if (fieldEntity case .Ok(Entity e))
|
|
entityName.Set(e.Name);
|
|
else
|
|
entityName..Clear().AppendF($"Missing reference ({entityId})");
|
|
|
|
ImGui.Text($"{fieldName}: ");
|
|
ImGui.SameLine();
|
|
|
|
if (ImGui.Button(entityName))
|
|
{
|
|
if (fieldEntity case .Ok)
|
|
Editor.Instance.EntityHierarchyWindow.HighlightEntity(fieldEntity);
|
|
}
|
|
|
|
if (ImGui.BeginDragDropTarget())
|
|
{
|
|
ImGui.Payload* peekPayload = ImGui.AcceptDragDropPayload(.Entity, .AcceptPeekOnly);
|
|
|
|
bool allowDrop = false;
|
|
|
|
if (peekPayload != null)
|
|
{
|
|
Entity draggedEntity = *(Entity*)peekPayload.Data;
|
|
|
|
// TODO: I don't like the fact, that we are using mono directly
|
|
|
|
ScriptField scriptField = scriptClass.Fields[fieldName];
|
|
|
|
// For some reason we have to retrieve the MonoType like this. Using scriptField.GetMonoType() directly returns the wrong type...
|
|
MonoReflectionType* reflectionType = Mono.mono_type_get_object(ScriptEngine.[Friend]s_AppDomain, scriptField.GetMonoType());
|
|
MonoType* actualMonoType = Mono.mono_reflection_type_get_type(reflectionType);
|
|
|
|
// TODO: We shouldn't abuse the script glue like that.
|
|
// ScriptGlue should only be called by C#, not by Beef.
|
|
if (ScriptGlue.[Friend]s_HasComponentMethods.TryGetValue(actualMonoType, let has_component))
|
|
{
|
|
allowDrop = has_component(draggedEntity);
|
|
}
|
|
else
|
|
{
|
|
Log.EngineLogger.Warning($"No HasComponent-Function found for field {scriptField.Name}");
|
|
allowDrop = false;
|
|
}
|
|
}
|
|
|
|
if (allowDrop)
|
|
{
|
|
ImGui.Payload* payload = ImGui.AcceptDragDropPayload(.Entity);
|
|
|
|
if (payload != null)
|
|
{
|
|
Log.EngineLogger.AssertDebug(payload.DataSize == sizeof(Entity));
|
|
|
|
Entity droppedEntity = *(Entity*)payload.Data;
|
|
|
|
if (droppedEntity.IsValid)
|
|
field.SetData<UUID>(droppedEntity.UUID);
|
|
}
|
|
}
|
|
|
|
ImGui.EndDragDropTarget();
|
|
}
|
|
}
|
|
|
|
private static void LabelColumn(StringView label)
|
|
{
|
|
ImGui.TextUnformatted(label);
|
|
ImGui.NextColumn();
|
|
}
|
|
|
|
private static void ShowLightComponentEditor(Entity entity, LightComponent* lightComponent)
|
|
{
|
|
ImGui.Columns(2);
|
|
defer ImGui.Columns(1);
|
|
|
|
const String[?] strings = String[]("Directional", "Point", "Spot");
|
|
|
|
var light = ref lightComponent.SceneLight;
|
|
|
|
String typeName = strings[light.LightType.Underlying];
|
|
|
|
LabelColumn("Type");
|
|
|
|
if (ImGui.BeginCombo("##Type", typeName.CStr()))
|
|
{
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
bool isSelected = (typeName == strings[i]);
|
|
|
|
if (ImGui.Selectable(strings[i], isSelected))
|
|
{
|
|
light.LightType = (.)i;
|
|
}
|
|
|
|
if (isSelected)
|
|
ImGui.SetItemDefaultFocus();
|
|
}
|
|
|
|
ImGui.EndCombo();
|
|
}
|
|
|
|
ImGui.NextColumn();
|
|
LabelColumn("Color");
|
|
|
|
ColorRGB color = ColorRGB.LinearToSRGB(light.Color);
|
|
if (ImGui.ColorEdit3("##Color", ref color))
|
|
light.Color = ColorRGB.SRgbToLinear(color);
|
|
|
|
ImGui.NextColumn();
|
|
LabelColumn("Illuminance");
|
|
|
|
float illuminance = light.Illuminance;
|
|
if (ImGui.DragFloat("##Illuminance", &illuminance, 0.1f, 0.0f, float.MaxValue))
|
|
light.Illuminance = illuminance;
|
|
}
|
|
|
|
private static void ShowMeshComponentEditor(Entity entity, MeshComponent* meshComponent)
|
|
{
|
|
ImGui.TextUnformatted("Mesh:");
|
|
ImGui.SameLine();
|
|
|
|
GeometryBinding mesh = meshComponent.Mesh;
|
|
|
|
StringView identifier = mesh?.Identifier ?? (meshComponent.Mesh.IsValid ? "<Missing Asset>" : "None");
|
|
ImGui.Button(identifier.ToScopeCStr!());
|
|
|
|
if (ImGui.BeginDragDropTarget())
|
|
{
|
|
ImGui.Payload* payload = ImGui.AcceptDragDropPayload(.ContentBrowserItem);
|
|
|
|
if (payload != null)
|
|
{
|
|
StringView fullpath = .((char8*)payload.Data, (int)payload.DataSize);
|
|
|
|
/*int idx = fullpath.IndexOf('#');
|
|
|
|
if (idx == -1)
|
|
{
|
|
// Doesn't make sense here, we NEED a sub asset
|
|
Runtime.NotImplemented();
|
|
}
|
|
|
|
StringView filePath = fullpath.Substring(0, idx);
|
|
StringView meshName = fullpath.Substring(idx + 1);*/
|
|
|
|
meshComponent.Mesh = Content.LoadAsset(fullpath);
|
|
|
|
// TODO: support multiple primitives (treat every primitive as a single mesh? or: mesh can have multiple primitives)
|
|
/*using (GeometryBinding binding = ModelLoader.LoadMesh(filePath, meshName, 0))
|
|
{
|
|
meshComponent.Mesh = binding;
|
|
}*/
|
|
|
|
//ModelLoader.LoadModel(scope .(path), )
|
|
|
|
/*using (Texture2D newTexture = new Texture2D(path, true))
|
|
{
|
|
newTexture.SamplerState = SamplerStateManager.AnisotropicWrap;
|
|
material.SetTexture(texture.key, newTexture);
|
|
}*/
|
|
}
|
|
|
|
ImGui.EndDragDropTarget();
|
|
}
|
|
}
|
|
|
|
private static void ShowAddComponentButton(Entity entity)
|
|
{
|
|
static char8[128] searchBuffer = .();
|
|
static StringView searchFilter = .();
|
|
|
|
static float buttonWidth = 100;
|
|
|
|
ImGui.NewLine();
|
|
ImGui.Separator();
|
|
ImGui.NewLine();
|
|
|
|
void ShowComponentButton<TComponent>(String name) where TComponent : struct, new
|
|
{
|
|
// If the entity already has this component, don't show the option to add it
|
|
if (entity.HasComponent<TComponent>())
|
|
return;
|
|
|
|
float textWidth = ImGui.CalcTextSize(name.CStr()).x;
|
|
buttonWidth = Math.Max(buttonWidth, textWidth + ImGui.GetStyle().FramePadding.x * 2);
|
|
|
|
if (name.Contains(searchFilter, true) && ImGui.Selectable(name))
|
|
{
|
|
if (!entity.HasComponent<TComponent>())
|
|
entity.AddComponent<TComponent>();
|
|
}
|
|
}
|
|
|
|
float textWidth = ImGui.CalcTextSize("Add Component...").x;
|
|
buttonWidth = Math.Max(buttonWidth, textWidth + ImGui.GetStyle().FramePadding.x * 2);
|
|
|
|
ImGui.PushItemWidth(buttonWidth);
|
|
|
|
ImGui.NewLine();
|
|
ImGui.SameLine(ImGui.GetContentRegionMax().x / 2 - buttonWidth / 2);
|
|
|
|
if (ImGui.BeginCombo("##add_component_combo", "Add Component...", .NoArrowButton))
|
|
{
|
|
if (ImGui.InputText("##search_component_name", &searchBuffer, (.)searchBuffer.Count))
|
|
{
|
|
searchFilter = .(&searchBuffer);
|
|
}
|
|
|
|
ImGui.Separator();
|
|
|
|
ShowComponentButton<CameraComponent>("Camera");
|
|
ShowComponentButton<SpriteRendererComponent>("Sprite Renderer");
|
|
ShowComponentButton<CircleRendererComponent>("Circle Renderer");
|
|
ShowComponentButton<LightComponent>("Light");
|
|
ShowComponentButton<Rigidbody2DComponent>("Rigidbody 2D");
|
|
ShowComponentButton<BoxCollider2DComponent>("Box collider 2D");
|
|
ShowComponentButton<CircleCollider2DComponent>("Circle collider 2D");
|
|
ShowComponentButton<PolygonCollider2DComponent>("Polygon collider 2D");
|
|
ShowComponentButton<MeshComponent>("Mesh");
|
|
ShowComponentButton<MeshRendererComponent>("Mesh Renderer");
|
|
ShowComponentButton<ScriptComponent>("C# Script");
|
|
|
|
ImGui.EndCombo();
|
|
}
|
|
|
|
ImGui.PopItemWidth();
|
|
}
|
|
}
|
|
}
|