Lumberyard WG

Amazon Lumberyard
Guía de bienvenida
Version 1.24
Amazon Lumberyard Guía de bienvenida
Amazon Lumberyard: Guía de bienvenida

Copyright © Amazon Web Services, Inc. and/or its affiliates. All rights reserved.
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 affiliated with, connected to, or sponsored by Amazon.
Table of Contents
Le damos la bienvenida a Amazon Lumberyard ...................................................................................... 1
Las capacidades creativas deAmazon Lumberyard sin compromisos .................................................. 1
Contenido de la guía de bienvenida .............................................................................................. 2
Características de Lumberyard ............................................................................................................. 3
Estas son solo algunas de las características de Lumberyard: ........................................................... 3
Plataformas admitidas ................................................................................................................. 4
Funcionamiento de Amazon Lumberyard ................................................................................................ 5
Información general del marco de Lumberyard ................................................................................ 5
Uso de Gemas ........................................................................................................................... 7
Mensajería entre sistemas con EBus ............................................................................................. 8
El sistema de entidades de componentes ...................................................................................... 9
La canalización de activos de Lumberyard .................................................................................... 10
Scripting para el marco de Lumberyard ........................................................................................ 11
Aprendizaje adicional ................................................................................................................. 11
Amazon Lumberyard configurar ........................................................................................................... 13
Requisitos del sistema ............................................................................................................... 13
Requisitos del sistema ....................................................................................................... 13
Prerequisites .................................................................................................................... 14
Paquetes redistribuibles de C++ visual ................................................................................ 14
Instalación ............................................................................................................................... 15
Ejecute el comando Lumberyard instalador ........................................................................... 15
LumberyardLos ejecutables de ............................................................................................ 16
LumberyardEstructura de directorios de ............................................................................... 16
Setup Assistant ........................................................................................................................ 17
Lumberyard Setup Assistant instalación personalizada ............................................................ 18
Configurador de proyectos ......................................................................................................... 19
Seleccionar un proyecto ..................................................................................................... 20
Crear un nuevo proyecto ................................................................................................... 21
Crear con Amazon Lumberyard .......................................................................................................... 24
¿Cómo puedo crear un juego con Lumberyard? ............................................................................ 24
Trabajar como artista ................................................................................................................ 26
Trabajar como diseñador ........................................................................................................... 27
Trabajar como ingeniero de juegos .............................................................................................. 28
Lumberyard Editor excursión ...................................................................................................... 29
El Lumberyard Editor diseño por defecto .............................................................................. 30
Cómo navegar por Lumberyard Perspectiva ventanilla ............................................................ 31
Preferencias de movimiento ............................................................................................... 32
[EMPTY] Perspectiva ubicaciones ....................................................................................... 34
Herramientas adicionales ........................................................................................................... 34
Animation Editor ............................................................................................................... 34
Configuración de FBX ....................................................................................................... 35
Editor de configuración de texturas ...................................................................................... 37
Asset Editor ..................................................................................................................... 39
Inspector de niveles .......................................................................................................... 40
Material Editor .................................................................................................................. 41
Particle Editor ................................................................................................................... 42
Configuración de PhysX ..................................................................................................... 43
Script Canvas ................................................................................................................... 44
Terrain Editor ................................................................................................................... 45
Terrain Tool ..................................................................................................................... 46
Track View ....................................................................................................................... 46
UI Editor .......................................................................................................................... 47
Audio Controls Editor ........................................................................................................ 47
Editor de variables de la consola ........................................................................................ 48
Version 1.24
iii
Lens Flare Editor .............................................................................................................. 49

Sun Trajectory Tool ........................................................................................................... 50
Terrain Texture Layers ...................................................................................................... 50
Time of Day Editor ............................................................................................................ 51
Recursos de Lumberyard adicionales ................................................................................................... 52
Cuestiones legales ............................................................................................................................ 53
Redistribuibles de Lumberyard .................................................................................................... 53
Servicios web alternativos .......................................................................................................... 55
....................................................................................................................................................... lvi
Version 1.24
iv
Las capacidades creativas deAmazon
Lumberyard sin compromisos
Le damos la bienvenida a Amazon

Lumberyard
Amazon Lumberyard es un motor 3D gratuito de alto rendimiento con un conjunto profesional de
herramientas, editores y bibliotecas que le permiten crear gráficos cautivadores en tiempo real,
experiencias inmersivas, mundos virtuales impresionantes y visualizaciones dinámicas. Lumberyard
ofrece las capacidades de Amazon Web Services y la comunidad de Twitch para conectar sus ideas con
jugadores, clientes y espectadores de todo el mundo.
¿Qué significa «gratuito»?
Lumberyard es gratuito. No hay licencias de uso, no hay licencias de sitio, no hay suscripciones, no hay
contratos de soporte, no hay participación en los ingresos. Sencillamente gratuito. Si decide utilizar los
servicios de AWS en su proyecto, será responsable de las tarifas asociadas a dichos servicios. El uso de
Amazon Lumberyard es siempre gratuito y puede personalizar las herramientas y el código fuente para
adaptarse a sus necesidades.
Las capacidades creativas deAmazon Lumberyard

sin compromisos
Un motor de primer nivel
Básicamente, Lumberyard es un motor 3D en tiempo real de alto rendimiento que produce una fidelidad
visual increíble. Lumberyard incluye todas las capacidades que los diseñadores profesionales, artistas
y desarrolladores esperan, con patrones familiares de experiencia de usuario que permiten una rápida
adopción y desarrollo. Su potente conjunto de herramientas permite una iteración rápida a la más alta
Version 1.24
1
Contenido de la guía de bienvenida
calidad. Creado sobre una arquitectura modular y ampliable a través del marco de Gemas, Lumberyard
hace que sea fácil agregar nuevas características, API y activos.
Excelente integración con Amazon Web Services
Las capacidades en línea de Lumberyard, respaldadas por Amazon Web Services, ofrece unas
asombrosas posibilidades a los desarrolladores. Los elementos conectados comunes, como servidores
dedicados, contenido dinámico, economías en línea y estadísticas en tiempo real, se implementan y
escalan fácilmente, para que pueda centrarse en los aspectos creativos del proyecto. Con las capacidades
de juego cruzado de Lumberyard y la integración de Twitch, puede encontrar formas nuevas y novedosas
de interactuar con las personas socialmente. El potencial ilimitado de AWS puede ofrecer experiencias que
van mucho más allá de las capacidades de cualquier dispositivo único.
Tanto si es estudiante, aficionado, desarrollador independiente o un estudio importante, Lumberyard

proporciona la misma caja de herramientas creciente para hacer realidad su visión creativa.
¿Le interesa? Siga leyendo para saber lo que hay en la caja.
Contenido de la guía de bienvenida

Características de Lumberyard (p. 3) - Más información sobre el conjunto de características de
Lumberyard.
Funcionamiento de Amazon Lumberyard (p. 5) - Información general de alto nivel de la tecnología

subyacente de Lumberyard.
Configuración Amazon Lumberyard (p. 13) - Descargue, instale y cree un proyecto con Lumberyard.
Crear con Amazon Lumberyard (p. 24) - Una introducción rápida a los flujos de trabajo y las
herramientas principales de Lumberyard.
Recursos de Lumberyard adicionales (p. 52) - Enlaces a explicaciones en vídeo, documentación y

comunidades de Lumberyard en línea.
Version 1.24
2
Estas son solo algunas de las
características de Lumberyard:
Características de Lumberyard
Lumberyard está repleto de características que le permiten crear mundos hermosos, personajes atractivos
y simulaciones dinámicas. Gracias a la profunda integración de Lumberyard con Amazon Web Services y
Twitch, puede agregar características conectadas a la nube y conectar a jugadores y clientes de todo el
mundo.
Estas son solo algunas de las características de

Lumberyard:
Interactuar con los fans con Twitch
Agregue nuevos niveles de interactividad entre los emisores de Twitch y los espectadores con Twitch
ChatPlay. Ofrezca opciones de personalización de transmisiones dinámicas en tiempo real a los emisores
de Twitch con Twitch Metastream. Permita la interacción directa entre los emisores de Twitch y los
espectadores con Twitch JoinIn.
Crear características multijugador robustas con rapidez
Implemente, opere y escale fácilmente servidores de juegos multijugador con Amazon GameLift. Utilice el
marco de gemas en la nube para agregar contenido dinámico, tablas de clasificación y mensajes diarios.
Crear mundos increíbles
Lumberyard Editor es una herramienta de creación de mundos potente y personalizable. Esculpa y pinte
terreno amplio en varias capas. Decore el paisaje con vegetación densa y exuberante. Diseñe cielos
panorámicos con hora del día dinámica y efectos atmosféricos. Cree mares infinitos interactivos. Llene su
mundo con entidades realistas utilizando componentes sencillos pero potentes.
Contar historias con personajes emotivos
Cree personajes creíbles e inmersivos con las herramientas basadas en datos de EMotion FX. El Editor de
animación de Lumberyard proporciona una interfaz visual basada en nodos para dar vida a los personajes
con árboles de mezcla y espacios de mezcla, máquinas de estado visuales y skinning lineal. Cuente
historias atractivas a través de cinemáticas con el editor de secuencias cinemáticas de Lumberyard, Track
View.
Efectos visuales espectaculares con NVIDIA PhysX y partículas
NVIDIA PhysX y NVIDIA Cloth le permiten crear interacciones físicas dinámicas en tiempo real con
colisionadores estáticos, cuerpos rígidos y simulaciones de tela realistas. Con el Editor de partículas de
Lumberyard, puede crear efectos visuales impresionantes.
Desarrollar experiencias atractivas con facilidad
No hace falta ser un programador experimentado para usar la potencia de Lumberyard. Diseñe sistemas y
experiencias atractivos con Script Canvas, un editor de scripts visual basado en nodos que permite un fácil
acceso a la funcionalidad subyacente de Lumberyard. Lumberyard también es compatible con Lua para
diseñadores que prefieren la iteración rápida que proporcionan los lenguajes de script.
Aproveche la potencia de Amazon Web Services
Version 1.24
3
Plataformas admitidas
Con Lumberyard, puede incorporar servicios de AWS como Amazon DynamoDB, AWS Lambda, Amazon
S3, Amazon Cognito, Amazon SNS y Amazon SQS con herramientas y soluciones Cloud Canvas. La gema
Cloud Gem Framework proporciona clases de C++ que pueden ejecutar cualquier llamada de AWS SDK
for C++, aportando la enorme capacidad de procesamiento y almacenamiento de la nube a sus proyectos.
Plataformas admitidas
Puede utilizar Lumberyard para desarrollar juegos para las siguientes plataformas:
• Equipo con Microsoft Windows

• Android
• iOS
• macOS
• PlayStation
• Xbox
• Linux (solo servidor dedicado)
Algunas plataformas tienen requisitos adicionales.
• Para obtener compatibilidad con la consola, consulte los portales Xbox para desarrolladores de juegos y
Socios de PlayStation.
• Para dispositivos móviles, consulte Creación de proyectos de Android e iOS en la Guía del usuario.
• Para macOS, consulte Creación de proyectos de macOS en la Guía del usuario.
• Para servidores Linux dedicados, consulte Creación de ejecutables de Lumberyard para Linux en la
Guía del usuario.
Version 1.24
4
Información general del marco de Lumberyard
Funcionamiento de Amazon
Lumberyard
Amazon Lumberyard proporciona un completo entorno integral para desarrollar y transmitir juegos y
simulaciones, y admite una amplia variedad de plataformas, incluidas consolas, dispositivos móviles,
realidad virtual y equipos con Microsoft Windows. Dado que es un entorno de desarrollo tan grande con
tantas características y herramientas diferentes, puede resultar intimidante para los nuevos usuarios,
especialmente para aquellos que no tienen antecedentes de desarrollador tradicional. Este tema trata
de las diversas partes de Lumberyard a un nivel alto y las formas comunes que puede trabajar con él en
función de su rol o tarea como un nuevo o desarrollador o diseñador de juegos con experiencia.
Lumberyard tiene varias herramientas, editores y sistemas que funcionan conjuntamente para ayudarle a
crear un juego. Un elemento fundamental es el «motor de videojuegos de Lumberyard», que proporciona lo
siguiente:
• Renderizado y salida de gráficos

• Ejecución de lógica de juego
• Mensajería entre sistemas y componentes del juego
• Abstracción y administración de recursos y memoria
• Compatibilidad con subprocesos múltiples para entrada, audio, simulación de físicas, interfaces de
usuario (IU), inteligencia artificial (IA), redes y multijugador, y otras características comunes del juego
• Administración y empaquetado de activos
El motor en sí es realmente solo una colección de componentes y módulos, denominados Gemas. Al

desarrollar, utiliza el editor de Lumberyard y las herramientas para montar el motor de videojuegos,
eligiendo y agregando estas gemas y módulos a medida que los desarrolla. También utiliza las
herramientas de Lumberyard para agregar sus activos (como texturas, mallas, sonidos, música y scripts)
para crear la experiencia y el mecánica únicas del juego.
Piense en Lumberyard como una colección de elementos discretos: código, scripts, diversos editores
basados en GUI y herramientas de línea de comandos. Cuando compila un proyecto de juego, los scripts
de compilación de Lumberyard recogen todas las piezas especificadas en la configuración del proyecto
para crear el juego. Las partes del motor que entran en el juego son solo aquellas que ha configurado para
que utilice el proyecto y hay muy poca funcionalidad incluida en el código compilado final que no haya
pedido tener. Del mismo modo, las herramientas de administración y agrupación de activos se aseguran de
que solo se incluyan los activos que realmente se utilizan en el juego.
Puede crear un juego con Lumberyard usar solo el editor de Lumberyard, pero se limitará a las gemas
y a las herramientas proporcionadas (junto con los activos y scripts que cree). Si su proyecto es más
ambicioso, si desea hacer evolucionar Lumberyard para que admita características y sistemas que no
hemos proporcionado, siga leyendo.

La instalación de Lumberyard proporciona un entorno de pruebas con distintas piezas para combinar,
incluidas más de 100 gemas y módulos para que pueda usar en el juego. Como concepto de alto nivel,
piense en Lumberyard como un marco: una estructura conceptual desde la que puede agregar nuevas
Version 1.24
5
características o eliminar cualquier elemento que no tenga previsto usar en el juego. Cuando necesite
cambiar o extender el comportamiento de algún elemento, no necesita acceder a algún conjunto de
archivos de código sobrediseñado y modificar o refactorizar una característica en el código del juego.
En lugar de eso, solo tiene que trabajar en la gema o módulo que contenga la funcionalidad que desee
cambiar. Al centrarse en la modularidad, puede experimentar de forma segura con diferentes cambios de
características sin poner en riesgo el avanza del proyecto del juego con una regresión involuntaria.
Un elemento fundamental para Lumberyard es la biblioteca AzFramework, que relaciona todos los
sistemas, módulos y gemas en la infraestructura del juego. El sistema de bus de eventos (EBus)
proporciona mensajería de solicitud y notificación a través de las DLL para estos sistemas, módulos y
gemas. Como desarrollador, escribe código C++ para implementar métodos definidos en encabezados de
API de C++ que definen la funcionalidad que necesita.
La instalación de Lumberyard predeterminada es en {drive-letter}:\Amazon\Lumberyard

\{lumberyard-version-number}\ en su equipo. Hay dos carpetas debajo: \dev y \3rdParty.
Examinaremos los contenidos más importantes de \dev, donde se definen AzFramework y todas las
diversas interfaces de gemas y módulos, así como las interfaces de EBus. También contiene scripts,
muestras y activos del editor.
• \dev\Bin64vc142 (o, en versiones anteriores a 1.24, \dev\devBin64vc141) contiene las bibliotecas

del generador de activos, los módulos del editor de Lumberyard (complementos) y las bibliotecas (debajo
de \EditorPlugins), entre otras cosas. Los registros de compilación y de configuración están debajo
de \Logs.
• \dev\Code contiene los encabezados de API de C++ que incluirá en cualquier código que cree para
ampliar la funcionalidad principal de Lumberyard. Están organizados en carpetas para cada uno de
los sistemas o características que desee extender. La mayoría de ellas son interfaces virtuales que
implementará para conectar esa funcionalidad al sistema o característica de Lumberyard pertinente
a través de EBus o contienen las definiciones de tipo y plantilla que se espera utilizar. Entre ellas se
incluyen:
• \Code\CryEngine contiene encabezados de API y archivos de código C++ para sistemas y
características CryEngine. Si necesita modificar los comportamientos de CryEngine, incluido el
renderizador 3D, el motor de físicas heredado, el motor de red GridMate u otros componentes de
CryEngine, comience con los archivos de origen en este directorio.
• \Code\Framework contiene las API de AzFramework. AzFramework es el marco principal de
Lumberyard que define todos los sistemas, incluidas gemas, motores de sistemas y EBus.
• \Code\Framework\AzCore\AzCore: contiene todas las API para interactuar con los sistemas,
módulos y gemas de Lumberyard. Si Lumberyard está ampliando la funcionalidad predeterminada,
aquí es donde encontrará todas las API que necesita.
• \Code\Framework\GridMate: contiene las API de red de GridMate.
• \Editor contiene todos los activos, scripts y archivos de configuración para el editor de Lumberyard,
así como algunos de los diversos editores que administra, como el editor de materiales, el editor de
lienzo de interfaz de usuario y el editor de partículas.
• \Engine contiene todos los archivos binarios de activos predeterminados, archivos de script (.lua),
archivos de configuración de entidades (.ent), archivos de definición de materiales (.mtl), extensiones
de sombreador (.ext) y archivos de configuración del motor para Lumberyard.
• \Gems contiene todos los archivos de origen y compilación de las gemas que se envían con
Lumberyard. Cuando cree una nueva gema, agregará el código y los orígenes de compilación aquí y, a
continuación, habilitará la gema a través del configurador de proyectos.
• \ProjectTemplates contiene las plantillas de proyecto de juego que puede elegir al configurar
inicialmente Lumberyard para el desarrollo del juego.
• \SamplesProject y \StarterGame contienen muestras y un nivel de juego completo para que las
revise.
• \Tools contiene una serie de herramientas y SDK que usará durante el desarrollo de tu juego, incluido:
• \Tools\AWSNativeSDK: contiene scripts para obtener diversos SDK específicos de plataforma para
trabajar con los servicios en la nube de Amazon en sus idiomas nativos.
Version 1.24
6
Uso de Gemas
• \Tools\AWSPythonSDK: contiene SDK de Python para trabajar con los servicios en la nube de
Amazon.
• \Tools\AzCodeGenerator: contiene los archivos binarios y de configuración para AZ Code
Generator, que es una utilidad de línea de comandos que genera código fuente (o cualquier dato
o texto) a partir de código fuente etiquetado especialmente. Para obtener más detalles, consulte
Automatización de texto reutilizable con Az Code Generator.
• \Tools\build: contiene scripts y herramientas para crear el proyecto de juego con Waf, incluida la
utilidad de compilación de línea de comandos lmbr_waf.
• \Tools\CrySCompileServer: contiene el ejecutable y las bibliotecas para el servicio de compilador
de sombreadores de CryEngine.
• \Tools\LuaRemoteDebugger: contiene el ejecutable y las bibliotecas para la herramienta de
depuración remota de scripts Lua.
• \Tools\Python: contiene todas las bibliotecas básicas de Python y el intérprete. Lumberyard admite
una versión mínima de 3.7.5.
• \Tools\Redistributables: contiene paquetes y archivos comunes que se pueden enviar con el
juego, incluidos archivos DLL de DirectX y Visual Studio.
• \Tools\RemoteConsole: contiene la aplicación de consola remota de Lumberyard.
Lumberyard también proporciona dos herramientas de línea de comandos Lmbr.exe y Lmbr_waf.exe,

que se utilizan para administrar el proyecto de juego en general y configurar los detalles del proyecto de
juego durante el desarrollo.
• Lmbr.exe: proporciona un conjunto de comandos para administrar y rastrear gemas, capacidades y

herramientas y paquetes de terceros.
• Lmbe_waf.exe: proporciona un conjunto de comandos para automatizar la compilación y el
empaquetado de proyectos de juego con el marco de automatización de compilación Waf.
Todos estos elementos (y otros no incluidos aquí) definen Lumberyard,y se pueden utilizar para crear el
juego. A medida que incorpore sistemas Lumberyard y desarrolle los suyos propios, querrá comunicarse a
través de ellos. Para eso, tenemos EBus.
Uso de Gemas
Muchas de las capacidades de Lumberyard se implementan a través de Gemas. Una Gem es
una extensión empaquetada que se puede habilitar en un proyecto para agregar funcionalidad o
características. Las Gemas pueden contener código de módulo, activos, scripts, archivos auxiliares y
referencias a otras Gemas. El uso de Gemas le permite elegir aquellas características que necesite para
su proyecto y excluir las que no sean necesarias. Al mantener todo modular y solo usar aquello que
necesita, el sistema de gemas le permite iterar más rápido. Las colecciones de activos, los ejemplos de
código, los componentes, las bibliotecas, las herramientas e incluso proyectos de juego enteros se pueden
distribuir como Gemas.
Se habilita Gemas cuando se crea el proyecto en Project Configurator. Puede volver a Project Configurator
en cualquier momento para habilitar Gemas adicionales y deshabilitar Gemas no utilizadas. Cuando cree
su primer proyecto, asegúrese de hacer clic en la opción Habilitar Gemas en Project Configurator para
ver la lista de Gemas disponibles. Algunas Gemas son sistemas básicos y son necesarios para todos
los proyectos de Lumberyard. Otras Gemas son extensiones para Gemas existentes y requieren que
sus dependencias estén habilitadas para su proyecto. Las Gemas que habilite se detectan y se compilan
automáticamente al crear el proyecto.
Puede crear sus propias Gemas y reutilizar y distribuir fácilmente su propio código y activos. Para tener
una mejor idea de lo que supone crear una Gem, eche un vistazo al directorio de Gemas de su instalación
Version 1.24
7
Mensajería entre sistemas con EBus
de Lumberyard y examine las Gemas incluidas. El proceso de creación de sus propia Gem se realiza en
Project Configurator y es muy similar a la creación de un proyecto.
Mensajería entre sistemas con EBus

Todas las gemas y sistemas de Lumberyard, así como los componentes de sus proyectos, necesitan
una forma de comunicarse entre sí. Lumberyard utiliza un sistema de comunicación de propósito general
denominado bus de eventos (EBus para abreviar).
Como se indicó anteriormente, las gemas y los sistemas suelen implementarse como DLL. EBus se utiliza
para comunicarse entre ellos y, específicamente, para invocar funciones en una gema o sistema desde
otro. EBus proporciona interfaces de eventos de solicitud y publicación/suscripción (buses) que permiten
llamadas a través de esas DLL. Por ejemplo, si ha creado una gema para comportamientos de físicas
personalizados y desea proporcionar datos al renderizador CryEngine, lo haría implementando una interfaz
EBus en su gema.
Proporcionamos las interfaces para las DLL sistemas y gemas que enviamos como encabezados en la
instalación predeterminada. Para utilizar la funcionalidad de estas DLL, utilice las interfaces de estos
encabezados para registrarse para un solo evento de conversión (Evento) o difusión (Difusión), o mediante
el suministro de un funtor de solicitud de datos a un controlador de bus de solicitud.
Del mismo modo, para exponer la funcionalidad de sus propias gemas y proporcionar datos a otro sistema,
debe heredar la interfaz virtual declarada en el archivo de encabezado correspondiente e implementar los
controladores en esa interfaz en las clases de su gema y, a continuación, registrar dicho controlador en el
sistema EBus. Específicamente, registrará un controlador que cree con EBus, que pasará un puntero a su
método de clase al sistema de destino o publicará una notificación a los sistemas que están suscritos a él.
Dentro del código de su gema, también administra la conexión y desconexión del controlador
implementado para el EBus. EBus es solo una lista de controladores que llama a todos los funtores
(punteros de función) registrados con él.
Para los controladores singleton donde solo necesita una interfaz para comunicarse a través de DLL,
considere usar AZ::Interface y AZ:Event directamente, sin EBus.
Existen dos tipos de eventos de EBus:
• Bus de solicitud: este tipo de EBus registra un controlador para un método al que pueden llamar otros
sistemas.
• Bus de notificación: este tipo de EBus proporciona una interfaz de mensajería para las notificaciones en
las que los sistemas pueden publicar o a las que pueden suscribirse.
Los EBuses ofrecen muchas ventajas frente a los métodos de sondeo tradicionales:
• Abstracción: reduzca al mínimo las dependencias fuertes entre sistemas.

