Amazon Lumberyard

(1)

Amazon Lumberyard

Welcome Guide

Version 1.28

(2)

Amazon Lumberyard: Welcome Guide

Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any manner that is likely to cause confusion among customers, or in any manner that disparages or discredits Amazon. All other trademarks not owned by Amazon are the property of their respective owners, who may or may not be aﬃliated with, connected to, or sponsored by Amazon.

(3)

Welcome to Amazon Lumberyard

Amazon Lumberyard is a free high-performance 3D engine with a professional suite of tools, editors, and libraries that enable you to create captivating real-time graphics, immersive experiences, awe-inspiring virtual worlds, and dynamic visualizations. Lumberyard brings the capabilities of Amazon Web Services and the community of Twitch to connect your ideas to players, customers, and viewers around the world.

(7)

Amazon Lumberyard’s creative capabilities without compromise What does "free" mean?

Lumberyard is free. There are no seat licenses, no site licenses, no subscriptions, no support contracts, no revenue share. Just free. If you choose to use AWS services in your project, you’ll be responsible for fees associated with those services. Amazon Lumberyard is always free to use and you can customize the tools and source code to suit your needs.

Amazon Lumberyard’s creative capabilities without compromise

A world-class engine

At its core, Lumberyard is a high-performance real-time 3D engine that produces incredible visual ﬁdelity. Lumberyard includes all the capabilities that professional designers, artists, and developers expect, with familiar user experience patterns that enable fast adoption and development. Its robust toolset enables rapid iteration to the highest quality. Built on a modular architecture and extensible through the Gems framework, Lumberyard makes it easy to add new features, APIs, and assets.

Deeply integrated with Amazon Web Services

Lumberyard’s online capabilities, backed by Amazon Web Services, oﬀer staggering possibilities to developers. Common connected elements like dedicated servers, dynamic content, online economies, and real-time stats are easily implemented and scaled, so you can focus on the creative aspects of your project. With Lumberyard’s crossplay capabilities and Twitch integration, you can ﬁnd new and novel ways to engage people socially. The limitless potential of AWS can deliver experiences that reach far beyond the capabilities of any single device.

Whether you’re a student, hobbyist, independent developer, or major studio, Lumberyard provides the same growing toolbox to realize your creative vision.

Interested? Read on to learn what’s in the box.

Welcome Guide contents

Lumberyard features (p. 3) - Learn about Lumberyard’s feature set.

How Amazon Lumberyard works (p. 5) - A high-level overview of the technology behind Lumberyard.

Setting up Amazon Lumberyard (p. 12) - Download, install, and create a project with Lumberyard.

Create with Amazon Lumberyard (p. 27) - A quick introduction to Lumberyard’s workﬂows and core tools.

Get started with Amazon Lumberyard tutorials (p. 58) - Step-by-step tutorials to get you hands-on experience with Lumberyard’s workﬂows and core tools.

Additional Lumberyard Resources (p. 162) - Links to video tutorials, documentation, and Lumberyard online communities.

(8)

Here are just some of Lumberyard’s features:

Lumberyard features

Lumberyard is packed with features that enable you to create beautiful worlds, engaging characters, and dynamic simulations. With Lumberyard’s deep integration to Amazon Web Services and Twitch, you can add cloud-connected features and connect players and customers around the world.

Here are just some of Lumberyard’s features:

Engage fans with Twitch

Add new levels of interactivity between Twitch streamers and viewers with Twitch ChatPlay. Give Twitch streamers dynamic real-time broadcast customization options with Twitch Metastream. Enable direct engagement between Twitch streamers and viewers with Twitch JoinIn.

Build robust multiplayer features, fast

Easily deploy, operate, and scale multiplayer game servers with Amazon GameLift. Use the Cloud Gems Framework to add dynamic content, leaderboards, and daily messages.

Create incredible worlds

Lumberyard Editor is a powerful, customizable world-building tool. Sculpt and paint expansive, multi- layered terrain. Decorate your landscape with dense, lush vegetation. Design panoramic skies with dynamic time-of-day and atmospheric eﬀects. Create interactive inﬁnite oceans. Populate your world with life-like entities using simple but powerful components.

Tell stories with emotive characters

Create believable, immersive characters with EMotion FX's data-driven tools. Lumberyard’s Animation Editor provides a visual, node-based interface for bringing characters to life with blend trees and blend spaces, visual state machines, and linear skinning. Tell engaging stories through cinematics with Lumberyard’s cinematic sequence editor, Track View.

Spectacular visual eﬀects with NVIDIA PhysX and particles

NVIDIA PhysX and NVIDIA Cloth enable you to build dynamic, real-time physical interactions with static colliders, rigid bodies, and realistic cloth simulations. With Lumberyard’s Particle Editor, you can create stunning visual eﬀects.

Develop engaging experiences with ease

You don’t need to be an experienced programmer to use the power of Lumberyard. Design captivating systems and experiences with Script Canvas, a node-based visual script editor that enables easy access to Lumberyard’s underlying functionality. Lumberyard also supports Lua for designers who prefer the rapid iteration that scripting languages provide.

Leverage the power of Amazon Web Services

With Lumberyard, you can incorporate AWS services such as Amazon DynamoDB, AWS Lambda, Amazon S3, Amazon Cognito, Amazon SNS, and Amazon SQS with Cloud Canvas tools and solutions. The Cloud Gem Framework Gem provides C++ classes that can execute any AWS SDK for C++ call, bringing the vast

(9)

Supported platforms

You can use Lumberyard to develop games for the following platforms:

• Microsoft Windows PC

• Android

• iOS

• macOS

• PlayStation

• Xbox

• Linux (dedicated server only)

Some platforms have additional requirements.

• For console support, see the Xbox for game developers and PlayStation Partners portals.

• For mobile devices, see Creating Android and iOS projects in the User guide.

• For macOS, see Creating macOS projects in the User guide.

• For Linux dedicated servers, see Creating Lumberyard Executables for Linux in the User guide.

(10)

Overview of the Lumberyard framework

How Amazon Lumberyard works

Amazon Lumberyard provides a complete, end-to-end environment for developing and delivering games and simulations, and supports a wide variety of platforms, including consoles, mobile devices, virtual reality, and Microsoft Windows PCs. Since it’s such a large development environment with so many diﬀerent features and tools, it can be intimidating to new users, especially for those who don’t have a traditional developer background. This topic covers the various parts of Lumberyard at a high level and the common ways you can work with it depending on your role or task as a new or experienced game developer or designer.

Lumberyard has several tools, editors, and systems that work together to help you assemble a game.

Central to this is the "Lumberyard game engine", which provides the following:

• Graphics rendering and output

• Game logic execution

• Messaging across game systems and components

• Memory and resource abstraction and management

• Multi-threading support for input, audio, physics simulation, user interfaces (UI), artiﬁcial intelligence (AI), networking and multiplayer, and other common game features

