На прошлом уроке мы настроили OpenGL и теперь что-нибудь нарисуем в нашем окне. Наш код будет размещаться в функции display() между glClear() и glFlush().  Сначала нарисуем треугольник. Зададим цвет с помощью функции glColor3ub(). Эта функция принимает три параметра (красный, зеленый, синий), каждый из которых в диапазоне (0; 255). Например так: glColor3ub( 145, 30, 66). Теперь напишем сам фрагмент кода рисования.

void display() { glClear(GL_COLOR_BUFFER_BIT); //рисуем треугольник glColor3ub( 145, 30, 66); glBegin(GL_TRIANGLES); glVertex3f( 0.0f, 0.8f, 0.0f); //верхняя вершина glVertex3f(-0.4f,0.4f, 0.0f); //левая вершина glVertex3f( 0.4f,0.4f, 0.0f); //правая вершина glEnd(); ////////////////////////////////// glFlush(); }

Функции glBegin() и glEnd() отвечают за начало и конец рисования соответственно. Параметр GL_TRIANGLES сообщает, что мы будем рисовать треугольник, три раза вызывая glVertex3f(). Функция glVertex3f() принимает значения x,y,z в формате float. Значения x и y лежат в диапазоне (-1; 1). Мы задали три вершины с координатами: (0; 0.8), (-0.4; 0.4), (0.4; 0.4). Третий параметр отвечает за ось z. Он равен 0, так как у нас 2d фигуры.

Теперь нарисуем прямоугольник. Будем использовать функцию glRectf(). Она принимает координаты левого верхнего угла и правого нижнего. Также зададим другой цвет.

void display() { glClear(GL_COLOR_BUFFER_BIT); //рисуем треугольник glColor3ub( 145, 30, 66); glBegin(GL_TRIANGLES); glVertex3f( 0.0f, 0.8f, 0.0f); //верхняя вершина glVertex3f(-0.4f,0.4f, 0.0f); //левая вершина glVertex3f( 0.4f,0.4f, 0.0f); //правая вершина glEnd(); ////////////////////////////////// //рисуем прямоугольник glColor3ub( 239, 211, 52); glRectf(-0.2f, 0.4f, 0.2f, 0.0f); /////////////////////////////////// glFlush(); }

У нас получился домик). Теперь еще добавим основание. Для этого нарисуем отрезок с толщиной, например, 50. Также зададим другой цвет.

void display() { glClear(GL_COLOR_BUFFER_BIT); //рисуем треугольник glColor3ub( 145, 30, 66); glBegin(GL_TRIANGLES); glVertex3f( 0.0f, 0.8f, 0.0f); //верхняя вершина glVertex3f(-0.4f,0.4f, 0.0f); //левая вершина glVertex3f( 0.4f,0.4f, 0.0f); //правая вершина glEnd(); ////////////////////////////////// //рисуем прямоугольник glColor3ub( 239, 211, 52); glRectf(-0.2f, 0.4f, 0.2f, 0.0f); /////////////////////////////////// //рисуем отрезок glLineWidth(50); //задаем толщину glColor3ub( 60, 170, 60); glBegin(GL_LINES); glVertex3f(-0.9, 0.0, 0.0); glVertex3f(0.9, 0, 0); glEnd(); /////////////////////////////////// glFlush(); }

Для рисования отрезка достаточно двух точек. В нашем случае (-0.9; 0) и (0.9; 0).

У нас получился симпатичный домик). И теперь полный код программы.

#include "glut.h" void display() { glClear(GL_COLOR_BUFFER_BIT); //рисуем треугольник glColor3ub( 145, 30, 66); glBegin(GL_TRIANGLES); glVertex3f( 0.0f, 0.8f, 0.0f); //верхняя вершина glVertex3f(-0.4f,0.4f, 0.0f); //левая вершина glVertex3f( 0.4f,0.4f, 0.0f); //правая вершина glEnd(); ////////////////////////////////// //рисуем прямоугольник glColor3ub( 239, 211, 52); glRectf(-0.2f, 0.4f, 0.2f, 0.0f); /////////////////////////////////// //рисуем отрезок glLineWidth(50); //задаем толщину glColor3ub( 60, 170, 60); glBegin(GL_LINES); glVertex3f(-0.9, 0.0, 0.0); glVertex3f(0.9, 0, 0); glEnd(); glFlush(); } void main() { glutInitWindowSize(500, 500); glutInitWindowPosition(100, 140); glutCreateWindow("OpenGL window"); glClearColor(0, 0, 1, 1); glutDisplayFunc(display); glutMainLoop(); }

Языки программирования

OpenGL

OpenGL (Open Graphics Library — открытая графическая библиотека) — спецификация, определяющая независимый от языка программирования и платформы программный интерфейс для написания приложений, использующих двухмерную и трёхмерную компьютерную графику. Включает более 250 функций для рисования сложных трёхмерных сцен из простых примитивов. Используется при создании компьютерных игр, САПР, виртуальной реальности, визуализации в научных исследованиях. На платформе Windows конкурирует с Direct3D. Silicon Graphics Incorporated (SGI) специализировалась на создании высокотехнологического графического оборудования и программных средств. Являясь в то время лидером в трёхмерной графике, SGI видела проблемы и барьеры в росте рынка. Поэтому было принято решение стандартизировать метод доступа к графической аппаратуре на уровне программного интерфейса.Таким образом появился программный интерфейс OpenGL, который стандартизирует доступ к графической аппаратуре путём смещения ответственности за создание аппаратного драйвера на производителя графического устройства. Это позволило разработчикам программного обеспечения использовать более высокий уровень абстракции от графического оборудования, что значительно ускорило создание новых программных продуктов и снизило на них затраты. В 1992 году компания SGI возглавила OpenGL ARB — группу компаний по разработке спецификации OpenGL. Он эволюционировал из 3D-интерфейса SGI — IRIS GL. Одним из ограничений IRIS GL было то, что он позволял использовать только возможности, поддерживаемые оборудованием. Если возможность не была реализована аппаратно, приложение не могло её использовать. OpenGL преодолевает эту проблему за счёт программной реализации возможностей, не предоставляемых аппаратно, что позволяет приложениям использовать этот интерфейс на относительно маломощных системах.

OpenGL. Урок 1. Введение.

Компилятор для OpenGL:

Microsoft Visual Studio

DevC++

Учебники по OpenGL:

Название: OpenGL. Профессиональное программирование трехмерной графики на C++
Автор: Сергей Гайдуков
Скачать:

Название: Open GL Графика в проектах Delphi — М.В. Краснов
Автор: М. В.Краснов
Скачать:

Название: Графика трехмерной компьютерной игры на основе OpenGL
Автор: А.В.Боресков
Скачать:

Страница сообщества OpenGL http://www.gamedev.ru/community/ogl/
Обсуждение проекта http://www.gamedev.ru/community/ogl/forum/

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

Страница проекта на Google Code http://code.google.com/p/gl33lessons/

Цель — сделать цикл из небольших уроков охватывающих разные аспекты работы с OpenGL 3.3.

Урок 1 — Создание контекста OpenGL 3.3
Урок 2 — Рисуем первый треугольник
Урок 3 — Вращающийся куб с текстурой
Урок 4 — Свет, камера, материал! Часть 1
Урок 5 — Свет, камера, материал!

Урок 1: Открываем окно

Часть 2
Урок 6 — Тени от объектов
Урок 7 — Экранные эффекты

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

Следите за обновлениями!

—

Создаю данную тему по этому обсуждению:
http://www.gamedev.ru/code/forum/?id=138251&page=2#m26

Суть такова — я вызвался создать цикл уроков/статей по использованию OpenGL 3.3
Уроки прежде всего предлагаются вниманию новичков, а также тех кто хочет перейти
на использование OpenGL 3.х и 4.х с более старых версий, для тех кто привык к FFP, IM,
DL и прочим пережиткам прошлого.

Можно сказать что это переосмысление уроков NeHe на современный лад 🙂

Также цикл уроков предложит более углубленно ознакомиться с написанием
графических приложений, загрузкой изображений и моделей, созданием
текстур, создание вершинных VB и индексных IB буферов, а в дальнейшем
добавить примеры реализации Bump/Normal Mapping и Shadow Maps.

Цитата из темы где зародилась идея:

Вот краткий набор возможностей которые лично я бы хотел рассмотреть:
1. Создание окна и инициализация контекста для OpenGL 3.3
2. Загрузка и проверка доступности расширений OpenGL
3. Создание VAO + VBO для данных геометрии
4. Загрузка вершинных и пиксельных шейдеров GLSL
5. Реализация базовой камеры с возможностью перемещения
6. Передача в шейдер необходимых параметров (матрицы, атрибуты и т.п.)
7. Реализация направленного источника освещения
8. Загрузка текстур формата TGA и моделей формата OBJ с материалами
9. Вывод геометрии из VAO + VBO с текстурами и материалами
+ Небольшая математическая библиотека для векторов и матриц

Дополнительно есть возможность рассмотреть:
1. Базовый Bump/Normal Mapping с автоматически рассчитанным TBN (по простому)
+ Для Tangent и Binormal используется отдельный VBO (демонстрация удобства VAO).
2. Базовая Shadow Map + PCF на один направленный источник света

Если есть предложения/пожелания — просьба направить мне в лс, либо писать здесь.

Также принимается помощь в создании уроков как моральная так и материальная 🙂

OpenGL является одним из ведущих и популярных графических API, разработанный SGI. OpenGL разрабатывался как многоплатформенный, открытый и быстрый графический API. Многие графические пакеты используют OpenGL для вывода трёхмерной графики. Многие известные игры, такие как Quake, Serious Sam и наш отечественный ИЛ-2 Штурмовик, также написаны под OpenGL.

Введение
Инициализация
Типы в OpenGL
Функции OpenGL
Дополнительные сведения об OpenGL
Дополнительные библиотеки
  OpenGL Utility Library (glu)
  OpenGL Auxiliary Library (glaux)
  OpenGL Utility Toolkit (GLUT)
Вывод кадра
  Графические примитивы
  Вершины
  Вывод примитивов последовательностью вершинных функций
  Вывод примитивов, используя массивы
  Индексные примитивы

Введение

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

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

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

Заголовочные файлы, которые могут понадобиться для работы с OpenGL, обычно находятся в папке GL, расположенной в стандартной папке Include.

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

#include <GL/gl.h>

Кроме того, линковщику нужно указать статические библиотеки, с внешними функциями. Например, для функций, объявленных в gl.h, необходимо добавить в проект opengl32.lib.

Инициализация

В OpenGL нет встроенных функций для инициализации OpenGL.

[wip] Цикл уроков по OpenGL 3.3

Это связано с тем, что OpenGL является независимым от платформы графическим API. Инициализацию обеспечивает операционная среда.

Существует несколько функций по работе с OpenGL, которые представляет Windows API.

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

Обычно в трёхмерных играх каждый видимый кадр строится заново. То есть, в каждом кадре полностью перерисовывается вся видимая графика. Построение кадра может происходить следующим образом. Сначала весь кадр очищается, а потом последовательно выводятся трёхмерные графические объекты. Такое действие происходит несколько раз в секунду. Количество этих перерисовок в секунду называют FPS (frames per second).

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

Чтобы не было этого неприятного эффекта, пользуются следующим способом. Весь кадр полностью строят в невидимой части видеопамяти адаптера. Эту часть называют Back Buffer. После того, как все графические объекты выведены, вся эта невидимая часть копируется в видимую область видеопамяти, называемую Front Buffer. Если ваше приложение выводит графику на весь экран, а не в окно, то можно избежать копирования буфера, переключая указатель на видимую часть в видео памяти. Такой эффект называют Flip. Видно, что он работает быстрее, чем копирование буфера.

Мы будем строить пример оконного приложения.

Окно, в котором будет выводиться графика под OpenGL должно иметь два дополнительных стиля WS_CLIPSIBLINGS и WS_CLIPCHILDREN. Эти стили можно установить либо во время создания окна в функции CreateWindow(), либо функцией из Windows API — SetWindowLong(), если окно уже создано.

Согласно нашему примеру, для того чтобы установить эти стили, нами созданную функцию CreateMainWindow() необходимо вызвать с true в параметре bIsOpenGL.

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

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

Рассмотрим функции, работающие с PIXELFORMATDESCRIPTOR.

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

Итак, сначала создадим объект типа PIXELFORMATDESCRIPTOR, полностью заполненный нулевыми значениями.

PIXELFORMATDESCRIPTOR pfd = {0};

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

Также необходимо выставить требуемые флаги в dwFlags. Поскольку мы собираемся выводить графические объекты в окно, то нужно выставить флаг PFD_DRAW_TO_WINDOW. Далее, говорим, что буфер кадра поддерживает вывод через OpenGL — PFD_SUPPORT_OPENGL, и, так как мы используем два буфера (Back и Front), устанавливаем флаг PFD_DOUBLEBUFFER. Итак:

pfd.dwFlags = PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER | PFD_DRAW_TO_WINDOW;

В поле iPixelType выставим PFD_TYPE_RGBA. Это означает, что цвет для пикселя представляется в виде RGBA (цветовые компоненты: R — красный, G — зелёный, B — голубой и A — альфа). Кроме этого бывает ещё индексное представление, которое мы не будем рассматривать вообще.

Дальше выставляем желаемые параметры. Например: глубину цвета (cColorBits) — 32 бит.

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

Если формат был успешно подобран, нужно его выставить функцией SetPixelFormat().

Чтобы узнать, какие именно значения устанавливаются для формата, то есть получить описание полей структуры PIXELFORMATDESCRIPTOR, пользуются функцией DescribePixelFormat()

Итак, построим функцию, инициализирующую пиксельный формат для устройства контекста:

Если удалось установить пиксельный формат, то теперь нужно создать просчитывающий контекст (rendering context) OpenGL. Это делается вызовом функции wglCreateContext(). Далее, созданный контекст выставляется текущим функцией wglMakeCurrent().

Теперь вы можете пользоваться функциями OpenGL.

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

Итак, мы теперь можем построить код, позволяющий работать нам с OpenGL:

Файл OpenGL.h

Файл OpenGL.cpp

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

В начале:

#include "OpenGL.h"

Функцию CreateMainWindow() вызвать с true для параметра bIsOpenGL.

В функции Init() вызвать:

InitOpenGL(hWndMain);

А в функции ReleaseAll() вызвать:

ReleaseOpenGL();

Введение

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

Что такое OpenGL

OpenGL — кросс-платформенная библиотека для 2D и 3D графики. В настоящее время используется для разработки приложений для Mac OS X, iOS, Android, Linux, конкурирует с DirectX для Windows. OpenGL используют не только для разработки игр, но и для приложений, работающих с 3D-графикой: СAD-системы, 3D редакторы, обучающие ПО, медицинские системы.

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

Уроки OpenGL

И самое главное, OpenGL поддерживается производителями видеокарт, благодаря чему библиотека получает аппаратное ускорение видеокарт. Когда я только начинал работать с OpenGL, у меня возник вопрос: Как установить OpenGL? Где взять дистрибутив? Ответ прост: OpenGL устанавливается вместе с драйверами видеокарты, так как и список расширений и различные константы разнятся в зависимости от видеокарты (правда, Windows может иметь встроенный OpenGL старой версии без поддержки аппаратного обеспечения).

Для использования OpenGL, конечно, необходимо иметь библиотеку для линковки (gl.lib, glu.lib) и заголовочный файлы. Они входят в Visual Studio, но и их не трудно найти в Интернете.

Какие именно возможности вам предоставит OpenGL?

OpenGL предоставляет средства для рендера 3D сцены. OpenGL также позволяет гибко настраивать отрисовку. OpenGL поддерживает аппаратное ускорение, так как большинство команд выполняется на видеокарте.

Какими знаниями необходимо обладать?

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

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

Позиционирование объектов — серьёзный вопрос, связанный с 3D сценами. Объекты позиционируются с помощью аффинных преобразований: перемещение, вращение и увеличение размера. С математической точки зрения эти преобразования записываются соответствующими матрицами. Если вы плохо разбираетесь в этом, то обязательно почитайте специализированную литературу, посвященную данному вопросу.

С чего начать?

Начать изучение я бы посоветовал с хорошей книги, при этом постоянно практикуясь. На русском языке не так много хороших книг, так как большинство из них уже устарели. Я бы посоветовал следующую книгу: «OpenGL. Руководство по программированию». При начальном обучении книга может показаться довольно сложной. Параллельно с ней можно изучать статьи с примерами http://nehe.gamedev.net (перевод статей на русский http://pmg.org.ru/nehe).

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

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

Об устаревших и современных методах и расширениях

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

Когда вы начнёте читать книгу, то обнаружите, что в первых примерах объекты (треугольники или квадраты) вы будете строить по точкам с помощью функции glVertex*, первое освещение вы будете включать, используя glLight, задавать цвет материала функцией glMaterialf. Многие из них не используются в современных проектах. Например, вершины объектов не задаются по одной, а передаются все вместе с помощью Vertex Buffer Object (VBO). Это намного быстрее, так как вершины необходимо передать на видеокарту и намного быстрее передать все сразу, чем по одной. Стандартное освещение тоже не используется, все реализуется в шейдерах. Другими словами, объекты всегда отрисовываются с помощью шейдеров. В шейдеры передаются все необходимые параметры: освещение, материалы, матрицы. И когда вы освоите азы, вам необходимо переключаться на изучение шейдеров (GLSL).

Изучая каждую функцию OpenGL, стоит задуматься как вызов этой функции выполняется и сколько времени он может занять. Например, если вы создаёте и загружаете данные текстуры в видеопамять, это значит что пока все данные не будут пересланы программа дальше не будет выполняться. Многие операции могут выполняться параллельно, то есть вы даёте команду видеокарте и она её выполняет, и ваша программа исполняется дальше.

На будущее

Когда вы освоите OpenGL вас могут заинтересовать вопросы работы видеокарты, эффективная реализация тех или иных эффектов. Для этого могу вам порекомендовать: