public static void Print(string text, Font font, Color color, double x, double y)
{
instance.Begin();
GL.Translate(x, y, 0);
instance.Print(text, font, color);
instance.End();
}
internal void Cleanup(ref WriteableBitmap backbuffer)
{
if (backbuffer == null || backbuffer.Width != this.size.Width || backbuffer.Height != this.size.Height)
{
backbuffer = new WriteableBitmap(
this.size.Width,
this.size.Height,
96,
96,
PixelFormats.Pbgra32,
BitmapPalettes.WebPalette);
readBuf = new byte[this.size.Width * this.size.Height * 4];
}
GL.ReadPixels(0, 0, this.size.Width, this.size.Height, PixelFormat.Bgra, PixelType.UnsignedByte, readBuf);
// copy pixels upside down
backbuffer.Lock();
var src = new Int32Rect(0, 0, (int)backbuffer.Width, 1);
for (int y = 0; y < (int)backbuffer.Height; y++)
{
src.Y = (int)backbuffer.Height - y - 1;
backbuffer.WritePixels(src, readBuf, backbuffer.BackBufferStride, 0, y);
}
backbuffer.AddDirtyRect(new Int32Rect(0, 0, (int)backbuffer.Width, (int)backbuffer.Height));
backbuffer.Unlock();
}
public void UpdateVerticesData(string name, List <Vector3> data)
{
if (data.Count > _objectsHandleDictionary[name].VertexBufferSize)
{
CreateVerticesData(name, data, data.Count * 2);
}
else
{
GL.BindVertexArray(_objectsHandleDictionary[name].ObjectHandle);
var vertexValuesArray = new float[data.Count * 3];
var index = 0;
foreach (var vertex in data)
{
vertexValuesArray[index++] = vertex.X;
vertexValuesArray[index++] = vertex.Y;
vertexValuesArray[index++] = vertex.Z;
}
var memoryPointer = GL.MapBuffer(BufferTarget.ArrayBuffer, BufferAccess.WriteOnly);
var byteArray = new byte[vertexValuesArray.Length * sizeof(float)];
Buffer.BlockCopy(vertexValuesArray, 0, byteArray, 0, byteArray.Length);
Marshal.Copy(byteArray, 0, memoryPointer, byteArray.Length);
GL.UnmapBuffer(BufferTarget.ArrayBuffer);
}
}
protected override void Init()
{
LoadShader($"Shaders\\{ShaderName}.frag", ShaderType.FragmentShader, PgmId, out FsId);
GL.LinkProgram(PgmId);
Console.WriteLine(GL.GetProgramInfoLog(PgmId));
}
public void Draw(float max)
{
Matrix4 transform = CanvasManager.ViewportTransform;
GL.Enable(EnableCap.ScissorTest);
transform = Matrix4.Scale(1, 2 / max, 1) * Matrix4.CreateTranslation(0, -1, 0) *
CanvasManager.ViewportTransform;
GL.UniformMatrix4(_shaderProgram.UniformTransform, false, ref transform);
GL.Uniform4(_shaderProgram.UniformColor, Color4.Gray);
//GL.LineWidth(1f);
GL.Disable(EnableCap.ScissorTest);
//transform = Matrix4.CreateTranslation(0, pos.Y, 0) * Matrix4.Scale(1, scale.Y, 1) * CanvasManager.ViewportTransform;
//GL.UniformMatrix4(_uniformTransform, false, ref transform);
GL.LineWidth(2f);
GL.Scissor(CanvasManager.TickSize, CanvasManager.BorderSize + CanvasManager.TickSize - 1, CanvasManager.ControlWidth - CanvasManager.TickSize,
CanvasManager.ControlHeight - 2 * (CanvasManager.BorderSize + CanvasManager.TickSize) + 2);
GL.Enable(EnableCap.ScissorTest);
YTicks.BeginDraw();
YTicks.Draw(BeginMode.Lines);
YTicks.EndDraw();
GL.Disable(EnableCap.ScissorTest);
}
private int CreateTexture(Bitmap texture, TextureUnit unit, TextureMinFilter minFilter, TextureMagFilter magFilter)
{
int textureId = GL.GenTexture();
GL.ActiveTexture(unit);
GL.BindTexture(TextureTarget.Texture2D, textureId);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)minFilter);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)magFilter);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.Repeat);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.Repeat);
GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, texture.Width, texture.Height, 0,
PixelFormat.Bgra, PixelType.UnsignedByte, IntPtr.Zero);
var bmpData = texture.LockBits(new Rectangle(0, 0, texture.Width, texture.Height),
ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
GL.TexSubImage2D(TextureTarget.Texture2D, 0, 0, 0, texture.Width, texture.Height, PixelFormat.Bgra,
PixelType.UnsignedByte, bmpData.Scan0);
texture.UnlockBits(bmpData);
GL.BindTexture(TextureTarget.Texture2D, 0);
return(textureId);
}
public void Draw(float xShift)
{
if (!Enabled)
{
return;
}
Matrix4 tmp = Matrix4.CreateTranslation(xShift, 0, 0) *
Matrix4.Scale(2f / CanvasManager.CurrentCanvasData.ScaleData.BaseScale, 1, 1) *
Matrix4.CreateTranslation(-1, 0, 0);
Matrix4 transform;
GL.Uniform4(_uniformColor, SelectionColor);
//Draw Marks
foreach (var mark in MarkList.Marks)
{
transform = mark.InitialTransform * tmp;
GL.UniformMatrix4(_uniformTransform, false, ref transform);
_selectionBlock.BeginDraw();
_selectionBlock.Draw(BeginMode.TriangleStrip);
_selectionBlock.EndDraw();
}
transform = _initialTransform * tmp;
GL.UniformMatrix4(_uniformTransform, false, ref transform);
GL.Uniform4(_uniformColor, SelectorColor);
_selectionBlock.BeginDraw();
_selectionBlock.Draw(BeginMode.TriangleStrip);
_selectionBlock.EndDraw();
}
protected virtual void SetupUniforms(IEnumerable <Uniform> uniforms)
{
foreach (var uniform in uniforms)
{
var loc = GL.GetUniformLocation(PgmId, uniform.Name);
var val = uniform.GetValue();
var type = val.GetType();
if (type == typeof(float))
{
GL.Uniform1(loc, (float)val);
}
else if (type == typeof(double))
{
GL.Uniform1(loc, (double)val);
}
else if (type == typeof(int))
{
GL.Uniform1(loc, (int)val);
}
else if (type == typeof(uint))
{
GL.Uniform1(loc, (uint)val);
}
else if (type == typeof(Vector2))
{
var vec2 = (Vector2)val;
GL.Uniform2(loc, vec2.X, vec2.Y);
}
else
{
throw new ArgumentException($"Unsupported uniform type: {type}");
}
}
}
public void UseShader(string shaderName)
{
if (!_shaderHandleDictionary.ContainsKey(shaderName))
{
throw new ApplicationException("Shader must be loaded before using it");
}
GL.UseProgram(_shaderHandleDictionary[shaderName]);
}
private void CreateFramebuffer()
{
this.glControl.MakeCurrent();
if (this.framebufferId > 0)
{
GL.DeleteFramebuffer(this.framebufferId);
}
if (this.depthbufferId > 0)
{
GL.DeleteRenderbuffer(this.depthbufferId);
}
if (this.colorbufferId > 0)
{
GL.DeleteRenderbuffer(this.colorbufferId);
}
this.framebufferId = GL.GenFramebuffer();
GL.BindFramebuffer(FramebufferTarget.Framebuffer, this.framebufferId);
this.colorbufferId = GL.GenRenderbuffer();
GL.BindRenderbuffer(RenderbufferTarget.Renderbuffer, this.colorbufferId);
GL.RenderbufferStorage(
RenderbufferTarget.Renderbuffer,
RenderbufferStorage.Rgba8,
this.size.Width,
this.size.Height);
GL.FramebufferRenderbuffer(
FramebufferTarget.Framebuffer,
FramebufferAttachment.ColorAttachment0,
RenderbufferTarget.Renderbuffer,
this.colorbufferId);
this.depthbufferId = GL.GenRenderbuffer();
GL.BindRenderbuffer(RenderbufferTarget.Renderbuffer, this.depthbufferId);
GL.RenderbufferStorage(
RenderbufferTarget.Renderbuffer,
RenderbufferStorage.DepthComponent24,
this.size.Width,
this.size.Height);
GL.FramebufferRenderbuffer(
FramebufferTarget.Framebuffer,
FramebufferAttachment.DepthAttachment,
RenderbufferTarget.Renderbuffer,
this.depthbufferId);
FramebufferErrorCode error = GL.CheckFramebufferStatus(FramebufferTarget.Framebuffer);
if (error != FramebufferErrorCode.FramebufferComplete)
{
throw new Exception();
}
this.loaded = true;
}
public void DrawInstancedTriangles(string objectName, int triangleCount, int instanceCount)
{
if (!_objectsHandleDictionary.ContainsKey(objectName))
{
throw new ApplicationException("Object must be added to the renderer before drawing");
}
GL.BindVertexArray(_objectsHandleDictionary[objectName].ObjectHandle);
GL.DrawElementsInstanced(BeginMode.Triangles, triangleCount, DrawElementsType.UnsignedInt, IntPtr.Zero, instanceCount);
}
private int CreateShader(string shaderSource, ShaderType type)
{
int shaderHandle = GL.CreateShader(type);
GL.ShaderSource(shaderHandle, shaderSource);
GL.CompileShader(shaderHandle);
Console.WriteLine(GL.GetShaderInfoLog(shaderHandle));
return(shaderHandle);
}
public void SetIndexData(string name, List <int> indices)
{
GL.BindVertexArray(_objectsHandleDictionary[name].ObjectHandle);
int indicesVboHandle;
GL.GenBuffers(1, out indicesVboHandle);
_objectsHandleDictionary[name].IndexBufferHandle = indicesVboHandle;
CreateIndexData(name, indices, indices.Count);
}
public void SetVerticesData(string name, List <Vector3> data)
{
GL.BindVertexArray(_objectsHandleDictionary[name].ObjectHandle);
int vboHandle;
GL.GenBuffers(1, out vboHandle);
_objectsHandleDictionary[name].VertexBufferHandle = vboHandle;
CreateVerticesData(name, data, data.Count);
}
public void SetInstanceData(string name, List <Matrix4> instanceData)
{
GL.BindVertexArray(_objectsHandleDictionary[name].ObjectHandle);
int instanceHandle;
GL.GenBuffers(1, out instanceHandle);
_objectsHandleDictionary[name].InstanceBufferHandle = instanceHandle;
CreateInstanceData(name, instanceData, instanceData.Count);
}
public void SetNumericParameter(string name, float number, string shader)
{
GL.UseProgram(_shaderHandleDictionary[shader]);
int location = GL.GetUniformLocation(_shaderHandleDictionary[shader], name);
if (location != -1)
{
GL.Uniform1(location, number);
}
}
public void DrawPoints(string name, int pointCount, float pointSize)
{
if (!_objectsHandleDictionary.ContainsKey(name))
{
throw new ApplicationException("Object must be added to the renderer before drawing");
}
GL.BindVertexArray(_objectsHandleDictionary[name].ObjectHandle);
GL.PointSize(pointSize);
GL.DrawElements(BeginMode.Points, pointCount, DrawElementsType.UnsignedInt, IntPtr.Zero);
}
private void CreateVerticesData(string name, List <Vector3> data, int bufferSize)
{
GL.BindVertexArray(_objectsHandleDictionary[name].ObjectHandle);
var verticesArray = data.ToArray();
GL.BindBuffer(BufferTarget.ArrayBuffer, _objectsHandleDictionary[name].VertexBufferHandle);
GL.BufferData(BufferTarget.ArrayBuffer, new IntPtr(bufferSize * Vector3.SizeInBytes), verticesArray,
BufferUsageHint.DynamicDraw);
_objectsHandleDictionary[name].VertexBufferSize = bufferSize;
}
public void SetVectorArrayParameter(string name, int index, Vector3 vector, string shader)
{
GL.UseProgram(_shaderHandleDictionary[shader]);
int location = GL.GetUniformLocation(_shaderHandleDictionary[shader], name + "[" + index + "]");
if (location != -1)
{
GL.Uniform3(location, vector);
}
}
public void SetMatrixParameter(string name, Matrix4 matrix, string shader)
{
GL.UseProgram(_shaderHandleDictionary[shader]);
int location = GL.GetUniformLocation(_shaderHandleDictionary[shader], name);
if (location != -1)
{
GL.UniformMatrix4(location, false, ref matrix);
}
}
private void CreateInstanceData(string name, List <Matrix4> instanceData, int bufferSize)
{
GL.BindVertexArray(_objectsHandleDictionary[name].ObjectHandle);
var instancesArray = instanceData.ToArray();
GL.BindBuffer(BufferTarget.ArrayBuffer, _objectsHandleDictionary[name].InstanceBufferHandle);
GL.BufferData(BufferTarget.ArrayBuffer, new IntPtr(bufferSize * 4 * Vector4.SizeInBytes), instancesArray,
BufferUsageHint.DynamicDraw);
_objectsHandleDictionary[name].InstanceBufferSize = bufferSize;
}
private void LoadingScreenLoop()
{
GL.MatrixMode(MatrixMode.Projection);
GL.PushMatrix();
GL.LoadIdentity();
GL.Ortho(0.0, (double)Screen.Width, (double)Screen.Height, 0.0, -1.0, 1.0);
GL.Viewport(0, 0, Screen.Width, Screen.Height);
while (!Loading.Complete && !Loading.Cancel)
{
CPreciseTimer.GetElapsedTime();
this.ProcessEvents();
if (this.IsExiting)
{
Loading.Cancel = true;
}
Renderer.DrawLoadingScreen();
Program.currentGameWindow.SwapBuffers();
if (Loading.JobAvailable)
{
while (jobs.Count > 0)
{
lock (jobLock)
{
var currentJob = jobs.Dequeue();
var locker = locks.Dequeue();
currentJob();
lock (locker)
{
Monitor.Pulse(locker);
}
}
}
Loading.JobAvailable = false;
}
double time = CPreciseTimer.GetElapsedTime();
double wait = 1000.0 / 60.0 - time * 1000 - 50;
if (wait > 0)
{
Thread.Sleep((int)(wait));
}
}
if (!Loading.Cancel)
{
GL.PopMatrix();
GL.MatrixMode(MatrixMode.Projection);
SetupSimulation();
}
else
{
this.Exit();
}
}
public void DrawBackBuffer(GraphScaleData scaleData)
{
if (Hide || _backData == null)
{
return;
}
float height = ScaleFunction.ScaledHeight(scaleData);
Matrix4 transform = Matrix4.CreateTranslation(scaleData.XShift, 0, 0) * Matrix4.Scale(2 / scaleData.BaseScale, 2 / height, 1) * Matrix4.CreateTranslation(-1, -1, 0);
GL.UniformMatrix4(_shaderProgram.UniformTransform, false, ref transform);
if (_drawMode == BeginMode.Lines || _drawMode == BeginMode.LineLoop || _drawMode == BeginMode.LineStrip)
{
GL.LineWidth(2f);
}
else if (_drawMode == BeginMode.Points)
{
GL.PointSize(2f);
}
if (_alphaBlend > 0)
{
Color4 col = Color;
col.A = 1 - _alphaBlend;
GL.Uniform4(_shaderProgram.UniformColor, col);
}
else
{
GL.Uniform4(_shaderProgram.UniformColor, Color);
}
if (_graphType == GraphType.SolidGraph)
{
_backBuffer.SetAttributeInfo(_shaderProgram.AttributeCoord2D, 2);
_backBuffer.BeginDraw();
_backBuffer.Draw(_drawMode);
_backBuffer.EndDraw();
_backBuffer.SetAttributeInfo(_shaderProgram.AttributeCoord2D, 2, false, 2 * Vector2.SizeInBytes);
GL.Uniform4(_shaderProgram.UniformColor, Color4.Black);
GL.LineWidth(1f);
_backBuffer.BeginDraw();
_backBuffer.Draw(BeginMode.LineStrip, _backData.Length / 2);
_backBuffer.EndDraw();
}
else
{
_backBuffer.BeginDraw();
_backBuffer.Draw(_drawMode, _backData.Length / 2);
_backBuffer.EndDraw();
}
}
public void EnableZBuffer(bool enable)
{
if (enable)
{
GL.Enable(EnableCap.DepthTest);
}
else
{
GL.Disable(EnableCap.DepthTest);
}
}
private void GlControlLoad(object sender, EventArgs e)
{
GL.ClearColor(1, 1, 1, 1);
GL.Viewport(0, 0, glControl.Width, glControl.Height);
GL.ShadeModel(ShadingModel.Smooth);
GL.Hint(HintTarget.PolygonSmoothHint, HintMode.Nicest);
GL.Enable(EnableCap.Blend);
GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
_graph = new CaptureGraph();
_loaded = true;
}
public static void Render(params string[] message)
{
textPrinter.Begin();
foreach (string msg in message)
{
textPrinter.Print(msg, Font, Color.Gray);
GL.Translate(0, FontHeight, 0);
}
textPrinter.End();
}
public void SetVectorArrayParameter(string name, int index, Vector3 vector)
{
foreach (var shaderHandle in _shaderHandleDictionary.Values)
{
GL.UseProgram(shaderHandle);
int location = GL.GetUniformLocation(shaderHandle, name + "[" + index + "]");
if (location != -1)
{
GL.Uniform3(location, vector);
}
}
}
public void SetNumericParameter(string name, float number)
{
foreach (var shaderHandle in _shaderHandleDictionary.Values)
{
GL.UseProgram(shaderHandle);
int location = GL.GetUniformLocation(shaderHandle, name);
if (location != -1)
{
GL.Uniform1(location, number);
}
}
}
private void GlControlPaint(object sender, PaintEventArgs e)
{
if (!_loaded)
{
GL.ClearColor(Color4.LightSteelBlue);
GL.Clear(ClearBufferMask.ColorBufferBit);
}
else if (!_bound)
{
GL.ClearColor(Color4.SteelBlue);
GL.Clear(ClearBufferMask.ColorBufferBit);
}
else if (_screenCap)
{
_screenCap = false;
SuspendLayout();
_graph.HideUI();
Size tmp = glControl.Size;
glControl.Size = new Size(2000, 750);
CanvasManager.ChangeViewportSize(glControl.Size);
GL.ClearColor(Color4.White);
GL.Clear(ClearBufferMask.ColorBufferBit);
_graph.DrawGraph();
Bitmap bmp = new Bitmap(glControl.Width, this.glControl.Height);
BitmapData data =
bmp.LockBits(glControl.ClientRectangle, ImageLockMode.WriteOnly,
System.Drawing.Imaging.PixelFormat.Format24bppRgb);
GL.Finish();
GL.ReadPixels(0, 0, this.glControl.Width, this.glControl.Height, PixelFormat.Bgr, PixelType.UnsignedByte, data.Scan0);
bmp.UnlockBits(data);
bmp.RotateFlip(RotateFlipType.RotateNoneFlipY);
bmp.Save(_screenCapFile, ImageFormat.Png);
glControl.Size = tmp;
CanvasManager.ChangeViewportSize(glControl.Size);
_graph.ShowUI();
ResumeLayout();
}
else
{
GL.ClearColor(Color4.White);
GL.Clear(ClearBufferMask.ColorBufferBit);
_graph.DrawGraph();
}
glControl.SwapBuffers();
}
private int CreateProgram(int vertexShaderHandle, int fragmentShaderHandle)
{
int shaderProgramHandle = GL.CreateProgram();
GL.AttachShader(shaderProgramHandle, vertexShaderHandle);
GL.AttachShader(shaderProgramHandle, fragmentShaderHandle);
GL.LinkProgram(shaderProgramHandle);
Console.WriteLine(GL.GetProgramInfoLog(shaderProgramHandle));
return(shaderProgramHandle);
}
