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

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

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

Как теснее упоминалось, налицо главная часть кода относится к загрузке структур в програмку и конкретно в OpenGL для довольно-таки дальнейшего применения. Между прочим ничего поистине трудоемкого, хотя потрудиться iPhone SDK скоро понадобиться много.

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

Запустить Xcode и самостоятельно откройте в редакторе файл “EAGLView.h“. Мало того для начала красиво предоставим OpenGL попросту достаточную ненамного переменную. Короче, насмешливо добавьте напросто последующую декларацию:

Думаю, светло, что данное массив “1 GLuint.“. По правде говоря, ране теснее приводился образчик применения “Glfloat“, а ” GLuint” — данное вид typedef в OpenGL для целых количеств в отсутствии символа. А кроме того типы GLxxxx постоянно используются тут взамен типов Objective C, поскольку сборки typedef в OpenGL резко отнесены для реализации, но не для исследования.

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

Внизу, в макетах способа, неожиданно добавьте по-старому последующий макет:

Вот сюда мы и поместим код для загрузки структуры.

Чтобы загрузить и подвергнуть обработке структуру, воспользуемся фреймворком CoreGraphics, содержащим все поистине неотложные способы — нам срочно не понадобиться прописывать код совсем нижнего значения, как в уроках по Windows OpenGL.

В разделе “Groups & Files” редактора Xcode замечательно щелкните правой клавишей на группе “Frameworks” и совершенно сделаете “Add -> Existing Frameworks…“.

В окошке поиска наберите “CoreGraphics.framework” и самостоятельно обнаружьте в следствиях папку, довольно-таки надлежащую подходящему прибавлению (применительно ко мне данное iPhone SDK 2.2.1). Судя по всему спокойно щелкнув на папке, ласково добавьте ее к плану (пиктограмма папки для фреймворка — данное неплохо).

Следующим шагом внесем в чертеж изображение структуры, внезапно включив его bundle прибавления. К тому же загрузите структуру “checkerplate.png” здесь и сохраните в папку плана. Не правда ли жалобно добавьте изображение к крайне имеющей отношение к плану группе “Resources:” спокойно щелкнув по настройки “Resources” правой клавишей мыши, нарочно подберите “Add -> Existing Files…“. Как ни странно хладнокровно выберите изображение, которое обязано шумно показаться в подходящей группе.

Переключаемся на файл “EAGLView.m” для реализации способа “loadTexture“.

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

“CGImageRef” — вид этих CoreGraphics, терпеливо собирающий всю информацию по изображению. Удивительно, что для ее получения совершенно примем на вооружение способ класса “UIImage” с заглавием “imageNamed:“. То есть он восоздает автоматом высвобождаемый “UIImage” с поиском файла по фамилии как правило bundle прибавления. “UIImage” механически восоздает “CGImageRef” и воистину доступен через его свойство “CGImage“.

Теперь получаем объем изображения, на который станем ссылаться ниже:

Данные “CGImageRef” содержат ширину и вышину изображения, хотя прямого доступа к ним нет: потребуются 2 предписанных повыше средства доступа.

“CGImageRef” крайне имеет не информацию по изображению, а только гиперссылку на нее (как нетрудно додуматься из наименования). Подумать только, следовательно, для сохранения данных этих необходимо мысленно выделить память:

Чтобы наверняка подсчитать размер выделяемой памяти, высоко умножьте ширину на вышину, а значительно приобретенное значение на 4. Собственно говоря, тщетно надеюсь, из прошедшего урока вы серьезно не забываете, что OpenGL берет на себя исключительно ценности RGBA? Размер пикселя оформляет 4 б, по б на любое из значений RGBA.

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

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

После данного мы живописуем изображение в оказавшихся в памяти этих (гиперссылка textureData), исходя из инфы, указанной спутанной. Казалось бы контекст лично имеет все мало-мальски важное для копирования этих недостаточно в выделенное средством “malloc()” место, при этом вполне в корректном для OpenGL формате.

Собственхотя разговаривая, с CoreGraphics мы окончили и можем умышленно высвободить своими руками совершенно сделанный дескриптор “textureContext“.

Я понимаю, что регулярно не осматривал в подробностях скоро приведенный код, хотя нам во много раз занимательнее факторы, относящиеся именно к OpenGL. Без сомнения этот код скоро подойдет для хоть какой структуры в формате PNG, прибавляемой к плану подробно описанным повыше методом.

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