• Programación basada en eventos: elimine los patrones de sondeo para obtener un software más
escalable y de alto rendimiento.
• Código de aplicación más limpio: envíe mensajes con seguridad sin preocuparse de qué los controla o si
los están controlando.
• Simultaneidad: pone en cola eventos de varios subprocesos para una ejecución segura en otro
subproceso o para aplicaciones de sistema distribuidas.
• Previsibilidad: proporciona asistencia para solicitar controladores en un bus determinado.
• Depuración: intercepta mensajes para informar, crear perfiles y realizar labores de introspección.
Los EBuses se pueden configurar y admiten varios casos de uso diferentes:
Version 1.24
8
El sistema de entidades de componentes
• Como una llamada de función global directa.

• Enviar procesamiento a varios controladores.
• Para poner en cola todas las llamadas, actuando como un búfer de comandos.
• Como un buzón al que se pueden dirigir solicitudes.
• Para la entrega forzosa.
• Para la entrega con colas.
• Para la clasificación automática de una llamada de función en un mensaje de red u otro búfer de
comandos.
Para obtener más información sobre el uso de EBus, lea:
• Trabajo con el sistema de bus de eventos (EBus)

• Buses de eventos en profundidad
El sistema de entidades de componentes

Pero, ¿qué pasa con las partes del juego que están realmente en el propio juego? Lumberyard tiene un
modelo para eso también, denominado el sistema de entidades de componentes.
Comprender el sistema de entidades de componentes es fundamental para usar Lumberyard.

Conceptualmente es sencillo: cada objeto del juego que cree para su proyecto es una entidad, con un
ID y un contenedor únicos. Cada entidad contiene componentes que proporcionan funcionalidad. La
funcionalidad que proporcionan los componentes es amplia e incluye formas primitivas, mallas, audio,
comportamientos de inteligencia artificial, animación, efectos visuales, físicas, scripts y mucho más. Incluso
hay componentes que proporcionan funcionalidad de herramientas y depuración.
Por ejemplo, supongamos que desea crear una entidad de puerta que se pueda abrir y cerrar. Hizo una
malla y un par de archivos de audio. Ahora, tenga en cuenta la funcionalidad que debe tener la puerta.
• Muestre el modelo de puerta.

• Reproduzca los archivos de audio cuando la puerta se abre y se cierra.
• Evite pasar a través de la puerta cuando está cerrada.
• Anime la apertura y cierre de la puerta.
• Activa la apertura y cierre de la puerta mediante algún mecanismo.
Conociendo la funcionalidad que necesita la entidad de puerta, agregue componentes a la entidad para
cada aspecto de la puerta, incluida su presencia en el mundo del juego y las formas que tiene un jugador
de interactuar con ella. Un componente Malla representa visualmente la puerta en el mundo del juego.
Los componentes de Desencadenador de audio proporcionan el audio cuando se abre o se cierra. Un
componente Colisionador de PhysX impide que un jugador pase por la puerta cuando está cerrada. Los
componentes de Script Canvas definen los comportamientos, incluidas la animación y la reproducción de
sonido, cuando se abre o cierra la puerta. Sea cual sea el comportamiento que necesite modelar, cada
entidad va a tener una colección de componentes como soporte. El único componente común a todas
las entidades es el componente Transformar que proporciona la posición, la orientación y la escala de la
entidad en el mundo del juego.
Las entidades son fáciles de comprender y de crear, pero pueden volverse complejas. Si la entidad
requiere mucha funcionalidad, la lista de componentes crece rápidamente. ¿Qué pasa si desea agregar un
pestillo con su propia animación y audio a la puerta? ¿Qué pasa si desea agregar a la puerta un cristal que
se pueda romper? De repente, la entidad pasa de tener cinco componentes a docenas de ellos. Aquí es
donde entran los sectores.
Version 1.24
9
La canalización de activos de Lumberyard
Un sector, al igual que una entidad, es un contenedor con un comportamiento de transformación. En

lugar de contener componentes, un sector contiene una o más entidades configuradas y también puede
contener otros sectores. Para crear una puerta más compleja, puede tener la entidad de puerta inicial,
una segunda entidad para el pestillo y sus componentes y una tercera entidad para el panel de vidrio
rompible y sus componentes. Estas tres pequeñas entidades se recopilan en un sector que proporciona
un activo de puerta reutilizable y totalmente funcional. Es posible que haya escuchado conceptos similares
denominados prefabs en otro software. En Lumberyard, un sector es una colección de entidades u otros
sectores en un único activo reutilizable.
Los comportamientos aplicados a un sector pueden potencialmente aplicarse en cascada a todas las
entidades que lo contienen y, a continuación, a los componentes de esa entidad. Sin embargo, no ocurre lo
contrario, ya que no tendría sentido que una ventana rota se aplicara al cierre de una puerta.
Una vez que haya internalizado la jerarquía sector > entidad > componente, plantéese cómo debería usar
estos conceptos para desarrollar los diversos elementos que pueden rellenar los niveles de juego y el
mundo.
La canalización de activos de Lumberyard

Hemos tratado lo que hay en la instalación de Lumberyard, el marco básico de Lumberyard, cómo se
comunican entre sí sus diversas partes y cómo se representan los objetos en el juego. Pero, ¿cómo se
crean y se administran los activos en el juego? Después de todo, una puerta no existe realmente en el
juego si no tiene alguna forma de representación.
A efectos de Lumberyard, definiremos un activo como un archivo de recursos, guardado en disco,

consumido por el proyecto de alguna manera. Un activo puede ser una fuente para la interfaz de usuario,
un archivo de mapa de bits que contenga una textura de terreno cubierto de hierba, una malla de roca que
haya modelado, animaciones para un personaje, etc. Algunos activos pueden crearse en Lumberyard. Los
archivos especializados denominados enlaces de entrada que asignan botones desde un panel de juego
a eventos de entrada para su proyecto y materiales de física que describen las propiedades físicas de las
superficies, por ejemplo, se crean en el Asset Editor de Lumberyard.
Por muchas razones, la principal son las consideraciones de rendimiento, Lumberyard no puede consumir
estos activos diferentes sin convertirse en datos específicos del sistema operativo listos para el juego.
Este proceso, que va de un archivo de activos de origen en el disco a datos listos para el juego es el
Canalización de recursos. El procesamiento lo realiza automáticamente Asset Processor.
Asset Processor es un proceso en segundo plano (verá su icono en la bandeja de tareas cuando se esté
ejecutando) que analiza constantemente los directorios del proyecto en busca de cambios en los archivos.
Cuando se detectan cambios, Asset Processor utiliza reglas configurables para determinar cómo tratar los
cambios. El objetivo es disponer de versiones listas para el juego de todos los activos para cada sistema
operativo y cada directorio del juego en una ubicación denominada caché de activos. La caché de activos
se mantiene separada del directorio de activos y se puede reconstruir automáticamente en su totalidad a
partir de los activos de origen mediante el Asset Processor.
La caché de activos contiene una imagen completa de todos los archivos (excepto ejecutables y archivos
relacionados) necesarios para ejecutar el proyecto. Asset Processor mantiene la imagen actualizada,
garantizando que los nuevos archivos estén listos para usar en el tiempo de ejecución del proyecto y
Lumberyard Editor lo antes posible. El tiempo de ejecución del proyecto solo cargará activos desde la
caché de activos y nunca directamente desde los directorios de origen de activos.
Proyectos como los juegos modernos pueden tener miles de activos que necesitan monitorearse y
procesarse para múltiples sistemas operativos objetivo. Para administrar esta complejidad, el Canalización
de recursos es completamente configurable. Estas son algunas de las opciones de configuración
disponibles:
• Especifique qué directorios se deben monitorear para detectar cambios.
Version 1.24
10
Scripting para el marco de Lumberyard
• Especifique los sistemas operativos de destino y ajuste el comportamiento de Canalización de recursos

en cada sistema operativo de destino.
• Establezca el número de tareas de procesamiento simultáneo.
• Utilice la información de metadatos para asociar tipos de archivo y procesar activos en paralelo.
• Agregue sus propios tipos de activos a Canalización de recursos.
• Procese activos por lotes en un servidor de compilación.
Cuando se prepare para enviar, deberá empaquetar los activos que utiliza el proyecto. Incluso los
proyectos pequeños pueden tener cientos de activos, incluidas varias versiones de los activos, muchos de
ellos no son necesarios en su proyecto final. El seguimiento manual y la determinación de los activos que
necesita enviar puede resultar tedioso, requiere mucho tiempo y es propenso a errores. Asset Bundler se
encarga de todo automáticamente.
Asset Bundler ayuda a hacer que el envío de los activos específicos utilizados para el lanzamiento
del juego sea más repetible y de confianza. La fiabilidad se basa en un sistema de dependencia
subyacente. Si realiza cambios en el proyecto y agrega, elimina o actualiza activos, Asset Bundler utiliza
las dependencias para determinar automáticamente qué activos se van a incluir. La repetibilidad se basa
en los archivos de configuración subyacentes que proporcionan coherencia cada vez que se ejecuta Asset
Bundler.
Scripting para el marco de Lumberyard

Ahora, ha creado activos y los ha definido en el juego usando sectores, entidades y componentes. Tiene
un nivel vacío o mundo para vagar, pero ¿dónde está el juego? Ahí es donde entra el scripting.
Lumberyard incluye dos tecnologías de scripting para crear lógica y comportamientos: Script Canvas y Lua.
Script Canvas es el entorno de creación de scripts visual. En el editor de Script Canvas, se crean, conectan
y reorganizan nodos gráficos que proporcionan una representación visual del flujo lógico. Script Canvas
ofrece un entorno accesible y fácil de leer para crear comportamientos utilizando el mismo marco que Lua
y C++. Puede usar Script Canvas para crear scripts sin necesidad de saber programar.
Para habilitar Script Canvas para Lumberyard debe habilitar la Gem Script Canvas.
Lua es un lenguaje de script potente, rápido, ligero e integrable. Lua facilita la iteración rápida en el
proyecto, ya que puede ejecutar los cambios de forma inmediata sin necesidad de volver a compilar el
código fuente.
La funcionalidad de Lumberyard está expuesta a Script Canvas y Lua por el contexto de comportamiento.
El contexto de comportamiento refleja el código de tiempo de ejecución y lo hace accesible para los scripts
proporcionando enlaces a clases, métodos, propiedades, constantes y enumeraciones de C++. El contexto
de comportamiento también proporciona enlaces para EBus de Lumberyard para que pueda enviar y tratar
eventos a través de Script Canvas y Lua.
La funcionalidad para Script Canvas y Lua se agrega a las entidades a través de componentes. Puede
tener varios componentes de script y mezclar y combinar Lua y Script Canvas dentro de sus entidades.
Este enfoque le permite crear módulos de lógica y comportamiento pequeños y manejables que se pueden
reutilizar en sus proyectos.
Aprendizaje adicional
Como probablemente haya sospechado, Lumberyard es mucho más que esto, pero esperamos que esto le
dé una buena idea de dónde comenzar las búsquedas para obtener más detalles en nuestros documentos
y código. Aquí hay algunos enlaces adicionales para ayudarle a explorar más a fondo:
Version 1.24
11
Aprendizaje adicional
Para ver algunos videos geniales sobre cómo empezar a usar Lumberyard, eche un vistazo a nuestra serie
de explicaciones introductorias en vídeo.
Para consultar algunos documentos para empezar, eche un vistazo a los siguientes temas:
• Lumberyard Editor
• Conceptos de programación
• Gemas
• Sistema de entidades de componentes
• Referencia de componentes
• Guía del programador para entidades y componentes
• Emotion FX Animation Editor
• Script Canvas
• Lua Editor
Version 1.24
12
Requisitos del sistema
Configuración Amazon Lumberyard

