295

Проектирование композитных трёхмерных объектов, сцен и разработка приложения интерактивной компьютерной графики

Курсовая

Информатика, кибернетика и программирование

Описание алгоритма и исходного кода программы проектирования композитной трехмерной сцены (замок) и разработки приложения интерактивной компьютерной графики. Разработана и отлажена программа, реализующая представленные алгоритмы на языке С++ с использованием библиотеки OpenGL.

Русский

2012-11-14

566.5 KB

57 чел.

АННОТАЦИЯ

В настоящей пояснительной записке приведено описание алгоритма и исходного кода программы проектирования композитной трехмерной сцены (замок) и разработки приложения интерактивной компьютерной графики. Разработана и отлажена  программа, реализующая представленные алгоритмы на языке С++ с использованием библиотеки OpenGL.

Пояснительная записка содержит 27 страниц, 5 рисунков, 3 использованных источника, 1 приложение.


Содержание.

ВВЕДЕНИЕ. 4

1. Описание программы. 5

1.1. Общие сведения. 5

1.2. Функциональное назначение. 5

1.4. Структурная схема программы. 6

1.5. Схема алгоритма функции, реализующей демонстрационный режим. 7

2. Теоретические сведения. 8

2.1. Преобразование координат. 8

2.2. Проекции. 9

2.3. Текстурирование. 9

2.4. Описание источников света. 11

Техническое и программное обеспечение. 13

Руководство для пользователя. 13

Пример работы программы. 14

Заключение. 15

Список литературы. 16

Приложение. 17


ВВЕДЕНИЕ.

OpenGL — это программный интерфейс к графическому оборудованию. Этот интерфейс содержит порядка 250 отдельных команд (около 200 в ядре OpenGL и еще 50 в библиотеке OpenGL UtilityLibrary), которые используются для задания объектов и операций, необходимых для создания интерактивных приложений трехмерной графики.

Ниже кратко перечислены основные графические операции, выполняемые OpenGLпри построении изображения на экране.

1. Построение моделей из графических примитивов и создание таким образом математического описания объектов. (Примитивами в OpenGLявляются точки, линии, многоугольники, изображения и битовые образы.)

2. Расстановка объектов в трехмерном пространстве и выбор выгодной точки обзора всей сцены.

3. Вычисление цвета всех объектов. Цвета могут быть заданы приложением, определяться условиями освещения, получаться наложением текстур на объекты или быть комбинацией этих трех действий.

4. Преобразование математического описания объектов и информации об их цвете в пикселы на экране. Данный процесс называется растеризацией.

Во время этих шагов OpenGLможет выполнять другие операции, например удаление невидимых частей объектов. Кроме того, после растеризации сцены, но перед ее прорисовкой, при необходимости можно выполнить операции с массивом пикселов.


  1.  Описание программы.

  1.   Общие сведения.

Программа демонстрирует работу приложения интерактивной компьютерной графики.

Реализованное на языке Microsoft Visual C++ приложение имеет имя «Zamok» и представляет собой исполняемый файл Zamok.exe.

Исходный текст программы на языке Microsoft Visual C++ (файл zamok.cpp) содержит около 655 строк, исполняемый код программы (файл Zamok.exe) занимает около 96 Кб оперативной памяти.

  1.  Функциональное назначение.

Программа реализует процесс построения и визуализации трехмерного объекта с элементами динамики. Базовый трехмерный объект – замок. Динамика реализуется посредством задания траектории движения объекта и камеры. Так же программа реализует включение и выключение дополнительного источника света и наложение текстур.

Возможна работа программы как в интерактивном режиме, так и в демонстрационном – автоматическом.

  1.   Описание структуры программы.

Программа разбита на отдельные функциональные части – подпрограммы, которые распределяются по отдельным уровням иерархии. Каждая из подпрограмм решает только свою небольшую задачу по преобразованию данных, что позволяет упростить процесс написания и отладки программы в целом. Далее приводится описания назначения всех функций.

Описание функций:

int main()главная функция программы.

void reshape(int w, int h) – функция, вызываемая при изменении размеров окна.

void display (void) – функция, рисования сцены.

void Zamok()- функция рисования замка и фонарей.

void Trava()- функция рисования травы.

void Rov()- функция рисования рва вокруг замка.

void SpecialKeys(int key, int x, int y) - функция, обрабатывающая сообщения с клавиатуры.

void Demo() - функция, описывающая демонстрационный режим программы.

void TimerFunc(int value) - функция таймер,используется в демо режиме.

void fonar_svet ()- функция, которая отвечает за установку параметров дополнительного света и его включение.

void init (void) - функция, которая отвечает за установку параметров основного света и его включение.

void Voda()функция рисования четырехугольника, для наложения текстуры воды.

void ocna()– функция рисования четырехугольника, для наложения текстуры окна.

  1.  
    Структурная схема программы.

Рисунок 1. Структурная схема программы.


  1.   Схема алгоритма функции, реализующей демонстрационный режим.

нет

 

 

да

 нет

да

нет

 

да

 

 

 

Рисунок 2. Схема алгоритма функции, реализующей демонстрационный режим.

Переменная time является счетчиком, с помощью которого определяется, длительность выполнения преобразований сцены, а также какие именно преобразования нужно выполнить в заданном интервале времени.

Переменная cam отвечает за изменение положения камеры по координате z.