• Asset management and packaging

The engine itself is really just a collection of components and modules, called Gems. When developing, you use the Lumberyard Editor and tools to assemble the engine for your game, choosing and adding these gems and modules as you develop it. You also use the Lumberyard tools to add your assets—

including textures, meshes, sounds, music, and scripts—to construct your game’s unique experience and gameplay.

Think of Lumberyard as a collection of discrete elements: code, scripts, various GUI-based editors, and command line tools. When you compile a game project, Lumberyard’s build scripts pull in all the pieces specified in your project’s configuration to build your game. The parts of the engine that go into your game are only those you’ve configured your project to use, and there’s very little functionality included in the final compiled code that you didn’t ask to have in it. Likewise, the asset bundling and management tools make sure you only ship with the assets you actually use in your game.

You can build a game in Lumberyard just using the Lumberyard Editor, but you will be constrained to the Gems and tools provided (along with the assets and scripts you create). If your ambitions are greater—if you want to evolve Lumberyard to support features and systems we haven’t provided in the box—read on.

Overview of the Lumberyard framework

The Lumberyard installation provides a sandbox of diﬀerent bits to combine, including over 100 gems and modules for you to use in your game. As a high-level concept, think of Lumberyard as a framework

—a conceptual structure from which you can add new features or remove anything you don’t plan to use in your game. When you need to change or extend the behavior of something, you don’t need to go to some massively over-architected set of code ﬁles and hack or refactor a feature in to your game’s code.

(11)

Overview of the Lumberyard framework

By focusing on modularity, you can safely experiment with diﬀerent feature changes without risking progress on the entire game with an unintended regression.

Central to Lumberyard is the AzFramework library, which relates all of the systems, modules, and Gems into the infrastructure for your game. The Event Bus (EBus) system provides request and notification messaging across the DLLs for these systems, modules, and Gems. As a developer, you write C++ code to implement methods defined in C++ API headers that define the functionality you need.

The default Lumberyard installation is to {drive-letter}:\Amazon\Lumberyard{lumberyard- version-number}\ on your PC. There are two folders under it: \dev and \3rdParty. We’ll examine the most important contents of \dev, which is where AzFramework and all of the various Gem and module interfaces are deﬁned, as well as the EBus interfaces. It also contains scripts, samples, and Editor assets.

• \dev\Bin64vc142 (or, in versions prior to 1.24, \dev\devBin64vc141) contains the asset builder libraries, the Lumberyard editor modules (plugins) and libraries (under \EditorPlugins), among other things. Build and conﬁguration logs are under \Logs.

• \dev\Code contains the C++ API headers that you’ll include in any code you create to extend the core functionality of Lumberyard. They are organized under folders for each of the systems or features that you want to extend. Most of them are virtual interfaces that you’ll implement so you connect that functionality to the relevant Lumberyard system or feature through EBus, or contain the expected type and template deﬁnitions to use. These include:

• \Code\CryEngine contains API headers and C++ code ﬁles for CryEngine systems and features. If you need to tweak the behaviors of CryEngine, including the 3D renderer, the legacy physics engine, the GridMate networking engine, or other components of the CryEngine, start with the source ﬁles in this directory.

• \Code\Framework contains the AzFramework APIs. AzFramework is the core Lumberyard framework that deﬁnes all the systems, including Gems, systems engines, and EBus.

• \Code\Framework\AzCore\AzCore: Contains all of the APIs for interoperating with Lumberyard’s systems, modules, and Gems. If you are extending Lumberyard’s default functionality, this is where you’ll ﬁnd all the APIs you need.

• \Code\Framework\GridMate: Contains the GridMate networking APIs.

• \Editor contains all the assets, scripts, and conﬁguration ﬁles for the Lumberyard Editor as well as some of the various editors it manages, such as the Materials Editor, the UI Canvas Editor, and the Particle Editor.

• \Engine contains all the default asset binaries, script files (.lua), entity configuration files (.ent), material definition files (.mtl), shader extensions (.ext), and engine configuration files for Lumberyard.

• \Gems contains all the source and build ﬁles for the Gems that ship with Lumberyard. When you create a new Gem, you’ll add the code and build sources here, and then enable the Gem through the Project Conﬁgurator.

• \ProjectTemplates contains the game project templates you can choose from when initially conﬁguring Lumberyard for your game’s development.

• \SamplesProject and \StarterGame contain samples and a complete game level for you to review.

• \Tools contains a number of tools and SDKs you’ll use throughout the development of your game, including:

• \Tools\AWSNativeSDK: Contains scripts for obtaining various platform-speciﬁc SDKs for working with Amazon’s cloud services in their native languages.

• \Tools\AWSPythonSDK: Contains Python SDKs for working with Amazon’s cloud services.

• \Tools\AzCodeGenerator: Contains the binaries and conﬁguration ﬁles for AZ Code Generator, which is a command-line utility that generates source code (or any data or text) from specially tagged source code. For more details, see Automating Boilerplate with Az Code Generator.

• \Tools\build: Contains scripts and tools for building your game project with Waf including the lmbr_waf command-line build utility.

(12)

Working with Gems

• \Tools\CrySCompileServer: Contains the executable and libraries for the CryEngine shader compiler service.

• \Tools\LuaRemoteDebugger: Contains the executable and libraries for the Lua script remote debugging tool.

• \Tools\Python: Contains all basic Python libraries and the interpreter. Lumberyard supports a minimum version of 3.7.5.

• \Tools\Redistributables: Contains common packages and ﬁles that you can ship with your game, including DirectX and Visual Studio DLLs.

• \Tools\RemoteConsole: Contains the Lumberyard remote console application.

Lumberyard also provides two command-line tools, Lmbr.exe and Lmbr_waf.exe, which you use to manage your game project overall and conﬁgure the details of your game project during development.

• Lmbr.exe--Provides a set of commands for managing and tracking Gems, capabilities, and 3rd party tools and packages.

• Lmbe_waf.exe--Provides a set of commands for automating the building and packaging of game projects with the Waf build automation framework.

All of these parts—plus some not listed here—deﬁne Lumberyard, and can be used to construct your game. As you incorporate Lumberyard systems and develop your own, you will want to communicate across them. For that, we have EBus.

Working with Gems

Many of Lumberyard’s capabilities are implemented through Gems. A Gem is a packaged extension that can be enabled in a project to add functionality or features. Gems might contain module code, assets, scripts, supporting ﬁles and references to other Gems. Using Gems enables you to choose the features you need for your project and exclude those that aren’t necessary. By keeping everything modular and only using what you need, the Gem system lets you iterate faster. Asset collections, code samples, components, libraries, tools, and even entire game projects can be distributed as Gems.

You enable Gems when you create your project in Project Conﬁgurator. You can return to Project

Configurator at any time to enable additional Gems and disable unused Gems. When you create your first project, be sure to click the Enable Gems option in Project Configurator to see the list of Gems available.

