«Интегрированная среда разработки приложений Lazarus» 10класс

Информатика 10 класс. Тема: «Интегрированная среда разработки приложений Lazarus»

Цели:
1) проверить знания учащихся по пройденным темам;
2) дать понятие об интегрированной среде разработки приложений Lazarus;
3) научить открывать, запускать и сохранять проект;
4) познакомить учащихся с интерфейсом программы, с планом разработки программы.

Задачи урока:
 Учебная – научиться работать в ИСРП Lazarus.
 Развивающая – развитие интереса к визуальному программированию, развитие памяти, внимательности.
 Воспитательная – воспитание познавательного интереса, логического мышления

Tип урока: комбинированный.
Методы обучения: словесный, наглядно-демонстрационный, практический.
ТСО: презентация, проектор, персональные компьютеры, приложение Lazarus.

Ход урока:
I. Организация класса к уроку
II. Актуализация прежних знаний
1. Что называется методом программирования?
2. Назовите известные методы и технологии программирования.
3. Как называется метод программирования, в котором используются объекты?
4. В приложении Word существует класс объектов Документ. Опишите его свойства, методы, события.
5. Выберите любой объект на экране компьютера (ярлык, окно, кнопка) и опишите его свойства, методы, события.

Выполнение тестовых заданий. (Приложение 1). Взаимопроверка.

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

IV. Изучение нового материала
Lazarus - свободная среда быстрой разработки программного обеспечения для компилятора Free Pascal, аналогичную Delphi. Данный проект базируется на оригинальной кроссплатформенной библиотеке визуальных компонентов Lazarus Component Library (LSL), также совместимых с Visual Component Library (VCL) – объектно-ориентированная библиотека для разработки программного обеспечения.

Кроссплатформенное программное обеспечение – программное обеспечение, работающее более чем на одной аппаратной платформе и/или операционной системе.

Free Pascal - кроссплатформенный язык на уровне компиляции, т.е. для него существуют компиляторы под различные платформы. Таким образом, разработанные приложения могут функционировать практически под любой ОС.
Все что мы видим на экране во время работы различных приложений, все элементы (кнопки, бегунки, меню и т.п.) можно реализовать в Lazarus.
В Lazarus используется технология визуального программирования, т.е. пользователь оформляет будущую программу и видит результаты своей работы еще до запуска самой программы.
Визуальное программирование – способ создания программы путем манипулирования графическими объектами вместо написания ее текста.

Процесс создания приложения можно разделить на следующие этапы:
1. Формирование окна программы – расположение необходимых элементов, задание размеров, изменение свойств;
2. Написание программного кода, описание свойств элементов, доступных только во время работы приложения, описание реакций на событие появления окна, нажатие на кнопку и других;
3. Отладка программы.

Запуск программы
Пуск→Все программы→Lazarus→Lazarus – запускается оболочка создания приложений называемая интегрированной средой разработки IDE (Integrated Development Enviroment).

Интерфейс программы:
Проект Lazarus представляет собой набор программных единиц — модулей.

1. Главное окно.
Здесь располагаются меню, панель инструментов и палитра компонентов.
На палитре компонентов, представляющую множество тематических вкладок, располагаются визуальные и невизуальные компоненты будущей программы.
Невизуальные компоненты видны только на первом этапе создания приложения – при проектировании.
Панель инструментов находится под главным меню и содержит наборы компонентов, заготовок будущих объектов. Для удобства эти компоненты объединены в различные группы — стандартные компоненты (Standart), расширенные компоненты (Additional), диалоги (Dialogs) и другие.
Главное окно остается открытым все время работы IDE. Закрывая его, мы закрываем Lazarus и все открытые в нем окна.

2. Окно Инспектор объектов содержит 4 страницы:
1. Свойства – отображает доступные свойства выбранного компонента. В левой колонке список существующих для выделенного объекта свойства, в правой – текущие значения по умолчанию. Общие для большинства компонентов свойства: цвет – Color, имя – Name, размер (Width – ширина, Height – высота) и т.п. Например, для будущего окна вашего приложения (формы) свойство Name имеет значение Form1, и его можно изменить в Инспекторе объектов
2. События – содержит возможные обработчики событий для выбранного компонента. В левой колонке расположены названия события, в правой соответствующие процедуры. Реакция на событие – это результат произошедшего системного события, например, щелчок мыши, нажатие на кнопку.. Например если пользователь выполняет клик по кнопке, производится копирование файла.
3. Избранное.
4. Ограничения.

3. Окно Редактор кода. На момент первого запуска имеет заголовок Unit 1. В редакторе кода могут быть открытыми сразу несколько файлов, размещенных на отдельных страницах.
В окне кода пишется текстовая часть программы, и само окно похоже на обычные текстовый редактор.
Строки пронумерованы, все служебные слова выделяются жирным цветом, знаки препинания становятся красными, строки с ошибками выделяются коричневым цветом, комментарии могут заключаются в {} или (**), начинаться с // и выделяются синим.
Текст программы разбивается на процедуры и функции, которые работают независимо. Основная работа программиста происходит именно здесь.

