В этом пособии вы найдете легкие инструкции со скриншотами для установки компилятора (MINGW компилятора), инструмента, который позволит вам преобразовать код, который вы пишете в программу и Code::Blocks, бесплатную среду разработки для C и C++. В этом пособии объясняется как установить Code::Blocks на Windows 2000, XP, Vista или Windows 7. Примечание: если вы работаете в Linux, перейдите по ссылке, чтобы узнать, как использовать GCC, если вы используете OS X, нажмите здесь, чтобы настроить его с помощью Apple XCode.

Шаг 1: Скачивание Code::Blocks

• Зайдите на этот сайт
• Перейдите по ссылке Download the binary release (прямая ссылка)
• Перейдите в раздел Windows 2000 / XP / Vista / 7
• Найдите файл, у которого в названии есть mingw . (Название на момент написания статьи было codeblocks-10.05 mingw-setup.exe; версии 10.05 могут быть разными).
• Сохраните файл на рабочем столе. Это примерно 74 мегабайта.

Шаг 2: Установка Code::Blocks

• Дважды щелкните на программу установки.
• Нажмите next несколько раз. Другие пособия по установке предполагают, что вы устанавливаете в C:\Program Files\CodeBlocks (место установки по умолчанию), но вы при желании можете установить в любом другом месте
• Проведите полную установку
• Запустите Code::Blocks

Шаг 3: Запуск в Code::Blocks

Перед вами откроется окно Compilers auto-detection:

Когда перед вами появится окно автоматического обнаружения компилятора, просто нажмите OK. Code::Blocks может спросить, хотите ли вы связать его с просмотром C/C++ файлов по умолчанию — я советую вам это сделать.

Нажмите на меню File и в разделе New , выберите Project ... Появится следующее окно:

Нажмите на Console Application , а затем Go . Нажимайте next , пока не дойдете до :

Вам будет предложено выбрать между C или C++. Если вы не уверены, используйте C++. В противном случае, выберите язык, который вы изучаете. (Вы можете найти пособия по С и С++ .)

После нажатия Next , Code::Blocks спросит, где вы хотите сохранить консольное приложение:

После нажатия Next еще раз, вам будет предложено настроить компилятор:

Вам не нужно ничего делать, просто нажмите Finish и используйте значения по умолчанию.

Теперь слева вы можете открыть файл main.cpp:

(Вам, возможно, потребуется раскрыть содержание папки Sources , если вы не видите main.cpp).

Теперь у вас есть свой файл main.cpp , который вы можете изменять при желании. На данный момент, он просто говорит: Hello World! , поэтому мы можем запустить его таким, какой он есть. Нажмите F9 , для того чтобы сначала скомпилировать, а потом запустить его.

Теперь у вас есть работающая программа! Вы можете просто отредактировать main.cpp, а затем нажать клавишу F9, чтобы скомпилировать и запустить его снова.

Теперь, когда вы закончили установку компилятора, самое время учиться программированию: на C++ (или, если вы изучаете C, программирование на C).

Поиск и устранение неисправностей

Если что-то не работает, то чаще всего появляется сообщение:

CB01 — Debug» uses an invalid compiler. Probably the toolchain path within the compiler options is not setup correctly?! Skipping…

Во-первых, убедитесь, что вы скачали правильную версию Code::Blocks, ту, которая содержит MinGW . Если так вы не решите проблему, то, скорее всего, проблема с автоматическим обнаружением компилятора. Вы можете проверить текущее состояние «авто-определения» так. Перейдите в Settings|Compiler and Debugger... . Затем слева выберите Global Compiler Settings (он имеет значок с изображением шестеренки), а справа, выберите вкладку Toolchain executables . В этой вкладке есть Auto-Detect , который можно использовать. Это может решить проблему — если нет, вы можете сделать это вручную. На скриншоте показано, как все это выглядит на моей системе. Измените путь с пометкой Compiler"s installation directory , если вы установили в другом месте, и убедитесь, что все остальное заполняется как показано на рисунке.

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

Интегрированная среда разработки (IDE) Code::Blocks (далее CB) представляет собой полноценный продукт для разработки приложений на языке C/C++. CB – это кроссплатформенная среда, разработанная с использованием библиотеки инструментов wxWidgets. Имеются версии среды как для Windows, так и для других операционных систем (ОС) - Linux и Mac OS. Эта IDE абсолютно бесплатна, имеет открытый исходный код и построена полностью с использованием открытых технологий. Одним из самых сильных сторон CB является поддержка создания приложений wxWidgets – т. е. такого программного обеспечения (ПО), которое для отрисовки графического пользовательского интерфейса (GUI) использует API ОС. Другими словами, CB позволяет создавать кроссплатформенное ПО на любой вкус.

CB умеет работать с большим количеством компиляторов. Если в системе их установлено несколько - можно с лёгкостью переключаться между ними, в зависимости от потребности. Плюс ко всему, IDE сама на этапе установки просканирует систему на наличие доступных компиляторов и предложит задействовать один как основной. Доступна возможность позже изменять эти настройки как глобально, так и отдельно для проектов. Для глобальных настроек среды существует целый раздел «Settings» в главном меню CB. Чтобы внести какие-либо специфические настройки, характерные для конкретного проекта, нужно открыть окно свойств проекта. Для этого необходимо вызвать контекстное меню проекта, кликнув по нему правой клавишей мыши, и выбрать пункт «Properties». Сами проекты (открытые в данный момент в IDE) выведены в виде дерева в док-панели «Management», в её вкладке «Projects». Теперь, в открывшемся окне свойств можно настраивать самые разнообразные параметры, начиная от редактирования целей сборки и заканчивая подключением сторонних библиотек. Кнопка «Project’s build options» на вкладке «Project Settings» того же окна свойств позволит очень гибко настроить для конкретного проекта конфигурацию сборки: ключи компилятора, выбрать сам компилятор, подключить библиотеки для линковщика и т. п. Всё это можно проделать для отдельных режимов: «Release» «Debug».

GUI CB построен на основе плавающих и растягивающихся док-панелей, которые можно пристыковывать к любым сторонам главного окна IDE, просто перетаскивая их мышкой. Благодаря этому, можно очень гибко настраивать различные компоновки интерфейса для различных размеров экрана, оптимизируя эргономику GUI. Если мониторов несколько - удобно отделить некоторые панели от основного окна и разместить их на соседних мониторах.

Подсветка, автодополнение кода и средства редактирования в CB делают процесс работ с кодом лёгким и комфортным. Огромный арсенал настроек позволяет очень тонко настраивать среду «под себя». Очень полезным является наличие поддержки работы с переменными окружения. Благодаря этой возможности CB можно очень тесно интегрировать в систему и расширять его возможности, например, таким образом можно подключать библиотеку wxWidgets.

Разработка приложений для встраиваемых устройств

Часть 2. Применение Code::Blocks для разработки AVR-приложений

Серия контента:

В предыдущей статье мы рассказали, как с помощью среды разработки Eclipse создавать приложения для микропроцессоров серии AVR фирмы Atmel с использованием комплекта компиляторов GNU AVR GCC. Рассматривалась настройка Eclipse с использованием подключаемого модуля AVR Plugin, а также ручная настройка среды. Сейчас мы покажем, как такую же задачу можно решить с помощью другой, более легкой и очень удобной среды разработки Code::Blocks.

Знакомство со средой

Создание проекта

Если еще ни одного проекта в рабочем пространстве не создано, то после запуска Code::Blocks в центральной панели активна только вкладка «Start here». Для создания нового проекта нужно выбрать команду «Create a new project» или пункт меню «File->New->Project». В любом случае откроется окно выбора шаблона будущего проекта, в котором мы указываем шаблон «AVR Project» и нажимаем кнопку «Go».

Появится приветственное окно мастера создания AVR-проекта. Нажмите кнопку «Next» и в открывшемся диалоговом окне введите название проекта и каталог, в котором он будет находиться. На основании этих данных программа автоматически предложит пользователю имя файла проекта с расширением *.cbp и каталог проекта, который будет создан. Далее следует нажать кнопку «Next».

В следующем окне предлагается выбрать конфигурации сборки, которые будут использоваться в проекте. По умолчанию активны обе конфигурации: Debug и Release. Компилятор «GNU AVR GCC Compiler» указан заранее. Также здесь можно изменить стандартные каталоги для скомпилированных файлов конфигураций.

В следующем окне мы указываем тип целевого процессора, выбрав его из выпадающего списка (позже это можно сделать в параметрах компиляции). Если в проекте используется внешняя память, стоит указать ее параметры. Далее следует задать значение глобальной переменной проекта F_CPU, указав тактовую частоту процессора в герцах. По умолчанию включено создание файла карты символов (.map) и hex-файлов, а также файла дизассемблерного листинга (.lss). Еще полезно включить параметр «Run avr-size after build» – тогда в конце журнала сборки проекта появится информация о том, сколько места будет занято в памяти программ и в оперативной памяти. По какой-то причине включение параметра создания листинга не оказывает никакого действия при создании проекта, и нужно вручную добавить соответствующую команду в «Pre/post build steps». Нажмите кнопку «Finish» (рисунок 2).

Проект создан, и в него автоматически добавлен первый файл – main.c.

Настройка проекта и среды разработки

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

1. Выберите пункт меню «Project->Build options». Откроется окно настроек параметров сборки (рисунок 3). В левой панели находится дерево целей сборки. На самом верхнем его уровне – настройки сборки для всего проекта. Удобнее всего сначала указать параметры для всего проекта, а уже затем добавлять что-то в отдельных вариантах сборки.
   
   

   Прежде всего нужно убедиться в том, что в поле «Selected Compiler» выбран «GNU AVR GCC Compiler». Ниже, на вкладке «Compiler Flags», приводятся флаги компилятора. По умолчанию здесь уже включен полезный флаг «Enable all compiler warnings». Также стоит убедиться в том, что мы правильно выбрали тип процессора, для которого разрабатывается проект.

   На вкладке «#defines» показано значение переменной F_CPU, если оно было задано при создании проекта.

   На вкладке «Linker Options» в панели «Other linker options» видно, что компоновщику задан правильный параметр -mmcu, а в левой панели «Link libraries» нужно указать необходимые для проекта библиотеки, если они есть.

   Перейдите к вкладке «Search directories». Ниже, на вкладке «Compiler», нужно вставить путь к заголовочным файлам, например, /usr/avr/include/. Для этого воспользуйтесь кнопкой «Добавить» и впишите правильный путь. Аналогично, на вкладке «Linker» указываем путь к библиотекам AVR GCC, например, /usr/avr/lib.

   Вкладка «Pre/post build steps». В поле «Post-build steps» можно увидеть команды для запуска утилит avr-size, avr-objcopy, avr-objdump. Например, для получения листинга (поскольку включение параметра «Create extended listing file» в мастере создания проекта не производит нужного эффекта, по крайней мере в версии 8.02) добавляем такую команду:

   avr-objdump -h -S $(TARGET_OUTPUT_FILE) > $(TARGET_OUTPUT_FILE).lss

   Если теперь с параметров всего проекта переключиться на более конкретные цели сборки, например, Debug или Release, то можно внести некоторые изменения в параметры сборки. При этом обратите внимание на то, что стал доступен параметр «Policy». Его стандартное значение – «Append target options to project options», т.е. к общим параметрам проекта добавляются параметры для конкретной цели сборки. Есть и другие варианты объединения настроек разных уровней. Это позволяет гибко настраивать проект, не повторяя уже введенные общие параметры.

   Стандартные настройки предусматривают автоматическое включение создания отладочной информации в цели Debug (параметр «-g») и оптимизацию размера полученной программы в цели Release (параметр «-Os»).

2. Выберите пункт меню «Project->Properties». Здесь стандартные настройки вполне подходят, чтобы начать работать с проектом, ничего в них не меняя. Стоит обратить внимание на вкладку «Build targets». Для каждой цели сборки (по умолчанию: Debug и Release) указывается, куда записываются получаемые объектные файлы, а в поле «Build target files» можно задавать, какие исходные файлы участвуют в данной сборке (рисунок 4).
   
   

   При желании можно свой настроенный проект сохранить как шаблон для будущих проектов. Для этого нужно выбрать команду меню «File->Save project as user template...» и ввести имя шаблона. В дальнейшем, при создании нового проекта, можно выбрать желаемый шаблон в категории «User templates» (рисунок 5). После этого потребуется задать пустой каталог, где будет создан новый проект, а затем отредактировать имя проекта.

   
   

   Можно даже изменить существующий стандартный шаблон. Для этого в окне выбора шаблонов нажмите правую кнопку мыши на нужном шаблоне и воспользуйтесь опцией «Edit this script» в появившемся меню.

3. Перед тем как что-нибудь собирать, нужно еще заглянуть в глобальные настройки компилятора. Это делается через главное меню: «Settings->Compiler an debugger settings». В открывшемся окне левой панели нажмите на значок «Global compiler settings». На самом верху правой панели в верхнем поле «Selected compiler» выберите «GNU AVR GCC compiler» (рисунок 6).
   
   

   На вкладке «Compiler settings» вряд ли стоит что-либо менять: эти параметры станут стандартными для всех AVR-проектов. А вот на вкладках «Search directories->Compiler» и «Search directories->Linker» в моем случае уже стояли стандартные пути /usr/include и /usr/lib соответственно, что было неверно. Можно тут указать правильные пути (например, /usr/avr/include и /usr/avr/lib), а в настройках проекта удалить эти же пути, я же просто очистил эти поля кнопками «Clear», потому что параметры проекта к этому моменту уже были настроены.

   На вкладке «Toolchain executables» проверяем, правильно ли указаны имена исполняемых файлов из комплекта AVR GCC и пути к ним. С помощью кнопки «autodetect» можно попробовать автоматически определить все эти значения. Если же что-то получилось не так (например, дистрибутив AVR GCC оказался с экзотическими именами и каталогами для размещения), то это как раз место, где все можно исправить вручную. На рисунке 7 в поле «Compiler"s installation directory» должно быть указано «/usr», если программы AVR GCC размещаются в каталоге /usr/avr/.

   
   

   И последнее. На вкладке «Other settings» есть поле «Compiler logging». В нем можно задать режим журналирования процесса компиляции. Рекомендуется установить здесь значение «Full command line». Это позволит подробно проследить команды, используемые при сборке.

Теперь Code::Blocks готов к сборке проекта!

Использование собственного makefile для своего проекта

Всегда может возникнуть нестандартная ситуация, когда процесс сборки проекта нужно взять под свой полный контроль. Для этого в Code::Blocks предусмотрена возможность работы с собственным файлом сборки. Чтобы воспользоваться ею, необходимо создать пустой проект и сохранить его. Теперь нужно указать, что используется собственный makefile:

1. Выберите пункт меню «Project -> Properties».
2. Перейдите на вкладку "Project Settings".
3. Поставьте галочку в поле "This is a custom makefile".
4. Убедитесь, что указано правильное имя файла в поле «Makefile:».
5. Теперь на вкладке «Build targets» нужно изменить или добавить цели сборки в соответствии с имеющимся makefile, например: all cleanall

При использовании собственного makefile следует проверить, какие команды имеются на вкладке «Make Commands» в пункте меню «Project ->Build Options».

Пробная программа

Во вновь созданном по AVR-шаблону проекте уже имеется файл main.c, который содержит заготовку модуля main для программы на С. Напишем новую программу на С++.

Воспользуйтесь опцией меню «File->New->File...» , выберите «C++ source» и нажмите кнопку «Go». Появится приветственное окно мастера создания нового исходного файла. Нажмите кнопку «Next» и в следующем окне выберите язык программирования для этого файла: С++. Далее укажите имя файла (например, sample.cpp) и полный путь к этому файлу, для чего нажмите кнопку «...» справа от поля с именем файла. Затем нужно указать, в каких целях сборки этот файл будет присутствовать, для чего можно просто нажать кнопку «All». Нажмите кнопку «Finish».