Some Gems are core systems and required for all Lumberyard projects. Other Gems are extensions for existing Gems and require their dependencies be enabled for your project. Gems you enable are detected and built automatically when you build your project.

You can create your own Gems and easily reuse and distribute your own code and assets. To get a better idea what goes into creating a Gem, have a look at the Gems directory of your Lumberyard installation and examine the included Gems. The process for creating your own Gem is through Project Conﬁgurator, and is very similar to creating a project.

Messaging between systems with EBus

All of Lumberyard’s Gems and systems, as well as the components in your projects need a way to communicate with each other. Lumberyard uses a general-purpose communication system called Event Bus (EBus for short).

As discussed earlier, Gems and systems are typically implemented as DLLs. EBus is used to communicate

(13)

Messaging between systems with EBus

both request and publish/subscribe event interfaces (buses) that allow calls across those DLLs. For example, if you’ve created a Gem for custom physics behaviors and you’d like to provide data to the CryEngine renderer, you’d do so by implementing an EBus interface in your Gem.

We provide the interfaces for the Gems and systems DLLs we ship as headers in the default installation.

To use the functionality in these DLLs, you use the interfaces in these headers to register for a single cast (Event) or broadcast (Broadcast) event, or through supplying a data request functor to a Request Bus handler.

Likewise, to expose functionality from your own gems and provide data to another system, you must inherit the virtual interface declared in the corresponding header file and implement the handlers on that interface in your Gem’s classes, and then register that handler with the EBus system. Specifically, you’ll register a handler you create with EBus, which will pass a pointer to your class method to the targeted system or post a notification to the systems that are subscribed to it.

Inside of your Gem code, you also manage the connection and disconnection of your implemented handler for the EBus. EBus is just a list of handlers that calls all the functors (function pointers) registered with it..

For singleton handlers where you only need one interface to communicate across DLLs, consider using AZ::Interface and AZ:Event directly, without EBus.

There are two types of EBus:

• Request bus: This EBus type registers a handler for a method that can be called by other systems.

• Notiﬁcation bus: This EBus type provides a messaging interface for notiﬁcations that systems can publish or subscribe to.

EBuses have many advantages over traditional polling methods:

• Abstraction – Minimize hard dependencies between systems.

• Event-driven programming – Eliminate polling patterns for more scalable and higher performance software.

• Cleaner application code – Safely dispatch messages without concern for what is handling them or whether they are being handled at all.

• Concurrency – Queue events from various threads for safe execution on another thread or for distributed system applications.

• Predictability – Provide support for ordering of handlers on a given bus.

• Debugging – Intercept messages for reporting, proﬁling, and introspection purposes.

EBuses are conﬁgurable and support many diﬀerent use cases:

• As a direct global function call.

• Dispatch processing to multiple handlers.

• Queue all calls, acting like a command buﬀer.

• As an addressable mailbox.

• For imperative delivery.

• For queued delivery.

• Automatic marshaling of a function call into a network message or other command buﬀer.

For details on using EBus, read:

• Working with the Event Bus (EBus) System

• Event Buses in Depth

(14)

The Component Entity system

But what about the parts of your game that are actually in the game proper? Lumberyard has a model for that as well, called the component entity system.

Understanding the component entity system is fundamental to using Lumberyard. It’s conceptually simple: Every in-game object you create for your project is an entity, with a unique ID and container.

Each entity contains components that provide functionality. The functionality components provide is broad and includes primitive shapes, meshes, audio, artiﬁcial intelligence behaviors, animation, visual eﬀects, physics, scripts, and so much more. There are even components that provide tool and debugging functionality.

As an example, suppose you want to create a door entity that can be opened and closed. You made a mesh and a couple audio ﬁles. Now, consider the functionality your door must have.

• Display the door model.

• Play back the audio ﬁles when the door opens and closes.

• Prevent passing through the door when it’s closed.

• Animate the door open and close.

• Trigger the door open and close by some mechanism.

Knowing the functionality your door entity needs, you add components to the entity for each aspect of the door, including its presence in the game world and the ways a player can interact with it. A Mesh component visually represents the door in the game world. Audio Trigger components provide the audio when it opens or closes. A PhysX Collider component prevents a player from passing through the door when it’s closed. Script Canvas components deﬁne the behaviors, including animation and sound playback, when the door is opened or closed. Whatever behavior you need to model, each entity is going to have a collection of components to support it. The only component common to all entities is the Transform component, which provides the position, orientation and scale of your entity in the game world.

Entities are easy to grasp and create, but can become complex. If the entity requires a lot of functionality, the list of components grows quickly. What if you want to add a latch with its own

animation and audio to the door? What if you want to add a breakable glass pane to the door? Suddenly, the entity goes from having ﬁve components to dozens of components. This is where slices come in.

A slice, like an entity, is a container with a transform behavior. Instead of containing components, a slice contains one or more conﬁgured entities and might contain other slices as well. To create a more complex door, you could have the initial door entity, a second entity for the latch and its components, and a third entity for the breakable glass pane and its components. These three small entities are collected into a slice that provides a reusable, fully functional door asset. You may have heard similar concepts referred to as prefabs in other software. In Lumberyard, a slice is a collection of entities and/or other slices in a single reusable asset.

Behaviors applied to a slice can potentially cascade down to all of the entities it contains, and then down to the components of that entity. However, the reverse is not true, as it would make no sense for a window shattering to apply to a door latch.

Once you’ve internalized the slice > entity > component hierarchy, consider how you would use these concepts to develop the various elements potentially populating your game levels and world.

The Lumberyard Asset Pipeline

We’ve discussed what’s in the Lumberyard installation, the basic framework of Lumberyard and how

(15)

Scripting for the Lumberyard framework

do you create and manage assets for your game? After all, a door doesn’t truly exist in your game if it doesn’t have some form of representation.

For the purposes of Lumberyard, we’ll define an asset as a resource file, saved on disk, consumed by your project in some way. An asset might be a font for your user interface, a bitmap file that contains a grassy terrain texture, a rock mesh you sculpted, animations for a character, etc. Some assets might be created in Lumberyard. Specialized files called inputbindings that map buttons from a game pad to input events for your project and physicsmaterials that describe the physical properties of surfaces, for example, are both created in Lumberyard’s Asset Editor.

For many reasons, the primary being performance considerations, these different assets cannot be consumed by Lumberyard without being converted to operating system specific, game ready data. This process, going from a source asset file on disk to game ready data is the Asset Pipeline. The processing is performed automatically by Asset Processor.

Asset Processor is a background process (you’ll see its icon in the task tray when it’s running) that constantly scans directories in your project for changes in ﬁles. When changes are detected, Asset Processor uses conﬁgurable rules to determine how to handle the changes. The objective is to have game ready versions of all assets for each OS and each game directory in a location called the asset cache. The asset cache is kept separate from your asset directories and can be automatically rebuilt entirely from your source assets by the Asset Processor.

