public void Init(MainWindow mainWindow)
{
m_program = OpenGLHelper._CompilerShader(vShaderStr, fShaderStr);
m_meshData = OpenGLHelper.GetCubeMesh();
m_ptr = Marshal.AllocHGlobal(sizeof(float) * m_meshData.m_data.Length);
Marshal.Copy(m_meshData.m_data, 0, m_ptr, m_meshData.m_data.Length);
GL.Enable(EnableCap.DepthTest);
GL.DepthFunc(All.Lequal);
GL.Enable(EnableCap.CullFace);
OpenGLHelper.ClearGLError();
m_locAmbient = GL.GetUniformLocation(m_program, "ambientColor");
Debug.Log("m_locAmbient" + m_locAmbient);
OpenGLHelper.CheckGLError();
m_locDiffuse = GL.GetUniformLocation(m_program, "diffuseColor");
Debug.Log("m_locDiffuse" + m_locDiffuse);
m_locSpecular = GL.GetUniformLocation(m_program, "specularColor");
Debug.Log("m_locSpecular" + m_locSpecular);
m_locLight = GL.GetUniformLocation(m_program, "vLightPosition");
Debug.Log("m_locLight" + m_locLight);
m_locMVP = GL.GetUniformLocation(m_program, "mvpMatrix");
Debug.Log("m_locMVP" + m_locMVP);
m_locMV = GL.GetUniformLocation(m_program, "mvMatrix");
Debug.Log("m_locMV" + m_locMV);
//m_locNM = GL.GetUniformLocation(m_program, "normalMatrix");
m_width = mainWindow.Width;
m_height = mainWindow.Height;
}
public void Init(MainWindow mainWindow)
{
m_program = OpenGLHelper._CompilerShader(vShaderStr, fShaderStr);
m_textureId = CreateSimpleTexture2D();
m_screenTexId = CreateScreenSizeTexture2D();
float[] vVertices = new float[] { -0.5f, 0.5f, 0.0f, // Position 0
0.0f, 0.0f, // TexCoord 0
-0.5f, -0.5f, 0.0f, // Position 1
0.0f, 1.0f, // TexCoord 1
0.5f, -0.5f, 0.0f, // Position 2
1.0f, 1.0f, // TexCoord 2
0.5f, 0.5f, 0.0f, // Position 3
1.0f, 0.0f // TexCoord 3
};
m_ptr = Marshal.AllocHGlobal(sizeof(float) * vVertices.Length);
Marshal.Copy(vVertices, 0, m_ptr, vVertices.Length);
int pixelDataSize = mainWindow.Width * mainWindow.Height * 3 * sizeof(byte);
byte[] pixelData = new byte[pixelDataSize];
m_pboId = GL.GenBuffer();
GL.BindBuffer(All.PixelPackBuffer, m_pboId);
GL.BufferData(All.PixelPackBuffer, pixelData.Length, pixelData, All.DynamicCopy);
GL.BindBuffer(All.PixelPackBuffer, 0);
m_width = mainWindow.Width;
m_height = mainWindow.Height;
}
private static GLTexture BindGLTexture(STGenericTexture texture, STGenericTextureMap textureMap, ShaderProgram shader)
{
if (texture.RenderableTex == null)
{
texture.LoadRenderableTexture();
}
if (texture.RenderableTex == null)
{
return(null);
}
var target = ((GLTexture)texture.RenderableTex).Target;
GL.BindTexture(target, texture.RenderableTex.ID);
GL.TexParameter(target, TextureParameterName.TextureWrapS, (int)OpenGLHelper.WrapMode[textureMap.WrapU]);
GL.TexParameter(target, TextureParameterName.TextureWrapT, (int)OpenGLHelper.WrapMode[textureMap.WrapV]);
GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)OpenGLHelper.MinFilter[textureMap.MinFilter]);
GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)OpenGLHelper.MagFilter[textureMap.MagFilter]);
GL.TexParameter(target, TextureParameterName.TextureLodBias, textureMap.LODBias);
GL.TexParameter(target, TextureParameterName.TextureMaxLod, textureMap.MaxLOD);
GL.TexParameter(target, TextureParameterName.TextureMinLod, textureMap.MinLOD);
int[] mask = new int[4]
{
OpenGLHelper.GetSwizzle(texture.RedChannel),
OpenGLHelper.GetSwizzle(texture.GreenChannel),
OpenGLHelper.GetSwizzle(texture.BlueChannel),
OpenGLHelper.GetSwizzle(texture.AlphaChannel),
};
GL.TexParameter(target, TextureParameterName.TextureSwizzleRgba, mask);
return((GLTexture)texture.RenderableTex);
}
private void ButtonImport_OnClick(object sender, RoutedEventArgs e)
{
List <int> SelectedGroups = new List <int>();
for (int i = 0; i < AvailableGroups.Count; i++)
{
foreach (var selectedItem in ListGroups.SelectedItems)
{
if ((string)selectedItem == AvailableGroups[i])
{
SelectedGroups.Add(i);
}
}
}
using (Stream SessionStream = File.OpenRead(SessionPath))
{
XPathDocument Doc = new XPathDocument(SessionStream);
XPathNavigator Reader = Doc.CreateNavigator();
Reader.MoveToRoot();
int iGroup = 0;
foreach (XPathNavigator groupNav in Reader.Select("//PointGroups/Group"))
{
if (SelectedGroups.Contains(iGroup))
{
PointGroup NewGroup = new PointGroup
{
Name = XMLHelper.LoadAttribute(groupNav, "Name", "Group " + (MainWindow.Options.Membrane.PointGroups.Count + 1)),
Size = XMLHelper.LoadAttribute(groupNav, "Size", 10),
Color = ColorHelper.LoadAttribute(groupNav, "Color", ColorHelper.SpectrumColor(MainWindow.Options.Membrane.PointGroups.Count, 0.3f))
};
NewGroup.PointCloud.GLContext = MainWindow.Options.Viewport.GetControl();
foreach (XPathNavigator pointNav in groupNav.SelectChildren("Point", ""))
{
int TriangleID = XMLHelper.LoadAttribute(pointNav, "ID", 0);
SurfacePoint NewPoint = new SurfacePoint(OpenGLHelper.LoadAttribute(pointNav, "Position", new Vector3(0)),
MainWindow.Options.Membrane.SurfaceMesh.Triangles[TriangleID < MainWindow.Options.Membrane.SurfaceMesh.Triangles.Count ? TriangleID : 0],
OpenGLHelper.LoadAttribute(pointNav, "Barycentric", new Vector3(0)),
XMLHelper.LoadAttribute(pointNav, "Offset", 0f),
OpenGLHelper.LoadAttribute(pointNav, "Orientation", new Vector3(0)).X);
NewGroup.Points.Add(NewPoint);
}
MainWindow.Options.Membrane.PointGroups.Add(NewGroup);
NewGroup.IsVisible = XMLHelper.LoadAttribute(groupNav, "IsVisible", true);
}
iGroup++;
}
}
if (SelectedGroups.Count > 0)
{
MainWindow.Options.Viewport.Redraw();
}
Close();
}
public void Init(MainWindow mainWindow)
{
m_program = OpenGLHelper._CompilerShader(vShaderStr, fShaderStr);
int vtxStride = sizeof(float) * (VERTEX_POS_SIZE + VERTEX_COLOR_SIZE);
GL.GenBuffers(2, m_vboBuff);
GL.BindBuffer(BufferTarget.ArrayBuffer, m_vboBuff[0]);
GL.BufferData(BufferTarget.ArrayBuffer, vtxStride * m_indices.Length, m_vertices, BufferUsageHint.StaticDraw);
GL.BindBuffer(BufferTarget.ElementArrayBuffer, m_vboBuff[1]);
GL.BufferData(BufferTarget.ElementArrayBuffer, sizeof(ushort) * m_indices.Length, m_indices, BufferUsageHint.StaticDraw);
m_vaoId = GL.GenVertexArray();
GL.BindVertexArray(m_vaoId);
GL.BindBuffer(BufferTarget.ArrayBuffer, m_vboBuff[0]);
GL.BindBuffer(BufferTarget.ElementArrayBuffer, m_vboBuff[1]);
GL.EnableVertexAttribArray(VERTEX_POS_INDX);
GL.EnableVertexAttribArray(VERTEX_COLOR_INDX);
int offset = 0;
GL.VertexAttribPointer(VERTEX_POS_INDX, VERTEX_POS_SIZE, VertexAttribPointerType.Float, false, vtxStride, offset);
offset += VERTEX_POS_SIZE * sizeof(float);
GL.VertexAttribPointer(VERTEX_COLOR_INDX, VERTEX_COLOR_SIZE, VertexAttribPointerType.Float, false, vtxStride, offset);
GL.BindVertexArray(0);
}
public void Init(MainWindow mainWindow)
{
m_mainWindow = mainWindow;
m_renderPorgram = OpenGLHelper._CompilerShader(m_vertexShaderSrc, m_pixelShaderSrc);
m_vertexArrayObject = GL.GenVertexArray();
GL.BindVertexArray(m_vertexArrayObject);
}
private Vector2 GetMouseCoords(Point screenMouse)
{
RenderEditor();
var coords = OpenGLHelper.convertScreenToWorldCoords(screenMouse.X, screenMouse.Y);
GL.PopMatrix();
return(new Vector2(coords.X, coords.Y));
}
void DrawCube()
{
float[] float_zeros = new float[] { 0.0f, 0.0f, 0.0f, 0.0f };
float[] float_ones = new float[] { 1.0f, 1.0f, 1.0f, 1.0f };
GL.BindFramebuffer(All.Framebuffer, m_gbuffer);
GL.Viewport(0, 0, m_width, m_height);
All[] draw_buffers = new All[] { All.ColorAttachment0, All.ColorAttachment1 };
GL.DrawBuffers(2, draw_buffers);
GL.ClearBuffer(All.Color, 0, float_zeros);
GL.ClearBuffer(All.Color, 1, float_zeros);
GL.ClearBuffer(All.Depth, 0, float_ones);
//float[] black = new float[] { 0, 0, 0, 1 };
//GL.ClearBuffer(ClearBuffer.Color, 0, black);
//float[] ones = new float[] { 1.0f };
//GL.ClearBuffer(ClearBuffer.Depth, 0, ones);
GL.UseProgram(m_prePassProgram);
const int POS_INDEX = 0;
const int NORMAL_INDEX = 1;
const int POS_SIZE = 3;
const int NORMAL_SIZE = 3;
GL.VertexAttribPointer(POS_INDEX, POS_SIZE, All.Float, false, (POS_SIZE + NORMAL_SIZE) * sizeof(float), m_ptrCube);
GL.VertexAttribPointer(NORMAL_INDEX, NORMAL_SIZE, All.Float, false, (POS_SIZE + NORMAL_SIZE) * sizeof(float), m_ptrCube + sizeof(float) * POS_SIZE);
GL.EnableVertexAttribArray(POS_INDEX);
GL.EnableVertexAttribArray(NORMAL_INDEX);
float[] vEyeLight = { -100.0f, 100.0f, 100.0f };
OpenTK.Matrix4 model = OpenGLHelper.GLSRT(OpenTK.Vector3.One, OpenTK.Quaternion.Identity, OpenTK.Vector3.One);
OpenTK.Matrix4 view = OpenGLHelper.GLLookAt(new OpenTK.Vector3(10, 10, 10), OpenTK.Vector3.Zero, new OpenTK.Vector3(0, 1, 0));
OpenTK.Matrix4 projection = OpenGLHelper.GLPerspective(60, m_width / (float)m_height, 0.1f, 100f);
OpenTK.Matrix4 mv = OpenGLHelper.GLVMathMultiply(view, model);
OpenTK.Matrix4 mvp = OpenGLHelper.GLVMathMultiply(projection, mv);
GL.Uniform3(m_locLight, 1, vEyeLight);
GL.UniformMatrix4(m_locMVP, 1, false, OpenGLHelper.ConverToFloat(mvp));
GL.UniformMatrix4(m_locMV, false, ref mv);
GL.Enable(EnableCap.DepthTest);
GL.DepthFunc(All.Lequal);
GL.Enable(EnableCap.CullFace);
GL.DrawElements(PrimitiveType.Triangles, m_meshData.m_index.Length, DrawElementsType.UnsignedShort, m_meshData.m_index);
GL.DisableVertexAttribArray(POS_INDEX);
GL.DisableVertexAttribArray(NORMAL_INDEX);
GL.BindFramebuffer(All.Framebuffer, 0);
GL.Disable(EnableCap.DepthTest);
GL.Disable(EnableCap.CullFace);
}
static void BindTexture(STGenericTexture tex)
{
if (tex == null)
{
return;
}
if (tex.RenderableTex == null)
{
tex.LoadRenderableTexture();
}
var target = ((GLTexture)tex.RenderableTex).Target;
var texID = tex.RenderableTex.ID;
if (tex.Platform.OutputFormat == TexFormat.BC5_SNORM)
{
if (!GLTextureCache.DecodedFormats.ContainsKey(texID))
{
var reloaded = GLTexture2D.FromGeneric(tex, new ImageParameters()
{
UseSoftwareDecoder = (tex.Platform.OutputFormat == TexFormat.BC5_SNORM),
});
GLTextureCache.DecodedFormats.Add(texID, reloaded.ID);
}
texID = GLTextureCache.DecodedFormats[texID];
}
//Fixed mip layer with nearest setting
GL.BindTexture(target, texID);
GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Nearest);
GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Nearest);
GL.TexParameter(target, TextureParameterName.TextureMaxLod, (int)15);
GL.TexParameter(target, TextureParameterName.TextureMinLod, (int)mipLevel);
int[] mask = new int[4] {
(int)All.Red, (int)All.Green, (int)All.Blue, (int)All.Alpha
};
if (ImageEditor.UseChannelComponents)
{
mask = new int[4]
{
OpenGLHelper.GetSwizzle(tex.RedChannel),
OpenGLHelper.GetSwizzle(tex.GreenChannel),
OpenGLHelper.GetSwizzle(tex.BlueChannel),
//For now prevent full disappearance of zero alpha types on alpha channel.
//This is typically used on BC4 and BC5 types when not using alpha data.
tex.AlphaChannel == STChannelType.Zero ? 1 : OpenGLHelper.GetSwizzle(tex.AlphaChannel),
};
}
GL.TexParameter(target, TextureParameterName.TextureSwizzleRgba, mask);
}
void DrawQuad()
{
float[] black = new float[] { 0, 0, 0, 1 };
GL.ClearBuffer(ClearBuffer.Color, 0, black);
GL.Viewport(0, 0, m_width, m_height);
//GL.DrawBuffer(All.Back);
GL.UseProgram(m_lightPassProgram);
OpenGLHelper.ClearGLError();
GL.Uniform1(m_locTex0, 0);
OpenGLHelper.CheckGLError();
GL.Uniform1(m_locTex1, 1);
GL.ActiveTexture(All.Texture0);
GL.BindTexture(All.Texture2D, m_gbuffer_tex[0]);
GL.ActiveTexture(All.Texture1);
GL.BindTexture(All.Texture2D, m_gbuffer_tex[1]);
float[] vAmbientColor = { 0.1f, 0.1f, 0.1f, 1.0f };
float[] vDiffuseColor = { 0.0f, 0.0f, 1.0f, 1.0f };
GL.Uniform4(m_locAmbient, 1, vAmbientColor);
GL.Uniform4(m_locDiffuse, 1, vDiffuseColor);
//GL.BindVertexArray(fs_quad_vao);
//GL.DrawArrays(All.TriangleStrip, 0, 4);
const int POS_INDEX = 0;
const int UV_INDEX = 1;
const int POS_SIZE = 3;
const int UV_SIZE = 2;
GL.EnableVertexAttribArray(POS_INDEX);
GL.EnableVertexAttribArray(UV_INDEX);
GL.VertexAttribPointer(POS_INDEX, POS_SIZE, All.Float, false, (POS_SIZE + UV_SIZE) * sizeof(float), m_ptrQuad);
GL.VertexAttribPointer(UV_INDEX, UV_SIZE, All.Float, false, (POS_SIZE + UV_SIZE) * sizeof(float), m_ptrQuad + sizeof(float) * POS_SIZE);
//OpenGLHelper.ClearGLError();
//GL.Uniform1(m_locTex1, m_gbuffer_tex[1]);
//OpenGLHelper.CheckGLError();
GL.DrawElements(PrimitiveType.Triangles, m_quadIndices.Length, DrawElementsType.UnsignedShort, m_quadIndices);
GL.DisableVertexAttribArray(POS_INDEX);
GL.DisableVertexAttribArray(UV_INDEX);
}
public void Init(MainWindow mainWindow)
{
m_program = OpenGLHelper._CompilerShader(vShaderStr, fShaderStr);
m_textureId = CreateSimpleTexture2D();
float[] vVertices = new float[] { -0.5f, 0.5f, 0.0f, // Position 0
0.0f, 0.0f, // TexCoord 0
-0.5f, -0.5f, 0.0f, // Position 1
0.0f, 1.0f, // TexCoord 1
0.5f, -0.5f, 0.0f, // Position 2
1.0f, 1.0f, // TexCoord 2
0.5f, 0.5f, 0.0f, // Position 3
1.0f, 0.0f // TexCoord 3
};
m_ptr = Marshal.AllocHGlobal(sizeof(float) * vVertices.Length);
Marshal.Copy(vVertices, 0, m_ptr, vVertices.Length);
}
public static int CreateTextureRender(STGenericTexture texture, int width, int height, bool displayAlpha = true)
{
if (texture.RenderableTex == null)
{
texture.LoadRenderableTexture();
}
if (texture.RenderableTex == null)
{
return(-1);
}
int ID = texture.RenderableTex.ID;
if (texture.Platform.OutputFormat == TexFormat.BC5_SNORM)
{
var reloaded = GLTexture2D.FromGeneric(texture, new ImageParameters()
{
UseSoftwareDecoder = (texture.Platform.OutputFormat == TexFormat.BC5_SNORM),
});
ID = reloaded.ID;
}
var shader = GlobalShaders.GetShader("TEXTURE_ICON");
Framebuffer frameBuffer = new Framebuffer(FramebufferTarget.Framebuffer, width, height, PixelInternalFormat.Rgba, 1);
frameBuffer.Bind();
GL.ClearColor(0, 0, 0, 0);
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
GL.Viewport(0, 0, width, height);
GL.Disable(EnableCap.Blend);
shader.Enable();
shader.SetBoolToInt("isSRGB", texture.IsSRGB);
int[] mask = new int[4]
{
OpenGLHelper.GetSwizzle(texture.RedChannel),
OpenGLHelper.GetSwizzle(texture.GreenChannel),
OpenGLHelper.GetSwizzle(texture.BlueChannel),
OpenGLHelper.GetSwizzle(displayAlpha ? texture.AlphaChannel : STChannelType.One),
};
((GLTexture)texture.RenderableTex).Bind();
GL.TexParameter(((GLTexture)texture.RenderableTex).Target, TextureParameterName.TextureSwizzleRgba, mask);
//Draw the texture onto the framebuffer
ScreenQuadRender.Draw(shader, ID);
//Disable shader and textures
GL.UseProgram(0);
GL.BindTexture(TextureTarget.Texture2D, 0);
var image = (GLTexture2D)frameBuffer.Attachments[0];
return(image.ID);
/* //Dispose frame buffer
* frameBuffer.Dispoe();
* frameBuffer.DisposeRenderBuffer();*/
}
public float[] GetViewProjAsArray()
{
return(OpenGLHelper.ToFloatArray(GetViewProj()));
}
private void glControl1_MouseMove(object sender, MouseEventArgs e)
{
var mouseCoords = GetMouseCoords(e.Location);
var picks = SearchHit(mouseCoords.X, mouseCoords.Y);
if (picks.Count > 0)
{
if (!picks[0].IsSelected)
{
picks[0].IsHovered = true;
glControl1.Invalidate();
}
}
else
{
foreach (var obj in GetPickableObjects())
{
obj.IsHovered = false;
}
glControl1.Invalidate();
}
if (mouseCameraDown)
{
var pos = new Vector2(e.Location.X - originMouse.X, e.Location.Y - originMouse.Y);
Camera.Position.X += pos.X;
Camera.Position.Y -= pos.Y;
originMouse = e.Location;
glControl1.Invalidate();
}
if (!showSelectionBox && isPicked)
{
Console.WriteLine(pickAction);
RenderEditor();
var temp = e.Location;
var curPos = OpenGLHelper.convertScreenToWorldCoords(temp.X, temp.Y);
var prevPos = OpenGLHelper.convertScreenToWorldCoords(pickOriginMouse.X, pickOriginMouse.Y);
var pickMouse = new Point((int)(prevPos.X - curPos.X), (int)(prevPos.Y - curPos.Y));
Console.WriteLine("curPos " + curPos);
Console.WriteLine("prevPos " + prevPos);
GL.PopMatrix();
if (pickAction == PickAction.Translate)
{
foreach (var pickObject in SelectedObjects)
{
if (pickOriginMouse != Point.Empty)
{
float posX = 0;
float posY = 0;
float posZ = 0;
if (pickAxis == PickAxis.X)
{
posX = pickMouse.X;
}
if (pickAxis == PickAxis.Y)
{
posY = pickMouse.Y;
}
if (pickAxis == PickAxis.All)
{
posX = pickMouse.X;
posY = pickMouse.Y;
}
pickObject.PickTranslate(posX, posY, posZ);
}
}
}
if (pickAction == PickAction.Rotate)
{
foreach (var pickObject in SelectedObjects)
{
if (pickOriginMouse != Point.Empty)
{
float rotX = 0;
float rotY = 0;
float rotZ = 0;
if (pickAxis == PickAxis.X)
{
rotX = pickMouse.X * -0.015625f;
}
if (pickAxis == PickAxis.Y)
{
rotY = pickMouse.Y;
}
if (pickAxis == PickAxis.All)
{
rotX = pickMouse.X * -0.015625f;
// rotY = pickMouse.Y;
}
pickObject.PickRotate(rotX, rotY, rotZ);
}
}
}
pickOriginMouse = temp;
glControl1.Invalidate();
}
if (mouseDown && !isPicked)
{
RenderEditor();
var temp = e.Location;
var curPos = OpenGLHelper.convertScreenToWorldCoords(temp.X, temp.Y);
var prevPos = OpenGLHelper.convertScreenToWorldCoords(pickOriginMouse.X, pickOriginMouse.Y);
GL.PopMatrix();
DrawSelectionBox(prevPos, curPos);
}
}
private void Viewport_Paint()
{
lock (RenderSync)
{
Viewport.MakeCurrent();
Membrane.MeshProgram.Use();
{
Membrane.MeshProgram.SetUniform("worldViewProjMatrix", Viewport.Camera.GetViewProj());
Membrane.MeshProgram.SetUniform("surfaceOffset",
(float)SurfaceOffset * MainWindow.Options.PixelScale.X);
if (Membrane.TomogramTexture != null)
{
Membrane.MeshProgram.SetUniform("useVolume", 1f);
Membrane.MeshProgram.SetUniform("volScale", OpenGLHelper.Reciprocal(Membrane.TomogramTexture.Scale));
Membrane.MeshProgram.SetUniform("volOffset", Membrane.TomogramTexture.Offset);
Membrane.MeshProgram.SetUniform("texSize", OpenGLHelper.Reciprocal(Membrane.TomogramTexture.Size));
GL.ActiveTexture(TextureUnit.Texture0);
GL.BindTexture(TextureTarget.Texture3D, Membrane.TomogramTexture.Handle);
}
else
{
Membrane.MeshProgram.SetUniform("useVolume", 0f);
}
GL.ActiveTexture(TextureUnit.Texture1);
GL.BindTexture(TextureTarget.Texture2D, Membrane.SelectionTexture.Handle);
float TraceStart = TraceDepthOffset;
float TraceLength = TraceDepth;
Membrane.MeshProgram.SetUniform("traceParams", new Vector2(TraceStart, TraceLength));
Membrane.MeshProgram.SetUniform("traceSharpening", (float)TraceSharpening / 100f);
float RangeMin = (float)Math.Min(OutputRangeMin, OutputRangeMax),
RangeMax = (float)Math.Max(OutputRangeMin, OutputRangeMax);
Membrane.MeshProgram.SetUniform("normalizeParams", new Vector2(RangeMin, RangeMax - RangeMin));
Vector3 LightDirection = Viewport.Camera.GetDirection();
Membrane.MeshProgram.SetUniform("lightDirection", LightDirection);
Membrane.MeshProgram.SetUniform("lightIntensity", 0.0f);
SurfaceMesh?.Draw();
}
Membrane.PointProgram.Use();
{
Membrane.PointProgram.SetUniform("worldViewProjMatrix",
MainWindow.Options.Viewport.Camera.GetViewProj());
// Draw back faces first, then front, to ensure correct transparency (locally)
GL.Enable(EnableCap.CullFace);
GL.CullFace(CullFaceMode.Front);
foreach (PointGroup group in PointGroups.Where(g => g.IsVisible && g.Points.Count > 0))
{
Membrane.PointProgram.SetUniform("cubeSize",
(float)group.Size * MainWindow.Options.PixelScale.X);
group.PointCloud.Draw();
}
GL.CullFace(CullFaceMode.Back);
foreach (PointGroup group in PointGroups.Where(g => g.IsVisible && g.Points.Count > 0))
{
Membrane.PointProgram.SetUniform("cubeSize",
(float)group.Size * MainWindow.Options.PixelScale.X);
group.PointCloud.Draw();
}
GL.Disable(EnableCap.CullFace);
}
}
}
public void SetUniform(string name, Matrix4 value)
{
float[] AsArray = OpenGLHelper.ToFloatArray(value);
GL.ProgramUniformMatrix4(Handle, GetUniformIndex(name), 1, false, AsArray);
}
public void Viewport_Paint()
{
if (SurfaceMesh != null)
{
Vector3[] Bounds = SurfaceMesh.BoundingBoxCorners;
Matrix4 ViewMatrix = Viewport.Camera.GetView();
float MinDist = float.MaxValue;
float MaxDist = -float.MaxValue;
foreach (var corner in Bounds)
{
float Dist = -Vector3.Transform(corner, ViewMatrix).Z;
MinDist = Math.Min(MinDist, Dist);
MaxDist = Math.Max(MaxDist, Dist);
}
MainWindow.Options.Viewport.Camera.ClipNear = Math.Max(1f, MinDist / 2);
MainWindow.Options.Viewport.Camera.ClipFar = Math.Max(2f, MaxDist * 2);
}
MeshProgram.Use();
{
MeshProgram.SetUniform("worldViewProjMatrix", MainWindow.Options.Viewport.Camera.GetViewProj());
MeshProgram.SetUniform("surfaceOffset", (float)SurfaceOffset * MainWindow.Options.PixelScale.X);
if (TomogramTexture != null)
{
MeshProgram.SetUniform("useVolume", 1f);
MeshProgram.SetUniform("volScale", OpenGLHelper.Reciprocal(TomogramTexture.Scale));
MeshProgram.SetUniform("volOffset", TomogramTexture.Offset);
MeshProgram.SetUniform("texSize", OpenGLHelper.Reciprocal(TomogramTexture.Size));
GL.ActiveTexture(TextureUnit.Texture0);
GL.BindTexture(TextureTarget.Texture3D, TomogramTexture.Handle);
}
else
{
MeshProgram.SetUniform("useVolume", 0f);
}
GL.ActiveTexture(TextureUnit.Texture1);
GL.BindTexture(TextureTarget.Texture2D, SelectionTexture.Handle);
float TraceStart = TraceDepthOffset;
float TraceLength = TraceDepth;
MeshProgram.SetUniform("traceParams", new Vector2(TraceStart, TraceLength));
MeshProgram.SetUniform("traceSharpening", (float)TraceSharpening / 100f);
float RangeMin = (float)Math.Min(OutputRangeMin, OutputRangeMax), RangeMax = (float)Math.Max(OutputRangeMin, OutputRangeMax);
MeshProgram.SetUniform("normalizeParams", new Vector2(RangeMin, RangeMax - RangeMin));
Vector3 LightDirection = MainWindow.Options.Viewport.Camera.GetDirection();
MeshProgram.SetUniform("lightDirection", LightDirection);
MeshProgram.SetUniform("lightIntensity", OutputLight / 100f);
if (SurfaceMesh != null)
{
SurfaceMesh.Draw();
}
}
// Draw point groups. There are 3 options for depiction:
// - Boxes with custom size
// - Same mesh for every point in a group, e. g. protein map from EMDB
// - Individual mesh for every point in a group, e. g. isosurface within its enclosed volume
{
List <PointGroup> AllGroups = new List <PointGroup>(PointGroups);
AllGroups.Add(PreviewGroup);
foreach (PointGroup group in AllGroups.Where(g => g.IsVisible && g.Points.Count > 0))
{
if (group.Depiction == PointDepiction.Box)
{
// Draw orientation gizmos
PointGizmoProgram.Use();
PointGizmoProgram.SetUniform("worldViewProjMatrix", MainWindow.Options.Viewport.Camera.GetViewProj());
GL.LineWidth(10f);
PointGizmoProgram.SetUniform("cubeSize", (float)group.Size * MainWindow.Options.PixelScale.X);
group.PointCloud.Draw();
// Draw boxes
PointProgram.Use();
PointProgram.SetUniform("worldViewProjMatrix", MainWindow.Options.Viewport.Camera.GetViewProj());
// Draw back faces first, then front, to ensure correct transparency (locally)
GL.Enable(EnableCap.CullFace);
GL.CullFace(CullFaceMode.Front);
PointProgram.SetUniform("cubeSize", (float)group.Size * MainWindow.Options.PixelScale.X);
group.PointCloud.Draw();
GL.CullFace(CullFaceMode.Back);
PointProgram.SetUniform("cubeSize", (float)group.Size * MainWindow.Options.PixelScale.X);
group.PointCloud.Draw();
GL.Disable(EnableCap.CullFace);
}
else if (group.Depiction == PointDepiction.Mesh)
{
PointModelProgram.Use();
PointModelProgram.SetUniform("modelColor", ColorHelper.ColorToVector(group.Color, true));
PointModelProgram.SetUniform("cameraDirection", Viewport.Camera.GetDirection());
foreach (var point in group.Points)
{
PointModelProgram.SetUniform("isSelected", point.IsSelected ? 1f : 0f);
Vector3 Offset = point.TransformedMatrix.Column2 * (float)group.DepictionMeshOffset;
PointModelProgram.SetUniform("worldViewProjMatrix", Matrix4.CreateTranslation(point.Position + Offset) * MainWindow.Options.Viewport.Camera.GetViewProj());
PointModelProgram.SetUniform("rotationMatrix", Matrix3.Transpose(point.TransformedMatrix));
group.DepictionMesh?.Draw();
}
}
else if (group.Depiction == PointDepiction.LocalSurface)
{
PointModelProgram.Use();
PointModelProgram.SetUniform("modelColor", ColorHelper.ColorToVector(group.Color, true));
PointModelProgram.SetUniform("cameraDirection", Viewport.Camera.GetDirection());
foreach (var point in group.Points)
{
PointModelProgram.SetUniform("isSelected", point.IsSelected ? 1f : 0f);
PointModelProgram.SetUniform("worldViewProjMatrix", Matrix4.CreateTranslation(point.Position) * MainWindow.Options.Viewport.Camera.GetViewProj());
PointModelProgram.SetUniform("rotationMatrix", Matrix3.Identity);
point.DepictionMesh?.Draw();
}
// Also draw the orientation stick
if (KeyboardHelper.CtrlDown())
{
PointGizmoProgram.Use();
PointGizmoProgram.SetUniform("worldViewProjMatrix", MainWindow.Options.Viewport.Camera.GetViewProj());
GL.LineWidth(10f);
PointGizmoProgram.SetUniform("cubeSize", (float)group.Size * MainWindow.Options.PixelScale.X);
group.PointCloud.Draw();
}
}
}
}
}
public void OnRenderFrame(OpenTK.FrameEventArgs e)
{
//ushort[] indices = { 0, 1, 2, 0, 2, 3 };
float[] black = new float[] { 0, 0, 0, 1 };
GL.ClearBuffer(ClearBuffer.Color, 0, black);
float[] ones = new float[] { 1.0f };
GL.ClearBuffer(ClearBuffer.Depth, 0, ones);
GL.UseProgram(m_program);
const int POS_INDEX = 0;
const int NORMAL_INDEX = 1;
const int POS_SIZE = 3;
const int NORMAL_SIZE = 3;
GL.VertexAttribPointer(POS_INDEX, POS_SIZE, All.Float, false, (POS_SIZE + NORMAL_SIZE) * sizeof(float), m_ptr);
GL.VertexAttribPointer(NORMAL_INDEX, NORMAL_SIZE, All.Float, false, (POS_SIZE + NORMAL_SIZE) * sizeof(float), m_ptr + sizeof(float) * POS_SIZE);
GL.EnableVertexAttribArray(POS_INDEX);
GL.EnableVertexAttribArray(NORMAL_INDEX);
float[] vEyeLight = { -100.0f, 100.0f, 100.0f };
float[] vAmbientColor = { 0.1f, 0.1f, 0.1f, 1.0f };
float[] vDiffuseColor = { 0.0f, 0.0f, 1.0f, 1.0f };
float[] vSpecularColor = { 1.0f, 1.0f, 1.0f, 1.0f };
GL.Uniform4(m_locAmbient, 1, vAmbientColor);
GL.Uniform4(m_locDiffuse, 1, vDiffuseColor);
GL.Uniform4(m_locSpecular, 1, vSpecularColor);
GL.Uniform3(m_locLight, 1, vEyeLight);
m_accTime += e.Time;
Matrix4x4 modelUnity = Matrix4x4.TRS(Vector3.one, Quaternion.identity, Vector3.one);
Transform cameraTrans = new Transform();
cameraTrans.position = new Vector3(10, 10, 10);
cameraTrans.forward = Vector3.zero - cameraTrans.position;
Matrix4x4 cameraLocalToWorld = cameraTrans.localToWorldMatrix;
Matrix4x4 viewUnity = OpenGLHelper.UnityWorldToCameraMatrix(cameraLocalToWorld);
Matrix4x4 projectionUnity = Matrix4x4.Perspective(60, m_width / (float)m_height, 0.1f, 100f);
Matrix4x4 mvUnity = viewUnity * modelUnity;
Matrix4x4 mvpUnity = projectionUnity * viewUnity * modelUnity;
Matrix4x4 mvUnity2 = viewUnity.transpose * modelUnity.transpose;
Matrix4x4 mvpUnity2 = projectionUnity.transpose * viewUnity.transpose * modelUnity.transpose;
//Vector3 testPoint = Vector3.one;
Vector4 testPoint = mvpUnity.MultiplyPoint(Vector3.one);
//Vector4 testPoint = mvpUnity * Vector3.one;
//Matrix4x4 cameraLocalToWorldUnity = Matrix4x4.TRS(new Vector3(10, 10, 10), Quaternion.Euler(45, 0, 0), Vector3.one);
//Matrix4x4 view = UnityWorldToCameraMatrix(cameraLocalToWorld);
//Matrix4x4 projection = Matrix4x4.Perspective(60, m_width / (float)m_height, 0.1f, 100f);
//Matrix4x4 mv = view * model;
//Matrix4x4 mvp = projection * view * model;
OpenTK.Matrix4 model = OpenGLHelper.GLSRT(OpenTK.Vector3.One, OpenTK.Quaternion.Identity, OpenTK.Vector3.One);
//OpenTK.Matrix4 cameraLocaltoWorld = TRS(new OpenTK.Vector3(0, 0, 50), new OpenTK.Quaternion(0, 0, 0), OpenTK.Vector3.One);
//OpenTK.Matrix4 view = worldToCameraMatrix(cameraLocaltoWorld);
OpenTK.Matrix4 view = OpenGLHelper.GLLookAt(new OpenTK.Vector3(10, 10, 10), OpenTK.Vector3.Zero, new OpenTK.Vector3(0, 1, 0));
OpenTK.Matrix4 projection = OpenGLHelper.GLPerspective(60, m_width / (float)m_height, 0.1f, 100f);
// 坑死。。opengl变换从左往右乘
OpenTK.Matrix4 mv = model * view;
OpenTK.Matrix4 mv2 = OpenGLHelper.Multiply(model, view);
OpenTK.Matrix4 mv3 = OpenGLHelper.GLVMathMultiply(view, model);
OpenTK.Matrix4 mvp = model * view * projection;
OpenTK.Matrix4 mvp2 = OpenGLHelper.Multiply(mv2, projection);
OpenTK.Matrix4 mvp3 = OpenGLHelper.GLVMathMultiply(projection, mv3);
OpenTK.Vector4 testPoint2 = OpenGLHelper.LeftMultiply(OpenTK.Vector3.One, mvp);
testPoint2 /= testPoint2.W;
OpenTK.Vector4 testPoint3 = OpenGLHelper.RightMultiply(mvp, OpenTK.Vector3.One);
//OpenTK.Vector4 testPoint4 = LeftMultiply(OpenTK.Vector3.One, mvp);
//UnityEngine.Debug.Log(mvp.ToString());
//OpenTK.Matrix4 mvp2 = ConverToFloat2(mvp);
//OpenTK.Matrix4 mv2 = ConverToFloat2(mv);
OpenGLHelper.ClearGLError();
//GL.UniformMatrix4(m_locMVP, false, ref mvp);
GL.UniformMatrix4(m_locMVP, 1, false, OpenGLHelper.ConverToFloat(mvp));
OpenGLHelper.CheckGLError();
GL.UniformMatrix4(m_locMV, false, ref mv);
//GL.UniformMatrix4(m_locMVP, 1, false, ConverToFloat(mvp));
//GL.UniformMatrix4(m_locMV, 1, false, ConverToFloat(mv));
GL.DrawElements(PrimitiveType.Triangles, m_meshData.m_index.Length, DrawElementsType.UnsignedShort, m_meshData.m_index);
}
public void Init(MainWindow mainWindow)
{
m_program = OpenGLHelper._CompilerShader(vShaderStr, fShaderStr);
}
public void Init(MainWindow mainWindow)
{
m_prePassProgram = OpenGLHelper._CompilerShader(prePassVShader, prePassFShader);
m_lightPassProgram = OpenGLHelper._CompilerShader(lightPassVShader, lightPassFShader);
m_meshData = OpenGLHelper.GetCubeMesh();
m_ptrCube = Marshal.AllocHGlobal(sizeof(float) * m_meshData.m_data.Length);
Marshal.Copy(m_meshData.m_data, 0, m_ptrCube, m_meshData.m_data.Length);
m_width = mainWindow.Width;
m_height = mainWindow.Height;
float[] quadVertices = new float[] { -1f, 1f, 0.0f, // Position 0
0.0f, 0.0f, // TexCoord 0
-1f, -1f, 0.0f, // Position 1
0.0f, 1.0f, // TexCoord 1
1f, -1f, 0.0f, // Position 2
1.0f, 1.0f, // TexCoord 2
1f, 1f, 0.0f, // Position 3
1.0f, 0.0f // TexCoord 3
};
m_ptrQuad = Marshal.AllocHGlobal(sizeof(float) * quadVertices.Length);
Marshal.Copy(quadVertices, 0, m_ptrQuad, quadVertices.Length);
m_gbuffer = GL.GenFramebuffer();
GL.BindFramebuffer(All.Framebuffer, m_gbuffer);
GL.GenTextures(3, m_gbuffer_tex);
GL.BindTexture(All.Texture2D, m_gbuffer_tex[0]);
GL.TexStorage2D(All.Texture2D, 1, All.Rgba32f, m_width, m_height);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)All.Nearest);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)All.Nearest);
GL.BindTexture(All.Texture2D, m_gbuffer_tex[1]);
GL.TexStorage2D(All.Texture2D, 1, All.Rgba32f, m_width, m_height);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)All.Nearest);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)All.Nearest);
GL.BindTexture(All.Texture2D, m_gbuffer_tex[2]);
GL.TexStorage2D(All.Texture2D, 1, All.DepthComponent32f, m_width, m_height);
GL.FramebufferTexture2D(FramebufferTarget.Framebuffer, FramebufferAttachment.ColorAttachment0, TextureTarget2d.Texture2D, m_gbuffer_tex[0], 0);
GL.FramebufferTexture2D(FramebufferTarget.Framebuffer, FramebufferAttachment.ColorAttachment1, TextureTarget2d.Texture2D, m_gbuffer_tex[1], 0);
GL.FramebufferTexture2D(FramebufferTarget.Framebuffer, FramebufferAttachment.DepthAttachment, TextureTarget2d.Texture2D, m_gbuffer_tex[2], 0);
GL.BindFramebuffer(All.Framebuffer, 0);
m_locLight = GL.GetUniformLocation(m_prePassProgram, "vLightPosition");
Debug.Log("m_locLight" + m_locLight);
m_locMVP = GL.GetUniformLocation(m_prePassProgram, "mvpMatrix");
Debug.Log("m_locMVP" + m_locMVP);
m_locMV = GL.GetUniformLocation(m_prePassProgram, "mvMatrix");
Debug.Log("m_locMV" + m_locMV);
m_locAmbient = GL.GetUniformLocation(m_lightPassProgram, "ambientColor");
Debug.Log("m_locAmbient" + m_locAmbient);
m_locDiffuse = GL.GetUniformLocation(m_lightPassProgram, "diffuseColor");
Debug.Log("m_locDiffuse" + m_locDiffuse);
m_locTex0 = GL.GetUniformLocation(m_lightPassProgram, "gbuf_tex0");
Debug.Log("m_locTex0" + m_locTex0);
m_locTex1 = GL.GetUniformLocation(m_lightPassProgram, "gbuf_tex1");
Debug.Log("m_locTex1" + m_locTex1);
//fs_quad_vao = GL.GenVertexArray();
//GL.BindVertexArray(fs_quad_vao);
}