Если time<40, то увеличиваем переменную cam на единицу, тем самым отдаляя камеру, затем увеличиваем на единицу переменную time и вызываем функцию-таймер TimerFunc, в которой происходит перерисовка окна.

Как только  time становится больше или равной 40, но меньше 80, переменную cam, наоборот, уменьшаем на единицу, приближая камеру, также увеличиваем time и вызываем функцию TimerFunc.

При time>250, изменяем положение объекта по оси y, таким образом, производим вращение объекта по кругу.

  1.  Теоретические сведения.
    1.   Преобразование координат.

Для задания различных преобразований объектов сцены в OpenGL используются операции над матрицами, при этом различают три типа матриц: видовая, проекций и текстуры. Все они имеют размер 4×4. Видовая матрица определяет преобразования объекта в мировых координатах, такие как параллельный перенос, изменение масштаба и поворот.

Параллельный перенос осуществляется с помощью команды

glTranslate[f d] (GLtype x, GLtype y, GLtype z) - перемещение объекта на расстояние x по оси Х, на расстояние y по оси Y и на расстояние z по оси Z.

Масштабирование производится посредством команды

void glScale[f d] (GLtype x, GLtype y, GLtype z) – осуществляет частичное изменение масштаба  вдоль каждой из координатных осей на значения, определяемые соответствующими параметрами.

Поворот осуществляется через команду

 void glRotate[f d] (GLtype angle, GLtype x, GLtype y,GLtype z) - рассчитывает матрицу для выполнения вращения вектора против часовой стрелки на угол, определяемый параметром angle, осуществляемого относительно точки (x, y, z).

В данной курсовой работе используются все 3 вида преобразований при создании отдельных  частей замка, а также операции параллельного переноса и поворота при наложении некоторых текстур (окна, дверь, ров).

Матрица проекций задает как будут проецироваться трехмерные объекты на плоскость экрана (в оконные координаты), а матрица текстуры определяет наложение текстуры на объект.

Для того, чтобы выбрать, какую матрицу надо изменить, используется команда

void glMatrixMode(GLenum mode)

вызов которой со значением параметра mode равным GL_MODELVIEW, GL_PROJECTION, GL_TEXTURE включает режим работы с видовой, проекций и матрицей текстуры соответственно. Для вызова команд, задающих матрицы того или иного типа необходимо сначала установить соответствующий режим.

В данной программе используются 2 матрицы: видовая и проекционная (см. с.25-26).

Команда void glLoadIdentity(void) заменяет текущую матрицу на единичную. Часто нужно сохранить содержимое текущей матрицы для дальнейшего использования, для чего используют команды

void glPushMatrix(void)

void glPopMatrix(void)

Они записывают и восстанавливают текущую матрицу из стека.


  1.   Проекции.

В OpenGL существует 2 вида проекций: перспективная и ортографическая (параллельная).

Перспективное проецирование.

Наиболее очевидная характеристика перспективной проекции — ракурс (foreshortening) в смысле сокращения размеров находящихся дальше от камеры объектов. Видимый объем в перспективной проекции представляет собой усеченную пирамиду (вершина которой срезана плоскостью, параллельной основанию). Объекты, попадающие в объем видимости, проецируются к вершине пирамиды, где находится камера или точка обзора, и те из них, что расположены ближе к точке обзора, выглядят больше, чем объекты, находящиеся ближе к основанию пирамиды. Этот метод используется в основном для анимации, визуального моделирования и в приложениях, где необходимо добиться определенной степени реализма, так как его работа схожа с работой глаза (или камеры).

Параллельное проецирование.

При ортографическом проецировании объем видимости представляет собой прямоугольный параллелепипед, или коробку. В отличие от перспективного проецирования размер объема видимости не изменяется от одного конца к другому, и расстояние от камеры не влияет на размер объектов. Этот тип проецирования применяется в архитектурных чертежных приложениях и системах автоматизированного проектирования, где необходимо знать реальные размеры объектов и углы между ними.

Для задания перспективной проекции в  OpenGL используется команда

void gluPerspective (GLdouble angley, GLdouble aspect,

                    GLdouble znear, GLdouble zfar)  

Параметр angley определяет угол видимости в градусах по оси у и должен находиться в диапазоне от 0 до 180. Угол видимости вдоль оси x задается параметром aspect, который обычно задается как отношение сторон области вывода (как правило, размеров окна). Параметры zfar и znear задают расстояние от наблюдателя до плоскостей отсечения по глубине и должны быть положительными.

В представленной программе используется перспективная проекция с целью повышения реалистичности.

  1.  Текстурирование.

Наложение текстуры на поверхность объектов сцены повышает ее реалистичность, однако при этом надо учитывать, что этот процесс требует вычислительных затрат, особенно если OpenGL не поддерживается аппаратно.

Для использования текстуры необходимо сначала загрузить в память нужное изображение и передать его OpenGL. Можно воспользоваться функцией, входящей в состав библиотеки GLAUX, которая сама проводит необходимые операции. Это функция

AUX_RGBImageRec* auxDIBImageLoad (const char *file)

где file – название файла с расширением *.bmp или *.dib.

При наложении текстуры надо учитывать случай, когда размеры текстуры отличаются от оконных размеров объекта, на который она накладывается. При этом возможно как растяжение, так и сжатие изображения, и то, как будут проводиться эти преобразования, может серьезно повлиять на качество построенного изображения. Для определения положения точки на текстуре используется параметрическая система координат (s,t), причем значения s и t находятся в отрезке [0,1].

Для изменения различных параметров текстуры применяется команда:

void glTexParameter[i f] (GLenum target, GLenum pname,

                         GLenum param)

При этом target может принимать значения GL_TEXTURE_1D или GL_TEXTURE_2D, pname определяет, какое свойство будем менять, а с помощью param устанавливается новое значение. Возможные значения pname:

GL_TEXTURE_MIN_FILTER

параметр param определяет функцию, которая будет использоваться для сжатия текстуры. При значении GL_NEAREST будет использоваться один (ближайший), а при значении GL_LINEAR четыре ближайших элемента текстуры. Значение по умолчанию: GL_LINEAR

GL_TEXTURE_MAG_FILTER

параметр param определяет функцию, которая будет использоваться для увеличения (растяжения) текстуры.

GL_TEXTURE_WRAP_S

параметр param устанавливает значение координаты s, если оно не входит в отрезок [0,1].

При значении GL_ REPEAT целая часть s отбрасывается, и в результате изображение размножается по поверхности. При значении GL_CLAMP используются краевые значения: 0 или 1, что удобно использовать, если на объект накладывается один образ. Значение по умолчанию: GL_REPEAT

GL_TEXTURE_WRAP_T

аналогично предыдущему значению, только для координаты t

Для того чтобы определить, как текстура будет взаимодействовать с материалом, из которого сделан объект, используется команда

void glTexEnv[i f]  (GLenum target, GLenum pname,

                    GLtype param)

Параметр target должен быть равен GL_TEXTURE_ENV, а в качестве pname рассмотрим только одно значение GL_TEXTURE_ENV_MODE, которое наиболее часто применяется.

Наиболее часто используемые значения параметра param:

GL_MODULATE

конечный цвет находится как произведение цвета точки на поверхности и цвета соответствующей ей точки на текстуре.

GL_REPLACE

в качестве конечного цвета используется цвет точки на текстуре.

В программе функции glTexParameter (применяется для сжатия текстуры), glTexEnv используются для более качественного наложения текстуры на куб.

Для наложения текстуры на объекты, созданные с помощью  примитивов gluNewQuadric(), используется функция gluQuadricTexture (GLUquadricObj* quadObject, GLboolean textureCoords) с параметром textureCoords равным GL_TRUE для автоматического натягивания текстуры на примитив.

  1.   Описание источников света.

Добавить в сцену источник света можно с помощью команды

void glLight[i f] (GLenum light, GLenum pname,

                  GLfloat param)

Параметр light однозначно определяет источник света. Он выбирается из набора специальных символических имен вида GL_LIGHTi , где i должно лежать в диапазоне от 0 до константы GL_MAX_LIGHT, которая обычно не превосходит восьми.

Рассмотрим значения параметра pname:

GL_SPOT_EXPONENT

параметр param должен содержать целое или вещественное число от 0 до 128, задающее распределение интенсивности света. Этот параметр описывает уровень сфокусированности источника света. Значение по умолчанию: 0 (рассеянный свет).

GL_SPOT_CUTOFF

параметр param должен содержать целое или вещественное число между 0 и 90 или равное 180, которое определяет максимальный угол разброса света. Значение этого параметра есть половина угла в вершине конусовидного светового потока, создаваемого источником. Значение по умолчанию: 180 (рассеянный свет).

GL_AMBIENT

параметр params должен содержать четыре целых или вещественных значения цветов RGBA, которые определяют цвет фонового освещения. Значение по умолчанию: (0.0, 0.0, 0.0, 1.0).

GL_DIFFUSE

параметр params должен содержать четыре целых или вещественных значения цветов RGBA, которые определяют цвет диффузного освещения. Значение по умолчанию: (1.0, 1.0, 1.0, 1.0) для LIGHT0 и (0.0, 0.0, 0.0, 1.0) для остальных.

GL_SPECULAR

параметр params должен содержать четыре целых или вещественных значения цветов RGBA, которые определяют цвет зеркального отражения. Значение по умолчанию: (1.0, 1.0, 1.0, 1.0) для LIGHT0 и (0.0, 0.0, 0.0, 1.0) для остальных.

GL_POSITION

параметр params должен содержать четыре целых или вещественных числа, которые определяют положение источника света. Если значение компоненты w равно 0.0, то источник считается бесконечно удаленным и при расчете освещенности учитывается только направление на точку (x,y,z), в противном случае считается, что источник расположен в точке (x,y,z,w). В первом случае ослабления света при удалении от источника не происходит, т.е. источник считается бесконечно удаленным. Значение по умолчанию: (0.0, 0.0, 1.0, 0.0).

Для использования освещения сначала надо установить соответствующий режим вызовом команды glEnable(GL_LIGHTNING), а затем включить нужный источник командой glEnable(GL_LIGHTi).

В данной работе используется 3 источника света: бесконечно удаленный, в качестве основного, и 2 точечных источника, в качестве дополнительного (см. с.17-18).

Техническое и программное обеспечение.

Для успешной эксплуатации программного продукта необходим персональный компьютер с оперативной памятью – не менее 512 Мбайт. Минимальным требованием служит ПК на основе Intel Pentium и наличие программы Microsoft Visual Studio 2005.

Приложение было реализовано на ПК на основе Intel Pentium, ОС Windows Vista на языке С++ (Microsoft Visual Studio 2005).

Руководство для пользователя.

