Использование OpenGL (стр. 5 из 6)
Псевдокод измененной версии приведенной выше программы, которая отображает плавно анимированную графику, используя при этом двойную буферизацию, мог бы выглядеть следующим образом:
открыть_окно_в_режиме_двойной_буфериэации(); for (i = 0; i < 1000000; i++) {
очис1ить_окно();
нарисовать_кадр(i);
поменять_буферы_местами() ; }
3.2 Обновление отображаемой информации во время паузы
Для некоторых реализаций библиотеки OpenGL в дополнение к простой перемене мест отображаемого и рисуемого буферов, подпрограмма поменять_буферы_местами() ожидает, пока не закончится текущий период обновления отображаемой информации для того, чтобы информация из предыдущего буфера был отображена полностью. Эта подпрограмма также позволяет новому буферу быть полностью отображенным, начиная с начала. Принимая, что ваша вычислительная система обеспечивает обновление отображения 60 раз в секунду, получим, что максимальная скорость передачи кадров, которой можно достичь — 60 кадров в секунду (fps — framespersecond). Это означает, что, если все кадры могут быть очищены и нарисованы в течение 1/60 доли секунды, то ваша анимация при данной скорости будет воспроизводиться плавно.
В подобных системах часто бывает так, что кадр оказывается слишком сложным для того, чтобы быть нарисованным в течение 1/60 доли секунды, и, таким образом, каждый кадр отображается более одного раза. Если, например, требуется 1/45 доля секунды для того, чтобы нарисовать некоторый кадр, вы задаете скорость передачи кадров равной 30 fps, и тогда графическое изображение "простаивает" в течение 1/30 — 1/45 = 1/90 доли секунды на каждый кадр, или треть всего времени отображения.
Кроме того, частота обновления отображаемой видеоинформации является постоянной величиной, которая может иметь некоторые неожиданные последствия с точки зрения производительности. Например, при периоде обновления информации, отображаемой на мониторе, равной 1/60 доли секунды и при постоянной скорости передачи кадров вы можете работать со скоростями 60 fps, 30 fps, 20 fps, 15 fps, 12 fps и т. д. (60/1, 60/2, 60/3, 60/4, 60/5, и т. д.). Это означает, что если вы пишете прикладную программу и постепенно добавляете к ней новые функциональные возможности (предположим, что эта программа — имитатор полета, и вы добавляете наземный пейзаж), то сначала каждая новая добавляемая деталь не будет оказывать никакого эффекта на суммарную производительность — вы все равно получаете скорость передачи кадров, равную 60 fps. Затем, когда вы добавляете еще одну новую деталь, система уже не может нарисовать все это в течение 1/60 доли секунды, и анимация резко замедляется — с 60 fps до 30 fps, поскольку она пропускает первый возможный момент смены буферов. Аналогичная ситуация происходит, когда время рисования одного кадра становится больше, чем 1/30 доля секунды — скорость передачи кадров анимации скачком уменьшается от 30 fps до 20 fps.
Если сложность сцены такова, что время ее рисования оказывается близко к любому из этих "волшебных" интервалов времени (1/60 доля секунды, 2/60 доли секунды, 3/60 доли секунды и т. д. в рассматриваемом примере), то из-за наличия случайного изменения некоторые кадры будут идти немного быстрее, а некоторые — немного медленнее. В результате скорость передачи кадров становится непостоянной, что визуально может быть неприятно. В этом случае, если вы не можете упростить сцену так,
чтобы все кадры рисовались достаточно быстро, возможно, лучше было бы преднамеренно добавить крошечную задержку для того, чтобы иметь уверенность, что все кадры пропущены, задавая при этом постоянную, более медленную скорость передачи кадров. Если же кадры имеют существенно отличающуюся степень сложности, тогда, возможно, вам потребуется более сложный подход к решению этой проблемы.
Движение = Перерисовка изображения + Перестановка буферов
Структура реальных программ анимации не слишком отличается от приведенного описания. Обычно проще перерисовать буфер целиком с чистого листа для каждого кадра, чем выяснять, какие части кадра требуют изменения. Это положение особенно справедливо для таких прикладных программ, как трехмерные имитаторы полета, где самое малое изменение ориентации самолета изменяет позицию всего вида из окна пилотской кабины.
В большинстве видов анимации объекты на сцене просто перерисовываются с различными преобразованиями: перемещается точка наблюдения зрителя или автомобиль немного проезжает по дороге, или какой-нибудь объект поворачивается на небольшой угол. Если для операций, не связанных с рисованием, требуется существенный объем повторных вычислений, то достижимая скорость передачи кадров часто замедляется. Следует иметь в виду, однако, что для выполнения таких вычислений после выполнения подпрограммы поменять_буферы_местами() часто может использоваться время простоя.
Библиотека OpenGL не имеет в своем составе команды типа "поменять_буферы_-местами()", поскольку такая функциональная возможность могла бы быть доступна не для всех аппаратных средств и, в любом случае, ее реализация существенно зависит от используемой оконной системы. Например, если вы используете оболочку X Window System и обращаетесь к ней непосредственно, то можно было бы воспользоваться следующей подпрограммой из библиотеки GLX:
void glXSwapBuffers(Display *dpy, Window window);
(Эквивалентные подпрограммы для других оконных систем приведены в Приложении С.)
Если вы используете библиотеку GLUT, то вы, возможно, захотите вызвать следующую подпрограмму:
void glutSwapBuffers(void);
Пример 3 иллюстрирует использование подпрограммы glutSwapBuffers() для рисования вращающегося квадрата, как это показано на рисунке 3. Этот пример также демонстрирует то, как следует использовать библиотеку GLUT для контроля состояния устройства ввода данных, а также для включения и выключения функции простоя. В приведенном примере кнопки мыши включают и отключают вращение квадрата.
Пример 3 Программа с использованием двойной буферизации: double.c
#include <stdlib.h> #include <GL/glut.h>
static GLfloat spin = 0.0;
void init(void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel(GL_FLAT); } void display(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glPushMatrix();
glRotatef(spin, 0.0, 0.0, 1.0);
glColor3f(1.0, 1.0, 1.0);
glRectf(-25.0, -25.0, 25.0, 25.0);
glPopMatrix () ;
glutSwapBuffers () ; )
void spinDisplay(void)
{
spin = spin +2.0;
if (spin > 360.0)
spin = spin - 360.0;
glutPostRedisplay(); }
void reshape (int w, int h)
{
glViewport(0, 0, (GLsizei) w, (GLsizei) h) ;
glMatrixMode(GL_PROJECTION);
glLoadldentity();
glOrtho(-50.0, 50.0, -50.0, 50.0, -1.0, 1.0);
glMatrixMode(GL_MODELVIEW);
glLoadldentity();
void mouse(int button, int state, int x, int y) {
switch (button) {
case GLUT_LEFT_BUTTON:
if (state == GLUT_DOWN)
glutldleFunc(spinDisplay); break; case GLUT_MIDDLE_BUTTON:
if (state == GLUT_DOWN)
glutldleFunc(NULL); break; default:
break; } }
/*
Запросить режим отображения с двойной буферизацией.
Зарегистрировать функции обратного вызова по вводу данных от мыши*/
int main(int argc, char** argv) {
glutlnit(Sargc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowSize(250, 250);
glutInitWindowPosition(100, 100);
glutCreateWindow(argv[0]);
init<);
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMouseFunc(mouse);
glutMainLoop();
return 0 ; }
Пример программы, написанной на C, с применением OpenGL.
Программа визуализирует вращающийся куб. На куб наложены текстуры, возможно включение альфа-прозрачности во время визуализации.
#include <GL/glut.h>
#include <GL/glaux.h>
#include <GL/glu.h>
int tex[1];
float xtr,ytr,ztr;
float rotx,roty,rotz;
float LightAmbient[]= { 0.5f, 0.5f, 0.5f, 1.0f };
float LightPosition[]= { 0.0f, 0.0f, 5.0f, 1.0f };//позицияосвещения
float LightDiffuse[]= { 1.0f, 1.0f, 1.0f, 1.0f }; //рассеивание
void LoadTexs()//инициализация и загрузка текстур
{
AUX_RGBImageRec *tex1;
tex1 = auxDIBImageLoad("droy.bmp");
glGenTextures(1, &tex[0]);
glBindTexture(GL_TEXTURE_2D, tex[0]);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, 3, tex1->sizeX, tex1->sizeY, 0,
GL_RGB, GL_UNSIGNED_BYTE, tex1->data);
}
void init()
{
LoadTexs();//процедуразагрузкитекстуры
glColor4f(1.0f,1.0f,1.0f,0.5f);
glBlendFunc(GL_SRC_ALPHA,GL_ONE); // параметрысмешивания
glEnable(GL_TEXTURE_2D);
glClearColor (0.0, 0.0, 0.0, 0.0);// цветфона
glClearDepth(1.0);
glDepthFunc(GL_LESS);
glEnable(GL_DEPTH_TEST); //тестглубины
glShadeModel (GL_SMOOTH);
glTranslatef(0.0f,0.0f,-5.0f);
glLightfv(GL_LIGHT1,GL_AMBIENT,LightAmbient); //параметрыосвещения
glLightfv(GL_LIGHT1,GL_POSITION,LightPosition);
glLightfv(GL_LIGHT1,GL_DIFFUSE,LightDiffuse);
glEnable(GL_LIGHT1);//освещения
glEnable(GL_LIGHTING);
glEnable (GL_COLOR_MATERIAL);
glColorMaterial (GL_FRONT,GL_AMBIENT_AND_DIFFUSE);
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);//очисткабуфераглубины
glPushMatrix();//сохранениематрицы
glTranslatef(xtr,ytr,ztr);
glRotatef(rotx,1.0,0.0,0.0);
glRotatef(roty,0.0,1.0,0.0);
glRotatef(rotz,0.0,0.0,1.0);
glBegin(GL_QUADS);
glNormal3f( 0.0f, 0.0f, 1.0f);// Передняягрань
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f); // Низлево
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f); // Низправо
glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, 1.0f); // Верхправо
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f); // Верхлево
glNormal3f( 0.0f, 0.0f,-1.0f);// Задняягрань
glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f); // Низправо
glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f); // Верхправо
glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f); // Верхлево
glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f); // Низлево
glNormal3f( 0.0f, 1.0f, 0.0f);// Верхняягрань
glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f); // Верхлево
glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, 1.0f, 1.0f); // Низлево
glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, 1.0f, 1.0f); // Низправо