Вы находитесь на странице: 1из 75

Компьютерная

графика

лекция 2
void glBegin(GLenum mode);
// Фукнция, объявляющая начало
описания примитива

void glEnd();
// Фукнция, объявляющая окончание
описания примитива
Константы, используемые в
функции glBegin()
GL_POINTS индивидуальные точки
GL_LINES вершины попарно интерпретируются как
самостоятельные отрезки
GL_LINE_STRIP серия соединенных отрезков (ломаная)
GL_LINE_LOOP аналогично предыдущему, но, кроме того,
автоматически добавляется отрезок, соединяющий первую
и последнюю вершины (замкнутая ломаная)
GL_TRIANGLES каждая тройка вершин интерпретируется как
треугольник
GL_TRIANGLE_STRIP цепочка соединенных треугольников
GL_TRIANGLE_FAN веер из соединенных треугольников
GL_QUADS каждая четверка вершин интерпретируется как
четырехугольный полигон
GL_QUAD_STRIP цепочка соединенных четырехугольников
GL_POLYGON граница простого выпуклого полигона
GL_POINTS Рисует точку на месте каждой из n вершин
GL_LINES Рисует серию несоединенных между собой
отрезков. Рисуются отрезки между V[0] и V[1] , между V[2] и
V[3], и так далее. Если n нечетно, то последний отрезок
рисуется между V[n-3] и V[n-2], а вершина n-1 игнорируется.
GL_LINE_STRIP Рисует отрезок между V[0] и V[1], между
V[1] и V[2], и так далее. Последний отрезок рисуется между
V[n-2] и V[n-1]. Таким образом, создается ломаная из n-1
отрезков. Если n < 2 не отображается ничего. Не
существует ограничений на вершины, описывающие
ломаную (или замкнутую ломаную). Отрезки могут любым
образом пересекаться.
GL_LINE_LOOP То же, что и GL_LINE_STRIP, но, кроме
того, рисуется отрезок между V[n-1] и V[0], замыкающий
ломаную.
GL_TRIANGLES Рисует серию треугольников (полигонов с
тремя сторонами) используя вершины V[0], V[1] и V[2],
затем V[3], V[4] и V[5], и так далее. Если n не кратно 3,
последние 1 или 2 вершины игнорируются.
GL_TRIANGLE_STRIP Рисует серию треугольников,
используя вершины V[0], V[1] и V[2], затем V[2], V[1] и V[3]
затем V[2], V[3], V[4], и так далее. Такой порядок
гарантирует, что все треугольники будут иметь одинаковую
ориентацию и, таким образом, соединенные треугольники
могут сформировать часть поверхности. Для того, чтобы
нарисовался хотя бы один треугольник n должно быть
больше или равно 3.
GL_TRIANGLE_FAN То же, что и GL_TRIANGLE_STRIP, но
порядок вершин следующий: V[0], V[1], V[2], затем V[0], V[2],
V[3], затем V[0], V[3], V[4], и так далее.
GL_QUADS Рисует серию четырехугольников (полигонов с
четырьмя сторонами), используя вершины V[0], V[1], V[2],
V[3], затем V[4], V[5], V[6], V[7], и так далее. Если n не
кратно 4, последние 1, 2 или 3 вершины игнорируются.
GL_QUAD_STRIP Рисует серию четырехугольников,
используя следующий порядок вершин: V[0], V[1], V[3], V[2],
затем V[2], V[3], V[5], V[4], затем V[4], V[5], V[7], V[6] и так
далее. n должно быть не меньше 4, иначе ничего не будет
нарисовано. Если n нечетно, последняя вершина
игнорируется.
GL_POLYGON Рисует полигон, используя точки V[0], V[1],
V[2], ..., V[n-1] в качестве вершин. n должно быть не меньше
3 или ничего нарисовано не будет. Кроме того,
описываемый полигон не должен иметь самопересечений и
должен быть выпуклым. Если вершины не удовлетворяют
этим условиям, результат непредсказуем.
Команды допустимые между
glBegin() и glEnd()
glVertex*() установка координат вершины
glColor*() установка текущего цвета
glIndex*() установка текущего цветового индекса
glNormal*() установка координат вектора нормали
glTexCoord*() установка координат текстуры
glMultiTexCoord*ARB() установка координат текстуры при
мультитекстурировании
glEdgeFlag*() контролирует рисование ребер
glMaterial*() установка свойств материала
glArrayElement() выделяет данные из массива вершин
glEvalCoords*(), glEvalPoint*() генерирует координаты
glCallList(), glCallLists()выполняет список отображения
Основы управления состоянием
переменных OpenGL
void glEnable (GLenum cap); включает механизм
void glDisable (GLenum cap); выключает механизм

GLboolean glIsEnabled (GLenum capability); проверка включен


или выключен определенный механизма

void glGetBooleanv (GLenum pname, GLboolean *params);


void glGetIntegerv (GLenum pname, GLint *params);
void glGetGLdoublev (GLenum pname, GLGLdouble *params);
void glGetDoublev (GLenum pname, GLdouble *params);
void glGetPointerv (GLenum pname, GLvoid *params);
Примеры функции рисования точки
void DrawPoint(GLdouble x, GLdouble y, GLdouble z, GLdouble s,
GLdouble r, GLdouble g, GLdouble b)

{ // передаются координаты, размер и цвет точки


glPointSize(s);
glColor3d(r, g, b);
glBegin(GL_POINTS);
glVertex3d(x, y, z);
glEnd();
}
Настройки, чтобы включить cглаживание
точек

glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA)
;
glEnable(GL_POINT_SMOOTH);

- эти функции необходимо вызвать один раз при


инициализации OpenGL.
Примеры функции рисования точек

void Draw()
{
for (int i = -10; i<=10; i++)
DrawPoint(i, 0, 0, rand()%30, 1, 1, 1);
}
Примеры функции рисования линии
void DrawLine(GLdouble x1, Gldouble y1, Gldouble z1,
Gldouble x2, Gldouble y2, Gldouble z2,
Gldouble r1, Gldouble g1, Gldouble b1,
Gldouble r2, Gldouble g2, Gldouble b2)
{ // передаются координаты и цвета двух точек линии
glBegin(GL_LINES);
glColor3d(r1, g1, b1);
glVertex3d(x1, y1, z1);
glColor3d(r2, g2, b2);
glVertex3d(x2, y2, z2);
glEnd();
}
Примеры функции рисования линии
void DrawLine(GLdouble x1, Gldouble y1, Gldouble z1,
Gldouble x2, Gldouble y2, Gldouble z2,
Gldouble r1, Gldouble g1, Gldouble b1)

{ // передаются координаты двух точек и цвет линии


DrawLine(x1, y1, z1, x2, y2, z2, r1, g1, b1, r1, g1, b1);
}
Примеры функции рисования линии
void DrawLine(GLdouble x1, GLdouble y1,
GLdouble x2, GLdouble y2,
GLdouble r1, GLdouble g1, GLdouble b1,
GLdouble r2, GLdouble g2, GLdouble b2)
{ // передаются координаты и цвета двух точек линии в
двухмерном пространстве
DrawLine(x1, y1, 0, x2, y2, 0, r1, g1, b1, r2, g2, b2);
}
Примеры функции рисования линии
void DrawLine(GLdouble x1, GLdouble y1,
GLdouble x2, GLdouble y2,
GLdouble r1, GLdoubleg1, GLdouble b1)
{ // передаются координаты двух точек в двухмерном
пространстве и цвет линии
DrawLine(x1, y1, 0, x2, y2, 0, r1, g1, b1);
}
void DrawLine(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble
y2)
{ // передаются координаты двух точек в двухмерном
пространстве, цвет по умолчанию белый
DrawLine(x1, y1, x2, y2, 1, 1, 1);
}
Вспомогательные структуры и функции

struct vertex3{GLdouble x, y, z; } ;
struct color3 {GLdouble r, g, b; };

vertex3 vertex GLdouble x, GLdouble y, GLdouble z=0){


vertex3 result = {x, y, z};
return result;
}
color3 color(GLdouble r, GLdouble g, GLdouble b){
color3 result = {r, g, b};
return result;
}
Вспомогательные константы

static color3 clWhite = { 1, 1, 1 };


static color3 clBlack = { 0, 0, 0 };
static color3 clRed = { 1, 0, 0 };
static color3 clGreen = { 0, 1, 0 };
static color3 clBlue = { 0, 0, 1 };
static color3 clGrey = { 0.5, 0.5, 0.5 };

static vertex3 vrZero = { 0, 0, 0 };


static vertex3 vrOne = { 1, 1, 1 };
Примеры функции рисования линии

void DrawLine(vertex3 v1, vertex3 v2, color3 c)


{// передаются координаты двух точек в трехмерном
пространстве и цвет линии
glBegin(GL_LINES);
glColor3d(c.r, c.g, c.b);
glVertex3d(v1.x, v1.y, v1.z);
glVertex3d(v2.x, v2.y, v2.z);
glEnd();
}
Примеры функции рисования линии

void DrawLine(vertex3 v1, vertex3 v2, color3 c1, color3 c2)


{// передаются координаты двух точек в трехмерном
пространстве и цвет начала и окончания линии
glBegin(GL_LINES);
glColor3d(c1.r, c1.g, c1.b);
glVertex3d(v1.x, v1.y, v1.z);
glColor3d(c2.r, c2.g, c2.b);
glVertex3d(v2.x, v2.y, v2.z);
glEnd();
}
Примеры функции рисования линии

void DrawLine(vertex3 v1, vertex3 v2, color3 c, GLfloat size)


{// передаются координаты двух точек в трехмерном
пространстве, цвет и размер линии
glLineWidth(size);
glBegin(GL_LINES);
glColor3d(c.r, c.g, c.b);
glVertex3d(v1.x, v1.y, v1.z);
glVertex3d(v2.x, v2.y, v2.z);
glEnd();
}
Примеры функции рисования линий
DrawLine(0, 0, 1, 2); //4 параметра
DrawLine(0, 0, 0, 1, 2, 3); //6 параметров
DrawLine(0, 0, 1, 2, 1, 1, 0); //7 параметров
DrawLine(0, 0, 1, 2, 1, 1, 0, 0, 1, 0); //10
параметров
DrawLine(0, 0, 0, 1, 2, 3, 1, 1, 1); //9
параметров
DrawLine(0, 0, 0, 1, 2, 3, 1, 0, 0, 0, 1,
0); //12 параметров
DrawLine(vertex(-10, 0, 0), vertex(10, 0, 0),
color(1,1,1), color(1,1,1));
DrawLine(vertex(-10, 0, 0), vertex(10, 0, 0),
color(1,1,1));
Примеры функции рисования линий

• void Draw()
• {
• for (int i = 0; i<=10; i++)
• DrawLine(rand()%30 - 15, rand()%30 - 15,
rand()%30 - 15, rand()%30 - 15, 1, 1,
1);
• }

• glLineWidth(10); - установка ширины линии