Поворот влево, вправо, вперед, назад осуществляется с помощью клавиш на клавиатуре  ← и →,↑ и ↓.

Для приближения и отдаления замка используются клавиши PageDown (приближение) и PageUp (отдаление).

За запуск демонстрационного режима отвечает кнопка F1.

Для  включения и отключения дополнительного источника освещения используются клавиши F2 (включить) и F3 (отключить).

Пример работы программы.

Рисунок 3. Объект при запуске приложения.

Рисунок 4. Объект после поворота.


Рисунок 5.Объект при включенном источнике дополнительного света.

Заключение.

В результате выполнения данной курсовой работы был спроектирован трёхмерный объект  - замок на языке Microsoft Visual C++, спроектирован пользовательский интерфейс и продемонстрирована его работа.

В работе были использованы геометрические примитивы: куб, цилиндр, конус, сфера, тор, октаэдр.

Было применено наложение текстур.

Использованы два источника света: основное и дополнительное освещение.

Реализованы два режима работы программы: интерактивный(управление осуществляется посредством клавиш на клавиатуре)   и демонстрационный (осуществляет автоматическое приближение, отдаление замка и движение по кругу).

Таким образом, техническое задание выполнено в полном объеме.


Список литературы.

  1.  Девис Т., Нейдер Дж., Шрайнер Д. - OpenGL. Руководство по программированию (Библиотека программиста) – 2006г.
  2.  Ричард С. Райт, мл., Бенджамин Липчак «OpenGL. Суперкнига.» 2006.


Приложение.

Текст программы.

#include <stdio.h>

#include <GL/glut.h>

#include <glaux.h>

//вращение

static GLfloat xRot = 0.0f;

static GLfloat yRot = 0.0f;

static GLfloat cam = 0.0f;

int time=0;

int i = 0;

//описание текстур

unsigned int trava;

AUX_RGBImageRec* travaImage;

unsigned int kamen;

AUX_RGBImageRec* kamenImage;

unsigned int kam2;

AUX_RGBImageRec* kam2Image;

unsigned int cherep;

AUX_RGBImageRec* cherepImage;

unsigned int dver;

AUX_RGBImageRec* dverImage;

unsigned int okno;

AUX_RGBImageRec* oknoImage;

unsigned int voda;

AUX_RGBImageRec* vodaImage;

unsigned int most;

AUX_RGBImageRec* mostImage;

unsigned int black;

AUX_RGBImageRec* blackImage;

void init (void)//основной свет

{

GLfloat light_ambient[] = { 0.0, 0.0, 0.0, 1.0 };

GLfloat light_diffuse[] = { 1.0, 1.0, 1.0,1.0 };

GLfloat light_specular[] = { 1.0,1.0,1.0, 1.0 };

GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 };

/* устанавливаем параметры источника основного света*/

  glLightfv (GL_LIGHT0, GL_AMBIENT, light_ambient);//цвет фонового излучения источника света

  glLightfv (GL_LIGHT0, GL_DIFFUSE, light_diffuse);//цвет рассеянного излучения

  glLightfv (GL_LIGHT0, GL_SPECULAR, light_specular);//цвет зеркального излучения источника

  glLightfv (GL_LIGHT0, GL_POSITION, light_position);//направление источника света

  

  glEnable (GL_LIGHTING);//включаем освещение

  glEnable (GL_LIGHT0);//включаем источник света

  glEnable(GL_DEPTH_TEST);//включаем Z-буфер

}

void fonar_svet ()//дополнительный свет

{

glDisable(GL_LIGHT0);//выключаем основной свет

glDisable(GL_LIGHTING);

 float color1[4]={4.0,4.5, 1.0, 1.0};//цвет источника света

 float light_position[] = { 16.0, -16.0, 9.0, 5.0 };//позиция

glLightfv(GL_LIGHT1, GL_POSITION, light_position);

glLightfv(GL_LIGHT1, GL_DIFFUSE, color1);//устанавливаем цвет источника

glLightf(GL_LIGHT1, GL_CONSTANT_ATTENUATION, 2.0);//постоянная в функции затухания

 

 float light_position2[] = { 16.0, 16.0, 9.0, 5.0 };

glLightfv(GL_LIGHT2, GL_POSITION, light_position2);

glLightfv(GL_LIGHT2, GL_DIFFUSE, color1);//устанавливаем цвет источника

glLightf(GL_LIGHT2, GL_CONSTANT_ATTENUATION, 2.0);

glEnable(GL_LIGHTING);//учет освещения

glEnable(GL_LIGHT1);//включаем источники света

glEnable(GL_LIGHT2);

}

void Demo();

void TimerFunc(int value)//таймер

{

glutPostRedisplay();//перерисовка окна

 if(time<251)

Demo();

}

void Demo()//демонстрационный режим

{

 if(time<40)

{

 cam += 1.0f;

 time++;

 glutTimerFunc(70, TimerFunc, 1);

}

 else

 if(time<80)

 {  

  cam -= 1.0f;

  time++;

  glutTimerFunc(70, TimerFunc, 1);  

 }

 else

 if(time<250)

 {

  yRot+=2;

  glutTimerFunc(70, TimerFunc, 1);

  time++;

 }

}

//Обработка сообщений от нажатия специальных клавиш

void SpecialKeys(int key, int x, int y)

