void Outline(Outliner outliner)
{
var min = m_PointerDownPosition;
var max = m_PointerDragEndPosition;
var delta = max - min;
if (delta.x < 0)
{
var temp = min.x;
min.x = max.x;
max.x = temp;
}
if (delta.y < 0)
{
var temp = min.y;
min.y = max.y;
max.y = temp;
}
var minBounds = new Vector3(min.x, min.y);
var maxBounds = new Vector3(max.x, max.y);
if (min == max)
{
outliner.OutlineSinglePosition(minBounds);
}
else
{
outliner.OutlineWithBounds(minBounds, maxBounds);
}
}
public static TweenerCore <float, float, FloatOptions> DODilateShift(this Outliner target, float endValue, float duration, bool snapping = false)
{
var tweener = DOTween.To(() => target.DilateShift, x => target.DilateShift = x, endValue, duration);
tweener.SetOptions(snapping).SetTarget(target);
return(tweener);
}
public static TweenerCore <float, float, FloatOptions> DOInfoRendererScale(this Outliner target, float endValue, float duration, bool snapping = false)
{
var tweener = DOTween.To(() => target.InfoRendererScale, x => target.InfoRendererScale = x, endValue, duration);
tweener.SetOptions(snapping).SetTarget(target);
return(tweener);
}
public static void Main()
{
// Sample input for the outliner
var input = new List <Heading>()
{
new Heading(1, "Title1"),
new Heading(2, "Something"),
new Heading(2, "Something2"),
new Heading(3, "SomethingElse"),
new Heading(2, "Something3"),
new Heading(3, "SomethingElse2"),
new Heading(2, "Something4"),
new Heading(2, "Something5"),
new Heading(2, "Something6"),
new Heading(3, "SomethingElse3"),
new Heading(4, "FinalSomething"),
new Heading(3, "SomethingElse4"),
new Heading(3, "SomethingElse5"),
new Heading(1, "Title2"),
new Heading(2, "Something"),
new Heading(2, "Something2"),
new Heading(1, "Title3"),
new Heading(2, "Something"),
};
var output = Outliner.CreateOutline(input);
printAnswer(output);
Console.WriteLine("\n\nPress Any Key To Exit");
Console.ReadKey();
}
private void Start()
{
controller = GetComponent<CharacterController> ();
charTransform = GetComponent<Transform> ();
charCam = GetComponentInChildren<Camera> ();
outliner = GetComponent<Outliner> ();
//rb = GetComponent<Rigidbody> ();
}
public override bool IsEnabled(Outliner.Controls.Tree.TreeNode tn)
{
IXRefRecord xrefRecord = TreeMode.GetMaxNode(tn) as IXRefRecord;
if (xrefRecord == null)
return false;
else
return xrefRecord.Enabled;
}
public override bool IsEnabled(Outliner.Controls.Tree.TreeNode tn)
{
XRefSceneRecord xrefScene = TreeMode.GetMaxNode(tn) as XRefSceneRecord;
if (xrefScene == null)
return false;
else
return xrefScene.HasFlags(this.Flags);
}
public override ToolStripItem[] ToToolStripMenuItems( Outliner.Controls.Tree.TreeView treeView
, Outliner.Controls.Tree.TreeNode clickedTn)
{
ToolStripSeparator separator = new ToolStripSeparator();
separator.Visible = base.Visible(null, treeView, clickedTn);
return new ToolStripItem[1] { separator };
}
protected override Boolean Checked( ToolStripMenuItem clickedItem
, Outliner.Controls.Tree.TreeView treeView
, Outliner.Controls.Tree.TreeNode clickedTn)
{
Throw.IfNull(treeView, "treeView");
IEnumerable<IMaxNode> context = TreeMode.GetMaxNodes(treeView.SelectedNodes);
return context.Any(n => n.GetNodeProperty(this.Property));
}
private static void OutputStarOutline(int points, float inner = 10, float outer = 20, float width = 5, JointStyle jointStyle = JointStyle.Miter)
{
// center the shape outerRadii + 10 px away from edges
float offset = outer + 10;
Star star = new Star(offset, offset, points, inner, outer);
var outline = Outliner.GenerateOutline(star, width, jointStyle);
outline.SaveImage("Stars", $"StarOutline_{points}_{jointStyle}.png");
}
private void Start()
{
movePoint.parent = null;
moveableLayer = LayerMask.GetMask("Moveable");
stairs = LayerMask.GetMask("Stairs");
ground = LayerMask.GetMask("Ground");
playerMovement = GameObject.FindGameObjectWithTag("Player").GetComponent <CharacterMovement>();
outliner = GetComponent <Outliner>();
}
private static void OutputStarOutlineDashed(int points, float inner = 10, float outer = 20, float width = 5, JointStyle jointStyle = JointStyle.Miter, EndCapStyle cap = EndCapStyle.Butt)
{
// center the shape outerRadii + 10 px away from edges
float offset = outer + 10;
Star star = new Star(offset, offset, points, inner, outer);
var outline = Outliner.GenerateOutline(star, width, new float[] { 3, 3 }, false, jointStyle, cap);
outline.SaveImage("Stars", $"StarOutlineDashed_{points}_{jointStyle}_{cap}.png");
}
public OutlinerFilter(Outliner.TreeView tree)
{
_tree = tree;
Enabled = false;
AffectLayers = false;
NameFilter = String.Empty;
NameFilterCaseSensitive = false;
ShowGeometry = ShowShapes = ShowLights = ShowCameras = ShowHelpers = ShowSpaceWarps =
ShowBones = ShowParticles = ShowXRefs = ShowGroups = ShowHidden = ShowFrozen = true;
}
public ContextMenuStrip ToContextMenuStrip( Outliner.Controls.Tree.TreeView treeView
, Outliner.Controls.Tree.TreeNode clickedTn)
{
ContextMenuStrip strip = new ContextMenuStrip();
foreach (MenuItemModel item in this.Items)
{
strip.Items.AddRange(item.ToToolStripMenuItems(treeView, clickedTn));
}
return strip;
}
protected override Boolean Checked( ToolStripMenuItem clickedItem
, Outliner.Controls.Tree.TreeView treeView
, Outliner.Controls.Tree.TreeNode clickedTn)
{
Throw.IfNull(treeView, "treeView");
IEnumerable<IMaxNode> context = TreeMode.GetMaxNodes(treeView.SelectedNodes);
OutlinerPredicate predicate = OutlinerActions.GetPredicate(this.CheckedPredicate);
if (predicate != null)
return predicate(clickedTn, context);
else
return base.Checked(clickedItem, treeView, clickedTn);
}
protected override void OnClick( ToolStripMenuItem clickedItem
, Outliner.Controls.Tree.TreeView treeView
, Outliner.Controls.Tree.TreeNode clickedTn)
{
Throw.IfNull(treeView, "treeView");
IEnumerable<IMaxNode> context = TreeMode.GetMaxNodes(treeView.SelectedNodes);
Boolean newValue = !this.Checked(clickedItem, treeView, clickedTn);
NodeProperty prop = NodeProperties.ToProperty(this.Property);
SetNodePropertyCommand<Boolean> cmd = new SetNodePropertyCommand<Boolean>(context, prop, newValue);
cmd.Execute(true);
clickedItem.Checked = newValue;
}
public EntityDie(GL gl, string modelPath) : base(modelPath)
{
RigidBodyController = new MovementControllerRigidBody(this, false);
RigidBody.CollisionTransform.Scale = new vec3(.97f);
LerpCurve = new BezierCurve(new vec2(1, 0), new vec2(.61f, .94f));
Outliner = new Outliner(gl, this)
{
Enabled = false
};
DrawInstanced = false;
//dm = new LineMesh(colors: new vec3[] { new vec3(.7f, .2f, .3f), new vec3(.7f, .2f, .3f) });
}
protected override Boolean Checked( ToolStripMenuItem clickedItem
, Outliner.Controls.Tree.TreeView treeView
, Outliner.Controls.Tree.TreeNode clickedTn)
{
Throw.IfNull(treeView, "treeView");
if (!String.IsNullOrEmpty(this.CheckedScript))
{
String script = FormatScript(this.CheckedScript, treeView);
return MaxscriptSDK.ExecuteBooleanMaxscriptQuery(script);
}
else
{
return base.Checked(clickedItem, treeView, clickedTn);
}
}
public MainWindow(GraphicsMode gMode) : base(1600, 900, gMode,
"Cafe Shader Studio",
GameWindowFlags.Default,
DisplayDevice.Default,
3, 2, GraphicsContextFlags.Default)
{
Title += ": OpenGL Version: " + GL.GetString(StringName.Version);
_config = Config.Load();
TimelineWindow = new TimelineWindow();
Outliner = new Outliner();
Pipeline = new Pipeline();
PropertyWindow = new PropertyWindow();
status = $"Loading global shaders...";
}
/// <summary>
/// <b>호출</b> : ElementPresenter.MakeWall()<br></br>
/// <b>참조</b> : CalcPadding(),FindRotateAngle(), MakeMesh.MakeWalls(), Outliner.FindAllOutline()<br></br>
/// 문/창문 위치 반영한 벽 생성 함수.
/// Outliner로 방의 외곽선 점을 얻은 다음,
/// 그 점들을 따라 quad로 기준이 될 벽을 생성하고,
/// MakeMesh.MakeWalls()으로 기준 벽에 문/창문 오브젝트의 정보를 반영하여 새로운 벽 오브젝트를 생성한 뒤,
/// 생성된 오브젝트와 그 벽의 면적을 딕셔너리로 묶어서 저장하여 반환한다.
/// </summary>
/// <param name="rooms">모든 방 리스트</param>
/// <param name="elements">모든 문/창문 오브젝트 리스트</param>
/// <param name="height">벽 높이</param>
/// <param name="material">생성된 벽에 적용할 기본 재질</param>
/// <param name="wallParent">생성된 벽 오브젝트를 담을 부모 오브젝트</param>
/// <param name="isDebug">디버그 옵션</param>
/// <returns>생성된 벽 오브젝트와 벽의 면적을 담은 딕셔너리</returns>
public static Dictionary <Transform, float> MakeWalls(List <Transform> rooms, List <Transform> elements, float height, Material material, out Transform wallParent, bool isDebug = false)
{
Dictionary <Transform, float> generatedWallList = new Dictionary <Transform, float>();
wallParent = new GameObject().transform;
wallParent.transform.parent = rooms[0].parent;
wallParent.name = "Walls";
foreach (var room in rooms)
{
// 방 외곽선을 이루는 점 수집
List <Transform> subFloors = new List <Transform>();
for (int i = 0; i < room.childCount; i++)
{
subFloors.Add(room.GetChild(i));
}
Outliner outliner = new Outliner();
List <List <Dot> > allDots = outliner.FindAllOutline(subFloors);
// 외곽선을 따라 벽 오브젝트 생성
foreach (var dots in allDots)
{
for (int i = 0; i < dots.Count; i++)
{
Vector3 dot1 = dots[i].position;
Vector3 dot2 = dots[(i + 1) % dots.Count].position;
// quad로 기준 벽을 생성
Transform wall = GameObject.CreatePrimitive(PrimitiveType.Quad).transform;
float angle = FindRotateAngle(dot1, dot2);
Vector3 padding = CalcPadding(angle);
wall.position = (dot1 + dot2) * 0.5f + Vector3.up * height * 0.5f;
wall.GetComponent <Renderer>().material.color = Color.black;
wall.localScale = new Vector3(Mathf.Max(Mathf.Abs(dot1.x - dot2.x), Mathf.Abs(dot1.z - dot2.z)), height, 1);
wall.Rotate(Vector3.up * angle);
// 기준 벽과 문/창문 오브젝트 정보를 이용하여 새로운 벽 오브젝트 생성
Transform madeWall = MakeMesh.MakeWalls(wall, elements, material, out float area, isDebug).transform;
generatedWallList.Add(madeWall, area);
madeWall.parent = wallParent;
GameObject.Destroy(wall.gameObject);
}
}
}
return(generatedWallList);
}
public static DragDropHandler GetDragDropHandlerForNode(Outliner.TreeView tree, OutlinerNode node)
{
if (node is OutlinerObject)
{
OutlinerObject obj = (OutlinerObject)node;
if (obj.IsGroupHead || obj.IsGroupMember) return new GroupDragDropHandler(tree, obj);
if (obj.Class == OutlinerScene.ContainerType) return new ContainerDragDropHandler(tree, obj);
if (obj.SuperClass == OutlinerScene.SpacewarpType) return new SpaceWarpDragDropHandler(tree, obj);
return new ObjectDragDropHandler(tree, obj);
}
else if (node is OutlinerMaterial)
return new MaterialDragDropHandler(tree, (OutlinerMaterial)node);
else if (node is OutlinerLayer)
return new LayerDragDropHandler(tree, (OutlinerLayer)node);
return new DragDropHandler(tree, node);
}
private unsafe void LoadWorkspaces()
{
uint dockspaceId = ImGui.GetID($"###workspace");
int workspaceID = 0;
var windowFlags = ImGuiWindowFlags.NoCollapse;
if (ImGui.DockBuilderGetNode(dock_id).NativePtr == null)
{
ReloadDockLayout(dock_id, workspaceID);
}
//Create an inital dock space for docking workspaces.
ImGui.DockSpace(dock_id, new System.Numerics.Vector2(0.0f, 0.0f), 0, window_class);
LoadWindow(GetWindowName("Viewport", workspaceID), windowFlags | ImGuiWindowFlags.MenuBar, ViewportRender);
LoadWindow(GetWindowName("Timeline", workspaceID), windowFlags, TimelineWindow.Render);
LoadWindow(GetWindowName("Outliner", workspaceID), windowFlags, () => Outliner.Render());
LoadWindow(GetWindowName("Properties", workspaceID), windowFlags, () => PropertyWindow.Render(Pipeline, Outliner, TimelineWindow));
}
/// <summary>
/// <b>호출</b> : ElementPresenter.MakeWall()<br></br>
/// <b>참조</b> : FindRotateAngle(), MakeMesh.MakeWalls(), Outliner.FindAllOutline()<br></br>
/// 외곽벽을 생성하는 함수.
/// Outliner를 이용하여 전체 방의 외곽 점을 수집한 뒤, 점사이 공간에 quad로 임시 벽을 생성한다.
/// 임시벽의 위치, 크기, 회전을 참조해서 문/창문 오브젝트를 고려한 벽을 MakeMesh 클래스를 이용하여 생성한다.
/// </summary>
/// <param name="allFloors">전체 바닥 정보</param>
/// <param name="elements">문/창문 리스트</param>
/// <param name="border">벽 두께</param>
/// <param name="height">벽 높이</param>
/// <param name="material">외곽벽 생성시 적용할 기본 오브젝트</param>
/// <returns>생성된 외곽벽 오브젝트를 담은 부모 오브젝트</returns>
public static GameObject MakeOutlineWalls(List <Transform> allFloors, List <Transform> elements, float border, float height, Material material)
{
// 위치,크기,회전 참조를 위해 quad로 임시 생성한 벽 오브젝트를 담을 부모 오브젝트
Transform wallParent = new GameObject().transform;
wallParent.name = "OutlineWalls";
// 문/창문 오브젝트를 고려하여 다시 생성한 벽 오브젝트를 담을 부모 오브젝트
Transform outlinewallParent = new GameObject().transform;
outlinewallParent.name = "OutlineWalls";
// 전체 방 외곽 점 수집
Outliner outliner = new Outliner();
List <List <Dot> > allDots = outliner.FindAllOutline(allFloors);
foreach (var dots in allDots)
{
for (int i = 0; i < dots.Count; i++)
{
Vector3 dot1 = dots[i].position;
Vector3 dot2 = dots[(i + 1) % dots.Count].position;
float angle = FindRotateAngle(dot1, dot2);
// 임시 벽 생성
Transform wall = GameObject.CreatePrimitive(PrimitiveType.Quad).transform;
wall.position = (dot1 + dot2) * 0.5f + Vector3.up * height * 0.5f;
wall.localScale = new Vector3(Mathf.Max(Mathf.Abs(dot1.x - dot2.x), Mathf.Abs(dot1.z - dot2.z)), height, 1);
wall.Rotate(Vector3.up * ((angle + 180) % 360));
wall.parent = wallParent;
// 문/창문 고려한 벽 생성
Transform madeWall = MakeMesh.MakeWalls(wall, elements, material, out float area).transform;
madeWall.parent = outlinewallParent;
madeWall.GetComponent <Renderer>().receiveShadows = false;
}
}
GameObject.Destroy(wallParent.gameObject);
return(outlinewallParent.gameObject);
}
/// <summary>
/// <b>호출</b> : SpacePresenter.ShowFloorsLabel() <br></br>
/// <b>참조</b> : AttachLabels(), Visualize(), Outliner.FindAllOutline() <br></br>
/// 방의 각 벽 수치를 표시하는 함수.
/// Outliner에서 방의 외곽선을 이루는 점 리스트를 받아오고, 각 점을 이어서 길이를 두 점 사이에 표시한다.
/// </summary>
/// <param name="room">수치 표시를 나타낼 방</param>
/// <param name="labelTransform">라벨 오브젝트를 담을 부모 오브젝트</param>
/// <param name="textPrefab">글자를 나타낼 프리팹</param>
/// <param name="linePrefab">치수선 프리팹</param>
/// <param name="isDebug">디버그 옵션</param>
/// <param name="option">치수 표현 옵션(0 : 방 바깥쪽에 표시, 1: 벽 가운데에 표시, 2: 방 내부에 표시)</param>
public static List <Transform> ShowRoomSize(List <Transform> subFloors, Transform labelTransform, GameObject textPrefab, GameObject linePrefab, bool isDebug = false, int option = 0)
{
List <Transform> labels = new List <Transform>();
List <Dot> allDots = new List <Dot>();
Outliner outliner = new Outliner();
Transform roomLabelParent = new GameObject("RoomLabel").transform;
roomLabelParent.parent = labelTransform;
try
{
List <List <Dot> > outlineAllDots = outliner.FindAllOutline(subFloors, isDebug);
foreach (var outlineDots in outlineAllDots)
{
AttachLabels(outlineDots, roomLabelParent, textPrefab, linePrefab, option);
allDots.AddRange(outlineDots.ToArray());
}
return(labels);
}
catch (System.Exception)
{
//Debug.Log(e);
}
// 디버그 옵션을 위한 부분 : 점 시각화를 통해 점 생성이 정상적인지 체크.
Transform debugParent = GameObject.Find("DebugParent").transform;
if (isDebug && debugParent != null)
{
for (int i = 0; i < debugParent.childCount; i++)
{
GameObject.Destroy(debugParent.GetChild(i).gameObject);
}
debugParent.position = Vector3.zero;
Util.Visualize(allDots, debugParent);
debugParent.position = Vector3.up * 3f;
}
return(null);
}
public override ToolStripItem[] ToToolStripMenuItems( Outliner.Controls.Tree.TreeView treeView
, Outliner.Controls.Tree.TreeNode clickedTn)
{
List<ToolStripMenuItem> items = new List<ToolStripMenuItem>(MaxScene.LayerCount);
IEnumerable<IMaxNode> layers = MaxScene.Layers
.OrderBy(n => !((ILayerWrapper)n).IsDefault)
.ThenBy(n => n.DisplayName);
foreach (IMaxNode layer in layers)
{
ToolStripMenuItem item = new ToolStripMenuItem();
item.Text = layer.DisplayName;
item.Image = this.Image16;
item.Tag = layer;
item.Click += new EventHandler((sender, eventArgs) => this.item_Click(treeView, clickedTn, layer));
items.Add(item);
}
return items.ToArray();
}
public override ToolStripItem[] ToToolStripMenuItems( Outliner.Controls.Tree.TreeView treeView
, Outliner.Controls.Tree.TreeNode clickedTn)
{
List<ToolStripItem> items = new List<ToolStripItem>(4);
ActionMenuItemModel hideItem = new ActionMenuItemModel();
hideItem.ResourceType = typeof(ContextMenuResources);
hideItem.TextRes = "Context_HideSelection";
hideItem.Image16Res = "hide";
hideItem.EnabledPredicate = "HideEnabled";
hideItem.OnClickAction = "Hide";
items.Add(hideItem.ToToolStripMenuItems(treeView, clickedTn)[0]);
ActionMenuItemModel unhideItem = new ActionMenuItemModel();
unhideItem.ResourceType = typeof(ContextMenuResources);
unhideItem.TextRes = "Context_UnhideSelection";
unhideItem.EnabledPredicate = "UnhideEnabled";
unhideItem.OnClickAction = "Unhide";
items.Add(unhideItem.ToToolStripMenuItems(treeView, clickedTn)[0]);
ActionMenuItemModel freezeItem = new ActionMenuItemModel();
freezeItem.ResourceType = typeof(ContextMenuResources);
freezeItem.TextRes = "Context_FreezeSelection";
freezeItem.Image16Res = "freeze";
freezeItem.EnabledPredicate = "FreezeEnabled";
freezeItem.OnClickAction = "Freeze";
items.Add(freezeItem.ToToolStripMenuItems(treeView, clickedTn)[0]);
ActionMenuItemModel unfreezeItem = new ActionMenuItemModel();
unfreezeItem.ResourceType = typeof(ContextMenuResources);
unfreezeItem.TextRes = "Context_UnfreezeSelection";
unfreezeItem.EnabledPredicate = "UnfreezeEnabled";
unfreezeItem.OnClickAction = "Unfreeze";
items.Add(unfreezeItem.ToToolStripMenuItems(treeView, clickedTn)[0]);
return items.ToArray();
}
protected override void OnClick( ToolStripMenuItem clickedItem
, Outliner.Controls.Tree.TreeView treeView
, Outliner.Controls.Tree.TreeNode clickedTn)
{
Throw.IfNull(treeView, "treeView");
if (String.IsNullOrEmpty(this.OnClickAction))
return;
OutlinerAction action = OutlinerActions.GetAction(this.OnClickAction);
IEnumerable<IMaxNode> context = TreeMode.GetMaxNodes(treeView.SelectedNodes);
if (action != null)
action(clickedTn, context);
else
MessageBox.Show( String.Format( CultureInfo.CurrentCulture
, ContextMenuResources.Str_ActionNotFound
, this.OnClickAction)
, ContextMenuResources.Str_ContextMenuWarningTitle
, MessageBoxButtons.OK
, MessageBoxIcon.Warning
, MessageBoxDefaultButton.Button1
, ControlHelpers.CreateLocalizedMessageBoxOptions());
}
public DragDropHandler(Outliner.TreeView tree, OutlinerNode data)
{
Tree = tree;
Data = data;
}
public static int DOKill(this Outliner target, bool complete = false)
{
return(DOTween.Kill(target, complete));
}
void item_Click(Outliner.Controls.Tree.TreeView treeView, Outliner.Controls.Tree.TreeNode clickedTn, IMaxNode layer)
{
IEnumerable<IMaxNode> nodes = TreeMode.GetMaxNodes(treeView.SelectedNodes);
layer.AddChildNodes(nodes);
}
protected override void OnClick( ToolStripMenuItem clickedItem
, Outliner.Controls.Tree.TreeView treeView
, Outliner.Controls.Tree.TreeNode clickedTn)
{
Throw.IfNull(treeView, "treeView");
if (!String.IsNullOrEmpty(this.OnClickScript))
{
String script = FormatScript(this.OnClickScript, treeView);
MaxscriptSDK.ExecuteMaxscriptCommand(script);
Viewports.ForceRedraw();
}
}
/// <summary>
/// Executes code when the MenuItem is clicked.
/// </summary>
protected virtual void OnClick( ToolStripMenuItem clickedItem
, Outliner.Controls.Tree.TreeView treeView
, Outliner.Controls.Tree.TreeNode clickedTn) { }
public MaterialDragDropHandler(Outliner.TreeView tree, OutlinerMaterial data)
: base(tree, null)
{
Data = data;
}
private void DrawViewport()
{
var size = ImGui.GetWindowSize();
if (Pipeline.Width != (int)size.X || Pipeline.Height != (int)size.Y)
{
Pipeline.Width = (int)size.X;
Pipeline.Height = (int)size.Y;
Pipeline.OnResize();
}
Pipeline.RenderScene();
if ((ImGui.IsWindowFocused() && _mouseDown) ||
ImGui.IsWindowFocused() && ImGui.IsWindowHovered() || _mouseDown)
{
if (!onEnter)
{
Pipeline.ResetPrevious();
onEnter = true;
}
//Only update scene when necessary
if (ImGuiController.ApplicationHasFocus)
{
UpdateCamera();
}
}
else
{
onEnter = false;
//Reset drag/dropped model data if mouse leaves the viewport during a drag event
if (DragDroppedModel != null)
{
DragDroppedModel.DragDroppedOnLeave();
DragDroppedModel = null;
}
}
var id = Pipeline.GetViewportTexture();
ImGui.Image((IntPtr)id, size, new System.Numerics.Vector2(0, 1), new System.Numerics.Vector2(1, 0));
if (ImGui.BeginDragDropTarget())
{
ImGuiPayloadPtr outlinerDrop = ImGui.AcceptDragDropPayload("OUTLINER_ITEM",
ImGuiDragDropFlags.AcceptNoDrawDefaultRect | ImGuiDragDropFlags.AcceptBeforeDelivery);
if (outlinerDrop.IsValid())
{
//Drag/drop things onto meshes
var mouseInfo = CreateMouseState();
var picked = Pipeline.GetPickedObject(mouseInfo);
//Picking object changed.
if (DragDroppedModel != picked)
{
//Set exit drop event for previous model
if (DragDroppedModel != null)
{
DragDroppedModel.DragDroppedOnLeave();
}
DragDroppedModel = picked;
//Model has changed so call the enter event
if (picked != null)
{
picked.DragDroppedOnEnter();
}
}
if (picked != null)
{
//Set the drag/drop event
var node = Outliner.GetDragDropNode();
picked.DragDropped(node.Tag);
}
if (mouseInfo.LeftButton == ButtonState.Released)
{
DragDroppedModel = null;
}
}
ImGui.EndDragDropTarget();
}
}
void Awake()
{
outliner = FindObjectOfType <Outliner>();
outlinedObject = new Outliner.OutlinedObject(GetComponentsInChildren <Renderer>());
}
public GroupDragDropHandler(Outliner.TreeView tree, OutlinerObject data)
: base(tree, data)
{
}
protected virtual Boolean Visible( ToolStripMenuItem clickedItem
, Outliner.Controls.Tree.TreeView treeView
, Outliner.Controls.Tree.TreeNode clickedTn)
{
Throw.IfNull(treeView, "treeView");
IEnumerable<IMaxNode> context = TreeMode.GetMaxNodes(treeView.SelectedNodes);
if (context.Count() == 0)
return this.VisibleForEmptySelection;
else
return context.Any(n => n != null && n.IsNodeType(this.VisibleTypes));
}
/// <summary>
/// Returns true if the MenuItem should be in a Checked state.
/// </summary>
protected virtual Boolean Checked( ToolStripMenuItem clickedItem
, Outliner.Controls.Tree.TreeView treeView
, Outliner.Controls.Tree.TreeNode clickedTn)
{
return false;
}
/// <summary>
/// <b>호출</b> : SpacePresneter.MakeWallsAndFloors()<br></br>
/// <b>참조</b> : IsClockwise(), FindRotateAngle(), CalcPadding(), Outliner.FindAllOutline() <br></br>
/// 요소설정 단계에서 문/창문 설치를 위해 병합된 모든 방의 벽 윗부분(WallTop)을 생성하는 부분.
/// Outliner로 각 방의 외곽선을 이루는 점을 수집한 뒤,
/// 각 점 중간 부분에 두 점 사이 길이를 갖는 벽 오브젝트를 quad로 생성한다.
/// 벽이 서로 직각으로 생성되는 경우 두 벽 사이에 빈 공간이 발생할 수 있는데,
/// 이 부분을 메꾸기 위해 정사각형의 wallPoint를 추가로 생성하여 배치한다.
/// 벽의 방향을 비교하여 가로 벽인지 세로 벽인지 구분하여 요소설정 단계에서 이용할 수 있도록 모델 클래스에 정보를 저장한다.
/// </summary>
/// <param name="rooms">모든 방 리스트</param>
/// <param name="border">벽 두께</param>
/// <param name="height">벽 높이</param>
/// <returns>생성된 WallTop 오브젝트들이 담긴 부모 오브젝트</returns>
public static GameObject MakeWallTops(List <Transform> rooms, float border, float height)
{
// 오브젝트들을 담을 부모 오브젝트 생성
// 실제로 꾸미기가 가능한 내벽을 제외한 나머지 벽 오브젝트를 담을 부모 모브젝트
Transform outwalls = new GameObject().transform;
// 벽 윗부분
Transform wallTopParent = new GameObject().transform;
// 벽 윗부분 중에서 모서리 점 부분
Transform wallPointParent = new GameObject().transform;
outwalls.parent = rooms[0].parent;
wallTopParent.parent = outwalls;
wallPointParent.parent = outwalls;
outwalls.name = "OutWalls";
wallTopParent.name = "WallsTop";
wallPointParent.name = "Points";
foreach (var room in rooms)
{
List <Transform> subFloors = new List <Transform>();
for (int i = 0; i < room.childCount; i++)
{
subFloors.Add(room.GetChild(i));
}
Outliner outliner = new Outliner();
List <List <Dot> > allDots = outliner.FindAllOutline(subFloors);
foreach (var dots in allDots)
{
//Visualize(dots, "outlineDots");
float beforeAngle = 0;
for (int i = 0; i < dots.Count; i++)
{
Vector3 dot1 = dots[i].position;
Vector3 dot2 = dots[(i + 1) % dots.Count].position;
Transform wallTop = GameObject.CreatePrimitive(PrimitiveType.Quad).transform;
wallTop.Rotate(Vector3.right * 90);
// 두 점의 x,z값을 비교하여 벽의 회전 각도(0,90,180,270)를 구한다
float angle = FindRotateAngle(dot1, dot2);
// 각도에 따라 두께만큼 이동할 방향을 계산한다.
Vector3 padding = CalcPadding(angle);
wallTop.localScale = new Vector3(Mathf.Max(Mathf.Abs(dot1.x - dot2.x), border), Mathf.Max(Mathf.Abs(dot1.z - dot2.z), border), height);
wallTop.GetComponent <Renderer>().material.color = Color.black;
wallTop.position = (dot1 + dot2) * 0.5f + Vector3.up * height + padding * border * 0.5f;
wallTop.parent = wallTopParent;
wallTop.GetComponent <Renderer>().material.color = Color.black;
wallTop.GetComponent <Renderer>().receiveShadows = false;
wallTop.gameObject.AddComponent <BoxCollider>();
wallTop.GetComponent <BoxCollider>().size = new Vector3(wallTop.localScale.x == border ? 2 : 1, wallTop.localScale.x == border ? 1 : 2, 0);
// 모델의 벽 리스트에 생성된 벽을 방향 정보와 함께 추가한다.
Model.Instance.WallList.Add(
new Model.Wall(wallTop.gameObject, wallTop.localScale.x == border
? Model.Wall.WallDirection.Vertical : Model.Wall.WallDirection.Landscape));
//이전 angle과 비교했을때 반시계 방향으로 생성되면 -> 땜빵을 메꾸기 위해 가운데 모서리 생성
if (i == 0)
{
beforeAngle = FindRotateAngle(dots[(i - 1 + dots.Count) % dots.Count].position, dots[i].position);
}
if (IsClockwise(angle, beforeAngle))
{
Transform point = GameObject.CreatePrimitive(PrimitiveType.Quad).transform;
point.Rotate(Vector3.right * 90);
point.localScale = Vector3.one * border;
Vector3 padding2 = CalcPadding((angle + 90) % 360);
point.position = dot1 + Vector3.up * height + (padding - padding2) * border * 0.5f;
point.GetComponent <Renderer>().material.color = Color.black;
point.GetComponent <Renderer>().receiveShadows = false;
// 요소설정 단계에서 벽의 끝부분을 감지하기 위해 collider를 추가한다.
BoxCollider box = point.gameObject.AddComponent(typeof(BoxCollider)) as BoxCollider;
box.size = new Vector3(1, 1.1f, 1.1f);
box = point.gameObject.AddComponent(typeof(BoxCollider)) as BoxCollider;
box.size = new Vector3(1.1f, 1, 11.1f);
point.parent = wallPointParent;
point.tag = "CorssPoint";
}
beforeAngle = angle == -90 ? 270 : angle;
}
}
}
return(wallTopParent.gameObject);
}
private void UpdateOutliner(ScriptableRenderContext renderContext, CommandBuffer cmd, Camera camera, Outliner outlineEffect, HDCamera hdCamera)
{
if (outlineEffect == null || !outlineEffect.enabled)
{
return;
}
if (pool == null)
{
pool = new Queue <OutlineParameters>();
}
if (parametersInUse == null)
{
parametersInUse = new Queue <OutlineParameters>();
}
if (pool.Count == 0)
{
pool.Enqueue(new OutlineParameters());
}
var parameters = pool.Dequeue();
parametersInUse.Enqueue(parameters);
parameters.Buffer = cmd;
outlineEffect.UpdateSharedParameters(parameters, camera, camera.cameraType == CameraType.SceneView);
Outlinable.GetAllActiveOutlinables(parameters.Camera, parameters.OutlinablesToRender);
RendererFilteringUtility.Filter(parameters.Camera, parameters);
parameters.Buffer.EnableShaderKeyword("EPO_HDRP");
var historyProperties = hdCamera.historyRTHandleProperties;
parameters.Buffer.SetGlobalVector(OutlineEffect.ScaleHash, new Vector4(
(float)historyProperties.currentViewportSize.x - (float)historyProperties.currentRenderTargetSize.x,
(float)historyProperties.currentViewportSize.y - (float)historyProperties.currentRenderTargetSize.y,
(float)historyProperties.currentViewportSize.x / (float)historyProperties.currentRenderTargetSize.x,
(float)historyProperties.currentViewportSize.y / (float)historyProperties.currentRenderTargetSize.y));
if (outlineEffect.RenderingStrategy == OutlineRenderingStrategy.Default)
{
outlineEffect.UpdateSharedParameters(parameters, camera, camera.cameraType == CameraType.SceneView);
parameters.PrimaryBufferScale = 1.0f;
parameters.InfoBufferScale = 1.0f;
RTHandle colorTarget;
RTHandle depthTarget;
GetCameraBuffers(out colorTarget, out depthTarget);
parameters.Scale = colorTarget.rtHandleProperties.rtHandleScale;
SetViewport(colorTarget, parameters);
parameters.Target = colorTarget;
parameters.DepthTarget = depthTarget;
parameters.TargetWidth = colorTarget.rt.width;
parameters.TargetHeight = colorTarget.rt.height;
parameters.Antialiasing = colorTarget.rt.antiAliasing;
parameters.Prepare();
OutlineEffect.SetupOutline(parameters);
renderContext.ExecuteCommandBuffer(parameters.Buffer);
parameters.Buffer.Clear();
}
else
{
if (tempOutlinables == null)
{
tempOutlinables = new List <Outlinable>();
}
tempOutlinables.Clear();
tempOutlinables.AddRange(parameters.OutlinablesToRender);
foreach (var outlinable in tempOutlinables)
{
outlineEffect.UpdateSharedParameters(parameters, camera, camera.cameraType == CameraType.SceneView);
RTHandle colorTarget;
RTHandle depthTarget;
GetCameraBuffers(out colorTarget, out depthTarget);
parameters.Scale = colorTarget.rtHandleProperties.rtHandleScale;
SetViewport(colorTarget, parameters);
parameters.Target = colorTarget;
parameters.DepthTarget = depthTarget;
parameters.TargetWidth = colorTarget.rt.width;
parameters.TargetHeight = colorTarget.rt.height;
parameters.Antialiasing = colorTarget.rt.antiAliasing;
parameters.OutlinablesToRender.Clear();
parameters.OutlinablesToRender.Add(outlinable);
parameters.BlitMesh = null;
parameters.Prepare();
cmd.SetViewport(new Rect(Vector2.zero, colorTarget.rtHandleProperties.currentViewportSize));
OutlineEffect.SetupOutline(parameters);
renderContext.ExecuteCommandBuffer(parameters.Buffer);
parameters.Buffer.Clear();
}
parameters.MeshPool.ReleaseAllMeshes();
}
parameters.Buffer.Clear();
}
public ActionOutlinerMax(GameObject go, Vector3 end, float duration, Ease ease = null)
: base(go, end, duration, ease)
{
Name = "OutlinerMax";
m_Outliner = go?.GetComponent <Outliner>();
}
public void RefreshWhenWorldLoaded()
{
PG.Instance = null;
CompCtrl.SetActors(null);
//nodes.RefreshActors();
//sceneGraph.RefreshFromWorld(VP1.World);
Outliner.BindingWorld(VP1.World);
Outliner.SetViewPort(VP1);
CompCtrl.ViewPort = VP1;
if (VP1.World.DefaultScene.SunActor != null)
{
var sunComp = VP1.World.DefaultScene.SunActor.GetComponent <EngineNS.GamePlay.Component.GDirLightComponent>();
if (sunComp != null)
{
var editorInstance = EngineNS.CEngine.Instance.GameEditorInstance as CoreEditor.CEditorInstance;
sunComp.View = editorInstance.RenderPolicy.BaseSceneView;
}
}
VP1.World.RemoveEditorActor(VP1.World.NavMeshActorID);
NavModifierVolumes.Clear();
NavMeshBoundVolumes.Clear();
if (VP1.World.DefaultScene.NavAreaActor != null)
{
//var test = BuildNavtion();
List <EngineNS.GamePlay.Actor.GActor> Children = VP1.World.DefaultScene.NavAreaActor.GetChildrenUnsafe();
foreach (var actor in Children)
{
var component = actor.GetComponent <EngineNS.Bricks.RecastRuntime.NavMeshBoundVolumeComponent>();
if (component != null)
{
if (component.RCAreaType == EngineNS.Bricks.RecastRuntime.NavMeshBoundVolumeComponent.AreaType.NoWalk)
{
actor.PlacementChange -= RefreshNavModifierVolumes;
actor.PlacementChange += RefreshNavModifierVolumes;
NavModifierVolumes.Add(new WeakReference <EngineNS.GamePlay.Actor.GActor>(actor));
}
else if (component.RCAreaType == EngineNS.Bricks.RecastRuntime.NavMeshBoundVolumeComponent.AreaType.Walk)
{
actor.PlacementChange -= RefreshNavMeshBoundVolumes;
actor.PlacementChange += RefreshNavMeshBoundVolumes;
NavMeshBoundVolumes.Add(new WeakReference <EngineNS.GamePlay.Actor.GActor>(actor));
}
if (RCTileMeshBuilder.InputGeom == null)
{
//var result = BuildNavtion();
}
AddActorToNavModifierVolume(actor);
}
}
//test = BuildNavMesh();
}
var test = CreateNavRenderMesh();
RefreshActorControlInfo();
}
public LayerDragDropHandler(Outliner.TreeView tree, OutlinerLayer data)
: base(tree, null)
{
Data = data;
}
public void Draw()
{
if (ImageWrapper != null)
{
var width = (int)ImageWrapper.ActualWidth;
var height = (int)ImageWrapper.ActualHeight;
using (image = new Image <Rgba32>(width, height))
{
// Draw triangle
image.Mutate((x) =>
{
// Define pens and inks
var sss = new Pen(Rgba32.ParseHex("#FFC0CB"), 10, new float[] { 2f, 6f, 8f });
var pinkPen = Pens.Solid(Rgba32.ParseHex("#FFC0CB"), 10);
var greenPen = Pens.Solid(Rgba32.ParseHex("#228B22"), 10);
var blackPen = Pens.Solid(Rgba32.ParseHex("#000000"), 10);
var pinkBrush = Brushes.Solid(Rgba32.ParseHex("#C71585"));
Image img = Image.Load("Resources\\cat.jpg");
img.Mutate((x) =>
{
x.Resize(
128,
(x.GetCurrentSize().Height / x.GetCurrentSize().Width) * 128);
});
var CatBrush = new ImageBrush(img);
// Draw a Line
x.DrawLines(pinkPen, new PointF[] {
new PointF(30, 30),
new PointF(100, 30)
});
// Draw a Triangle
x.FillPolygon(CatBrush, new PointF[] {
new PointF(50, 50),
new PointF(500, 30),
new PointF(555, 555),
});
// Draw a star x y numberofcorners innerradius outerradius
Star star = new Star(50, 50, 5, 50, 100);
var staroutline = Outliner.GenerateOutline(star, 2, JointStyle.Round);
x.Fill(CatBrush, star);
// Draw an arc
var arc = new Polygon(new CubicBezierLineSegment(new PointF[] {
new PointF(10, 400),
new PointF(30, 10),
new PointF(240, 30),
new PointF(300, 400)
}));
x.Draw(blackPen, arc);
// Draw some Ellipse
var sector = new EllipsePolygon(200, 200, 10, 20).Scale(5);
x.Draw(blackPen, sector);
});
// Set the source
ImageControl.Source = Helpers.ImageToBitmap(image);
}
}
}
/// <summary>
/// Creates a new ToolStripMenuItem from this model.
/// </summary>
/// <param name="clickedTn">The TreeNode that was clicked when opening the menu.</param>
/// <param name="context">The context on which the menu item will operate (e.g. selected nodes).</param>
public virtual ToolStripItem[] ToToolStripMenuItems( Outliner.Controls.Tree.TreeView treeView
, Outliner.Controls.Tree.TreeNode clickedTn)
{
Throw.IfNull(treeView, "treeView");
ToolStripMenuItem item = new ToolStripMenuItem();
item.Text = this.Text;
item.Image = this.Image16;
Boolean visible = this.Visible(item, treeView, clickedTn);
item.Visible = visible;
if (visible)
{
Boolean enabled = this.Enabled(item, treeView, clickedTn);
item.Enabled = enabled;
if (enabled)
item.Checked = this.Checked(item, treeView, clickedTn);
foreach (MenuItemModel subitem in this.SubItems)
{
item.DropDownItems.AddRange(subitem.ToToolStripMenuItems(treeView, clickedTn));
}
item.Click += new EventHandler((sender, eventArgs) => this.OnClick(item, treeView, clickedTn));
}
return new ToolStripItem[1] { item };
}
public ObjectDragDropHandler(Outliner.TreeView tree, OutlinerObject data)
: base(tree, null)
{
Data = data;
}
public TreeDragDropHandler(Outliner.TreeView tree, OutlinerScene data)
: base(tree, null)
{
Data = data;
}
/// <summary>
/// 스냅기능을 위해 바닥에 변경사항이 생길 때마다 Dot 리스트를 갱신해주는 함수.
/// </summary>
/// <param name="floor"></param>
private void RefreshDots(GameObject floor)
{
snapDots = new List <Dot>();
roomContainsDot = new Dictionary <Dot, Transform>();
xRightDots = new List <Dot>();
xLeftDots = new List <Dot>();
yUpDots = new List <Dot>();
yDownDots = new List <Dot>();
Outliner outliner = new Outliner();
List <Dot> tempOutLine = new List <Dot>();
for (int i = 0; i < Model.Instance.Room.Rooms.Count; i++)
{
List <Transform> floors = new List <Transform>();
for (int j = 0; j < Model.Instance.Room.Rooms[i].childCount; j++)
{
if (floor != Model.Instance.Room.Rooms[i].GetChild(j).gameObject)
{
floors.Add(Model.Instance.Room.Rooms[i].GetChild(j));
}
}
if (floors.Count > 0)
{
tempOutLine = outliner.FindOutline(floors);
snapDots.AddRange(tempOutLine);
for (int k = 0; k < tempOutLine.Count; k++)
{
try
{
roomContainsDot.Add(tempOutLine[k], Model.Instance.Room.Rooms[i]);
}
catch (Exception e)
{
Debug.Log(e.Message);
}
}
}
}
Floor tempfloor = Util.ConvertFloorToFloor(floor.transform);
// 바닥에서 4방향으로 나누고, 해당 부분을 리스트로 따로 담음.
xRightDots = snapDots.FindAll(x => (x.diretion == Direction.Down ||
x.diretion == Direction.Right && x.attribute == "Cross" ||
x.diretion == Direction.Left && x.attribute == "Corner"));
xLeftDots = snapDots.FindAll(x => (x.diretion == Direction.Up ||
x.diretion == Direction.Left && x.attribute == "Cross" ||
x.diretion == Direction.Right && x.attribute == "Corner"));
yUpDots = snapDots.FindAll(x => (x.diretion == Direction.Right ||
x.diretion == Direction.Up && x.attribute == "Cross" ||
x.diretion == Direction.Down && x.attribute == "Corner"));
yDownDots = snapDots.FindAll(x => (x.diretion == Direction.Left ||
x.diretion == Direction.Down && x.attribute == "Cross" ||
x.diretion == Direction.Up && x.attribute == "Corner"));
if (isDebugMode)
{
Debug.Log("---DotListCount---");
Debug.Log("xRightDots : " + xRightDots.Count);
Debug.Log("xLeftDots : " + xLeftDots.Count);
Debug.Log("yUpDots : " + yUpDots.Count);
Debug.Log("yDownDots : " + yDownDots.Count);
Debug.Log("------------------");
}
}
protected override void OnClick( ToolStripMenuItem clickedItem
, Outliner.Controls.Tree.TreeView treeView
, Outliner.Controls.Tree.TreeNode clickedTn)
{
//IncludeContextMenuData does not execute anything.
}
