Разработка приложения с использованием OpenGL для динамического изображения трехмерной модели изображения

Размещено на http://www.allbest.ru/

1

[Введите текст]

Пензенский государственный университет

Кафедра "Информационно-вычислительные системы"

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

«Компьютерная графика»

Тема: Разработка приложения с использованием OpenGL для динамического изображения трехмерной модели изображения

2014



Введение

Сегодня трехмерная компьютерная графика нашла широкое распространение и применение в повседневной жизни. Ученые используют компьютерную графику для анализа результатов моделирования. Инженеры и архитекторы используют трехмерную графику для создания виртуальных моделей. Кинематографы создают удивительные спецэффекты или полностью анимированные фильмы. В последние годы широкое распространение получили также компьютерные игры, максимально использующие трехмерную графику для создания виртуальных миров.

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

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

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

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

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

В заключительной части приведено описание создания пользовательского интерфейса программы в Lazarus, а в приложении - текст программы.

1. Анализ предметной области

Библиотека OpenGL предназначена для моделирования компьютерной графики на высоком уровне, и является программным интерфейсом к аппаратному обеспечению. Главное назначение библиотеки - преобразовывать 2-х и 3- х мерные объекты в специальный формат в специальном буфере. Эти объекты описываются как последовательности точек в пространстве, которые определяют геометрические объекты, или пикселов, которые определяют изображения.

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

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



2. Техническое задание

2.1 Основание для разработки

Программа разрабатывается на основании задания на курсовое проектирование по дисциплине «Компьютерная графика». Задание утверждено заведующим кафедрой ИВС Пензенского государственного университета Косниковым Ю.Н. и выдано доцентом кафедры ИВС Стариковой А.Ю.

2.2 Назначение разработки

Данное приложение предназначено для демонстрации возможностей библиотеки OpenGL и для реализации имитации движения заданного графического примитива в пространстве.

2.3 Требования к программе

2.3.1 Требования к функциональным характеристикам

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

2.3.2 Требования к составу и параметрам технических средств

Программа предназначена для работы на IBM-совместимых персональных компьютерах, имеющих следующие минимальные характеристики:

Оперативная память 1Гб;

Операционная система Windows XP;

Процессор Intel Pentium 3;

Объем графической памяти 128 Мб.

2.3.3 Требования к информационной и программной совместимости

Так как программа должна быть написана на языке программирования Lazarus, ее требуется разрабатывать в объектно-ориентированной среде Lazarus.

2.4 Требования к программной документации

Разрабатываемая программа должна сопровождаться следующими программными документами:

- Описание программы;

- Описание применения;

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

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

3.1 Общие сведения

Для текстурирования примитивов и фона потребуется 3 варианта текстур в формате .png. Для включения текстур в проект требуется дополнительная библиотека, реализующая функции преобразования и добавления текстуры в проект. Данные функции реализованы в библиотеке BMP. Остальные функции работы с примитивами уже реализованы в библиотеке OpenGL.

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

Приложение реализует имитацию движения графических примитивов по заданной траектории.

3.3 Описание логической структуры

Программа состоит из модуля exampleform.pp- содержащий исходный код программы, текстуры, и служебных файлов проекта.

Выполним необходимые действия для создания программы по шагам.

Для отрисовки треугольников использовалась команда из библиотеки OpenGL - GL_LINE_LOOP.

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

Для получения нескольких одинаковых изображений было создано 3 дисплейных списка:

ParticleList:=glGenLists(1);

glNewList(ParticleList, GL_COMPILE); // лист для рисования точки

glBindTexture(GL_TEXTURE_2D, textures[0]);

glBegin(GL_TRIANGLE_STRIP);

glNormal3f( 0.0, 0.0, 1.0);

glTexCoord2f( 1.0, 1.0); glVertex3f(+0.025, +0.025, 0);

glTexCoord2f( 0.0, 5.0); glVertex3f(-0.025, +0.025, 0);

glTexCoord2f( 1.0, 0.0); glVertex3f(+0.025, -0.025, 0);

glTexCoord2f( 0.0, 0.0); glVertex3f(-0.025, -0.025, 0);

glEnd;

glEndList; В программу добавил команды сдвига и поворота системы координат.

Провел текстурирование сцены. Залил фон текстурой «texture2.png».