{

 if(key == GLUT_KEY_UP)//назад

 xRot-= 5.0f;

 if(key == GLUT_KEY_DOWN)//вперед

 xRot += 5.0f;

 if(key == GLUT_KEY_LEFT)//влево

 yRot -= 5.0f;

 if(key == GLUT_KEY_RIGHT)//вправо

 yRot += 5.0f;

 if(key == GLUT_KEY_F2)//включить доп. источник света

       fonar_svet();

 if(key == GLUT_KEY_F3) //включить основной источник света

{

 glDisable(GL_LIGHT1);//выключаем дополнительный свет

 glDisable(GL_LIGHT2);

 init();

}

 

 if(key == GLUT_KEY_F1)//запуск демонстрационного режима

{

 time=0;

 Demo();

}

 if(key == GLUT_KEY_PAGE_DOWN)//приближение

 cam -= 5.0f;

 if(key == GLUT_KEY_PAGE_UP)//отдаление

 cam += 5.0f;

 

glutPostRedisplay();//перерисовка окна

}

void Voda()

{

glBegin(GL_QUADS);//четырехугольник

glTexCoord2d(0,1); glVertex2d(2,8);

glTexCoord2d(1,1); glVertex2d(6,8);

glTexCoord2d(1,0); glVertex2d(6,0);

glTexCoord2d(0,0); glVertex2d(2,0);

glEnd();

}

void Rov()//функция рисования рва вокруг замка

{

glPushMatrix();//сохранение текущей матрицы

glEnable(GL_TEXTURE_2D);

glBindTexture(GL_TEXTURE_2D, voda );//загружаем текстуру воды

glRotated(90, 1,0,0);

glTranslated( 16,-22,9);

Voda();

 for(int i=0;i<4;i++)

{

 glTranslated( 0,8,0);

 Voda();

}

glRotated(90, 0,0,1);

glTranslated( 5.5,-6,0);

Voda();

 for(int i=0;i<4;i++)

{

 glTranslated( 0,8,0);

 Voda();

}

glRotated(90, 0,0,1);

glTranslated( 4,-6,0);

Voda();

 for(int i=0;i<4;i++)

{glTranslated( 0,8,0);

 Voda();

}

glRotated(90, 0,0,1);

glTranslated( 5.5,-6,0);

Voda();

 for(int i=0;i<4;i++)

{

 glTranslated( 0,8,0);

 Voda();

}

glPopMatrix();//восстановление матрицы

 //рисование моста

glPushMatrix();

glBindTexture(GL_TEXTURE_2D, most );

glRotated(90, 1,0,0);

glRotated(90, 0,0,1);

glTranslated( -5,-22.5,8.9);

glBegin(GL_QUADS);

glTexCoord2d(0,1); glVertex2d(2,10);// мост

glTexCoord2d(1,1); glVertex2d(8,10);

glTexCoord2d(1,0); glVertex2d(8,0);

glTexCoord2d(0,0); glVertex2d(2,0);

glEnd();

glPopMatrix();

glDisable(GL_TEXTURE_2D);

}

void Trava()//функция рисования травы

{

   GLfloat razmer = 75.0f;

   GLfloat fStep = 1.0f;//шаг

   GLfloat y = -0.04f;

   GLint ipoloska, iRun;

   GLfloat s = 0.0f;

   GLfloat t = 0.0f;

   GLfloat texStep = 0.1f / (razmer * .025f);

  

glEnable(GL_TEXTURE_2D);//разрешаем наложение текстуры

   glBindTexture(GL_TEXTURE_2D, trava);

   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);//устанавливаем режим повторения для S координаты

   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);//режим повторения для T координаты

  

 //земля состоит из четырехугольников, на каждый из которых накладывается текстура

   glPushMatrix();

glTranslated(0,-9,0);

 for(ipoloska = -razmer; ipoloska <= razmer; ipoloska += fStep)

{

       t = 0.0f;

       glBegin(GL_QUAD_STRIP); //рисовать четырехугольники

           for(iRun = razmer; iRun >= -razmer; iRun -= fStep)

  {

               glTexCoord2f(s, t);//координаты вершин

               glVertex3f(ipoloska, y, iRun);//задает трехмерные координаты вершин

               glTexCoord2f(s + texStep, t);

               glVertex3f(ipoloska + fStep, y, iRun);

   t = t + texStep;

  }

       glEnd();

       s = s + texStep;

}

glPopMatrix();

glDisable(GL_TEXTURE_2D);// запрещаем отображение текстуры

}

void ocna()

{

glBegin(GL_QUADS);

glTexCoord2d(0,1); glVertex2d(2,10);

glTexCoord2d(1,1); glVertex2d(10,10);

glTexCoord2d(1,0); glVertex2d(10,0);

glTexCoord2d(0,0); glVertex2d(2,0);

glEnd();

}

void Zamok()

{

 //создаем новый объект для создания фигур

GLUquadricObj *quadObj;

quadObj = gluNewQuadric();

glColor3d(1,1,0);

gluQuadricDrawStyle(quadObj, GLU_FILL); // устанавливаем стиль: сплошной

glPushMatrix();

glEnable(GL_TEXTURE_2D);//разрешить наложение текстуры

 //разрешить автоматическую генерацию текстурных координат

glEnable(GL_TEXTURE_GEN_S);

glEnable(GL_TEXTURE_GEN_T);

glBindTexture(GL_TEXTURE_2D, kam2);

glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,(float)GL_LINEAR);//определяет,какая функция будет использоваться для сжатия текстуры

glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,(float)GL_REPLACE);//взаимодействие текстуры с материалом(в качестве конечного цвета используется цвет точки на текстуре)

 

glutSolidCube(18);//куб

glPushMatrix();

glTranslated(8,-4,0);

glutSolidCube(10);//вход

glRotated(45, 0, 1, 0);

glScalef(7.5, 4.5, 7.5);//изменяем масштаб

glTranslated(0,1.1,0);

glEnable(GL_TEXTURE_2D);

glBindTexture(GL_TEXTURE_2D, cherep); //текстура черепица

glutSolidOctahedron();//козырек

glPopMatrix();

 

glPushMatrix();

glRotatef(270, 1, 0, 0);

glDisable(GL_TEXTURE_GEN_S);// запрещаем генерацию текстурных координат

glDisable(GL_TEXTURE_GEN_T);

   //рисование двери

glPushMatrix();

glBindTexture(GL_TEXTURE_2D, dver );

glRotated(90, 1,0,0);

glRotated(90, 0,1,0);

glTranslated( -6,-9,13.2);

glBegin(GL_QUADS);

glTexCoord2d(0,1); glVertex2d(2,10);

glTexCoord2d(1,1); glVertex2d(10,10);

glTexCoord2d(1,0); glVertex2d(10,0);

glTexCoord2d(0,0); glVertex2d(2,0);

glEnd();

glPopMatrix();

  //рисование окон

glPushMatrix();

glBindTexture(GL_TEXTURE_2D, okno );

glRotated(90, 1,0,0);

glRotated(90, 0,1,0);

glTranslated( -2.5,-4,-9.4);

ocna();

glTranslated( -6.5,0,0);

ocna();

glPopMatrix();

   glPushMatrix();

glBindTexture(GL_TEXTURE_2D, okno );

glRotated(90, 1,0,0);

glTranslated( -6,-4,-9.4);

ocna();

glTranslated( 0,0,19);

ocna();

glPopMatrix();

   //цепи

glPushMatrix();

glEnable(GL_TEXTURE_2D);  

glBindTexture(GL_TEXTURE_2D, black);

gluQuadricTexture (quadObj, GL_TRUE);

glTranslated(22,-2.6,-8.9);

glRotatef(-45,0, 1, 0);

gluCylinder(quadObj, 0.15, 0.15,15, 50, 50);

glTranslated(0,5,0);

gluCylinder(quadObj, 0.15, 0.15,15, 50, 50);

glDisable(GL_TEXTURE_2D);

glPopMatrix();

 //большая башня на основании

glPushMatrix();

glEnable(GL_TEXTURE_2D);  

glBindTexture(GL_TEXTURE_2D, kamen);

gluQuadricTexture (quadObj, GL_TRUE);

gluCylinder(quadObj, 4.5, 4.5,20, 50, 50);

glDisable(GL_TEXTURE_2D);

glTranslated(0,0,20);

glEnable(GL_TEXTURE_2D);  

glBindTexture(GL_TEXTURE_2D, cherep);

gluQuadricTexture (quadObj, GL_TRUE);

glutSolidCone (5, 5, 50, 50);

glDisable(GL_TEXTURE_2D);

glPopMatrix();

 

glPushMatrix();

glTranslated(13,5,-9);

glEnable(GL_TEXTURE_2D);  

glBindTexture(GL_TEXTURE_2D, cherep);

gluQuadricTexture (quadObj, GL_TRUE);

gluCylinder(quadObj, 0.15, 0.15,9.9, 50, 50);

glTranslated(0,-10,0);

gluCylinder(quadObj, 0.15, 0.15,9.9, 50, 50);

glDisable(GL_TEXTURE_2D);

glPopMatrix();

 //рисование заборчика

glPushMatrix();

glTranslated(9,6.5,9);

gluCylinder(quadObj, 0.2, 0.2,2.5, 50, 50);

 for(int i=0;i<8;i++)

{

glTranslated(0,-1.6,0);

gluCylinder(quadObj, 0.2, 0.2,2.5, 50, 50);

}

glTranslated(-18,0,0);

gluCylinder(quadObj, 0.2, 0.2,2.5, 50, 50);

 for(int i=0;i<8;i++)

{

glTranslated(0,1.6,0);

gluCylinder(quadObj, 0.2, 0.2,2.5, 50, 50);

}

glTranslated(4.2,2.55,0);

gluCylinder(quadObj, 0.2, 0.2,2.5, 50, 50);

 for(int i=0;i<8;i++)

{

glTranslated(1.6,0,0);

gluCylinder(quadObj, 0.2, 0.2,2.5, 50, 50);

}

glTranslated(0,-18,0);

gluCylinder(quadObj, 0.2, 0.2,2.5, 50, 50);

 for(int i=0;i<8;i++)

{

glTranslated(-1.6,0,0);

gluCylinder(quadObj, 0.2, 0.2,2.5, 50, 50);

}

glPopMatrix();

glPushMatrix();

glRotatef(270, 1, 0, 0);

glTranslated(9,-11.5,-10);//1

gluCylinder(quadObj, 0.2, 0.2,19, 50, 50);

glTranslated(0,2.5,0);

gluCylinder(quadObj, 0.2, 0.2,19, 50, 50);

 

glTranslated(-18,0,0);//2

gluCylinder(quadObj, 0.2, 0.2,19, 50, 50);

glTranslated(0,-2.5,0);