Amazon Lumberyard tiene un proceso de instalación de dos partes:
1. La aplicación del instalador descarga, extrae e instala Lumberyard.

2. Setup Assistant configura e instala software adicional basado en en sus necesidades de
desarrollo. Entra directamente en el Lumberyard Editor con un Instalación exprés o personalizar
LumberyardCaracterísticas de para su necesidades de desarrollo con un Instalación personalizada.
Después de Lumberyard está instalado, utilice Project Configurator para seleccionar un o crear un nuevo
proyecto. En las siguientes secciones se detallan los requisitos mínimos para Lumberyard y le guiará a
través del proceso de instalación.
Temas de configuración
• Amazon Lumberyard requisitos del sistema (p. 13)
• Instalación Amazon Lumberyard (p. 15)
• Configuración de la Amazon Lumberyard con Setup Assistant (p. 17)
• Gestión Lumberyard Proyectos de con Project Configurator (p. 19)
Amazon Lumberyard requisitos del sistema

Lumberyard tiene un conjunto mínimo de requisitos del sistema para el desarrollo, como se describe en el
las siguientes secciones. Los requisitos de espacio en disco y RAM dependen de las opciones que elija
durante la instalación.
Requisitos del sistema

Si su sistema es capaz de ejecutar un juego 3D moderno en tiempo real con buen rendimiento, debe estar
configurado, sin embargo, revise estos requisitos detallados para estar seguro.
Lumberyard requiere Windows 10.
Lumberyard requisitos mínimos de hardware:
• Procesador de cuatro núcleos de 3 GHz

• 8 GB de RAM
• Tarjeta de vídeo compatible con VRAM DirectX 11 de 2 GB o posterior
• NVIDIA GeForce GTX 660 Ti con controlador versión 368.81 o posterior
• AMD Radeon HD 8730M con controlador versión 16.15.2211 o posterior
Version 1.24
13
Prerequisites
• 60 GB de espacio libre en disco
Note
Si selecciona opciones para compilar el motor, el editor o las herramientas en Asistente de

configuraciónde Se necesitan 14 GB de RAM para la compilación.
Algunas funciones gráficas avanzadas requieren un vídeo compatible con DirectX 12 o posterior
tarjeta de crédito.
El espacio libre en disco necesario depende de las opciones que seleccione cuando instalación
Lumberyard.
Prerequisites
Puedes utilizar la función Lumberyard Editor y herramientas sin instalar software adicional. [EMPTY]
crear nuevos proyectos o utilizar características de desarrollo avanzadas en Lumberyard, necesitas un
desarrollador del entorno de. Se requiere una de las siguientes versiones de Microsoft Visual Studio:
• Versión de Microsoft Visual Studio 2019 [EMPTY] o más tarde.

• Versión de Microsoft Visual Studio 2017 15,91,4 o más tarde.
Microsoft ofrece la edición de Visual Studio Community gratuita para desarrolladores individuales. Para
obtener más información y descargue e instale Visual Studio Community, visite la Comunidad de Visual
Studio del portal.
Las características necesarias de Visual Studio 2017 y 2019
La instalación predeterminada de Visual Studio podría no incluir todas las características que son
obligatorios para Lumberyard. Asegúrese de que las siguientes características de Visual Studio son
activado:
1. Lanzamiento de la Instalador de Visual Studio from your download o el directorio Menú Inicio si ya has
instalado Estudio visual.
2. Si has instalado Visual Studio, selecciona Más - Modificar en la versión de Visual Studio que usarás con
Lumberyard.
3. En la Cargas de trabajo pestaña:
• Seleccionar Desarrollo de juegos con C++.
• En la pestaña Detalles de la instalación en el panel derecha, seleccione al menos una [EMPTY] del
SDK.
4. En la Componentes individuales , en Compiladores, herramientas de compilación y tiempo de ejecución,
selecciona la opción Conjunto de herramientas VC++ que corresponde a la versión instalada de Visual
Studio:
• Estudio visual 2017: Seleccionar al menos una versión de la Conjunto de herramientas VC++ 2017.
• Estudio visual 2019: Seleccionar al menos una versión de la Versión MSVC v142 - VS 2019 C++ x64/
x86 herramienta.
• (Opcional) Para compilar con el conjunto de herramientas de Visual Studio 2017, seleccionar
Versión MSVC v141 - VS 2017 C++ x64/x86 herramientas.
Paquetes redistribuibles de C++ visual

Lumberyard Instalador intentará descargar e instalar el Paquetes redistribuibles de Visual C++ durante el
proceso de instalación. En algunas circunstancias, la instalación de estos productos redistribuibles Los
Version 1.24
14
Instalación
paquetes de pueden fallar. Si recibe un tiempo de ejecución de Visual C++ que falta .dll error durante
la ejecución Lumberyard Instalador, Lumberyard Setup Assistant, o bien Project Configurator, haga lo
siguiente:
1. Compruebe que los instaladores redistribuibles de Visual C++ para Visual Studio 2012 y Visual Studio
2019 se han instalado correctamente ha descargado. Los instaladores se encuentran en el Estudio
visual de directorios en la lumberyard_version\dev\Tools\Redistributables\ del directorio.
2. Si los instaladores redistribuibles de Visual C++ para Visual Studio 2012 y Visual Studio 2019 no se
han descargado por Lumberyard del instalador, descargue manualmente los instaladores de Microsoft.
• Redistribuible de Visual C++ para Visual Studio 2012

• C++ de Visual Redistributable para Visual Studio 2019
3. Ejecute los dos instaladores redistribuibles de Visual C++.
4. Vuelva a intentarlo Lumberyard después de que los redistribuibles de Visual Studio hayan instalado
correctamente.
Note
El Visual C++ Redistributable para Visual Studio 2019 también contiene redistribuibles para Visual
Studio 2015 y 2017.
Instalación Amazon Lumberyard

Use el enlace de descarga a continuación para obtener la última Lumberyard Instalador aplicación.
Ejecute el comando Lumberyard instalador

Ve a tu Downloads directorio y ejecutar LumberyardInstaller.exe para descargar, extraer e instalar
Lumberyard.
El valor predeterminado Lumberyard la ruta de instalación es C:\Amazon\Lumberyard\. [EMPTY]

establece una ruta de instalación diferente, elige la opción Options botón. Elija la opción Install para
comenzar la instalación. El proceso puede tómate un tiempo, dependiendo de la velocidad de tu conexión
a Internet.
Note
En algunas situaciones, la Lumberyard El instalador puede colgar y rechazar el progreso de. El

único remedio conocido en este momento es terminar de forma forzada el instalador a través del
Administrador de tareas de Windows y reiniciarlo, luego reintentar la instalación.
El instalador muestra una La instalación se completó correctamente mensaje. Haga clic en Lanzamiento
Lumberyard Setup Assistant para continuar con la configuración.
Version 1.24
15
LumberyardLos ejecutables de
LumberyardLos ejecutables de
LumberyardInstaller.exe crea accesos directos en el escritorio y en el menú Inicio para tres
aplicaciones:
Setup Assistant (p. 17)
Setup Assistant configura Lumberyarddel entorno de según su desarrollo y descarga e instala software
y SDKS adicionales. Puedes usar Setup Assistant en cualquier momento para añadir características
de desarrollo a su Lumberyard del entorno de.
SetupAssistant.exe está ubicado en lumberyard_version\dev\Tools\LmbrSetup\Win.

Project Configurator (p. 19)
Con Project Configurator, crea, configura, establece y compila proyectos de. Cuando corres Project
Configurator por primera vez, ve varios proyectos de muestra que están disponibles para ayudarle a
aprender Lumberyardde cuenta con.
ProjectConfigurator.exe está ubicado en lumberyard_version\dev\Bin64vc141_or_vc142.

Lumberyard Editor (p. 29)
Lumberyard Editor es Lumberyardde la aplicación principal de. En Lumberyard Editor, creas niveles,
recursos e interacciones para sus proyectos.
Editor.exe está ubicado en lumberyard_version\dev\Bin64vc141_or_vc142.
LumberyardEstructura de directorios de
El valor predeterminado Lumberyard la ubicación de la instalación es C:\Amazon\Lumberyard
\lumberyard_version\. El directorio raíz contiene los siguientes directorios y archivos:
• dev
• _WAF_: Archivos del sistema de compilación Waf.
• Bin64: Archivos binarios y archivos de configuración para el Resource Compiler.
• Bin64vc141: Archivos binarios y archivos de configuración para Estudio visual 2017.
• Bin64vc142: Archivos binarios y archivos de configuración para Estudio visual 2019.
• Code: Archivos de origen y archivos de solución para el Lumberyard motor y herramientas.
• Editor: Los recursos del editor.
• Engine: Recursos del motor.
• Gems: Modular components and assets.
• MultiplayerSample: Proyecto de ejemplo de multijugador que demuestra cómo crear un juego
multijugador con el sistema de entidades de componentes.
• ProjectTemplates: Archivos de configuración, bibliotecas, y scripts para la plantilla vacía.
• SamplesProject: Proyecto de ejemplo.
• StarterGame: Un juego de ejemplo completo con 3D , scripting de eventos y IA enemiga básica.
• Tools: Herramientas y complementos de terceros.
• engineroot.txt: El archivo del sistema requerido por Lumberyard Setup Assistant para verificar el
directorio.
• 3rdParty
• Software de terceros necesario para utilizar o compilar Lumberyard.
• 3rdParty.txt: Archivo del sistema utilizado por otro Herramientas de terceros para verificar el
directorio.
Version 1.24
16
Setup Assistant
Configuración de la Amazon Lumberyard con Setup

Assistant
Lumberyard Setup Assistant configura y mantiene su Lumberyard basado en su desarrollo necesita. Si
va a continuar desde Instalación Amazon Lumberyard (p. 15), Setup Assistant debe ejecutarse en su
escritorio. Setup Assistant también se puede lanzar desde el menú Inicio Accesos directos de menú o
escritorio.
Lumberyard Setup Assistant realiza varias funciones importantes:
• Garantiza que tiene el software de tiempo de ejecución necesario.

• Garantiza que tiene los SDK necesarios.
• Proporciona complementos para aplicaciones de contenido detectado como Photoshop y Maya.
• Valida la configuración del registro, las rutas y las bibliotecas.
En la primera ejecución, Lumberyard Setup Assistant presenta dos opciones, Instalación exprés y
Instalación personalizada. Si eres un contenido creador, como un diseñador o artista, y no compilarás
código, o si quieres saltar directamente y utilizar el Lumberyard Editor y herramientas, seleccionar
Instalación exprés. Siempre puede volver a visitar Setup Assistant para añadir El desarrollo de
características de. Si quieres configurar Lumberyard para el desarrollo del código, seleccione Instalación
personalizada.
Deberías correr Setup Assistant periódicamente, especialmente después de realizar cambios en su para
validar y reparar la configuración y las rutas de. También puede personalizar Setup Assistant con un para
integrar fácilmente su estructura de directorios específica.
Note
Algunas Setup Assistant requieren la instalación de software y licencias de terceros, así que
asegúrese de consultar los términos de servicio antes de instalar del software.
Version 1.24
17
Lumberyard Setup Assistant instalación personalizada
Lumberyard Setup Assistant instalación personalizada

Con Instalación personalizada, especifique cómo desea utilizar Lumberyard. Setup Assistant descarga
software de terceros y valida que el entorno es adecuado configurado en función de sus elecciones.
1. La instalación personalizada comienza especificando cómo pretende utilizar Lumberyard.
2. Verifica la Trayectoria es correcto para su Lumberyard de instalación.

3. Seleccione opciones en función de sus necesidades de desarrollo:
• Ejecute su proyecto de juego
• Ejecute el comando Lumberyard Editor y herramientas
• Compilar el código del juego* - Seleccione esta opción si desea crear nuevos proyectos con
Lumberyard.
• Compilación del motor y la canalización de activos* - Seleccione esta opción si tiene intención de
hacer Los cambios de en el motor o la canalización de activos.
• Compilación de Lumberyard Editor y herramientas* - Seleccione esta opción si tiene intención de
hacer cambios en Lumberyard Editor u otras herramientas.
• Compilación para dispositivos Android*
• Configuración del servidor dedicado Linux*
Note
* Si selecciona cualquiera de estas opciones, podría necesitar realizar tareas adicionales, como
instalar Microsoft Visual Studio y la instalación de los SDK necesarios adicionales. Estas tareas
se muestran en el Instalar software y Se requiere instalación Los SDK de las páginas.
4. Seleccionar Estudio visual 2017de Estudio visual 2019, o ambos.
Note
Las versiones de Visual Studio seleccionadas aquí se habilitarán como plataformas de