В программу заготовку ввел команды подготовки и наложения текстур на объекты сцены.

Для того чтобы наложить текстуру поверх фигуры построенной с помощью GL_LINE_LOOP и GL_QUADS, создана фигура с соответствующими текстурными координатами.

Задал соответствующие координаты текстур для объектов (Рисунок 2 Приложение Б).

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

Установил интервал таймера = 16, чтобы достичь оптимальной плавности движения.

Для вращения фигуры по собственной эллипсоидной траектории в пространстве, после установки начального положения фигур, с помощью математических операций происходит определение новых точек, согласно которым объект будет перемещаться в сцене. (Рисунок 3 Приложение Б).

3.4 Используемые технические средства

Работа программы обеспечивается на вычислительной машине с нижеприведёнными минимальными характеристиками:

Оперативная память 1Гб;

Операционная система Windows XP;

Процессор Intel Pentium 3;

Объем графической памяти 128 Мб.

3.5 Вызов и загрузка

Запуск программы осуществляется при открытии файла openglcontrol.exe.

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



4. Программа и методика испытаний

4.1 Объект испытаний

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

4.2 Цель испытаний

Целью испытания является проверка работоспособности и надежности программы.

4.3 Требования к программе

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

4.4 Требования к программной документации

Состав программной документации, предъявляемой на испытания:

Техническое задание;

Требования к программе;

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

Описание применения;

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



4.5 Средства и порядок испытаний

Работа программы обеспечивается на вычислительной машине с нижеприведёнными минимальными характеристиками:

Оперативная память 1Гб;

Операционная система Windows XP;

Процессор Intel Pentium 3;

Объем графической памяти 128 Мб.

Программа разработана в среде Lazarus работающей под управлением операционной системы Windows 7.

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

а) запустить программу на выполнение;

б) сравнить реакцию программы с ожидаемым результатом;

в) сделать выводы по результатам тестирования о работоспособности программы.

Результаты работы программы приведены в приложении Б.

5. Описание применения

5.1 Назначение программы

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

5.2 Условия применения

Работа программы обеспечивается на вычислительной машине с нижеприведёнными минимальными характеристиками:

Оперативная память 1Гб;

Операционная система Windows XP;

Процессор Intel Pentium 3;

Объем графической памяти 128 Мб.

Программа разработана в среде Lazarus работающей под управлением операционной системы Windows 7.

5.3 Описание задачи

Для пересчёта координат используется параметрическое уравнение эллипса. При срабатывании таймера через определенный интервал времени происходит перерасчет координат.

5.4 Входные и выходные данные

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

Заключение

При выполнении курсового проекта были выполнены следующие работы:

Анализ предметной области.

Анализ требований к программе.

Проектирование программных средств.

Реализация программы.

Тестирование программы.

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

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

Список использованных источников

1. Ву М., Девис Т., Дж. Нейдер, Шрайнер Д. OpenGL. Руководство по программированию./пер. с англ. - СПб.: ”Питер” 2006.

2. Косников Ю.Н. Геометрические преобразования в компьютерной графике. Конспект лекций. - Пенза.: "ПГУ", 2010.

3. Краснов М.В. OpenGL графика в проектах Delphi. 2002.

4. Тихомиров Ю.В.Программирование трехмерной графики. - СПб.:”БХВ” 1998.



Приложение А

Файл ExampleForm.pp

unit ExampleForm;

{$mode objfpc}{$H+}

interface

uses

Classes, SysUtils, FileUtil, LCLProc, Forms, LResources, Buttons,

StdCtrls, Dialogs, Graphics, IntfGraphics, GL, FPimage, OpenGLContext;

const

GL_CLAMP_TO_EDGE = $812F;

type

TglTexture = class

public

Width,Height: longint;

Data : pointer;

destructor Destroy; override;

end;

type

{ TExampleForm }

TExampleForm = class(TForm)

OpenGLControl1: TOpenGLControl;

ExitButton1: TButton;

LightingButton1: TButton;

BlendButton1: TButton;

MoveCubeButton1: TButton;

MoveBackgroundButton1: TButton;

RotateZButton1: TButton;

RotateZButton2: TButton;

HintLabel1: TLabel;

procedure IdleFunc(Sender: TObject; var Done: Boolean);

procedure FormResize(Sender: TObject);

procedure ExitButton1Click(Sender: TObject);