4. Окно Проектировщик форм. При запуске Lazarus автоматически предлагает пользователю новый проект, окно под названием Form 1, и назначает его главным окном. Перенося на него элементы из палитры компонетов, тем самым оформляете его. Главное окно в проекте может быть только одно, все другие создаваемые окна будут дочерними.

5. Окно Сообщения. Это окно выводит диагностические сообщения, сообщения об ошибке, сообщения об удачной компиляции и др.

Для создания нового проекта выполните команду Файл→Создать→Проект и выберите Приложение, Или выполните команду Проект →Создать проект.

Для сохранения проекта Файл→Сохранить все. Каждый проект сохраняется в отдельный каталог.
Файлы проекта:
Модуль программы - Unit1.pas
Проект – project1.lpi
Файл Unit.lfm – файл с данными о проектировщике форм
Резервные копии файлов – папка backup

Запуск Приложения на выполнение можно сделать нажатием клавиши F9, или через пункт в меню Запуск или выбором соответствующей кнопки на панели инструментов

V. Закрепление.
Вопросы и задания.
1. В чем принцип визуального программирования?
2. Назовите основные окна программы.
3. Назовите этапы создания приложения.
4. Как сохраняются проекты?
5. Как запускается созданное приложение?

VI. Практическое задание:
1. Запустите программу Lazarus с компьютера.
2. Измените имя формы «Моя первая программа».
3. Поместите компонент Button на форму, измените его имя, свойства.
4. Поместите компонент Label. Введите текст «Я программист!».
5. Измените шрифт, цвет, расположение.
6. Сохраните проект.

VII. Подведение итогов урока.

VIII. Домашнее задание. §6, стр. 36

Среда программирования: 

Delphi (Lazarus)

Построение повторяющихся элементов изображения имеет смысл включать в операторы цикла. Операторы цикла условно можно разделить на циклы по условию и циклы по количеству повторений (циклы-счетчики).

Когда точно известно количество повторяющихся элементов изображения удобно использовать цикл for.

for счетчик:=значение to конечное_значение do

тело_цикла;

for счетчик:=значение downto конечное_значение do

тело_цикла;

При переходе к обработке оператора цикла for управляющей переменной счетчик присваивается заданное начальное значение. Затем в цикле выполняется исполнительный оператор (или составной оператор begin..end). Каждый раз при выполнении исполнительного оператора управляющая переменная увеличивается на 1 (для for...to) или уменьшается на 1 (для for...downto). Цикл завершается при достижении управляющей переменной своего конечного значения.

Пример использования оператора цикла for при построении забора из 20 элементов.

procedure TForm1.Button1Click(Sender: TObject);

Var maxX, maxY : Integer;

i : Integer;

begin

maxX := PaintBox1.Width;

maxY := PaintBox1.Height;

// Количество повторений

for i := 1 to 20 do begin

// Определение цвета досок забора

PaintBox1.Canvas.Brush.Color := RGBToColor(200,160,0);

// Отрисовка досок забора

PaintBox1.Canvas.Rectangle(i*20, maxY, 19 + i*20, maxY-80);

// Верхняя шапка забора

PaintBox1.Canvas.Polygon([Point(i*20, maxY-80),

Point(10 + i*20, maxY-95), Point(19 + i*20, maxY-80)]);

// Круглые отверстия в шапке

PaintBox1.Canvas.Brush.Color := clWhite;

PaintBox1.Canvas.Ellipse(7 + i*20, maxY-82, 13 + i*20, maxY-88);

end;

// Поперечные перекладины

PaintBox1.Canvas.Brush.Color := RGBToColor(200,200,0);

PaintBox1.Canvas.Rectangle(0, maxY-20, 620, maxY-25);

PaintBox1.Canvas.Rectangle(0, maxY-55, 620, maxY-60);

end;

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

while expression do statement;

При выполнении этого оператора вначале вычисляется значение логического выражения expression. Если это значение истинно, выполняется оператор statement, затем значение выражения проверяется вновь и т. д., до тех пор, пока выражение не примет значение «ложь». Если выражение принимает значение «ложь» при первой же проверке, то оператор statement не выполняется вообще.

Пример использования оператора цикла while при построении морских волн.

procedure TForm1.Button1Click(Sender: TObject);

Var maxX, maxY : Integer;

x : Integer;

begin

maxX := PaintBox1.Width;

maxY := PaintBox1.Height;

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

PaintBox1.Canvas.Brush.Color := clYellow;

PaintBox1.Canvas.Polygon([Point(250,maxY-35), Point(280, maxY-250), Point(150, maxY-65)]);

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

PaintBox1.Canvas.Brush.Color := RGBToColor(150, 150, 0);

PaintBox1.Canvas.Polygon([Point(50,maxY-25),

Point(300,maxY-25), Point(340,maxY-50)]);

// Построение волн в виде полуокружностей.

PaintBox1.Canvas.Brush.Color := clBlue;

x:=0;

while x < maxX do begin