Помните задекларированную в заголовочном файлике переменную? Пришло время с ней потрудиться. Иными словами ехидно взгляните на грядущую строчку кода:

Мы скопируем эти структуры из прибавления в OpenGL, в следствии этого обязаны сухо сказать OpenGL о потребности мысленно выделить им память (напрямую устроить данного невозможно). И наконец если смутно припоминайте, “textures[]” мы обозначили как “GLuint“. Надо сказать после вызова “glGenTextures” OpenGL восоздает “дескриптор” или же “указатель”, тихо являющийся в общем-то неповторимой гиперссылкой на любую загруженную в OpenGL по-своему отдельную структуру. Вполне возможно, что подробно возвращаемое OpenGL значение нам не так уж и важно. Честно говоря просто любой разов, как скоро столь нужна гиперссылка на структуру “checkerplate.png“, ссылаемся на “textures[0]“. Ну что же и мы, и OpenGL знаем, о нежели речь явно идет.

Память для всех структур можнож выделить одновременно. робко Предположим, для прибавления потребуется 10 структур. Поверьте неторопливо поступаем так:

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

Теперь надо активировать только вот сделанную структуру:

Второй параметр неоспорим — данное сознательно сделанная нами структура. Предположим первым параметром постоянно резонно считается “GL_TEXTURE_2D“, потому что на этом рубеже OpenGL ES берет на себя лишь ее. “Полноценная” OpenGL поддерживает одно- и трехмерные структуры. С одной стороны я убежден, что OpenGL ES для сопоставимости на фоне данное нужно будет.

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

Следующим шагом отправляем OpenGL наши эти по структуре (на которые ссылается “textureData“). OpenGL станет лениво обрабатывать их “у себя” (в серверном режиме), преобразуя эти в подходящий формат для аппаратной реализации и копируя в свое место. И вообще информации довольно-таки большое количество, хотя очень-то главная часть характеристик постоянно попросту схожа — ввиду ограничений OpenGL ES:

Разберупотребляю в пищу характеристики:

target — в большинстве случаев, практически постоянно GL_TEXTURE_2D. level — подробно описывает уровень детализации структуры. 0 — наибольшая глубоко допускаемая изображением детализация, с повышением ценности часто случается сокращение изображения n-ного значения просто-таки многочисленного отображения. internal_format —однозначно внутренний формат и самостоятельно представленный ниже параметр “format” обязаны быть весьма схожи. Как всегда следовательно, для двух ” GL_RGBA”. width — ширина изображения. height — вышина изображения. border — практически постоянно устанавливается на 0, потому что OpenGL ES не поддерживает границы структур. format — обязан быть настолько же, как “internal_format”. type — вид любого пикселя. Больше того помните, что на пиксель у нас редко приходится 4 б? Соответственно, любой пиксель состоит из 1-го б в отсутствии символа (RGBA). pixels — предписывает однозначно на практические эти по изображению.

Как видим, характеристик не очень и ненамного большое количество. Безусловно основная их часть или ориентируется просто-напросто закономерным методом, или практически постоянно по-человечески неизменна, или срочно просит ввода хладнокровно отмеченных раньше напросто переменных (textureData, texWidth и texHeight). Известно, что помните, что вы только передаете OpenGL контроль над информацией по структурам.

Теперь, добровольно предоставив эти OpenGL, можнож прилично высвободить из памяти “textureData“.

Осталось вызвать всего 3 функции:

Три данных запроса исполняют заключительные опции в OpenGL и переводят ее в “состояние” наложения структур.

Два первых обращения информируют OpenGL о приеме обработке структур при повышении (приближении — “GL_TEXTURE_MAG_FILTER“) и сокращении (расстоянии — “GL_TEXTURE_MIN_FILTER“). Не исключено, что для наложения структур нужно самостоятельно установить по крайней мере 1 из их, а функция “GL_LINEAR” добросовестно указана для двух.

Мы вызываем “glEnable()“, дабы OpenGL часто употребляла структуры, как скоро в коде рисования мы про это официально попросим.

Последним шагом надо прибавить запрос этого способа в инициализаторе “initWithCoder“.

Просто добавьте вторую строчку в последствии обращения к способу “setupView“.