procedure LightingButton1Click(Sender: TObject);

procedure BlendButton1Click(Sender: TObject);

procedure MoveCubeButton1Click(Sender: TObject);

procedure MoveBackgroundButton1Click(Sender: TObject);

procedure RotateZButton1Click(Sender: TObject);

procedure RotateZButton2Click(Sender: TObject);

procedure OpenGLControl1Paint(Sender: TObject);

procedure OpenGLControl1Resize(Sender: TObject);

public

constructor Create(TheOwner: TComponent); override;

destructor Destroy; override;

procedure LoadTextures;

private

AreaInitialized: boolean;

end;

TParticle = class

x, y, z: GLfloat;

vx, vy, vz: GLfloat;

life: single;

end;

TParticleEngine = class

xspawn: GLfloat;

Particle: array [1..2001] of TParticle;

procedure MoveParticles;

procedure DrawParticles;

procedure Start;

public

constructor Create;

destructor Destroy; override;

private

procedure RespawnParticle(i: integer);

end;

var AnExampleForm: TExampleForm;

front, left1: GLuint;

rx, ry, rz, rrx, rry, rrz: single;

LightAmbient : array [0..3] of GLfloat;

checked, blended, lighted, ParticleBlended, MoveCube, MoveBackground: boolean;

textures : array [0..2] of GLuint; // Storage For 3 Textures

MyglTextures : array [0..2] of TglTexture;

lightamb, lightdif, lightpos, light2pos, light2dif,

light3pos, light3dif, light4pos, light4dif, fogcolor: array [0..3] of GLfloat;

ParticleEngine: TParticleEngine;

ParticleList, CubeList, BackList: GLuint;

var direction: boolean;

timer: single;

LastMsecs: integer;

function LoadFileToMemStream(const Filename: string): TMemoryStream;

function LoadglTexImage2DFromPNG(PNGFilename:string;

Image: TglTexture): boolean;

implementation

function LoadFileToMemStream(const Filename: string): TMemoryStream;

var FileStream: TFileStream;

begin

Result:=TMemoryStream.Create;

try

FileStream:=TFileStream.Create(UTF8ToSys(Filename), fmOpenRead);

try

Result.CopyFrom(FileStream,FileStream.Size);

Result.Position:=0;

finally

FileStream.Free;

end;

except

Result.Free;

Result:=nil;

end;

end;

function LoadglTexImage2DFromPNG(PNGFilename: string; Image: TglTexture

): boolean;

var

png: TPortableNetworkGraphic;

IntfImg: TLazIntfImage;

y: Integer;

x: Integer;

c: TFPColor;

p: PByte;

begin

Result:=false;

png:=TPortableNetworkGraphic.Create;

IntfImg:=nil;

try

png.LoadFromFile(PNGFilename);

IntfImg:=png.CreateIntfImage;

Image.Width:=IntfImg.Width;

Image.Height:=IntfImg.Height;

GetMem(Image.Data,Image.Width*Image.Height * 3);

p:=PByte(Image.Data);

for y:=0 to IntfImg.Height-1 do begin

for x:=0 to IntfImg.Width-1 do begin

c:=IntfImg.Colors[x,y];

p^:=c.red shr 8;

inc(p);

p^:=c.green shr 8;

inc(p);

p^:=c.blue shr 8;

inc(p);

end;

end;

finally

png.Free;

IntfImg.Free;

end;

Result:=true;

end;

{ TExampleForm }

constructor TExampleForm.Create(TheOwner: TComponent);

begin

inherited CreateNew(TheOwner);

if LazarusResources.Find(ClassName)=nil then begin

SetBounds((Screen.Width-800) div 2,(Screen.Height-600) div 2,800,600);

Caption:='LCL example for the TOpenGLControl';

Application.OnIdle:=@IdleFunc;

OnResize:=@FormResize;

blended:=false;

lighted:=false;

ParticleEngine:=TParticleEngine.Create;

ExitButton1:=TButton.Create(Self);

with ExitButton1 do begin

Name:='ExitButton1';

Parent:=Self;

SetBounds(320,10,80,25);

Caption:='Exit';

OnClick:=@ExitButton1Click;

end;

MoveCubeButton1:=TButton.Create(Self);

with MoveCubeButton1 do begin

Name:='MoveCubeButton1';