The asset cache contains a full image of all files (except executables and related files) needed to run your project. Asset Processor keeps the image up to date, ensuring that new files are ready to use in the project runtime and Lumberyard Editor as soon as possible. Your project runtime will only load assets from the asset cache and never directly from your asset source directories.

Projects like modern games can have thousands of assets that need to be monitored and processed for multiple target operating systems. To manage this complexity, the Asset Pipeline is completely conﬁgurable. Here are just some of the conﬁguration options available:

• Specify what directories should be monitored for changes.

• Specify target operating systems and tailor the Asset Pipeline’s behavior per target operating system.

• Set the number of concurrent processing tasks.

• Use metadata information to associate ﬁle types and process side-by-side assets.

• Add your own asset types to the Asset Pipeline.

• Batch process assets on a build server.

When you’re preparing to ship, you’ll need to package the assets your project uses. Even small projects can have hundreds of assets, including multiple versions of assets, many of them not required in your ﬁnal project. Manually tracking and determining which assets you need to ship can be tedious, time consuming an error prone. Asset Bundler solves this for you.

Asset Bundler makes shipping the specific assets used for the release of your game more reliable and repeatable. Reliability is based on an underlying dependency system. If you make changes to your project and add, remove, or update assets, Asset Bundler uses the dependencies to automatically determine which assets to include. Repeatability is based on underlying configuration files that provide consistency each time you run Asset Bundler.

Scripting for the Lumberyard framework

Now, you’ve created assets and deﬁned them in your game using slices, entities, and components. You have an empty level or world to roam, but where’s the game? That’s where scripting comes in.

Lumberyard includes two scripting technologies for creating logic and behaviors: Script Canvas and Lua.

(16)

Further learning

Script Canvas is a visual scripting environment. In the Script Canvas editor, you create, connect, and rearrange graphical nodes that provide a visual representation of the logic ﬂow. Script Canvas oﬀers an approachable and easy-to-read environment to author behaviors using the same framework as Lua and C ++. You can use Script Canvas to create scripts without needing to know how to code.

To enable Script Canvas for Lumberyard, you must enable the Script Canvas Gem.

Lua is powerful, fast, lightweight, embeddable scripting language. Lua facilitates quick iteration in your project because you can run your changes immediately without needing to recompile your source code.

Lumberyard’s functionality is exposed to Script Canvas and Lua by the behavior context. The behavior context reﬂects runtime code and makes it accessible to scripts by providing bindings to C++

classes, methods, properties, constants, and enums. The behavior context also provides bindings for Lumberyard’s EBus so you can dispatch and handle events through Script Canvas and Lua.

Functionality for both Script Canvas and Lua is added to entities through components. You can have multiple script components and mix and match between Lua and Script Canvas within your entities. This approach enables you to create small, manageable modules of logic and behavior that can be reused throughout your projects.

Further learning

As you’ve probably suspected, there’s a lot more to Lumberyard than this, but we hope this gives you a good sense of where to start your searches for greater detail in our docs and code. Here’s a few additional links to help you explore further:

For some great videos on getting started with Lumberyard, check out our Getting Started video tutorial series.

For some docs to get you started, check out the following topics:

• Lumberyard Editor

• Programming Concepts

• Gems

• Component Entity System

• Component Reference

• Programmer’s Guide to Entities and Components

• Emotion FX Animation Editor

• Script Canvas

• Lua Editor

(17)

System requirements

Setting up Amazon Lumberyard

Amazon Lumberyard has a two-part installation process:

1. The installer application downloads, extracts, and installs Lumberyard.

2.Setup Assistant conﬁgures and installs additional software based on your development needs. Jump right in to the Lumberyard Editor with an Express Install or customize Lumberyard’s features for your development needs with a Custom Install.

After Lumberyard is installed, use Project Conﬁgurator to select a project or create a new project.

The following sections detail the minimum requirements for Lumberyard and guide you through the installation process.

Topics

• Amazon Lumberyard system requirements (p. 12)

• Installing Amazon Lumberyard (p. 14)

• Conﬁguring your Amazon Lumberyard environment with Setup Assistant (p. 16)

• Manage Lumberyard projects with Project Conﬁgurator (p. 20)

Amazon Lumberyard system requirements

Lumberyard has a minimum set of system requirements for development, as outlined in the following sections. Disk space and RAM requirements are dependent on the options that you choose during installation.

System requirements

If your system is capable of running a modern real-time 3D game with good performance you should be set, however, review these detailed requirements to be certain.

Lumberyard requires Windows 10.

Minimum hardware requirements include the following:

• 3 GHz quad-core processor

• 8 GB RAM

• 2 GB VRAM DirectX 11 or later compatible video card

• NVIDIA GeForce GTX 660 Ti with driver version 368.81 or later

• AMD Radeon HD 8730M with driver version 16.15.2211 or later

(18)

Prerequisites

• 60 GB of free disk space

• 1366 x 768 px screen resolution

NoteIf you select options to build the engine, editor, or tools in Setup Assistant, 14 GB RAM is required for compilation.

Some advanced graphics features require a DirectX 12 or later compatible video card.

Required free disk space is dependent on the options that you select when installing Lumberyard.

Prerequisites

You can use the Lumberyard Editor and tools without installing additional software. To create new projects or use advanced development features in Lumberyard, you need a developer environment that includes Microsoft Visual Studio. The following versions are supported:

• (Recommended) Microsoft Visual Studio 2019 version 16.2.4 thru version 16.9.x.

Important

There are some issues that arise when using the MSVC compiler shipped with Visual Studio 2019 versions 16.8, 16.8.1, and 16.8.2. For more details, check out the Lumberyard 1.28 Known Issues.

• Microsoft Visual Studio 2017 version 15.9.14 thru version 15.9.x.

Microsoft oﬀers Visual Studio Community edition free to individual developers. For more information and to download and install Visual Studio Community, visit the Visual Studio Community portal.

Visual Studio 2017 and 2019 required features

The default Visual Studio installation might not include all of the features that are required by Lumberyard. Ensure that the following Visual Studio features are enabled:

1. Launch the Visual Studio Installer from your download directory or the Start Menu if you’ve already installed Visual Studio.

2. If you’ve installed Visual Studio, choose More - Modify on the version of Visual Studio you’ll use with Lumberyard.

3. On the Workloads tab:

• Select Game development with C++.

• In the Installation details panel on the right, select at least one Windows 10 SDK.

• Select Desktop development with C++.

4. On the Individual components tab, under Compilers, build tools, and runtime, make sure that a VC+

+ toolset that corresponds to the installed version of Visual Studio has been selected:

• If using Visual Studio 2017: Select at least one version of the VC++ 2017 toolset.

• If using Visual Studio 2019: Select at least one version of the MSVC v142 - VS 2019 C++ x64/x86 build tool.