PaintBox1.Canvas.Pie(0 + x, maxY, 40 + x, maxY-30,

40 + x, maxY-15, 0 + x, maxY-15 );

x := x+30;

end;

end;

Понятие процедуры, функции и метода класса

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

Подпрограммы в Pascal делят на процедуры и функции. Процедуры - это такие подпрограммы, которые выполняют предназначенное действие и возвращают выполнение в точку вызова. Функции в целом аналогичны процедурам, за тем исключением, что они еще и возвращают результат своего выполнения.

Процедуры и функции, объявленные внутри класса называют методами класса.

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

procedure Stars (N : Integer); // N - параметр, определяющий количество звезд

Var

i : Integer; // Локальная переменная, используемая в операторе цикла

begin

for i:=1 to N do

Form1.PaintBox1.Canvas.Pixels[Random(PaintBox1.Width), Random(PaintBox1.Height)]:=clRed;

end;

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

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

Передача параметров

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

Передача параметров по значению

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

procedure Test(s: string);

При вызове указанной процедуры будет создана копия передаваемой ей в качестве параметра строки s, с которой и будет работать процедура Test. При этом все внесенные в строку изменения никак не отразятся на исходной переменной s.

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

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

Передача параметров по ссылке

Pascal позволяет также передавать параметры в функции или процедуры по ссылке — такие параметры называются параметрами-переменными. Передача параметра по ссылке означает, что функция или процедура сможет изменить полученные значения параметров. Для передачи параметров по ссылке используется ключевое слово var, помещаемое в список параметров вызываемой процедуры или функции.

procedure ChangeMe(var x: longint);

begin

x := 2; // Параметр х изменен вызванной процедурой

end;

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

Передача параметров констант

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

procedure Test(const s: string );

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

Процедура Star объявлена внутри класса TForm1 и по сути является методом этого класса, позволяющим рисовать звезды на форме. При создании процедуры удобно использовать горячие клавиши (Ctrl-Shift+C), которые автоматически создадут тело процедуры внутри блока implementation. Для этого необходимо прописать заголовок процедуры в разделе public или private и нажать горячие клавиши Ctrl-Shift+C.

В процедуру передаются параметры x,y - координаты расположения звезды, Size - размер и Color - цвет отрисовки. Используя цикл задается 100 звезд разного цвета и размера.

unit Unit1;

interface

uses

Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,

ExtCtrls;

type

{ TForm1 }

TForm1 = class(TForm)

Button1: TButton;

PaintBox1: TPaintBox;

procedure Button1Click(Sender: TObject);

private

{ private declarations }

public

{ public declarations }

// Рисование звезды

procedure Star(x,y: Integer; Size: Integer; Colour: TColor);

// Получение случайного цвета. A - параметр, определяющий яркость случайного цвета

function GetRandomColor( A: Integer): TColor;

end;

var

Form1: TForm1;

implementation

{$R *.lfm}

{ TForm1 }

procedure TForm1.Button1Click(Sender: TObject);

// Локальные переменные i и с используются для задания количества и цвета звезд

Var i : Integer;

c : TColor;

begin

// Закрашиваем поле для рисования в черный цвет

PaintBox1.Canvas.Brush.Color:=clBlack;

PaintBox1.Canvas.Rectangle(0,0,PaintBox1.Width, PaintBox1.Height);

// Вызываем процедуру Star 100 раз, тем самым рисуя 100 звезд

for i := 1 to 100 do begin

// Случайным образом формируем цвет звезды, с помощью функции

c := GetRandomColor(100);

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

Star( Random(PaintBox1.Width), Random(PaintBox1.Height), Random(7)+3, c);

end;

end;

//Процедура прорисовки звезды с разными параметрами расположения, размера и цвета

procedure TForm1.Star(x, y: Integer; Size: Integer; Colour: TColor);

begin

// Задаем цвет в соответствии с полученным параметром

PaintBox1.Canvas.Pen.Color:= Colour;

PaintBox1.Canvas.Brush.Color:= Colour;

// Рисуем звезду, используя переданные координаты и размер

Paintbox1.Canvas.Polygon( [Point(x, y-size),

Point(x-size div 4, y-size div 4), Point(x-size, y),

Point(x-size div 4, y+size div 4), Point(x, y+size),

Point(x+size div 4, y+size div 4), Point(x+size, y),

Point(x+size div 4, y-size div 4), Point(x, y-size)]);

end;

function TForm1.GetRandomColor( A: Integer): TColor;

begin

// Проверка на корректность задания параметра A (не больше 255)

if A > 255 then A := 255;

// Получение случайного цвета, в зависимости от значения A

Result := RGBToColor(Random(256-A)+A, Random(256-A)+A, Random(256-A)+A);

end;

end.

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

Для реализации анимации, помимо двух уже известных компонентов TPaintBox (поле для рисования) и TButton (кнопка запуска), понадобится компонент TTimer со вкладки System. Компонент Timer имеет единственное событие OnTimer, которое выполняется пока Timer включен с интервалом по времени, установленным в свойстве Interval.