compilación y Visual Studio Solutions se generará.
Version 1.24
18
Configurador de proyectos
5. Cuando esté satisfecho con sus selecciones, elija Siguiente para instalar el software y los SDK
necesarios.
6. El Instalar software y Se requiere instalación Los SDK de muestran un icono rojo si no se puede
encontrar un requisito y una marca de verificación verde para los requisitos instalados. Falta software
y SDK opcionales mostrar un icono amarillo. Siga las instrucciones de cada página para instalar el del
software y SDKS necesarios.
Note
Asegúrese de que el Ruta de terceros en Instalar los SDK necesarios la página es correcta
para su Lumberyard de instalación.
7. Instalación deseada opcional y los SDK en la Instalar softwarede Instalación opcional Los SDK de, y
Instalar complementos páginas siguiendo las instrucciones de cada página.
8. Cuando haya terminado de instalar el software y los SDK, la [EMPTY] muestra información sobre tu
Lumberyard del entorno de. Desde la pestaña [EMPTY] página, puedes lanzar el Lumberyard Editor
eligiendo Iniciar editor. Si desea elegir un proyecto existente o crear un nuevo proyecto, elija Configurar
proyecto para lanzar Project Configurator.
Gestión Lumberyard Proyectos de con Project

Configurator
Project Configurator configura y administra su Lumberyard proyectos de. Si continúas de Configuración
de la Amazon Lumberyard con Setup Assistant (p. 17), Project Configurator debe ejecutarse en su
escritorio. Project Configurator también puede ser desde el menú Inicio o desde los accesos directos del
escritorio.
Con Project Configurator, puede:
• Establezca un proyecto predeterminado.

• Cree nuevos proyectos.
Version 1.24
19
Seleccionar un proyecto
• Añada características de código o activos a su proyecto habilitando Gemas.

• Crear nuevo Gemas que se puede añadir a los proyectos.
• Proyectos de compilación.
• Establezca la configuración avanzada del juego y del editor por proyecto.
Seleccionar un proyecto
Lumberyard tiene varios proyectos de ejemplo con los que puede trabajar para aprender LumberyardLas
características de. Para seleccionar un proyecto, elija el icono del proyecto. El proyecto seleccionado se
resalta con una marca de verificación.
Para cargar un proyecto en Lumberyard Editor, el proyecto debe establecerse en el valor predeterminado.
Mientras que el botón el proyecto seleccionado, elija el Set as default en el botón esquina superior derecha
de la Project Configurator ventana. Si el Set as default está inactivo, el proyecto seleccionado ya es el
predeterminado del proyecto.
Version 1.24
20
Crear un nuevo proyecto

Cuando crea un nuevo proyecto Project Configurator crea un nuevo directorio en
lumberyard_version\dev\ con el nombre del proyecto. Cualquier archivo específico del proyecto,
como datos de configuración, activos, Los niveles de y los scripts de residen en este directorio del
proyecto. A lo largo de este proceso, Project Configurator crea el los archivos necesarios y las soluciones
de Visual Studio, luego compila su del proyecto. Este proceso puede tardar algún tiempo.
Para crear un nuevo proyecto
1. Elija la opción Create new en la parte superior izquierda del Project Configurator para que aparezca el
Crear un nuevo proyecto ventana.
2. En Crear un nuevo proyecto asigne un nombre a su proyecto en la parte superior izquierda y

seleccione la opción Valor predeterminado o bien Vacío del proyecto de la plantilla de.
Note
Muchas características en Lumberyard se implementan en extensiones empaquetadas

llamadas Gemas. El Valor predeterminado proyecto contiene un conjunto básico de plantillas
de Gemas. El Vacío proyecto La plantilla contiene un conjunto mínimo de elementos
necesarios Gemas. Una vez que haya creado un proyecto, puede agregar o eliminar Gemas.
Version 1.24
21
3. Elegir Create project. Una nueva ventana muestra su del proyecto a medida que se crea y compila. El
proceso de compilación puede llevar según el sistema.
4. ¿Cuándo? se ha creado tu nuevo proyecto, elige Continuar para devolver al principal Project
Configurator de la interfaz de. Su nuevo proyecto debería ser seleccionado. En caso contrario, elija
el icono del proyecto para seleccionarlo. Elija la opción Set as default para que tu proyecto sea el
proyecto predeterminado.
5. El proyecto ya está listo. Puedes pasar a Lumberyard Editor o tómese el tiempo para explorar algunas
de las características avanzadas del Project Configurator antes de pasar a. Junto al icono del nuevo
proyecto hay tres enlaces:
• Activar Gemas
Elegir Activar Gemas para abrir el Gemas del editor de. Gemas son extensiones empaquetadas que
agregan nuevas características y activos a su del proyecto. Puede crear su propio Gemas aquí, de
forma similar a cómo creó un nuevo proyecto. Desplazamiento hacia abajo por la lista de disponibles
Gemas, observará que algunas gemas están habilitadas (su casilla está marcada). Para añadir o
eliminar Gemas, marque o desmarque la casilla situada junto a la gema.
Version 1.24
22
Note
Añadiendo o eliminando Gemas podría necesitar reconstruir su proyecto, que puede

tardar algún tiempo. Para volver a compilar el proyecto, elija la opción Rebuild en el botón
principal Project Configurator página.
• Configuración avanzada del juego
Elegir Configuración avanzada del juego para abrir el juego de la vista de configuración. En esta
vista, puede modificar la memoria del proyecto asignación y otros ajustes que se exponen mediante
Lumberyard, así como el Gemas que se han añadido a su proyecto.
• Configuración avanzada del editor
Elegir Configuración avanzada del editor para abrir el de la vista de configuración. En esta vista,
puede modificar Lumberyard Editor configuración para el proyecto.
Version 1.24
23
¿Cómo puedo crear un juego con Lumberyard?
Crear con Amazon Lumberyard

Anteriormente en esta guía, tratamos Funcionamiento de Amazon Lumberyard (p. 5) y Configuración
Amazon Lumberyard (p. 13).
Ahora, ¡vamos a empezar a crear el juego! En este tema, ofrecemos información general de la creación de
un juego con Lumberyard y le ayudamos a identificar dónde enfocar su aprendizaje, en función de su papel
en el desarrollo del juego. Si es experto en todos los roles, ¡léalo todo!

Mantener la modularidad
El desarrollo de juegos en Lumberyard se entiende mejor si se tiene en cuenta una filosofía de diseño
de Lumberyard clave a medida que se aprende: el concepto de modularidad. El motor de videojuegos de
Lumberyard, sus sistemas y su entorno se construyen como una colección de módulos C++. Elegir los
módulos adecuados en función de la combinación del diseño de su juego y sus flujos de trabajo mantendrá
el proceso de desarrollo del juego enfocado y, de la misma manera, facilitará la sobrecarga que supone la
administración del proyecto de juego.
Incluso Lumberyard Editor, la herramienta más común asociada con Lumberyard. utiliza estos módulos,
que denominamos –. Lumberyard se envía con más de 100 Gemas como parte de la instalación y puede
adquirir otras Gemas de terceros, o escribir otras nuevas usted mismo. Cuando construye el juego, la
funcionalidad de estas Gemas se combina para crear los sistemas del juego. Esto significa que no tiene
que codificar los sistemas y las características del juego. En su lugar, puede obtener o crear una Gem con
la funcionalidad que necesita, e incluso mantener el código para que sea independiente del juego. Este
aislamiento significa que un desarrollador de juegos puede trabajar en la funcionalidad de IA específica del
juego en una Gem. Cuando la Gem se actualiza el, los diseñadores de nivel pueden acceder a la nueva
funcionalidad después de una reconstrucción del proyecto del juego y sin afectar a ninguna otra Gem.
Las Gemas también puede agregar nuevas características al Lumberyard Editor y proporcionar nuevos
comportamientos de procesamiento de activos.
Observará esta filosofía de modularidad en las entidades individuales que cree, hasta la funcionalidad más
compleja que agregue.
Por ejemplo, piense en el concepto de una entidad en Lumberyard. Una entidad puede representar
casi cualquier cosa en su juego en el sistema de entidades de componentes de Lumberyard. Al dar los
componentes de la entidad, comienza a dar forma a la utilidad en el juego. Los componentes especifican
comportamientos y propiedades de las entidades.
Es posible que tenga una entidad con la que desee ver e interactuar en el mundo de su juego que use
todos los componentes siguientes:
• El componente de transformación predeterminado para definir su posición

• Un componente de malla para definir su geometría visual
• Componentes de NVIDIA PhysX para definir características de colisión y otros aspectos para una
simulación realista de cuerpo rígido
• Un componente de entrada para hacer referencia a una definición de enlace de eventos de entrada
• Un componente de script para automatizar algún tipo de comportamiento o procesar eventos de entrada
desde el reproductor
• Un componente de cámara para permitir que la entidad se utilice como cámara
Version 1.24
24
… y ¡mucho más!
Las demás entidades que cree serán invisibles para los jugadores. Estas entidades podrían existir para
implementar desencadenadores, generar efectos ambientales o hacer referencia a activos creados con
herramientas, como la interfaz de usuario del juego que creó en UI Editor.
Una parte importante del ensamblaje de un juego en Lumberyard gira en torno al uso del Lumberyard
Editor para hacer lo siguiente:
• Colocar y agrupar entidades

• Agregar componentes a estas entidades
• Configurar propiedades en estos componentes
• Utilizar herramientas asociadas con los componentes
Entre las herramientas que puede utilizar que están asociadas a componentes específicos se incluyen:
• Script Canvas para crear y editar scripts mediante un sistema de scripting visual y, a continuación, hacer
referencia desde el componente Script Canvas.
• Emotion FX Animation Editor para animar caracteres y, a continuación, hacer referencia desde el
componente Gráfico de animación.
• Asset Editor para crear enlaces de entrada que vinculen la entrada de reproductor sin formato, como
pulsaciones de teclas, a eventos y, a continuación, hagan referencia desde el componente Entrada.
• Audio Controls Editor para configurar efectos de sonido que se asignan a los controles Wwise y, a
continuación, hacer referencia desde los componentes Desencadenador de audio y Conmutador de
audio.
… y muchos más.
Algunas herramientas se pueden abrir directamente desde su componente asociado. Otras requieren
que las abra desde el menú Herramientas de Lumberyard Editor. Para un recorrido por Lumberyard
Editor, consulte Introducción a la Lumberyard Editor (p. 29). Para obtener información general de las
herramientas proporcionadas con Lumberyard, consulte el tema siguiente en Herramientas disponibles en
Amazon Lumberyard (p. 34).
La naturaleza modular de Lumberyard significa que hay activos, componentes y herramientas adicionales
que puede agregar habilitando Gemas en Project Configurator. Lumberyard viene con una biblioteca de
Gemas. Las Gemas pueden incluir nuevo código, nuevos activos, o ambos. Incluso puede escribir la suya
propia. De hecho, esto es lo que a lo que los programadores de C++ de un juego suelen dedicar su tiempo,
para ayudar a crear la arquitectura que haga que su juego sea único.
Comienzo del recorrido
¿Está empezando un nuevo proyecto, tal vez para iniciar un prototipo de tu juego? ¿O solo para jugar con
Lumberyard, darse una vuelta con él y aprender lo que puede hacer? Probablemente tenga que saber
cómo poner en marcha el sistema mínimo, que normalmente incluye:
• Camera
• Renderizado
• Física
• Input
Utilizará la herramienta Project Configurator para definir el proyecto en el que está trabajando. Puede
utilizar uno de los proyectos que se incluyen con Lumberyard, como el Proyecto de ejemplos, si desea
aprender o jugar con algo prefabricado. O, si quiere comenzar algo nuevo, aquí también es donde se crea
un nuevo proyecto, a partir de la plantilla que elija.
Version 1.24
25
Trabajar como artista
A continuación, lance el Lumberyard Editor, se abre uno de los niveles de ejemplo en el Proyecto de
ejemplos y empiece a explorarlo. Le recomendamos seguirlo con una de estas explicaciones escritas o en
vídeo:
• Aprenda Lumberyard en 20 minutos