gluCylinder(quadObj, 0.2, 0.2,19, 50, 50);

glRotatef(90, 0, 1, 0);//3

glTranslated(-1,0,-1);

gluCylinder(quadObj, 0.2, 0.2,19, 50, 50);

glTranslated(0,2.5,0);

gluCylinder(quadObj, 0.2, 0.2,19, 50, 50);

glTranslated(-18,0,0);//4

gluCylinder(quadObj, 0.2, 0.2,19, 50, 50);

glTranslated(0,-2.5,0);

gluCylinder(quadObj, 0.2, 0.2,19, 50, 50);

glPopMatrix();

 //первая башня

glPopMatrix();

glRotatef(270, 1, 0, 0);

glPushMatrix();

glTranslated(-8,-10,-9);

glEnable(GL_TEXTURE_2D);  

glBindTexture(GL_TEXTURE_2D, kamen);

gluQuadricTexture (quadObj, GL_TRUE);

gluCylinder(quadObj, 2.5, 2.5,23, 50, 50);

glDisable(GL_TEXTURE_2D);

glTranslated(0,0,22);

glEnable(GL_TEXTURE_2D);  

glBindTexture(GL_TEXTURE_2D, cherep);

gluQuadricTexture (quadObj, GL_TRUE);

glutSolidCone (3, 7, 50, 50);

glDisable(GL_TEXTURE_2D);

glPopMatrix();

 //вторая башня

glTranslated(-8,10,-9);

glEnable(GL_TEXTURE_2D);  

glBindTexture(GL_TEXTURE_2D, kamen);

gluQuadricTexture (quadObj, GL_TRUE);

 gluCylinder(quadObj, 2.5, 2.5,23, 50, 50);

glTranslated(0,0,22);

glEnable(GL_TEXTURE_2D);  

glBindTexture(GL_TEXTURE_2D, cherep);

gluQuadricTexture (quadObj, GL_TRUE);

glutSolidCone (3, 7, 50, 50);

glDisable(GL_TEXTURE_2D);

 //3 башня

glTranslated(15,-20,-22);

glEnable(GL_TEXTURE_2D);  

glBindTexture(GL_TEXTURE_2D, kamen);

gluQuadricTexture (quadObj, GL_TRUE);

gluCylinder(quadObj, 2.5, 2.5,23, 50, 50);

glTranslated(0,0,22);

glEnable(GL_TEXTURE_2D);  

glBindTexture(GL_TEXTURE_2D, cherep);

gluQuadricTexture (quadObj, GL_TRUE);

glutSolidCone (3, 7, 50, 50);

glDisable(GL_TEXTURE_2D);

 //4 башня

glTranslated(1,20,-22);

glEnable(GL_TEXTURE_2D);  

glBindTexture(GL_TEXTURE_2D, kamen);

gluQuadricTexture (quadObj, GL_TRUE);

gluCylinder(quadObj, 2.5, 2.5,23, 50, 50);

glTranslated(0,0,22);

glEnable(GL_TEXTURE_2D);  

glBindTexture(GL_TEXTURE_2D, cherep);

gluQuadricTexture (quadObj, GL_TRUE);

glutSolidCone (3, 7, 50, 50);

glDisable(GL_TEXTURE_2D);

glPopMatrix();

glRotatef(270, 1, 0, 0);

 //фонарь1

   glPushMatrix();

glColor3d(0.7,0.7,0.5);

glTranslated(16 ,16,-9);

glEnable(GL_TEXTURE_2D);  

glBindTexture(GL_TEXTURE_2D, black);

gluQuadricTexture (quadObj, GL_TRUE);

glutSolidCone (0.6, 1.5, 50, 50);

gluCylinder(quadObj, 0.3, 0.3,18, 50, 50);

glDisable(GL_TEXTURE_2D);

glColor3d(1,0,0);

glTranslated(0 ,0,18);

auxSolidSphere(1.5);

glTranslated(0 ,0,-1.5);

auxSolidTorus(0.3,0.6);

   glPopMatrix();

 //фонарь2

glPushMatrix();

glColor3d(0,0,0);

glTranslated(16 ,-16,-9);

glEnable(GL_TEXTURE_2D);  

glBindTexture(GL_TEXTURE_2D, black);

gluQuadricTexture (quadObj, GL_TRUE);

glutSolidCone (0.6, 1.5, 50, 50);

gluCylinder(quadObj, 0.3, 0.3,18, 50, 50);

glDisable(GL_TEXTURE_2D);

glColor3d(10,0,0);

glTranslated(0 ,0,18);

auxSolidSphere(1.5);

glTranslated(0 ,0,-1.5);

auxSolidTorus(0.3,0.6);

   glPopMatrix();

gluDeleteQuadric(quadObj);//удаляем объект для создания фигур

}

//функция рисования сцены

void display (void)

{

 /* очищаем буфер кадра и буфер глубины */

glClearColor(0.08, 0.6, 0.9, 1);

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

glPushMatrix(); //сохранить текущие координаты

   gluLookAt(

   0.0f,0.0f,80.0f+cam, /* положение камеры */

   0.0f,0.0f,0.0f, /* центр сцены */

   0.0f,1.0f,0.0f);//положительное направление

 //координаты, изменяемые при повороте

glRotatef(xRot, 1.0f, 0.0f, 0.0f);

   glRotatef(yRot, 0.0f, 1.0f, 0.0f);

 

glRotated(250, 0, 1, 0);

Trava();

Rov();

Zamok();

glPopMatrix ();

  //выводим сцену на экран

  glFlush ();

}