В созданный пустой файл впишите простейшую C++ программу:

int main(void) { const int some_size = 1000; while (true) { for (int i = 0; i < some_size; i++) int a = 3; // какое-нибудь действие } return 0; // никогда не дойдет сюда }

Сохраните файл, нажав клавиши Ctrl+S. Файл main.c нам не нужен, его можно удалить из проекта, нажав на его имени правую кнопку мыши и выбрав из появившегося меню команду «Remove file from project» (рисунок 8).

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

Скомпилируем программу. Для этого нужно выбрать команду меню «Build->Build» или нажать знакомую многим комбинацию клавиш Ctrl+F9, также можно использовать кнопку с голубой шестеренкой в панели инструментов. Программа будет скомпилирована, а окно сообщений внизу экрана автоматически переключится на вкладку «Build messages», где будет сказано, что сборка закончена, получилось 0 ошибок и одно предупреждение: в строке 8 неиспользованная переменная «a».

Немного об отладке

Подход к отладке AVR-приложений в значительной степени зависит от используемого оборудования. При наличии устройства AVR JTAG ICE можно производить внутрисхемную отладку, подключаясь с его помощью к процессору, используя для этого утилиту avarice. Если такого устройства нет, воспользуйтесь имитатором процессора simulavr. К сожалению, этот проект уже несколько лет не развивается, но разработчики продолжают выпускать исправления.

Чтобы настроить отладку в Code::Blocks, нужно открыть свойства проекта «Project->Properties» и перейти на вкладку «Debugger». Здесь в поле «Select target» выбираем «Debug». Для этой конфигурации на вкладке «Remote connection» указываются параметры подключения avr-gdb к удаленной цели отладки:

• «Connection type»: TCP.
• «IP address»: localhost, если устройство отладки (или имитатор) подключено к этому же компьютеру.
• «Port»: например, 1212.

Теперь на вкладке «Additional commands» в поле «After connection» нужно вписать следующие команды для отладчика:

load break main

Первая команда загрузит программу в цель отладки (микропроцессор или имитатор), а вторая вставит точку останова на функции main.

Перед отладкой нужно запустить в терминале simulavr:

simulavr -g -p 1212 -d atmega128

(для процессора atmega128), получится примерно такой вывод:

$ simulavr -g -p 1212 -d atmega128 Simulating a atmega128 device. ... main.c:415: MESSAGE: Simulating clock frequency of 8000000 Hz Waiting on port 1212 for gdb client to connect...

Если устройство подключено к последовательному порту /dev/ttyS0, запуск avarice можно произвести такой командой:

avarice -j /dev/ttyS0 -P atmega128:1212

Теперь можно запускать отладку в Code::Blocks при помощи команды меню «Debug->Start». В окне, где запущен simulavr, добавятся примерно такие сообщения:

Connection opened by host 127.0.0.1, port -14999. decoder.c:737: MESSAGE: BREAK POINT: PC = 0x00000068: clock = 34

При этом в редакторе Code::Blocks будет загружен исходный текст, содержащий функцию main, и курсор отладчика остановится на этой функции, как это показано на рисунке 9. Теперь можно пользоваться удобными кнопками для управления отладчиком в панели инструментов, просматривать значения переменных и так далее. Более подробно об отладке можно узнать в документации на gdb, simulavr или avarice.

Заключение

Итак, мы рассказали, как, затратив минимум усилий и времени, не обращаясь к документации и руководствам, быстро приступить к разработке AVR-приложений с использованием замечательной и быстро развивающейся среды разработки Code::Blocks. В настоящее время интерфейс среды переведен на множество языков и, возможно, скоро локализованные файлы войдут в состав основной ветви разработки.

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

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

Введение

Итак, в свободное от работы время решил я изучить популярный графический API. Прочитав несколько книг и разобрав кучу примеров и туториалов (в том числе из DirectX SDK), я осознал, что настал тот самый момент, когда стоит попробовать свои силы самостоятельно. Основная проблема была в том, что большинство существующих примеров просто демонстрируют ту или иную возможность API и реализованы процедурно чуть ли не в одном cpp-файле, да еще и с использованием обертки DXUT, и не дают представления о том, какую структуру должно иметь конечное приложение, какие классы нужно спроектировать и как это все должно друг с другом взаимодействовать, чтобы все было красиво, читабельно и эффективно работало. Данный недостаток касается и книг по Direct3D: например, для многих новичков не является очевидным тот факт, что состояния рендера (render states) не всегда нужно обновлять при отрисовке каждого кадра, а также, что большинство тяжеловесных операций (типа заполнения вершинного буфера) следует выполнить всего один раз при инициализации приложения (либо при загрузке игрового уровня).

Идея

Первым делом мне необходимо было определиться с самой идеей игры. На ум сразу пришла старая игра из 1992 года под MS-DOS, которая, я думаю, многим знакома. Это логическая игра Lines компании Gamos.

Что ж, вызов принят. Вот что мы имеем:

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

Теперь посмотрим с точки зрения приложения Direct3D:

• поле из ячеек сделаем в виде трехмерной платформы с выступами, каждая ячейка будет представлять из себя что-то типа подиума;
• должно быть реализовано три вида анимации шаров:
  1. появление шара: сначала появляется маленький шар, который за короткое время вырастает до взрослого размера;
  2. перемещение шара: просто происходит последовательное передвижение по ячейкам;
  3. прыгающий шар: при выборе шара мышью он должен активизироваться и начать прыгать на месте;
• должна быть реализована система частиц, которая будет использоваться при анимации взрыва;
• должен быть реализован вывод текста: для отображения на экране заработанных очков;
• должно быть реализовано управление виртуальной камерой: вращение и зум.

По сути дела пункты, перечисленные выше, являются жалким подобием документа под названием дизайн-проект. Настоятельно рекомендую перед началом разработки расписать в нем все до мелких подробностей, распечатать и держать перед глазами! Забегая вперед сразу показываю демо-ролик для наглядности реализации пунктов (кстати, видео записано с помощью программы ezvid , так что не пугайтесь их сплэш-скрина в начале):

Начало разработки

До сих пор я не упоминал, какие инструменты использовались. Во-первых, необходим DirectX software development kit (SDK), всегда доступный для свободного скачивания на сайте Microsoft: DirectX SDK . Если вы собираетесь использовать версию Direct3D 9, как я, то после установки необходимо через главное меню открыть DirectX Control Panel и на вкладке Direct3D 9 выбрать, какая версия библиотек будет использоваться при сборке — retail либо debug (это влияет на то, будет ли Direct3D сообщать отладчику о результатах своей деятельности):

Debug или retail

Почему Direct3D 9-й версии? Потому что это последняя версия, где все еще есть fixed function pipeline, то есть фиксированный графический конвейер, включающий в себя, например, функции расчета освещения, обработки вершин, смешивания и так далее. Начиная с 10-й версии, разработчикам предлагается самостоятельно реализовывать эти функции в шейдерах, что является неоспоримым преимуществом, но, на мой взгляд, сложновато для восприятия при первых опытах с Direct3D.

Почему Code::blocks? Наверное, глупо было использовать кросс-платформенную IDE для разработки приложения, использующего некросс-платформенный API. Просто Code::blocks занимает в несколько раз меньше места, чем Visual Studio, что оказалось очень актуальным для моего дачного ПК.

Старт разработки с Direct3D оказался очень прост. В Code::blocks я создал пустой проект (empty project), затем в build options нужно было сделать две вещи:

1) На вкладке search directories и подвкладке compiler добавить путь к директории include DirectX SDK — например, так:

Search directories

2) На вкладке linker добавить две библиотеки — d3d9.lib и d3dx9.lib:

Linker

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

#include "d3d9.h" #include "d3dx9.h"

Структура приложения

Здесь я допустил первую ошибку: начал размышлять над тем, какой шаблон проектирования выбрать. Пришел к выводу, что лучше всего подходит MVC (model-view-controller): моделью будет класс игры (game), включающий всю логику - вычисление путей перемещения, появление шаров, разбор взрывных комбинаций; представлением будет класс движка (engine), отвечающий за отрисовку и взаимодействие с Direct3D; контроллером будет собственно обертка (app) - сюда входит цикл обработки сообщений, обработка пользовательского ввода, а также, что самое главное, менеджер состояний и обеспечение взаимодействия объектов game и engine. Вроде бы все просто, и можно начинать писать заголовочные файлы, но не тут-то было! На этом этапе оказалось очень сложно сориентироваться и понять, какие методы должны быть у этих классов. Понятно, что сказалось полное отсутствие опыта, и я решил прибегнуть к совету одной из книг: «Не пытайтесь с самого начала написать идеальный код, пусть он будет неоптимальным и сумбурным. Понимание приходит со временем, и рефакторингом можно заняться потом.» В итоге после нескольких итераций рефакторинга уже работающего макета определение трех основных классов приняло вид:

Класс TGame

class TGame { private: BOOL gameOver; TCell *cells; WORD *path; WORD pathLen; LONG score; void ClearField(); WORD GetSelected(); WORD GetNeighbours(WORD cellId, WORD *pNeighbours); BOOL CheckPipeDetonate(WORD *pPipeCells); public: TGame(); ~TGame(); void New(); BOOL CreateBalls(WORD count); void Select(WORD cellId); BOOL TryMove(WORD targetCellId); BOOL DetonateTest(); WORD GetNewBallList(TBallInfo **ppNewList); WORD GetLastMovePath(WORD **ppMovePath); WORD GetDetonateList(WORD **ppDetonateList); LONG GetScore(); BOOL IsGameOver(); };

Класс TEngine

class TEngine { private: HWND hWindow; RECT WinRect; D3DXVECTOR3 CameraPos; LPDIRECT3D9 pD3d; LPDIRECT3DDEVICE9 pDevice; LPDIRECT3DTEXTURE9 pTex; LPD3DXFONT pFont; D3DPRESENT_PARAMETERS settings; clock_t currentTime; TGeometry *cellGeometry; TGeometry *ballGeometry; TParticleSystem *psystem; TBall *balls; TAnimate *jumpAnimation; TAnimate *moveAnimation; TAnimate *appearAnimation; LONG score; void InitD3d(); void InitGeometry(); void InitAnimation(); void DrawPlatform(); void DrawBalls(); void UpdateView(); public: TEngine(HWND hWindow); ~TEngine(); void AppearBalls(TBallInfo *ballInfo, WORD count); void MoveBall(WORD *path, WORD pathLen); void DetonateBalls(WORD *detonateList, WORD count); BOOL IsSelected(); BOOL IsMoving(); BOOL IsAppearing(); BOOL IsDetonating(); void OnResetGame(); WORD OnClick(WORD x, WORD y, BOOL *IsCell); void OnRotateY(INT offset); void OnRotateX(INT offset); void OnZoom(INT zoom); void OnResize(); void OnUpdateScore(LONG score); void Render(); };