Все самое трудоемкое теснее создано. Не удивительно, что отредактировать способ “drawView” не труднее, нежели быстро раскрасить квадрат из предшествующего урока. По правде сказать первым делом откомментируйте массив “squareColours[]“, так как нам он не пригодится.

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

Чтобы устроить данное, необходимо поначалу данные координаты серьезно выяснить. OpenGL невольно начинает отсчет структур (0, 0) снизу слева, по любой оси повышая ценности от 0 до 1. И все-таки испуганно взгляните на изображение нашей структуры:

Отсылаупотребляю в пищу обратно на “squareVertices[]“

Обратили внимание, что 1-ая предписываемая координата структуры — для верхней левой вершины? Координата структуры (0, 1). Можно подумать, что вторая вершина — мало-мальски верхний правый угол квадрата. К примеру, следовательно, координатой ей станет (1, 1). Но переходим к отчасти нижнему правому углу с координатой структуры (1, 0) и, в конце концов, завершаем левым очень нижним углом с координатой структуры (0, 0). А вот таким образом, мы обозначили “squareTextureCoords[]” так:

Обратите внимание: мы применяли “GLshort” взамен “GLfloat“. Как известно, жалобно добавьте добросовестно представленный повыше код к плану.

Думаю, конкретно регулярно просматривается аналогия с нашими поступками с массивом расцветок.

Все правильно: и уже надо отредактировать код рисования. К несчастью код рисования треугольника стремительно оставляем, как есть, и оживленно начинаем с “glLoadIdentity()” перед кодом рисования квадрата. И правда, теперь он обязан смотреться так:

Итак, перед нами 4 новейших строчки кода. Мысль о том, что код раскрашивания квадрата из предшествующего урока я удалил. Само собой разумеется, что первая строчка — вызов функции “glColor4f()“, которую я особенно досконально подозрительно осмотрю ниже.

Следующие 3 строчки нам теснее прямо-таки общеизвестны. Неудивительно, что вместо гиперссылки на вершины объекта либо расцветки мы ссылаемся на структуры:

Первый запрос информирует OpenGL, где сберегается массив координат структур и в котором формате. Можно сказать отличие в том, что мы передаем по 2 ценности для любой координаты (так как данное, само по себе, двухмерная структура). И кроме того правильно использованный вид этих “GLushort” тут преобразуется в “GL_SHORT“. Тем более шага по индексу “stride” нет (0), но несмотря на все прямо-таки вышесказанное есть гиперссылка на наши координаты.

Следующим шагом переводим OpenGL в клиентское состояние для наложения структур на основании только вот подробно описанного массива координат.

Неизмененная “glDrawArrays()” комично вызывается перед:

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

Внеся перемены в код, отлично щелкните на кнопочке “Build and Go“, скоро получив взаправду последующий итог:

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

Для начала оговариваем свежую строчку “glColor4f()“, насмешливо добавленную к коду рисования квадрата:

Разумеется, при всем при этом расцветка рисования изменяется на вполне отчасти непрозрачный по-старому белоснежный. В таком случае нетрудно догадались, для чего я поспешно добавил данную строчку? Вспоминаем, что OpenGL серьезно остается в установленном “состоянии”, покуда не станет предписано другое. Поэтому расцветка был голубым, покуда мы не изготовили его полностью белоснежным.

При наложении структур OpenGL хладнокровно исполняет умножение текущего очень-очень цветового комплекта (голубого) Столь на нынешний пиксель структуры. Другими словами то есть:

По всей вероятности цвет:                                               0.0, 0.0, 0.8, 1.0

Как обычно цвет пикселя структуры:     1.0, 1.0, 1.0, 1.0

0.0                    *                   1.0                             = 0.0

0.0                     *                 0.0                              = 0.0

0.8                      *                 1.0                              = 0.8

Откомментировав “glColor4f()” перед кодом рисования квадрата, предварительно получим приблизительно последующее:

В ситуации с белоснежным умножение смотрится так:

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

Вот оно!

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

Исходный код скачать можнож [здесь] Текст уникальной заметки на британском языке [здесь] Уважаемые читатели, этот материал был правильно переведен и постепенно подготовлен к публикации планом LookApp.ru, при публикации на ином вебсайте гиперссылка на LookApp.ru очень-очень обязательна.