• (Optional) To build with the Visual Studio 2017 toolset in Visual Studio 2019, select MSVC v141 - VS 2017 C++ x64/x86 build tools.

Visual C++ redistributable packages

(19)

Install

redistributable packages may fail. If you receive a missing Visual C++ runtime .dll error while running Lumberyard Installer, Lumberyard Setup Assistant, or Project Conﬁgurator, do the following:

1. Check that the Visual C++ redistributable installers for Visual Studio 2012 and Visual Studio 2019 have been successfully downloaded. The installers are located in the corresponding Visual Studio directories in the lumberyard_version\dev\Tools\Redistributables\ directory.

2. If the Visual C++ redistributable installers for Visual Studio 2012 and Visual Studio 2019 have not been downloaded by Lumberyard Installer, manually download the installers from Microsoft.

• Visual C++ Redistributable for Visual Studio 2012

• Visual C++ Redistributable for Visual Studio 2019 3. Run both Visual C++ redistributable installers.

4. Retry the Lumberyard installation after the Visual Studio redistributables have successfully installed.

NoteThe Visual C++ Redistributable for Visual Studio 2019 also contains redistributables for Visual Studio 2015 and 2017.

Installing Amazon Lumberyard

Download the latest Lumberyard Installer.

Run the Lumberyard installer

Navigate to your Downloads directory and run LumberyardInstaller.exe to download, extract, and install Lumberyard.

The default Lumberyard installation path is C:\Amazon\Lumberyard\. To set a diﬀerent installation path, choose the Options button. Choose the Install button to begin installation. The process can take some time, depending on your internet connection speed.

NoteIn some situations, the Lumberyard Installer can hang and refuse to progress. The only known remedy at this time is to forcibly terminate the installer through the Windows Task Manager, or reboot, then retry the installation.

(20)

Lumberyard’s executables

The installer displays an Installation Successfully Completed message. Click Launch Lumberyard Setup Assistant to continue with setup.

Lumberyard’s executables

LumberyardInstaller.exe creates shortcuts on the desktop and in the Start Menu for three applications:

Setup Assistant (p. 16)

• Setup Assistant conﬁgures Lumberyard’s environment according to your development needs, and downloads and installs additional software and SDKS. You can use Setup Assistant at any time to add development features to your Lumberyard environment.

SetupAssistant.exe is located in lumberyard_version\dev\Tools\LmbrSetup\Win.

Project Conﬁgurator (p. 20)

• With Project Configurator, you create, configure, set, and build projects. When you run Project Configurator for the first time, you see several sample projects that are available to help you learn Lumberyard’s features.

ProjectConﬁgurator.exe is located in lumberyard_version\dev\Bin64vc141 or Bin64vc142.

Lumberyard Editor (p. 32)

• Lumberyard Editor is Lumberyard’s core application. In Lumberyard Editor, you create levels, assets, and interactions for your projects.

Editor.exe is located in lumberyard_version\dev\Bin64vc141 or Bin64vc142.

Lumberyard’s directory structure

The default Lumberyard installation location is C:\Amazon\Lumberyard\lumberyard_version\.

The root directory contains the following directories and ﬁles:

• dev

• _WAF_: Waf build system ﬁles.

• Bin64: Binaries and conﬁguration ﬁles for the Resource Compiler.

• Bin64vc141: Binaries and conﬁguration ﬁles for Visual Studio 2017.

• Bin64vc142: Binaries and conﬁguration ﬁles for Visual Studio 2019.

• Code: Source ﬁles and solution ﬁles for the Lumberyard engine and tools.

• Editor: Editor assets.

• Engine: Engine assets.

• Gems: Modular components and assets.

• MultiplayerSample: Multiplayer sample project that demonstrates how to build a multiplayer game with the component entity system.

• ProjectTemplates: Conﬁguration ﬁles, libraries, and scripts for the empty template.

• SamplesProject: Sample project.

• StarterGame: A full example game with 3D environments, event scripting, and basic enemy AI.

• Tools: Third-party tools and plugins.

• engineroot.txt: System ﬁle required by Lumberyard Setup Assistant to verify the directory.

• 3rdParty

(21)

Setup Assistant

Conﬁguring your Amazon Lumberyard environment with Setup Assistant

Lumberyard Setup Assistant conﬁgures and maintains your Lumberyard environment based on your development needs. If you’re continuing from Installing Amazon Lumberyard (p. 14), Setup Assistant should be running on your desktop. Setup Assistant can also be launched from the Start Menu or desktop shortcuts.

Lumberyard Setup Assistant performs several important functions:

• Ensures that you have the required runtime software.

• Ensures that you have the required SDKs.

• Provides plugins for detected content applications such as Photoshop and Maya.

• Validates registry settings, paths, and libraries.

On ﬁrst run, Lumberyard Setup Assistant presents two options, Try out Lumberyard and Full Install (also known as "Custom Install"). If you’re a content creator, such as a designer or artist, and won’t be compiling code, or if you want to jump right in and use the Lumberyard Editor and tools, select Try out Lumberyard. You can always revisit Setup Assistant to add development features. If you’d like to set up Lumberyard for code development, select Full Install.

You should run Setup Assistant periodically, especially after you make changes to your environment, to validate and repair settings and paths. You can also customize Setup Assistant with a configuration file to easily integrate your specific directory structure.

(22)

Lumberyard Setup Assistant custom installation

NoteSome Setup Assistant options require the installation of third-party software and licenses, so make sure that you consult the terms of service before installing third-party software.

Lumberyard Setup Assistant custom installation

With Full Install, you specify how you would like to use Lumberyard. Setup Assistant downloads third- party software and validates that the environment is properly conﬁgured based on your choices.

1. Custom installation begins with specifying how you intend to use Lumberyard.

2. Verify the Path is correct for your Lumberyard installation.

3. Select options based on your development needs:

• Create, Modify and Build projects - Select this option if you intend to create and build new projects with Lumberyard on the Windows platform, or make changes to the engine, asset pipeline, or other tools.

• Compile for Android devices - Select this option if you intend to build projects for Android devices.

• Setup for Linux Dedicated Server - Select this option if you intend to build projects for Linux Dedicated Server.

4. Select Visual Studio 2017 or Visual Studio 2019.

NoteWe recommend that you select only one version of Visual Studio - the one that you will use to compile your projects. If both are enabled, you will be asked which compiler to use when you rebuild your project in Project Conﬁgurator.

Important

The version(s) of Visual Studio selected here will be enabled as build platforms, and Visual

(23)

5. Once you are satisﬁed with your selections, choose Next to install required software and SDKs.

6. The Install software and Install required SDKs pages display a red icon if a requirement cannot be found and a green checkmark for installed requirements. Missing optional software and SDKs display a yellow icon. Follow the instructions on each page to install the required software and SDKS.

(24)

(25)

Project Conﬁgurator