• Serie Configuración de Amazon Lumberyard
• Crear una entidad controlable
• Conceptos básicos de la serie Motion
Unirse a un equipo
En función de su papel en el equipo de desarrollo de juegos y del alcance del proyecto de juego en el
que está trabajando, es posible que no encuentre todas las herramientas y tecnologías que proporciona
Lumberyard. En la siguiente sección, echaremos un vistazo a los posibles enfoques que puede dar a su
ruta de aprendizaje.
Trabajar como artista

Lumberyard proporciona todas las herramientas básicas que necesita para importar, ensamblar y combinar
animaciones en un juego AAA, creando nuevos mundos o entornos para que el jugador pueda visualizar,
interactuar y experimentar.
Aunque gran parte de su trabajo como artista puede implicar el uso de herramientas externas a
Lumberyard, utilizará las herramientas de Lumberyard cuando desee controlar las animaciones de los
personajes y manipular la apariencia de sus activos o el entorno. Es posible que esté trabajando con
diseñadores para crear el entorno del juego.
Como ejemplo, echemos un vistazo al flujo de trabajo para configurar un actor en el juego.
1. Fuera de Lumberyard, se crea un modelo de personaje, materiales, texturas y plataforma para el

personaje.
2. El Asset Processor de Lumberyard procesa automáticamente los activos de origen en activos de juego
específicos de la plataforma, lo que garantiza que los archivos nuevos o modificados estén listos para
su uso en Lumberyard lo antes posible. Utilice Configuración de FBX si desea modificar la configuración
del procesador.
3. Importe su archivo de actor en Animation Editor y cree un conjunto de movimientos para especificar los
movimientos que quiera para su personaje.
4. A continuación, cree un gráfico de animación utilizando nodos.
5. Después, se crea un árbol de combinación para combinar las animaciones.
6. Cuando haya creado y previsualizado las animaciones y esté listo para probarlas en un entorno de
juego, puede cambiar a Lumberyard Editor.
7. En el Lumberyard Editor, creará o abrirá un nivel de prueba existente.
8. Para ver su personaje animado, necesita una entidad con:
• un componente Actor para crear un personaje controlable con el archivo de actor de Animation Editor
y un material vinculado a su activo de actor.
• un componente AnimGraph para utilizar los activos de conjunto de movimientos y gráficos de
animación creados en el Animation Editor.
9. Para controlar al personaje en el nivel, es posible que desee trabajar con un diseñador de juego o
programador en este momento para agregar un componente Entrada, componentes de PhysX y
componentes de script para que pueda ejecutar y probar todas las animaciones del personaje en el
entorno específico del juego.
Version 1.24
26
Trabajar como diseñador
Le sugerimos que comience su ruta de aprendizaje explorando el siguiente conjunto de herramientas y

tecnologías de Lumberyard, y que después se centre en las que se ajusten a sus necesidades:
• Canalización de recursos
• Herramienta Configuración de FBX
• Biblioteca de Gem
• Cinematografía y el editor de Track View
• Sombreadores y materiales
• Terreno y entorno
• Editor de vegetación
Algunas explicaciones específicas que es posible que desee consultar son:
• Importar activos en Lumberyard

• Sistema de animación y Emotion FX
• Iluminación
Trabajar como diseñador

Lumberyard Editor es una herramienta importante para diseñadores de juegos y diseñadores de nivel.
Es donde se crean los niveles, se rellenan con entidades y se asignan componentes a esas entidades.
También proporciona acceso a herramientas importantes como el UI Editor para diseñadores de interfaz de
usuario, el Audio Controls Editor para diseñadores de sonido y Script Canvas para todos los diseñadores
que trabajarán con el sistema de script visual en Lumberyard.
Así es como puede empezar:
1. Al empezar Lumberyard Editor por primera vez, puede crear un nuevo nivel, o es posible que prefiera
abrir uno de los niveles existentes en el proyecto de ejemplos para jugar. Si el proyecto de ejemplos no
es el proyecto actual, utilice Project Configurator primero y establezca el proyecto como predeterminado.
2. Para empezar a rellenar el nivel en la ventanilla, cree entidades. En Lumberyard, una entidad puede ser
casi cualquier cosa, desde los objetos estáticos que ve, hasta los desencadenadores para escribir el
script, hasta los objetos de marcador de posición que hacen referencia a la interfaz de usuario del juego.
3. Puede agregar componentes a las entidades a través de la herramienta Entity Inspector.
4. Para proporcionar control de jugador a sus entidades, necesitará un enlace de entrada. Con la
herramienta Asset Editor, vincula la entrada de jugador sin procesar desde el teclado, el ratón y los
controladores de juego a los eventos que crea. A continuación, puede escuchar y responder a estos
eventos utilizando una de las herramientas de scripting.
5. Script Canvas y Lua son herramientas de scripting comunes que se utilizan en Lumberyard. Script
Canvas proporciona un sistema de scripting visual basado en nodos para script de la lógica de juego,
mientras que Lua proporciona un entorno de scripting más tradicional basado en la API de Lua. Agregue
un componente Script Canvas o un componente Lua Script a una entidad. Desarrolle un script en
uno de los editores de scripts. A continuación, puede agregar ese script al componente para controlar
esa entidad en tiempo de ejecución. Por ejemplo, mediante un script, puede controlar una entidad
respondiendo a eventos de entrada del reproductor, generando entidades dinámicas en tiempo de
ejecución, produciendo efectos visuales y mucho más.
Version 1.24
27
Trabajar como ingeniero de juegos
6. A medida que usted rellena su mundo de entidades, aprenderá que una excelente manera de ahorrar
tiempo es usar el sistema de sectores. Los sectores son un tipo de sistema prefabricado que permite
agrupar y anidar entidades de componentes, guarde el grupo como sector y, a continuación, cree varias
instancias de ese sector a lo largo de los niveles del proyecto. En cada instancia del sector, tiene la
capacidad de realizar cambios en esa instancia específica. Este cambio se denomina anulación de
sectores. También puede optar por guardar la anulación en el sector original, que luego envía ese
cambio a todas las demás instancias, también.
7. Cuando esté listo para crear la interfaz de usuario del juego, utilice el UI Editor, donde puede establecer
un lienzo de interfaz de usuario y diseñar su interfaz y crear scripts para sus flujos de trabajo.
8. Cuando esté listo para agregar sonido al juego, establezca eventos de audio y desencadenadores
en el Audio Controls Editor. A continuación, puede agregar este audio a las entidades a través de
componentes y crear scripts para su reproducción utilizando uno de los sistemas de scripting.
Para sacar el máximo partido a Lumberyard, explore la biblioteca de componentes y la biblioteca de

Gemas para ver lo que Lumberyard tiene que ofrecer. Después hable con sus programadores para ver qué
componentes adicionales hay que crear para el juego.
Le sugerimos que comience su ruta de aprendizaje explorando el siguiente conjunto de herramientas y

tecnologías de Lumberyard, y que después se centre en las que se ajusten a sus necesidades:
• Canalización de recursos
• Biblioteca de Gem
• Script Canvas
• Lua Editor
• Navegación de IA
• Audio Controls Editor
• Cloud Canvas
• UI Editor

• Serie Script Canvas
• Conceptos básicos de la serie Motion
• Trabajar con sectores
• Simular física
• Modify Terrain
Trabajar como ingeniero de juegos

Como ingeniero de juegos de Lumberyard, es probable que tenga que aprender tanto a apoyar a los
diseñadores y artistas en el diseño del juego y el entorno, como a crear componentes individuales.
Estos nuevos componentes se pueden agregar a entidades en el Lumberyard Editor para crear un juego
Version 1.24
28
Lumberyard Editor excursión
personalizado. También puede aprender a desarrollar nuevos nodos de Script Canvas. Los diseñadores
pueden utilizar estos nuevos nodos en el editor de Script Canvas para tratar los nuevos eventos que
ha creado o cambiar las propiedades de los nuevos componentes. A mayor escala, cuando tenga que
trabajar en un sistema que se pueda distribuir como un contenedor compartible de código y activos, puede
aprender a crear una Gem.
Le recomendamos que su ruta de aprendizaje tenga este aspecto:
1. Siga las explicaciones de introducción para obtener información sobre el sistema de entidades de
componentes y la biblioteca de componentes existente.
2. Examine la biblioteca de Gem para ver ejemplos de la funcionalidad más amplia que pueden agregar en
comparación con componentes individuales.
3. Aprenda acerca de la creación de sus propios componentes y Gemas, donde también aprenderá sobre
cómo trabajar con EBuses, el bus de eventos de Lumberyard y el sistema de mensajería de propósito
general; AZ Modules, una colección de código C++ creada como biblioteca estática o dinámica; y mucho
más.
Aquí hay un conjunto básico de herramientas de Lumberyard y tecnologías en las que centrarse:
• Conceptos de programación
• Gemas
• Guía del programador para entidades y componentes
• Script Canvas
• Lua Editor

• Serie Script Canvas
• Trabajar con sectores
• Uso de Gemas
• Simular física
Introducción a la Lumberyard Editor

Lumberyard Editor es su espacio de trabajo principal. Desde aquí, accede a todas las herramientas para
diseñar, cree, pruebe, reproduzca e implemente su proyecto de. Si ha utilizado otros motores profesionales
o de animación en 3D, encontrarás familiar la experiencia del usuario y te adaptarás a Lumberyard Editor
rápidamente.
Lumberyard Editor se puede iniciar desde el menú de inicio o desde el Lumberyard Editor icono del
escritorio. ¿Cuándo? Lumberyard Editor , se le da la opción de crear un nuevo nivel o cargar un nivel. Si
está utilizando uno de los ejemplos Lumberyard proyectos, encontrarás niveles de ejemplo en el Niveles
del directorio del proyecto. Si estás trabajando con un nuevo proyecto, debe crear un nuevo nivel.
Version 1.24
29
El Lumberyard Editor diseño por defecto
Para un curso intensivo de 20 minutos sobre cómo navegar por el Perspectiva visor, personalizar el
Lumberyard Editor diseño, creación de entidades y trabajo con componentes en Lumberyard Editor, vea el
siguiente vídeo del tutorial.
Lumberyard del curso intensivo de editor de 20 minutos Fundamentals

Note
Amazon Lumberyard versión 1.25 introdujo una interfaz actualizada. Notará diferencias en
la interfaz visual y experiencia de usuario ver este vídeo mientras se utiliza Lumberyard 1.25
o posterior, sin embargo, la información del tutorial en vídeo sigue siendo aplicable a los
fundamentos del uso Lumberyard Editor.
El Lumberyard Editor diseño por defecto

El diseño predeterminado de Lumberyard Editor contiene las herramientas más utilizadas en un , similar a
otras aplicaciones de creación de contenido. El flujo de trabajo principal de Lumberyard es crear y colocar
entidades en un nivel, de modo que el valor predeterminado contiene una barra de menús, dos barras de
herramientas y cinco paneles de herramientas centrados en la creación de entidades y colocación.
Puede personalizar el diseño arrastrando y soltando, y guardarlo en un diseño personalizado de

la mano de Diseños en la opción [EMPTY] menú de la barra de menú principal. Arrastre las barras
separadoras entre los paneles para cambiar el tamaño de los paneles. Arrastrar barra de título de un
panel para arrancar el panel. El panel se puede soltar en cualquier parte del diseño o se ha caído fuera
de Lumberyard Editor como su propia ventana. Para restaurar el diseño predeterminado, select Diseño
predeterminado desde el paso Diseños opción en el [EMPTY] de la barra de menús principal.
Herramientas disponibles en el valor predeterminado Lumberyard Editor diseño
A. Perspectiva – Este encuadre 3D es un vista en tiempo real de su nivel. En Perspectiva, debe crear y
colocar entidades y ver y reproducir el proyecto.
Version 1.24
30
Cómo navegar por Lumberyard Perspectiva ventanilla
Haga clic con el botón derecho del ratón Perspectiva en la barra de título del panel para abrir el menú de
perspectiva. Desde el menú de perspectiva, puedes cambiar la visibilidad para varios ayudantes, como
el plano de construcción, los iconos y las guías. También puede seleccionar una relación de aspecto,
ver a través de varias cámaras colocadas en el nivel, crear cámaras nuevas desde la vista actual y
divide el Perspectiva en varias vistas.
Haga clic con el botón derecho en Perspectiva para abrir el menú contextual para crear entidades
y rodajas, que son activos reutilizables que contienen varias entidades. Desde el menú contextual,
también puede crear capas que puede utilizar para organizar entidades y sectores en tu nivel.
B. Entity Outliner – El Entity Outliner muestra una lista de entidades, sectores y capas en el nivel actual.
Haz clic con el botón derecho en el menú desplegable Entity Outliner para abrir el contexto para crear
entidades, sectores y capas. Gran parte de la funcionalidad del Entity Outliner el menú contextual
se comparte con el Perspectiva menú contextual. El Entity Outliner el menú contextual también tiene
opciones para encontrar entidades y sectores seleccionados en Perspectiva, organiza el en la lista
Entity Outliner y buscar sectores en el campo Asset Browser.
C. Entity Inspector – El Entity Inspector muestra los componentes del entidad seleccionada actualmente.
En la parte superior del Entity Inspector es un campo para la entidad Nombre y un Add Component
botón. El Add Component abre una lista de Los componentes de , ordenados por tipo, que se pueden
añadir a la entidad. Cada componente tiene su propio conjunto de propiedades que se muestran en
el Entity Inspector. Todas las entidades contienen una transformación que establece la posición, la
rotación y la escala de la entidad en el componente nivel.
D. Asset Browser – El Asset Browser examina los activos en disco del proyecto. Los activos como mallas,
animaciones y texturas se crean en de las aplicaciones. Los activos como materiales, scripts y sectores
se crean en Lumberyard Editor. Los recursos que cree se almacenan en el directorio del proyecto.
También puede examinar los activos predeterminados que se incluyen con Lumberyard, así como de
activos que se incluyen con Gemas que se han añadido a su proyecto.
La izquierda del panel de la pestaña Asset Browser muestra una , que puede buscar en los recursos
disponibles. Cuando un activo es seleccionado, el panel de vista previa de la derecha muestra una vista
previa en miniatura y información sobre el activo, si está disponible.
E. Consola del editor – El Consola del editor muestra el comando y el resultado del proceso de Lumberyard
Editor y su proyecto. Cuando carga un nivel, por ejemplo, la consola de muestra mensajes sobre
recursos y archivos de configuración a medida que se cargan y podría muestran advertencias y errores
si se encuentran problemas. Puede acceder a la consola como la configuración de variables de consola
en el campo de entrada en la parte inferior de la consola de. Haz clic en el botón {x} en la parte inferior
izquierda de el Consola del editor para abrir el Editor de variables de la consola, que proporciona una
interfaz sencilla para establecer variables de consola.
F. Barra de herramientas – El Barra de herramientas permite acceder fácilmente a varias herramientas
de editor y características. La barra de herramientas está acoplada en la parte superior del editor de
forma predeterminada, pero también puede acoplarlo verticalmente en los bordes del editor. Para
personalizar el barra de herramientas, haga clic con el botón derecho en cualquier lugar de la barra de
herramientas y seleccione Personalizar en el menú contextual. Puedes elegir qué , vistas o modos para
incluir. También puede añadir comandos a una barra de herramientas.
G. Perspectiva Barra de herramientas – El Perspectiva Barra de herramientas en la parte inferior del
Perspectiva muestra información de posición para objetos seleccionados. Usted también puede ajustar
la velocidad de navegación; silenciar audio; ir a una posición específica; alternar la colisión de la
cámara; ejecutar simulaciones y habilitar Modo de vista previa de RV.
Cómo navegar por Lumberyard Perspectiva ventanilla

Lumberyardel modelo de interacción de será familiar para cualquier persona que haya jugado a un PC en
primera persona del juego, con algunos pequeños ajustes y adiciones. El movimiento se maneja mediante
la introducción del teclado, y La vista de se gestiona mediante la entrada del dispositivo del puntero.
Version 1.24
31
Preferencias de movimiento
Navegación por el teclado
• W – Avance.
• S – Muévase hacia atrás.
• A – Mover a la izquierda.
• D – Mover a la derecha.
• Q – Baje.
• E – Suba.
• Z – Céntrese en los seleccionados.
Navegación del ratón
• Ratón derecho + arrastrar – Girar vista, conocida como ratónaspecto en la mayoría de los juegos.
• Rueda de desplazamiento del ratón – Ampliar vista.
• Ratón central + arrastrar – Vista panorámica.
• Ratón izquierdo – Seleccione la entidad.
• Ratón izquierdo + arrastrar – Entidades de selección de área.
Es posible que prefiera que los controles de la cámara del editor se comporten como un simulador de
vuelo. ¿O bien es posible que desee acelerar o ralentizar el movimiento o la rotación predeterminados
del editor cámara. Puede ajustar el comportamiento de control de cámara del editor predeterminado
configurando la opción Movimiento en el campo Internacional Preferencias del editor de.
Version 1.24
32
Elegir Preferencias globales desde el paso del Editor Configuración en el grupo [EMPTY] del menú.
Seleccionar Movimiento en la sección Ventanillas en la lista izquierda. Aquí puede invertir cualquiera de los
ejes del ratón y ajustar la velocidad de movimiento del editor cámara.
Cuando tiene sus preferencias de movimiento ajustadas a su gusto, puede encontrar a veces que el
movimiento de la cámara del editor es demasiado rápido o demasiado lento en ciertas situaciones. Puedes
ajusta la velocidad de movimiento en la Perspectiva Barra de herramientas en la inferior de la Perspectiva.
Version 1.24
33
[EMPTY] Perspectiva ubicaciones
Introduzca un valor de punto flotante en el campo Velocidad para establecer la velocidad de movimiento.
También puedes hacer clic en el botón a la derecha de la flecha de Velocidad para establecer la velocidad
de movimiento en .1de el valor predeterminado 1, o bien 10. Los valores son mayores que 1.0 aumenta la
velocidad de movimiento. Los valores son inferiores a 1.0 reduzca la velocidad de movimiento.
[EMPTY] Perspectiva ubicaciones

Al crear un nivel, es posible que encuentres útil tener un valor preestablecido Perspectiva vistas guardadas
para su uso posterior. Puedes guardar la vista actual de la cámara del editor, asignándola a un Function
clave. Para guardar un Perspectiva ubicación, pulse Control + Function(1-12). Para establecer la
Perspectiva vista a un ubicación guardada, pulse Shift + Function(1-12).
Herramientas disponibles en Amazon Lumberyard

El valor predeterminado Lumberyard Editor el diseño contiene herramientas comunes a la mayoría de
desarrollo de trabajo, pero hay muchas herramientas adicionales disponibles. Según su de desarrollo,
puede que estas no sean siempre las herramientas que necesita, o incluso las herramientas adecuadas
para su trabajo. El Lumberyard Editor admite opciones de diseño personalizadas para que puede añadir
todas las herramientas que necesite para utilizarlas con mayor frecuencia justo donde las necesite.
Algunas herramientas que tienen varios paneles, como el Animation Editor, puede tienen sus propios
diseños personalizados y preestablecidos.
Estas herramientas están disponibles en el Herramientas del menú de la Lumberyard Editor.
Animation Editor
Version 1.24
34
Configuración de FBX
Con Animation Editor, compilación animada los comportamientos para su actores.
Utiliza el botón Animation Editor para crear bucles de animación y configurar transiciones fluidas entre
ellos. Para crear comportamientos, comience cargando un actor, que es una malla con piel, y sus
animaciones correspondientes. Las animaciones se añaden a movimiento conjuntos. Usted crea gráficos
de movimiento usar conjuntos de movimiento que puede combinar la animación en función de los estados
y los eventos. Los gráficos de movimiento que cree defina el de su actor de los comportamientos de.
El Configuración de FBX herramienta convertirs estático .fbx mallas, actores, mallas PhysX y
movimientos en Lumberyard de activos de.
Version 1.24
35
Cuando exporta o copia .fbx archivos a un directorio de su actual proyecto de juego, Asset Processor
detecta el de los archivos. Al usar estos archivos como entrada, Lumberyard calcula la configuración
predeterminada. Estos de configuración especifique cómo Asset Processor convierte los archivos en la
malla adecuada, o activos de animación.
Para personalizar .fbx configuración, buscar el activo en Asset Browser. Haga clic con el botón derecho
en el activo y seleccione [EMPTY] Configuración para abrir Configuración de FBX. El opciones en
Configuración de FBX varían en función del contenido del .fbx del archivo.
Version 1.24
36
Editor de configuración de texturas
Version 1.24
37
Editor de configuración de texturas convierte archivos de imagen en Lumberyard de activos de.
Al exportar o copiar archivos de imagen en un directorio del proyecto de juego actual, Asset Processor
detecta los archivos. Al usar estos archivos como entrada, Lumberyard calcula el valor predeterminado
la configuración. Estos ajustes especifican cómo Asset Processor convierte los archivos en las texturas
adecuadas.
Para personalizar la configuración de la textura, busque el activo de imagen en Asset Browser. Haga
clic con el botón derecho en el activo y seleccione [EMPTY] Configuración de imagen para abrir Editor
de configuración de texturas. En Editor de configuración de texturas, puedes elegir entre los elementos
preestablecidos en función del tipo de textura y especifique la configuración para varias plataformas. Editor
de configuración de texturas muestra una imagen de vista previa de la textura, por lo que puede ver los
resultados de la configuración.
Tipos de imagen admitidos por Lumberyard
• .bmp
• .gif
• .jpg
• .jpeg
• .png
• .tga
• .tif
• .tiff
Version 1.24
38
Asset Editor
Asset Editor
Crear y editar Lumberyardde activos específicos de Asset Editor.
Lumberyard tiene un pequeño número de activos especializados como secuencia de comandos eventos
que permiten que los scripts se comuniquen entre sí, materiales de física que dan a las superficies
propiedades físicas como la fricción, y enlaces de entrada que vinculan la entrada a los eventos. Crear y
edite estos tipos de contenido especializados con el Asset Editor.
Version 1.24
39
Inspector de niveles
Inspector de niveles
Añadir y modificar componentes de nivel en Inspector de niveles.
Inspector de niveles permite añadir y modificar niveles componentes, similar a Entity Inspector. En
Inspector de niveles, puede añadir componentes de terreno y NVIDIA PhysX Componentes de terreno para
colisiones de terreno.
Version 1.24
40
Material Editor
Material Editor
Cree y edite el aspecto de las entidades en su proyecto con Material Editor.
Un material tiene un conjunto de propiedades que determina cómo reacciona su superficie a la , otros
materiales y su entorno. Material Editor es la herramienta principal utilizada para crear materiales y mapear
texturas, y le permite configurar como opacidad, efectos de lighitng, parámetros de sombreador y mucho
más.
Version 1.24
41
Particle Editor
Particle Editor
Creación de efectos visuales dinámicos en capas con Particle Editor.
Lumberyard incluye un sistema avanzado de efectos de partículas que puede utilizar para simular efectos
ambientales como fuego y chispas, o efectos meteorológicos como niebla, nieve o lluvia. Uso Particle
Editor para crear y administrar bibliotecas de partículas en su proyecto.
Version 1.24
42
Configuración de PhysX
Configuración de PhysX
Establezca las propiedades globales de PhysX para su proyecto con Configuración de PhysX.
Lumberyard integra NVIDIA PhysX para la simulación de física en tiempo real. Con Configuración
de PhysX, puede establecer propiedades globales para NVIDIA PhysX como como la gravedad, el
rendimiento y la precisión de la simulación de equilibrio, crear filtros con colisión Las capas y grupos de y
configure un depurador visual de PhysX.
Version 1.24
43
Script Canvas
Script Canvas
Programe lógica y comportamientos visualmente con Script Canvas.
Script Canvas es uno de Lumberyardlas herramientas más potentes de. Con Script Canvas, puede
crear comportamientos, funciones y lógica en un entorno de programación visual. Script Canvas está
diseñado para usar Lumberyardde sistemas de serialización, reflexión, modularización y mensajería EBus
de. Es fuertemente integrado con Lumberyarddel sistema de entidades de componentes de y basado
en el AzCore biblioteca. Esto significa que puede crear lógica basada en eventos y sin experiencia de
programación.
Version 1.24
44
Terrain Editor
Terrain Editor
Creación de terreno con Terrain Editor.
Con Terrain Editor, puede pintar mapas de alturas para crear picos y valles en el terreno y añada texturas
de megaterreno para vistas de barrido.
Version 1.24
45
Terrain Tool
Terrain Tool
Añada detalles precisos al terreno con Terrain Tool.
Con Terrain Tool, puedes esculpir detalles precisos en tu terreno y pintar capas de textura vivas en la
Perspectiva en la ventanilla.
Track View
Creación de secuencias cinemáticas con Track View.
Track View es la herramienta principal para crear y gestionar secuencias cinemáticas como cuscenes o
eventos de animación con scripts.
Version 1.24
46
UI Editor
UI Editor
Diseñe interfaces de usuario dinámicas con UI Editor.
Puedes usar UI Editor para crear, personalizar y animar varios elementos de la interfaz de usuario del
juego y componentes como menús, botones y pantallas de visualización frontal.
Audio Controls Editor
Mapear controles de audio en Audio Controls Editor.
El proyecto comunica todas las acciones, eventos y parámetros al sistema de audio con controles de
capa de traducción de audio (ATL). Estos ATL Los controles de se asignan a uno o más controles dentro
del middleware seleccionado (Wwise o Wwise LTX). Con Audio Controls Editor, puede crear controles y
realizar conexiones entre los controles ATL y el middleware de control.
Version 1.24
47
Editor de variables de la consola
Editor de variables de la consola
Buscar y establecer variables de consola en Editor de variables de la consola.
Lumberyard tiene muchas consolas variables, o bien CVAR, que controlan todos los aspectos del editor y
del proyecto. Las CVAR pueden habilitar y deshabilitar características de depuración, establecer detalle de
salida, modificar sistema rendimiento, y mucho más. Editor de variables de la consola presenta una lista de
búsqueda de de CVAR disponibles para que pueda modificar sus valores.
Version 1.24
48
Lens Flare Editor
Lens Flare Editor
Diseñar efectos de destello de lente únicos para luces específicas en Lens Flare Editor.
Version 1.24
49
Sun Trajectory Tool
Sun Trajectory Tool
Crear dinámica tiempo-de-día con la Sun Trajectory Tool.
Con Sun Trajectory Tool, usted define la hora actual, el amanecer y el atardecer, y la dirección del sol para
crear una dinámica amanecer, luz del día, anochecer y cielos nocturnos.
Terrain Texture Layers
Cree terrenos naturales realistas con Terrain Texture Layers.
Las capas de textura se utilizan para crear un terreno de aspecto natural que cambia entre tipos de
superficies como arena, suciedad, barro, hierba y piedra. Con Terrain Texture Layers you crear y orden las
capas del terreno y aplicar materiales y texturas que cree transiciones entre tipos de superficie del terreno.
Version 1.24
50
Time of Day Editor
Time of Day Editor
Cree luz natural y transiciones atmosféricas a lo largo del tiempo con Time of Day Editor.
Time of Day Editor configura los cambios en los parámetros del entorno a lo largo del tiempo para imitar un
ciclo de iluminación día-noche. El Time of Day Editor utiliza un gráfico de líneas de tiempo de 24 horas y
una función de grabación para almacenar los valores de los parámetros de entorno cambiantes.
Version 1.24
51
Recursos de Lumberyard adicionales

• Después de configurar Amazon Lumberyard, aprenda a usar la plataforma con nuestra serie de vídeos
de introducción. Esta serie cubre todos los conceptos básicos del trabajo con Lumberyard y supone una
excelente base para pasar a temas intermedios y avanzados.
Introducción a Amazon Lumberyard

• Lumberyard también tiene un canal de YouTube en constante crecimiento que está repleto de vídeos
con explicaciones y presentaciones adicionales. Suscríbase y active las notificaciones para enterarse
siempre que se publiquen nuevos vídeos.
Amazon Lumberyard en YouTube

• Sumérjase más en las características y el uso de Lumberyard con la documentación de Amazon
Lumberyard.
Página de inicio de documentación de Amazon Lumberyard

• Únase a la comunidad en línea en los foros de Lumberyard para aprender del personal y los usuarios de
Lumberyard, así como para compartir sus proyectos.
Foros de Amazon Lumberyard

• Los usuarios de Lumberyard han creado un Discord no oficial. Únase a la conversación para compartir
consejos y obtener ayuda de los usuarios de Lumberyard.
Amazon Lumberyard en Discord
Version 1.24
52
Redistribuibles de Lumberyard
Cuestiones legales
El motor de Amazon Lumberyard, el entorno de desarrollo integrado y las herramientas y los recursos
relacionados cuentan con licencia "Lumberyard Materials" de acuerdo con los términos y condiciones
del acuerdo del cliente de AWS y los términos de servicio de Lumberyard. Consulte estos términos y
condiciones para obtener más detalles.
Temas
• Redistribuibles de Lumberyard (p. 53)
• Servicios web alternativos (p. 55)
A efectos de las condiciones de servicio de Lumberyard, los materiales de Lumberyard en los directorios
que indicamos a continuación se marcan como ""redistribuibles de Lumberyard". A menos que se
especifiquen subdirectorios de un directorio, todos los archivos en el directorio indicado se considerarán
redistribuibles de Lumberyard.
Note
Las restricciones de uso y distribución de los materiales de Lumberyard, incluidos aquellos que
tienen formato de código fuente, se especifican en las condiciones de servicio.
Lumberyard
• \3rdParty\GameLift
• \dev\_WAF_
• \dev\Bin64
• \dev\CloudGemSamples
• \dev\Code\CloudGemSamples
• \dev\Code\CryEngine
• \dev\Code\Framework
• \dev\Code\Launcher
• \dev\Code\MultiplayerProject
• \dev\Code\SamplesProject
• \dev\Code\Sandbox
• \dev\Code\Tools
• \dev\Code\Tools\AssetTagging
• \dev\Code\Tools\ClangReflect
• \dev\Code\Tools\CryCommonTools
• \dev\Code\Tools\CryD3DCompilerStub
• \dev\Code\Tools\CrySCompilerServer
• \dev\Code\Tools\CryXML
• \dev\Code\Tools\DBAPI
Version 1.24
53
• \dev\Code\Tools\GemRegistry
• \dev\Code\Tools\HLSLCrossCompiler
• \dev\Code\Tools\LUARemoteDebugger
• \dev\Code\Tools\PRT
• \dev\Code\Tools\RC
• \dev\Code\Tools\ShaderCacheGen
• \dev\Code\Tools\SphericalHarmonics
• \dev\Code\Tools\AssetProcessor
• \dev\Editor
• \dev\Engine
• \dev\FeatureTests
• \dev\Gems
• \dev\MultiplayerProject
• \dev\ProjectTemplates
• \dev\SamplesProject
• \dev\Tools\Build\waf-1.7.13
• \dev\Tools\lmbr_aws\AWSResourceManager\default-project-content
• \dev\AssetProcessorPlatformConfig.ini
• \dev\bootstrap.cfg
• \dev\editor.cfg
• \dev\engineroot.txt
• \dev\lmbr_aws.cmd
• \dev\lmbr_waf.bat
• \dev\lmbr_waf.exe
• \dev\SetupAssistantConfig.json
• \dev\system_BuildShaderPak_DX11.cfg
• \dev\system_BuildShaderPak_GL4.cfg
• \dev\system_windows_pc.cfg
• \dev\waf_branch_spec.py
• \dev\wscript
Recopilación de activos: Woodland
• Todos los directorios
Recopilación de activos: Beach City
Muestra heredada (GameSDK)
Starter Game
Version 1.24
54
Servicios web alternativos
Servicios web alternativos

En el ámbito de las Condiciones de servicio de Lumberyard, un "servicio web alternativo" es cualquier
servicio de computación, base de datos, almacenamiento o contención no perteneciente a AWS similar a o
sustitutivo de los siguientes servicios: Amazon EC2, Amazon Lambda, Amazon DynamoDB, Amazon RDS,
Amazon S3, Amazon EBS, Amazon EC2, Container Service o Amazon GameLift.
Version 1.24
55
Si proporcionásemos una traducción de la versión en inglés de la guía, prevalecerá la versión en inglés de

la guía si hubiese algún conflicto. La traducción se proporciona mediante traducción automática.
Version 1.24
lvi

Lumberyard WG

Cargado por

Copyright:

Formatos disponibles

Lumberyard WG

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Lumberyard WG

Cargado por

Copyright:

Formatos disponibles

Amazon Lumberyard

Amazon Lumberyard: Guía de bienvenida

Lens Flare Editor .............................................................................................................. 49

Le damos la bienvenida a Amazon

¿Qué significa «gratuito»?

Las capacidades creativas deAmazon Lumberyard

Excelente integración con Amazon Web Services

Tanto si es estudiante, aficionado, desarrollador independiente o un estudio importante, Lumberyard

¿Le interesa? Siga leyendo para saber lo que hay en la caja.

Contenido de la guía de bienvenida

Funcionamiento de Amazon Lumberyard (p. 5) - Información general de alto nivel de la tecnología

Recursos de Lumberyard adicionales (p. 52) - Enlaces a explicaciones en vídeo, documentación y

Estas son solo algunas de las características de

Crear características multijugador robustas con rapidez

Crear mundos increíbles

Contar historias con personajes emotivos

Efectos visuales espectaculares con NVIDIA PhysX y partículas

Desarrollar experiencias atractivas con facilidad

Aproveche la potencia de Amazon Web Services

• Equipo con Microsoft Windows

Algunas plataformas tienen requisitos adicionales.

• Renderizado y salida de gráficos

El motor en sí es realmente solo una colección de componentes y módulos, denominados Gemas. Al

Información general del marco de Lumberyard

La instalación de Lumberyard predeterminada es en {drive-letter}:\Amazon\Lumberyard

• \dev\Bin64vc142 (o, en versiones anteriores a 1.24, \dev\devBin64vc141) contiene las bibliotecas

Lumberyard también proporciona dos herramientas de línea de comandos Lmbr.exe y Lmbr_waf.exe,

• Lmbr.exe: proporciona un conjunto de comandos para administrar y rastrear gemas, capacidades y

Mensajería entre sistemas con EBus

Existen dos tipos de eventos de EBus:

• Abstracción: reduzca al mínimo las dependencias fuertes entre sistemas.

Los EBuses se pueden configurar y admiten varios casos de uso diferentes:

• Como una llamada de función global directa.

Para obtener más información sobre el uso de EBus, lea:

• Trabajo con el sistema de bus de eventos (EBus)

El sistema de entidades de componentes

Comprender el sistema de entidades de componentes es fundamental para usar Lumberyard.

• Muestre el modelo de puerta.

Un sector, al igual que una entidad, es un contenedor con un comportamiento de transformación. En

La canalización de activos de Lumberyard

A efectos de Lumberyard, definiremos un activo como un archivo de recursos, guardado en disco,

• Especifique qué directorios se deben monitorear para detectar cambios.

• Especifique los sistemas operativos de destino y ajuste el comportamiento de Canalización de recursos

Scripting para el marco de Lumberyard

Configuración Amazon Lumberyard

1. La aplicación del instalador descarga, extrae e instala Lumberyard.

Amazon Lumberyard requisitos del sistema

Requisitos del sistema

Lumberyard requiere Windows 10.

Lumberyard requisitos mínimos de hardware:

• Procesador de cuatro núcleos de 3 GHz

• 60 GB de espacio libre en disco

Si selecciona opciones para compilar el motor, el editor o las herramientas en Asistente de

• Versión de Microsoft Visual Studio 2019 [EMPTY] o más tarde.

Las características necesarias de Visual Studio 2017 y 2019

Paquetes redistribuibles de C++ visual

• Redistribuible de Visual C++ para Visual Studio 2012

Instalación Amazon Lumberyard

Ejecute el comando Lumberyard instalador