private void DrawBegin(RectangleF dstRect)
{
GL.Enable(EnableCap.AlphaTest);
GL.Disable(EnableCap.DepthTest);
GL.Color4(Color);
GL.Viewport(0, 0, Width, Height);
GL.MatrixMode(MatrixMode.Projection);
GL.LoadIdentity();
var w = MMW.Width;
var h = MMW.Height;
GL.Ortho(0, w, h, 0, -1, 1);
GL.MatrixMode(MatrixMode.Modelview);
GL.LoadIdentity();
var trans = new Vector3(dstRect.X + dstRect.Width * CenterPivot.X, dstRect.Y + dstRect.Height * CenterPivot.Y, 0.0f);
GL.Translate(trans);
GL.Scale(Scale.X, Scale.Y, 1.0f);
GL.Rotate(Rotate.Z, 0.0f, 0.0f, 1.0f);
GL.Rotate(Rotate.X, 1.0f, 0.0f, 0.0f);
GL.Rotate(Rotate.Y, 0.0f, 1.0f, 0.0f);
GL.Translate(-trans);
GL.Translate(dstRect.X - 0.5f, dstRect.Y - 0.5f, 0.0f);
}
public void DrawRect(SColorF color, SRectF rect, bool allMonitors = true)
{
int loops = 1;
if (allMonitors)
{
loops = CConfig.Config.Graphics.NumScreens;
}
for (int i = 0; i < loops; i++)
{
SRectF newrect = rect;
newrect.X += CSettings.RenderW * i;
GL.Enable(EnableCap.Blend);
GL.Color4(color.R, color.G, color.B, color.A * CGraphics.GlobalAlpha);
GL.Begin(PrimitiveType.Quads);
GL.MatrixMode(MatrixMode.Color);
GL.PushMatrix();
if (Math.Abs(newrect.Rotation) > 0.001)
{
GL.Translate(0.5f, 0.5f, 0);
GL.Rotate(-newrect.Rotation, 0f, 0f, 1f);
GL.Translate(-0.5f, -0.5f, 0);
}
GL.Vertex3(newrect.X, newrect.Y, newrect.Z + CGraphics.ZOffset);
GL.Vertex3(newrect.X, newrect.Y + newrect.H, newrect.Z + CGraphics.ZOffset);
GL.Vertex3(newrect.X + newrect.W, newrect.Y + newrect.H, newrect.Z + CGraphics.ZOffset);
GL.Vertex3(newrect.X + newrect.W, newrect.Y, newrect.Z + CGraphics.ZOffset);
GL.End();
GL.PopMatrix();
GL.Disable(EnableCap.Blend);
}
}
private void MusicCirsle(double x, double y, double begin, double end)
{
for (int j = 0; j < 5; j++)
{
GL.Begin(PrimitiveType.TriangleFan);
GL.Color4(firstColorSpectr.R, firstColorSpectr.G, firstColorSpectr.B, 0.8);
if (j == 0)
{
spectrRadius[j] += _FFTSpectr[j] * glControl1.Width / 3;
}
else
{
spectrRadius[j] += _FFTSpectr[j] * glControl1.Width / Math.Sqrt(j + 10) + spectrRadius[j - 1];
}
spectrRadius[j] /= 2;
GL.Vertex3(x, y, (double)(1 - 0.1));
for (double i = begin; i < end; i += 0.05)
{
GL.Color4(secondColorSpectr[j].R, secondColorSpectr[j].G, secondColorSpectr[j].B, 0.8);
GL.Vertex3(spectrRadius[j] * Math.Cos(i) + x,
spectrRadius[j] * Math.Sin(i) + y, (double)(1 - 0.1));
GL.Vertex3(spectrRadius[j] * Math.Cos(i + 0.01) + x,
spectrRadius[j] * Math.Sin(i + 0.01) + y, (double)(1 - 0.1));
}
GL.End();
}
}
public void DrawRectReflection(SColorF color, SRectF rect, float space, float height)
{
if (rect.H < height)
{
height = rect.H;
}
float rx1 = rect.X;
float rx2 = rect.X + rect.W;
float ry1 = rect.Y + rect.H + space;
float ry2 = rect.Y + rect.H + space + height;
if (rx1 < rect.X)
{
rx1 = rect.X;
}
if (rx2 > rect.X + rect.W)
{
rx2 = rect.X + rect.W;
}
if (ry1 < rect.Y + space)
{
ry1 = rect.Y + space;
}
if (ry2 > rect.Y + rect.H + space + height)
{
ry2 = rect.Y + rect.H + space + height;
}
GL.Enable(EnableCap.Blend);
GL.MatrixMode(MatrixMode.Color);
GL.PushMatrix();
if (Math.Abs(rect.Rotation) > 0.001)
{
GL.Translate(0.5f, 0.5f, 0);
GL.Rotate(-rect.Rotation, 0f, 0f, 1f);
GL.Translate(-0.5f, -0.5f, 0);
}
GL.Begin(PrimitiveType.Quads);
GL.Color4(color.R, color.G, color.B, color.A * CGraphics.GlobalAlpha);
GL.Vertex3(rx2, ry1, rect.Z + CGraphics.ZOffset);
GL.Color4(color.R, color.G, color.B, 0f);
GL.Vertex3(rx2, ry2, rect.Z + CGraphics.ZOffset);
GL.Vertex3(rx1, ry2, rect.Z + CGraphics.ZOffset);
GL.Color4(color.R, color.G, color.B, color.A * CGraphics.GlobalAlpha);
GL.Vertex3(rx1, ry1, rect.Z + CGraphics.ZOffset);
GL.End();
GL.PopMatrix();
GL.Disable(EnableCap.Blend);
}
void drawCollisionIntervals()
{
if (view == '0' || picked == -1)
{
return;
}
GL.LineWidth(4.0f);
colors[picked % (colors.Count())][3] = 0.5f;
GL.Color4(colors[picked % (colors.Count())]);
Vector3 pos = bodies[picked].getPos();
Sphere bsphere = bodies[picked].getBSphere();
if (view == 'z')
{
GL.Begin(PrimitiveType.Lines);
{
GL.Vertex3(pos.X - bsphere.radius, -gizmosOffsetY, 10);
GL.Vertex3(pos.X + bsphere.radius, -gizmosOffsetY, 10);
GL.Vertex3(-gizmosOffsetX, pos.Y + bsphere.radius, 10);
GL.Vertex3(-gizmosOffsetX, pos.Y - bsphere.radius, 10);
}
GL.End();
}
else if (view == 'x')
{
GL.Begin(PrimitiveType.Lines);
{
GL.Vertex3(10, -gizmosOffsetY, pos.Z - bsphere.radius);
GL.Vertex3(10, -gizmosOffsetY, pos.Z + bsphere.radius);
GL.Vertex3(10, pos.Y + bsphere.radius, gizmosOffsetZ);
GL.Vertex3(10, pos.Y - bsphere.radius, gizmosOffsetZ);
}
GL.End();
}
else
{
GL.Begin(PrimitiveType.Lines);
{
GL.Vertex3(-gizmosOffsetX, 10, pos.Z + bsphere.radius);
GL.Vertex3(-gizmosOffsetX, 10, pos.Z - bsphere.radius);
GL.Vertex3(pos.X - bsphere.radius, 10, gizmosOffsetZ);
GL.Vertex3(pos.X + bsphere.radius, 10, gizmosOffsetZ);
}
GL.End();
}
GL.LineWidth(1.0f);
}
protected override void _DrawTexture(COGLTexture texture, SDrawCoords dc, SColorF color, bool isReflection = false)
{
// Align textures to full pixels to reduce artefacts
dc.Wx1 = (float)Math.Round(dc.Wx1);
dc.Wy1 = (float)Math.Round(dc.Wy1);
dc.Wx2 = (float)Math.Round(dc.Wx2);
dc.Wy2 = (float)Math.Round(dc.Wy2);
GL.BindTexture(TextureTarget.Texture2D, texture.Name);
GL.Enable(EnableCap.Blend);
GL.MatrixMode(MatrixMode.Texture);
GL.PushMatrix();
if (Math.Abs(dc.Rotation) > float.Epsilon)
{
GL.Translate(0.5f, 0.5f, 0);
GL.Rotate(-dc.Rotation, 0f, 0f, 1f);
GL.Translate(-0.5f, -0.5f, 0);
}
GL.Begin(PrimitiveType.Quads);
GL.Color4(color.R, color.G, color.B, color.A * CGraphics.GlobalAlpha);
GL.TexCoord2(dc.Tx1, dc.Ty1);
GL.Vertex3(dc.Wx1, dc.Wy1, dc.Wz);
if (isReflection)
{
GL.Color4(color.R, color.G, color.B, 0);
}
GL.TexCoord2(dc.Tx1, dc.Ty2);
GL.Vertex3(dc.Wx1, dc.Wy2, dc.Wz);
GL.TexCoord2(dc.Tx2, dc.Ty2);
GL.Vertex3(dc.Wx2, dc.Wy2, dc.Wz);
if (isReflection)
{
GL.Color4(color.R, color.G, color.B, color.A * CGraphics.GlobalAlpha);
}
GL.TexCoord2(dc.Tx2, dc.Ty1);
GL.Vertex3(dc.Wx2, dc.Wy1, dc.Wz);
GL.End();
GL.PopMatrix();
GL.Disable(EnableCap.Blend);
GL.BindTexture(TextureTarget.Texture2D, 0);
}
void MusicCirsle(object data)
{
for (int j = 0; j < 5; j++)
{
GL.Begin(PrimitiveType.TriangleFan);
//GL.Color3(firstColorSpectr);
GL.Color4(((tData)data).firstColorSpectr.R, ((tData)data).firstColorSpectr.G, ((tData)data).firstColorSpectr.B, 0.8);
// spectrRadius[j] *= 3;
if (j == 0)
{
((tData)data).spectrRadius[j] += ((tData)data)._FFTSpectr[j] * ((tData)data).glControl1.Width / 3;
}
else
{
((tData)data).spectrRadius[j] += ((tData)data)._FFTSpectr[j] * ((tData)data).glControl1.Width / Math.Sqrt(j + 10) + ((tData)data).spectrRadius[j - 1];
}
((tData)data).spectrRadius[j] /= 2;
GL.Vertex3(((tData)data).x, ((tData)data).y, (double)(1 - 0.1 + j / 100));
for (double i = 0; i < 2 * Math.PI; i += 0.01)
{
//GL.Color3(secondColorSpectr[j]);
GL.Color4(secondColorSpectr[j].R, secondColorSpectr[j].G, secondColorSpectr[j].B, 0.8);
GL.Vertex3(((tData)data).spectrRadius[j] * Math.Cos(i) + ((tData)data).x,
((tData)data).spectrRadius[j] * Math.Sin(i) + ((tData)data).y, (double)(1 - 0.1 - j / 100));
GL.Vertex3(((tData)data).spectrRadius[j] * Math.Cos(i + 0.01) + ((tData)data).x,
((tData)data).spectrRadius[j] * Math.Sin(i + 0.01) + ((tData)data).y, (double)(1 - 0.1 - j / 100));
}
GL.End();
}
Console.WriteLine("asdf");
GL.Begin(PrimitiveType.Triangles);
GL.Vertex3(0, 0, 0);
GL.Vertex3(100, 0, 0);
GL.Vertex3(0, 100, 0);
GL.End();
}
public void DrawRect(SColorF color, SRectF rect)
{
GL.Enable(EnableCap.Blend);
GL.Color4(color.R, color.G, color.B, color.A * CGraphics.GlobalAlpha);
GL.Begin(PrimitiveType.Quads);
GL.MatrixMode(MatrixMode.Color);
GL.PushMatrix();
if (Math.Abs(rect.Rotation) > 0.001)
{
GL.Translate(0.5f, 0.5f, 0);
GL.Rotate(-rect.Rotation, 0f, 0f, 1f);
GL.Translate(-0.5f, -0.5f, 0);
}
GL.Vertex3(rect.X, rect.Y, rect.Z + CGraphics.ZOffset);
GL.Vertex3(rect.X, rect.Y + rect.H, rect.Z + CGraphics.ZOffset);
GL.Vertex3(rect.X + rect.W, rect.Y + rect.H, rect.Z + CGraphics.ZOffset);
GL.Vertex3(rect.X + rect.W, rect.Y, rect.Z + CGraphics.ZOffset);
GL.End();
GL.PopMatrix();
GL.Disable(EnableCap.Blend);
}
private void RenderTransformBox(Viewport2D viewport)
{
if (!CurrentTransform.HasValue)
{
return;
}
var box = new Box(State.PreTransformBoxStart, State.PreTransformBoxEnd);
var trans = CreateMatrixMultTransformation(CurrentTransform.Value);
box = box.Transform(trans);
var s = viewport.Flatten(box.Start);
var e = viewport.Flatten(box.End);
GL.Enable(EnableCap.LineStipple);
GL.LineStipple(10, 0xAAAA);
GL.Begin(PrimitiveType.Lines);
GL.Color4(Color.FromArgb(64, BoxColour));
Coord(s.DX, s.DY, e.DZ);
Coord(e.DX, s.DY, e.DZ);
Coord(s.DX, e.DY, e.DZ);
Coord(e.DX, e.DY, e.DZ);
Coord(s.DX, s.DY, e.DZ);
Coord(s.DX, e.DY, e.DZ);
Coord(e.DX, s.DY, e.DZ);
Coord(e.DX, e.DY, e.DZ);
GL.End();
GL.Disable(EnableCap.LineStipple);
RenderBoxText(viewport, s, e);
}
void DrawGrid()
{
int half_fov = fov / 2;
float offset;
GL.Color4(1f, 0f, 0f, 1f);
//grid y
GL.Begin(PrimitiveType.LineLoop);
{
GL.Vertex3(-half_fov, -half_fov, half_fov);
GL.Vertex3(half_fov, -half_fov, half_fov);
GL.Vertex3(half_fov, -half_fov, -half_fov);
GL.Vertex3(-half_fov, -half_fov, -half_fov);
}
GL.End();
for (int i = 1; i < tiles; i++)
{
offset = (float)grid_edge * i;
GL.Begin(PrimitiveType.Lines);
{
GL.Vertex3(offset - half_fov, -half_fov, half_fov);
GL.Vertex3(offset - half_fov, -half_fov, -half_fov);
GL.Vertex3(-half_fov, -half_fov, offset - half_fov);
GL.Vertex3(half_fov, -half_fov, offset - half_fov);
}
GL.End();
}
GL.Color4(0f, 1f, 0f, 1f);
//grid x
GL.Begin(PrimitiveType.LineLoop);
{
GL.Vertex3(-half_fov, half_fov, half_fov);
GL.Vertex3(-half_fov, half_fov, -half_fov);
GL.Vertex3(-half_fov, -half_fov, -half_fov);
GL.Vertex3(-half_fov, -half_fov, half_fov);
}
GL.End();
for (int i = 1; i < tiles; i++)
{
offset = (float)grid_edge * i;
GL.Begin(PrimitiveType.Lines);
{
GL.Vertex3(-half_fov, -half_fov, offset - half_fov);
GL.Vertex3(-half_fov, half_fov, offset - half_fov);
GL.Vertex3(-half_fov, offset - half_fov, half_fov);
GL.Vertex3(-half_fov, offset - half_fov, -half_fov);
}
GL.End();
}
GL.Color4(0f, 0f, 1f, 1f);
//grid z
GL.Begin(PrimitiveType.LineLoop);
{
GL.Vertex3(-half_fov, -half_fov, -half_fov);
GL.Vertex3(half_fov, -half_fov, -half_fov);
GL.Vertex3(half_fov, half_fov, -half_fov);
GL.Vertex3(-half_fov, half_fov, -half_fov);
}
GL.End();
for (int i = 1; i < tiles; i++)
{
offset = (float)grid_edge * i;
GL.Begin(PrimitiveType.Lines);
{
GL.Vertex3(offset - half_fov, -half_fov, -half_fov);
GL.Vertex3(offset - half_fov, half_fov, -half_fov);
GL.Vertex3(-half_fov, offset - half_fov, -half_fov);
GL.Vertex3(half_fov, offset - half_fov, -half_fov);
}
GL.End();
}
}
protected override void OnRenderFrame(FrameEventArgs e)
{
base.OnRenderFrame(e);
#if TEST
#else
GL.Clear(TK.ClearBufferMask.DepthBufferBit | TK.ClearBufferMask.ColorBufferBit);
if (ortho)
{
modelView = Matrix4.CreateOrthographic(width, height, -height, height);
GL.MatrixMode(TK.MatrixMode.Projection);
GL.PushMatrix();
GL.LoadMatrix(ref modelView);
GL.Scale(scale_factor, scale_factor, scale_factor);
}
else
{
modelView = Matrix4.LookAt(eye, target, up);
GL.MatrixMode(TK.MatrixMode.Modelview);
GL.PushMatrix();
GL.LoadMatrix(ref modelView);
}
GL.PushMatrix();
GL.Rotate(offsetX, 0.0f, 1.0f, 0.0f);
GL.Rotate(offsetY, 1.0f, 0.0f, 0.0f);
DrawGrid();
#region Draw 3D Polyhedrons
GL.Color3(0.0, 0.5, 1.0);
GL.Enable(TK.EnableCap.Light0);
GL.Enable(TK.EnableCap.Lighting);
int i = 0;
foreach (Body body in bodies)
{
float[] color = colors[i % colors.Count()];
color[3] = 0.9f;
GL.Color4(color);
body.Draw();
color[3] = 0.25f;
GL.Color4(color);
body.getBSphere().Draw();
i++;
}
if (picked != -1)
{
GL.Color3(colors[picked % colors.Count()]);
GL.PolygonMode(TK.MaterialFace.FrontAndBack, TK.PolygonMode.Line);
foreach (Body body in bodies.ElementAt(picked).getBSphere().cells)
{
body.Draw();
}
GL.PolygonMode(TK.MaterialFace.FrontAndBack, TK.PolygonMode.Fill);
}
GL.Disable(TK.EnableCap.Lighting);
GL.Disable(TK.EnableCap.Light0);
#endregion
#region Draw Gizmos
drawCollisionIntervals();
#endregion
GL.PopMatrix();
GL.PopMatrix();
SwapBuffers();
showFPS();
//showInfo();
#endif
}
private void GlPaint(object sender, PaintEventArgs e)
{
if (!_glLoaded)
{
return;
}
// Color fonColor = Color.FromArgb(_soundColor.R, _soundColor.B, 0);
_fonStrong = ((_fonStrong * 3) + _total) / 4;
if (_fonStrong > 1)
{
_fonStrong = 1;
}
Color fonColor = Color.FromArgb((int)(255 * _fonStrong),
(int)(255 * _fonStrong), (int)(255 * _fonStrong * 0.2));
GL.ClearColor(fonColor);
// GL.ClearColor(1f, 1f, 1f, 1f);
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
GL.LoadIdentity();
GL.Disable(EnableCap.Lighting);
GL.Enable(EnableCap.Blend);
GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
//Прорисoвка круга
if (Visual1.Colors.Count >= 10)
{
Color spin = new Color();
GL.Begin(PrimitiveType.TriangleFan);
GL.Color3(Visual1.Colors[0]);
GL.Color4(Visual1.Colors[0].R, Visual1.Colors[0].G, Visual1.Colors[0].B, (double)0.5);
GL.Color4(Color.FromArgb(Visual1.Colors[0].A * 0, Visual1.Colors[0].R, Visual1.Colors[0].G, Visual1.Colors[0].B));
GL.Vertex3(-0, -0, -1);
GL.Vertex3(Visual1.Coordinates[0].X, Visual1.Coordinates[0].Y, -1);
for (int i = 0; i < Visual1.Coordinates.Count; i++)
{
if ((i % 4 == 0) && (i > 0))
{
GL.End();
GL.Begin(PrimitiveType.TriangleFan);
GL.Vertex3(-0, -0, (float)((double)i / Visual1.Coordinates.Count / 2 - 1));
for (int j = i - 3; j < i; j++)
{
GL.Vertex3(-Visual1.Coordinates[j - 1].X, -Visual1.Coordinates[j - 1].Y,
(float)((double)j / Visual1.Coordinates.Count / 2 - 1));
}
GL.End();
GL.Begin(PrimitiveType.TriangleFan);
GL.Vertex3(-0, -0, (float)((double)i / Visual1.Coordinates.Count / 2 - 1));
GL.Vertex3(Visual1.Coordinates[i - 1].X, Visual1.Coordinates[i - 1].Y,
(float)((double)i / Visual1.Coordinates.Count / 2 - 1));
}
GL.Color3(Visual1.Colors[i]);
GL.Color4(Visual1.Colors[i].R, Visual1.Colors[i].G, Visual1.Colors[i].B, (double)0.5);
GL.Color4(Color.FromArgb((int)((double)i / Visual1.Coordinates.Count * TR * 255), Visual1.Colors[i].R, Visual1.Colors[i].G, Visual1.Colors[i].B));
GL.Vertex3(Visual1.Coordinates[i].X, Visual1.Coordinates[i].Y,
(float)((double)i / Visual1.Coordinates.Count / 2 - 1));
}
GL.End();
}
//////конец прорисовки круга
float[] diffuse = new float[3] {
0.5f, 0.5f, 0.5f
};
GL.Light(LightName.Light0, LightParameter.Diffuse, diffuse);
float[] ambient = new float[3] {
4, 4, 4
};
GL.Light(LightName.Light0, LightParameter.Ambient, ambient);
float[] lightPos = new float[4] {
-glControl1.Width, 0.0f, 10.0f, 1.0f
};
GL.Light(LightName.Light0, LightParameter.Position, lightPos);
float[] specular = new float[4] {
10, 10, 10, 1
};
GL.Light(LightName.Light0, LightParameter.Specular, specular);
GL.Enable(EnableCap.Lighting);
GL.Enable(EnableCap.Light0);
GL.LightModel(LightModelParameter.LightModelTwoSide, 1);
//звуковой спектр снизу в виде диаграмм
Random rand = new Random();
for (int color = 0; color < 5; color++)
{
LoadTexture(bmpTex[color]);
for (int j = 0; j < 50; j++)
{
if (_FFTnum[j] - 1 != color)
{
continue;
}
GL.Enable(EnableCap.Texture2D);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter,
(int)TextureMinFilter.Nearest);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter,
(int)TextureMagFilter.Linear);
GL.PolygonMode(MaterialFace.FrontAndBack, mode);
GL.Begin(PrimitiveType.QuadStrip);
double w = glControl1.Width / 25;
float k = 0.5f;
double r = 0.5;
int n = 20;
for (int i = 0; i <= n; ++i)
{
double a = Math.PI / n * i;
double x = r * Math.Cos(a);
double z = r * Math.Sin(a);
GL.TexCoord2(0, 1);
GL.Vertex3(x * w + w * j + (w / 2) - glControl1.Width,
-glControl1.Height * (1 - _FFTSpectr[_FFTnum[j] - 1]), z);
GL.TexCoord2(1, 0);
GL.Vertex3(x * w + w * j + (w / 2) - glControl1.Width, -glControl1.Height, z);
if (i > 0)
{
GL.Normal3(-(x - r * Math.Cos(a - 1)), (x - r * Math.Cos(a - 1)), 0);
}
}
GL.End();
}
}
GL.Disable(EnableCap.Lighting);
GL.Disable(EnableCap.Texture2D);
//myThread t1 = new myThread("Thread 1", glControl1.Width, glControl1.Height, firstColorSpectr, spectrRadius,
// _FFTSpectr, glControl1);
//myThread t2 = new myThread("Thread 1", -glControl1.Width, glControl1.Height, firstColorSpectr, spectrRadius,
// _FFTSpectr, glControl1);
//myThread t3 = new myThread("Thread 1", glControl1.Width, -glControl1.Height, firstColorSpectr, spectrRadius,
// _FFTSpectr, glControl1);
//myThread t4 = new myThread("Thread 1", -glControl1.Width, -glControl1.Height, firstColorSpectr, spectrRadius,
// _FFTSpectr, glControl1);
MusicCirsle(glControl1.Width, glControl1.Height, Math.PI, 3 * Math.PI / 2);
MusicCirsle(-glControl1.Width, glControl1.Height, 3 * Math.PI / 2, 2 * Math.PI);
MusicCirsle(glControl1.Width, -glControl1.Height, Math.PI / 2, 2 * Math.PI);
MusicCirsle(-glControl1.Width, -glControl1.Height, 0, Math.PI / 2);
//GL.Disable(EnableCap.Lighting);
GL.Disable(EnableCap.Blend);
GL.Flush();
//GL.Finish();
glControl1.SwapBuffers();
}
public static void Color4(Vector4 color)
{
GL.Color4(color.X, color.Y, color.Z, color.W);
}
public static void Color4(Color4 color)
{
GL.Color4(color.R, color.G, color.B, color.A);
}
public static void Color4(System.Drawing.Color color)
{
GL.Color4(color.R, color.G, color.B, color.A);
}
public static void Color4(LayoutFarm.Drawing.Color color)
{
GL.Color4(color.R, color.G, color.B, color.A);
}