// End конструктор
public void Plot(PaintPoint ds, int X0, int Y0, double scaleX, double scaleY)
{
//paint = new Paint(Rts, pnlCh);
//paint.Plot(); //, pnlCh);
//MessageBox.Show(pnlCh.Controls.Count.ToString());
Ant.MakeCurrent();
// очистка буфера цвета и буфера глубины
Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);
// очищение текущей матрицы
Gl.glLoadIdentity();
// установка черного цвета
Gl.glColor3f(100, 0, 0);
// помещаем состояние матрицы в стек матриц
Gl.glPushMatrix();
// выполняем перемещение в пространстве по осям X и Y
Gl.glTranslated(X0, Y0, 0);
// Gl.glScaled(scaleX, scaleY, 1);
// Gl.glLineWidth(1);
Gl.glBegin(Gl.GL_QUADS);//GL_LINES);
// далее мы рисуем координатные оси и стрелки на их концах
foreach (var bar in BarsDraw.Bars)
{
foreach (var k in bar.Point)
{
Gl.glVertex2d(k.Of.X, k.Of.Y);
Gl.glVertex2d(k.Of.X, k.Of.Y + hightCl - 1);
Gl.glVertex2d(k.To.X, k.To.Y + hightCl - 1);
Gl.glVertex2d(k.To.X, k.To.Y);
}
}
// завершаем режим рисования
Gl.glEnd();
//axis.PlotAxis(X0,Y0,scaleX,scaleY);
Gl.glPopMatrix();
Gl.glFlush();
Ant.Invalidate();
axis.PlotAxis1(ds, X0, Y0, scaleX, scaleY);
//FontPlot.Plot(ds, startPrice, delta, Ant.Height, Ant.Width, Paint.hightCl, Paint.widthCl, X0, Y0);
Ant.Invalidate();
}
void timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
{
// Prepare for simulation. Typically we use a time step of 1/60 of a
// second (60Hz) and 10 iterations. This provides a high quality simulation
// in most game scenarios.
float timeStep = 1.0f / 60.0f;
int velocityIterations = 8;
int positionIterations = 4;
// This is our little game loop.
// Instruct the world to perform a single step of simulation.
// It is generally best to keep the time step and iterations fixed.
world.Step(timeStep, velocityIterations, positionIterations);
sogc.Invalidate();
}
public void render()
{
// очищаем экран и z-буфер
Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);
// ставим свет (нужно вызывать каждый раз, иначе будет двигаться вместе с камерой)
Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_POSITION, light0Pos);
Gl.glLightfv(Gl.GL_LIGHT1, Gl.GL_POSITION, light1Pos);
// рисуем модельки
table.render();
bottom.render();
DrawScale();
Gl.glPushMatrix();
Gl.glTranslatef(0.0f, 0.0f, H0 - dH);
Gl.glScalef(Scale, Scale, Scale);
ball.render();
Gl.glPopMatrix();
liquid.render();
tube.render();
tube_inside.render();
// сообщаем OpenGL что закончили все дела и можно рисовать кадр
Gl.glFlush();
OGLVP.Invalidate();
}
public void print()// в методе print происходит отрисовка системы координат и решения уравнения
{
Gl.glColor3f(0.0f, 0.0f, 1.0f);
//отрисовываем систему координат
Gl.glBegin(Gl.GL_LINES);
Gl.glVertex2d(2.0, 0);
Gl.glVertex2d(-2.0, 0);
Gl.glVertex2d(0, 2.0);
Gl.glVertex2d(0, -2.0);
Gl.glEnd();
//y = x^2 + k, k = -4, ....4 для каждого k рисуем график
Gl.glColor3f(0.0f, 1.0f, 0.0f);
for (double k = -4; k <= 4; k += 0.5)
{
Gl.glBegin(Gl.GL_LINE_STRIP);
for (double j = -4; j <= 4; j += 0.01)
{
Gl.glVertex2d(j, y(j, k));// метод y(j,k) соответствует функции y = x^2 + k
}
Gl.glEnd();
}
Gl.glColor3f(0.0f, 1.0f, 0.0f);
Gl.glBegin(Gl.GL_LINES);
for (double i = -2; i <= 2; i += 0.5)
{
for (double j = -4; j <= 4; j += 0.1)
{
Gl.glVertex2d(j - 0.1, Math.Pow(j, 2) + i + i * (-0.1)); //отрисовка изоклин
Gl.glVertex2d(j + 0.1, Math.Pow(j, 2) + i + i * 0.1);
}
}
Gl.glEnd();
// u, w - задаем начальное условие
double u = -0.9;
double w = 1;
coordinatesY.Clear();
coordinatesX.Clear();
result(u, w); //получаем список координат точек интегральной кривой
//для начального условия (u,w)
Gl.glColor3f(1.0f, 0.0f, 0.0f);
Gl.glLineWidth(2);
Gl.glBegin(Gl.GL_LINE_STRIP);
for (int i = 0; i < coordinatesY.Count(); i++)
{
Gl.glVertex2d(coordinatesX[i], coordinatesY[i]);//Отрисовка интегральной кривой
}
Gl.glEnd();
AnT.Invalidate();
}
/// <summary>
/// отрисовка поля по всей области
/// </summary>
/// <param name="Scene">области отрисовки</param>
/// <param name="isNigth">текущее время суток (true — ночь, false — день)</param>
public static void RenderField(SimpleOpenGlControl Scene, bool isNigth)
{
int height = Scene.Height;
int width = Scene.Width;
// если текстура загружена
if (textureIsLoad)
{
// очищение текущей матрицы
Gl.glLoadIdentity();
// включаем режим текстурирования
Gl.glEnable(Gl.GL_TEXTURE_2D);
if (!isNigth)
{
Gl.glBindTexture(Gl.GL_TEXTURE_2D, mGlTextureObject4);
}
else
{
Gl.glBindTexture(Gl.GL_TEXTURE_2D, mGlTextureObject5);
}
// включаем режим текстурирования , указывая индификатор mGlTextureObject
// сохраняем состояние матрицы
Gl.glPushMatrix();
// отрисовываем полигон
Gl.glBegin(Gl.GL_TRIANGLE_FAN);
Gl.glTexCoord2f(0, 0);
Gl.glVertex2d(0, 0);
Gl.glTexCoord2f(1, 0);
Gl.glVertex2d(width, 0);
Gl.glTexCoord2f(1, 1);
Gl.glVertex2d(width, height);
Gl.glTexCoord2f(0, 1);
Gl.glVertex2d(0, height);
// завершаем отрисовку
Gl.glEnd();
// возвращаем матрицу
Gl.glPopMatrix();
// отключаем режим текстурирования
Gl.glDisable(Gl.GL_TEXTURE_2D);
// обновлеям элемент со сценой
Scene.Invalidate();
}
}
public void drawAll()
{
Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);
foreach (Shape shape in geometrics)
{
shape.draw();
}
Gl.glFlush();
graphics.Invalidate();
}
public static void drawAll()
{
Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);
drawGrid();
foreach (var shape in geometrics)
{
shape.draw();
}
Gl.glFlush();
canvas.Invalidate();
}
static public void CalculateAverages()
{
int[] rowIntersect = { -1, -1, -1, 0, 0, 1, 1, 1 };
int[] colIntersect = { -1, 0, 1, -1, 1, -1, 0, 1 };
int RowsCount = MainOpenGLControl.Height / Cell.length, ColsCount = MainOpenGLControl.Width / Cell.length;
panelCellsBackup = new Cell[RowsCount, ColsCount];
// We want to change in the main array beacuse it's used in the invalidating function
// Just ot avoid shallow copies, copy cell by cell.
for (int l = 0; l < RowsCount; l++)
{
for (int m = 0; m < ColsCount; m++)
{
panelCellsBackup[l, m] = panelCells[l, m];
}
}
while (true)
{
switch (mainCalculationMode)
{
case CalculationMode.Sequential:
calculateAveragesSequential(rowIntersect, colIntersect, RowsCount, ColsCount);
break;
case CalculationMode.Parallel:
if (Visualizer.mainParallizationMode == ParallelizationMode.CSharp)
{
calculateAveragesParallelCSharp(rowIntersect, colIntersect, RowsCount, ColsCount);
}
else if (Visualizer.mainParallizationMode == ParallelizationMode.CPP)
{
calculateAveragesParallelCppPre(rowIntersect, colIntersect, RowsCount, ColsCount);
}
break;
}
MainOpenGLControl.Invalidate();
// Replacing the old values with the new ones ..
for (int l = 0; l < RowsCount; l++)
{
for (int m = 0; m < ColsCount; m++)
{
panelCells[l, m] = panelCellsBackup[l, m];
}
}
}
}
public override void DrawFunc()
{
Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);
Gl.glLoadIdentity();
UpdateLookerPosition();
Gl.glPushMatrix();
Gl.glTranslated(0, 0, -5);
this.RedisplayMeth();
Gl.glPopMatrix();
Gl.glFlush();
DrawContext.Invalidate();
}
public void render()
{
// очищаем экран и z-буфер
Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);
// ставим свет (нужно вызывать каждый раз, иначе будет двигаться вместе с камерой)
Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_POSITION, light0Pos);
Gl.glLightfv(Gl.GL_LIGHT1, Gl.GL_POSITION, light1Pos);
Gl.glLightfv(Gl.GL_LIGHT1, Gl.GL_SPOT_DIRECTION, light1spotdir);
if (ExpIsRunning)
{
wave1.render();
wave2.render();
wave3.render();
}
Table.render();
Laser.render();
ControlUnit.render();
Supports.render();
Connector.render();
Platforms.render();
if (DrawOSD)
{
OSD.render();
}
Gl.glPushMatrix();
Gl.glScalef(Scale, 1.0f, 1.0f);
if (DrawCrystal)
{
Crystal.render();
}
else
{
CrystalOutline.render();
}
Gl.glPopMatrix();
// сообщаем OpenGL что закончили все дела и можно рисовать кадр
Gl.glFlush();
GLVP.Invalidate();
}
//препятствие
private static void RenderFillSquareGraphPoint(Point begin, Textures type)
{
// если текстура загружена
if (textureIsLoad)
{
// очищение текущей матрицы
Gl.glLoadIdentity();
// включаем режим текстурирования
Gl.glEnable(Gl.GL_TEXTURE_2D);
// включаем режим текстурирования , указывая индификатор mGlTextureObject
switch (type)
{
case Textures.Block:
Gl.glBindTexture(Gl.GL_TEXTURE_2D, mGlTextureObject0);
break;
case Textures.TransparentCharacter:
Gl.glBindTexture(Gl.GL_TEXTURE_2D, mGlTextureObject1);
break;
case Textures.CurrentCharactert:
Gl.glBindTexture(Gl.GL_TEXTURE_2D, mGlTextureObject2);
break;
case Textures.Toarch:
Gl.glBindTexture(Gl.GL_TEXTURE_2D, mGlTextureObject3);
break;
}
// сохраняем состояние матрицы
Gl.glPushMatrix();
// отрисовываем полигон
Gl.glBegin(Gl.GL_TRIANGLE_FAN);
Gl.glTexCoord2f(0, 0);
Gl.glVertex2d(begin.X, begin.Y);
Gl.glTexCoord2f(1, 0);
Gl.glVertex2d(begin.X + scaleX, begin.Y);
Gl.glTexCoord2f(1, 1);
Gl.glVertex2d(begin.X + scaleX, begin.Y + scaleY);
Gl.glTexCoord2f(0, 1);
Gl.glVertex2d(begin.X, begin.Y + scaleY);
// завершаем отрисовку
Gl.glEnd();
// возвращаем матрицу
Gl.glPopMatrix();
// отключаем режим текстурирования
Gl.glDisable(Gl.GL_TEXTURE_2D);
// обновлеям элемент со сценой
Scene.Invalidate();
}
}
public void DrawModel()
{
int width = Controls[(SoftwareRendering ? 2 : 1)].Width;
int height = Controls[(SoftwareRendering ? 2 : 1)].Height;
Array.Copy(checkerboard, pixel_buffer, pixel_buffer.Length);
DrawingArea.initDrawingArea(height, width, pixel_buffer);
Rasterizer.method364();
bool success = false;
if (SelectedModel != null)
{
try
{
int k3 = Rasterizer.center_x;
int j4 = Rasterizer.center_y;
Rasterizer.center_x = c_x + DrawingArea.width / 2;
Rasterizer.center_y = c_y + DrawingArea.height / 2;
while (Yaw < 0)
{
Yaw += Model.SIN.Length;
}
while (Pitch < 0)
{
Pitch += Model.COS.Length;
}
while (Roll < 0)
{
Roll += Model.COS.Length;
}
Yaw %= Model.SIN.Length;
Pitch %= Model.COS.Length;
Roll %= Model.COS.Length;
int i5 = Rasterizer.SIN[Yaw] * c_z >> 16;
int l5 = Rasterizer.COS[Yaw] * c_z >> 16;
bool animated = false; //interfaceIsSelected(class9_1);
int i7;
/*if (animated)
* i7 = class9_1.anInt258;
* else
* i7 = class9_1.anInt257;
* Model model;
* if (i7 == -1)
* {
* model = class9_1.method209(-1, -1, animated);
* }
* else
* {
* Animation animation = Animation.anims[i7];
* model = class9_1.method209(animation.anIntArray354[class9_1.anInt246], animation.anIntArray353[class9_1.anInt246], animated);
* }*/
if (SelectedModel != null)
{
SelectedModel.Render(Pitch, Roll, Yaw, 0, i5, l5);
}
Rasterizer.center_x = k3;
Rasterizer.center_y = j4;
if (!SoftwareRendering)
{
Gl.glClearColor(.5f, 1, 1, 1);
Gl.glClear(Gl.GL_COLOR_BUFFER_BIT);
Gl.glMatrixMode(Gl.GL_PROJECTION);
Gl.glLoadIdentity();
Gl.glOrtho(0, width, 0, height, -1, 1);
Gl.glMatrixMode(Gl.GL_MODELVIEW);
Gl.glViewport(0, 0, width, height);
Gl.glTexSubImage2D(Gl.GL_TEXTURE_2D, 0, 0, 0, width, height, Gl.GL_BGRA, Gl.GL_UNSIGNED_BYTE, DrawingArea.pixels);
Gl.glBegin(Gl.GL_QUADS);
Gl.glTexCoord2d(0.0, 1.0); Gl.glVertex2d(0.0, 0.0);
Gl.glTexCoord2d(1.0, 1.0); Gl.glVertex2d(width, 0.0);
Gl.glTexCoord2d(1.0, 0.0); Gl.glVertex2d(width, height);
Gl.glTexCoord2d(0.0, 0.0); Gl.glVertex2d(0.0, height);
Gl.glEnd();
gl_control.Invalidate();
}
else
{
software_control.Image = DrawingArea.ToBitmap();
}
success = true;
}
catch (Exception)
{
success = false;
}
}
else
{
Controls[(SoftwareRendering ? 2 : 1)].Visible = false;
Controls[0].Visible = true;
this.Invalidate();
}
if (!success)
{
Controls[(SoftwareRendering ? 2 : 1)].Visible = false;
Controls[0].Visible = true;
if (!SoftwareRendering)
{
gl_control.Invalidate();
}
else
{
software_control.Invalidate();
}
}
else
{
Controls[(SoftwareRendering ? 2 : 1)].Visible = true;
Controls[0].Visible = false;
}
}
public void Draw()
{
try
{
Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);
Gl.glClearColor(255.0f, 255.0f, 255.0f, 1.0f);
Gl.glLoadIdentity();
if (!ortho)
{
Glu.gluLookAt(0.0f, 0.0f, 8.0f,
0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f);
}
if (translateX != 0)
{
Gl.glTranslated(translateX, 0, 0);
}
if (translateY != 0)
{
Gl.glTranslated(0, translateY, 0);
}
if (translateZ != 0)
{
Gl.glTranslated(0, 0, translateZ);
}
if (angleX != 0)
{
Gl.glRotated(angleX, 1, 0, 0);
}
if (angleY != 0)
{
Gl.glRotated(angleY, 0, 1, 0);
}
if (angleZ != 0)
{
Gl.glRotated(angleZ, 0, 0, 1);
}
if (scale != 0)
{
Gl.glScaled(scale, scale, scale);
}
//////////////////////////////////////////////////////////////////
Gl.glColor3f(0.0f, 255.0f, 0.0f);
if (points.Count > 0 && drawPoints)
{
Gl.glPointSize(5.0f);
Gl.glBegin(Gl.GL_POINTS);
foreach (Point3D p in points)
{
Gl.glVertex3d(p.X, p.Y, p.Z);
}
Gl.glEnd();
Gl.glPointSize(1.0f);
}
//////////////////////////////////////////////////////////////////
if (faces.Count > 0)
{
if (drawWire)
{
foreach (Face f in faces)
{
Gl.glBegin(Gl.GL_LINE_LOOP);
foreach (int point in f.points)
{
Gl.glVertex3d(points[point - 1].X, points[point - 1].Y, points[point - 1].Z);
}
Gl.glEnd();
}
}
//////////////////////////////////////////////////////////////////
Gl.glEnable(Gl.GL_LIGHTING);
Gl.glColor3f(255, 0, 0);
foreach (Face f in faces)
{
switch (f.points.Count)
{
case 3:
Gl.glBegin(Gl.GL_TRIANGLES);
break;
case 4:
Gl.glBegin(Gl.GL_QUADS);
break;
default:
Gl.glBegin(Gl.GL_POLYGON);
break;
}
//////////////////////////////////////////////////////////////////
for (int j = 0; f.points.Count > j; j++)
{
if (f.normales.Count == f.points.Count)
{
Gl.glNormal3d(normales[f.normales[j] - 1].X, normales[f.normales[j] - 1].Y, normales[f.normales[j] - 1].Z);
}
else
{
Vector3D n;
var vec1 = points[f.points[1] - 1] - points[f.points[0] - 1];
var vec2 = points[f.points[2] - 1] - points[f.points[0] - 1];
Vector3D n1 = Vector3D.CrossProduct(vec1, vec2);
Vector3D n2 = Vector3D.CrossProduct(vec2, vec1);
n1.Normalize();
n2.Normalize();
var t1 = Vector3D.DotProduct(n1, lightDir);
var t2 = Vector3D.DotProduct(n2, lightDir);
n = t1 >= t2 ? n1 : n2;
Gl.glNormal3d(n.Z, n.Y, n.Z);
}
//////////////////////////////////////////////////////////////////
if (f.textures.Count > 0)
{
Gl.glTexCoord2f(textures[f.textures[j] - 1].X, textures[f.textures[j] - 1].Y);
}
Gl.glVertex3d(points[f.points[j] - 1].X, points[f.points[j] - 1].Y, points[f.points[j] - 1].Z);
}
Gl.glEnd();
}
}
else
{
throw new Exception("Ошибка в файле. Не заданы грани.");
}
Gl.glFlush();
AnT.Invalidate();
Gl.glDisable(Gl.GL_LIGHTING);
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
}
public void EndDrawing()
{
Gl.glFlush();
_viewport.Invalidate();
}
public void Plot()
{
if (!Window.add)
{
PlotSer = true;
//paint = new Paint(Rts, pnlCh);
//paint.Plot(); //, pnlCh);
//MessageBox.Show(pnlCh.Controls.Count.ToString());
Chart.MakeCurrent();
// очистка буфера цвета и буфера глубины
Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);
// очищение текущей матрицы
Gl.glLoadIdentity();
// установка черного цвета
Gl.glColor3f(100, 0, 0);
// помещаем состояние матрицы в стек матриц
Gl.glPushMatrix();
// выполняем перемещение в пространстве по осям X и Y
Gl.glTranslated(X0, Y0, 0);
// Gl.glScaled(scaleX, scaleY, 1);
// Gl.glLineWidth(1);
Gl.glBegin(Gl.GL_QUADS); //GL_LINES);
// далее мы рисуем координатные оси и стрелки на их концах
int l = hiCl - 1;
int From = -X0 - wiCl;
int To = -X0 + ScreenW;
// string str;
foreach (var ds in DrawSer.Bars)
{
var gfgf = ds.Value.Price.ElementAt(0).Value[0];
if (gfgf >= From && gfgf <= To)
{
foreach (var pr in ds.Value.Price)
{
Gl.glVertex2d(pr.Value[0], pr.Value[2]);
Gl.glVertex2d(pr.Value[0], pr.Value[2] + l);
Gl.glVertex2d(pr.Value[1], pr.Value[2] + l);
Gl.glVertex2d(pr.Value[1], pr.Value[2]);
}
}
}
// завершаем режим рисования
Gl.glEnd();
// установка черного цвета
Gl.glColor3f(0, 0, 50);
Gl.glBegin(Gl.GL_POLYGON);
Gl.glVertex2d(DrawSer.lastPriceX, DrawSer.lastPriceY);
Gl.glVertex2d(DrawSer.lastPriceX + 10, DrawSer.lastPriceY + 10);
Gl.glVertex2d(DrawSer.lastPriceX + 80, DrawSer.lastPriceY + 10);
Gl.glVertex2d(DrawSer.lastPriceX + 80, DrawSer.lastPriceY - 10);
Gl.glVertex2d(DrawSer.lastPriceX + 10, DrawSer.lastPriceY - 10);
Gl.glEnd();
Gl.glColor3f(1, 1, 1);
string strr = DrawSer.lastPrice.ToString();
int i = 0;
foreach (var ch in strr)
{
Gl.glBegin(Gl.GL_LINE_STRIP);
foreach (var f in FontPlot.Symbols[ch])
{
// Glut.glutStrokeCharacter(Glut.GLUT_STROKE_ROMAN, '3');
Gl.glVertex2i(DrawSer.lastPriceX + 15 + i * 9 + f.X, DrawSer.lastPriceY - 5 + Convert.ToInt32(f.Y));
}
Gl.glEnd();
i++;
}
Gl.glColor3f(0.172f, 0.2f, 0.215f);
Gl.glBegin(Gl.GL_LINE_STRIP);
Gl.glVertex2d(DrawSer.lastPriceX, DrawSer.lastPriceY);
Gl.glVertex2d(0, DrawSer.lastPriceY);
Gl.glEnd();
// PlotNum();
Gl.glPopMatrix();
Gl.glFlush();
Chart.Invalidate();
// PlotNum();
PlotAxis();
PlotSer = false;
}
}
public void DrawSurface()
{
int x = 0;
MaxMin();
float delta = CG_GET_MAX_Z - CG_GET_MIN_Z;
Point3D[] tmp = new Point3D[3];
Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);
Gl.glLoadIdentity();
Gl.glColor3f(255, 0, 0);
Gl.glPushMatrix();
Gl.glTranslated(transform.x, transform.y, transform.z);
Gl.glRotatef(-60, 1, 0, 0);
Gl.glRotatef(ang, 0, 0, 1);
Gl.glClear(Gl.GL_COLOR_BUFFER_BIT);
DrawAxis();
//Graph
float red = 0;
Gl.glLineWidth(5);
while (x + raw_delta + 1 < DataXYZ.Length)
{
if (DataXYZ[x + raw_delta + 1].x == 0)
{
x++;
}
tmp = new Point3D[4] {
DataXYZ[x], DataXYZ[x + raw_delta], DataXYZ[x + raw_delta + 1], DataXYZ[x + 1]
};
Gl.glBegin((int)CG_VISUAL);
foreach (Point3D v in tmp)
{
Gl.glColor3f(1 - (CG_GET_MAX_Z - (float)v.z) / delta, 0, (CG_GET_MAX_Z - (float)v.z) / delta);
Gl.glVertex3d(v.x, v.y, v.z / compress_koeff);
}
Gl.glEnd();
x++;
}
if (CG_VISUAL == VISUALIZATION.POLY)
{
x = 0;
}
while (x + raw_delta + 1 < DataXYZ.Length)
{
if (DataXYZ[x + raw_delta + 1].x == 0)
{
x++;
}
tmp = new Point3D[4] {
DataXYZ[x], DataXYZ[x + raw_delta], DataXYZ[x + raw_delta + 1], DataXYZ[x + 1]
};
Gl.glPolygonMode(Gl.GL_FRONT, Gl.GL_LINE);
Gl.glLineWidth(1);
Gl.glBegin(Gl.GL_LINE_LOOP);
foreach (Point3D v in tmp)
{
if (CG_THEME == Theme.CLASSIC)
{
Gl.glColor3f(0, 0, 0);
}
else
{
Gl.glColor3f(1, 1, 1);
}
Gl.glVertex3d(v.x, v.y, v.z / compress_koeff);
}
red += 0.002f;
Gl.glEnd();
x++;
}
DrawVectors();
DrawText();
Gl.glPopMatrix();
Gl.glLoadIdentity();
Gl.glFlush();
control.Invalidate();
}
