Context Navigation

source: branches/HeuristicLab.Problems.GaussianProcessTuning/ILNumerics.2.14.4735.573/Drawing/Platform/OpenGL/ILOGLPanel.cs @ 11826

Visit:

Last change on this file since 11826 was 9102, checked in by gkronber, 12 years ago
#1967: ILNumerics source for experimentation
File size: 41.0 KB

Rev	Line
[9102]	1	///
	2	/// This file is part of ILNumerics Community Edition.
	3	///
	4	/// ILNumerics Community Edition - high performance computing for applications.
	5	/// Copyright (C) 2006 - 2012 Haymo Kutschbach, http://ilnumerics.net
	6	///
	7	/// ILNumerics Community Edition is free software: you can redistribute it and/or modify
	8	/// it under the terms of the GNU General Public License version 3 as published by
	9	/// the Free Software Foundation.
	10	///
	11	/// ILNumerics Community Edition is distributed in the hope that it will be useful,
	12	/// but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	/// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	/// GNU General Public License for more details.
	15	///
	16	/// You should have received a copy of the GNU General Public License
	17	/// along with ILNumerics Community Edition. See the file License.txt in the root
	18	/// of your distribution package. If not, see <http://www.gnu.org/licenses/>.
	19	///
	20	/// In addition this software uses the following components and/or licenses:
	21	///
	22	/// =================================================================================
	23	/// The Open Toolkit Library License
	24	///
	25	/// Copyright (c) 2006 - 2009 the Open Toolkit library.
	26	///
	27	/// Permission is hereby granted, free of charge, to any person obtaining a copy
	28	/// of this software and associated documentation files (the "Software"), to deal
	29	/// in the Software without restriction, including without limitation the rights to
	30	/// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
	31	/// the Software, and to permit persons to whom the Software is furnished to do
	32	/// so, subject to the following conditions:
	33	///
	34	/// The above copyright notice and this permission notice shall be included in all
	35	/// copies or substantial portions of the Software.
	36	///
	37	/// =================================================================================
	38	///
	39
	40	using System;
	41	using System.Drawing;
	42	using System.Drawing.Imaging;
	43	using System.Windows.Forms;
	44	using System.Diagnostics;
	45	using ILNumerics.Exceptions;
	46	using ILNumerics.Drawing;
	47	using ILNumerics.Drawing.Graphs;
	48	using ILNumerics.Drawing.Lighting;
	49	using ILNumerics.Drawing.Interfaces;
	50	using OpenTK.Graphics;
	51	using OpenTK.Platform;
	52	using OpenTK;
	53	using OpenTK.Math;
	54	using ILNumerics.Drawing.Shapes;
	55	using System.Linq;
	56
	57	namespace ILNumerics.Drawing.Platform.OpenGL {
	58	/// <summary>
	59	/// OpenGL implementation for ILPanel
	60	/// </summary>
	61	internal partial class ILOGLPanel : ILPanel, IILCreationFactory{
	62
	63	#region members / properties
	64	bool m_mustReconfigureLight = true;
	65	GraphicsMode m_format;
	66	IWindowInfo m_window_info;
	67	IGraphicsContext m_context;
	68	IGLControl m_implementation;
	69	private const float Sqrt2 = 1.4142135623730950488016887242097f;
	70	double[] m_projMatrix = new double[16];
	71	double[] m_modelViewMatrix = new double[16];
	72	int[] m_viewMatrix = new int[16];
	73	float[] m_selectionVertices = new float[32]; // V2F format, interleaved
	74	int m_errorCount = 0;
	75	private readonly int MAXERRORLOGCOUNT = 100;
	76	protected bool m_polyOffsetEnable = true;
	77	/// <summary>
	78	/// Gets an interface to the underlying GraphicsContext used by this GLControl.
	79	/// </summary>
	80	public override object GetDeviceContext() {
	81	return m_context;
	82	}
	83
	84	internal double[] ProjectionMatrix {
	85	get {
	86	return m_projMatrix;
	87	}
	88	}
	89	internal double[] ModelviewMatrix {
	90	get {
	91	return m_modelViewMatrix;
	92	}
	93	}
	94	internal int[] ViewMatrix {
	95	get {
	96	return m_viewMatrix;
	97	}
	98	}
	99
	100	/// <summary>
	101	/// Control polygon offset ([on]/off)
	102	/// </summary>
	103	public bool PolyOffsetEnable {
	104	get {
	105	return m_polyOffsetEnable;
	106	}
	107	set {
	108	m_polyOffsetEnable = value;
	109	}
	110	}
	111
	112	#endregion private members
	113
	114	#region constructors
	115
	116	internal ILOGLPanel() : base( GraphicDeviceType.OpenGL ) {
	117	#if TRACE
	118	Trace.TraceInformation("{0},{1} ILOGLPanel.ctor(mode) start",DateTime.Now, Environment.TickCount);
	119	Trace.Indent();
	120	#endif
	121
	122	this.SetStyle(ControlStyles.Opaque, true);
	123	this.SetStyle(ControlStyles.UserPaint, true);
	124	this.SetStyle(ControlStyles.AllPaintingInWmPaint, true);
	125	m_format = GraphicsMode.Default;
	126
	127	if (Configuration.RunningOnWindows)
	128	m_implementation = new OpenTK.Platform.Windows.WinGLControl(m_format, this);
	129	else if (Configuration.RunningOnX11)
	130	m_implementation = new OpenTK.Platform.X11.X11GLControl(m_format, this);
	131	else if (Configuration.RunningOnOSX)
	132	throw new PlatformNotSupportedException("Refer to http://www.opentk.com for more information.");
	133
	134	this.CreateControl();
	135
	136	#if TRACE
	137	Trace.Unindent();
	138	Trace.TraceInformation("{0},{1} ILPanel.ctor(mode) end",DateTime.Now, Environment.TickCount);
	139	#endif
	140	}
	141
	142	#endregion
	143
	144	#region panel setup / destroy
	145
	146	/// <summary>
	147	/// will get called after the handle has been created
	148	/// </summary>
	149	/// <param name="e"></param>
	150	protected override void OnHandleCreated(EventArgs e) {
	151	base.OnHandleCreated(e);
	152	if (DesignMode)
	153	m_context = new DummyGLContext(null);
	154	else
	155	m_context = m_implementation.CreateContext();
	156
	157	m_window_info = m_implementation.WindowInfo;
	158	this.MakeCurrent();
	159	((IGraphicsContextInternal)m_context).LoadAll();
	160	OnGraphicsDeviceCreated();
	161	}
	162	/// <summary>
	163	/// gets called, after the handle has been destroyed
	164	/// </summary>
	165	/// <param name="e"></param>
	166	protected override void OnHandleDestroyed(EventArgs e)
	167	{
	168	base.OnHandleDestroyed(e);
	169	if (m_context != null)
	170	{
	171	m_context.Dispose();
	172	m_context = null;
	173	}
	174	m_window_info = null;
	175	}
	176	/// <summary>
	177	/// Dispose off the panels resources
	178	/// </summary>
	179	/// <param name="disposing"></param>
	180	protected override void Dispose(bool disposing) {
	181	m_active = false;
	182	base.Dispose(disposing);
	183	if (disposing) {
	184	// he ?
	185	}
	186	if (m_context != null && disposing) {
	187	m_context.Dispose();
	188	m_context = null;
	189	}
	190	}
	191
	192	#endregion
	193
	194	#region rendering related
	195
	196	/// <summary>
	197	/// set up viewport, projection and modelview matrices
	198	/// </summary>
	199	protected override void UpdateMatrices(float width2D, float height2D, float zDepth) {
	200	if (ClientSize.IsEmpty) return;
	201	if (m_plotBoxScreenRectF.Size.IsEmpty) return;
	202
	203	float worldSceneWidth;
	204	float worldSceneHeight;
	205	// ILPoint3Df camPos = m_camera.Position;
	206	ILPoint3Df top;
	207	ILPoint3Df moveOffset;
	208	helperUpdateMatrices(width2D, height2D, out worldSceneWidth, out worldSceneHeight, out top, out moveOffset);
	209
	210	#region projection
	211	GL.MatrixMode(MatrixMode.Projection);
	212	GL.LoadIdentity();
	213
	214	float nearPlane = 0f; // Math.Max(0.0f, m_camera.Distance - m_clippingView.SphereRadius);
	215	float farPlane = m_camera.Distance + m_clippingView.SphereRadius * 100;
	216	if (m_projection == Projection.Perspective) {
	217	float angle = (float)Math.Atan2(worldSceneHeight / 2.0f, m_camera.Distance - (zDepth / 2)) * 2.0f;
	218	Glu.Perspective(angle / Math.PI * 180, (double)worldSceneWidth / worldSceneHeight,
	219	nearPlane, farPlane);
	220	} else {
	221	GL.Ortho(
	222	-worldSceneWidth / 2.0, worldSceneWidth / 2.0
	223	, -worldSceneHeight / 2.0, worldSceneHeight / 2.0
	224	, nearPlane, farPlane);
	225	}
	226	GL.GetDouble(GetPName.ProjectionMatrix,m_projMatrix);
	227	// set viewport
	228	GL.Viewport(0,0,ClientSize.Width,ClientSize.Height);
	229	GL.GetInteger(GetPName.Viewport,m_viewMatrix);
	230	#endregion
	231
	232	#region modelview
	233	GL.MatrixMode(MatrixMode.Modelview);
	234	GL.LoadIdentity();
	235	ILGLU.LookAt (m_camera.Position, m_camera.LookAt, m_camera.Top, moveOffset);
	236
	237	// Glu.LookAt(camPos.X, camPos.Y, camPos.Z
	238	// , m_camera.LookAt.X, m_camera.LookAt.Y, m_camera.LookAt.Z
	239	// , m_camera.Top.X, m_camera.Top.Y, m_camera.Top.Z);
	240	// GL.Translate(moveOffset.X,moveOffset.Y,moveOffset.Z);
	241
	242	GL.GetDouble(GetPName.ModelviewMatrix, m_modelViewMatrix);
	243	//Console.Out.WriteLine("Camera: {0} \|\| Top: {1} \n m_modelViewMatr:{2}",m_camera.ToString(), m_camera.Top.ToString(), String.Join(", ", m_modelViewMatrix));
	244	//Console.Out.WriteLine("Camera: {0} \|\| Top: {1} \n m_modelViewMatr:{2}",m_camera.ToString(), m_camera.Top.ToString(), String.Join(", ", m_modelViewMatrix));
	245	#endregion
	246
	247	}
	248
	249	protected override void iRenderingState1(ILRenderProperties p) {
	250	MakeCurrent();
	251	}
	252	/// <summary>
	253	/// Render the OpenGL scene
	254	/// </summary>
	255	/// <param name="g"></param>
	256	protected override void iRenderingState2(ILRenderProperties p) {
	257
	258	if (m_context == null \|\| (!m_active && !m_drawHidden))
	259	return;
	260	try {
	261	//System.Diagnostics.Debug.WriteLine(String.Format("ILOGLPanel{0}: RenderScene, Thread={1}"
	262	// ,this.GetHashCode(), System.Threading.Thread.CurrentThread.GetHashCode()));
	263	// draw background
	264	GL.ClearColor(m_backColor);
	265	GL.Clear(ClearBufferMask.ColorBufferBit \| ClearBufferMask.DepthBufferBit);
	266	// draw back axis
	267	GL.Enable(EnableCap.DepthTest);
	268	if (m_fillBackground)
	269	renderBackground();
	270	GL.Enable(EnableCap.Blend);
	271	//GL.MatrixMode(MatrixMode.Modelview);
	272	//GL.PushMatrix();
	273	if (m_polyOffsetEnable) {
	274	GL.Enable(EnableCap.PolygonOffsetFill);
	275	} else {
	276	GL.Disable(EnableCap.PolygonOffsetFill);
	277	}
	278	GL.PolygonOffset(1.0f,1.0f);
	279	GL.Disable(EnableCap.Blend);
	280	m_axes.XAxis.RenderState1(p);
	281	m_axes.YAxis.RenderState1(p);
	282	if (m_camera.SinRho > 1e-5)
	283	m_axes.ZAxis.RenderState1(p);
	284
	285	if ((m_plotBoxScreenSizeMode != PlotBoxScreenSizeMode.StrictOptimal)
	286	\|\| (p.PassCount > 0)) {
	287
	288	#region enable clipping planes
	289	if (m_renderProperties.Clipping) {
	290	unsafe {
	291	fixed (double* pClip = m_clipplanes) {
	292	if (m_clippingView.WidthF > 0) {
	293	GL.ClipPlane(ClipPlaneName.ClipPlane0, pClip);
	294	GL.ClipPlane(ClipPlaneName.ClipPlane1, pClip + 4);
	295	GL.Enable(EnableCap.ClipPlane0);
	296	GL.Enable(EnableCap.ClipPlane1);
	297	}
	298	if (m_clippingView.HeightF > 0) {
	299	GL.ClipPlane(ClipPlaneName.ClipPlane2, pClip + 8);
	300	GL.ClipPlane(ClipPlaneName.ClipPlane3, pClip + 12);
	301	GL.Enable(EnableCap.ClipPlane2);
	302	GL.Enable(EnableCap.ClipPlane3);
	303	}
	304	if (m_clippingView.DepthF > 0) {
	305	GL.ClipPlane(ClipPlaneName.ClipPlane4, pClip + 16);
	306	GL.ClipPlane(ClipPlaneName.ClipPlane5, pClip + 20);
	307	GL.Enable(EnableCap.ClipPlane4);
	308	GL.Enable(EnableCap.ClipPlane5);
	309	}
	310	}
	311	}
	312	}
	313	#endregion
	314	// draw all graphs
	315	//GL.MatrixMode(MatrixMode.Modelview);
	316	//ILPoint3Df ab = m_clippingView.CenterToUnitCube();
	317	//GL.Translate(ab.X, ab.Y, ab.Z);
	318	//ab = m_clippingView.ScaleToUnitCube();
	319	//GL.Scale(ab.X, ab.Y, ab.Z); //Identity; //RotationZ(m_cameraPhi);
	320
	321	#region lighting
	322	if (m_mustReconfigureLight) {
	323	m_mustReconfigureLight = false;
	324	if (m_lights.Enabled) {
	325	float[] tmpF = new float[4]; tmpF[3] = 1.0f;
	326	foreach (ILLight light in m_lights) {
	327	EnableCap lightID = EnableCap.Light0 + light.Index;
	328	if (!light.Enabled) {
	329	GL.Disable(lightID);
	330	continue;
	331	}
	332	GL.Enable(lightID);
	333	tmpF[0] = light.Position.X;
	334	tmpF[1] = light.Position.Y;
	335	tmpF[2] = light.Position.Z;
	336	GL.Lightv((LightName)lightID, LightParameter.Position, tmpF);
	337	tmpF[0] = (float)light.Ambient.R / 255;
	338	tmpF[1] = (float)light.Ambient.G / 255;
	339	tmpF[2] = (float)light.Ambient.B / 255;
	340	GL.Lightv((LightName)lightID, LightParameter.Ambient, tmpF);
	341	tmpF[0] = (float)light.Specular.R / 255;
	342	tmpF[1] = (float)light.Specular.G / 255;
	343	tmpF[2] = (float)light.Specular.B / 255;
	344	GL.Lightv((LightName)lightID, LightParameter.Specular, tmpF);
	345	tmpF[0] = (float)light.Diffuse.R / 255;
	346	tmpF[1] = (float)light.Diffuse.G / 255;
	347	tmpF[2] = (float)light.Diffuse.B / 255;
	348	GL.Lightv((LightName)lightID, LightParameter.Diffuse, tmpF);
	349	}
	350	}
	351	}
	352	#endregion
	353
	354	#region graph rendering
	355	// Easy sorting - this expects a few graphs in the collection only.
	356	// For situations, where a large number of graphs need to be sorted here,
	357	// one may implement sorting in the way it is done in ILSceneGraph
	358	// (via ILNumerics.ILArray and ILMath.sort).
	359
	360	//m_graphs.Sort(new ILNumerics.Drawing.Misc.ILGraphComparer());
	361	m_sortingCacheList.Clear();
	362	m_graphs.GetSortedList4Render(m_camera, m_sortingCacheList);
	363	foreach (ILGraph graph in m_sortingCacheList) {
	364	try {
	365	graph.Draw(p);
	366	} catch (Exception e) {
	367	#if TRACE
	368	m_errorCount++;
	369
	370	if (m_errorCount < MAXERRORLOGCOUNT) {
	371	System.Diagnostics.Trace.TraceError(String.Format("[{0}].Draw() failed: {1}",graph.GetType().Name,e.ToString()));
	372	} else if (m_errorCount == MAXERRORLOGCOUNT) {
	373	System.Diagnostics.Trace.TraceError(String.Format("(more than {0} errors. Further reporting disabled.)",m_errorCount));
	374	}
	375	#endif
	376	if (m_errorCount < 3) {
	377	MessageBox.Show(e.Message, "ILNumerics.Drawing");
	378	}
	379
	380	}
	381	}
	382	#endregion
	383
	384	#region world label test, please delete me
	385	//ILNumerics.Drawing.Labeling.ILLabel label = new ILNumerics.Drawing.Labeling.ILLabel(this);
	386	//label.Position = new Point(0,0);
	387	//label.Text = "World";
	388	//label.Renderer = TextRendererManager.GetDefault(CoordSystem.World3D);
	389	//label.Draw(g);
	390	#endregion
	391
	392	#region disable clipping planes
	393	GL.Disable(EnableCap.ClipPlane0);
	394	GL.Disable(EnableCap.ClipPlane1);
	395	GL.Disable(EnableCap.ClipPlane2);
	396	GL.Disable(EnableCap.ClipPlane3);
	397	GL.Disable(EnableCap.ClipPlane4);
	398	GL.Disable(EnableCap.ClipPlane5);
	399	#endregion disable clipping planes
	400
	401	}
	402	// render front axis
	403	//GL.MatrixMode(MatrixMode.Modelview);
	404	//GL.PopMatrix();
	405	GL.Enable(EnableCap.Blend);
	406	GL.Enable(EnableCap.LineSmooth);
	407	m_axes.XAxis.RenderState2(p);
	408	m_axes.YAxis.RenderState2(p);
	409	if (m_camera.SinRho > 1e-5)
	410	m_axes.ZAxis.RenderState2(p);
	411
	412	} catch (ILArgumentException e) {
	413	throw new ILArgumentException("rendering failed at state 2",e);
	414	}
	415	}
	416	/// <summary>
	417	/// swap buffers and finalize rendering
	418	/// </summary>
	419	/// <param name="p"></param>
	420	protected override void iRenderingState3(ILRenderProperties p) {
	421
	422	try {
	423	p.Graphics = null;
	424	m_legend.Draw(p, Rectangle.Empty);
	425
	426	#region screen label test, please delete me
	427	//label = new ILNumerics.Drawing.Labeling.ILLabel(this);
	428	//label.Position = new Point(30,40);
	429	//label.Text = "Screen";
	430	//label.Renderer = TextRendererManager.GetDefault(CoordSystem.Screen);
	431	//label.Draw(g);
	432	#endregion
	433
	434	//GL.MatrixMode(MatrixMode.Modelview);
	435	if (m_selectingMode == InteractiveModes.ZoomRectangle && m_isDragging)
	436	drawSelectionRect(PointToClient(MousePosition));
	437
	438	#if DRAWPLOTCUBESCREENRECT
	439	#region
	440	float[] viewport = new float[4];
	441	GL.GetFloat(GetPName.Viewport, viewport);
	442	GL.MatrixMode(MatrixMode.Projection);
	443	GL.PushMatrix();
	444	GL.LoadIdentity();
	445	GL.Ortho(viewport[0], viewport[2], viewport[3], viewport[1], -1.0, 1.0);
	446	GL.MatrixMode(MatrixMode.Modelview);
	447	GL.PushMatrix();
	448	GL.LoadIdentity();
	449	GL.Color3(Color.LightGray);
	450	GL.LineWidth(1f);
	451	GL.Begin(BeginMode.LineLoop);
	452	GL.Vertex2(m_plotBoxScreenRectF.Left * ClientSize.Width, m_plotBoxScreenRectF.Top * ClientSize.Height);
	453	GL.Vertex2(m_plotBoxScreenRectF.Right * ClientSize.Width, m_plotBoxScreenRectF.Top * ClientSize.Height);
	454	GL.Vertex2(m_plotBoxScreenRectF.Right * ClientSize.Width, m_plotBoxScreenRectF.Bottom * ClientSize.Height);
	455	GL.Vertex2(m_plotBoxScreenRectF.Left * ClientSize.Width, m_plotBoxScreenRectF.Bottom * ClientSize.Height);
	456	GL.End();
	457	GL.PopMatrix();
	458	GL.MatrixMode(MatrixMode.Projection);
	459	GL.PopMatrix();
	460	#endregion
	461
	462	#endif
	463	//GL.Finish();
	464	// update model matrix (to be avilable for zooming etc.)
	465	//GL.GetDouble(GetPName.ModelviewMatrix,m_modelViewMatrix);
	466
	467
	468	#if DRAWTEXTURESHEET
	469	#region
	470	// prepare GL
	471	float[] deb_viewport = new float[4];
	472	GL.GetFloat(GetPName.Viewport, deb_viewport);
	473	GL.MatrixMode(MatrixMode.Projection);
	474	GL.PushMatrix();
	475	GL.LoadIdentity();
	476	GL.Ortho(deb_viewport[0], deb_viewport[2], deb_viewport[3], deb_viewport[1], -1.0, 1.0);
	477	GL.MatrixMode(MatrixMode.Modelview);
	478	GL.PushMatrix();
	479	GL.LoadIdentity();
	480	GL.PushAttrib(AttribMask.TextureBit \| AttribMask.EnableBit \| AttribMask.ColorBufferBit);
	481	GL.Enable(EnableCap.Texture2D);
	482	GL.Enable(EnableCap.Blend);
	483	GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
	484	GL.Disable(EnableCap.DepthTest);
	485	// draw one large quad with whole texture sheet
	486	GL.Begin(BeginMode.Quads);
	487	GL.TexCoord2(0,1);
	488	GL.Vertex2(0,ClientSize.Height/2); // ul
	489	GL.TexCoord2(0,0);
	490	GL.Vertex2(0,0); // bl
	491	GL.TexCoord2(1,0);
	492	GL.Vertex2(ClientSize.Width,0); // br
	493	GL.TexCoord2(1,1);
	494	GL.Vertex2(ClientSize.Width,ClientSize.Height/2); // tr
	495	GL.End();
	496	#endregion
	497	#endif
	498
	499	SwapBuffers();
	500	m_axes.XAxis.RenderState3(p);
	501	m_axes.YAxis.RenderState3(p);
	502	if (m_camera.SinRho > 1e-5)
	503	m_axes.ZAxis.RenderState3(p);
	504
	505	//if (false) {
	506	// p.Graphics.DrawLine(new Pen(new SolidBrush(Color.Red)), m_axes[0].Label.m_position, m_axes[0].Label.m_position);
	507	// p.Graphics.DrawLine(new Pen(new SolidBrush(Color.Green)), m_axes[1].Label.m_position, m_axes[0].Label.m_position);
	508	// p.Graphics.DrawLine(new Pen(new SolidBrush(Color.Blue)), m_axes[2].Label.m_position, m_axes[0].Label.m_position);
	509	//}
	510	} catch (ILArgumentException exc) {
	511	throw new ILArgumentException("rendering failed aat state 3",exc);
	512	// todo: exception handling
	513	}
	514	}
	515	/// <summary>
	516	/// draws the selection rectangle va OpenGL (rather than GDI in base class)
	517	/// </summary>
	518	/// <param name="endPoint"></param>
	519	protected override void drawSelectionRect(Point endPoint) {
	520	float [] viewport = new float[4];
	521	GL.GetFloat(GetPName.Viewport, viewport);
	522	GL.MatrixMode(MatrixMode.Projection);
	523	GL.PushMatrix();
	524	GL.LoadIdentity();
	525	GL.Ortho(viewport[0], viewport[2], viewport[3], viewport[1], -1.0, 1.0);
	526
	527	GL.MatrixMode(MatrixMode.Modelview);
	528	GL.PushMatrix();
	529	GL.LoadIdentity();
	530
	531	//GL.Enable(EnableCap.Texture2D);
	532	//GL.Enable(EnableCap.Blend);
	533	//GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
	534
	535	GL.Disable(EnableCap.DepthTest);
	536	SetupLineStyle(m_selectionRectangle);
	537	//// upper left corner
	538	m_selectionVertices[0] = m_mouseStart.X;
	539	m_selectionVertices[1] = m_mouseStart.Y + (endPoint.Y - m_mouseStart.Y) / 4;
	540	m_selectionVertices[2] = m_mouseStart.X;
	541	m_selectionVertices[3] = m_mouseStart.Y;
	542	m_selectionVertices[4] = m_mouseStart.X;
	543	m_selectionVertices[5] = m_mouseStart.Y;
	544	m_selectionVertices[6] = m_mouseStart.X + (endPoint.X - m_mouseStart.X) / 4;
	545	m_selectionVertices[7] = m_mouseStart.Y;
	546	// lower left corner
	547	m_selectionVertices[8] = m_mouseStart.X;
	548	m_selectionVertices[9] = endPoint.Y - (endPoint.Y - m_mouseStart.Y) / 4;
	549	m_selectionVertices[10] = m_mouseStart.X;
	550	m_selectionVertices[11] = endPoint.Y;
	551	m_selectionVertices[12] = m_mouseStart.X;
	552	m_selectionVertices[13] = endPoint.Y;
	553	m_selectionVertices[14] = m_mouseStart.X + (endPoint.X - m_mouseStart.X) / 4;
	554	m_selectionVertices[15] = endPoint.Y;
	555	// lower right corner
	556	m_selectionVertices[16] = endPoint.X;
	557	m_selectionVertices[17] = endPoint.Y - (endPoint.Y - m_mouseStart.Y) / 4;
	558	m_selectionVertices[18] = endPoint.X;
	559	m_selectionVertices[19] = endPoint.Y;
	560	m_selectionVertices[20] = endPoint.X;
	561	m_selectionVertices[21] = endPoint.Y;
	562	m_selectionVertices[22] = endPoint.X - (endPoint.X - m_mouseStart.X) / 4;
	563	m_selectionVertices[23] = endPoint.Y;
	564	// upper right corner
	565	m_selectionVertices[24] = endPoint.X;
	566	m_selectionVertices[25] = m_mouseStart.Y + (endPoint.Y - m_mouseStart.Y) / 4;
	567	m_selectionVertices[26] = endPoint.X;
	568	m_selectionVertices[27] = m_mouseStart.Y;
	569	m_selectionVertices[28] = endPoint.X;
	570	m_selectionVertices[29] = m_mouseStart.Y;
	571	m_selectionVertices[30] = endPoint.X - (endPoint.X - m_mouseStart.X) / 4;
	572	m_selectionVertices[31] = m_mouseStart.Y;
	573	// draw them
	574	unsafe {
	575	fixed (float* verticesP = m_selectionVertices) {
	576	GL.InterleavedArrays(InterleavedArrayFormat.V2f,8,(IntPtr)verticesP);
	577	GL.DrawArrays(BeginMode.Lines,0,16);
	578	}
	579	}
	580	GL.MatrixMode(MatrixMode.Modelview);
	581	GL.PopMatrix();
	582	GL.MatrixMode(MatrixMode.Projection);
	583	GL.PopMatrix();
	584	}
	585	/// <summary>
	586	/// Swaps the front and back buffers, presenting the rendered scene to the screen.
	587	/// </summary>
	588	protected void SwapBuffers() {
	589	if (m_context != null)
	590	m_context.SwapBuffers();
	591	}
	592	/// <summary>
	593	/// Makes the underlying this GLControl current in the calling thread.
	594	/// All OpenGL commands issued are hereafter interpreted by this GLControl.
	595	/// </summary>
	596	protected void MakeCurrent() {
	597	if (m_context != null)
	598	m_context.MakeCurrent(m_implementation.WindowInfo);
	599	}
	600
	601	public override void DrawToBitmap(Bitmap bitmap, Rectangle bounds) {
	602	RenderScene(m_renderProperties);
	603	BitmapData bmpData = bitmap.LockBits(bounds,ImageLockMode.ReadWrite,
	604	System.Drawing.Imaging.PixelFormat.Format24bppRgb);
	605	// reset any changes to pixel store
	606	GL.PixelStore(PixelStoreParameter.UnpackAlignment,4.0f);
	607	GL.PixelStore(PixelStoreParameter.UnpackRowLength,bmpData.Width);
	608	GL.PixelStore(PixelStoreParameter.UnpackSkipRows,bounds.Y);
	609	GL.PixelStore(PixelStoreParameter.UnpackSkipPixels,bounds.X);
	610	GL.ReadPixels(0,0,bounds.Width,bounds.Height,OpenTK.Graphics.PixelFormat.Bgr,
	611	PixelType.UnsignedByte,(IntPtr)bmpData.Scan0);
	612	bitmap.UnlockBits(bmpData);
	613	bitmap.RotateFlip(RotateFlipType.RotateNoneFlipY);
	614	}
	615	#endregion
	616
	617	#region IILGraphFactory member
	618	/// <summary>
	619	/// Create specific graph (device dependent)
	620	/// </summary>
	621	/// <param name="data">numeric data to be visualized, any numeric type is accepted</param>
	622	/// <param name="type">type of graph to be created</param>
	623	/// <param name="additionalParams">user defined parameter, depend on concrete device type</param>
	624	/// <returns>Concrete ILGraph object</returns>
	625	public ILGraph CreateGraph(ILInArray<float> data, GraphType graphType, params ILArray<float>[] parameter) {
	626	using (ILScope.Enter(data)) {
	627	switch (graphType) {
	628	case GraphType.Plot2D:
	629	if (parameter != null && parameter.Length == 1
	630	&& parameter[0] != null && parameter[0] is ILArray<float>) {
	631	return new ILOGLPlot2DGraph(this, parameter[0] as ILArray<float>,
	632	data, m_graphs.Limits);
	633	} else {
	634	return new ILOGLPlot2DGraph(this, data, m_graphs.Limits);
	635	}
	636	case GraphType.Surf:
	637	if (parameter == null \|\| parameter.Length == 0)
	638	return new ILOGLSurfaceGraph(this, null, null, data, null, m_graphs.Limits);
	639	if (parameter.Length == 2) {
	640	return new ILOGLSurfaceGraph(this, data, parameter[0] as ILArray<float>,
	641	parameter[1] as ILArray<float>, null, m_graphs.Limits);
	642	} else if (parameter.Length == 1) {
	643	return new ILOGLSurfaceGraph(this, null, null, data,
	644	parameter[0] as ILArray<float>, m_graphs.Limits);
	645	} else if (parameter.Length == 3) {
	646	return new ILOGLSurfaceGraph(this, parameter[0] as ILArray<float>, parameter[1] as ILArray<float>,
	647	data, parameter[2] as ILArray<float>, m_graphs.Limits);
	648	} else
	649	throw new ILArgumentException("graph creation: invalid number of arguments! (surface)");
	650	case GraphType.Imagesc:
	651	return new ILOGLImageSCGraph(this, null, null, data, null, m_graphs.Limits);
	652	default:
	653	throw new ILInvalidOperationException("Graph type not supported: " + graphType.ToString());
	654	}
	655	}
	656	}
	657	/// <summary>
	658	/// Create Axis (device dependent)
	659	/// </summary>
	660	/// <param name="name">specfies axis name (X,Y,ZAxis)</param>
	661	/// <param name="clippingView">the global clipping view object for the axis</param>
	662	/// <param name="parameters">user defined parameters (implementation dependent)</param>
	663	/// <returns>ILAXis object</returns>
	664	public ILAxis CreateAxis(AxisNames name, ILClippingData clippingView, params object[] parameters) {
	665	switch (name) {
	666	case AxisNames.XAxis:
	667	return new ILOGLXAxis(clippingView, m_layoutData, this);
	668	case AxisNames.YAxis:
	669	return new ILOGLYAxis(clippingView, m_layoutData, this);
	670	default:
	671	return new ILOGLZAxis(clippingView, m_layoutData, this);
	672	}
	673	}
	674	/// <summary>
	675	/// create a new device dependent scene graph for hosting shapes, internally used
	676	/// </summary>
	677	/// <returns>scene graph</returns>
	678	public ILSceneGraph CreateSceneGraph() {
	679	return new ILSceneGraph(this,m_graphs.Limits);
	680	}
	681	public ILVertexRenderer CreateVertexRenderer(Type vertexType, ILShape shape) {
	682	if (vertexType == typeof(C4bV3f)) {
	683	ILVertexRenderer ret;
	684	if (shape is ILQuads) {
	685	ret = new ILOGLVertexRendererC4bV3f(BeginMode.Quads);
	686	} else if (shape is ILPolygon) {
	687	ret = new ILOGLVertexRendererC4bV3f(BeginMode.Polygon);
	688	} else if (shape is ILLine) {
	689	ret = new ILOGLLineRendererC4bV3f(shape.VertexCount);
	690	ret.CloseLines = false;
	691	} else if (shape is ILTriangle) {
	692	ret = new ILOGLVertexRendererC4bV3f(BeginMode.Triangles);
	693	} else if (shape is ILQuad) {
	694	ret = new ILOGLVertexRendererC4bV3f(BeginMode.Quads);
	695	} else if (shape is ILLines) {
	696	ret = new ILOGLLinesRendererC4bV3f();
	697	} else if (shape is ILTriangles) {
	698	ret = new ILOGLVertexRendererC4bV3f(BeginMode.Triangles);
	699	} else if (shape is ILPoints) {
	700	ret = new ILOGLPointsRendererC4bV3f();
	701	} else
	702	throw new NotSupportedException ("Shape of type " + shape.GetType().Name + " is not supported!");
	703	return ret;
	704	} else if (vertexType == typeof(C4fN3fV3f)) {
	705	ILOGLVertexRendererC4fN3fV3f ret;
	706	if (shape is ILLitQuads) {
	707	ret = new ILOGLVertexRendererC4fN3fV3f(BeginMode.Quads);
	708	ret.UseLight = true;
	709	} else if (shape is ILLitPolygon) {
	710	ret = new ILOGLVertexRendererC4fN3fV3f(BeginMode.Polygon);
	711	ret.UseLight = true;
	712	} else if (shape is ILLitQuad) {
	713	ret = new ILOGLVertexRendererC4fN3fV3f(BeginMode.Quads);
	714	ret.UseLight = true;
	715	} else if (shape is ILLitTriangle) {
	716	ret = new ILOGLVertexRendererC4fN3fV3f(BeginMode.Triangles);
	717	ret.UseLight = true;
	718	} else if (shape is ILLitSphere) {
	719	ret = new ILOGLVertexRendererC4fN3fV3f(BeginMode.Triangles);
	720	ret.UseLight = true;
	721	} else if (shape is ILLitTriangles) {
	722	ret = new ILOGLVertexRendererC4fN3fV3f(BeginMode.Triangles);
	723	ret.UseLight = true;
	724	} else {
	725	throw new NotSupportedException("Shape of type " + shape.GetType().Name + " is not supported for vertex type " + vertexType.Name + "!");
	726	}
	727	return ret;
	728	} else {
	729	throw new NotSupportedException("VertexType is not supported!");
	730	}
	731	}
	732	internal override IILCreationFactory GetCreationFactory() {
	733	return this;
	734	}
	735
	736	#endregion
	737
	738	#region public methods
	739
	740	public override Point World2Screen(ILPoint3Df world) {
	741	//Vector3 w = new Vector3(world.X, world.Y, world.Z);
	742	ILPoint3Df screen;
	743	ILGLU.Project(world,m_modelViewMatrix, m_projMatrix, m_viewMatrix, out screen);
	744	return new Point((int)screen.X,(int)(ClientSize.Height - screen.Y));
	745	}
	746	public override Point World2Screen(ILPoint3Df world, double[] modelview) {
	747	//Vector3 w = new Vector3(world.X, world.Y, world.Z);
	748	ILPoint3Df screen;
	749	ILGLU.Project(world,modelview, m_projMatrix, m_viewMatrix, out screen);
	750	return new Point((int)screen.X,(int)(ClientSize.Height - screen.Y));
	751	}
	752
	753	public static void SetupLineStyle(ILLineProperties wireprops) {
	754	if (wireprops.Style == LineStyle.Solid) {
	755	GL.Disable(EnableCap.LineStipple);
	756	} else {
	757	int stipFactr = 1;
	758	short stipple;
	759	if (wireprops.Style != LineStyle.UserPattern)
	760	stipple = ILPanel.StippleFromLineStyle(
	761	wireprops.Style, ref stipFactr);
	762	else {
	763	stipple = wireprops.Pattern;
	764	stipFactr = (int)wireprops.PatternScale;
	765	}
	766	GL.Enable(EnableCap.LineStipple);
	767	GL.LineStipple(stipFactr, stipple);
	768	}
	769	if (wireprops.Antialiasing && wireprops.Width > 1)
	770	GL.Enable(EnableCap.LineSmooth);
	771	else
	772	GL.Disable(EnableCap.LineSmooth);
	773	GL.LineWidth(wireprops.Width);
	774	GL.Color3(wireprops.Color);
	775	}
	776
	777	private string DebugJoin(string seperator, double[] list) {
	778	System.Text.StringBuilder ret = new System.Text.StringBuilder();
	779	foreach (object o in list) {
	780	ret.Append(seperator + String.Format("{0:f2}",o));
	781	}
	782	return ret.ToString();
	783	}
	784
	785	/// <summary>
	786	/// Transform 2 world coordinates into screen coords under current matrices
	787	/// </summary>
	788	/// <param name="p1_3D">world coord point 1</param>
	789	/// <param name="p2_3D">world coord point 2</param>
	790	/// <param name="p1_2D">(output) screen coord point 1</param>
	791	/// <param name="p2_2D">(output) screen coord point 2</param>
	792	public override void World2Screen(ILPoint3Df p1_3D, ILPoint3Df p2_3D, out Point p1_2D, out Point p2_2D) {
	793	ILPoint3Df s, e;
	794	ILGLU.Project(p1_3D, m_modelViewMatrix, m_projMatrix, m_viewMatrix, out s);
	795	ILGLU.Project(p2_3D, m_modelViewMatrix, m_projMatrix, m_viewMatrix, out e);
	796	p1_2D = new Point((int)s.X,(int)(ClientSize.Height - s.Y));
	797	p2_2D = new Point((int)e.X,(int)(ClientSize.Height - e.Y));
	798	}
	799	/// <summary>
	800	/// transform from screen space into world space using OpenGL
	801	/// </summary>
	802	/// <param name="x">screen X</param>
	803	/// <param name="y">screen Y</param>
	804	/// <returns>world coord</returns>
	805	public override void Screen2World(int x, int y, out ILPoint3Df nearClip, out ILPoint3Df farClip) {
	806	// TODO: check the Z coord values. 0.68 here was result of trial only!
	807	ILGLU.UnProject(new ILPoint3Df(x, y, 0.0f), m_modelViewMatrix, m_projMatrix, m_viewMatrix, out nearClip);
	808	ILGLU.UnProject(new ILPoint3Df(x, y, 1.0f), m_modelViewMatrix, m_projMatrix, m_viewMatrix, out farClip);
	809
	810	}
	811	public override ILPoint3Df Screen2World2D(int x, int y) {
	812	ILPoint3Df ret;
	813	ILGLU.UnProject(new ILPoint3Df(x, y, 0), m_modelViewMatrix, m_projMatrix, m_viewMatrix, out ret);
	814	ret.Z = m_clippingView.CenterF.Z;
	815	return ret;
	816	}
	817
	818	#endregion
	819
	820	#region private helper
	821	private void renderBackground () {
	822	//determine, which edges are in the back, fill with cube background color
	823	GL.Begin(BeginMode.TriangleStrip);
	824	GL.Color3(m_cubeBGColor);
	825	float xmin = m_clippingView.XMin;
	826	float xmax = m_clippingView.XMax;
	827	float ymin = m_clippingView.YMin;
	828	float ymax = m_clippingView.YMax;
	829	float zmin = m_clippingView.ZMin;
	830	float zmax = m_clippingView.ZMax;
	831	if (!m_camera.LooksFromLeft) {
	832	if (m_camera.LooksFromFront) {
	833	// left & back border
	834	GL.Vertex3(xmin,ymin,zmin);
	835	GL.Vertex3(xmin,ymin,zmax);
	836	GL.Vertex3(xmin,ymax,zmin);
	837	GL.Vertex3(xmin,ymax,zmax);
	838	GL.Vertex3(xmax,ymax,zmin);
	839	GL.Vertex3(xmax,ymax,zmax);
	840	} else {
	841	GL.Vertex3(xmin,ymax,zmin); //
	842	GL.Vertex3(xmin,ymax,zmax);
	843	GL.Vertex3(xmin,ymin,zmin);
	844	GL.Vertex3(xmin,ymin,zmax);
	845	GL.Vertex3(xmax,ymin,zmin);
	846	GL.Vertex3(xmax,ymin,zmax);
	847	}
	848	} else {
	849	if (!m_camera.LooksFromFront) {
	850	GL.Vertex3(xmin,ymin,zmin);
	851	GL.Vertex3(xmin,ymin,zmax);
	852	GL.Vertex3(xmax,ymin,zmin);
	853	GL.Vertex3(xmax,ymin,zmax);
	854	GL.Vertex3(xmax,ymax,zmin);
	855	GL.Vertex3(xmax,ymax,zmax);
	856	} else {
	857	GL.Vertex3(xmin,ymax,zmin);
	858	GL.Vertex3(xmin,ymax,zmax);
	859	GL.Vertex3(xmax,ymax,zmin);
	860	GL.Vertex3(xmax,ymax,zmax);
	861	GL.Vertex3(xmax,ymin,zmin);
	862	GL.Vertex3(xmax,ymin,zmax);
	863	}
	864	}
	865	GL.End();
	866	// draw bottom
	867	if (m_camera.LooksFromTop) {
	868	GL.Begin(BeginMode.TriangleStrip);
	869	GL.Vertex3(xmin,ymin,zmin);
	870	GL.Vertex3(xmax,ymin,zmin);
	871	GL.Vertex3(xmin,ymax,zmin);
	872	GL.Vertex3(xmax,ymax,zmin);
	873	GL.End();
	874	}
	875	}
	876	#endregion
	877
	878	}
	879	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Update cookies preferences