Parent:=Self;

SetBounds(320,10,80,25);

Caption:='Move';

Checked:=false;

OnClick:=@MoveCubeButton1Click;

end;

// resize the components first, because the opengl context needs some time to setup

FormResize(Self);

OpenGLControl1:=TOpenGLControl.Create(Self);

with OpenGLControl1 do begin

Name:='OpenGLControl1';

Parent:=Self;

SetBounds(10,90,380,200);

OnPaint:=@OpenGLControl1Paint;

OnResize:=@OpenGLControl1Resize;

end;

end;

LoadTextures;

// now resize

FormResize(Self);

end;

destructor TExampleForm.Destroy;

var i: integer;

begin

for i:=0 to 2 do begin

Textures[i]:=0;

FreeAndNil(MyglTextures[i]);

end;

FreeAndNil(ParticleEngine);

inherited Destroy;

end;

procedure TExampleForm.LoadTextures;

procedure LoadglTexture(Filename:string; Image:TglTexture);

begin

Filename:=ExpandFileNameUTF8(Filename);

if not LoadglTexImage2DFromPNG(Filename,Image) then begin

MessageDlg('File not found',

'Image file not found: '+Filename,

mtError,[mbOk],0);

raise Exception.Create('Image file not found: '+Filename);

end;

end;

var

i: Integer;

begin

for i:=0 to 2 do begin

Textures[i]:=0;

MyglTextures[i]:=TglTexture.Create;

end;

{loading the texture and setting its parameters}

LoadglTexture('data/particle.png',MyglTextures[0]);

LoadglTexture('data/texture2.png',MyglTextures[1]);

LoadglTexture('data/texture3.png',MyglTextures[2]);

end;

// --------------------------------------------------------------------------

// Particle Engine

// --------------------------------------------------------------------------

constructor TParticleEngine.Create;

var i: integer;

begin

for i:=1 to 2001 do Particle[i]:=TParticle.Create;

xspawn:=0;

end;

destructor TParticleEngine.Destroy;

var i: integer;

begin

for i:=1 to 2001 do FreeAndNil(Particle[i]);

inherited Destroy;

end;

procedure TParticleEngine.DrawParticles;

var i: integer;

begin

for i:=1 to 2001 do begin

glPushMatrix;

glTranslatef(Particle[i].x, Particle[i].y, Particle[i].z);

glCallList(ParticleList);

glPopMatrix;

end;

end;

procedure TParticleEngine.RespawnParticle(i: integer);

begin

if (xspawn>2) and (direction=true) then direction:=false;

if (xspawn<-2) and (direction=false) then direction:=true;

if direction then

xspawn:=xspawn+0.0002*(timer/10)

else

xspawn:=xspawn-0.0002*(timer/10);

Particle[i].x:=xspawn;

Particle[i].y:=-0.5;

Particle[i].z:=0;

Particle[i].vx:=-0.005+GLFloat(random(2000))/200000;

Particle[i].vy:=0.035+GLFloat(random(750))/100000;

Particle[i].vz:=-0.005+GLFloat(random(2000))/200000;

Particle[i].life:=GLFloat(random(1250))/1000+1;

end;

procedure TParticleEngine.MoveParticles;

var i: integer;

begin

for i:=1 to 2001 do begin

if Particle[i].life>0 then begin

Particle[i].life:=Particle[i].life-0.01*(timer/10);

Particle[i].x:=Particle[i].x+Particle[i].vx*(timer/10);

Particle[i].vy:=Particle[i].vy-0.00035*(timer/10); // gravity

Particle[i].y:=Particle[i].y+Particle[i].vy*(timer/10);

Particle[i].z:=Particle[i].z+Particle[i].vz*(timer/10);

end else begin

RespawnParticle(i);

end;

end;

end;

procedure TParticleEngine.Start;

var i: integer;

begin

for i:=1 to 2001 do begin

RespawnParticle(i);

end;

end;

// ---------------------------------------------------------------------------

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

// ---------------------------------------------------------------------------

procedure TExampleForm.IdleFunc(Sender: TObject; var Done: Boolean);

begin

OpenGLControl1.Invalidate;

//OpenGLControl1Paint(Self);

Done:=false; // tell lcl to handle messages and return immediatly

end;

// --------------------------------------------------------------------------

// Buttons

