public void DrawHud(int width, int height, Point center, Color crosshair)
{
GL.MatrixMode(MatrixMode.Projection);
GL.PushMatrix();
GL.LoadIdentity();
GL.Ortho(0, width, height, 0, 0, 1);
GL.MatrixMode(MatrixMode.Modelview);
GL.LoadIdentity();
GL.Clear(ClearBufferMask.DepthBufferBit);
GL.LineWidth(1);
GLUtils.SafeBegin(BeginMode.Lines, () =>
{
GL.Color3(crosshair);
GL.Vertex2(center.X - 2, center.Y);
GL.Vertex2(center.X + 3, center.Y);
GL.Vertex2(center.X, center.Y - 3);
GL.Vertex2(center.X, center.Y + 2);
});
GL.MatrixMode(MatrixMode.Projection);
GL.PopMatrix();
}
private void DoSelectionPass()
{
// turn off lighting and draw world as flat colored objects who's color corresponds to their node id
GLUtils.SafeDisable(EnableCap.Lighting, () =>
{
// reset vbo
Nodes.Reset();
// call render
Model.Render();
// load vbo
Nodes.Load();
// draw node vbo
Nodes.Draw(BeginMode.Triangles);
// read pixel at cursor
byte[] rgb = new byte[3];
GL.ReadPixels(SelectionPoint.X, Height - SelectionPoint.Y, 1, 1, PixelFormat.Rgb, PixelType.UnsignedByte, rgb);
// convert to color int
int id = (rgb[0] << 24) | (rgb[1] << 16) | rgb[2];
// look up in map
NodeModel node;
SelectionMap.TryGetValue(id, out node);
if (SelectionMode == SelectionModes.Single)
{
Model.ClickNode(node);
}
else
{
Model.SetRoot(node);
}
});
// clear buffer
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
// turn off selection mode
SelectionMode = SelectionModes.None;
}
public void Draw(BeginMode mode)
{
// To draw a VBO:
// 1) Ensure that the VertexArray client state is enabled.
// 2) Bind the vertex and element buffer handles.
// 3) Set up the data pointers (vertex, normal, color) according to your vertex format.
// 4) Call DrawElements. (Note: the last parameter is an offset into the element buffer
// and will usually be IntPtr.Zero).
GLUtils.SafeGLEnableClientStates(DrawStates, () =>
{
GL.BindBuffer(BufferTarget.ArrayBuffer, VboID);
GL.VertexPointer(3, VertexPointerType.Float, BlittableValueType.StrideOf(Vertices), new IntPtr(0));
GL.ColorPointer(4, ColorPointerType.UnsignedByte, BlittableValueType.StrideOf(Vertices), new IntPtr(12));
GL.NormalPointer(NormalPointerType.Float, BlittableValueType.StrideOf(Vertices), new IntPtr(16));
GL.DrawArrays(mode, 0, VertexCount);
});
}
public void DrawNode(Color color, RectangleF area, bool outside, NodeModel node, int depth)
{
float x = area.X + 0.1f;
float y = area.Y + 0.1f;
float width = area.Width - 0.2f;
float length = area.Height - 0.2f;
float bottom = depth * LevelSize + 0.1f;
float height = GetNodeHeight(node) - 0.2f;
if (SelectionMode != SelectionModes.None)
{
SelectionMap[node.ID] = node;
color = Color.FromArgb((255 << 24) | node.ID);
}
if (outside)
{
DrawPyramid(color, x, y, width, length, bottom, height);
}
else
{
GLUtils.DrawCube(Nodes, color, x, y, width, length, bottom, height);
}
}
void GLRenderer_Paint(object sender, PaintEventArgs e)
{
if (!GLLoaded)
{
return;
}
GL.Clear(ClearBufferMask.ColorBufferBit);
if (!Model.Paused)
{
// reset vertex buffers
Nodes.Reset();
FontMap.Values.ForEach(f => f.ResetVBOs());
Outlines.Values.ForEach(v => v.Reset());
CallLines.Values.ForEach(v => v.Reset());
DashedCallLines.Values.ForEach(v => v.Reset());
Overlays.Reset();
// render
Model.Render();
// send vertex buffers to gpu
Nodes.Load();
FontMap.Values.ForEach(f => f.LoadVBOs());
Outlines.Values.Where(v => v.VertexCount > 0).ForEach(v => v.Load());
CallLines.Values.Where(v => v.VertexCount > 0).ForEach(v => v.Load());
DashedCallLines.Values.Where(v => v.VertexCount > 0).ForEach(v => v.Load());
Overlays.Load();
}
// draw vertex buffers
Nodes.Draw(BeginMode.Triangles);
DrawLineVbo(Outlines);
GLUtils.SafeEnable(LineCaps, () =>
{
GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
DrawLineVbo(CallLines);
GLUtils.SafeEnable(EnableCap.LineStipple, () =>
{
//1111 1000 0000 0000
ushort pattern = (ushort)(0xF800 >> (XRay.DashOffset * 5));
GL.LineStipple(1, pattern);
DrawLineVbo(DashedCallLines);
});
});
GLUtils.SafeEnable(EnableCap.Blend, () =>
{
GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
Overlays.Draw(BeginMode.Triangles);
FontMap.Values.ForEach(f => f.DrawVBOs());
});
SwapBuffers();
Model.FpsCount++;
}
private void DrawNode(NodeModel node, RectangleF area, RectangleF labelArea, int depth, bool drawChildren, bool showHit)
{
if (!node.Show)
{
return;
}
var xNode = node.XNode;
// set background of node base color
Color background = XColors.EmptyColor;
// if selcted
if (node.Hovered && ViewLayout == LayoutType.TreeMap)
{
if (depth > XColors.OverColors.Length - 1)
{
depth = XColors.OverColors.Length - 1;
}
background = XColors.OverColors[depth];
}
else if (ViewLayout != LayoutType.TreeMap && !CenterMap.Contains(node.ID))
{
background = XColors.OutsideColor;
}
// if no overlay, draw the border color as the entire node cause its very small
bool noBorder = area.Width < 3.0f || area.Height < 3.0f;
if (noBorder)
{
background = XColors.ObjColors[(int)node.ObjType];
}
Color overlay = XColors.EmptyColor;
if (showHit)
{
// check if function is an entry point or holding
if (XRay.FlowTracking && xNode.StillInside > 0)
{
GLUtils.BlendColors((xNode.EntryPoint > 0) ? XColors.EntryColor : XColors.HoldingColor, ref overlay);
}
// not an else if, draw over holding or entry
if (xNode.ExceptionHit > 0)
{
GLUtils.BlendColors(XColors.ExceptionColors[xNode.ExceptionHit], ref overlay);
}
else if (xNode.FunctionHit > 0)
{
if (node.ObjType == XObjType.Field)
{
if (xNode.LastFieldOp == FieldOp.Set)
{
GLUtils.BlendColors(XColors.FieldSetColors[xNode.FunctionHit], ref overlay);
}
else
{
GLUtils.BlendColors(XColors.FieldGetColors[xNode.FunctionHit], ref overlay);
}
}
else
{
GLUtils.BlendColors(XColors.HitColors[xNode.FunctionHit], ref overlay);
}
}
else if (xNode.ConstructedHit > 0)
{
GLUtils.BlendColors(XColors.ConstructedColors[xNode.ConstructedHit], ref overlay);
}
else if (xNode.DisposeHit > 0)
{
GLUtils.BlendColors(XColors.DisposedColors[xNode.DisposeHit], ref overlay);
}
}
if (FocusedNodes.Count > 0 && node.ObjType == XObjType.Class)
{
bool dependent = DependentClasses.Contains(node.ID);
bool independent = IndependentClasses.Contains(node.ID);
if (dependent && independent)
{
GLUtils.BlendColors(XColors.InterdependentColor, ref overlay);
}
else if (dependent)
{
GLUtils.BlendColors(XColors.DependentColor, ref overlay);
}
else if (independent)
{
GLUtils.BlendColors(XColors.IndependentColor, ref overlay);
}
}
if (node.SearchMatch && !SearchStrobe)
{
GLUtils.BlendColors(XColors.SearchMatchColor, ref overlay);
}
if (FilteredNodes.Contains(node.ID))
{
GLUtils.BlendColors(XColors.FilteredColor, ref overlay);
}
else if (IgnoredNodes.Contains(node.ID))
{
GLUtils.BlendColors(XColors.IgnoredColor, ref overlay);
}
// mix background with overlay
if (overlay != XColors.EmptyColor)
{
GLUtils.BlendColors(overlay, ref background);
}
// use a circle for external/outside nodes in the call map
bool outside = (ViewLayout == LayoutType.CallGraph && node.XNode.External);
// if just a point, drawing a border messes up pixels
if (noBorder && !DrawSubpixel)
{
Renderer.DrawNode(background, area, outside, node, depth);
}
else
{
Color pen = XColors.ObjColors[(int)node.ObjType];
if (FilteredNodes.Contains(node.ID))
{
pen = XColors.FilteredColor;
}
else if (IgnoredNodes.Contains(node.ID))
{
pen = XColors.IgnoredColor;
}
int penWidth = 1;
if (FocusedNodes.Contains(node))
{
penWidth = 2;
}
Renderer.DrawNode(background, area, outside, node, depth);
Renderer.DrawNodeOutline(pen, penWidth, area, outside, node, depth);
}
// draw label
//buffer.FillRectangle(SearchMatchBrush, node.DebugRect);
if (ShowLabels && node.RoomForLabel)
{
Renderer.DrawTextBackground(XColors.LabelBgColor, labelArea.X, labelArea.Y, labelArea.Width, labelArea.Height);
Renderer.DrawNodeLabel(node.Name, TextFont, XColors.ObjColors[(int)node.ObjType], labelArea, node, depth);
// draw code inside node
if (ShowCode && node.AreaF.Width > 50 && node.AreaF.Height > 50)
{
if (node.ObjType == XObjType.Method)
{
string code = node.XNode.GetMethodCode();
Renderer.DrawString(code, TextFont, XColors.CodeColor, node.AreaF.X + 5, node.AreaF.Y + labelArea.Height + 5, node.AreaF.Width - 10, node.AreaF.Height - 10 - labelArea.Height);
}
// draw field values inside node
else if (node.ObjType == XObjType.Field)
{
var summary = "";
foreach (var value in node.GetFieldValues())
{
summary += value + "\r\n";
}
Renderer.DrawString(summary, TextFont, XColors.CodeColor, node.AreaF.X + 5, node.AreaF.Y + labelArea.Height + 5, node.AreaF.Width - 10, node.AreaF.Height - 10 - labelArea.Height);
}
}
}
if (MapMode == TreeMapMode.Dependencies && node.ObjType == XObjType.Class)
{
drawChildren = false;
}
if (drawChildren && ((area.Width > 1 && area.Height > 1) || DrawSubpixel))
{
foreach (var sub in node.Nodes)
{
DrawNode(sub, depth + 1, drawChildren);
}
}
// after drawing children, draw instance tracking on top of it all
/*if (XRay.InstanceTracking && node.ObjType == XObjType.Class)
* {
* if (XRay.InstanceCount[node.ID] > 0)
* {
* string count = XRay.InstanceCount[node.ID].ToString();
* Rectangle x = new Rectangle(node.Area.Location, buffer.MeasureString(count, InstanceFont).ToSize());
*
* if (node.Area.Contains(x))
* {
* buffer.FillRectangle(NothingBrush, x);
* buffer.DrawString(count, InstanceFont, InstanceBrush, node.Area.Location.X + 2, node.Area.Location.Y + 2);
* }
* }
* }*/
}
void GLRenderer_Paint(object sender, PaintEventArgs e)
{
if (!GLLoaded)
{
return;
}
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
GL.MatrixMode(MatrixMode.Modelview);
GL.LoadIdentity();
// Move the camera to our location in space
FpsCam.SetupCamera();
if (!Model.Paused)
{
if (SelectionMode != SelectionModes.None)
{
DoSelectionPass();
}
// reset vertex buffers
Nodes.Reset();
FontMap.Values.ForEach(f => f.ResetVBOs());
Outlines.Values.ForEach(v => v.Reset());
CallLines.Values.ForEach(v => v.Reset());
DashedCallLines.Values.ForEach(v => v.Reset());
// render
Model.Render();
// send vertex buffers to gpu
Nodes.Load();
FontMap.Values.ForEach(f => f.LoadVBOs());
Outlines.Values.Where(v => v.VertexCount > 0).ForEach(v => v.Load());
CallLines.Values.Where(v => v.VertexCount > 0).ForEach(v => v.Load());
DashedCallLines.Values.Where(v => v.VertexCount > 0).ForEach(v => v.Load());
}
// draw vertex buffers
Nodes.Draw(BeginMode.Triangles);
GLUtils.SafeEnable(LineCaps, () =>
{
GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
DrawLineVbo(Outlines);
DrawLineVbo(CallLines);
GLUtils.SafeEnable(EnableCap.LineStipple, () =>
{
//1111 1000 0000 0000
ushort pattern = (ushort)(0xF800 >> (XRay.DashOffset * 5));
GL.LineStipple(1, pattern);
DrawLineVbo(DashedCallLines);
});
});
GLUtils.SafeSaveMatrix(() =>
{
GL.Rotate(90, 1.0f, 0.0f, 0.0f);
FontMap.Values.ForEach(f => f.DrawVBOs());
});
if (MouseLook)
{
FpsCam.DrawHud(Width, Height, MidWindow, Color.Black);
}
SwapBuffers();
Model.FpsCount++;
}