Расположите компонент Timer1 на форме. Установите его свойства Timer1.Interval := 100 и Timer1.Enabled := false

В коде программы необходимо прописать три процедуры (см. урок "Процедуры и функции при построении изображений"). Процедуру отрисовки объекта procedure TForm1.Cloud, процедуру, отрабатывающую на событие OnTimer, - procedure TForm1.Timer1Timer и процедуру запуска анимации, срабатывающую на нажатие кнопки, procedure TForm1.Button1Click.

unit Unit1;

{$mode objfpc}{$H+}

interface

uses

Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, Buttons,

ExtCtrls, StdCtrls;

type

{ TForm1 }

TForm1 = class(TForm)

Button1: TButton;

PaintBox1: TPaintBox;

Timer1: TTimer;

procedure Button1Click(Sender: TObject);

procedure Timer1Timer(Sender: TObject);

private

{ private declarations }

// координаты прорисовки объекта. Доступны всем процедурам класса TForm1

x1, y1 : Integer;

public

{ public declarations }

// процедура прорисовки облака

procedure Cloud (x, y: Integer; ColorCloud: TColor);

end;

var

Form1: TForm1;

implementation

{$R *.lfm}

{ TForm1 }

procedure TForm1.Cloud(x, y: Integer; ColorCloud: TColor);

begin

// прорисовка облака из двух эллипсов

with PaintBox1.Canvas do begin

Pen.Style := psClear;

Brush.Color := ColorCloud;

Ellipse(x,y,x+80,y+40);

Ellipse(x+30,y+10,x+100,y+50);

end;

end;

procedure TForm1.Button1Click(Sender: TObject);

begin

// установка начальных значений

x1:=0;

y1:=50;

Timer1.Interval:=100;

// прорисовка картинки по которой двигается объект

PaintBox1.Canvas.Brush.Color := clBlue;

PaintBox1.Canvas.Rectangle(0,0, PaintBox1.Width, PaintBox1.Height);

// Включение таймера - запуск анимации

Timer1.Enabled := true;

end;

procedure TForm1.Timer1Timer(Sender: TObject);

begin

// Закраска объекта цветом фона

Cloud(x1,y1,clBlue);

// Изменение координат прорисовки

x1:=x1+1;

// Прорисовка объекта в новом месте

Cloud(x1,y1,clWhite);

end;

end.

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

Для сохранения части изображения используется класс TBitMap (битовая карта изображения). Используя методы этого класса вырезаем часть изображения и по таймеру производим восстановление изображения и прорисовку объекта на новом месте.

unit Unit1;

{$mode objfpc}{$H+}

interface

uses

Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, Buttons,

ExtCtrls, StdCtrls;

type

{ TForm1 }

TForm1 = class(TForm)

Button1: TButton;

PaintBox1: TPaintBox;

Timer1: TTimer;

procedure Button1Click(Sender: TObject);

procedure Timer1Timer(Sender: TObject);

private

{ private declarations }

// координаты прорисовки объекта. Доступны всем процедурам класса TForm1

x1, y1 : Integer;

ARect : TRect;

BitMap : TBitMap;

public

{ public declarations }

// процедура прорисовки облака

procedure Cloud (x, y: Integer; ColorCloud: TColor);

end;

var

Form1: TForm1;

implementation

{$R *.lfm}

{ TForm1 }

procedure TForm1.Cloud(x, y: Integer; ColorCloud: TColor);

begin

// прорисовка облака из трех эллипсов

with PaintBox1.Canvas do begin

Pen.Style := psClear;

Brush.Color := ColorCloud;

Ellipse(x,y,x+80,y+40);

Ellipse(x+30,y+10,x+120,y+50);

Ellipse(x+40,y-10,x+150,y+35);

end;

end;

procedure TForm1.Button1Click(Sender: TObject);

begin

// установка начальных значений

x1:=0;

y1:=50;

Timer1.Interval:=30;

// прорисовка картинки по которой двигается объект

PaintBox1.Canvas.Brush.Color := clBlue;

PaintBox1.Canvas.Rectangle(0,0, PaintBox1.Width, PaintBox1.Height);

PaintBox1.Canvas.Brush.Color := clYellow;

PaintBox1.Canvas.Ellipse(50,50, 150, 150);

Cloud(200,100,clWhite);

Cloud(400,10,clWhite);

// Сохранение части изображения в BitMap-массив

BitMap := TBitmap.Create;

BitMap.Width := PaintBox1.Width;

BitMap.Height := 100;

ARect := Rect(0,y1-10,PaintBox1.Width,y1+90);

BitMap.Canvas.CopyRect(ARect,PaintBox1.Canvas, ARect);

// Включение таймера - запуск анимации

Timer1.Enabled := true;

end;

procedure TForm1.Timer1Timer(Sender: TObject);

begin

// Восстановление изображения из BitMap-массива

ARect := Rect(0,y1-10,PaintBox1.Width,y1+90);

PaintBox1.Canvas.CopyRect(ARect, BitMap.Canvas, ARect);

// Прорисовка объекта