NoteEnsure the Third-party path on the Install required SDKs page is correct for your Lumberyard installation.

7. Install desired optional software and SDKs on the Install software, Install optional SDKs, and Install plugins pages by following the instructions on each page.

8. When you have completed installing software and SDKs, the Summary page displays information about your Lumberyard environment. From the Summary page, you can launch the Lumberyard Editor by choosing Launch Editor. If you’d like to choose an existing project or create a new project, choose Conﬁgure project to launch Project Conﬁgurator.

Manage Lumberyard projects with Project Conﬁgurator

Project Configurator configures and manages your Lumberyard projects. If you’re continuing from Configuring your Amazon Lumberyard environment with Setup Assistant (p. 16), Project Configurator should be running on your desktop. Project Configurator can also be launched from the Start Menu or desktop shortcuts.

With Project Conﬁgurator, you can:

• Set a default project.

• Create new projects.

• Add code or asset features to your project by enabling Gems.

• Create new Gems that can be added to projects.

• Build projects.

• Set advanced game and editor settings per project.

(26)

Select a project

Lumberyard has several example projects that you can work with to learn Lumberyard’s features. To select a project, choose the project’s icon. The selected project is highlighted with a check mark.

Important

If you’re new to Lumberyard and would like to explore its tools and features quickly, we

strongly recommend using the default StarterGame project. Changing or modifying the default project, or creating a new project will require rebuilding the Lumberyard game and engine. The initial build for a Lumberyard project can take two hours or more depending on your system speciﬁcations.

To load a project in Lumberyard Editor, the project must be set to default. While the project is selected, choose the Set as default button in the upper right-hand corner of the Project Conﬁgurator window. If

(27)

Create a new project

When you create a new project Project Conﬁgurator creates a new directory in lumberyard_version

\dev\ with your project’s name. Any project-specific files like configuration data, assets, levels, and scripts live within this project directory. Throughout this process, Project Configurator creates the necessary files and Visual Studio solutions, then builds your project. This process can take some time.

1. Choose the Create new button in the upper left of the Project Conﬁgurator to bring up the Create a new project window.

2. In Create a new project give your project a name in the upper left and select either the Default or Empty project template.

(28)

NoteMany features in Lumberyard are implemented in packaged extensions called Gems. The Default project template contains a basic set of commonly used Gems. The Empty project template contains a minimal set of required Gems. Once you have created a project, you can add or remove Gems.

3. Choose Create project. A new window displays your progress as your project is created and built. The build process can take some time based on your system.

(29)

4. When your new project has been built, choose Continue to return to the main Project Conﬁgurator interface. Your new project should be selected. If not, choose the project icon to select it. Choose the Set as default button to make your project the default project.

5. Your project is now ready. You can move on to Lumberyard Editor or take the time to explore some of the advanced features of the Project Conﬁgurator before moving on. Next to your new project icon are three links:

• Enable Gems

Choose Enable Gems to open the Gems editor. Gems are packaged extensions that add new features and assets to your project. You can create your own Gems here, similarly to how you created a new project. Scrolling down the list of available Gems, you’ll notice that some gems are enabled (their box is checked). To add or remove Gems, check or uncheck the box next to the Gem.

(30)

(31)

NoteAdding or removing Gems might require rebuilding your project, which can take some time.

To rebuild your project, choose the Rebuild button on the main Project Conﬁgurator page.

• Advanced Game Settings

Choose Advanced Game Settings to open the game settings view. In this view, you can modify your project’s memory allocation and other settings that are exposed by Lumberyard, as well as the Gems that have been added to your project.

• Advanced Editor Settings

Choose Advanced Editor Settings to open the settings view. In this view, you can modify Lumberyard Editor settings for your project.

(32)

How do I create a game with Lumberyard?

Create with Amazon Lumberyard

Previously in this guide, we covered How Amazon Lumberyard works (p. 5) and Setting up Amazon Lumberyard (p. 12).

Now, let’s get started creating your game! In this topic, we provide an overview of creating a game with Lumberyard, and help you identify where to focus your learning, based on your role in game development. If you’re proﬁcient in all roles, read everything!

How do I create a game with Lumberyard?

Keeping it Modular

Game development in Lumberyard is best understood if you keep a key Lumberyard design philosophy in mind as you learn: the concept of modularity. The Lumberyard game engine, its systems, and its environment are built as a collection of C++ modules. Choosing the right modules based on the combination of your game’s design and your workﬂows will keep your game development process focused and likewise keep the overhead of managing your game project simpler.

Even the Lumberyard Editor – the most common tool associated with Lumberyard – uses these modules, which we call Gems. Lumberyard ships with well over 100 Gems as part of the installation, and you can acquire other Gems from third parties, or write new ones yourself. When you build your game, the functionality of these Gems is combined to create the systems of your game. This means that you don’t have to hard-code the systems and features of your game. Instead, you can either obtain or create a Gem with the functionality you need – and even maintain the code for it independent of the game! This isolation means that a game developer can work on game-speciﬁc AI functionality in a Gem. When the Gem is updated, level designers can access the new functionality after a rebuild of the game project, and without impacting any other Gem. Gems can also add new features to the Lumberyard Editor and provide new asset processing behaviors.

You’ll notice this philosophy of modularity in the individual entities you create, up through the most complex functionality you add.

For example, consider the concept of an entity in Lumberyard. An entity can represent just about anything in your game under Lumberyard’s component entity system. By giving the entity components, you begin to shape their utility in your game. The components specify entity behaviors and properties.

You might have an entity that you want to see and interact with in your game world that uses all of the following components:

• The default transform component to deﬁne its position

• A mesh component to deﬁne its visual geometry

• NVIDIA PhysX components to deﬁne collision characteristics and other aspects for a realistic, rigid body simulation

• An input component to reference an input event-binding deﬁnition

• A script component to automate some sort of behavior, or process input events from the player

• A camera component to allow the entity to be used as a camera

(33)

How do I create a game with Lumberyard?

Other entities that you create will be invisible to players. These entities might exist to implement triggers, spawn environmental eﬀects, or reference assets created with tools, such as the game UI that you created in UI Editor.

A major part of assembling a game in Lumberyard revolves around using the Lumberyard Editor to do the following:

• Place and group entities

• Add components to these entities

• Conﬁgure properties on these components

• Use tools associated with the components

Tools you might use that are associated to speciﬁc components include:

• Script Canvas to create and edit scripts using a visual scripting system, then reference from the Script Canvas component.

• Emotion FX Animation Editor to animate characters, then reference from the Anim Graph component.

• Asset Editor to create input bindings that bind raw player input, such as keystrokes, to events, then reference from the Input component.

• Audio Controls Editor to setup sound eﬀects that map to Wwise controls, then reference from the Audio Trigger and Audio Switch components.

...and many more.