// Вызывается при изменении пользователем размеров окна

void reshape(int w, int h)

{

GLfloat nRange = 120.0f;

 //устанавливаем размер области вывода равным размеру окна

glViewport (0, 0, (GLsizei) w, (GLsizei) h);

 //задаем матрицу проекции с учетом размеров окна

glMatrixMode (GL_PROJECTION);//включить режим работы с нужной матрицей

glLoadIdentity ();

gluPerspective( 40.0, /* угол зрения в градусах */

   (GLfloat)w/h, /* коэффициент сжатия окна */

   1,150.0);  /* расстояние до плоскостей отсечения */

glMatrixMode (GL_MODELVIEW);

 glLoadIdentity ();

}

int main()

{

  glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);

  glutInitWindowSize(1000,700);//определяет размер окна в пикселах

  glutCreateWindow("Курсовая работа Аминевой Нурии 09ВА1");

  

  glutSpecialFunc(SpecialKeys);//поворот

  glutReshapeFunc (reshape);//при изменении размеров окна

  init ();//основной свет

  glutDisplayFunc (display);//рисование изображения

  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);      // Выравнивание в *.bmp по байту

  travaImage = auxDIBImageLoad("trava2.bmp"); // Загрузка изображений в память

  kamenImage = auxDIBImageLoad("bash.bmp");

  kam2Image = auxDIBImageLoad("krosh.bmp");

  cherepImage = auxDIBImageLoad("cherep.bmp");

  dverImage = auxDIBImageLoad("dver.bmp");

  vodaImage = auxDIBImageLoad("vod.bmp");

  oknoImage = auxDIBImageLoad("okno.bmp");

  mostImage = auxDIBImageLoad("most.bmp");

  blackImage = auxDIBImageLoad("cvet.bmp");

  glGenTextures(1, &trava); // Создание идентификаторов для текстур

  glGenTextures(1, &kamen);

  glGenTextures(1, &kam2);

  glGenTextures(1, &cherep);

  glGenTextures(1, &dver);

  glGenTextures(1, &voda);

  glGenTextures(1, &most);

  glGenTextures(1, &black);

  glBindTexture(GL_TEXTURE_2D, kam2 );  // Начало описания свойств текстуры

  gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA,  // Создание уровней детализации и инициализация текстуры

 kam2Image->sizeX,

 kam2Image->sizeY,

 GL_RGB, GL_UNSIGNED_BYTE,

 kam2Image->data);

  glBindTexture(GL_TEXTURE_2D, kamen );  

 

  gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA,

 kamenImage->sizeX,

 kamenImage->sizeY,

 GL_RGB, GL_UNSIGNED_BYTE,

 kamenImage->data);

  glBindTexture(GL_TEXTURE_2D, cherep );  

 

  gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA,  

 cherepImage->sizeX,

 cherepImage->sizeY,

 GL_RGB, GL_UNSIGNED_BYTE,

 cherepImage->data);

  glBindTexture(GL_TEXTURE_2D, trava );  

 

  gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA,  

 travaImage->sizeX,

 travaImage->sizeY,

 GL_RGB, GL_UNSIGNED_BYTE,

 travaImage->data);

   glBindTexture(GL_TEXTURE_2D, dver );  

gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA,  

 dverImage->sizeX,

 dverImage->sizeY,

 GL_RGB, GL_UNSIGNED_BYTE,

 dverImage->data);

  glBindTexture(GL_TEXTURE_2D, voda );  

 

  gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA,  

 vodaImage->sizeX,

 vodaImage->sizeY,

 GL_RGB, GL_UNSIGNED_BYTE,

 vodaImage->data);

  glBindTexture(GL_TEXTURE_2D, okno );  

 

  gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA,  

 oknoImage->sizeX,

 oknoImage->sizeY,

 GL_RGB, GL_UNSIGNED_BYTE,

 oknoImage->data);

   glBindTexture(GL_TEXTURE_2D, most );  

 

  gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA,  

 mostImage->sizeX,

 mostImage->sizeY,

 GL_RGB, GL_UNSIGNED_BYTE,

 mostImage->data);

   glBindTexture(GL_TEXTURE_2D, black );    

  gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA,  

 blackImage->sizeX,

 blackImage->sizeY,

 GL_RGB, GL_UNSIGNED_BYTE,

 blackImage->data);

  glutMainLoop();//пока не будет вызвана данная функция, окно и его содержимое не будут отображены

  return 0;

}


main()

SpecialKeys

display ()

reshape()

Rov()

Zamok()

fonar_svet ()

Demo()

Init()

Trava()

oda()

ocna()

TimerFunc

Начало

time<40

cam += 1.0f;

time++;

 time++;

cam -= 1.0f;

time++;

glutTimerFunc(70, TimerFunc,1);

glutTimerFunc(70, TimerFunc,1);

time<80

time<250

yRot+=2;

glutTimerFunc(70, TimerFunc,1);

time++;

Конец


 

А также другие работы, которые могут Вас заинтересовать

59613. Сучасні технології навчання 81.5 KB
  Мета: повторити узагальнити та поглибити знання учнів про іменник удосконалювати вміння розпізнавати іменник серед інших частин мови формувати вміння добирати аргументи на доведення своєї думки розвивати...