// --------------------------------------------------------------------------

procedure TExampleForm.LightingButton1Click(Sender: TObject);

begin

if lighted then glDisable(GL_LIGHTING) else glEnable(GL_LIGHTING);

lighted:=not lighted;

OpenGLControl1.Invalidate;// not need

end;

procedure TExampleForm.BlendButton1Click(Sender: TObject);

begin

blended:=not blended;

OpenGLControl1.Invalidate;

end;

procedure TExampleForm.MoveCubeButton1Click(Sender: TObject);

begin

MoveCube:=not MoveCube;

OpenGLControl1.Invalidate;

end;

procedure TExampleForm.MoveBackgroundButton1Click(Sender: TObject);

begin

MoveBackground:=not MoveBackground;

OpenGLControl1.Invalidate;

end;

procedure TExampleForm.RotateZButton1Click(Sender: TObject);

begin

ParticleEngine.Start;

OpenGLControl1.Invalidate;

end;

procedure TExampleForm.RotateZButton2Click(Sender: TObject);

begin

ParticleBlended:=not ParticleBlended;

OpenGLControl1.Invalidate;

end;

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

// ---------------------------------------------------------------------------

procedure TExampleForm.FormResize(Sender: TObject);

begin

if OpenGLControl1<>nil then

OpenGLControl1.SetBounds(10, 30, Width-120, Height-40);

ExitButton1.SetBounds(Width-90, 5, 80, 25);

MoveCubeButton1.SetBounds(Width-90, 50, 80, 25);

end;

procedure TExampleForm.ExitButton1Click(Sender: TObject);

begin

Close;

end;

procedure TExampleForm.OpenGLControl1Paint(Sender: TObject);

procedure myInit;

begin

{init lighting variables}

{ambient color}

lightamb[0]:=0.5;

lightamb[1]:=0.5;

lightamb[2]:=0.5;

lightamb[3]:=1.0;

{diffuse color}

lightdif[0]:=0.8;

lightdif[1]:=0.0;

lightdif[2]:=0.0;

lightdif[3]:=1.0;

{diffuse position}

lightpos[0]:=0.0;

lightpos[1]:=0.0;

lightpos[2]:=3.0;

lightpos[3]:=1.0;

{diffuse 2 color}

light2dif[0]:=0.0;

light2dif[1]:=0.8;

light2dif[2]:=0.0;

light2dif[3]:=1.0;

{diffuse 2 position}

light2pos[0]:=3.0;

light2pos[1]:=0.0;

light2pos[2]:=3.0;

light2pos[3]:=1.0;

{diffuse 3 color}

light3dif[0]:=0.0;

light3dif[1]:=0.0;

light3dif[2]:=0.8;

light3dif[3]:=1.0;

{diffuse 3 position}

light3pos[0]:=-3.0;

light3pos[1]:=0.0;

light3pos[2]:=0.0;

light3pos[3]:=1.0;

{fog color}

fogcolor[0]:=0.5;

fogcolor[1]:=0.5;

fogcolor[2]:=0.5;

fogcolor[3]:=1.0;

end;

const GLInitialized: boolean = false;

procedure InitGL;

var

i: Integer;

begin

if GLInitialized then exit;

GLInitialized:=true;

{setting lighting conditions}

glLightfv(GL_LIGHT0,GL_AMBIENT,lightamb);

glLightfv(GL_LIGHT1,GL_AMBIENT,lightamb);

glLightfv(GL_LIGHT2,GL_DIFFUSE,lightdif);

glLightfv(GL_LIGHT2,GL_POSITION,lightpos);

glLightfv(GL_LIGHT3,GL_DIFFUSE,light2dif);

glLightfv(GL_LIGHT3,GL_POSITION,light2pos);

glLightfv(GL_LIGHT4,GL_POSITION,light3pos);

glLightfv(GL_LIGHT4,GL_DIFFUSE,light3dif);

glEnable(GL_LIGHT0);

glEnable(GL_LIGHT1);

glEnable(GL_LIGHT2);

glEnable(GL_LIGHT3);

glEnable(GL_LIGHT4);

glGenTextures(3, @textures[0]);

for i:=0 to 2 do begin

glBindTexture(GL_TEXTURE_2D, Textures[i]);

glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);

glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE);

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,MyglTextures[i].Width,MyglTextures[i].Height,0

,GL_RGB,GL_UNSIGNED_BYTE,MyglTextures[i].Data);

end;

glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);

{instead of GL_MODULATE you can try GL_DECAL or GL_BLEND}

glEnable(GL_TEXTURE_2D); // enables 2d textures

glClearColor(0.0,0.0,0.0,1.0); // sets background color

glClearDepth(1.0);

glDepthFunc(GL_LEQUAL); // the type of depth test to do

glEnable(GL_DEPTH_TEST); // enables depth testing

glShadeModel(GL_SMOOTH); // enables smooth color shading

{blending}

glColor4f(1.0,1.0,1.0,0.5); // Full Brightness, 50% Alpha ( NEW )

glBlendFunc(GL_SRC_ALPHA, GL_ONE);

glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);

{}

glHint(GL_LINE_SMOOTH_HINT,GL_NICEST);

glHint(GL_POLYGON_SMOOTH_HINT,GL_NICEST);

glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);

// creating display lists

ParticleList:=glGenLists(1);

glNewList(ParticleList, GL_COMPILE);

glBindTexture(GL_TEXTURE_2D, textures[0]);

glBegin(GL_TRIANGLE_STRIP);

glNormal3f( 0.0, 0.0, 1.0);

glTexCoord2f( 1.0, 1.0); glVertex3f(+0.025, +0.025, 0);

glTexCoord2f( 0.0, 5.0); glVertex3f(-0.025, +0.025, 0);

glTexCoord2f( 1.0, 0.0); glVertex3f(+0.025, -0.025, 0);

glTexCoord2f( 0.0, 0.0); glVertex3f(-0.025, -0.025, 0);

glEnd;

glEndList;

BackList:=ParticleList+1;

glNewList(BackList, GL_COMPILE);

glBindTexture(GL_TEXTURE_2D, textures[2]);

glBegin(GL_QUADS);

{Front Face}

glNormal3f( 0.0, 0.0, 1.0);

glTexCoord2f( 1.0, 1.0); glVertex3f( 2.5, 2.5, 2.5);

glTexCoord2f( 0.0, 1.0); glVertex3f(-2.5, 2.5, 2.5);

glTexCoord2f( 0.0, 0.0); glVertex3f(-2.5,-2.5, 2.5);

glTexCoord2f( 1.0, 0.0); glVertex3f( 2.5,-2.5, 2.5);

{Back Face}

glNormal3f( 0.0, 0.0,-1.0);

glTexCoord2f( 0.0, 1.0); glVertex3f( 2.5, 2.5,-2.5);

glTexCoord2f( 0.0, 0.0); glVertex3f( 2.5,-2.5,-2.5);

glTexCoord2f( 1.0, 0.0); glVertex3f(-2.5,-2.5,-2.5);

glTexCoord2f( 1.0, 1.0); glVertex3f(-2.5, 2.5,-2.5);

{Left Face}

glNormal3f(-1.0, 0.0, 0.0);

glTexCoord2f( 1.0, 1.0); glVertex3f(-2.5, 2.5, 2.5);

glTexCoord2f( 0.0, 1.0); glVertex3f(-2.5, 2.5,-2.5);

glTexCoord2f( 0.0, 0.0); glVertex3f(-2.5,-2.5,-2.5);

glTexCoord2f( 1.0, 0.0); glVertex3f(-2.5,-2.5, 2.5);

{Right Face}

glNormal3f( 1.0, 0.0, 0.0);

glTexCoord2f( 1.0, 1.0); glVertex3f( 2.5, 2.5,-2.5);

glTexCoord2f( 0.0, 1.0); glVertex3f( 2.5, 2.5, 2.5);

glTexCoord2f( 0.0, 0.0); glVertex3f( 2.5,-2.5, 2.5);

glTexCoord2f( 1.0, 0.0); glVertex3f( 2.5,-2.5,-2.5);

{Top Face}

glNormal3f( 0.0, 1.0, 0.0);

glTexCoord2f( 1.0, 1.0); glVertex3f( 2.5, 2.5,-2.5);

glTexCoord2f( 0.0, 1.0); glVertex3f(-2.5, 2.5,-2.5);

glTexCoord2f( 0.0, 0.0); glVertex3f(-2.5, 2.5, 2.5);