Some tools can be opened directly from their associated component. Others require you to open them from the Tools menu in Lumberyard Editor. For a tour of Lumberyard Editor, see Introduction to the Lumberyard Editor (p. 32). For an overview of the tools provided with Lumberyard, see the following topic on Tools available in Amazon Lumberyard (p. 38).

The modular nature of Lumberyard means there are additional assets, components, and tools that you can add by enabling Gems in Project Conﬁgurator. Lumberyard comes with a library of Gems. Gems can include new code, new assets, or both! You can even write your own. In fact, this is what a game’s C+

+ programmers will often spend their time doing, to help create the gameplay that makes your game unique.

Starting the Journey

Are you starting a new project, maybe to start a prototype of your game? Or to just play around with Lumberyard – take it for a spin and learn what it can do? You’ll probably need to know how to get the minimum systems going, which typically include:

• Camera

• Rendering

• Physics

• Input

You’ll use the Project Conﬁgurator tool to set the project that you’re working on. You can use one of the projects that ship with Lumberyard, such as the Samples Project, if you want to learn or play around with something premade. Or, if you want to start something new, this is also where you create a brand new project, based on the template of your choice.

Then, launch the Lumberyard Editor, open one of the sample levels in the Sample Project, and start exploring! We suggest following along with one of these written or video tutorials:

(34)

Work as an artist

• Learn Lumberyard in 20 Minutes

• Set Up Amazon Lumberyard series

• Creating a Controllable Entity

• Basics of Motion series

Joining a Team

Depending on your role in your game development team and the scope of the game project that you’re working on, you might not encounter all of the tools and technologies that Lumberyard provides. In the next section, we’ll take a look at how you might want to focus your learning path.

Work as an artist

Lumberyard provides all of the basic tools that you need to import, assemble, and blend animations in a AAA game, creating new worlds or environments for the player to visualize, interact with, and experience.

While much of your work as an artist might involve using tools outside Lumberyard, you will use Lumberyard tools when you want to control your character animations, and manipulate the look and feel of your assets or the environment. You might be working with designers to create the game environment.

As an example, let’s take a look at the workﬂow for setting up an actor in your game.

1. Outside of Lumberyard, you create a character model, materials, textures, and rig for the character.

2. Lumberyard’s Asset Processor automatically processes source assets into platform-specific game assets, ensuring new or modified files are ready to use in Lumberyard as soon as possible. Use FBX Settings if you want to modify the processor settings.

3. You import your actor ﬁle in Animation Editor and create a motion set to specify the motions that you want for your character.

4. Next, you create an animation graph using nodes.

5. Then, you build a blend tree to blend the animations together.

6. When you’ve built and previewed the animations and are ready to try them out in a game environment, you can switch over to Lumberyard Editor.

7. In the Lumberyard Editor, you create or open an existing test level.

8. To see your animated character, you need an entity with:

• an Actor component to create a controllable character with the actor ﬁle from Animation Editor and a material linked to your actor asset.

• an AnimGraph component to use the animation graph and motion set assets that you created in the Animation Editor.

9. To control your character in your level, you might want to work with a gameplay designer or programmer at this point to add an Input component, PhysX components, and script components so you can run through and playtest all of your character’s animations in your game’s speciﬁc environment.

We suggest that you begin your learning path by browsing the following set of Lumberyard tools and technologies, and then focusing on the ones that apply to your needs:

(35)

Work as a designer

• Asset Pipeline

• FBX Settings Tool

• Gem Library

• Cinematics and the Track View Editor

• Shaders and Materials

• Terrain and Environment

• Vegetation Editor

Some speciﬁc tutorials you might want to look at include:

• Import Assets into Lumberyard

• Animation System and Emotion FX

• Lighting

Work as a designer

Lumberyard Editor is an important, core tool for game designers and level designers. It’s where you create your levels, populate them with entities, and assign components to those entities. It also provides access to important tools such as the UI Editor for UI designers, the Audio Controls Editor for sound designers, and Script Canvas for all designers who will be working with the visual scripting system in Lumberyard.

Here’s how you might start out:

1. When you start Lumberyard Editor for the first time, you can create a new level, or you might prefer to open one of the existing levels in the Samples Project to play around with. If the Samples Project is not your current project, use Project Configurator first, and set it as the default project.

2. You start populating your level in the viewport by creating entities. In Lumberyard, an entity can be just about anything, from the static objects you see, to the triggers you script, to the placeholder objects that reference game UI.

3. You add components to your entities through the Entity Inspector tool.

4. To provide player control for your entities, you’ll need an input binding. Using the Asset Editor tool, you bind raw player input from keyboard, mouse, and game controllers to events that you create.

Then you can listen for and respond to these events using one of the scripting tools.

5. Script Canvas and Lua are common scripting tools that are used in Lumberyard. Script Canvas provides a visual, node-based scripting system for scripting your gameplay logic, while Lua provides a more traditional scripting environment based on the Lua API. Add a Script Canvas component or Lua Script component to an entity. Develop a script in one of the script editors. Then you can add that script to the component to control that entity at runtime. For example, using a script, you can control an entity by responding to player input events, spawning dynamic entities at runtime, producing visual eﬀects, and much more.

6. As you populate your world with entities, you’ll learn that a great way to save time is to use the slice system. Slices are a type of prefab system that allows you to group and nest component entities together, save the group as a slice, and then create multiple instances of that slice throughout the levels of your project. In each instance of the slice, you have the ability to make changes to that

(36)

Work as a game engineer

speciﬁc instance. This change is referred to as a slice override. You can also choose to save the override to the original slice, which then pushes that change to every other instance, too.

7. When you’re ready to author game UI, you use the UI Editor, where you can establish a UI canvas and layout your interface and script your workﬂows.

8. When you’re ready to add sound to your game, you establish audio events and triggers in the Audio Controls Editor. You can then add this audio to entities through components, and script its playback using one of the scripting systems.

To get the most out of Lumberyard, browse the Components library and the Gems library to see what Lumberyard has to oﬀer. Then talk to your programmers to see what additional components need to be authored for your game.

We suggest that you begin your learning path by browsing the following set of Lumberyard tools and technologies, and then focusing on the ones that apply to your needs:

• Asset Pipeline

• Gem Library

• Script Canvas

• Lua Editor

• AI Navigation

• Audio Controls Editor

• Cloud Canvas

• UI Editor

• Script Canvas series

• Basics of Motion series

• Working with Slices

• Simulate Physics

• Modify Terrain

Work as a game engineer

As a Lumberyard game engineer, you will likely need to learn both how to support the designers and artists in the design of the game and environment, and how to author individual components. These new components can then be added to entities in the Lumberyard Editor to create custom gameplay.

You might also learn how to develop new Script Canvas nodes. These new nodes can then be used by

(37)

Lumberyard Editor tour

your new components. On a larger scale, when you need to work on a system that can be distributed as a shareable container of code and assets, you can learn how to create a Gem.

