/// <summary>
/// Handles the OpenGLDraw event of the openGLControl control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="RenderEventArgs"/> instance containing the event data.</param>
public void openGLControl_OpenGLDraw(object sender, RenderEventArgs e)
{
// Get the OpenGL object.
gl = openGLControl.OpenGL;
// Clear the color and depth buffer.
gl.Clear(OpenGL.GL_COLOR_BUFFER_BIT | OpenGL.GL_DEPTH_BUFFER_BIT);
// Load the identity matrix.
gl.LoadIdentity();
// Rotate around the Y axis.
//gl.Rotate(rotation, 0.0f, 1.0f, 0.0f);
cord = ComInput.Coordinates.Instance;
this.ModelRotater(gl);
gl.Enable(OpenGL.GL_BLEND);
gl.BlendFunc(OpenGL.GL_SRC_ALPHA, OpenGL.GL_ONE_MINUS_SRC_ALPHA);
// Draw a coloured parallelepiped.
gl.Begin(OpenGL.GL_QUADS);
gl.Color(0.0f, 1.0f, 0.0f);
gl.Vertex(-2.0f, -0.25f, -1.0f);
gl.Color(0.0f, 1.0f, 0.0f);
gl.Vertex(2.0f, -0.25f, -1.0f);
gl.Color(0.0f, 1.0f, 0.0f);
gl.Vertex(2.0f, 0.25f, -1.0f);
gl.Color(0.0f, 1.0f, 0.0f);
gl.Vertex(-2.0f, 0.25f, -1.0f);
//-------------------------------------
gl.Color(1.0f, 0.0f, 0.0f);
gl.Vertex(-2.0f, -0.25f, -1.0f);
gl.Color(1.0f, 0.0f, 0.0f);
gl.Vertex(-2.0f, -0.25f, 1.0f);
gl.Color(1.0f, 0.0f, 0.0f);
gl.Vertex(-2.0f, 0.25f, 1.0f);
gl.Color(1.0f, 0.0f, 0.0f);
gl.Vertex(-2.0f, 0.25f, -1.0f);
//-------------------------------------
gl.Color(0.0f, 1.0f, 0.0f);
gl.Vertex(-2.0f, -0.25f, 1.0f);
gl.Color(0.0f, 1.0f, 0.0f);
gl.Vertex(2.0f, -0.25f, 1.0f);
gl.Color(0.0f, 1.0f, 0.0f);
gl.Vertex(2.0f, 0.25f, 1.0f);
gl.Color(0.0f, 1.0f, 0.0f);
gl.Vertex(-2.0f, 0.25f, 1.0f);
//-------------------------------------
gl.Color(1.0f, 0.0f, 0.0f);
gl.Vertex(2.0f, -0.25f, 1.0f);
gl.Color(1.0f, 0.0f, 0.0f);
gl.Vertex(2.0f, -0.25f, -1.0f);
gl.Color(1.0f, 0.0f, 0.0f);
gl.Vertex(2.0f, 0.25f, -1.0f);
gl.Color(1.0f, 0.0f, 0.0f);
gl.Vertex(2.0f, 0.25f, 1.0f);
//-------------------------------------
gl.Color(0.0f, 1.0f, 1.0f);
gl.Vertex(-2.0f, 0.25f, -1.0f);
gl.Color(0.0f, 1.0f, 1.0f);
gl.Vertex(2.0f, 0.25f, -1.0f);
gl.Color(0.0f, 1.0f, 1.0f);
gl.Vertex(2.0f, 0.25f, 1.0f);
gl.Color(0.0f, 1.0f, 1.0f);
gl.Vertex(-2.0f, 0.25f, 1.0f);
//--------------------------------------
gl.Color(0.0f, 0.0f, 1.0f);
gl.Vertex(-2.0f, -0.25f, -1.0f);
gl.Color(0.0f, 0.0f, 1.0f);
gl.Vertex(2.0f, -0.25f, -1.0f);
gl.Color(0.0f, 0.0f, 1.0f);
gl.Vertex(2.0f, -0.25f, 1.0f);
gl.Color(0.0f, 0.0f, 1.0f);
gl.Vertex(-2.0f, -0.25f, 1.0f);
gl.End();
//-------------------Angle indicator prototype is here----------------------------------------------
gl.LoadIdentity();
gl.Rotate(cord.getX(), 1.0f, 0.0f, 0.0f);
gl.Begin(OpenGL.GL_TRIANGLES);
gl.Vertex(0.0f, 2.75f, 0.0f);
gl.Vertex(0.25f, 3.25f, 0.0f);
gl.Vertex(-0.25f, 3.25f, 0.0f);
gl.End();
gl.LoadIdentity();
gl.Rotate(cord.getZ(), 0.0f, 1.0f, 0.0f);
gl.Begin(OpenGL.GL_TRIANGLES);
gl.Vertex(0.0f, 0.0f, 2.75f);
gl.Vertex(0.0f, 0.25f, 3.25f);
gl.Vertex(0.0f, -0.25f, 3.25f);
gl.End();
gl.LoadIdentity();
gl.Rotate(cord.getY(), 0.0f, 0.0f, 1.0f);
gl.Begin(OpenGL.GL_TRIANGLES);
gl.Vertex(2.75f, 0.0f, 0.0f);
gl.Vertex(3.25f, 0.0f, 0.25f);
gl.Vertex(3.25f, 0.0f, -0.25f);
gl.End();
//------------------Circles of planes is here-----------------------------------------------
gl.LoadIdentity();
gl.Begin(OpenGL.GL_LINE_LOOP);
for(int i = 0; i < 200; i++)
{
float theta = 2.0f * 3.1415926f * (float)i / 200f;//get the current angle
float x = 3f * (float)System.Math.Cos(theta);//calculate the x component
float y = 3f * (float)System.Math.Sin(theta);//calculate the y component
gl.Color(0.0f, 1.0f, 0.0f);
gl.Vertex(0f, y + 0.0f, x + 0.0f);//output vertex
}
gl.End();
gl.Begin(OpenGL.GL_LINE_LOOP);
for (int i = 0; i < 200; i++)
{
float theta = 2.0f * 3.1415926f * (float)i / 200f;//get the current angle
float x = 3f * (float)System.Math.Cos(theta);//calculate the x component
float y = 3f * (float)System.Math.Sin(theta);//calculate the y component
gl.Vertex(x + 0.0f, 0.0f, y + 0.0f);//output vertex
}
gl.End();
gl.Begin(OpenGL.GL_LINE_LOOP);
for (int i = 0; i < 200; i++)
{
float theta = 2.0f * 3.1415926f * (float)i / 200f;//get the current angle
float x = 3f * (float)System.Math.Cos(theta);//calculate the x component
float y = 3f * (float)System.Math.Sin(theta);//calculate the y component
gl.Vertex(x + 0.0f, y + 0.0f, 0.0f);//output vertex
}
gl.End();
/* //--------------Coordinate axis's is here--------------------------------------------
gl.LoadIdentity();
gl.Begin(OpenGL.GL_LINE_STRIP);
gl.Color(1.0f, 1.0f, 1.0f);
gl.Vertex(-4.0f, 0.5f, 1.5f);
gl.Vertex(2.5f, 0.5f, 1.5f);
gl.Vertex(2.5f, 0.5f, -4.5f);
gl.Vertex(2.5f, 0.5f, 1.5f);
gl.Vertex(2.5f, 4.0f, 1.5f);
gl.End();
*/ //------------Shpere is here-----------------------------
gl.LoadIdentity();
gl.Color(0.85f, 0.85f, 0.85f, 0.5f);
gl.Begin(OpenGL.GL_QUADS);
for (int i = 0; i < 1; i++)
{
this.draw_sphere(gl, 3);
}
gl.End();
//---------------3D Text prototype is here-------------------
gl.LoadIdentity();
gl.Translate(0.0f, 3.5f, -3.0f);
gl.Color(0.0f, 1.0f, 0.65f);
gl.Rotate(270.0f, 0.0f, 1.0f, 0.0f);
gl.DrawText3D("a", 0.2f,
1.0f, 0.1f, "osX: 0");
// Nudge the rotation.
rotation += 2.0f;
}
public override void Draw3D(OpenGL gl)
{
float drawCoord = (int)(y * 2) % pieces;
float size = 2;
double theta = 0;
if (fever)
{
size = 3f;
if (xpos < -4)
theta = (xpos + 4) * Math.PI / 4;
else if (xpos > 4)
theta = (xpos - 4) * Math.PI / 4;
}
gl.Begin(BeginMode.Quads);
{
if (fever)
gl.Color(1.0f, 0.5f, 0.5f);
gl.TexCoord(drawCoord / pieces, 1);
gl.Vertex(xpos * 0.5f - (0.4f * size) * Math.Cos(theta), y - (0.4f * size) * Math.Sin(theta), 0);
gl.TexCoord(drawCoord / pieces, 0);
gl.Vertex(xpos * 0.5f - (0.4f * size) * Math.Cos(theta), y - (0.4f * size) * Math.Sin(theta), size);
gl.TexCoord((drawCoord + 1) / pieces, 0);
gl.Vertex(xpos * 0.5f + (0.4f * size) * Math.Cos(theta), y + (0.4f * size) * Math.Sin(theta), size);
gl.TexCoord((drawCoord + 1) / pieces, 1);
gl.Vertex(xpos * 0.5f + (0.4f * size) * Math.Cos(theta), y + (0.4f * size) * Math.Sin(theta), 0);
gl.Color(1.0f, 1.0f, 1.0f);
}
gl.End();
}
/// <summary>
/// Draws the text.
/// </summary>
/// <param name="gl">The gl.</param>
/// <param name="x">The x.</param>
/// <param name="y">The y.</param>
/// <param name="r">The r.</param>
/// <param name="g">The g.</param>
/// <param name="b">The b.</param>
/// <param name="faceName">Name of the face.</param>
/// <param name="fontSize">Size of the font.</param>
/// <param name="text">The text.</param>
public void DrawText(OpenGL gl, int x, int y, float r, float g, float b, string faceName, float fontSize, string text)
{
// Get the font size in pixels.
var fontHeight = (int)(fontSize * (16.0f / 12.0f));
// Do we have a font bitmap entry for this OpenGL instance and face name?
var result = (from fbe in fontBitmapEntries
where fbe.HDC == gl.RenderContextProvider.DeviceContextHandle
&& fbe.HRC == gl.RenderContextProvider.RenderContextHandle
&& String.Compare(fbe.FaceName, faceName, StringComparison.OrdinalIgnoreCase) == 0
&& fbe.Height == fontHeight
select fbe).ToList();
// Get the FBE or null.
var fontBitmapEntry = result.FirstOrDefault();
// If we don't have the FBE, we must create it.
if (fontBitmapEntry == null)
fontBitmapEntry = CreateFontBitmapEntry(gl, faceName, fontHeight);
double width = gl.RenderContextProvider.Width;
double height = gl.RenderContextProvider.Height;
// Create the appropriate projection matrix.
gl.MatrixMode(OpenGL.GL_PROJECTION);
gl.PushMatrix();
gl.LoadIdentity();
int[] viewport = new int[4];
gl.GetInteger(OpenGL.GL_VIEWPORT, viewport);
gl.Ortho(0, width, 0, height, -1, 1);
// Create the appropriate modelview matrix.
gl.MatrixMode(OpenGL.GL_MODELVIEW);
gl.PushMatrix();
gl.LoadIdentity();
gl.Color(r, g, b);
gl.RasterPos(x, y);
gl.PushAttrib(OpenGL.GL_LIST_BIT | OpenGL.GL_CURRENT_BIT |
OpenGL.GL_ENABLE_BIT | OpenGL.GL_TRANSFORM_BIT);
gl.Color(r, g, b);
gl.Disable(OpenGL.GL_LIGHTING);
gl.Disable(OpenGL.GL_TEXTURE_2D);
gl.Disable(OpenGL.GL_DEPTH_TEST);
gl.RasterPos(x, y);
// Set the list base.
gl.ListBase(fontBitmapEntry.ListBase);
// Create an array of lists for the glyphs.
var lists = text.Select(c => (byte) c).ToArray();
// Call the lists for the string.
gl.CallLists(lists.Length, lists);
gl.Flush();
// Reset the list bit.
gl.PopAttrib();
// Pop the modelview.
gl.PopMatrix();
// back to the projection and pop it, then back to the model view.
gl.MatrixMode(OpenGL.GL_PROJECTION);
gl.PopMatrix();
gl.MatrixMode(OpenGL.GL_MODELVIEW);
}
public static void LocalAxis(SharpGL.OpenGL gl)
{
double[] Reddish = { 0.9, 0.3, 0.4 };
double[] Greenish = { 0.1, 0.8, 0.3 };
double[] Bluish = { 0.1, 0.2, 0.8 };
gl.PushAttrib(SharpGL.OpenGL.GL_LIGHTING);
gl.Disable(SharpGL.OpenGL.GL_LIGHTING);
gl.LineWidth(3);
gl.Color(Reddish);
gl.Begin(SharpGL.Enumerations.BeginMode.LineLoop);
gl.Vertex(0f, 0f, 0f);
gl.Vertex(1f, 0f, 0f);
gl.End( );
gl.Color(Greenish);
gl.Begin(SharpGL.Enumerations.BeginMode.LineLoop);
gl.Vertex(0f, 0f, 0f);
gl.Vertex(0f, 1f, 0f);
gl.End( );
gl.Color(Bluish);
gl.Begin(SharpGL.Enumerations.BeginMode.LineLoop);
gl.Vertex(0f, 0f, 0f);
gl.Vertex(0f, 0f, 1f);
gl.End( );
gl.PopAttrib( );
}
//-------------------------------------
public override void ConvertPrimitive(I3DPrimitive primitive, SharpGL.OpenGL gl)
{
C3DPrimitiveQuad quad = primitive as C3DPrimitiveQuad;
if (quad == null || quad.Points == null || quad.Points.Length != 4)
{
return;
}
for (int nTmp = 0; nTmp < 2; nTmp++)
{
if (nTmp == 0)
{
gl.PolygonMode(OpenGL.FRONT_AND_BACK, OpenGL.FILL);
gl.Color(GetComposantsCouleur(quad.Couleur));
}
else
{
gl.PolygonMode(OpenGL.FRONT_AND_BACK, OpenGL.LINE);
gl.Color(0.0f, 0.0f, 0.0f, 1.0f);
}
gl.Material(OpenGL.FRONT_AND_BACK, OpenGL.SPECULAR, GetComposantsCouleur(quad.Couleur));
gl.Material(OpenGL.FRONT_AND_BACK, OpenGL.SHININESS, 100.0f);
gl.Begin(OpenGL.QUADS);
//Fond
//gl.Normal3f(0f, 0f, -1.0f);
for (int n = 0; n < 4; n++)
{
gl.Vertex(quad.Points[n].X, quad.Points[n].Y, quad.Points[n].Z);
}
gl.End();
}
}
//rysowanie siatki
private void openGLControl1_OpenGLDraw(object sender, PaintEventArgs e)
{
SharpGL.OpenGL gl = this.openGLControl1.OpenGL;
gl.Clear(OpenGL.COLOR_BUFFER_BIT | OpenGL.DEPTH_BUFFER_BIT);
gl.LoadIdentity();
gl.Translate(0, 0, tz);
gl.Rotate(rotX, 1, 0, 0);
gl.Rotate(rotZ, 0, 0, 1);
gl.Begin(OpenGL.TRIANGLES);
gl.Color(1, 0, 0, 1);
int multt = 1;
gl.Vertex((minY - (heightArray.Length / 2)) * multt, (minX - (heightArray.Length / 2)) * multt, heightArray[minY][minX]);
gl.Vertex((minY - (heightArray.Length / 2)) * multt, (minX + 1 - (heightArray.Length / 2)) * multt, heightArray[minY + 1][minX]);
gl.Vertex((minY + 1 - (heightArray.Length / 2)) * multt, (minX - (heightArray.Length / 2)) * multt, heightArray[minY][minX + 1]);
gl.End();
gl.Color(1, 1, 1, 1);
gl.Begin(OpenGL.LINES);
for (int i = 0; i < heightArray.Length - 1; i++)
{
for (int j = 0; j < heightArray[0].Length - 1; j++)
{
DrawTriangle(gl, i, j);
}
}
gl.End();
}
public override void Draw(SharpGL.OpenGL gl)
{
//Process alignment in baseclass
base.Draw(gl);
//Draw arms
_arm1.Draw(gl);
_arm2.Draw(gl);
_arm3.Draw(gl);
//Draw middle triangle. At each vertex of this triangle two arms meet.
//So for color merging we will give each vertex the average color of the two
//adjacent arms - precalculated in constructor
gl.Begin(SharpGL.Enumerations.BeginMode.Triangles);
gl.Color(_vertex32.R, _vertex32.G, _vertex32.B);
gl.Vertex(_arm3.Corner1.x, _arm3.Corner1.y);
gl.Color(_vertex21.R, _vertex21.G, _vertex21.B);
gl.Vertex(_arm1.Corner4.x, _arm1.Corner4.y);
gl.Color(_vertex13.R, _vertex13.G, _vertex13.B);
gl.Vertex(_arm1.Corner1.x, _arm1.Corner1.y);
gl.End();
}
public override void Draw(SharpGL.OpenGL gl)
{
base.Draw(gl);
if (_data == null)
{
}
gl.BindTexture(OpenGL.GL_TEXTURE_2D, 0);
gl.Begin(OpenGL.GL_QUAD_STRIP);
for (int i = 0; i < _data.Length; i++)
{
gl.Color(_data[i], _data[i], _data[i]);
_x = ((GetSize().x / 256f) * i) + CamController.X - (GetSize().x / 2f);
gl.Vertex(_x, GetPosition().y + _data[i] * _height);
//gl.Vertex(_x, GetPosition().y + _data[i] * _height - 1.0f);
gl.Vertex(_x, GetPosition().y);
}
gl.End();
gl.Begin(OpenGL.GL_QUAD_STRIP);
for (int i = 0; i < _data.Length; i++)
{
gl.Color(_data[i] - 0.5f, _data[i] - 0.5f, _data[i] - 0.5f);
_x = ((GetSize().x / 256f) * i) + CamController.X - (GetSize().x / 2f);
gl.Vertex(_x, GetPosition().y - _data[i] * _height / 10.0f);
//gl.Vertex(_x, GetPosition().y + _data[i] * _height - 1.0f);
gl.Color(_data[i], _data[i], _data[i]);
gl.Vertex(_x, GetPosition().y);
}
gl.End();
}
public void paint(OpenGL gl)
{
gl.Color(1f, 1f, 1f);
gl.Begin(OpenGL.GL_TRIANGLE_STRIP);
gl.Vertex(x, y + height, 0);
gl.Vertex(x, y, 0);
gl.Vertex(x+width, y + height, 0);
gl.Vertex(x+width, y, 0);
gl.End();
gl.LineWidth(1);
gl.Begin(OpenGL.GL_LINES);
gl.Color(0, 0, 0);
if (centerCoordinateX <= x + width && centerCoordinateX >= x)
{
gl.Vertex4d(centerCoordinateX, y, 0, 1);
gl.Vertex4d(centerCoordinateX, y + height, 0, 1);
}
if (centerCoordinateY <= y + height && centerCoordinateY >= y)
{
gl.Vertex4d(x, centerCoordinateY, 0, 1);
gl.Vertex4d(x+width, centerCoordinateY, 0, 1);
}
gl.End();
for(int i = 0; i < functions.Count; i++)
{
drawFunction(gl, functions.ElementAt(i));
}
}
public override void Draw(SharpGL.OpenGL gl)
{
//float defaultHeight = 0.3f * 3 + 0.2f;
gl.PushMatrix();
gl.Translate(position.x, position.y, position.z);
gl.Rotate(-90, 1, 0, 0);
gl.Scale(scaleKoef, scaleKoef, scaleKoef);
//gl.Color(color.GetInArr());
//float curHeight = 0.25f;
//gl.Cylinder(gl.NewQuadric(), curHeight / 2, curHeight / 2, curHeight, 20, 20);
//gl.Translate(0, 0, 0.25f);
//curHeight = 5f / 14f;
//gl.Cylinder(gl.NewQuadric(), curHeight, 0, curHeight, 20, 20);
//gl.Translate(0, 0, 0.25f);
//curHeight = 4f / 14f;
//gl.Cylinder(gl.NewQuadric(), curHeight, 0, curHeight, 20, 20);
//gl.Translate(0, 0, 0.25f);
//curHeight = 3f / 14f;
//gl.Cylinder(gl.NewQuadric(), curHeight, 0, curHeight, 20, 20);
gl.Color(trunkColor.GetInArrWithAlpha());
gl.Material(OpenGL.GL_FRONT_AND_BACK, OpenGL.GL_DIFFUSE, trunkColor.GetInArrWithAlpha());
gl.Cylinder(gl.NewQuadric(), 0.1, 0.1, 0.4, 20, 20);
gl.Material(OpenGL.GL_FRONT_AND_BACK, OpenGL.GL_DIFFUSE, color.GetInArrWithAlpha());
gl.Color(color.GetInArrWithAlpha());
gl.Translate(0, 0, 0.2);
gl.Cylinder(gl.NewQuadric(), 0.5, 0, 0.5, 20, 20);
gl.Translate(0, 0, 0.3);
gl.Cylinder(gl.NewQuadric(), 0.4, 0, 0.4, 20, 20);
gl.Translate(0, 0, 0.3);
gl.Cylinder(gl.NewQuadric(), 0.3, 0, 0.3, 20, 20);
gl.PopMatrix();
}
//jumpFrame: 一次跳躍資料數
public static void drawGL_FrameData_Triangle(SharpGL.OpenGL gl_object, FrameData_LJV7 frame, int jumpFrame)
{
gl_object.Clear(OpenGL.COLOR_BUFFER_BIT | OpenGL.DEPTH_BUFFER_BIT);
//可以不用每次都旋轉，可以滑鼠動作時變更即可
//不影響效能
gl_object.LoadIdentity();
gl_object.Translate(_LX, _LY, _LZ);
gl_object.Rotate(_RoX, 0.0, 1.0, 0.0);
gl_object.Rotate(_RoY, 1.0, 0.0, 0.0);
gl_object.Rotate(_RoZ, 0.0, 0.0, 1.0);
double x = 0, y = 0;
double centerx = frame.size_per_frame / 2;
double centery = frame.LJVcount / 2;
double diff = frame.Max_Buffer_Compute - frame.Min_Buffer_Compute;
double r = 0, g = 0, b = 0;
double Color_H = 0.0;
for (int j = 0; j < frame.LJVcount - jumpFrame; j += jumpFrame)
{
gl_object.Begin(OpenGL.TRIANGLE_STRIP);
for (int i = 0; i < frame.size_per_frame - jumpFrame; i += jumpFrame)
{
int pos = Convert.ToInt32(i * frame.LJVcount + j);
if (frame.buffer_compute[pos] == -999 || frame.buffer_compute[pos + jumpFrame] == -999)
{
gl_object.End();
gl_object.Begin(OpenGL.TRIANGLE_STRIP);
continue;
}
Color_H = (frame.buffer_compute[pos] - frame.Min_Buffer_Compute) / diff;
Color_H = Color_H * (MaxColorH - MinColorH) + MinColorH;
HsvToRgb(Color_H, 1.0, 1.0, out r, out g, out b);
gl_object.Color(r, g, b);
x = (Convert.ToDouble(i) - centerx) / Convert.ToDouble(100);
y = -(Convert.ToDouble(j) - centery) / Convert.ToDouble(100);
gl_object.Vertex(x, y, frame.buffer_compute[pos]);
Color_H = (frame.buffer_compute[pos + jumpFrame] - frame.Min_Buffer_Compute) / diff;
Color_H = Color_H * (MaxColorH - MinColorH) + MinColorH;
HsvToRgb(Color_H, 1.0, 1.0, out r, out g, out b);
gl_object.Color(r, g, b);
x = (Convert.ToDouble(i) - centerx) / Convert.ToDouble(100);
y = -(Convert.ToDouble(j + jumpFrame) - centery) / Convert.ToDouble(100);
gl_object.Vertex(x, y, frame.buffer_compute[pos + jumpFrame]);
}
gl_object.End();
}
//drawAxis(gl_object);
gl_object.Flush();
return;
}
public static void Draw3DInformation(SharpGL.OpenGL gl_object, float[] X, float[] Y, float[] Z, DetectedRectRegion DetectField)
{
double MaxDistance = 0;
double r = 0, g = 0, b = 0;
gl_object.Clear(OpenGL.GL_COLOR_BUFFER_BIT | OpenGL.GL_DEPTH_BUFFER_BIT);
gl_object.LoadIdentity();
gl_object.Translate(_LX, _LY, _LZ);
gl_object.Rotate(_RoX, 0.0, 1.0, 0.0);
gl_object.Rotate(_RoY, 1.0, 0.0, 0.0);
gl_object.Rotate(_RoZ, 0.0, 0.0, 1.0);
//畫光達自己的位置
gl_object.Begin(OpenGL.GL_TRIANGLES);
gl_object.Color(1.0, 1.0, 1.0);
gl_object.Vertex(-0.2, -0.15, 0);
gl_object.Vertex(0, 0.2, 0);
gl_object.Vertex(0.2, -0.15, 0);
gl_object.End();
drawAxis(gl_object);
//畫D場景
gl_object.Begin(OpenGL.GL_POINTS);
for (int i = 0; i < 23040; i++)
{
if (DetectField.DetectRegionX1 < X[i] && X[i] < DetectField.DetectRegionX2 && DetectField.DetectRegionY1 < Y[i] && Y[i] < DetectField.DetectRegionY2 && DetectField.DetectRegionZ1 < Z[i] && Z[i] < DetectField.DetectRegionZ2)
{
continue;
}
if (X[i] != 0 && Y[i] != 0 && Z[i] != 0)
{
//用XY距離計算顯示顏色
double XYDistance = Math.Sqrt(X[i] * X[i] + Y[i] * Y[i]);
if (XYDistance > MaxDistance)
{
MaxDistance = XYDistance;
}
if (XYDistance > 10)
{
XYDistance = 10;
}
XYDistance = XYDistance / 10 * (360 - 30) + 30;
HsvToRgb(XYDistance, 1, 1, out r, out g, out b);
gl_object.Color(r, g, b);
//畫上點座標
gl_object.Vertex(X[i], Y[i], Z[i]);
}
}
gl_object.End();
gl_object.Flush();
}
public static void drawGL_FrameData_Triangle(SharpGL.OpenGL gl_object, ModelBuilder builder, int jumpFrame)
{
if (builder._ShowPoints == null || builder._ShowPoints.Length <= 0)
{
return;
}
gl_object.Clear(OpenGL.COLOR_BUFFER_BIT | OpenGL.DEPTH_BUFFER_BIT);
//可以不用每次都旋轉，可以滑鼠動作時變更即可
//不影響效能
gl_object.LoadIdentity();
gl_object.Translate(GLDrawObject._LX, GLDrawObject._LY, GLDrawObject._LZ);
gl_object.Rotate(GLDrawObject._RoX, 0.0, 1.0, 0.0);
gl_object.Rotate(GLDrawObject._RoY, 1.0, 0.0, 0.0);
gl_object.Rotate(GLDrawObject._RoZ, 0.0, 0.0, 1.0);
for (int j = 0; j < builder._LJV7Frame.LJVcount - jumpFrame; j += jumpFrame)
{
gl_object.Begin(OpenGL.TRIANGLE_STRIP);
for (int i = 0; i < builder._LJV7Frame.size_per_frame - jumpFrame; i += jumpFrame)
{
int pos = Convert.ToInt32(i * builder._LJV7Frame.LJVcount + j);
if (builder._ShowPoints[pos].Z == -999 || builder._ShowPoints[pos + jumpFrame].Z == -999)
{
gl_object.End();
gl_object.Begin(OpenGL.TRIANGLE_STRIP);
continue;
}
DPoint point = builder._ShowPoints[pos];
gl_object.Color(point.r, point.g, point.b);
gl_object.Vertex(point.X, point.Y, point.Z);
point = builder._ShowPoints[pos + jumpFrame];
gl_object.Color(point.r, point.g, point.b);
gl_object.Vertex(point.X, point.Y, point.Z);
//Console.WriteLine("X:" + point.r);
//Console.WriteLine("Y:" + point.g);
//Console.WriteLine("Z:" + point.b);
}
gl_object.End();
}
GLDrawObject.drawAxis(gl_object);
gl_object.Flush();
return;
}
private void openGLControl1_OpenGLDraw(object sender, SharpGL.RenderEventArgs args)
{
SharpGL.OpenGL gl = this.openGLControl1.OpenGL;
gl.Clear(OpenGL.GL_COLOR_BUFFER_BIT | OpenGL.GL_DEPTH_BUFFER_BIT);
gl.LoadIdentity();
gl.LookAt(0, 20, 30, 0, 0, 0, 0, 1, 0);
//desenha o piso
gl.Enable(OpenGL.GL_TEXTURE_2D);
grass.Bind(gl);
gl.Begin(OpenGL.GL_QUADS);
gl.Color(0.0f, 1.0f, 0.0f);
gl.TexCoord(0.0f, 0.0f); gl.Vertex(-100.0f, 0.0f, -100.0f);
gl.TexCoord(100.0f, 0.0f); gl.Vertex(100.0f, 0.0f, -100.0f);
gl.TexCoord(100.0f, 100.0f); gl.Vertex(100.0f, 0.0f, 100.0f);
gl.TexCoord(0.0f, 100.0f); gl.Vertex(-100.0f, 0.0f, 100.0f);
gl.End();
gl.Disable(OpenGL.GL_TEXTURE_2D);
foreach (Polygon polygon in polygons)
{
polygon.PushObjectSpace(gl);
polygon.Render(gl, SharpGL.SceneGraph.Core.RenderMode.Render);
polygon.PopObjectSpace(gl);
}
gl.Flush();
}
private void openGLControl2_Load(object sender, EventArgs e)
{
this.openGLControl2.OpenGLDraw += new System.Windows.Forms.PaintEventHandler(this.openGLControl2_OpenGLDraw);
SharpGL.OpenGL gl = this.openGLControl2.OpenGL;
gl.Color(0.0f, 0.0f, 0.0f);
}
public override void Draw(SharpGL.OpenGL gl)
{
gl.PushAttrib(AttributeMask.All);
gl.PushMatrix();
if (texture != null)
{
gl.Enable(OpenGL.GL_TEXTURE_2D);
texture.Push(gl);
}
gl.Begin(BeginMode.Quads);
{
gl.Color(color.GetInArrWithAlpha());
gl.Normal(0, 1, 0);
gl.TexCoord(0, 0);
gl.Vertex(position.x - lenByX / 2, position.y, position.z + lenByZ / 2);
gl.TexCoord(lenByX, 0);
gl.Vertex(position.x + lenByX / 2, position.y, position.z + lenByZ / 2);
gl.TexCoord(lenByX, lenByZ);
gl.Vertex(position.x + lenByX / 2, position.y, position.z - lenByZ / 2);
gl.TexCoord(0, lenByZ);
gl.Vertex(position.x - lenByX / 2, position.y, position.z - lenByZ / 2);
}
gl.End();
if (texture != null)
{
texture.Pop(gl);
}
gl.PopMatrix();
gl.PopAttrib();
}
public override void Draw(SharpGL.OpenGL gl)
{
if (_trail > 1)
{
for (int t = 0; t < _trail; t++)
{
PointFloat trailPos = GetPosition();
PointFloat vel = GetVelocity();
PointFloat dit = new PointFloat(trailPos.x - vel.x * t, trailPos.y - vel.y * t);
PointFloat[] pointData = RenderLogics.RectPoint(dit, GetSize(), GetRotation());
GetTexture().UseTexure(gl);
gl.Begin(OpenGL.GL_QUADS);
byte[] col = GetColor();
gl.Color(col[0], col[1], col[2]);
gl.TexCoord(0, 0);
gl.Vertex(pointData[1].x, pointData[1].y);
gl.TexCoord(0, 1);
gl.Vertex(pointData[0].x, pointData[0].y);
gl.TexCoord(1, 1);
gl.Vertex(pointData[3].x, pointData[3].y);
gl.TexCoord(1, 0);
gl.Vertex(pointData[2].x, pointData[2].y);
gl.End();
}
}
base.Draw(gl);
}
public static void Draw(OpenGL gl, double height, double length, double width)
{
gl.LineWidth(1);
gl.Color(0.7, 0.7, 0.7);
gl.Begin(OpenGL.GL_LINE_LOOP);
gl.Vertex(0, height, 0 );
gl.Vertex(0, height, width);
gl.Vertex(length, height, width);
gl.Vertex(length, height, 0 );
gl.End();
gl.Begin(OpenGL.GL_LINES);
gl.Vertex(0, height, 0);
gl.Vertex(0, 0, 0);
gl.Vertex(length, height, 0);
gl.Vertex(length, 0, 0);
gl.Vertex(0, height, width);
gl.Vertex(0, 0, width);
gl.Vertex(length, height, width);
gl.Vertex(length, 0, width);
gl.End();
gl.Begin(OpenGL.GL_LINE_LOOP);
gl.Vertex(0, 0, 0);
gl.Vertex(0, 0, width);
gl.Vertex(length, 0, width);
gl.Vertex(length, 0, 0);
gl.End();
}
public static void DrawDetectRectRegion(SharpGL.OpenGL gl_object, DetectedRectRegion DetectField, double ColorR, double ColorG, double ColorB)
{
gl_object.LoadIdentity();
gl_object.Translate(_LX, _LY, _LZ);
gl_object.Rotate(_RoX, 0.0, 1.0, 0.0);
gl_object.Rotate(_RoY, 1.0, 0.0, 0.0);
gl_object.Rotate(_RoZ, 0.0, 0.0, 1.0);
//畫範圍
gl_object.Color(ColorR, ColorG, ColorB);
gl_object.Begin(OpenGL.GL_LINE_STRIP);
gl_object.Vertex(DetectField.DetectRegionX1, DetectField.DetectRegionY1, DetectField.DetectRegionZ1);
gl_object.Vertex(DetectField.DetectRegionX2, DetectField.DetectRegionY1, DetectField.DetectRegionZ1);
gl_object.Vertex(DetectField.DetectRegionX2, DetectField.DetectRegionY2, DetectField.DetectRegionZ1);
gl_object.Vertex(DetectField.DetectRegionX1, DetectField.DetectRegionY2, DetectField.DetectRegionZ1);
gl_object.Vertex(DetectField.DetectRegionX1, DetectField.DetectRegionY1, DetectField.DetectRegionZ1);
gl_object.Vertex(DetectField.DetectRegionX1, DetectField.DetectRegionY1, DetectField.DetectRegionZ2);
gl_object.Vertex(DetectField.DetectRegionX2, DetectField.DetectRegionY1, DetectField.DetectRegionZ2);
gl_object.Vertex(DetectField.DetectRegionX2, DetectField.DetectRegionY1, DetectField.DetectRegionZ1);
gl_object.Vertex(DetectField.DetectRegionX2, DetectField.DetectRegionY1, DetectField.DetectRegionZ2);
gl_object.Vertex(DetectField.DetectRegionX2, DetectField.DetectRegionY2, DetectField.DetectRegionZ2);
gl_object.Vertex(DetectField.DetectRegionX2, DetectField.DetectRegionY2, DetectField.DetectRegionZ1);
gl_object.Vertex(DetectField.DetectRegionX2, DetectField.DetectRegionY2, DetectField.DetectRegionZ2);
gl_object.Vertex(DetectField.DetectRegionX1, DetectField.DetectRegionY2, DetectField.DetectRegionZ2);
gl_object.Vertex(DetectField.DetectRegionX1, DetectField.DetectRegionY2, DetectField.DetectRegionZ1);
gl_object.Vertex(DetectField.DetectRegionX1, DetectField.DetectRegionY2, DetectField.DetectRegionZ2);
gl_object.Vertex(DetectField.DetectRegionX1, DetectField.DetectRegionY1, DetectField.DetectRegionZ2);
gl_object.End();
}
public override void Draw(SharpGL.OpenGL gl)
{
gl.PushMatrix();
gl.PushAttrib(AttributeMask.All);
gl.PushClientAttrib(OpenGL.GL_CLIENT_ALL_ATTRIB_BITS);
gl.VertexPointer(3, 0, vertexs);
gl.NormalPointer(OpenGL.GL_FLOAT, 0, normals);
gl.TexCoordPointer(2, OpenGL.GL_FLOAT, 0, texCoord);
gl.EnableClientState(OpenGL.GL_VERTEX_ARRAY);
gl.EnableClientState(OpenGL.GL_NORMAL_ARRAY);
gl.EnableClientState(OpenGL.GL_TEXTURE_COORD_ARRAY);
gl.Translate(position.x, position.y + sizeY / 2, position.z);
gl.Color(color.GetInArrWithAlpha());
DrawArrayWithTexture(gl, OpenGL.GL_QUADS, 0, 4, textureZplus); //z+
DrawArrayWithTexture(gl, OpenGL.GL_QUADS, 4, 4, textureYplus); //y+
DrawArrayWithTexture(gl, OpenGL.GL_QUADS, 8, 4, textureZminus); //z-
DrawArrayWithTexture(gl, OpenGL.GL_QUADS, 12, 4, textureYminus); //y-
DrawArrayWithTexture(gl, OpenGL.GL_QUADS, 16, 4, textureXminus); //x-
DrawArrayWithTexture(gl, OpenGL.GL_QUADS, 20, 4, texture); //x+
gl.PopClientAttrib();
gl.PopAttrib();
gl.PopMatrix();
}
public override void Draw(SharpGL.OpenGL gl)
{
gl.PushMatrix();
gl.PushAttrib(AttributeMask.All);
gl.PushClientAttrib(OpenGL.GL_CLIENT_ALL_ATTRIB_BITS);
gl.VertexPointer(3, 0, vertexs);
gl.NormalPointer(OpenGL.GL_FLOAT, 0, normals);
gl.TexCoordPointer(2, OpenGL.GL_FLOAT, 0, texCoord);
gl.EnableClientState(OpenGL.GL_VERTEX_ARRAY);
//gl.EnableClientState(OpenGL.GL_COLOR_ARRAY);
gl.EnableClientState(OpenGL.GL_NORMAL_ARRAY);
gl.EnableClientState(OpenGL.GL_TEXTURE_COORD_ARRAY);
gl.Translate(position.x, position.y + sizeY / 2, position.z);
gl.Color(color.GetInArrWithAlpha());
if (texture != null)
{
gl.Enable(OpenGL.GL_TEXTURE_2D);
texture.Bind(gl);
}
else
{
gl.Disable(OpenGL.GL_TEXTURE_2D);
}
gl.DrawArrays(OpenGL.GL_QUADS, 0, 24);
gl.PopClientAttrib();
gl.PopAttrib();
gl.PopMatrix();
}
/// <summary>
/// Creates the display list. This function draws the
/// geometry as well as compiling it.
/// </summary>
void CreateDisplayList(SharpGL.OpenGL gl)
{
// Create the display list.
this.displayList = new DisplayList();
// Generate the display list and
this.displayList.Generate(gl);
this.displayList.New(gl, DisplayList.DisplayListMode.CompileAndExecute);
// Push attributes, set the color.
gl.PushAttrib(OpenGL.GL_CURRENT_BIT | OpenGL.GL_ENABLE_BIT |
OpenGL.GL_LINE_BIT);
gl.Disable(OpenGL.GL_LIGHTING);
gl.Disable(OpenGL.GL_TEXTURE_2D);
gl.LineWidth(1.0f);
// Draw the grid lines.
gl.Begin(SharpGL.OpenGL.GL_LINES);
for (int i = -10; i <= 10; i++)
{
float fcol = ((i % 10) == 0) ? 0.3f : 0.15f;
gl.Color(fcol, fcol, fcol);
gl.Vertex(i, -10, 0);
gl.Vertex(i, 10, 0);
gl.Vertex(-10, i, 0);
gl.Vertex(10, i, 0);
}
gl.End();
// Restore attributes.
gl.PopAttrib();
// End the display list.
this.displayList.End(gl);
}
public override void Draw(SharpGL.OpenGL gl)
{
gl.PushMatrix();
float halfSize = size / 2;
gl.Translate(position.x, position.y + halfSize, position.z);
gl.Color(color.GetInArrWithAlpha());
Point3D[] vertex = new Point3D[]
{
new Point3D(halfSize, halfSize, halfSize),
new Point3D(-halfSize, halfSize, halfSize),
new Point3D(-halfSize, -halfSize, halfSize),
new Point3D(halfSize, -halfSize, halfSize),
new Point3D(halfSize, halfSize, -halfSize),
new Point3D(-halfSize, halfSize, -halfSize),
new Point3D(-halfSize, -halfSize, -halfSize),
new Point3D(halfSize, -halfSize, -halfSize)
};
DrawPrimitive.Quard(gl, vertex[0], vertex[1], vertex[2], vertex[3], false);
DrawPrimitive.Quard(gl, vertex[0], vertex[4], vertex[5], vertex[1], false);
DrawPrimitive.Quard(gl, vertex[7], vertex[6], vertex[5], vertex[4], false);
DrawPrimitive.Quard(gl, vertex[3], vertex[2], vertex[6], vertex[7], false);
DrawPrimitive.Quard(gl, vertex[1], vertex[5], vertex[6], vertex[2], false);
DrawPrimitive.Quard(gl, vertex[0], vertex[3], vertex[7], vertex[4], false);
gl.PopMatrix();
}
private void openGLControl1_OpenGLDraw(object sender, RenderEventArgs e)
{
// Get the OpenGL object, for quick access.
SharpGL.OpenGL gl = this.openGLControl1.OpenGL;
gl.Clear(OpenGL.GL_COLOR_BUFFER_BIT | OpenGL.GL_DEPTH_BUFFER_BIT);
gl.Color(1.0f, 1.0f, 1.0f);
gl.MatrixMode(OpenGL.GL_PROJECTION);
gl.LoadIdentity();
cam.Look();
gl.Disable(OpenGL.GL_TEXTURE_2D);
PlaneSurfaceRenderer psr = new PlaneSurfaceRenderer(16);
psr.render(gl);
texture.Bind(gl);
gl.Enable(OpenGL.GL_TEXTURE_2D);
foreach (ShapeRenderer shape in listShape)
{
shape.render(gl);
}
}
public override void Draw(SharpGL.OpenGL gl)
{
gl.PushMatrix();
gl.PushAttrib(AttributeMask.Lighting);
gl.Translate(position.x, position.y + 1 * scaleKoef, position.z);
gl.Scale(scaleKoef, scaleKoef, scaleKoef);
gl.Color(color.GetInArrWithAlpha());
float[] specular1 = { 1, 1, 1, 1 };
gl.Material(OpenGL.GL_FRONT_AND_BACK, OpenGL.GL_SPECULAR, specular1);
gl.Material(OpenGL.GL_FRONT_AND_BACK, OpenGL.GL_SHININESS, 60);
gl.Material(OpenGL.GL_FRONT, OpenGL.GL_SHININESS, 128);
for (int i = 0; i < 20; i++)
{
subdivine(gl,
new Vector3d(vdata[tindices[i][0]]),
new Vector3d(vdata[tindices[i][1]]),
new Vector3d(vdata[tindices[i][2]]),
divineCount);
}
gl.PopAttrib();
gl.PopMatrix();
}
public static void DrawDetectCircleRegion(SharpGL.OpenGL gl_object, DetectCircleRegion DetectField, double ColorR, double ColorG, double ColorB)
{
float x = 0;
float y = 0;
gl_object.LoadIdentity();
gl_object.Translate(_LX, _LY, _LZ);
gl_object.Rotate(_RoX, 0.0, 1.0, 0.0);
gl_object.Rotate(_RoY, 1.0, 0.0, 0.0);
gl_object.Rotate(_RoZ, 0.0, 0.0, 1.0);
//畫範圍
gl_object.Color(ColorR, ColorG, ColorB);
gl_object.Begin(OpenGL.GL_LINE_LOOP);
for (double i = 0; i < 6.28; i += 0.1744)
{
x = DetectField.CenterX + DetectField.Radius * (float)Math.Sin(i);
y = DetectField.CenterY + DetectField.Radius * (float)Math.Cos(i);
gl_object.Vertex(x, y, DetectField.ZUp);
}
gl_object.End();
gl_object.Color(ColorR, ColorG, ColorB);
gl_object.Begin(OpenGL.GL_LINE_LOOP);
for (double i = 0; i < 6.28; i += 0.1744)
{
x = DetectField.CenterX + DetectField.Radius * (float)Math.Sin(i);
y = DetectField.CenterY + DetectField.Radius * (float)Math.Cos(i);
gl_object.Vertex(x, y, DetectField.ZDown);
}
gl_object.End();
float ang = 0;
for (double i = 0; i < 4; i++)
{
gl_object.Color(ColorR, ColorG, ColorB);
gl_object.Begin(OpenGL.GL_LINE_LOOP);
x = DetectField.CenterX + DetectField.Radius * (float)Math.Sin(ang);
y = DetectField.CenterY + DetectField.Radius * (float)Math.Cos(ang);
gl_object.Vertex(x, y, DetectField.ZUp);
gl_object.Vertex(x, y, DetectField.ZDown);
ang += 1.57f;
gl_object.End();
}
}
private void openGLControl1_OpenGLDraw(object sender, PaintEventArgs e)
{
SharpGL.OpenGL gl = this.openGLControl1.OpenGL;
ResetOpenGL(gl, this.openGLControl1.Width, this.openGLControl1.Height);
int x = 0;
int y = 0;
for (int i = 0; i < tileSet.tile.Count; i++)
{
if (x + tileSize > this.openGLControl1.Width)
{
x = 0;
y += tileSize;
}
//Draw tile imgs
if (tileSet.tile[i].tileSprite.Count > 0)
{
for (int l = 0; l < tileSet.tile[i].tileSprite.Count; l++) // to diplay all layers on tile
{
tileSet.tileSheet.DrawSprite(x, y, tileSet.tile[i].tileSprite[l], gl);
}
}
else
{
gl.Color(0.25f, 0.25f, 0.25f);
gl.LineWidth(2.0f);
gl.Begin(OpenGL.GL_QUADS);
gl.Vertex(x, y, 1);
gl.Vertex(x, y + tileSize, 1);
gl.Vertex(x + tileSize, y, 1);
gl.Vertex(x + tileSize, y + tileSize, 1);
gl.End();
}
gl.LoadIdentity();
x += tileSize;
}
//Draw Selection
gl.Color(1.25f, 0.25f, 0.25f);
gl.LineWidth(2.0f);
gl.Begin(OpenGL.GL_LINES);
gl.Vertex(control1SelectionX * tileSize, control1SelectionY * tileSize, 1);
gl.Vertex((control1SelectionX * tileSize) + tileSize, (control1SelectionY * tileSize) + tileSize, 1);
gl.End();
}
public static void Draw(OpenGL gl, IEnumerable<double[]> bolt)
{
gl.Begin(OpenGL.GL_LINE_STRIP);
gl.Color(0, 1, 0);
foreach (var point in bolt)
{
gl.Vertex(point);
}
gl.End();
}
public override void Draw(SharpGL.OpenGL gl)
{
gl.PushAttrib(AttributeMask.Point);
gl.PointSize(10);
gl.Color(1f, 1f, 1f, 1f);
gl.Begin(BeginMode.Points);
gl.Vertex(position.ToArray());
gl.End();
gl.PopAttrib();
}
private void RenderVertices_Immediate(OpenGL gl)
{
gl.Color(1f, 0f, 0f);
gl.Begin(OpenGL.GL_POINTS);
for(uint i=0;i<vertices.Length; i++)
{
gl.Vertex(vertices[i]);
}
gl.End();
}
private void drawCoordinateAxes(OpenGL gl)
{
gl.Color(OpenGlUtility.GetOpenGlColor(Color.Red));
gl.Begin(OpenGL.GL_LINES);
gl.Vertex(0, 0, 0);
gl.Vertex(100, 0, 0);
gl.End();
gl.Color(OpenGlUtility.GetOpenGlColor(Color.Green));
gl.Begin(OpenGL.GL_LINES);
gl.Vertex(0, 0, 0);
gl.Vertex(0, 100, 0);
gl.End();
gl.Color(OpenGlUtility.GetOpenGlColor(Color.Blue));
gl.Begin(OpenGL.GL_LINES);
gl.Vertex(0, 0, 0);
gl.Vertex(0, 0, 100);
gl.End();
}
private void CreateDisplayList(OpenGL gl)
{
displayList = new DisplayList();
displayList.Generate(gl);
displayList.New(gl, DisplayList.DisplayListMode.CompileAndExecute);
//Push all attributes, disable lighting and depth testing.
gl.PushAttrib(OpenGL.GL_CURRENT_BIT | OpenGL.GL_ENABLE_BIT |
OpenGL.GL_LINE_BIT | OpenGL.GL_DEPTH_BUFFER_BIT);
gl.Disable(OpenGL.GL_LIGHTING);
gl.Disable(OpenGL.GL_TEXTURE_2D);
gl.DepthFunc(OpenGL.GL_ALWAYS);
//Set line width.
gl.LineWidth(lineWidth);
//Draw the line.
gl.Begin(OpenGL.GL_LINES);
for (float i = (size * -1); i < size; i+=0.4f)
{
float add = 0.2f;
if (i > 0) add = 0.4f;
if (i < 0 && i > -0.2f) add = 0.4f;
gl.Color(1f, 0f, 0f, 1f);
gl.Vertex(i, 0, 0);
gl.Vertex(i + add, 0, 0);
gl.Color(0f, 1f, 0f, 1f);
gl.Vertex(0, i, 0);
gl.Vertex(0, i + add, 0);
gl.Color(0f, 0f, 1f, 1f);
gl.Vertex(0, 0, i);
gl.Vertex(0, 0, i + add);
}
gl.End();
// Restore attributes.
gl.PopAttrib();
displayList.End(gl);
}
public static double ang2 = Math.PI / 6; //Угол поворота на 30 градусов
public static void DrawTree(SharpGL.OpenGL gl, Tree tree)
{
gl.Begin(OpenGL.GL_LINE_STRIP);
gl.Color(tree.Color.R, tree.Color.G, tree.Color.B);
foreach (var point in tree.Points)
{
TreeDraw((float)point.X, (float)point.Y, (float)point.X, (float)point.Y + (float)0.3, (float)120.0, 5, gl);
}
//gl.Vertex(point.X, point.Y);
//gl.End();
}
private void Bed(OpenGL gl, double x, double y, double z, double width, double height)
{
gl.Begin(OpenGL.GL_QUADS);
gl.Color(1f, 1f, 1f, 1f);
gl.Vertex(x, y + height, -6.0f);
gl.Vertex(x, y, -6.0f);
gl.Vertex(x + width, y, -6.0f);
gl.Vertex(x + width, y + height, -6.0f);
gl.End();
}
private void CreateDisplayList(OpenGL gl)
{
displayList = new DisplayList();
displayList.Generate(gl);
displayList.New(gl, DisplayList.DisplayListMode.CompileAndExecute);
//Push all attributes, disable lighting and depth testing.
gl.PushAttrib(OpenGL.GL_CURRENT_BIT | OpenGL.GL_ENABLE_BIT |
OpenGL.GL_LINE_BIT | OpenGL.GL_DEPTH_BUFFER_BIT);
gl.Disable(OpenGL.GL_LIGHTING);
gl.Disable(OpenGL.GL_TEXTURE_2D);
gl.DepthFunc(OpenGL.GL_ALWAYS);
//Set line width.
gl.LineWidth(lineWidth);
//Draw the line.
gl.Begin(OpenGL.GL_LINES);
for (int i = (size * -1); i <= size; i++)
{
if (i != 0)
{
if ((i % 4) == 0)
gl.Color(Convert.ColorToGLColor(darkColor));
else
gl.Color(Convert.ColorToGLColor(lightColor));
gl.Vertex(i, (size * -1), 0);
gl.Vertex(i, size, 0);
gl.Vertex((size * -1), i, 0);
gl.Vertex(size, i, 0);
}
}
gl.End();
// Restore attributes.
gl.PopAttrib();
displayList.End(gl);
}
private bool toClearPoly = false; // 多边形工具是否双击结束绘制的flag
public Painter(OpenGL glCanvas)
{
gl = glCanvas;
selectedTool = Tools.pointer;
pointQueue = new Queue <fPoint>();
gl.Color(0, 0, 0);
gl.LineWidth(2);
gl.PointSize(2);
//初始化坐标0, 0至左上角,Translate参数经尝试得到
gl.LoadIdentity();
gl.Translate(-4.68f, 4.11f, -10f);
buffers = new uint[100];
}
public override void Draw(SharpGL.OpenGL gl)
{
//Process alignment in baseclass
base.Draw(gl);
//Draw the color "squares" on screen - make bigger than the viewport
//so that alignment translation and rotation don't give edges
gl.Begin(OpenGL.GL_QUADS);
//first square - top left
gl.Color(ColorSquare1.R, ColorSquare1.G, ColorSquare1.B);
gl.Vertex(-15f, -15f);
gl.Vertex(-15f, 0f);
gl.Vertex(0f, 0f);
gl.Vertex(0f, -15f);
//second square - bottom left
gl.Color(ColorSquare2.R, ColorSquare2.G, ColorSquare2.B);
gl.Vertex(-15f, 0f);
gl.Vertex(-15f, 15f);
gl.Vertex(0f, 15f);
gl.Vertex(0f, 0f);
//third square - top right
gl.Color(ColorSquare3.R, ColorSquare3.G, ColorSquare3.B);
gl.Vertex(0f, -15f);
gl.Vertex(0f, 0f);
gl.Vertex(15f, 0f);
gl.Vertex(15f, -15f);
//fourth square - bottom right
gl.Color(ColorSquare4.R, ColorSquare4.G, ColorSquare4.B);
gl.Vertex(0f, 0f);
gl.Vertex(0f, 15f);
gl.Vertex(15f, 15f);
gl.Vertex(15f, 0f);
gl.End();
}
private void openGLControl_OpenGLDraw(object sender, OpenGLEventArgs e)
{
SharpGL.OpenGL gl = e.OpenGL;
gl.MatrixMode(SharpGL.OpenGL.GL_PROJECTION);
gl.LoadIdentity();
const float left = -5;
const float right = 5;
const float bottom = -5;
const float top = 5;
gl.Ortho2D(left, right, bottom, top);
gl.Color(1, 1, 1);
gl.Begin(SharpGL.OpenGL.GL_LINES);
gl.Vertex(0, bottom);
gl.Vertex(0, top);
gl.Vertex(left, 0);
gl.Vertex(right, 0);
gl.End();
gl.Color(0.0f, 0.0f, 1.0f);
gl.Begin(SharpGL.OpenGL.GL_LINE_STRIP);
for (var x = -4.0; x < 4; x += 0.1)
{
gl.Vertex(x, Math.Sin(x));
}
gl.Viewport(20, 20, 200, 200);
gl.End();
gl.Flush();
}
public override void Draw(SharpGL.OpenGL gl)
{
float[] curSize = new float[1];
gl.GetFloat(GetTarget.PointSize, curSize);
gl.PointSize(5);
gl.PushMatrix();
gl.Translate(position.x, position.y, position.z);
gl.Begin(BeginMode.Lines);
{
gl.Color(1.0f, 0.0f, 0.0f, 1f);
gl.Vertex(0.0f, 0.0f, 0.0f);
gl.Vertex(lens, 0.0f, 0.0f);
gl.Color(0.0f, 1.0f, 0.0f, 1f);
gl.Vertex(0.0f, 0.0f, 0.0f);
gl.Vertex(0.0f, lens, 0.0f);
gl.Color(0.0f, 0.0f, 1.0f, 1f);
gl.Vertex(0.0f, 0.0f, 0.0f);
gl.Vertex(0.0f, 0.0f, lens);
}
gl.End();
gl.PointSize(curSize[0]);
gl.PopMatrix();
}
private void drawMaze(OpenGL gl)
{
if (dataModel.MazeStructure.Origin != null)
{
// Draw a coloured pyramid.
gl.Begin(OpenGL.GL_TRIANGLES);
gl.Color(0.0f, 1.0f, 0.0f);
float x = dataModel.MazeStructure.Origin.Coordinates.X;
float y = dataModel.MazeStructure.Origin.Coordinates.Y;
float z = 1.0f;
gl.Vertex(x, y, z);
gl.DrawText(0, 0, 128.0f, 128.0f, 128.0f, "Arial", 12.0f, "Drawing maze");
/*
gl.Color(1.0f, 0.0f, 0.0f);
gl.Vertex(0.0f, 1.0f, 0.0f);
gl.Color(0.0f, 1.0f, 0.0f);
gl.Vertex(-1.0f, -1.0f, 1.0f);
gl.Color(0.0f, 0.0f, 1.0f);
gl.Vertex(1.0f, -1.0f, 1.0f);
gl.Color(1.0f, 0.0f, 0.0f);
gl.Vertex(0.0f, 1.0f, 0.0f);
gl.Color(0.0f, 0.0f, 1.0f);
gl.Vertex(1.0f, -1.0f, 1.0f);
gl.Color(0.0f, 1.0f, 0.0f);
gl.Vertex(1.0f, -1.0f, -1.0f);
gl.Color(1.0f, 0.0f, 0.0f);
gl.Vertex(0.0f, 1.0f, 0.0f);
gl.Color(0.0f, 1.0f, 0.0f);
gl.Vertex(1.0f, -1.0f, -1.0f);
gl.Color(0.0f, 0.0f, 1.0f);
gl.Vertex(-1.0f, -1.0f, -1.0f);
gl.Color(1.0f, 0.0f, 0.0f);
gl.Vertex(0.0f, 1.0f, 0.0f);
gl.Color(0.0f, 0.0f, 1.0f);
gl.Vertex(-1.0f, -1.0f, -1.0f);
gl.Color(0.0f, 1.0f, 0.0f);
gl.Vertex(-1.0f, -1.0f, 1.0f);
*/
gl.End();
}
if (dataModel != null)
gl.DrawText(0, 0, 128.0f, 128.0f, 128.0f, "Arial", 12.0f, dataModel.SolverAgentList.Count.ToString());
}
public override void Draw(SharpGL.OpenGL gl)
{
base.Draw(gl);
//approximate circle using a triangle fan
//the more triangles are drawn (the lower the degree step)
//the smoother the circle will be
float angleStep = (float)(2 * Math.PI / SegmentCount);
//All circles will be drawn concentric around the origin
//starting with the outermost circle (otherwise we would overpaint
//the inner circles)
// we draw the circles extending to a larger area than the viewport
float radiusMax = Math.Max(1.5f * ViewportHalfSizeX, 1.5f * ViewportHalfSizeY);
int nCircles = (int)(radiusMax / StripeWidth);
//prevent changes to our inner diameter while we draw
float innerDiam = _innerDiameter;
//loop over circles
for (int i = nCircles - 1; i >= 0; i--)
{
float Radius = i * StripeWidth + innerDiam;
if (Radius <= 0)//don't draw inner circles if they are currently collapsed into the center
{
break;
}
FColor Color;
if (i % 2 == 0)
{
Color = ColorStripe1;
}
else
{
Color = ColorStripe2;
}
gl.Begin(BeginMode.TriangleFan);
for (float angle = 0; angle <= (float)(2 * Math.PI); angle += angleStep)
{
gl.Color(Color.R, Color.G, Color.B);
gl.Vertex(Math.Sin(angle) * Radius, Math.Cos(angle) * Radius);
}
gl.End();
}
}
public void ResetOpenGL(SharpGL.OpenGL gl, int width, int height)
{
gl.Viewport(0, 0, width, height);
gl.Color(1.0, 1.0, 1.0, 1.0); // reset gl color
gl.MatrixMode(MatrixMode.Projection);
gl.LoadIdentity();
gl.Ortho(0, width, height, 0, -10, 10);
gl.MatrixMode(MatrixMode.Modelview);
gl.Clear(OpenGL.GL_COLOR_BUFFER_BIT | OpenGL.GL_DEPTH_BUFFER_BIT);
gl.LoadIdentity();
}
public void DrawGrid(OpenGL gl, int camX,int camY)
{
gl.Clear(OpenGL.GL_COLOR_BUFFER_BIT | OpenGL.GL_DEPTH_BUFFER_BIT);
gl.LoadIdentity();
int MapHeight = tileMap.mapHeight;
int MapWidth = tileMap.mapWidth;
float[] darkColor = { 0.2f, 0.2f, 0.2f };
float[] lightColor = { 0.25f, 0.25f, 0.25f };
for (int h = 0; h < MapHeight; h++)
{
if (h % 10 == 0)
{
gl.LineWidth(2.0f);
gl.Color(lightColor);
}
else
{
gl.LineWidth(1.0f);
gl.Color(darkColor);
}
if (h == 0)
{
gl.LineWidth(4.0f);
gl.Color(lightColor);
}
gl.Begin(OpenGL.GL_LINES); // Start Drawing Verticle Cell Borders
gl.Vertex(0 - camX, h * tileSize - camY, 0);// Left Side Of Horizontal Line
gl.Vertex((MapWidth * tileSize) - camX, (h * tileSize) - camY, 0);// Right Side Of Horizontal Line
gl.End();
}
for (int v = 0; v < MapWidth; v++)
{
if (v % 10 == 0)
{
gl.LineWidth(2.0f);
gl.Color(lightColor);
}
else
{
gl.LineWidth(1.0f);
gl.Color(darkColor);
}
if (v == 0)
{
gl.LineWidth(4.0f);
gl.Color(lightColor);
}
gl.Begin(OpenGL.GL_LINES); // Start Drawing Verticle Cell Borders
gl.Vertex(v * tileSize - camX, 0 - camY, 0);// Left Side Of Horizontal Line
gl.Vertex((v * tileSize) - camX, (MapHeight * tileSize) - camY, 0);// Right Side Of Horizontal Line
gl.End();
}
}
public override void Draw(OpenGL gl)
{
PointFloat _size = GetSize();
PointFloat[] pointData = RenderLogics.RectPoint(GetPosition(), _size, GetRotation());
byte[] color = GetColor();
GetTexture().UseTexure(gl);
gl.Begin(OpenGL.GL_QUADS);
gl.Color(color[0], color[1], color[2]);
gl.TexCoord(0, 0);
gl.Vertex(pointData[1].x, pointData[1].y);
gl.TexCoord(0, 1);
gl.Vertex(pointData[0].x, pointData[0].y);
gl.TexCoord(1, 1);
gl.Vertex(pointData[3].x, pointData[3].y);
gl.TexCoord(1, 0);
gl.Vertex(pointData[2].x, pointData[2].y);
gl.End();
}
//以下是二维平面的处理
private void triangle(OpenGL gl, double x1, double y1, double x2, double y2, double x3, double y3)
{
gl.PolygonMode(OpenGL.GL_FRONT_AND_BACK, OpenGL.GL_LINE);
gl.Begin(OpenGL.GL_TRIANGLES);
gl.Color(0f, 0f, 0f);
gl.Vertex(x1, y1, 0);
gl.Vertex(x2, y2, 0);
gl.Vertex(x3, y3, 0);
gl.End();
}
void drawFunction(OpenGL gl, FunctionAppearance app)
{
gl.LineWidth(app.lineWidth);
double aInPaintCoords = centerCoordinateX + app.a / unitsProPixel;
double bInPaintCoords = centerCoordinateX + app.b / unitsProPixel;
double a = 0;
double b = 0;
if (aInPaintCoords<=x+width)
{
if (bInPaintCoords >= x)
{
if (aInPaintCoords >= x)
{
a = app.a;
}
else
{
a = (x-centerCoordinateX) * unitsProPixel;
}
if (bInPaintCoords <= x + width)
{
b = app.b;
}
else
{
b = (x + width - centerCoordinateX) * unitsProPixel;
}
gl.Begin(OpenGL.GL_LINE_STRIP);
double xInFunctionCoords = a;
double xInPaintCoords = Math.Max(aInPaintCoords, x);
gl.Color((float)(app.color >> 16 & 0xff) / 255, (float)(app.color >> 8 & 0xff) / 255, (float)(app.color & 0xff) / 255);
while (xInFunctionCoords <= b)
{
double yInPaintCoords = centerCoordinateY + app.func(xInFunctionCoords) / unitsProPixel;
if (yInPaintCoords >= y && yInPaintCoords <= y + height)
{
gl.Vertex(xInPaintCoords, yInPaintCoords, 0);
}
else
{
gl.End();
gl.Begin(OpenGL.GL_LINE_STRIP);
}
xInFunctionCoords += unitsProPixel;
xInPaintCoords++;
}
gl.End();
}
}
}
public override void Draw(ref OpenGL gl)
{
if (!TexturesInitialised)
{
InitializeTexture(ref gl);
}
// Clear the color and depth buffer.
gl.Clear(OpenGL.GL_COLOR_BUFFER_BIT | OpenGL.GL_DEPTH_BUFFER_BIT);
// Load the identity matrix.
gl.LoadIdentity();
gl.Enable(OpenGL.GL_TEXTURE_2D);
gl.Enable(OpenGL.GL_LIGHTING);
gl.Enable(OpenGL.GL_LIGHT0);
gl.Enable(OpenGL.GL_DEPTH_TEST);
gl.Enable(OpenGL.GL_NORMALIZE);
gl.BindTexture(OpenGL.GL_TEXTURE_2D, gtexture[0]);
gl.Color(1.0f, 1.0f, 1.0f, 0.1f);
gl.Begin(OpenGL.GL_QUADS);
gl.FrontFace(OpenGL.GL_FRONT_FACE);
gl.TexCoord(1.0f, 1.0f);
gl.Vertex(gImage1.Width, gImage1.Height, 1.0f);
gl.TexCoord(0.0f, 1.0f);
gl.Vertex(0.0f, gImage1.Height, 1.0f);
gl.TexCoord(0.0f, 0.0f);
gl.Vertex(0.0f, 0.0f, 1.0f);
gl.TexCoord(1.0f, 0.0f);
gl.Vertex(gImage1.Width, 0.0f, 1.0f);
gl.End();
gl.Disable(OpenGL.GL_TEXTURE_2D);
gl.MatrixMode(OpenGL.GL_PROJECTION);
gl.LoadIdentity();
gl.Ortho(0.0, (double)gImage1.Width, (double)gImage1.Height, 0.0, -1.0, 1.0);
gl.MatrixMode(OpenGL.GL_MODELVIEW);
gl.Disable(OpenGL.GL_DEPTH_TEST);
}
//上色四边形
private void quadrangle(OpenGL gl, double x1, double y1, double z1, double x2, double y2, double z2, double x3, double y3, double z3, double x4, double y4, double z4, int n)
{
gl.PolygonMode(OpenGL.GL_FRONT, OpenGL.GL_FILL);
gl.Begin(OpenGL.GL_QUADS);
gl.Color(ColorR[n], ColorG[n], ColorB[n]);
gl.Vertex(x1, y1, z1);
gl.Vertex(x2, y2, z2);
gl.Vertex(x3, y3, z3);
gl.Vertex(x4, y4, z4);
gl.End();
// info.AppendText(n.ToString() + "\r\n");
}
public static void DrawOperation(OpenGL gl, Project testProject, Vector rotation, List<List<double[]>> detailCache)
{
var bill = testProject.Settings;
gl.Translate(bill.Length / 2, bill.Height / 2, bill.Width / 2);//высчитывается из размера заготовки
gl.Rotate((float)rotation.Y, (float)rotation.X, 0); // вращение с зажатой средней кнопкой мыши
gl.Translate(-bill.Length / 2, -bill.Height / 2, -bill.Width / 2);
//var Bill = this.testProject.Settings;
Billet.Draw(gl, bill.Height, bill.Length, bill.Width); // заготовка
var operations = testProject.Operations;//колличество операций
var boltReg = new Regex("BoltHole");
var pocketReg = new Regex("Pocket");
if (detailCache.Count != operations.Count) detailCache.Clear();
for (var i = 0; i < operations.Count; i++)//главный цикл отрисовки
{
var shapeName = operations[i].Shape.Name;
if (boltReg.IsMatch(shapeName))
{
var bolt = (Model.Primitives.BoltHole)operations[i].Shape;
var boltlocation = operations[i].Location.LocationsList.GetEnumerator();
while (boltlocation.MoveNext())
{
if (bolt.Modified || boltlocation.Current.Modified || detailCache.Count<=i)
{
try
{
detailCache.RemoveAt(i);
}
catch{}
var location = new Point(boltlocation.Current.X, boltlocation.Current.Y);
detailCache.Insert(i, BoltHole.ReCalc(bolt, 0.5, location)); //здесь уже всё ок, кроме величины шага
boltlocation.Current.IsDrawn();
bolt.IsDrawn();//значит в кэше лежит актуальная информация
}
else
{
var location = new Point(boltlocation.Current.X, boltlocation.Current.Y);
BoltHole.Draw(gl, detailCache[i]); //здесь уже всё ок, кроме величины шага
}
}
}
if (!pocketReg.IsMatch(shapeName)) continue;
var poc = (Model.Primitives.Pocket)operations[i].Shape;
var poclocation = operations[i].Location.LocationsList.GetEnumerator();
while (poclocation.MoveNext())
{
if (poc.Modified || poclocation.Current.Modified || detailCache.Count <= i)
{
try
{
detailCache.RemoveAt(i);
}
catch { }
var location = new Point(poclocation.Current.X, poclocation.Current.Y);
var p = Pocket.ReCalc(poc, 0.5, location);
detailCache.Insert(i, p); //здесь уже всё ок, кроме величины шага
poclocation.Current.IsDrawn();
poc.IsDrawn();//значит в кэше лежит актуальная информация
}
else
{
var location = new Point(poclocation.Current.X, poclocation.Current.Y);
Pocket.Draw(gl, detailCache[i]); //здесь уже всё ок, кроме величины шага
}
}
}
//отрисовщик траекторий
gl.Begin(OpenGL.GL_LINE_STRIP);
gl.Color(1f, 0, 0);
var trajectorys = GCodeGenerator.TrajectoryStor.GetTrajectorys();
foreach (var point in trajectorys.SelectMany(operation => operation))
{
gl.Vertex(point.GetCoordinates());
}
}
private void quadrangle(OpenGL gl, double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
{
gl.PolygonMode(OpenGL.GL_FRONT_AND_BACK, OpenGL.GL_LINE);
gl.Begin(OpenGL.GL_QUADS);
gl.Color(0f, 0f, 0f);
gl.Vertex(x1, y1, 0);
gl.Vertex(x2, y2, 0);
gl.Vertex(x3, y3, 0);
gl.Vertex(x4, y4, 0);
gl.End();
}
/// <summary>
/// Draw a mesh.
/// </summary>
/// <param name="gl">OpenGL handler.</param>
/// <param name="buildingObj">The mesh.</param>BuildingObjectLib3DS _object,
private void DrawMesh(OpenGL gl, Lib3dsMesh thisMesh, Hashtable textures, List<Lib3dsMaterial> matrials, DrawType type)
{
if (thisMesh == null || thisMesh.nfaces == 0)
return;
// Draw all the faces in this mesh.
for (int j = 0; j < thisMesh.faces.Count; j++)
{
Lib3dsFace thisFace = thisMesh.faces[j];
float transparency = matrials[thisFace.material].transparency;
//float[] fogColor = new float[4] { 0.5f, 0.5f, 0.5f, 1.0f };
//float[] LightAmbient = new float[4] { 0.5f, 0.5f, 0.5f, 1.0f };
//float[] LightDiffuse = new float[4] { 1.0f, 1.0f, 1.0f, 1.0f };
//float[] LightPosition = new float[4] { 0.0f, 0.0f, 2.0f, 1.0f };
switch (type)
{
case DrawType.WireFrame:
gl.PolygonMode(OpenGL.GL_FRONT_AND_BACK, OpenGL.GL_LINE);
IsDrawTexture = false;
gl.Color(0.5f, 0.5f, 0.5f, 0.5f);
gl.LineWidth(1.5f);
break;
case DrawType.Full:
IsDrawTexture = BindTexture(gl, textures, matrials[thisFace.material].name);
gl.PolygonMode(OpenGL.GL_FRONT_AND_BACK, OpenGL.GL_FILL);
break;
case DrawType.Face:
gl.PolygonMode(OpenGL.GL_FRONT_AND_BACK, OpenGL.GL_FILL);
IsDrawTexture = false;
break;
case DrawType.Translucent:
IsDrawTexture = BindTexture(gl, textures, matrials[thisFace.material].name);
gl.PolygonMode(OpenGL.GL_FRONT_AND_BACK, OpenGL.GL_FILL);
gl.Enable(OpenGL.GL_BLEND);
gl.BlendFunc(OpenGL.GL_SRC_ALPHA,OpenGL.GL_ONE_MINUS_SRC_ALPHA);
//gl.Enable(OpenGL.GL_TEXTURE_2D); // Enable Texture Mapping
//gl.ShadeModel(OpenGL.GL_SMOOTH); // Enable Smooth Shading
//gl.ClearColor(0.5f,0.5f,0.5f,1.0f); // We'll Clear To The Color Of The Fog
//gl.ClearDepth(1.0f); // Depth Buffer Setup
//gl.Enable(OpenGL.GL_DEPTH_TEST); // Enables Depth Testing
//gl.DepthFunc(OpenGL.GL_LEQUAL); // The Type Of Depth Testing To Do
//gl.Hint(OpenGL.GL_PERSPECTIVE_CORRECTION_HINT, OpenGL.GL_NICEST); // Really Nice Perspective Calculations
//gl.Light(OpenGL.GL_LIGHT1, OpenGL.GL_AMBIENT, LightAmbient); // Setup The Ambient Light
//gl.Light(OpenGL.GL_LIGHT1, OpenGL.GL_DIFFUSE, LightDiffuse); // Setup The Diffuse Light
//gl.Light(OpenGL.GL_LIGHT1, OpenGL.GL_POSITION,LightPosition); // Position The Light
//gl.Enable(OpenGL.GL_LIGHT1);
//gl.Fog(OpenGL.GL_FOG_COLOR, fogColor);//设置雾颜色，f是一个指定颜色的数组float f[4]
//gl.Fog(OpenGL.GL_FOG_DENSITY, 0.85f); // 设置雾的密度
//gl.Hint(OpenGL.GL_FOG_HINT, OpenGL.GL_DONT_CARE); // 设置系统如何计算雾气
//gl.Fog(OpenGL.GL_FOG_START, 0.01f);//设置雾从多远开始
//gl.Fog(OpenGL.GL_FOG_END, 100.0f);//设置雾从多远结束
//gl.Fog(OpenGL.GL_FOG_MODE, OpenGL.GL_LINEAR);//设置使用哪种雾，共有三中雾化模式
//gl.Enable(OpenGL.GL_FOG);//打开雾效果
transparency = 0.2f;
break;
default:
gl.PolygonMode(OpenGL.GL_FRONT_AND_BACK, OpenGL.GL_FILL);
IsDrawTexture = false;
break;
}
if (type != DrawType.WireFrame)
{
gl.Color(matrials[thisFace.material].diffuse[0], matrials[thisFace.material].diffuse[1],
matrials[thisFace.material].diffuse[2], matrials[thisFace.material].transparency);
}
gl.Begin(OpenGL.GL_TRIANGLES);
for (int k = 0; k != 3; ++k)
{
int index = thisFace.index[k];
if (IsDrawTexture)
gl.TexCoord(thisMesh.texcos[index].s, thisMesh.texcos[index].t);
gl.Vertex(thisMesh.vertices[index].x / 20, thisMesh.vertices[index].z / 20, -thisMesh.vertices[index].y / 20);
}
gl.End();
if(type == DrawType.Translucent)
gl.Disable(OpenGL.GL_BLEND);
}
}
/// <summary>
/// Sets the background color, using a gradient existing from 2 colors
/// </summary>
/// <param name="gl"></param>
private static void SetVerticalGradientBackground(OpenGL gl, ColorF colorTop, ColorF colorBot)
{
float topRed = colorTop.R;// / 255.0f;
float topGreen = colorTop.G;// / 255.0f;
float topBlue = colorTop.B;// / 255.0f;
float botRed = colorBot.R;// / 255.0f;
float botGreen = colorBot.G;// / 255.0f;
float botBlue = colorBot.B;// / 255.0f;
gl.Begin(OpenGL.GL_QUADS);
//bottom color
gl.Color(botRed, botGreen, botBlue);
gl.Vertex(-1.0, -1.0);
gl.Vertex(1.0, -1.0);
//top color
gl.Color(topRed, topGreen, topBlue);
gl.Vertex(1.0, 1.0);
gl.Vertex(-1.0, 1.0);
gl.End();
}
/// <summary>
/// This is called when a face is interactable, so highlight it.
/// </summary>
void IInteractable.DrawPick(OpenGL gl)
{
// Save all the attributes.
gl.PushAttrib(OpenGL.ALL_ATTRIB_BITS);
// Disable lighting, set colour to red etc.
gl.Disable(OpenGL.LIGHTING);
gl.DepthFunc(OpenGL.LEQUAL);
// Now draw it with a faint red.
gl.Enable(OpenGL.BLEND);
gl.BlendFunc(OpenGL.SRC_ALPHA, OpenGL.ONE_MINUS_SRC_ALPHA);
gl.Color(1, 0, 0, 0.2f);
// Draw the face.
gl.Begin(OpenGL.POLYGON);
foreach(Index index in indices)
gl.Vertex(parentpoly.Vertices[index.Vertex]);
gl.End();
gl.Disable(OpenGL.BLEND);
// Draw the face.
gl.Begin(OpenGL.LINE_LOOP);
for(int i = 0; i < indices.Count - 1; i++)
gl.Vertex(parentpoly.Vertices[indices[i].Vertex]);
gl.End();
gl.PopAttrib();
}
private void quadrangle(OpenGL gl, double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4, int n)
{
gl.PolygonMode(OpenGL.GL_FRONT, OpenGL.GL_FILL);
gl.Begin(OpenGL.GL_QUADS);
gl.Color(ColorR[n], ColorG[n], ColorB[n]);
gl.Vertex(x1, y1, 0);
gl.Vertex(x2, y2, 0);
gl.Vertex(x3, y3, 0);
gl.Vertex(x4, y4, 0);
gl.End();
}
/// <summary>
/// Use this to draw the vertex grid.
/// </summary>
/// <param name="gl">OpenGL object.</param>
/// <param name="points">Draw each individual vertex (with selection names).</param>
/// <param name="lines">Draw the lines connecting the points.</param>
public virtual void Draw(OpenGL gl, bool points, bool lines)
{
// Save the attributes.
gl.PushAttrib(OpenGL.ALL_ATTRIB_BITS);
gl.Disable(OpenGL.LIGHTING);
gl.Color(1, 0, 0, 1);
if(points)
{
int name = 0;
gl.PointSize(5);
// Add a new name (the vertex name).
gl.PushName(0);
foreach(Vertex v in vertices)
{
// Set the name, draw the vertex.
gl.LoadName((uint)name++);
((IInteractable)v).DrawPick(gl);
}
// Pop the name.
gl.PopName();
}
if(lines)
{
// Draw lines along each row, then along each column.
gl.DepthFunc(OpenGL.ALWAYS);
gl.LineWidth(1);
gl.Disable(OpenGL.LINE_SMOOTH);
for(int col=0; col < y; col++)
{
for(int row=0; row < x; row++)
{
// Create vertex indicies.
int nTopLeft = (col * x) + row;
int nBottomLeft = ((col + 1) * x) + row;
gl.Begin(OpenGL.LINES);
if(row < (x-1))
{
gl.Vertex(vertices[nTopLeft]);
gl.Vertex(vertices[nTopLeft + 1]);
}
if(col < (y-1))
{
gl.Vertex(vertices[nTopLeft]);
gl.Vertex(vertices[nBottomLeft]);
}
gl.End();
}
}
gl.DepthFunc(OpenGL.LESS);
}
gl.PopAttrib();
}
private void triangle(OpenGL gl, double x1, double y1, double x2, double y2, double x3, double y3, int n)
{
gl.PolygonMode(OpenGL.GL_FRONT, OpenGL.GL_FILL);
gl.Begin(OpenGL.GL_TRIANGLES);
gl.Color(ColorR[n], ColorG[n], ColorB[n]);
gl.Vertex(x1, y1, 0);
gl.Vertex(x2, y2, 0);
gl.Vertex(x3, y3, 0);
gl.End();
}
public void DrawSprite(float posX, float posY, Sprite sprite, OpenGL gl)
{
float[] verts = {
posX, posY,
posX + 32, posY,
posX + 32, posY + 32,
posX, posY + 32
};
float tw = sprite.spriteWidth;
float th = sprite.spriteHeight;
float tx = sprite.spriteX;
float ty = sprite.spriteY;
float[] texVerts = {
tx, ty,
tx + tw, ty,
tx + tw, ty + th,
tx, ty + th
};
gl.Color(1.0, 1.0, 1.0, 1.0); // reset gl color
tex.Bind(gl);
gl.Begin(OpenGL.GL_QUADS);
gl.TexCoord(texVerts[0], texVerts[1]); gl.Vertex(verts[0], verts[1], 0.0f); // Bottom Left Of The Texture and Quad
gl.TexCoord(texVerts[2], texVerts[3]); gl.Vertex(verts[2], verts[3], 0.0f); // Bottom Right Of The Texture and Quad
gl.TexCoord(texVerts[4], texVerts[5]); gl.Vertex(verts[4], verts[5], 0.0f); // Top Right Of The Texture and Quad
gl.TexCoord(texVerts[6], texVerts[7]); gl.Vertex(verts[6], verts[7], 0.0f); // Top Left Of The Texture and Quad
gl.End();
//this is sposed to be better but doesnt seem to work
//gl.VertexPointer(2, OpenGL.GL_FLOAT, 0, verts);
//gl.TexCoordPointer(2, OpenGL.GL_FLOAT, 0, texVerts);
//gl.DrawArrays(OpenGL.GL_TRIANGLE_STRIP,0,4);
}
public void DrawCircle(OpenGL gl, float x, float y, float s)
{
gl.Begin(OpenGL.GL_LINES);
gl.Color(1f, 1f, 1f);
float xp, yp;
float max = (float)(Math.PI * 2);
for (float i = 0f; i < max; i = i + 0.5f)
{
xp = x + ((float)Math.Cos(i) * s);
yp = y + ((float)Math.Sin(i) * s);
gl.Vertex(xp,yp);
xp = x + ( (float)Math.Cos(i+0.5f) * s );
yp = y + ( (float)Math.Sin(i+0.5f) * s );
gl.Vertex(xp, yp);
}
gl.Vertex(x, y);
gl.End();
}
private void SampleRendering(OpenGL gl, float rX, float rY, float rZ)
{
gl.Clear(OpenGL.GL_COLOR_BUFFER_BIT | OpenGL.GL_DEPTH_BUFFER_BIT); // Clear The Screen And The Depth Buffer
gl.LoadIdentity(); // Reset The View
gl.Translate(-1.5f, 0.0f, -6.0f); // Move Left And Into The Screen
gl.Rotate(rtri, rX, rY, rZ); // Rotate The Pyramid On It's Y Axis
gl.Begin(OpenGL.GL_TRIANGLES); // Start Drawing The Pyramid
gl.Color(1.0f, 0.0f, 0.0f); // Red
gl.Vertex(0.0f, 1.0f, 0.0f); // Top Of Triangle (Front)
gl.Color(0.0f, 1.0f, 0.0f); // Green
gl.Vertex(-1.0f, -1.0f, 1.0f); // Left Of Triangle (Front)
gl.Color(0.0f, 0.0f, 1.0f); // Blue
gl.Vertex(1.0f, -1.0f, 1.0f); // Right Of Triangle (Front)
gl.Color(1.0f, 0.0f, 0.0f); // Red
gl.Vertex(0.0f, 1.0f, 0.0f); // Top Of Triangle (Right)
gl.Color(0.0f, 0.0f, 1.0f); // Blue
gl.Vertex(1.0f, -1.0f, 1.0f); // Left Of Triangle (Right)
gl.Color(0.0f, 1.0f, 0.0f); // Green
gl.Vertex(1.0f, -1.0f, -1.0f); // Right Of Triangle (Right)
gl.Color(1.0f, 0.0f, 0.0f); // Red
gl.Vertex(0.0f, 1.0f, 0.0f); // Top Of Triangle (Back)
gl.Color(0.0f, 1.0f, 0.0f); // Green
gl.Vertex(1.0f, -1.0f, -1.0f); // Left Of Triangle (Back)
gl.Color(0.0f, 0.0f, 1.0f); // Blue
gl.Vertex(-1.0f, -1.0f, -1.0f); // Right Of Triangle (Back)
gl.Color(1.0f, 0.0f, 0.0f); // Red
gl.Vertex(0.0f, 1.0f, 0.0f); // Top Of Triangle (Left)
gl.Color(0.0f, 0.0f, 1.0f); // Blue
gl.Vertex(-1.0f, -1.0f, -1.0f); // Left Of Triangle (Left)
gl.Color(0.0f, 1.0f, 0.0f); // Green
gl.Vertex(-1.0f, -1.0f, 1.0f); // Right Of Triangle (Left)
gl.End(); // Done Drawing The Pyramid
gl.LoadIdentity();
gl.Translate(1.5f, 0.0f, -7.0f); // Move Right And Into The Screen
gl.Rotate(rquad, rX, rY, rZ); // Rotate The Cube On X, Y & Z
gl.Begin(OpenGL.GL_QUADS); // Start Drawing The Cube
gl.Color(0.0f, 1.0f, 0.0f); // Set The Color To Green
gl.Vertex(1.0f, 1.0f, -1.0f); // Top Right Of The Quad (Top)
gl.Vertex(-1.0f, 1.0f, -1.0f); // Top Left Of The Quad (Top)
gl.Vertex(-1.0f, 1.0f, 1.0f); // Bottom Left Of The Quad (Top)
gl.Vertex(1.0f, 1.0f, 1.0f); // Bottom Right Of The Quad (Top)
gl.Color(1.0f, 0.5f, 0.0f); // Set The Color To Orange
gl.Vertex(1.0f, -1.0f, 1.0f); // Top Right Of The Quad (Bottom)
gl.Vertex(-1.0f, -1.0f, 1.0f); // Top Left Of The Quad (Bottom)
gl.Vertex(-1.0f, -1.0f, -1.0f); // Bottom Left Of The Quad (Bottom)
gl.Vertex(1.0f, -1.0f, -1.0f); // Bottom Right Of The Quad (Bottom)
gl.Color(1.0f, 0.0f, 0.0f); // Set The Color To Red
gl.Vertex(1.0f, 1.0f, 1.0f); // Top Right Of The Quad (Front)
gl.Vertex(-1.0f, 1.0f, 1.0f); // Top Left Of The Quad (Front)
gl.Vertex(-1.0f, -1.0f, 1.0f); // Bottom Left Of The Quad (Front)
gl.Vertex(1.0f, -1.0f, 1.0f); // Bottom Right Of The Quad (Front)
gl.Color(1.0f, 1.0f, 0.0f); // Set The Color To Yellow
gl.Vertex(1.0f, -1.0f, -1.0f); // Bottom Left Of The Quad (Back)
gl.Vertex(-1.0f, -1.0f, -1.0f); // Bottom Right Of The Quad (Back)
gl.Vertex(-1.0f, 1.0f, -1.0f); // Top Right Of The Quad (Back)
gl.Vertex(1.0f, 1.0f, -1.0f); // Top Left Of The Quad (Back)
gl.Color(0.0f, 0.0f, 1.0f); // Set The Color To Blue
gl.Vertex(-1.0f, 1.0f, 1.0f); // Top Right Of The Quad (Left)
gl.Vertex(-1.0f, 1.0f, -1.0f); // Top Left Of The Quad (Left)
gl.Vertex(-1.0f, -1.0f, -1.0f); // Bottom Left Of The Quad (Left)
gl.Vertex(-1.0f, -1.0f, 1.0f); // Bottom Right Of The Quad (Left)
gl.Color(1.0f, 0.0f, 1.0f); // Set The Color To Violet
gl.Vertex(1.0f, 1.0f, -1.0f); // Top Right Of The Quad (Right)
gl.Vertex(1.0f, 1.0f, 1.0f); // Top Left Of The Quad (Right)
gl.Vertex(1.0f, -1.0f, 1.0f); // Bottom Left Of The Quad (Right)
gl.Vertex(1.0f, -1.0f, -1.0f); // Bottom Right Of The Quad (Right)
gl.End(); // Done Drawing The Q
gl.Flush();
rtri += 1.0f;// 0.2f; // Increase The Rotation Variable For The Triangle
rquad -= 1.0f;// 0.15f; // Decrease The Rotation Variable For The Quad
}
void CreateAndDrawGrid(OpenGL GL)
{
// Debug.WriteLine("Painting Begins..");
// Create vertices for 4 lines that will split the figure into 3 equal sections
xgrid = new vec3[(C_NUM_Y_DIV + 1) * 2];
for (int i = 0; i < (C_NUM_Y_DIV + 1) * 2; i = i + 2)
{
xgrid[i].x = -1f; xgrid[i + 1].x = 1f;
xgrid[i].y = C_X_MARGIN_MIN + C_Y_STEP * i / 2; xgrid[i + 1].y = C_X_MARGIN_MIN + C_Y_STEP * i / 2;
xgrid[i].z = 0f; xgrid[i + 1].z = 0f;
}
coldata = new vec3[] {
GL.Color(DR.Color.White),
GL.Color(DR.Color.White),
GL.Color(DR.Color.White),
GL.Color(DR.Color.White),
GL.Color(DR.Color.White),
GL.Color(DR.Color.White),
GL.Color(DR.Color.White),
GL.Color(DR.Color.White),
GL.Color(DR.Color.White),
GL.Color(DR.Color.White),
GL.Color(DR.Color.White),
GL.Color(DR.Color.White),
GL.Color(DR.Color.White),
GL.Color(DR.Color.White),
GL.Color(DR.Color.White),
GL.Color(DR.Color.White)
};
mviewdata = new mat4(1.0f);
// --------------- Implementation WITH VERTEX ARRAY OBJECTS --------------------
//// Create the vertex array object.
vertexBufferArray = new VertexBufferArray();
vertexBufferArray.Create(GL);
vertexBufferArray.Bind(GL);
// Create a vertex buffer for the vertex data.
var vertexDataBuffer = new VertexBuffer();
vertexDataBuffer.Create(GL);
vertexDataBuffer.Bind(GL);
vertexDataBuffer.SetData(GL, attribute_vpos, xgrid, false, 3);
// Now do the same for the colour data.
var colourDataBuffer = new VertexBuffer();
colourDataBuffer.Create(GL);
colourDataBuffer.Bind(GL);
colourDataBuffer.SetData(GL, attribute_vcol, coldata, false, 3);
// Unbind the vertex array, we've finished specifying data for it.
vertexBufferArray.Unbind(GL);
// Bind the shader, set the matrices.
shaderProgram.Bind(GL);
//shaderProgram.SetUniformMatrix4(gl, "projectionMatrix", projectionMatrix.to_array());
//shaderProgram.SetUniformMatrix4(gl, "viewMatrix", viewMatrix.to_array());
shaderProgram.SetUniformMatrix4(GL, "modelview", mviewdata.to_array());
// Bind the out vertex array.
vertexBufferArray.Bind(GL);
GL.DrawArrays(OpenGL.GL_LINES, 0, 8);
// Unbind our vertex array and shader.
vertexBufferArray.Unbind(GL);
shaderProgram.Unbind(GL);
// --------------- Implementation WITH VERTEX ARRAY OBJECTS END --------------------
}