Класс TApplication

class TApplication { private: HINSTANCE hInstance; HWND hWindow; POINT mouseCoords; TEngine* engine; TGame* game; BOOL moveStarted; BOOL detonateStarted; BOOL appearStarted; void RegWindow(); static LRESULT CALLBACK MsgProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam); void ProcessGame(); public: TApplication(HINSTANCE hInstance, INT cmdShow); ~TApplication(); TEngine* GetEngine(); TGame* GetGame(); INT MainLoop(); };

Класс TGame имеет всего 3 метода, которые может инициировать сам пользователь — New (новая игра), Select (выбор шара) и TryMove (попытка переместить шар). Остальные вспомогательные и вызываются контроллером в особых случаях. Например, DetonateTest (тест на взрывные комбинации) вызывается после появления новых шаров или после попытки перемещения. GetNewBallList, GetLastMovePath, GetDetonateList вызываются, соответственно, после появления шаров, после перемещения и после взрыва, с одной целью: получить список конкретных шаров и передать его на обработку объекту engine, чтобы он что-то нарисовал. На логике работы TGame не хочется подробно останавливаться, поскольку есть исходники с комментариями . Скажу только, что определение пути перемещения шара реализовано с помощью алгоритма Дейкстры по неориентированному графу с равными весами всех ребер.

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

TEngine

• В классе определены поля для хранения handle окна и его прямоугольника. Они используются в методе OnResize, который контроллер вызывает при изменении размеров окна, для расчета новой матрицы проекции.
• В поле CameraPos хранятся координаты наблюдателя в мировом пространстве. Вектор направления взгляда хранить не нужно, поскольку по моей задумке камера всегда направлена в начало координат, которое, кстати, совпадает с центром платформы.
• Также имеются указатели на интерфейсы Direct3D: LPDIRECT3D9, который нужен только для создания устройства; LPDIRECT3DDEVICE9 — собственно, само устройство Direct3D, основной интерфейс, с которым приходится работать; LPD3DXFONT и LPDIRECT3DTEXTURE9 для работы с текстом и текстурой.
• Поле currentTime используется для хранения текущего времени в миллисекундах и необходимо для отрисовки плавной анимации. Дело в том, что отрисовка каждого кадра занимает разное количество миллисекунд, поэтому приходится каждый раз замерять эти миллисекунды и использовать в качестве параметра при интерполировании анимации. Такой способ известен под названием синхронизация временем и используется повсеместно в современных графических приложениях.
• Указатели на объекты класса TGeometry (cellGeometry и ballGeometry) хранят геометрию одной ячейки и одного шара. Сам по себе объект TGeometry, как понятно из названия, предназначен для работы с геометрией и содержит вершинные и индексные буферы, а также описание материала (D3DMATERIAL9). При отрисовке мы можем изменять мировую матрицу и вызывать метод Render объекта TGeometry, что приведет к отрисовке нескольких ячеек или шаров.
• TParticleSystem — это класс системы частиц, имеющий методы для инициализации множества частиц, обновления их позиций в пространстве и, конечно же, рендеринга.
• TBall *balls — массив шаров с информацией о цвете и статусе [прыгающий, перемещающийся, появляющийся].
• Три объекта типа TAnimate — для обеспечения анимации. Класс имеет метод для инициализации ключевых кадров, которые представляют собой матрицы мирового преобразования, и методы для вычисления текущей позиции анимации и применения преобразования. В процедуре рендеринга объект engine последовательно отрисовывает шары и при необходимости вызывает метод ApplyTransform нужной анимации, чтобы сдеформировать либо переместить шар.
• InitD3d, InitGeometry, InitAnimation вызываются только из конструктора TEngine и выделены в отдельные методы для наглядности. В InitD3d создается устройство Direct3D и устанавливаются все необходимые render state"ы, включая установку точечного источника освещения со specular-составляющей прямо над центром платформы.
• Три метода AppearBalls, MoveBall и DetonateBalls запускают анимации появления, перемещения и взрыва, соответственно.
• Методы IsSelected, IsMoving, IsAppearing, IsDetonating используются в функции менеджера состояний для отслеживания момента окончания анимации.
• Методы с префиксом On вызываются контроллером при возникновении соответствующих событий: клика мышью, вращении камеры и т.д.

Рассмотрим основной метод Render:

TEngine::Render()

void TEngine::Render() { //вычисляем, сколько миллисекунд прошло с момента отрисовки предыдущего кадра clock_t elapsed=clock(), deltaTime=elapsed-currentTime; currentTime=elapsed; //обновляем позиции анимаций, если они активны if(jumpAnimation->IsActive()) { jumpAnimation->UpdatePosition(deltaTime); } if(appearAnimation->IsActive()) { appearAnimation->UpdatePosition(deltaTime); } if(moveAnimation->IsActive()) { moveAnimation->UpdatePosition(deltaTime); } pDevice->Clear(0,NULL,D3DCLEAR_STENCIL|D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER,D3DCOLOR_XRGB(0,0,0),1.0f,0); pDevice->BeginScene(); //рисуем платформу DrawPlatform(); //рисуем шары DrawBalls(); //если активна система частиц, то обновляем положения частиц и рендерим их с текстурой if(psystem->IsActive()) { pDevice->SetTexture(0,pTex); psystem->Update(deltaTime); psystem->Render(); pDevice->SetTexture(0,0); } //вывод заработанных очков char buf="Score: ",tmp; itoa(score,tmp,10); strcat(buf,tmp); RECT fontRect; fontRect.left=0; fontRect.right=GetSystemMetrics(SM_CXSCREEN); fontRect.top=0; fontRect.bottom=40; pFont->DrawText(NULL,_T(buf),-1,&fontRect,DT_CENTER,D3DCOLOR_XRGB(0,255,255)); pDevice->EndScene(); pDevice->Present(NULL,NULL,NULL,NULL); }

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

TApplication

• Класс имеет поле для хранения координат мыши, поскольку нам необходимо будет вычислять значения относительных смещений курсора, чтобы вращать камеру.
• Булевы флаги appearStarted, moveStarted и detonateStarted необходимы для отслеживания статуса соответствующих анимаций.
• В метод RegWindow вынесен код для регистрации класса окна.
• Static-метод MsgProc — так называемая оконная процедура.
• ProcessGame — упрощенная версия менеджера состояний, в котором оценивается текущее состояние игры и в зависимости от него предпринимаются какие-то действия.
• MainLoop — цикл обработки сообщений.

Вот такой легковесный контроллер. Подобный цикл обработки сообщений можно встретить в любой книге по Direct3D:

TApplication::MainLoop()

INT TApplication::MainLoop() { MSG msg; ZeroMemory(&msg,sizeof(MSG)); while(msg.message!=WM_QUIT) { if(PeekMessage(&msg,NULL,0,0,PM_REMOVE)) { TranslateMessage(&msg); DispatchMessage(&msg); } else { //если нет сообщений, то обрабатываем состояние игры и занимаемся рендерингом ProcessGame(); engine->Render(); } } return (INT)msg.wParam; }

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

А вот и функция менеджера состояний:

TApplication::ProcessGame()

void TApplication::ProcessGame() { if(moveStarted) { //ждем до окончания анимации перемещения if(!engine->IsMoving()) { //перемещение окончено - тестируем на взрыв moveStarted=FALSE; if(game->DetonateTest()) { //инициируем взрыв и увеличиваем очки WORD *detonateList, count=game->GetDetonateList(&detonateList); detonateStarted=TRUE; engine->DetonateBalls(detonateList,count); engine->OnUpdateScore(game->GetScore()); } else { //иначе пытаемся добавить шары if(game->CreateBalls(APPEAR_COUNT)) { TBallInfo *appearList; WORD count=game->GetNewBallList(&appearList); appearStarted=TRUE; engine->AppearBalls(appearList,count); } else { //game over! } } } } if(appearStarted) { //ждем до окончания анимации появления if(!engine->IsAppearing()) { appearStarted=FALSE; //появление окончено - тестируем на взрыв на всякий случай if(game->DetonateTest()) { //инициируем взрыв и увеличиваем очки WORD *detonateList, count=game->GetDetonateList(&detonateList); detonateStarted=TRUE; engine->DetonateBalls(detonateList,count); engine->OnUpdateScore(game->GetScore()); } } } if(detonateStarted) { //ждем до окончания анимации взрыва if(!engine->IsDetonating()) { //просто сбрасываем флаг detonateStarted=FALSE; } } }

Что ж, пожалуй, на этом все!

Надеюсь, мои изыскания принесут кому-то пользу. Кстати, исходники на github .

Спасибо за внимание!

Обещанная литература

1. Frank D. Luna Введение в программирование трехмерных игр с DirectX 9.0 — для понимания основ;
2. Горнаков С. DirectX9 уроки программирования на С++ — тоже основы, но есть главы по DirectInput, DirectSound и DirectMusic. В примерах программ иногда встречаются ошибки;
3. Фленов М. Е. DirectX и C++ искусство программирования — забавный стиль изложения. В основном, целью книги является создание анимационных роликов с использованием интересных эффектов, в том числе с шейдерами. Судите сами по названию разделов: сердечный приступ, огненный дракон;
4. Баррон Тодд Программирование стратегических игр с DirectX 9 — полностью посвящена темам, связанным со стратегическими играми: блочная графика, ИИ, создание карт и ландшафтов, спрайты, спецэффекты с системами частиц, а также разработка экранных интерфейсов и работа с DirectSound/Music;
5. Bill Fleming 3D Creature WorkShop — книга не по программированию, а по разработке трехмерных моделей персонажей в средах LightWave, 3D Studio Max, Animation Master;
6. Thorn Alan DirectX 9 User interfaces Design and implementation — подробная книга о разработке графических интерфейсов с DirectX. Рассматривается иерархическая модель компонентов экранных форм, подобная реализованной в Delphi;
7. Adams Jim Advanced Animation with DirectX — рассматриваются типы анимации (скелетная, морфинг и разновидности) и их реализация, а также работа с геометрией и анимацией из X-файлов;
8. Ламот Андре Программирование игр для Windows. Советы профессионала — эта книга уже посерьезнее: рассматриваются вопросы оптимизации, выбора структур данных под различные задачи, многопоточность, физическое моделирование, ИИ. В последней главе описывается создание игры про космический корабль и пришельцев;
9. David H. Eberly 3D Game engine design — хорошая книга для понимания всей теории игростроения: сначала описываются технологии графических API (трансформации, растеризация, затенение, смешивание, мультитекстурирование, туман и т.д.), затем такие темы, как граф сцены, выбор объектов, определение столкновений, анимация персонажей, level of detail, ландшафты;
10. Daniel Sánchez-Crespo Dalmau Core techniques and algorithmes in game programming — подробно рассматриваются алгоритмы и структуры данных, используемые в задачах игростроения, такие как ИИ, скриптинг, рендеринг в закрытых и в открытых пространствах, алгоритмы отсечения, процедурные техники, способы реализации теней, реализация камеры и т.д.;
11. Ламот Андре Programming Role Playing Games with directX 9 — тысячестраничное подробное руководство по разработке RPG. Включает как теоретические главы по программированию с Direct3D, DirectInput, DirectSound, DirectPlay, так и прикладные главы, имеющие непосредственное отношение к игровому движку.

Теги: Добавить метки

С++ предлагает разработчикам универсальный способ решения задач. Программы на C++ могут компилироваться и запускаться на компьютере, контроллерах, телефонах и даже веб-серверах. Если создавать сайты на C++, тогда они будут работать быстрее, хотя сложность разработки существенно повысится.
Возможности языка С++ для разработчиков программного обеспечения - обязательны для изучения каждым. Для демонстрации этого языка и его работы тут размещены исходные коды двух программ.

Следующая программа написана на C++: Расчёт заработной платы сотрудников предприятия.
Вторая программа: Перевод футов в дюймы.

Ниже представлены задания, скриншоты работы в IDE компиляторе и коды программ на C++.

Итак, в книге "Самоучитель C++", Херберт Шилдт, издательства bhv 1998год предложены задания:
"Напишите программу для ввода количества отработанных персоналом часов и размера почасовой оплаты каждого. Затем выведите суммарную зарплату персонала. (Удостоверьтесь в правильности ввода)."

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

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

Установка компилятора gcc и g++

Под Убунту можно пользоваться для компиляции программ на языке C - компилятором gcc , а для программ на C++ - компилятором g++ . Установите оба компилятора так:

sudo apt-get install gcc g++

С этими компиляторами можно компилировать программы в консоли, также ими пользуются среды программирования.
Через консоль это может выглядеть так: если ваша программа в файле my.cpp, то компилируется так:

g++ my.cpp -o my

это создаст исполняемый файл my, или вы можете назвать по-другому.

Как установить Code::Blocks на Ubuntu

Откройте Центр приложений и в поиске укажите: "Code:" - и среди всего будет эта программа, если написать полное имя, то у меня почему-то не находил.

Эта программа мне показалась неудобной, наверное, потому что в процессе написания программы я её писал как обычный текстовый файл, и подсказок и помощи от IDE было мало, в основном мешала. Но после сохранения файла с расширением cpp код стал подсвеченным, а в процессе доработки улучшилось взаимодействие.
Для компиляции и запуска нужно пользоваться зелёной кнопкой Build and Run, или на русском: Построить и запустить.

Как запустить проект в Code Blocks

Для этого нужно видеть окно сообщений компилятора, чтобы читать сообщения об ошибках. Включается окно: View - Log , или на русском примерно так: Вид - Логи.
Если программа еще не откомпилирована, то нужно нажать кнопку Build and run или Компиляция и запуск. Тогда появятся сообщения в логах и появится окно программы. Если не появилось, исправьте ошибку, обозначенную в логах.
Скриншот экрана Code Blocks

Запуск первой программы на C++ в компиляторе Code::Blocks

Принтскрин программы 1

Принтскрин программы 2

Код программы Расчёт зарплаты сотрудников предприятия, C++

#include

using namespace std;

1. int main()

   // определяем переменные

   int i, n, h;

   double s, sum;

2. //выводим название и приглашение к вводу данных

   cout << "Расчёт общей зарплаты всего персонала предприятия\n " ;

   cout << "\n Введите количество работников: " ;

   cin >> n; //записываем количество работников в переменную n

   cout << "Вводите количество часов работы каждого работника и стоимость часа работы\n " ;

   cout << "(Вводите два числа через пробел и нажимайте Ввод)\n " ;

   //организуем ввод данных в цикле, пока не введем данные о всех n работниках

   i = 1 ;

   sum = 0 ;

   do {

   cout << "Часы и стоимость часа работы " << i << "го сотрудника:\n " ;

   cin >> h >> s;

   sum += s * h; // добавляем к общему бюджету зарплату сотрудника

   i++;

   } while (i<= n) ;

3. cout << "Ввод завершён\n \n Общая зарплата сотрудников предприятия составляет:\n " ;

   cout << sum << "\n " ;

4. return 0 ;

Код программы перевода футов в дюймы, C++

#include

using namespace std;

1. int main()

   int i;

   double f, d;

2. cout << "Программа преобразования футов в дюймы\n " ;

   cout << "Фут = 12 дюймов\n " ;

   cout << "Вводите количество футов, чтобы получать эту длину в дюймах\n " ;

   cout << "(Десятичные доли вводятся через точку)" ;

   cout << "(Для ввода числа пишите число и нажимайте кнопку Ввод)\n " ;

   cout << "(Для выхода из программы введите 0 и нажмите Ввод)\n \n " ;