We suggest that your learning path looks like this:

1. Follow the intro tutorials to learn about the component entity system and the existing library of components.

2. Browse the Gem library to see examples of the larger functionality they can add compared to individual components.

3. Learn about authoring your own components and Gems, where you will also learn about working with EBuses, Lumberyard’s event bus and general-purpose messaging system; AZ Modules, a collection of C ++ code built as a static or dynamic library; and more.

Here is a basic set of Lumberyard tools and technologies to focus on:

• Programming Concepts

• Gems

• Programmer’s Guide to Entities and Components

• Script Canvas

• Lua Editor

• Script Canvas series

• Working with Slices

• Working with Gems

• Simulate Physics

Introduction to the Lumberyard Editor

Lumberyard Editor is your primary workspace. From here, you access all of the tools to design, create, test, play, and deploy your project. If you have used other professional engines or 3D animation packages, you’ll ﬁnd the user experience familiar and adapt to Lumberyard Editor quickly.

Lumberyard Editor can be launched from the start menu or the Lumberyard Editor desktop icon. When Lumberyard Editor launches, you’re given the option to create a new level or load an existing level. If you’re using one of the example Lumberyard projects, you will ﬁnd example levels in the Levels directory of the project. If you’re working with a new project, you must create a new level.

For a 20-minute crash course on navigating the Perspective viewport, customizing the Lumberyard Editor layout, creating entities, and working with components in Lumberyard Editor, see the following video tutorial.

(38)

The Lumberyard Editor default layout

NoteAmazon Lumberyard version 1.25 introduced an updated interface. You will notice diﬀerences in the visual interface and user experience viewing this video while using Lumberyard 1.25 or later;

however, the information in the video tutorial is still applicable to the fundamentals of using Lumberyard Editor.

The Lumberyard Editor default layout

The default layout of Lumberyard Editor contains the most commonly used tools in a configuration, similar to other content creation applications. The core workflow of Lumberyard is to create and place entities in a level, so the default layout contains a menu bar, two toolbars, and five tool panes focused on entity creation and placement.

You can customize the layout through drag and drop, and save to a custom layout through the Layouts option in the View menu of the main menu bar. Drag the separator bars between panes to resize the panes. Drag the title bar of a pane to tear oﬀ the pane. The pane can be dropped anywhere in the layout or dropped outside of Lumberyard Editor as its own window. To restore the default layout, select Default Layout from the Layouts option in the View menu of the main menu bar.

(39)

The Lumberyard Editor default layout

(40)

Navigating the Lumberyard Perspective viewport

A.Perspective – This 3D viewport is a real-time view of your level. In Perspective, you create and place entities, and view and play your project.

Right-click Perspective in the title bar of the pane to open the perspective menu. From the

perspective menu, you can toggle visibility for various helpers such as the construction plane, icons, and guides. You can also select an aspect ratio, view through various cameras placed in the level, create new cameras from the current view, and split the Perspective pane into multiple views.

Right-click in Perspective to open the context menu to create entities and slices, which are reusable assets that contain multiple entities. From the context menu, you can also create layers that you can use to organize entities and slices in your level.

B.Entity Outliner – The Entity Outliner displays a list of entities, slices, and layers in the current level.

Right-click in the Entity Outliner to open the context menu to create entities, slices, and layers. Much of the functionality of the Entity Outliner context menu is shared with the Perspective context menu.

The Entity Outliner context menu also has options to ﬁnd selected entities and slices in Perspective, organize the list in the Entity Outliner and ﬁnd slices in the Asset Browser.

C.Entity Inspector – The Entity Inspector displays the components of the currently selected entity. At the top of the Entity Inspector is a ﬁeld for the entity Name and an Add Component button. The Add Component button opens a list of components, sorted by type, that can be added to the entity. Each component has its own set of properties that are displayed in the Entity Inspector. All entities contain a transform component that sets the position, rotation, and scale of the entity in the level.

D.Asset Browser – The Asset Browser browses your project’s on-disk assets. Assets such as meshes, animations, and textures are created in third-party applications. Assets such as materials, scripts, and slices are created within Lumberyard Editor. The assets that you create are stored in your project directory. You can also browse default assets that are included with Lumberyard, as well as assets that are included with Gems that have been added to your project.

The left of the pane of the Asset Browser displays a directory structure that you can browse for available assets. When an asset is selected, the preview pane on the right displays a thumbnail preview and information about the asset, if available.

E. Editor Console – The Editor Console shows command and process output from Lumberyard Editor and your project. When you load a level, for example, the console displays messages about assets and configuration files as they load, and might display warnings and errors if issues are encountered. You can enter console commands such as setting console variables in the entry field at the bottom of the console. Click the {x} button in the lower left of the Editor Console to open the Console Variables Editor, which provides a simple interface for setting console variables.

F. Toolbar – The Toolbar provides easy access to various editor tools and features. The toolbar is docked at the top of the editor by default, but you can also dock it vertically on the edges of the editor. To customize the toolbar, right-click anywhere on the toolbar and select Customize from the context menu. You can choose which toolbars, views, or modes to include. You can also add commands to a toolbar.

G.Perspective Toolbar – The Perspective Toolbar at the bottom of the Perspective pane displays position information for selected objects. You can also adjust navigation speed; mute audio; go to a speciﬁc position; toggle camera collision; run simulations, and enable VR preview mode.

Navigating the Lumberyard Perspective viewport

Lumberyard’s interaction model will be familiar to anyone who has played a ﬁrst-person PC game, with a few minor tweaks and additions. Movement is handled by keyboard input, and view is handled by pointer device input.

Amazon Lumberyard

Amazon Lumberyard

Welcome Guide

Version 1.28

Amazon Lumberyard: Welcome Guide

Table of Contents

Welcome to Amazon Lumberyard

Amazon Lumberyard’s creative capabilities without compromise

Welcome Guide contents

Lumberyard features

Here are just some of Lumberyard’s features:

Supported platforms

How Amazon Lumberyard works

Overview of the Lumberyard framework

Working with Gems

Messaging between systems with EBus

The Component Entity system

The Lumberyard Asset Pipeline

Scripting for the Lumberyard framework

Further learning

Setting up Amazon Lumberyard

Amazon Lumberyard system requirements

System requirements

Prerequisites

Visual C++ redistributable packages

Installing Amazon Lumberyard

Run the Lumberyard installer

Lumberyard’s executables

Lumberyard’s directory structure

Conﬁguring your Amazon Lumberyard environment with Setup Assistant

Lumberyard Setup Assistant custom installation

Manage Lumberyard projects with Project Conﬁgurator

Select a project

Create a new project

Create with Amazon Lumberyard

How do I create a game with Lumberyard?

Work as an artist

Work as a designer

Work as a game engineer

Introduction to the Lumberyard Editor

The Lumberyard Editor default layout

Navigating the Lumberyard Perspective viewport