glTexCoord2f( 1.0, 0.0); glVertex3f( 2.5, 2.5, 2.5);

{Bottom Face}

glNormal3f( 0.0,-1.0, 0.0);

glTexCoord2f( 1.0, 1.0); glVertex3f(-2.5,-2.5,-2.5);

glTexCoord2f( 0.0, 1.0); glVertex3f( 2.5,-2.5,-2.5);

glTexCoord2f( 0.0, 0.0); glVertex3f( 2.5,-2.5, 2.5);

glTexCoord2f( 1.0, 0.0); glVertex3f(-2.5,-2.5, 2.5);

glEnd;

glEndList;

CubeList:=BackList+1;

glNewList(CubeList, GL_COMPILE);

glBindTexture(GL_TEXTURE_2D, textures[1]);

glBegin(GL_TRIANGLES);

{Back Face}

glNormal3f( 0.0, 0.0,-1.0);

glTexCoord2f( 0.0, 0.0); glVertex3f( 0.5,-0.5,-0.5);

glTexCoord2f( 1.0, 0.0); glVertex3f(-0.5,-0.5,-0.5);

glTexCoord2f( 1.0, 1.0); glVertex3f(-0.5, 0.5,-0.5);

glEnd;

glBindTexture(GL_TEXTURE_2D, textures[1]);

glBegin(GL_TRIANGLES);

{Left Face}

glNormal3f(-1.0, 0.0, 0.0);

glTexCoord2f( 0.0, 1.0); glVertex3f(-0.5, 0.5,-0.5);

glTexCoord2f( 0.0, 0.0); glVertex3f(-0.5,-0.5,-0.5);

glTexCoord2f( 1.0, 0.0); glVertex3f(-0.5,-0.5, 0.5);

glEnd;

glBindTexture(GL_TEXTURE_2D, textures[2]);

glEndList;

end;

var

CurTime: TDateTime;

MSecs: integer;

begin

if OpenGLControl1.MakeCurrent then

begin

if not AreaInitialized then begin

myInit;

InitGL;

glMatrixMode (GL_PROJECTION); { prepare for and then }

glLoadIdentity (); { define the projection }

glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0); { transformation }

glMatrixMode (GL_MODELVIEW); { back to modelview matrix }

glViewport (0, 0, OpenGLControl1.Width, OpenGLControl1.Height);

{ define the viewport }

AreaInitialized:=true;

end;

CurTime:=Now;

MSecs:=round(CurTime*86400*1000) mod 1000;

if MSecs<0 then MSecs:=1000+MSecs;

timer:=msecs-LastMsecs;

if timer<0 then timer:=1000+timer;

LastMsecs:=MSecs;

// ParticleEngine.MoveParticles;

glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);

glLoadIdentity; { clear the matrix }

glTranslatef (0.0, 0.0,-3.0); // -2.5); { viewing transformation }

{rotate}

glPushMatrix;

// draw background

if blended then begin

glEnable(GL_BLEND);

glDisable(GL_DEPTH_TEST);

end;

glCallList(BackList);

glPopMatrix;

glPushMatrix;

if MoveCube then begin

// rx:=rx+0.5*(timer/10);

ry:=ry+0.025*timer;

// rz:=rz+0.8*(timer/10);

end;

// glRotatef(rx,1.0,0.0,0.0);

glRotatef(ry,0.0,1.0,0.0);

// glRotatef(rz,0.0,0.0,1.0);

// draw cube

glCallList(CubeList);

if blended then begin

glDisable(GL_BLEND);

glEnable(GL_DEPTH_TEST);

end;

glPopMatrix;

OpenGLControl1.SwapBuffers;

end;

end;

procedure TExampleForm.OpenGLControl1Resize(Sender: TObject);

begin

if (AreaInitialized)

and OpenGLControl1.MakeCurrent then

glViewport (0, 0, OpenGLControl1.Width, OpenGLControl1.Height);

end;

{ TglTexture }

destructor TglTexture.Destroy;

begin

if Data<>nil then FreeMem(Data);

inherited Destroy;

end;

end.



Приложение Б

Рисунок 1 - Расстановка объектов в сцене

программа испытание данная

Рисунок 2 - Текстурирование объектов



Рисунок 3 - Движение объектов относительно общей стороны в пространстве

Размещено на Allbest.ru