Cloud(x1,y1,clWhite);

x1 := x1+1;

// Если объект вышел за пределы окна, то начать движение объекта сначала

if x1 > PaintBox1.Width then x1:= -100;

end;

end.

OpenGL (Open Graphics Library — открытая графическая библиотека) — спецификация, определяющая независимый от языка программирования кросс-платформенный программный интерфейс для написания приложений, использующих двумерную и трёхмерную компьютерную графику.

Включает более 250 функций для рисования сложных трёхмерных сцен из простых примитивов. Используется при создании компьютерных игр, САПР, виртуальной реальности, визуализации в научных исследованиях. На платформе Windows конкурирует с Direct3D.

Основные возможности OpenGL

Что предоставляет библиотека в распоряжение программиста? Основные возможности:

• Геометрические и растровые примитивы. На основе геометрических и растровых примитивов строятся все объекты. Из геометрических примитивов библиотека предоставляет: точки, линии, полигоны. Из растровых: битовый массив(bitmap) и образ(image)

• Использование В-сплайнов. B-сплайны используются для рисования кривых по опорным точкам.

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

• Работа с цветом. OpenGL предоставляет программисту возможность работы с цветом в режиме RGBA (красный-зелёный-синий-альфа) или используя индексный режим, где цвет выбирается из палитры.

• Удаление невидимых линий и поверхностей. Z-буферизация.

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

• Наложение текстуры. Позволяет придавать объектам реалистичность. На объект, например шар, накладывается текстура(просто какое-то изображение), в результате чего наш объект теперь выглядит не просто как шар, а как разноцветный мячик.

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

• Освещение. Позволяет задавать источники света, их расположение, интенсивность, и т.д.

• Атмосферные эффекты. Например туман, дым. Всё это также позволяет придать объектам или сцене реалистичность, а также "почувствовать" глубину сцены.

• Прозрачность объектов.

• Использование списков изображений.

Дополнительные библиотеки

Для OpenGL существуют так называемые вспомогательные библиотеки.

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

Следующая библиотека, также широко используемая - это GLUT. Это также независимая от платформы библиотека. Она реализует не только дополнительные функции OpenGL, но и предоставляет функции для работы с окнами, клавиатурой и мышкой. Для того чтобы работать с OpenGL в конкретной операционной системе (например Windows или X Windows), надо провести некоторую предварительную настройку и эта предварительная настройка зависит от конкретной операционной системы. С библиотекой GLUT всё намного упрощается, буквально несколькими командами можно определить окно, в котором будет работать OpenGL, определить прерывание от клавиатуры или мышки и всё это не будет зависеть от операционной системы. Библиотека предоставляет также некоторые функции, с помощью которых можно определять некоторые сложные фигуры, такие как конусы, тетраэдры, и даже можно с помощью одной команды определить чайник!

Есть ещё одна библиотека похожая на GLUT, называется она GLAUX. Это библиотека разработана фирмой Microsoft для операционной системы Windows. Она во многом схожа с библиотекой GLUT, но немного отстаёт от неё по своим возможностям. И ещё один недостаток заключается в том, что библиотека GLAUX предназначена только для Windows, в то время как GLUT поддерживает очень много операционных систем.

Синтаксис команд

type glCommand_name[1 2 3 4][b s i f d ub us ui][v]

(type1 arg1,…,typeN argN)

Таким образом, имя состоит из нескольких частей: Gl это имя библиотеки, в которой описана эта функция: для базовых функций OpenGL, функций из библиотек GLU, GLUT, GLAUX это gl, glu, glut, glaux соответственно
Command_name - имя команды
[1 2 3 4] – число аргументов команды
[b s i f d ub us ui] – тип аргумента:
b - GLbyte байт,
s - GLshort короткое целое,
i - GLint целое,
f - GLfloat дробное,
d - GLdouble дробное с двойной точностью,
ub - GLubyte беззнаковый байт,
us - GLushort беззнаковое короткое целое,
ui - GLuint беззнаковое целое.

Полный список типов и их описание можно посмотреть в файле gl.h.
[v] – наличие этого символа показывает, что в качестве параметров функции используется указатель на массив значений.

Рисование геометрических объектов

Очистка окна.

glClearColor (clampf r, clampf g, clampf b, clampf a)

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

Вершины и примитивы

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

С каждой вершиной ассоциируются ее атрибуты. В число основных атрибутов входят положение вершины в пространстве, цвет вершины и вектор нормали.
Положение вершины в пространстве

Положение вершины определяются заданием ее координат в двух-, трех-, или четырехмерном пространстве (однородные координаты). Это реализуется с помощью нескольких вариантов команды glVertex*:

void glVertex[2 3 4][s i f d] (type coords)

void glVertex[2 3 4][s i f d]v (type *coords)

Каждая команда задает четыре координаты вершины: x, y, z, w. Команда glVertex2* получает значения x и y. Координата z в таком случае устанавливается по умолчанию равной 0, координата w – равной 1. Vertex3* получает координаты x, y, z и заносит в координату w значение 1. Vertex4* позволяет задать все четыре координаты.

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

Цвет вершины

Для задания текущего цвета вершины используются команды :

void glColor[3 4][b s i f] (GLtype components)

void glColor[3 4][b s i f]v (GLtype components)

Первые три параметра задают R, G, B компоненты цвета, а последний параметр определяет коэффициент непрозрачности (так называемая альфа-компонента). Если в названии команды указан тип ‘f’ (float), то значения всех параметров должны принадлежать отрезку [0,1], при этом по умолчанию значение альфа-компоненты устанавливается равным 1.0, что соответствует полной непрозрачности. Тип ‘ub’ (unsigned byte) подразумевает, что значения должны лежать в отрезке [0,255].

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

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

void glShadeModel (GLenum mode)

вызов которой с параметром GL_SMOOTH включает интерполяцию (установка по умолчанию), а с GL_FLAT – отключает.

Нормаль

Определить нормаль в вершине можно, используя команды

void glNormal3[b s i f d] (type coords)

void glNormal3[b s i f d]v (type coords)

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

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

Однако применение этого режима уменьшает скорость работы механизма визуализации OpenGL, так как нормализация векторов имеет заметную вычислительную сложность (взятие квадратного корня и т.п.). Поэтому лучше сразу задавать единичные нормали.

Отметим, что команды

void glEnable (GLenum mode)

void glDisable (GLenum mode)

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

Операторные скобки glBegin / glEnd

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

void glBegin (GLenum mode);

void glEnd (void);

Параметр mode определяет тип примитива, который задается внутри и может принимать следующие значения: GL_POINTS каждая вершина задает координаты некоторой точки.

• GL_LINES каждая отдельная пара вершин определяет отрезок; если задано нечетное число вершин, то последняя вершина игнорируется.

• GL_LINE_STRIP каждая следующая вершина задает отрезок вместе с предыдущей.

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

• GL_TRIANGLES каждая отдельная тройка вершин определяет треугольник; если задано не кратное трем число вершин, то последние вершины игнорируются.

• GL_TRIANGLE_STRIP каждая следующая вершина задает треугольник вместе с двумя предыдущими.

• GL_TRIANGLE_FAN треугольники задаются первой и каждой следующей парой вершин (пары не пересекаются).

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

• GL_QUAD_STRIP четырехугольник с номером n определяется вершинами с номерами 2n-1, 2n, 2n+2, 2n+1.

• GL_POLYGON последовательно задаются вершины выпуклого многоугольника.

Например, чтобы нарисовать треугольник с разными цветами в вершинах, достаточно написать:

glBegin(GL_TRIANGLES);

glColor3f(1.0, 0.0, 0.0); glVertex3f(0.0, 0.0, 0.0);

glColor3ub(0,255,0); glVertex3f(1.0, 0.0, 0.0);

glColor3fv(BlueCol); glVertex3f(1.0, 1.0, 0.0);

glEnd();

Установка пакета получения контекста устройства в Lazarus

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

Однако компонент TOpenGLControl, по — умолчанию, не установлен в среде Lazarus, поэтому необходимо установить данный компонент. Выберите пункт меню "Пакет -> Установить/Удалить пакеты" (Package -> Install/Uninstall Packages), откроется окно установки новых пакетов в среду Lazarus.

В окне установки новых пакетов, в списке неустановленных пакетов, необходимо найти пакет с именем lazopenglcontext 0.0.1, выбрать его и нажать кнопку "Установить выбранное" (Install selection). После этого необходимо нажать кнопку "Сохранить и перезапустить IDE" (Save and Rebuild IDE), для пересборки Lazarus уже с компонентом TOpenGLControl. В окне подтверждения установки нового пакета, нажмите кнопку "Продолжить" (Continue).

Если все проделано верно, то в панели инструментов появится вкладка OpenGl с компонентом TOpenGLControl.

Можно начинать работать с библиотекой.

Простейшая программа на OpenGL в Lazarus

Расположите на форме два компонента

Panel1: TPanel

Button1: TButton

пропишите следующий код на события OnCreate и ButtonClick

unit Unit1;

{$mode objfpc}{$H+}

interface

// Подключение библиотек. Для работы C OpenGL необходимы OpenGLContext, GL, GLU

uses

Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,

ExtCtrls, OpenGLContext, GL, GLU;

type

{ TForm1 }

TForm1 = class(TForm)

Button1: TButton;

Panel1: TPanel;

procedure Button1Click(Sender: TObject);

procedure FormCreate(Sender: TObject);

private

{ private declarations }

public

{ public declarations }

OpenGLControl1: TOpenGLControl; // Контекст воспроизведения OpenGL

end;

var

Form1: TForm1;

implementation

{$R *.lfm}

{ TForm1 }

procedure TForm1.FormCreate(Sender: TObject);

begin

// Создание контекста воспроизведения OpenGL и привязка его к панели на форме

OpenGLControl1:=TOpenGLControl.Create(Self);

with OpenGLControl1 do begin

Name:='OpenGLControl1';

Align:=alClient;

