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); }