sdl что это такое
Библиотека SDL — обзор
Intro
SDL позиционируется как инструмент, дающий независимый от платформы низкоуровневый API для доступа к таким возможностям аппаратуры, как 2D и 3D рендеринг, воспроизведение звука и обработка устройств ввода (мышь, клавиатура, джойстик). Либа может быть полезна главным образом для тех, кто занимается разработкой cross-platform игр, однако с тем же успехом её можно использовать, например, в программах наподобие видео- и аудио-проигрывателей, эмуляторов, и т.д. Помимо вышеперечисленных возможностей, в SDL есть средства для работы с многопоточностью, файлами, таймерами и приводом CD/DVD. Это позволяет применять либу также в тех проектах, которые не связаны с графикой и/или воспроизведением звука.
SDL портирована на многие платформы. Помимо Windows, Linux и Mac OS (X), существуют также порты на Solaris, IRIX, *BSD, и т.д. Полный список есть на главной странице проекта, там же перечислены привязки ко многим языкам программирования, в т.ч. скриптовым.
Распространяется под лицензией GNU LGPL. Текущая версия 1.2.14, согласно заявлению разработчиков, выпущена для исправления ряда багов и является последней в ветке 1.2, следующая будет 1.3.
Немного об установке и API
SDL написана на С. Интерфейс состоит из функций и макросов, список которых не так велик и не сложен для изучения. На вики проекта API функции и типы данных сгруппированы как по алфавиту, так и по категориям, поэтому найти что-то нужное можно практически без труда.
Небольшой пример
Ниже приведу простой пример программы, использующей SDL:
(для меня непривычно писать комментарии на русском, но т.к. наверное не у всех хорошо с английским, на всякий случай оставлю так)
Пробегусь по коду. Прежде всего инициализируем нужные нам подсистемы. В данном случае это видео, аудио и тайминг. После этого отдельно устанавливаем видео режим функцией SDL_SetVideoMode(), которая возвращает созданный видео-контекст. Она также по совместительству также создаёт окошко, в котором будет происходить рендеринг. Флагов инициализации достаточно много, полный список есть на вики.
После предварительных настроек переходим к основному рабочему циклу программы. На каждой итерации он извлекает из очереди информацию о произошедших событиях, после чего меняет местами фреймбуферы (включена двойная буферизация). Между двумя этими действиями можно творить что-нибудь более содержательное, например отрисовывать очередной кадр анимации. Цикл выполняется до тех пор, пока не будет закрыто окно или нажата клавиша Esc. Перед завершением работы вызываем функцию SDL_Quit(), которая закрывает все подсистемы SDL.
Как видно из примера, SDL API очень простой, подготовка системы к работе занимает всего пару строчек, а цикл обработки событий похож на стандартный цикл обработки сообщений Windows-программ.
Уроки по SDL 2: Урок 1 — привет, SDL 2
Всем привет! Решил вот посмотреть на SDL 2, но на русском ничего толкового не нашел. Решил написать свое, питаясь вдохновением отсюда.
Установку SDL 2 я пропущу, а начну сразу с написания программ, итак:
Ваше первое окно
начнем с подключения SDL 2.
Здесь же объявим несколько глобальных переменных.
Далее открываем всем знакомую функцию main.
Давайте немного разберем код. В main из командной строки принимаются параметры командной строки, их нужно обязательно принять. Далее мы инициализируем SDL 2 функцией SDL_Init(). Мы передали в нее SDL_INIT_EVERYTHING, что означает, что мы инициализируем все модули SDL (видео, аудио и т. д.). Есть еще несколько флагов для SDL_Init:
Далее создаем окно функцией SDL_CreateWindow(). Если что-то пошло не так, как задумывалось, возвращаем 1.
Функция SDL_CreateWindow() принимает значения имени окна, позиции окна по OX, позиции окна по OY, ширину окна, высоту окна и флаги. Сейчас мы обойдемся флагом SDL_WINDOW_SHOWN.
Есть и другие флаги для создания окна.
Если сейчас скомпилировать и запустить программу, то мы увидим окно размером 640×480, залитое белым цветом, которое через мгновение закрывается. Чудесно! Чтобы немного полюбоваться этим чудом, можем написать SDL_Delay(2000). Оно заставит программу зависнуть на 2 секунды.
Просто окно — это, конечно же, хорошо, но рисовать в нем было бы еще круче, согласны? Для этого создадим поверхность, на которой будем все рисовать, т. к. непосредственно в окне рисовать как-то некрасиво, что ли.
Сначала мы получаем поверхность окна функцией SDL_GetWindowSurface(). Она сделана для того, чтобы не надо было указывать размеры поверхности, её формат, а сразу получить готовую поверхность. Также эту поверхность не надо отрисовывать в окне — она сама всё сделает.
Потом мы используем SDL_FillRect(), чтобы зарисовать нашу поверхность зеленым. Мы написали SDL_MapRGB, сказав тем самым программе, что мы воспользуемся RGB(Red Green Blue) для задания цвета.
И в конце нам следует обновить окно функцией SDL_UpdateWindowSurface(), чтобы в нем отобразилось то, что мы ему сказали.
На данном этапе при запуске программа отобразит окно, залитое ярко-зеленым цветом, которое не будет закрываться в течении 2-х секунд.
После завершения программы нам нужно очистить ОЗУ от ненужных файлов, закрыть окно, в целом, обусловить корректное завершение программы. В этом нам помогут специально подготовленные функции.
Функция SDL_DestroyWindow() закрывает окно, а функция SDL_Quit() разынициализирует все модули, подключенные ранее функцией SDL_Init().
Ну что же, урок №1 подошел к концу, надеюсь, всё было понятно. Вот такой код у меня вышел в конце:
Цикл уроков по SDL 2.0: урок 1
От переводчика: вдохновившись циклом статей, я решил попробовать свои силы в SDL. Да вот незадача, каких-либо толковых уроков по SDL версии 2.0 на русском языке найти мне не удалось. Это и подтолкнуло меня к переводу замечательной серии туториалов Twinklebear, в оригинале доступных тут.
Добро пожаловать!
Цель данных уроков — познакомить вас с основами SDL 2.0 и гейм-дева на С++. Подразумевается, что у читателя есть некоторый опыт программирования на С++ и минимальные знания массивов, векторов, управляющих структур, функций и указателей.
Если вы испытываете трудности при разборе кода в примерах, воспользуйтесь одной из книг, представленных в этом чудесном списке на StackOverflow.
Если вы хотите увидеть полный исходник или же скачать ресурсы для уроков, то все это можно получить на GitHub’е. Но не копируйте!
Также документация по SDL 2.0 доступна для чтения в этой вики.
Урок 1: Hello World!
В этом уроке мы научимся открывать окно, создавать контекст рендеринга и рисовать загруженное изображение на экране. Ниже вы можете забрать BMP картинку, которую мы будем рисовать. Сохраните ее где-нибудь в своем проекте. Так давайте уже начнем!
Запуск SDL
Первый шаг обычно заключается в подключении заголовочного файла SDL.
Для того, чтобы начать работать с SDL, нам необходимо инициализировать различные SDL подсистемы, которые мы хотим использовать. Это можно сделать с помощью функции SDL_Init, которая принимает набор флагов, указывающих, какие подсистемы мы хотим инициализировать. Сейчас мы просто скажем, что хотим инициализировать все, но если хотите, вы можете это изменить. Минимум, что необходимо для нашего урока — это SDL_INIT_VIDEO. Если все пройдет успешно, SDL_Init вернет 0, в противном случае мы напечатаем ошибку и выйдем.
Заметка для пользователей Visual Studio: если вы установили значение системы как Windows в настройках компоновщика, то вы не получите стандартный вывод в консоль. Чтобы этого не произошло, вам необходимо изменить значение системы на Console.
Открытие окна
Нам нужно окно, чтобы можно было в нем отображать на рендер. Мы можем создать его, используя функцию SDL_CreateWindow, которая принимает название окна, его координаты, высоту, ширину и некоторые флаги, чтобы задать параметры окна. Данная функция возвращает SDL_Window*. Этот указатель будет NULL, если что-нибудь пойдет не так при создании окна.
Создание рендерера
Загрузка BMP изображения
Для того, чтобы отрендерить BMP картинку, нам необходимо сначала загрузить ее в память, а затем в устройство рендеринга, которое мы используем (в данном случае GPU). Мы можем загрузить изображение с помощью SDL_LoadBMP. Эта функция возвращает SDL_Surface*, которую мы можем загрузить в SDL_Texture, чтобы ей мог воспользоваться рендерер.
SDL_LoadBMP принимает путь к нашему изображению, который вы должны изменить, чтобы он соответствовал структуре вашего проекта, и возвращает SDL_Surface* или NULL, в случае ошибки.
Теперь мы можем загрузить изображение в рендерер, используя SDL_CreateTextureFromSurface. Мы передаем контекст рендеринга и картинку в памяти (SDL_Surface), а получаем загруженную текстуру. В случае, если что-то пошло не так, мы получим NULL. Также SDL_Surface нам больше не потребуется, поэтому мы освободим занимаемую ей память.
Отрисовка текстуры
Все, что осталось сделать, это получить нашу текстуру на экране! Сперва мы очистим рендерер, после отрендерим текстуру, а затем покажем обновленный экран, чтобы увидеть результат. Так как мы хотим отрендерить изображение целиком и заставить его растянутся по размеру экрана, мы передадим NULL как исходный и целевой прямоугольники для SDL_RenderCopy. Также мы хотим сохранить окно открытым на некоторое время, чтобы увидеть результат до завершения программы, поэтому мы добавим вызов SDL_Delay.
Уборка мусора
Перед тем, как выйти, мы должны уничтожить все созданные нами объекты с помощью различных SDL_DestroyX функций и завершить SDL.
Конец урока
В случае успеха, при запуске вы должны увидеть изображение во все окно, а через две секунды программа завершится. В случае проблем убедитесь, что SDL установлена и настроена правильно. Подробная инструкция по установке и настройке SDL под различные платформы доступна тут.
SDL2: Основы
К сожалению, даже на официальной вики почти не возможно найти каких либо примеров использования SDL2.x, что уж говорить о рунете. Пытаясь разобраться, я нашел всего лишь пару статей, которые не покрыли и трети моих вопросов.
SDL 2.x существенно отличается от 1.x и даже, если в прошлом вам приходилось с ним работать — теперь вы рискуете ничего не понять.
Начнем с самого начала:
Инициализация SDL
Начнем, пожалуй, с создания объекта класса SDL_DisplayMode.
Он нам очень пригодится, если мы хотим иметь приложение на весь экран.
Этот объект нужно создать до инициализации самого SDL.
После этого нужно проинициализировать сам SDL:
Флаг SDL_INIT_EVERYTHING инициализирует все подсистемы SDL. Если вам нужно только что то конкретное, то на вики можно найти их полный перечень.
Пришло время заняться нашим окном!
Тут все предельно просто, создаем указатель на объект класса SDL_Window и вызываем функцию
В итоге на выходе получаем такой код:
Теперь нам нужно создать рендерер:
Теперь SDL готов с нами сотрудничать!
Вывод на экран
И еще пару строк, чтобы чуть позже мы смогли зумировать нашего персонажа:
И вот мы добрались до загрузки текстур.
Я покажу 2 способа:
Объект этой структуры позволяет загрузить в себя любое BMP изображение, для дальнейшего перевода в текстуру. Однако ее немодифицируемое использование влечет за собой ограничения.
Как пример: чистый SDL работает только с BMP, которое поддерживает альфа-канал, только в 32-битном цвете, а он поддерживается для этого формата далеко не на каждой ОС. А тут уже теряется вся польза от кроссплатформенности SDL.
Ну вот, с теорией разобрались, пора к практике!
Его особенность в том, что он без велосипедов передает альфа-канал.
Теперь у нас есть текстура персонажа готовая показаться на экране. Но перед этим нам нужно еще создать фон.
Вариант номер ДВА:
Фон мы создадим с использованием чистого SDL. Просто потому, что мы можем!
Работая с чистым SDL никогда нельзя забывать делать проверки на ошибки!
И вот наконец то, УРА, пришло время вывести это на экран!
События
Думаю не стоит объяснять что из 2-х картинок игры не выйдет.
Время добавить немного динамики к нашему чуду!
Для начало нужно создать парочку бесконечных циклов, которые работают пока есть события и нет выхода:
Это нам пригодится чтобы иметь возможность отображать или не отображать ту или иную текстуру.
А теперь вставляем этот код во внутренний цикл.
Думаю это не требует пояснений, если вы внимательно читали и занимаетесь программированием больше 21 дня, но все же уточню, что event.button.button ждет специальный флаг SDLя, который вы сможете легко найти на вики, а event.type ждет флага о типе события, полный список которых находится все там же!
Мы уже можем закрыть окно кликом по левому верхнему углу экрана! И даже более того, мы можем убрать и вернуть персонажа когда захотим просто кликнув по нему!
Да, я тоже чувствую, как ощущение власти начинает нас захлестывать, но не время останавливаться, впереди еще клавиатура!
Она нужна что бы отслеживать состояния кнопок.
Еще вне нашей главной функции надо добавить много-много кода, который сделает нашу программу более структурированной.
(Вижу кто то уже начал писать о том, что нужно пользоваться классами и библиотеками, но я хочу напомнить, что это туториал и будет не хорошо, если человек запутается собирая код, поэтому будем писать все максимально просто. Приношу свои извинения тем, чьи чувства я задел!)
И теперь возвращаемся во внутренний цикл и добавляем еще много-много кода:
Осталось вывести полученный результат на экран. Для этого добавляем в цикл:
Закрываем цикл!
И в итоге нам осталось только завершить нашу программу.
Занавес!
Перед тем как все закончить нам нужно удалить наши текстуры из памяти.
И теперь можно смело завершать работу SDL и программы:
Финал, овации! Мы написали первую программу на SDL2! С чем я нас поздравляю!
Что бы создать такую элементарную программу у меня ушло 2 дня. В интернете настолько мало мануалов по SDL2, что проще застрелиться чем что то найти.
Очень надеюсь, что Вам эта статья была полезна и этот монстр не отберет у вас так много времени, как у меня.
Как создавать безопасные системы. Краткое введение в SDL
При разработке любой программной системы, будь это простой вебсайт, десктоп-приложение или сложный трехзвенный комплекс, рано или поздно возникают вопросы безопасности. Нельзя исключить, что та система, которую вы разрабатываете, будет каким-то образом атакована. Причем, в зависимости от типа системы, ее сложности, применяемых технологических решений, векторы атак и их последствия могут иметь самый разный характер. Возможно, время от времени кто-то в команде проводит анализ безопасности разрабатываемой системы, проводится моделирование. Куда хуже если эти вопросы оставляются на потом. Результаты могут быть весьма плачевными, если вашу систему взламывают в режиме коммерческой эксплуатации и вам приходится впопыхах создавать исправления для обнаруженной бреши. Очевидно, что вопросы, связанные с безопасностью лучше решать, начиная с самых ранних этапов создания системы, таких как анализ требований и архитектурного моделирования. Но лучше всего это делать на всем жизненном цикле системы, интегрировав в процесс разработки специальные шаги, предназначенные для решения этих вопросов. Одним из таких процессов является Security Development Lifecycle – набор практик направленных на повышение безопасности разрабатываемых систем.
Что такое Security Development Lifecycle
SDL это процесс который позволяет убедиться в необходимом уровне безопасности разрабатываемой системы. SDL базируется на основе практик направленных на обучение команды, подготовку отчетности и непосредственные действия связанные с анализом безопасности разрабатываемой системы и имплементацией механизмов направленных на улучшение безопасности. Эти практики в виде конкретных шагов легко ложатся на привычный спиральный цикл разработки программного обеспечения.
Некоторые из этих практик сами по себе могут улучшить безопасность разрабатываемой системы. Но как показывает опыт, их применение в рамках процесса разработки позволяет значительно улучшить результат и снизить затраты.
Перед тем как внедрить SDL: Обучение
Все члены команды, перед тем как непосредственно начать разработку, должны пройти тренинг по безопасности и изучить важные моменты, связанные с текущими трендами в этой области. Базовый уровень этого тренинга должен включать в себя:
Анализ требований: Что следует учитывать в контексте безопасности
Уже на уровне анализа требований к системе нужно учитывать важные аспекты, связанные с безопасностью. При этом важно разделять между собой «безопасные требования» и «требования безопасности». В SDL есть некоторый набор практик, и несколько таких из таких практик – «Анализ безопасности и приватности требований» может быть применена на этапе анализа требований. Эта практика предназначена для идентификации функциональных требований, у которых есть необходимость углубленного изучения вопросов связанных с безопасностью. Такой аудит может включать в себя следующую информацию:
Дизайн с учетом безпасности
При дизайне приложений так же можно применить ряд практик, которые помогут повысить безопасность приложения. В первую очередь это снижение площади поверхности возможных атак (Attack Surface Reduction) и моделирование угроз. Несмотря на близкую взаимосвязь этих двух понятий, первый механизм подразумевает активное снижение возможностей злоумышленника на эксплуатацию неизвестных брешей в безопасности. Для снижения площади возможных атак можно применять механизмы послойной защиты и принципы наименьших привилегий. Моделирование угроз в свою очередь позволяет предположить, какие компоненты системы могут быть рассмотрены в качестве векторов атак. Удобным инструментом для моделирования угроз является Microsoft Thread Modeling Tool базирующийся на классификации STRIDE.
Реализация с учетом безопасности
Этап реализации, как правило, наиболее трудоемкая часть проекта. Чтобы облегчить эту задачу используется множество средств, технологий и готовых компонент. В контексте безопасности важно чтобы перечень этого инструментария был заранее зафиксирован. Рекомендованным подходом является формирование перечня разрешенных при имплементации инструментов. Везде где только можно следует исключать или специально обозначать использование небезопасных или вышедших из употребления функций и компонент. В дополнение, важно использование автоматизированных средств, таких как статический анализ кода.
Фаза верификации (тестирования) с учетом безопасности
На этой фазе возможно использование таких практик как динамический анализ кода (во время выполнения) который позволяет быстро выявить аномальное поведение функций, порчу памяти, использование привилегированных функций и другие критические проблемы. Одним из инструментов который может пригодится для решения этой задачи является AppVerifier. В дополнение к стандартным функциональным тестам так же следует добавить плавающее тестирование которое предназначено для проверки приложения в режиме ввода неверных данных, неправильно сформированных параметров и других условий которые могут привести к аномальному поведению но при этом все равно система должна быть в безопасном состоянии. Так же на этом этапе важным является проверка смоделированных векторов атак на предыдущих фазах для того чтобы убедиться в корректности сформированных моделей.
Фаза Выпуска с учетом безопасности
На этой фазе важно создание плана по реакции инцидентов связанных с безопасностью, в которых будет задекларирован порядок взаимодействия и реакции на выявленные угрозы или проникновение. Финальные релизы (RTM,RTW) должны соответствовать всем заранее обговоренным на стадии дизайна условиям безопасности перед развертыванием. Если это не так, даже при соблюдении всех функциональных требований, необходим повтор стандартного цикла разработки для фиксации проблем связанных с безопасностью.
Что дальше
Конечно, эта заметка раскрывает только самые основные аспекты SDL и для успешного применения требуется дополнительное изучение. Помочь в этом может центр безопасности MSDN.
Если вы хотите узнать более подробно о SDL, посмотрите завтра прямую трансляцию докладов конференции «Microsoft Secure Software Development Conference». В том числе там будут доклады Алекса Лукаса «Эволюция цикла безопасной разработки SDL», Гленна Питавея «Внедрение SDL».