Примеры функции рисования
окружности
void DrawCircle(GLdouble x, GLdouble y, GLdouble z,
GLdouble radius, GLdouble r, GLdouble g, GLdouble b)
{ // передаются координаты центра, радиус и цвет
окружности
glColor3d(r, g, b);
int n = 60;
glBegin(GL_LINE_LOOP);
for (int i = 0; i<n; i++)
glVertex3d(x+radius*sin(i*2*3.14/n),
y+radius*cos(i*2*3.14/n), z);
glEnd();
Примеры функции рисования круга
• void DrawRound(GLdouble x, GLdouble y, GLdouble z,
GLdouble radius, GLdouble r, GLdouble g, GLdouble b)
• { // передаются координаты центра, радиус и цвет круга
• glColor3d(r, g, b);
• int n = 60;
• glBegin(GL_TRIANGLE_FAN);
• for (int i = 0; i<n; i++)
• glVertex3d(x+radius*sin(i*2*3.14/n),
• y+radius*cos(i*2*3.14/n), z);
• glEnd();
• }
Примеры функции рисования
окружности и круга
void DrawCircle(vertex3 v, GLdouble radius, color3 c)
{
DrawCircle(vertex(v.x, v.y, v.z), radius, color(c.r, c.g, c.b));
}

void DrawRound(vertex3 v, GLdouble radius, color3 c)


{
DrawRound(vertex(v.x, v.y, v.z), radius, color(c.r, c.g, c.b));
}
Примеры функции рисования
окружностей и кругов

void Draw()
{
DrawCircle (0, -8, 0, 5, 1, 1, 1);
DrawCircle (0, 1, 0, 4, 1, 0, 0);
DrawRound (0, 8, 0, 3, 0, 0, 1);
DrawRound (1, 3, 0, 3, 0.5, 0.5, 0.5);
DrawCircle(vertex(2, 1), 1, color(0.5, 0.5, 0);
DrawRound (vertex(3, -1), 3, color(1, 1, 0.5);
}
Примеры функции рисования
треугольника
void DrawTriangle(GLdouble x1, GLdouble y1, GLdouble z1,
GLdouble x2, GLdouble y2, GLdouble z2,
GLdouble x3, GLdouble y3, GLdouble z3,
GLdouble r1, GLdouble g1, GLdouble b1,
GLdouble r2, GLdouble g2, GLdouble b2,
GLdouble r3, GLdouble g3, GLdouble b3)
{ // передаются координаты и цвета трех точек треугольника
glBegin(GL_TRIANGLES);
glColor3d(r1, g1, b1); glVertex3d(x1, y1, z1);
glColor3d(r2, g2, b2); glVertex3d(x2, y2, z2);
glColor3d(r3, g3, b3); glVertex3d(x3, y3, z3);
glEnd();
}
Примеры функции рисования
треугольника
void DrawTriangle(GLdouble x1, GLdouble y1, GLdouble z1,
GLdouble x2, GLdouble y2, GLdouble z2,
GLdouble x3, GLdouble y3, GLdouble z3,
GLdouble r, GLdouble g, GLdouble b)
{ // передаются координаты трех точек и цвет
треугольника
DrawTriangle(x1, y1, z1, x2, y2, z2, x3, y3, z3, r, g,
b, r, g, b, r, g, b);
}
Примеры функции рисования
треугольника
void DrawTriangle(vertex3 v1, vertex3 v2, vertex3 v3,
color3 c1, color3 c2, color3 c3)
{ // передаются координаты и цвета трех точек
треугольника
glBegin(GL_TRIANGLES);
glColor3d(c1.r, c1.g, c1.b); glVertex3d(v1.x, v1.y, v1.z);
glColor3d(c2.r, c2.g, c2.b); glVertex3d(v2.x, v2.y, v2.z);
glColor3d(c3.r, c3.g, c3.b); glVertex3d(v3.x, v3.y, v3.z);
glEnd();
}
Примеры функции рисования
треугольника
void DrawTriangle(vertex3 v1, vertex3 v2, vertex3 v3,
color3 c)
{ // передаются координаты и цвет треугольника
DrawTriangle(v1, v2, v3, c, c, c);
}
Примеры функции рисования
треугольников
void Draw()
{ DrawTriangle(0, 0, 3, 0, 0, 3, 1, 1, 1);
DrawTriangle(3, 0, 6, 0, 3, 5, 1, 1, 1, 1,
0, 0, 0, 1, 0);

DrawTriangle(-5, -5, 5, -5, 0, -1, 1, 1, 1,


1, 1, 1, 0, 0, 0);

DrawTriangle(vertex(-5, 0), vertex(1, 2),


vertex(4, -5), color(1, 0, 0), color(0, 1,
0), color(0, 0, 1));
}
Примеры функции рисования
четырехугольника
void DrawQuad(GLdouble x1, GLdouble y1, GLdouble z1, GLdouble x2,
GLdouble y2, GLdouble z2, GLdouble x3, GLdouble y3, GLdouble z3,
GLdouble x4, GLdouble y4, GLdouble z4, GLdouble r1, GLdouble g1,
GLdouble b1, GLdouble r2, GLdouble g2, GLdouble b2, GLdouble r3,
GLdouble g3, GLdouble b3, GLdouble r4, GLdouble g4, GLdouble b4)
{ // передаются координаты и цвет четырех точек четырехугольника
glBegin(GL_QUADS);
glColor3d(r1, g1, b1); glVertex3d(x1, y1, z1);
glColor3d(r2, g2, b2); glVertex3d(x2, y2, z2);
glColor3d(r3, g3, b3); glVertex3d(x3, y3, z3);
glColor3d(r4, g4, b4); glVertex3d(x4, y4, z4);
glEnd();
}
Примеры функции рисования
четырехугольника
void DrawQuad(GLdouble x1, GLdouble y1, GLdouble z1,
GLdouble x2, GLdouble y2, GLdouble z2,
GLdouble x3, GLdouble y3, GLdouble z3,
GLdouble x4, GLdouble y4, GLdouble z4,
GLdouble r1, GLdouble g1, GLdouble b1)
{ // передаются координаты четырех точек и цвет четырехугольника
DrawQuad(x1, y1, z1, x2, y2, z2, x3, y3, z3, x4, y4, z4, r1, g1,
b1, r1, g1, b1, r1, g1, b1, r1, g1, b1);
}
Примеры функции рисования
четырехугольника
void DrawQuad(vertex3 v1, vertex3 v2, vertex3 v3, vertex3 v4, color3 c)
{ // передаются координаты и цвет четырех точек четырехугольника
glBegin(GL_QUADS);
glColor3d(c.r, c.g, c.b);
glVertex3d(v1.x, v1.y, v1.z);
glVertex3d(v2.x, v2.y, v2.z);
glVertex3d(v3.x, v3.y, v3.z);
glVertex3d(v4.x, v4.y, v4.z);
glEnd();
}
Примеры функции рисования
прямоугольника
void DrawRect(GLdouble x1, GLdouble y1, GLdouble z1,
GLdouble w, GLdouble h,
GLdouble r1, GLdouble g1, GLdouble b1)
{ // передаются координаты центра, ширина, высота и цвет
прямоугольника
DrawQuad(x1-w/2, y1-h/2, z1,
x1+w/2, y1-h/2, z1,
x1+w/2, y1+h/2, z1,
x1-w/2, y1+h/2, z1,
r1, g1, b1);
}
Примеры функции рисования полигона
void DrawPolygon(GLdouble **mas, int n,
GLdouble r1, GLdouble g1, GLdouble b1)
{ // передается двумерный массив, количество вершин и
цвет полигона
glColor3d(r1, g1, b1);
glBegin(GL_POLYGON);
for (int i=0; i<n; i++)
glVertex3d(mas[i][0], mas[i][1], mas[i][2]);
glEnd();
}
Пример вызова функции рисования
полигона
GLdouble **mas;
int n = 7;
mas = new GLdouble *[n];
for (int i=0; i<n; i++)
{
mas[i] = new GLdouble [3];
mas[i][0] = 1*sin(i*6.28/n);
mas[i][1] = 1*cos(i*6.28/n);
mas[i][2] = 0;
}
DrawPolygon(mas, n, 1, 1, 1);
Примеры функции рисования круга
void DrawRound(GLdouble x, GLdouble y, GLdouble z,
GLdouble radius, GLdouble r, GLdouble g, GLdouble b)
{ // передаются координаты центра, радиус и цвет круга
glColor3d(r, g, b);
int n = 30;
glBegin(GL_POLYGON);
for (int i = 0; i<n; i++)
glVertex3d(x + radius*sin(i * 2 * 3.14 / n),
y + radius*cos(i * 2 * 3.14 / n), z);
glEnd();
}
Преобразование плоскости называется
аффинным, если
• оно взаимно однозначно;
• образом любой прямой является прямая.

Преобразование называется взаимно


однозначным, если
• разные точки переходят в разные;
• в каждую точку переходит какая-то точка.
Однородные координаты

Однородные координаты —
координаты, обладающие тем
свойством, что определяемый ими
объект не меняется при умножении всех
координат на одно и то же число.

 
Примеры движений.

Примеры аффинных преобразований


Простейшие преобразования

• Сжатие/растяжение
• Поворот
• Параллельный перенос
• Отражение
1) каждое из приведенный
преобразований имеет простой и
наглядный геометрический смысл

2) любое преобразование всегда можно


представить как последовательное
исполнение простейших
преобразований
Сжатие/растяжение
Это преобразование умножает соответствующие
координаты точек на коэффициенты
масштабирования по осям: (x, y) -> (ax * x, ay * y).
Матрица преобразования :

[  ax   0    0  ]     


[  0    ay   0  ]
[  0    0    1  ] 

ax – растяжение по оси x,
ay  – растяжение по оси y.
Поворот
Матрица преобразования :
[cos(а)  sin(а)   0  ]                             
[-sin(а)  cos(а)  0 ]
[  0         0        1  ] 
а – угол поворота
Параллельный перенос
Исходный вектор (x, y) переходит в
(x + dx, y + dy).
Матрица преобразования: 
[  1    0    0  ]    
[  0    1    0  ]
[  dx   dy   1  ]
Отражение
[  -1    0    0  ]     [   1    0    0  ] 
[   0    1    0  ] [   0   -1    0  ]
[   0    0    1  ] [   0    0    1  ]

относительно оси x относительно оси y


Общий вид аффинного преобразования
f(x) = x * R + t, где R – обратимая матрица 2x2,
а t – произвольный вектор.
Матрица преобразования:
[ R1,1      R1, 2 0 ] [ х ] [ x’ ]
[ R2 ,1 R2, 2    0 ] [ y ] = [ y’ ]
[ tx        ty      1 ] [ 1 ] [ 1 ]

x  x  R1,1  y  R2,1  tx
y  x  R1, 2  y  R2, 2  ty
glRotate
Функция glRotate поворачивает текущую матрицу
на заданный угол вокруг заданного вектора. Имеет
следующие формы:

glRotated (GLdouble angle, GLdouble x, GLdouble y,


double z)
glRotatef (GLfloat angle, GLfloat x, GLdouble y, GLfloat
z)

angle - угол поворота


x, y, z – вектор, задающий ось поворота
Примеры вызова функции glRotate

glRotated(45, 1, 0, 0) – поворот на 45
градусов против часовой стрелки
относительно оси x.

glRotated(90, 0, 0, -1) – поворот на 90


градусов по часовой стрелке
относительно оси z.
В функции glRotate вычисляется матрица поворота:

выполняющая поворот на угол angle против


часовой стрелки вокруг вектора, направление
которого задано точкой (x, y, z). Эта матрица
вычисляется следующим образом:
glTranslate
Функция glTranslate вносит дополнительное
смещение в текущую матрицу. Имеет
следующие формы:

glTranslated(GLdouble x, GLdouble y, GLdouble z)

glTranslatef(GLfloat x, GLfloat y, GLfloat z)

x, y, z - координаты вектора сдвига


Функция glTranslate выполняет сдвиг
текущей матрицы на вектор (x, y, z). Этот
вектор сдвига используется для
составления матрицы сдвига:
glScale
Функция glScale масштабирует текущую
матрицу. Имеет следующие формы:

glScaled(GLdouble x, GLdouble y, GLdouble z)

glScalef(GLfloat x, GLfloat y, GLfloat z)

x, y, z - Коэффициенты
масштабирования по соответствующим
осям
В функции glScale вычисляется матрица
масштабирования:
Текущая матрица умножается на матрицу
преобразования, а затем результат этого
произведения записывается в текущую
матрицу. Таким образом, если M — текущая
матрица, а R — матрица преобразования, то
матрица M будет заменена на M*R.

Если режим текущей матрицы


GL_MODELVIEW , то все примитивы,
нарисованные после вызова glScale,
glRotate, glTranslated, будут
соответствующим образом масштабированы
glLoadIdentity
Функция glLoadIdentity заменяет текущую
матрицу на единичную.

glLoadIdentity ()
glPushMatrix, glPopMatrix
Функции glPushMatrix и glPopMatrix
предназначены для помещения матриц в
стек и извлечения из него.

glPushMatrix( )
glPopMatrix( )
Примеры преобразований
• void DrawGrid(GLdouble r, GLdouble g,
GLdouble b)
• {
• GLdouble dx = 1;
• for (int i = -10; i<=10; i++)
• DrawLine(i*dx, -10, 0, i*dx, 10, 0,
r, g, b);
• }
Примеры преобразований
void Draw()
{ glTranslated(0, 0, -30);
glRotated(GetTickCount()/10.f , 0.1, 0.2, 0.3);
glTranslated(0, 0, -10); DrawGrid(1, 1, 1);
glRotated(90, 0, 0, 1); DrawGrid(1, 1, 1);
glPushMatrix(); glTranslated(0, 0, -20);
DrawGrid(1, 0, 0); glRotated(90, 0, 0, 1);

DrawGrid(1, 0, 0);
glPopMatrix(); glTranslated(-10, 0, -10);
glRotated(90, 0, 1, 0); DrawGrid(0, 1, 0);
glRotated(90, 0, 0, 1); DrawGrid(0, 1, 0);

glTranslated(0, 0, 20); DrawGrid(0, 0, 1);


glRotated(90, 0, 0, 1); DrawGrid(0, 0, 1);