Как открыть blueprint в visual studio
В этот раз поговорим про С++ и Blueprints и о том, как они могут повлиять на память и производительность игры. И, как обычно, категорически приветствуется обсуждение статьи в комментариях! Делимся своим опытом и становимся лучше 😁
Можно ли написать игру используя только Blueprints? Можно. Можно ли написать игру используя только C++? Можно. А что тогда выбрать? А выбирать не надо, надо использовать оба языка. Главное - правильно соблюсти баланс.
Даже если вы решили писать игру только на Blueprints, создавайте именно С++ проект. В скором времени вы убедитесь, что многие вещи гораздо проще решить с использованием С++. А переконвертировать Blueprint проект в С++ не так и просто.
Первое и основное правило - если что-то можно написать на С++, пишите на С++. Основная прелесть в том, что зависимостей в С++ нет. Нужно вызвать метод класса - не проблема, нужно скастовать к другому типу - все хорошо, кастуем. Blueprints такое не прощают.
Одно условие - не надо в конструкторе загружать ассеты. Откуда взялось такое условие? Дело в том, что для каждого AActor автоматически создается его default версия. И, естественно, для нее вызывается конструктор.
Эм. а блюпринты куда? А блюпринты грузятся только тогда, когда они нужны. И в этом их прелесть - ассеты подтянутся, только тогда, когда блюпринт начали использовать (в другом блюпринте или поместили на уровень). Поэтому, часто разбивают код так: всю логику работы выносят в базовый класс на С++, а настройки, меши, материалы и эффекты - в блюпринты-наследники. Даже если этот блюпринт-наследник будет единственным.
Дальше я буду писать только о блюпринтах, потому что не всегда получается следовать "первому и основному правилу".
Блюпринты великолепны для прототипирования. Вот только с усложнением кода, становится все сложнее разбираться в получившейся "лапше". Как только идея устаканилась, старайтесь перенести ее на С++. Анализ кода, поиск и читаемость - не лучшие стороны блюпринтов:
Надо сводить к минимуму зависимость блюпринтов друг от друга. Зависимость Controller и Character обоснована - они не могут работать друг без друга. Но, ситуация, когда А тянет за собой В, который тянет C и D и все дальше и глубже, приведет к печальным последствиям. Причем простейший "Cast to" уже введет зависимость и начнет грузить другой блюпринт! Интерфейсы или взаимодействие на уровне С++ помогут разрулить ситуацию.
Циклические зависимости могут привести проект в полностью нерабочее состояние. У меня такое тоже было. Пришлось переписывать весь код игры.
Я написал блюпринт и хочу использовать его переменную или вызвать его функцию в С++. Это возможно? Если коротко, то: Да. Однако, по словам эпиков: "Если бы вы видели этот код, то никогда не захотели бы его использовать". Так что правильный ответ: Нет. Хотите что-то использовать в С++ из блюпринтов - объявите это в С++.
Производительность блюпринтов. Ее достаточно для игровой логики. Что-то сложнее, лучше выносить в С++. Крайне не рекомендуется делать блюпринты с Tick'ом. "Тикать" лучше на С++. С другой стороны, нет ничего страшного, если блюпринт изредка включает свой тик на короткое время, или тикает не каждый кадр, а пару раз в секунду. Также стоит помнить, что Tick - это просто таймер по умолчанию. Вынос "тикающего" кода в другие таймеры или Timeline не исправит ситуацию.
Я не рассказал про hard references и soft references. Исправляюсь тут:
Отличный пример того, как правильно сбалансировать С++ и Blueprints, показан в демо-проекте Action RPG:
Часть 3. Префиксы в именах классов. Целочисленные типы. Типы контейнеров. Итераторы контейнеров. Цикл For-each, хеш-функции.
Часть 4. Бонусная. Unreal Engine 4 для Unity разработчиков.
Unreal C++ очень крут!
Это руководство покажет вам как писать код на С++ в Unreal Engine. Не переживайте, разработка на С++ в Unreal Engine весёлая, и совершенно не сложная, чтобы её начать. Нам нравится думать о Unreal C++ как о «помогающем C++» *, поскольку мы создали множество разных фич чтобы сделать C++ легче для всех!
Примечания
Вы можете писать «старый добрый С++ код», но вы будете более продвинутым разработчиком, после прочтения этого руководства и изучении модели разработки в Unreal.
C++ и Blueprints
UE предоставляет два метода для создания элементов геймплея — C++ и Blueprint. С++ программисты добавляют основные блоки геймплея, таким образом, чтобы дизайнеры (тут имеется ввиду левел-дизайнер, а не художник) с помощью этих блоков мог создавать свои элементы геймплея для отдельного уровня или всей игры. В таком случае, программисты работают в своем (своей) любимой IDE (например — MS Visual Studio, Xcode), а дизайнер работает в Blueprint редакторе UE.
API геймплея и фреймворк классов полностью доступны из обоих систем. Обе системы можно использовать по отдельности, но используя их вместе вы получаете более мощную и гибкую систему. Это значит, что лучшей практикой будет слаженная работа программистов, которые создают основы геймплея и левел-дизайнеров, которые используют эти блоки для создания увлекательного геймплея.
С учетом всего вышесказанного, далее будет рассмотрен типичный рабочий процесс программиста C++, который создает блоки для дизайнера. В этом случает вы должны создать класс, который в дальнейшем будет расширен с помощью Blueprint, созданного дизайнером или другим программистом. В этом классе мы создадим различные свойства (переменные), которые сможет задать дизайнер. На основе этих заданных значений, мы собираемся извлечь новые значения созданных свойств. Данный процесс очень прост благодаря инструментам и макросам, которые мы предоставляем для вас.
Мастер классов
Самое первое что требуется сделать это воспользоваться мастером классов (class wizard) предоставляемый UE, для создания базы будущего С++ класса, который в дальнейшем будет расширен с помощью Blueprint. Ниже показано, каким образом происходит выбор при создании нового класса, дочернего от класса Actor.
Далее требуется ввести название вашего класса. Мы воспользуемся именем по умолчанию (MyActor).
После того как вы создадите класс, мастер генерирует файлы и откроет IDE, таким образом что вы сразу можете начать редактировать его. Ниже приведен полученный таким образом код созданного класса. Для получения доп. информации о мастере классов, вы можете перейти по этой ссылке.
Мастер классов генерирует класс с методами BeginPlay() и Tick(), со спецификатором перегрузки (override). Событие BeginPlay() происходит когда Actor входит в игру, в состоянии разрешённом для игры (playable state). Хорошей практикой является инициирование геймплей-кода вашего класса в этом методе. Метод Tick() вызывается каждый кадр с параметром, который равен времени, прошедшему с последнего своего вызова. В этом методе должна содержаться постоянно повторяющаяся логика. Если у вас она отсутствует, то лучше всего будет убрать данный метод, что немного увеличит производительность. Если вы удалили код данного метода, убедитесь что вы так же удалили строку в конструкторе класса, которая указывает, что Tick() должен вызываться каждый кадр. Ниже приведет код конструктора с указанной строкой:
Создание свойств, отображающихся в редакторе
Теперь у нас есть собственный класс. Давайте создадим несколько свойств, которые могут быть использованы другими разработчиками, непосредственно в UE. Для отображения свойства в редакторе требуется использовать специальный макрос UPROPERTY(). Все что требуется сделать, это написать макрос UPROPERTY(EditAnywhere) перед объявлением переменной, как написано ниже:
Это все что требуется сделать, чтобы редактировать данное значение в редакторе. Есть еще несколько путей, для указания каким образом и где данная переменная редактируется. Это делается с помощью указания доп. опций в макросе. К примеру, если вы хотите чтобы данное свойство было сгруппировано в разделе с другими соответствующими свойствами, вы должны указать категорию, как это указанно ниже:
Теперь, пользователи будут видеть вашу переменную помещенную в категорию с заголовком «Damage». В этой категории так же могут быть другие свойства, у которых указана такая же категория. Это отличный способ размещать наиболее часто используемые переменные вместе.
Теперь сделаем свойство доступным из Bluerpint:
Как вы можете увидеть, мы указали специальный параметр, для возможности чтения и записи свойства. Вы так же можете использовать другую опцию — BlueprintReadOnly, чтобы ваши переменные в редакторе указывались как константные. Кроме этого доступны многие другие свой тва, передаваемые макросу UPROPERTY.
Перед тем как перейдем к следующему разделу, давайте добавим несколько переменных нашему классу. У нас уже имеется переменная хранящая полный урон, который может нанести Actor, но давайте считать, что урон может производиться длительное время. Код ниже содержит одну новую переменную доступную для редактирования левел-дизайнером и одну недоступную для редактирования:
Как видно, DamageTimeInSeconds свойство, которое доступно для редактирования в редакторе. DamagePerSecond будет вычисляться, как вы увидите позднее, на основе значения заданного в DamageTimeInSeconds, например, левел-дизайнером. Флаг VisibleAnywhere указывает что свойство отображается, но не может быть изменено. Флаг Transient означает что это свойство нельзя сохранить или прочитать с диска, то есть полученное значение является непостоянным. На картинке ниже показано как отображаются эти свойства в разделе значений по умолчанию нашего класса.
Установки значений по умолчанию в конструкторе
Установка начальных значений переменных происходит как и в обыкновенном C++ классе — в конструкторе. Ниже приведены два примера, каким образом это можно сделать, оба примера эквиваленты по функциональности:
Вот тот же кусок окна, но уже с заданными значениями в конструкторе
Так же возможно задавать начальные значения основанные на значениях заданных в редакторе. Эти данные задаются после конструктора, для этого требуется использовать метод PostInitProperties(). В данном примере TotalDamage и DamageTimeInSeconds задаются левел-дизайнером. Независимо от того, заданны ли эти значения из редактора, вы по прежнему можете задать требуемые начальные значения, как мы сделали это ранее.
Заметка: если вы не задаете значения по умолчанию, они автоматически будут установлены в 0 или nullptr для значений указателей.
Тот же кусок окна, что и ранее, но уже после добавления PostInitProperties() в цепь вызовов.
Горячая перезагрузка.
UE 4 предоставляет возможность, которая возможно удивит вас, если вы привыкли к обычному программированию на C++ в других проектах. Вы можете скомпилировать добавленный вами С++ код без перезапуска редактора. Есть два пути сделать это:
- Если редактор запущен, сделайте билд в Visual Studio или Xcode, как вы обычно это делаете. Редактор обнаружит новые скомпилированные DLL и перезагрузит ваши изменения сразу же.
Заметка: Если у вас приатачен дебаггер, вы должны открепить его, в начале, иначе VS не позволит вам сделать build.
2. Или просто нажмите на Compele в основном тулбаре в редакторе.
Вы можете использовать эту возможность по мере продвижения по данному руководству.
Расширение С++ класс с помощью Blueprint
До этого мы создали простой геймплей-класс, при помощи С++ мастера классов и добавили в него несколько переменных. Теперь мы изучим на то, как пользователь может создавать уникальные классы из наших скромных набросков.
Первое, что требуется сделать, это создать Blueprint класс из нашего AMyActor класса. Обратите внимание, что на изображении ниже имя базового класса указанно как MyActor, а не AMyActor. Это сделано для того, чтобы спрятать соглашения об именах, которое используется в наших инструментах от пользователя, делая имена более удобными для него.
После нажатия на Select, будет создан новый Blueprint с дефолтным именем. Мы зададим ему имя CustomActor1, как указанно на изображении из Content Browser'а ниже.
Это наш первый класс, который наш пользователь будет редактировать. Во-первых, поменяем значения наших переменных. В данном случае выставим TotalDamage равным 300 и время, в течении которого наносятся эти повреждения равным двум секундам. Вы можете увидеть это на картинки ниже:
Погодите… Наша расчетная величина не соответствует нашему ожиданию. Оно должно быть 150, но мы видим значение равное 200. Это происходит потому, что в данным момент мы вычисляем значения сразу после инициализации значений, которое происходит в момент загрузки. Но у нас происходят изменения времени выполнения в редакторе (runtime changes), которые не учитываются. Эту проблему легко решить, поскольку движок уведомляет целевой объект о событии, которое вызывается при изменении в редакторе. Код ниже показывает, что именно требуется добавить для расчета новых значений, полученных при изменении переменных в редакторе:
Заметьте, что метод PostEditChangeProperty расположен внутри директивы, которая указывает, работаем мы в редакторе или нет. Это сделано для того чтобы при билде, игра содержала только необходимый для неё код, без лишних строк, которые увеличивают размер исполняемого файла, без необходимости. Теперь, после перекомпиляции, значение DamagePerSecond будет соответствующим нашему ожиданию. Это указанно на картинке ниже.
Вызов C++ методов в Blueprint
До сих пор мы изучали работу с переменными. Кроме этого требуется изучить еще одну важную базовую вещь, перед тем как более детально изучать движок. В процессе создания геймплея, пользователь должен иметь возможность вызывать в Blueprint функции созданные C++ программистом. Для начала давайте сделаем чтобы метод CalculateValues() можно было вызывать из Bluerpint.
Макрос UFUNCTION() содержит описание, каким образом наша С++ функция обрабатывается системой рефлексии. Опция BlueprintCallable указывает возможность обработки данного метода в виртуальной машине Blueprint'ов (далее Blueprint VM). Для того, чтобы контекстное меню (вызываемое правой кнопкой мыши) работало должным образом, каждый метод, вызов которого разрешен редактором, должен содержать имя категории. Изображение ниже показывает как именно категории отображаются в контекстном меню:
Как видите, метод может быть выбран в категории Damage. Blueprint-код ниже показывает, каким образом происходят изменения в значении TotalDamage, с последующим вызовом метода для пересчета зависимых значений.
Тут мы используем метод, описанный ранее, для пересчета зависимых свойств. Большая часть методов движка доступны для вызова из Blueprint, при помощи макроса UFUNCTION(), так чтобы разработчики могли создавать игры без написания С++ кода. Тем не менее, более грамотным подходом будет использования С++ для создания основных блоков геймплея и кода, чья производительность критична, а применение Blueprint для кастомизирования созданного поведения или конструирование нового, в основе которого лежит созданный код.
Теперь, когда наши пользователи могут вызывать ваш C++ код, рассмотрим еще один способ вызова C++ кода в Blueprint. Этот подход позволяет вызывать в С++-коде функции реализованные в Blueprint. Таким образом можно уведомить пользователя о событиях, на которые они могут реагировать тем образом, которым считают нужным. Часто это бывает создание эффектов или другие графические взаимодействия, как показ/сокрытие объектов. Фрагмент кода ниже содержит метод, который реализован в Blueprint:
Эта функция вызывается как и обычная С++-функция. UE генерирует основу реализации С++ функции для правильного вызова ее в Blueprint VM. Обычно мы называем это Thunk(Преобразователь). Если Blueprint не реализует тело функции, то её поведение представляет С++-функцию с пустым телом, которое ничего не делает. Что делать, если мы хотим обеспечить С++ реализацию по умолчанию и сделать возможным переопределения ее в Bluerpint. Макрос UFUNCTION() имеет опцию для этого случая. Фрагмент кода ниже показывает, какие изменения в заголовочном файле нужно сделать, чтобы добиться этого:
Эта версия метода по-прежнему преобразует метод для его вызова в Blueprint VM. Каким образом мы должны обеспечить реализацию по умолчанию? Инструменты так же генерируют новое определение метода с постфиксом _Implementation(). Мы должны представить вашу версию этого метода или ваш проект не будет слинкован. Вот реализация для указанного выше определения:
Теперь этот метод вызывается когда Blueprint не переопределяет его. На заметку: в будущих версиях билд инструментов автосгенерированное определение _Implementation() будет убрано и его нужно будет явно добавлять в заголовок. В версии 4.7 автогенерация этого определения по-прежнему происходит.
Теперь вы изучили основы разработки геймплея и методы совместной работы с пользователями для создания более разнообразного геймплея. Пришло время вам выбрать ваши собственные приключения. Вы можете продолжить изучения разработки в следующих частях или вы можете ознакомиться с одним из примеров проектов, которые вы можете найти в лаунчере (стартовом экране), чтобы получить еще больше полезных навыков.
Actor.h
//потключены 3 библиотеки
//метка что начинаеться описание класса
//начало описание гласа
class AMyActor : public AActor
//метка что это начало тела класса
//обьявление публичных методов
//Функция срабатывающая при создании класса в UE4
//Функция срабатывает при каждом создании класса на сцене во время игры
virtual void BeginPlay() override ;
// функция которая будет вызываться при каждом обновлении экрана
virtual void Tick( float DeltaSeconds) override ;
Функция с именем класса называется конструктором она позволяет при первом обращении к классу создать его и например назначить какие ни будь стан драные параметры которые должны быть у объекта. Допустим мы делаем класс мина и хотим чтобы у мины которой мы разместим в игре был выставлен параметр урона в 100 тогда в этом методе мы можем задать значение переменной и она при создании нового класса будет иметь значение 100. Но в нашем случае конструктор просто включает функцию класса отслеживать обновление кадров игры.Actor.cpp конструктор
//включает отслеживангие каждого обновления игры
Допустим у нас возникла ситуация, когда мы хотим создать у класса какой ни будь параметр, или параметры, чтобы их можно было изменять из редактора Unreal Editor. Для этого в конструкторе нужно описать создание свойств. Для этого нужно в конструкторе класса описать следующий код.Создание редактируемого параметра видимого из Unreal Editor
//при создании класса
class AMyActor : public AActor
//указываем что данный параметр будет виден из редактора
//переменная типа целого числа которая будет хранить значение
Директива UNPROPERTY() (Unreal Property ) это по сути функция которая создает пункт во вкладке параметров она позволяет указать область видимости параметра в окнах редактора, возможность чтения записи параметра в Blueprint скрипта и категорию параметра. Добавим в для наглядности несколько параметров нашему объекту которые будут видны из редактора при выборе нашего объекта в обозревателе ресурсов (Content Brouser).Добавляем 3 параметра
class AMyActor : public AActor
//переменная общий урон
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Damage" )
//Получаемый урон в секундах
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Damage" )
//Возможный разовый молучаемый урон в секунду
UPROPERTY(BlueprintReadOnly, VisibleAnywhere, Transient, Category = "Damage" )
После того как добавили код его нужно собрать в библиотеку для этого нужно скомпилироваться проект. После этого скомпилировать UE4
Зададим в конструкторе значения по умолчанию
AMyActor::AMyActor()
//зададим 1 параметр
TotalDamage = 200;
//задаим 2 параметр
DamageTimeInSeconds = 1.f;
>
создание функций изменения параметра
//функция срабатывает во время обновления настроек на экране
void AMyActor::PostInitProperties()
Super::PostInitProperties();
Доброго времени суток, все, кто подписался или просто проходил мимо. Ранее я писал, что на выходных будет первый вводный урок по UE4, собственно, настало это время!
Нам понадобится сам движок UE4 версии 4.10.X и Visual Studio 2015 Community. Все это доступно бесплатно. Все ссылки и требования по железу я описывал в нулевом ПОСТЕ
Начнем с создания проекта. Как я и писал ранее, будем комбинировать BP и C++. Запускаем из лаунчера движок, жмем New Project, выбираем C++ и из списка примеров берем FirstPerson, выбираем путь и придумываем название.
Чтобы сразу пояснить что и как, возьмем проект с примером для первого урока, а далее будем менять его с каждым новым уроком. Зачем? А чтобы сразу же не заваливать вас информацией о сборке уровней, настройках света, настройке персонажа игрока и т.д. и т.п. В стартовом проекте будет персонаж (ну как персонаж. Просто руки с оружием и камерой в центре) и оружие, стреляющее шариками. Все это мы благополучно выпилим в следующих уроках и сделаем нечто более интересное, похожее на игру)
После генерации кода вы увидите интерфейс движка с превью уровня. В этом уроке мы как раз и поговорим про сам движок и про BP.
Описание интерфейса UEEditor.
Content Browser.
Здесь находится весь контент вашего проекта и его исходники. Через него вы можете добавлять новые классы, импортировать различные объекты и т.д.
Это используется для настройки свойств выбранного на уровне актера. Здесь будут и созданные вами переменные, и стандартные для родительского класса параметры.
World outliner.
Здесь находится список всех "актеров", которые находятся на сцене вашего уровня. Почему актеры? В UE4 есть класс AActor, от которого наследуется большая часть всех базовых классов, что есть в движке. Если вы что то видите в игре на сцене - это актер или меш, или система частиц. АЙ, если вы видите что то в игре на сцене, то, скорее всего, это актер. Если в коде перед именем класса стоит префикс A - значит этот класс является наследником от актера или от чего то, что тоже было наследовано от него. Вообще, у эпиков есть статья на их вики со стандартами кода, да и документацией к SDK. Но вкратце и по теме:
Классы наследованные от AActor имеют префикс A
Классы наследованные от UObject имеют префикс U
Классы наследованные от SWidget имеют префикс S
Абстрактные интерфейсы имеют префикс I
Структуры имеют префикс F
Это превьюшка вашего уровня, в которой вы производите различные действия над уровнем и актерами на нем.
На том же вьюпорте имеются кнопки для редактирования выбранных актеров.
1. Переместить, вращать, растянуть.
2. Изменение чувствительности перемещения, вращения, растягивания.
3. Скорость перемещения камеры во время редактирования уровня.
4. Кнопки слева позволяют выбирать плоскость в которой отображается уровень, режим отображения объектов, отображение каких-то областей (например там включается отображение нав меша - области, по которой могут перемещаться ИИ).
Управление на вьюпорте. для поворота камеры зажмите ПКМ и двигайте мышь. Увеличение масштаба производится колесиком мыши. Перемещение камеры по уровню производится с помощью стрелок клавиатуры.
Панель над вьюпортом.
На ней находятся кнопки сохранения, открытия браузера контента, настроек проекта в целом, открытия/создания BP игры, уровня, сборки графики и различных параметров из движка(свет, геометрия, навигация), компиляция (Запускает компиляцию исходников вашего проекта. Через эдитор это происходит дольше, чем из студии), воспроизведение (Запуск игры на вьюпорте, и настройка параметров запуска). Launch уже собирает проект в exe файл (на самом деле не только exe, зависит от выбранных целевых платформ)
Здесь вы можете искать ваши C++ и BP классы или брать те, что есть в движке по стандарту и располагать их на уровне. Здесь же находятся навмеши, навлинки, разные типы освещения, зоны звуковых или световых эффектов и т.д. В той же вкладке можно перейти в режим редактирования ландшафтов, рисования всякой растительности, редактирования геометрии и т.д. На этих всех делах будем останавливаться подробнее в следующих постах, когда что то из этого будет нам требоваться.
Для примера, давайте найдем объект Text Render и перетянем его из списка на уровень, зажав ЛКМ. Появится строка с текстом "Text". Повернем на 180 градусов нашу строчку. В свойствах поменяем текст на "Pikabu", сменим цвет и размер шрифта.
Давайте немного поиграемся с BLUEPRINT.
BP - это визуальный скриптинг в движке UE4. Если говорить проще, то это программирование мышкой. Ранее я обещал рассказать о плюсах и минусах, так что давайте начнем с хороших его сторон. (Опишу основное, другие достоинства или недостатки будут всплывать в процессе)
BP ооочень быстро компилируется, если сравнивать его с C++, следовательно, на нем можно очень быстро протестировать право на жизнь какого-то алгоритма, вашей идеи, или чтобы просто посмотреть как работает какая-либо функция. В нем есть все те же функции, что и в C++, но большинством из них гораздо удобнее пользоваться в BP. (Кстати, некоторые BP функции не доступны для использования в C++)
BP - это мощьный и очень удобный инструмент. Он идеален для простых объектов. В итоге, как ни старайся, но вы все-равно им будете пользоваться. Например, написав класс персонажа игрока, вам нужно будет создать BP, наследованный от вашего класса, чтобы выбрать модельку, выставить параметры и т.д. Редактор материалов в UE4 тоже работает на BP. Анимационный блюпринт делается тоже на BP (о нем в следующих уроках). Можно довольно быстро создавать события, которыми достаточно удобно пользоваться. Мультиплеер на BP делается проще, чем на C++, но местами связывает руки по возможностям.
Но, если говорить о плохих сторонах.
Отлаживать код на BP жутко не удобно. Если объект сложный, то появляется огромное количество "макоронин" от связей между блоками, в которых потом будет очень сложно разобраться (C++ тут удобнее). Не очень удобно комментировать. Некоторые вещи на бп просто не реализуемы т.к. отлаживать это все жутко муторно.
Тем не менее, движок строится на использовании BP. Сложные моменты с кучей связей вы можете просто перенести в функцию в своем классе C++ и разрешить ее использование в BP. В общем, тут каждый решает сам. Я не создаю C++ классы, ради того, чтобы написать 2 строчки, ведь быстрее будет сделать BP класс.
Давайте посмотрим что вообще представляет из себя BP или комбинация C++ с BP.
Сразу же даю скриншот BP и куска .h файла от класса нашего персонажа. Описание всего под картинкой.
Возьмем для примера блюпринт персонажа игрока. Слева вверху мы видим список компонентов, используемых в блюпринте, чуть ниже у нас список переменных, функций, макросов и событий. Справа у нас свойства выбранного компонента.
Если открыть исходники нашего персонажа, в .h файле мы сможем увидеть те самые компоненты, отображаемые в BP и переменные, которые также видны в BP, если выбрать в списке компонентов верхний объект с поменткой "self", т.е. параментры самого класса. Обратите внимание на то, что в коде на C++ у макроса UPROPERTY указывается категория, и все переменные в BP располагаются по этим самым категориям, т.е. мы можем отсортировать наши переменные по ним так, чтобы в дальнейшем можно было проще их находить для изменения.
В данном случае у нас нет BP скриптов, у нас все прописано через C++, и просто выведены параметры персонажа в BP, чтобы можно было их быстро редактировать, не компилируя по пол дня из-за изменения значений пары переменных проект целиком из исходников. Довольно удобно, не правда ли?)
Это был такой маленький обзорчик BP, а теперь, по старым традициям, сделаем что то очень простое, вроде "Hello World!", но на BP.
Давайте найдем в контент браузере папку Geometry, а в ней папку Meshes. Там вы найдете меш (3D объект) куба с именем "1M_Cube". Жмите правой кнопкой -> Asset Actions -> Create blueprint using this. Далее выбирайте папку, в которую вы хотите создать BP-класс и пишите имя. Кстати, я всегда приписываю префикс BP_ к блюпринт классам, чтобы потом в настройках чего-либо было проще находить нужное. Т.е. иногда нужен BP-класс, а иногда C++, а так их будет проще различать.
Так-с здесь бы пришлось слишком много писать и втыкать скриншотов, получилось бы очень не понятно, по-этому ВИДЕО! Да, видео, коротенькое, где можно посмотреть, как работать с BP и что из этого получается)
Читайте также: