private void Display_SizeChanged(object sender, System.EventArgs e)
{
display.MakeCurrent();
GL.Viewport(0, 0, display.Width, display.Height);
renderer.SetViewport(display.Width, display.Height);
display.Invalidate();
}
private void Plot_Load(object sender, EventArgs e)
{
if (ResolveDesignMode(this))
{
return;
}
CreateGLControl();
_glctrl.MakeCurrent();
GL.ClearColor(GraphBackColor);
if (_antialias)
{
GL.Enable(EnableCap.Blend);
GL.Enable(EnableCap.AlphaTest);
GL.Enable(EnableCap.LineSmooth);
GL.Enable(EnableCap.Multisample);
GL.Hint(HintTarget.LineSmoothHint, HintMode.Nicest);
GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
}
else
{
GL.Disable(EnableCap.Multisample);
GL.Disable(EnableCap.LineSmooth);
GL.Disable(EnableCap.AlphaTest);
GL.Disable(EnableCap.Blend);
}
_loaded = true;
GLLoaded?.Invoke(this, EventArgs.Empty);
this.OnResize(EventArgs.Empty);
}
public static void MakeCurrent()
{
if (control != null)
{
control.MakeCurrent();
}
}
private void GLInitialize(object sender, EventArgs e)
{
if (OpenGLControl.Context == null)
{
return;
}
GLInitializeDelayTimer.Enabled = false;
GLInitializeDelayTimer.Tick -= GLInitialize;
GLInitializeDelayTimer.Dispose();
GLInitializeDelayTimer = null;
OpenGL_Size_Calc();
OpenGLControl.MouseDown += OpenGL_MouseDown;
OpenGLControl.Resize += OpenGL_Resize;
if (GraphicsContext.CurrentContext != OpenGLControl.Context)
{
OpenGLControl.MakeCurrent();
}
GL.ClearColor(0.0F, 0.0F, 0.0F, 1.0F);
GL.Clear(ClearBufferMask.ColorBufferBit);
//GL.Enable(EnableCap.Blend);
//GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
//GL.Enable(EnableCap.CullFace);
IsGLInitialized = true;
}
private void MeshControl_GotFocus(object sender, EventArgs e)
{
meshControl.MakeCurrent();
GL.Flush();
meshControl.SwapBuffers();
meshControl.VSync = true;
}
private void Paint(object sender, PaintEventArgs e)
{
if (!glLoaded)
{
Load(sender, e);
}
// activate this context if it isn't already
glControl.MakeCurrent();
GL.ClearColor(0f, 0f, 0f, 1f);
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
// transformations
GL.MatrixMode(MatrixMode.Modelview);
GL.LoadIdentity();
GL.Scale(scale, scale, 1);
GL.Translate(0, 0, scale);
GL.Translate(frustumCenter);
//GL.Translate(mesh.boundingBox.center);
foreach (Rotation rot in rotations)
{
GL.Rotate(rot.angle, rot.axis);
}
GL.EnableClientState(ArrayCap.VertexArray);
// draw mesh
var meshVertices = mesh.vertices.ToArray();
GL.VertexPointer(3, VertexPointerType.Float, 0, meshVertices);
GL.Color4(0.5f, 0.5f, 0.5f, 1f);
var meshVertexIndices = mesh.vertexIndices.ToArray();
GL.DrawElements(PrimitiveType.Triangles, mesh.vertexIndices.Count, DrawElementsType.UnsignedInt, meshVertexIndices);
// draw bounding box
var bbVertices = mesh.boundingBox.vertices.ToArray();
GL.VertexPointer(3, VertexPointerType.Float, 0, bbVertices);
GL.Color4(BoundingBox.drawColor);
var bbVertexIndices = mesh.vertexIndices.ToArray();
GL.DrawElements(PrimitiveType.Lines, mesh.boundingBox.indices.Count, DrawElementsType.UnsignedInt, bbVertexIndices);
// cleanup
GL.DisableClientState(ArrayCap.VertexArray);
// we're double-buffered
glControl.SwapBuffers();
}
public void GLContext_Init()
{
GLContext.MakeCurrent();
GL.MatrixMode(MatrixMode.Projection);
GL.LoadIdentity();
GL.Viewport(0, 0, GLContext.Width, GLContext.Height);
GL.Ortho(0, GLContext.Width, GLContext.Height, 0, -1, 1);
GL.Disable(EnableCap.DepthTest);
}
private void GlControl_Load(object sender, EventArgs e)
{
glControl.MakeCurrent();
GL.Enable(EnableCap.DepthTest);
GL.Enable(EnableCap.Texture2D);
GL.Enable(EnableCap.Blend);
GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
SetCam();
}
private void MainForm_Load(object sender, EventArgs e)
{
panel.MakeCurrent();
shader = new Shader(panel.Width, panel.Height);
updateThread = new Thread(Update);
updateThread.Start();
this.Closed += CloseEvent;
}
private void _glctrl_Load(object sender, EventArgs e)
{
_glctrl.MakeCurrent();
GL.Disable(EnableCap.Multisample);
GL.Disable(EnableCap.LineSmooth);
GL.Disable(EnableCap.AlphaTest);
GL.Disable(EnableCap.Blend);
GL.ClearColor(Color.Black);
_loaded = true;
CreateTextureShader();
CreateFont();
WaterfallPlot_Resize(null, null);
}
public void GLContext_Init()
{
GLContext.MakeCurrent();
ContextContainer.Size = new System.Drawing.Size(Program.ActiveProject.Width + 1, Program.ActiveProject.Height + 1);
ClientSize = new Size(Program.ActiveProject.Width + 2, Program.ActiveProject.Height + 2);
GL.MatrixMode(MatrixMode.Projection);
GL.LoadIdentity();
GL.Viewport(0, 0, GLContext.Width, GLContext.Height);
GL.Ortho(0, GLContext.Width, GLContext.Height, 0, -1, 1);
GL.Disable(EnableCap.DepthTest);
}
private void OnLoad(object sender, EventArgs e)
{
glControl.MakeCurrent();
GL.Enable(EnableCap.Blend);
stopwatch.Start();
Load?.Invoke(this, e);
HandleResize();
Draw();
}
void glControl_Disposed(object sender, EventArgs e)
{
glControl.MakeCurrent();
for (int i = 0; i < 4; i++)
{
if (tex[i] != -1)
{
GL.DeleteTexture(tex[i]);
}
}
GL.DeleteProgram(shaderProgram);
}
private void glControl_Load(object sender, EventArgs e)
{
Console.WriteLine("Loading GLcontrol..");
glControl.MakeCurrent();
GL.Enable(EnableCap.Texture2D);
GL.Enable(EnableCap.DepthTest);
GL.ClearColor(OpenTK.Graphics.Color4.Black);
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
InitializeInputTick();
ActiveCamera.setupGLRenderMatrix();
Console.WriteLine("GLcontrol is done loading!");
}
public void Draw()
{
if (Window == null)
{
Window = new GraphWindow {
DataOrigin = new GLPoint(0, 0),
DataHeight = 100,
DataWidth = 100,
WindowHeight = Control.Height,
WindowWidth = Control.Width
};
}
if (Window.WindowWidth == 0 || Window.WindowHeight == 0)
{
return;
}
_glcontrol.MakeCurrent();
if (_displayChanged)
{
_displayChanged = false;
LoadDisplayLists();
}
GL.ClearColor(1.0f, 1.0f, 1.0f, 1.0f);
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
GL.LoadIdentity();
SetupProjection();
ConfigureLeftTickBar();
ConfigureBottomTickBar();
_leftTickBar.DrawCrossLines();
_bottomTickBar.DrawCrossLines();
DrawDataAndMarkers();
if (TextEnabled)
{
_leftTickBar.DrawTicks();
_bottomTickBar.DrawTicks();
}
DrawDeadSpace();
_glcontrol.SwapBuffers();
}
public void Load()
{
Control.MakeCurrent();
Control.Context.LoadAll();
Control.Paint += OnPaint;
Control.Resize += OnResize;
GL.ClearColor(Color.FromKnownColor(KnownColor.Control));
GL.Enable(EnableCap.DepthTest);
_timer.Enabled = true;
SetupViewport();
}
private void RenderTexture(GLControl glControl1, NUT nut)
{
if (nut == null)
{
return;
}
glControl1.MakeCurrent();
GL.Viewport(glControl1.ClientRectangle);
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
GL.ClearColor(Color.Black);
GL.Enable(EnableCap.Texture2D);
GL.Enable(EnableCap.Blend);
GL.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.OneMinusSrcAlpha);
GL.MatrixMode(MatrixMode.Modelview);
GL.LoadIdentity();
GL.MatrixMode(MatrixMode.Projection);
foreach (NutTexture tex in nut.Nodes)
{
ScreenDrawing.DrawTexturedQuad(nut.glTexByHashId[tex.HashId].Id, tex.Width, tex.Height, screenVao, true, true, true, true, true);
}
glControl1.SwapBuffers();
}
private void Control_Paint(object sender, PaintEventArgs e)
{
if (devenv)
{
return;
}
control.MakeCurrent();
GL.Enable(EnableCap.Blend);
Renderer.SetBlendFunc();
Renderer.Clear(SystemColors.ControlDark);
Renderer.SetViewport(control.Width, control.Height);
var offset = getOffset();
GL.LoadIdentity();
GL.Translate(-offset.X, -offset.Y, 0);
World.Draw();
if (leftDown)
{
RectangleF rect = getRect(pos1, pos2, 32);
Renderer.FillRect(rect, Color.FromArgb(100, 0, 100, 255));
}
control.SwapBuffers();
}
private void RenderTexture(GLControl glControl1, NUT nut)
{
if (nut == null)
{
return;
}
glControl1.MakeCurrent();
GL.Viewport(glControl1.ClientRectangle);
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
GL.ClearColor(Color.White);
GL.Enable(EnableCap.Texture2D);
GL.Enable(EnableCap.Blend);
GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
GL.MatrixMode(MatrixMode.Modelview);
GL.LoadIdentity();
GL.MatrixMode(MatrixMode.Projection);
foreach (NUT.NUD_Texture tex in nut.textures)
{
RenderTools.DrawTexturedQuad(nut.draw[tex.id], tex.width, tex.height, true, true, true, true, false, true);
}
glControl1.SwapBuffers();
}
public Viewport(Window parentWindow)
{
ParentWindow = parentWindow;
OpenTK.Graphics.GraphicsMode Mode = new OpenTK.Graphics.GraphicsMode(new OpenTK.Graphics.ColorFormat(8, 8, 8, 8), 24);
GLControl = new GLControl(Mode, 4, 4, OpenTK.Graphics.GraphicsContextFlags.Default);
GLControl.MakeCurrent();
GLControl.Paint += GLControl_Paint;
GLControl.Resize += GLControl_Resize;
GLControl.MouseDown += GLControl_MouseDown;
GLControl.MouseUp += GLControl_MouseUp;
GLControl.MouseMove += GLControl_MouseMove;
GLControl.MouseWheel += GLControl_MouseWheel;
GLControl.MouseLeave += GLControl_MouseLeave;
GLControl.Dock = System.Windows.Forms.DockStyle.Fill;
GL.Disable(EnableCap.CullFace);
GL.Enable(EnableCap.DepthTest);
GL.DepthFunc(DepthFunction.Less);
GL.DepthMask(true);
GL.Enable(EnableCap.Blend);
GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
_Camera = new Camera();
_Camera.ViewportSize = new int2(GLControl.Width, GLControl.Height);
_Camera.PropertyChanged += _Camera_PropertyChanged;
}
protected override void OnElementChanged(ElementChangedEventArgs <OpenGLView> e)
{
if (e.OldElement != null)
{
((IOpenGlViewController)e.OldElement).DisplayRequested -= Render;
}
if (e.NewElement != null)
{
var windowsFormsHost = new WindowsFormsHost();
_glControl = new GLControl(new GraphicsMode(32, 24), 2, 0, GraphicsContextFlags.Default);
_glControl.MakeCurrent();
_glControl.Dock = DockStyle.Fill;
_glControl.Paint += OnPaint;
windowsFormsHost.Child = _glControl;
SetNativeControl(windowsFormsHost);
_timer = new DispatcherTimer();
_timer.Interval = TimeSpan.FromMilliseconds(16);
_timer.Tick += OnTick;
_timer.Start();
((IOpenGlViewController)e.NewElement).DisplayRequested += Render;
SetRenderMode();
SetupRenderAction();
}
base.OnElementChanged(e);
}
private void MainLoop_Tick(object sender, EventArgs e)
{
GLCont.MakeCurrent();
GL.ClearBuffer(ClearBuffer.Color, 0, new float[] { 0, 0, 0, 1 });
GL.ClearBuffer(ClearBuffer.Depth, 0, new float[] { 1 });
GLCont.SwapBuffers();
}
public MainWindow()
{
InitializeComponent();
//wfhPropViewer.Child = pGrid;
// WPF
canvas.MouseLeftButtonUp += ShapeMouseLeftButtonUp;
// GL
var flags = GraphicsContextFlags.Default;
glControl = new GLControl(new GraphicsMode(32, 24), 2, 0, flags);
glControl.MakeCurrent();
glControl.Paint += GlControl_Paint;
glControl.Dock = DockStyle.Fill;
glControl.Resize += GlControl_Resize;
glControl.MouseDown += GlControl_MouseClick;
glControl.MouseUp += GlControl_MouseUp;
glControl.MouseMove += GlControl_MouseMove;
wfh.Child = glControl;
// MODEL
slider = new Slider();
slider.Position = slider.center = new Vector2d(200, 300);
slider.Caption = "A";
AddShapeToCanves(new SliderShape(slider));
glList.Add(new SliderGlShape(slider));
edA.DataContext = slider;
edB.DataContext = AddLeg(slider, -45, "B");
edC.DataContext = AddLeg(slider, 45, "C");
edD.DataContext = AddLeg(slider, 45, "D");
}
private void glControl1_Resize(object sender, EventArgs e)
{
Point p = PointToScreen(glControl1.Location);
ClientRect.X = p.X;
ClientRect.Y = p.Y;
ClientRect.Width = glControl1.Width;
ClientRect.Height = glControl1.Height;
int w = 800;
int h = 600;
if (glControl1 != null)
{
w = glControl1.Width;
h = glControl1.Height;
glControl1.MakeCurrent();
}
//GL.Viewport(0, 32, w, h);
if ((w > 16) && (h > 16))
{
MScreen.Resize(w, h);
}
//if (_infoForm != null)
//{
//_infoForm.UpdateData();
//}
UpdateWindowVariables();
}
/// <summary>
/// Invoked when the canvas is being painted.
/// </summary>
/// <param name="sender">The sender of the event</param>
/// <param name="e">The event data</param>
private void Canvas_Paint(object sender, System.Windows.Forms.PaintEventArgs e)
{
if (!loaded)
{
return;
}
if (!canvas.Context.IsCurrent)
{
canvas.MakeCurrent();
}
Plugins.Plugin p = PluginManager.Get(SettingsManager.CurrentVisualizer);
if (p == null)
{
return;
}
Plugins.Visualizer vis = p as Plugins.Visualizer;
if (vis == null)
{
return;
}
vis.Refresh();
canvas.SwapBuffers();
}
internal static bool SupportsOpenGLPreview()
{
bool supported = false;
try
{
lock (OpenGlPreviewForm.ContextLock)
{
var control = new GLControl();
control.MakeCurrent();
var major = GL.GetInteger(GetPName.MajorVersion);
var minor = GL.GetInteger(GetPName.MinorVersion);
if (major > 3 || (major == 3 && minor >= 3))
{
Logging.Info($"Open GL version supported!. {major}.{minor}");
supported = true;
}
else
{
Logging.Error($"Open GL version not supported. {major}.{minor}");
}
control.Context.MakeCurrent(null);
control.Dispose();
}
}
catch (Exception e)
{
Logging.Error(e, "An error occurred testing for OpenGL support.");
}
return(supported);
}
/// <summary>
/// this function take a datapacket and render it
/// </summary>
public void Draw(DataPacket packet)
{
lock (ControlPanel.RenderLock)
{
glControl.MakeCurrent();
GL.PushMatrix();
GL.ClearColor(backgroundColor);
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
GL.Viewport(0, 0, glControl.Width, glControl.Height * 4 / 5);
GL.MatrixMode(MatrixMode.Projection);
GL.LoadIdentity();
getSta(packet);
GL.Ortho(1, HISTORY, minY, maxY, -1, 1);
drawData(packet);
GL.PopMatrix();
//different viewport
GL.PushMatrix();
GL.Viewport(0, glControl.Height * 3 / 4, glControl.Width, glControl.Height * 1 / 5);
GL.MatrixMode(MatrixMode.Projection);
GL.LoadIdentity();
GL.Ortho(0, 1, 1, 0, -1, 1);
GL.Enable(EnableCap.Texture2D);
drawStatitics(packet);
GL.Disable(EnableCap.Texture2D);
GL.PopMatrix();
glControl.SwapBuffers();
glControl.Context.MakeCurrent(null);
deleteHistory(packet);
}
}
private void GLControlOnPaint(object sender, System.Windows.Forms.PaintEventArgs e)
{
#region Timer
//_stopwatch.Start();
#endregion
//Reset
_glControl.MakeCurrent();
_screenBufferManager.ResetScreenBuffer();
//Render
_shaderProvider.UpdateShadersCameraMatrices(_camera);
OnRenderLoop?.Invoke();
_sceneManager.CurrentScene.Render(_camera);
//Replace
GL.Finish();
_glControl.SwapBuffers();
#region Timer
//_frames++;
//if (_stopwatch.ElapsedTicks >= Stopwatch.Frequency)
//{
// this.Title = $"{_frames} FPS";
// _frames = 0;
// _stopwatch.Reset();
//}
#endregion
}
private void T_Tick(object sender, EventArgs e)
{
int w = GLcontrol.Width;
int h = GLcontrol.Height;
GLcontrol.MakeCurrent();
//GL.ClearColor(Color.Blue);
SetOrthographicProjection(0, 0, w, h);
GL.Viewport(0, 0, w, h);
//ShaderController.Compute();
Main.Update();
if (ResizeTimer > 0)
{
ResizeTimer--;
}
if (ResizeTimer == 1)
{
Main.Resize(GLcontrol.Width, GLcontrol.Height);
}
if (ResizeTimer == 0)
{
Main.Draw(PointToClient(MousePosition), MouseButtons, ContainsFocus);
GLcontrol.SwapBuffers();
}
//ShaderController.Draw();
}
private void Form1_Load(object sender, EventArgs e)
{
instance = this;
MouseWheel += Form1_MouseWheel;
//string S = Application.LocalUserAppDataPath;
GraphicsMode graphicsMode = new GraphicsMode(new ColorFormat(8, 8, 8, 8), 24, 8, 4);
GLcontrol = new GLControl(graphicsMode, 6, 4, GraphicsContextFlags.ForwardCompatible);
//GLcontrol = new GLControl(graphicsMode);
GLcontrol.Dock = DockStyle.Fill;
WindowState = FormWindowState.Maximized;
GLcontrol.Parent = this;
int w = GLcontrol.Width;
int h = GLcontrol.Height;
T.Interval = 10;
T.Tick += T_Tick;
T.Start();
//ShaderId = GL.CreateShader(ShaderType.ComputeShader);
//ShaderController = new ShaderController(w,h);
ShaderController.GenreateComputeProgram();
ShaderController.GenerateFragProgram();
GLcontrol.MakeCurrent();
SetOrthographicProjection(0, 0, w, h);
GL.Viewport(0, 0, w, h);
Main = new Main(GLcontrol.Size);
//Console.WriteLine();
}
public void Start(IApi platformImplementation, Action update, Action render)
{
this.update = update;
this.render = render;
ComponentDispatcher.ThreadIdle += (sender, e) => System.Windows.Forms.Application.RaiseIdle(e);
glControl = new GLControl(new GraphicsMode(32, 24), 2, 0, GraphicsContextFlags.Default);
glControl.Paint += (object sender, PaintEventArgs e) => {
if (!loaded)
return;
render();
glControl.SwapBuffers();
};
glControl.Dock = DockStyle.Fill;
glControl.Load += (object sender, EventArgs e) => { this.loaded = true; };
Application.Idle += (object sender, EventArgs e) => {
double milliseconds = ComputeTimeSlice();
Accumulate(milliseconds);
update();
Animate(milliseconds);
};
glControl.MakeCurrent();
}