Parent:=Panel1;

end;

end;

procedure TForm1.Button1Click(Sender: TObject);

begin

glClearColor (0, 0, 0, 0); // цвет фона

glClear (GL_COLOR_BUFFER_BIT); // очистка буфера цвета

glMatrixMode(GL_MODELVIEW); // Выбор видовой матрицы

glLoadIdentity(); // Установка в единичные значения

glOrtho(0, 1, 0, 1, -1 ,1); // Установка проекции окна

//glTranslatef(0.5,0.5,0); // Сдвиг

//glRotatef(10, 0, 0, 0); // Вращение

glBegin(GL_TRIANGLES); // Рисование треугольника

glColor3f(1.0,0.0,0.0); // Красный

glVertex3f(1,0,0 ); // Верх треугольника (Передняя)

glColor3f(0.0,1,0.0);

glVertex3f( 0,1,0);

glColor3f(0,0,1);

glVertex3f( 0,0,0);

glEnd;

OpenGLControl1.SwapBuffers; // Отрисовка из буффера

end;

end.

Среда программирования: 

Delphi (Lazarus)

В OpenGL используются основные три системы координат: левосторонняя, правосторонняя и оконная. Первые две системы являются трехмерными и отличаются друг от друга направлением оси z: в правосторонней она направлена на наблюдателя, в левосторонней – в глубину экрана. Ось x направлена вправо относительно наблюдателя, ось y – вверх.

Системы координат в OpenGL

Строго говоря, OpenGL позволяет путем манипуляций с матрицами моделировать как правую, так и левую систему координат. Но на данном этапе лучше пойти простым путем и запомнить: основной системой координат OpenGL является правосторонняя система.

РАБОТА С МАТРИЦАМИ

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

Умножение координат на матрицы происходит в момент вызова соответствующей команды OpenGL, определяющей координату (как правило, это команда glVertex*)

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

void glMatrixMode (GLenum mode)

вызов которой со значением параметра mode равным

GL_MODELVIEW,

GL_PROJECTION,

GL_TEXTURE

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

Для определения элементов матрицы текущего типа вызывается команда

void glLoadMatrix[f d] (GLtype *m)

где m указывает на массив из 16 элементов типа float или double в соответствии с названием команды, при этом сначала в нем должен быть записан первый столбец матрицы, затем второй, третий и четвертый. Еще раз обратим внимание: в массиве m матрица записана по столбцам.

Команда

void glLoadIdentity (void)

заменяет текущую матрицу на единичную.

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

void glPushMatrix (void)

void glPopMatrix (void)

Они записывают и восстанавливают текущую матрицу из стека, причем для каждого типа матриц стек свой. Для модельно-видовых матриц его глубина равна как минимум 32, для остальных – как минимум 2.

МОДЕЛЬНО-ВИДОВЫЕ ПРЕОБРАЗОВАНИЯ

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

Сама матрица может быть создана с помощью следующих команд:

void glTranslate[f d] (GLtype x, GLtype y, GLtype z)

void glRotate[f d] (GLtype angle, GLtype x, GLtype y, GLtype z)

void glScale[f d] (GLtype x, GLtype y, GLtype z)

glTranlsate*() производит перенос объекта, прибавляя к координатам его вершин значения своих параметров.

glRotate*() производит поворот объекта против часовой стрелки на угол angle (измеряется в градусах) вокруг вектора (x,y,z).

glScale*() производит масштабирование объекта (сжатие или растяжение) вдоль вектора (x,y,z), умножая соответствующие координаты его вершин на значения своих параметров.

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

Чтобы изображенная фигура выглядела пространственной, систему координат разворачивают вокруг оси X и вокруг оси Y.

ПРОЕКЦИИ

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

void glOrtho (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top,

GLdouble near, GLdouble far)

void glFrustum (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top,

GLdouble near, GLdouble far)

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

glLoadIdentity; //Сброс всех матриц в 1

glFrustum(-1, 1, -1, 1, 3, 10); //видовые параметры

glTranslatef(0.0, 0.0, -5.0); //начальный сдвиг системы координат

glRotatef(30.0, 1.0, 0.0, 0.0); //поворот относительно оси X

glRotatef(70.0, 0.0, 1.0, 0.0); //поворот относительно оси Y

glBegin(…);

….. // команды рисования

glEnd;

Второй способ – использование команд glPushMatrix и glPopMatrix:

glPushMatrix(); //запоминаем текущую матрицу

glFrustum(-1, 1, -1, 1, 3, 10); //видовые параметры

glTranslatef(0.0, 0.0, -5.0); //начальный сдвиг системы координат

glRotatef(30.0, 1.0, 0.0, 0.0); //поворот относительно оси X

glRotatef(70.0, 0.0, 1.0, 0.0); //поворот относительно оси Y

glBegin(…);

….. // команды рисования

glEnd;

glPopMatrix(); //восстанавливаем текущую матрицу

ПРОГРАММА - ПРИМЕР ВРАЩЕНИЯ КУБА В LAZARUS НА OPENGL

Разместите на форме три компонента

OpenGLControl1: TOpenGLControl;

Button1: TButton;

Timer1: TTimer;

Примечание. Обратите внимание для установки компонента TOpenGLControl смотрите урок "Подключение и работа с OpenGL в Lazarus под Windows".

Пропишите на события создания формы Form1: OnFormCreate, нажатия кнопки Form1: OnButton1Click и работы таймера Form1: OnTimer1Timer следующий код:

unit Unit1;

{$mode objfpc}{$H+}

interface

uses

Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,

ExtCtrls, OpenGLContext, GL, GLU;

type

{ TForm1 }

TForm1 = class(TForm)

Button1: TButton;

OpenGLControl1: TOpenGLControl;

Timer1: TTimer;

procedure Button1Click(Sender: TObject);

procedure FormCreate(Sender: TObject);

procedure Timer1Timer(Sender: TObject);

private

{ private declarations }

public

{ public declarations }

cube_rotation: GLFloat;

Speed: Double;

end;

var

Form1: TForm1;

implementation

{$R *.lfm}

{ TForm1 }

procedure TForm1.Button1Click(Sender: TObject);

begin

Timer1.Enabled := true;

end;

procedure TForm1.FormCreate(Sender: TObject);

begin

Timer1.Enabled := false;

Timer1.Interval := 100;

Speed := 1;

end;

procedure TForm1.Timer1Timer(Sender: TObject);

begin

glClearColor(1.0, 1.0, 1.0, 1.0);

glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);

glEnable(GL_DEPTH_TEST);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

gluPerspective(45.0, double(width) / height, 0.1, 100.0);

glMatrixMode(GL_MODELVIEW);

glLoadIdentity();

glTranslatef(0.0, 0.0,-6.0);

glRotatef(cube_rotation, 1.0, 1.0, 1.0);

glBegin(GL_QUADS);

glColor3f(0.0,1.0,0.0); // Set The Color To Green

glVertex3f( 1.0, 1.0,-1.0); // Top Right Of The Quad (Top)

glVertex3f(-1.0, 1.0,-1.0); // Top Left Of The Quad (Top)

glVertex3f(-1.0, 1.0, 1.0); // Bottom Left Of The Quad (Top)

glVertex3f( 1.0, 1.0, 1.0); // Bottom Right Of The Quad (Top)

glEnd();

glBegin(GL_QUADS);

glColor3f(1.0,0.5,0.0); // Set The Color To Orange

glVertex3f( 1.0,-1.0, 1.0); // Top Right Of The Quad (Bottom)

glVertex3f(-1.0,-1.0, 1.0); // Top Left Of The Quad (Bottom)

glVertex3f(-1.0,-1.0,-1.0); // Bottom Left Of The Quad (Bottom)

glVertex3f( 1.0,-1.0,-1.0); // Bottom Right Of The Quad (Bottom)

glEnd();

glBegin(GL_QUADS);

glColor3f(1.0,0.0,0.0); // Set The Color To Red

glVertex3f( 1.0, 1.0, 1.0); // Top Right Of The Quad (Front)

glVertex3f(-1.0, 1.0, 1.0); // Top Left Of The Quad (Front)

glVertex3f(-1.0,-1.0, 1.0); // Bottom Left Of The Quad (Front)

glVertex3f( 1.0,-1.0, 1.0); // Bottom Right Of The Quad (Front)

glEnd();

glBegin(GL_QUADS);

glColor3f(1.0,1.0,0.0); // Set The Color To Yellow

glVertex3f( 1.0,-1.0,-1.0); // Bottom Left Of The Quad (Back)

glVertex3f(-1.0,-1.0,-1.0); // Bottom Right Of The Quad (Back)

glVertex3f(-1.0, 1.0,-1.0); // Top Right Of The Quad (Back)

glVertex3f( 1.0, 1.0,-1.0); // Top Left Of The Quad (Back)

glEnd();

glBegin(GL_QUADS);

glColor3f(0.0,0.0,1.0); // Set The Color To Blue

glVertex3f(-1.0, 1.0, 1.0); // Top Right Of The Quad (Left)

glVertex3f(-1.0, 1.0,-1.0); // Top Left Of The Quad (Left)

glVertex3f(-1.0,-1.0,-1.0); // Bottom Left Of The Quad (Left)

glVertex3f(-1.0,-1.0, 1.0); // Bottom Right Of The Quad (Left)

glEnd();

glBegin(GL_QUADS);

glColor3f(1.0,0.0,1.0); // Set The Color To Violet

glVertex3f( 1.0, 1.0,-1.0); // Top Right Of The Quad (Right)

glVertex3f( 1.0, 1.0, 1.0); // Top Left Of The Quad (Right)

glVertex3f( 1.0,-1.0, 1.0); // Bottom Left Of The Quad (Right)

glVertex3f( 1.0,-1.0,-1.0); // Bottom Right Of The Quad (Right)

glEnd();

cube_rotation += 5.15 * Speed;

OpenGLControl1.SwapBuffers;

end;

end.