Amazon Lumberyard Guida di benvenuto Version 1.24
←
→
Trascrizione del contenuto della pagina
Se il tuo browser non visualizza correttamente la pagina, ti preghiamo di leggere il contenuto della pagina quaggiù
Amazon Lumberyard
Guida di benvenuto
Version 1.24
Amazon Lumberyard Guida di benvenuto Amazon Lumberyard: Guida di benvenuto 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.
Amazon Lumberyard Guida di benvenuto
Table of Contents
Benvenuto in Amazon Lumberyard ........................................................................................................ 1
Funzionalità creative di Amazon Lumberyard, senza compromessi ..................................................... 1
Contenuti della Guida di benvenuto ............................................................................................... 2
Caratteristiche di Lumberyard ............................................................................................................... 3
Qui ci sono solo alcune delle caratteristiche di Lumberyard: .............................................................. 3
Piattaforme supportate ................................................................................................................ 4
Funzionamento di Amazon Lumberyard ................................................................................................. 5
Panoramica del framework Lumberyard ......................................................................................... 5
Utilizzo dei Pacchetti gem ............................................................................................................ 7
Messaggistica tra sistemi con EBus .............................................................................................. 8
Component Entity System ............................................................................................................ 9
L'Asset Pipeline di Lumberyard ................................................................................................... 10
Scripting per il framework Lumberyard ......................................................................................... 11
Ulteriori apprendimenti ............................................................................................................... 11
Amazon Lumberyard configurazione .................................................................................................... 13
Requisiti di sistema ................................................................................................................... 13
Requisiti di sistema ........................................................................................................... 13
Prerequisites .................................................................................................................... 14
Pacchetti ridistribuibili Visual C++ ....................................................................................... 14
Installazione ............................................................................................................................. 15
Esegui il Lumberyard installatore ......................................................................................... 15
Lumberyardeseguibili di ..................................................................................................... 16
LumberyardStruttura della directory di .................................................................................. 16
Assistente configurazione ........................................................................................................... 17
Lumberyard Setup Assistant (Assistente configurazione Lumberyard) installazione personalizzata .. 18
Configuratore progetto ............................................................................................................... 19
Seleziona un progetto ........................................................................................................ 20
Crea un nuovo progetto ..................................................................................................... 21
Crea con Amazon Lumberyard ........................................................................................................... 24
Come faccio a creare un gioco con Lumberyard? .......................................................................... 24
Partecipi ai lavori come artista .................................................................................................... 26
Partecipi ai lavori come progettista .............................................................................................. 27
Partecipi ai lavori come ingegnere di gioco ................................................................................... 28
Lumberyard Editor (Editor Lumberyard) tour .................................................................................. 29
Il Lumberyard Editor (Editor Lumberyard) layout predefinito ..................................................... 30
Navigazione nel Lumberyard Perspective riquadro di visualizzazione ......................................... 32
Preferenze di movimento ................................................................................................... 32
Salva Perspective località ................................................................................................... 34
Strumenti aggiuntivi ................................................................................................................... 34
Animation Editor (Editor animazione) ................................................................................... 35
FBX Settings (Impostazioni FBX) ........................................................................................ 36
Editor delle impostazioni delle texture .................................................................................. 38
Asset Editor ..................................................................................................................... 40
Ispettore livello ................................................................................................................. 41
Material Editor .................................................................................................................. 42
Particle Editor (Editor di particelle) ....................................................................................... 43
Configurazione PhysX ....................................................................................................... 44
Script Canvas ................................................................................................................... 45
Terrain Editor (Editor terreno) ............................................................................................. 46
Terrain Tool ..................................................................................................................... 47
Track View ....................................................................................................................... 47
UI Editor (Editor IU) .......................................................................................................... 48
Audio Controls Editor (Editor controlli audio) ......................................................................... 48
Editor variabili di console ................................................................................................... 49
Version 1.24
iii
Amazon Lumberyard Guida di benvenuto
Lens Flare Editor (Editor aberrazione lente) .......................................................................... 50
Sun Trajectory Tool (Strumento traiettoria sole) ..................................................................... 51
Terrain Texture Layers (Livelli texture terreno) ....................................................................... 51
Time of Day Editor (Editor momento del giorno) .................................................................... 52
Altre risorse Lumberyard .................................................................................................................... 53
Note legali ....................................................................................................................................... 54
Ridistribuibili di Lumberyard ........................................................................................................ 54
Servizi Web alternativi ............................................................................................................... 55
...................................................................................................................................................... lvii
Version 1.24
iv
Amazon Lumberyard Guida di benvenuto
Funzionalità creative di Amazon
Lumberyard, senza compromessi
Benvenuto in Amazon Lumberyard
Amazon Lumberyard è un motore 3D gratuito ad alte prestazioni con una suite professionale di strumenti,
editor e librerie che ti consentono di creare grafica accattivante in tempo reale, esperienze coinvolgenti,
mondi virtuali straordinari e visualizzazioni dinamiche. Lumberyard offre le funzionalità di Amazon Web
Services e la community di Twitch per condividere le tue idee con giocatori, clienti e spettatori di tutto il
mondo.
Che cosa significa "gratuito"?
Lumberyard non è a pagamento. Non prevede licenze per la postazione, licenze per il sito, sottoscrizioni,
contratti di supporto, quote sui ricavi. È semplicemente gratuito. Se scegli di utilizzare i servizi AWS nel
tuo progetto, sarai responsabile delle commissioni associate a tali servizi. Amazon Lumberyard è sempre
gratuito e tu puoi personalizzare gli strumenti e il codice di origine in base alle esigenze specifiche.
Funzionalità creative di Amazon Lumberyard, senza
compromessi
Un motore di altissimo livello
Lumberyard è un motore 3D in tempo reale ad alte prestazioni che produce un'incredibile fedeltà visiva.
Lumberyard include tutte le funzionalità che i designer professionisti, gli artisti e gli sviluppatori si aspettano,
con modelli di esperienza utente familiari che consentono l'adozione e lo sviluppo rapidi. Il suo robusto
set di strumenti consente un'iterazione rapida dalla qualità senza precedenti. Basato su un'architettura
modulare ed estensibile attraverso il framework Pacchetti gem, Lumberyard semplifica l'aggiunta di nuove
caratteristiche, API e asset.
Profondamente integrato con Amazon Web Services
Version 1.24
1
Amazon Lumberyard Guida di benvenuto
Contenuti della Guida di benvenuto
Le funzionalità online di Lumberyard, supportate da Amazon Web Services, offrono possibilità straordinarie
agli sviluppatori. Elementi connessi comuni come server dedicati, contenuti dinamici, economie online e
statistiche in tempo reale sono facilmente implementabili e scalabili; in questo modo potrai concentrarti
sugli aspetti creativi del tuo progetto. Grazie alle funzionalità crossplay di Lumberyard e all'integrazione
con Twitch, puoi sperimentare opportunità innovative di coinvolgimento sociale tra le persone. Il potenziale
illimitato di AWS può offrire esperienze che vanno ben oltre le funzionalità di qualsiasi dispositivo singolo.
Che tu sia uno studente, un hobbista, uno sviluppatore indipendente o uno studio importante, Lumberyard
la stessa gamma di strumenti in costante espansione per realizzare la tua visione creativa.
Sei interessato? Continua a leggere per saperne di più.
Contenuti della Guida di benvenuto
Caratteristiche di Lumberyard (p. 3) – Scopri di più sul set di caratteristiche di Lumberyard.
Funzionamento di Amazon Lumberyard (p. 5) – Una panoramica di alto livello della tecnologia alla
base di Lumberyard.
Configurazione Amazon Lumberyard (p. 13) – Scarica, installa e crea un progetto con Lumberyard.
Crea con Amazon Lumberyard (p. 24) – Una rapida introduzione ai flussi di lavoro e agli strumenti
principali di Lumberyard.
Altre risorse Lumberyard (p. 53) – Collegamenti a esercitazioni video, documentazione e community
Lumberyard online.
Version 1.24
2
Amazon Lumberyard Guida di benvenuto
Qui ci sono solo alcune delle caratteristiche di Lumberyard:
Caratteristiche di Lumberyard
Lumberyard è ricco di funzioni che permettono di creare mondi belli, personaggi coinvolgenti e simulazioni
dinamiche. Grazie alla profonda integrazione di Lumberyard con Amazon Web Services e Twitch, puoi
aggiungere funzionalità connesse al cloud e connettere giocatori e clienti in tutto il mondo.
Qui ci sono solo alcune delle caratteristiche di
Lumberyard:
Coinvolgi i fan con Twitch
Aggiungi nuovi livelli di interattività tra gli streamer di Twitch e gli spettatori con Twitch ChatPlay. Offri
agli streamer Twitch opzioni di personalizzazione della trasmissione dinamica in tempo reale con Twitch
Metastream. Attiva il coinvolgimento diretto tra gli streamer di Twitch e gli spettatori con Twitch JoinIn.
Crea potenti funzionalità multigiocatore, velocemente
Distribuisci, gestisci e ridimensiona facilmente i server di gioco multigiocatore con Amazon GameLift. Usa
Cloud Gems Framework per aggiungere contenuti dinamici, classifiche e messaggi giornalieri.
Crea mondi incredibili
Lumberyard Editor (Editor Lumberyard) è un potente strumento di costruzione mondiale personalizzabile.
Scolpisci e dipingi terreno espansivo e multistrato. Decora il tuo paesaggio con una vegetazione densa
e lussureggiante. Progetta cieli panoramici con ora del giorno ed effetti atmosferici dinamici. Crea oceani
infiniti interattivi. Popolate il tuo mondo con entità della vita reale utilizzando componenti semplici ma
potenti.
Racconta storie con personaggi emotivi
Crea personaggi incredibili e coinvolgenti con gli strumenti basati sui dati di EMotion FX. L'editor di
animazione di Lumberyard fornisce un'interfaccia visiva basata su nodi per dare vita ai personaggi con
alberi di fusione e spazi di fusione, macchine a stato visivo e skin lineare. Racconta storie coinvolgenti
attraverso i cinematismi con l'editor di sequenze cinematiche di Lumberyard, Track View.
Effetti visivi spettacolari con NVIDIA PhysX e particelle
NVIDIA PhysX e NVIDIA Cloth consentono di creare interazioni fisiche dinamiche in tempo reale con
elementi di collisione statici, corpi rigidi e simulazioni realistiche di indumenti. Con l'Editor di particelle
Lumberyard, è possibile creare straordinari effetti visivi.
Sviluppa esperienze coinvolgenti con facilità
Non è necessario essere un programmatore esperto per utilizzare la potenza di Lumberyard. Progetta
sistemi ed esperienze accattivanti con Script Canvas, un editor di script visivo basato su nodi che consente
un facile accesso alle funzionalità sottostanti di Lumberyard. Lumberyard supporta anche Lua per i
progettisti che preferiscono l'iterazione rapida fornita dai linguaggi di scripting.
Sfrutta la potenza di Amazon Web Services
Con Lumberyard, puoi incorporare servizi AWS come Amazon DynamoDB, AWS Lambda, Amazon S3,
Amazon Cognito, Amazon SNS e Amazon SQS con strumenti e soluzioni Cloud Canvas. Il Cloud Gem
Version 1.24
3
Amazon Lumberyard Guida di benvenuto
Piattaforme supportate
Framework Gem fornisce classi C++ in grado di eseguire qualsiasi chiamata AWS SDK for C++, portando
la vasta elaborazione e archiviazione del cloud ai tuoi progetti.
Piattaforme supportate
Puoi utilizzare Lumberyard per sviluppare giochi per le seguenti piattaforme:
• PC Microsoft Windows
• Android
• iOS
• macOS
• PlayStation
• Xbox
• Linux (solo server dedicato)
Alcune piattaforme hanno requisiti aggiuntivi.
• Per il supporto della console, vedere i portali Xbox per gli sviluppatori di giochi e Partner PlayStation.
• Per i dispositivi mobili, consulta Creazione di progetti Android e iOS nella Guida per l'utente.
• Per macOS, consulta Creazione di progetti macOS nella Guida per l'utente.
• Per i server dedicati Linux, consulta Creazione di eseguibili Lumberyard per Linux nella Guida per
l'utente.
Version 1.24
4
Amazon Lumberyard Guida di benvenuto
Panoramica del framework Lumberyard
Funzionamento di Amazon
Lumberyard
Amazon Lumberyard fornisce un ambiente end-to-end completo per lo sviluppo e la distribuzione di giochi
e simulazioni e supporta un'ampia gamma di piattaforme, tra cui console, dispositivi mobili, realtà virtuale
e PC Microsoft Windows. Dal momento che si tratta di un ambiente di sviluppo così ampio con così tante
caratteristiche e strumenti diversi, può essere intimidatorio per i nuovi utenti, soprattutto per coloro che
non hanno un background di sviluppo tradizionale. Questo argomento illustra i diversi componenti di
Lumberyard ad alto livello e le modalità con cui è generalmente possibile lavorare con essi a seconda del
proprio ruolo o attività di sviluppatore di giochi o progettista principiante o esperto.
Lumberyard offre diversi strumenti, editor e sistemi che lavorano insieme per aiutarti a comporre un gioco.
Fondamentale a questo scopo è il "motore di gioco di Lumberyard", che si occupa dei seguenti aspetti:
• Rendering e output grafici
• Esecuzione della logica di gioco
• Messaggistica tra sistemi e componenti del gioco
• Astrazione e gestione della memoria e degli asset
• Supporto multi-threading per input, audio, simulazione Fisica, interfacce utente (UI), intelligenza artificiale
(IA), networking e multiplayer e altre caratteristiche comuni di gioco
• Gestione degli asset e della creazione di pacchetti
Il motore stesso è in realtà solo una raccolta di componenti e moduli, chiamati Gem. Durante lo sviluppo,
si usano l'editor di Lumberyard e gli strumenti per assemblare il motore per il gioco, scegliendo e
aggiungendo questi gem e moduli durante lo sviluppo. Si usano anche gli strumenti di Lumberyard per
aggiungere gli asset, tra cui texture, mesh, suoni, musica e script, per costruire l'esperienza e il gameplay
unici del proprio gioco.
Pensa a Lumberyard come a una raccolta di elementi discreti: codice, script, vari editor basati su GUI e
strumenti a riga di comando. Quando compili un progetto di gioco, gli script di compilazione di Lumberyard
raccolgono tutti i componenti specificati nella configurazione del progetto per creare il gioco. Le componenti
del motore che entrano nel tuo gioco sono solo quelle il cui uso è stato configurato nel progetto e ci sono
pochissime funzionalità incluse nel codice compilato finale che non hai chiesto esplicitamente di avere. Allo
stesso modo, gli strumenti di raggruppamento e gestione degli asset ti assicurano di creare una versione
finale contenente solo gli asset effettivamente utilizzati nel gioco.
In Lumberyard puoi creare un gioco semplicemente usando l'editor di Lumberyard, ma sarai vincolato ai
Gem e agli strumenti forniti (insieme agli asset e agli script che crei). Se le tue ambizioni sono maggiori, se
vuoi far evolvere Lumberyard per supportare caratteristiche e sistemi che non abbiamo messo direttamente
a disposizione, continua a leggere.
Panoramica del framework Lumberyard
L'installazione di Lumberyard fornisce una ambiente di sperimentazione di diversi pezzi da combinare, tra
cui oltre 100 gem e moduli da utilizzare nel gioco. Come concetto di alto livello, pensa a Lumberyard come
Version 1.24
5
Amazon Lumberyard Guida di benvenuto
Panoramica del framework Lumberyard
a un framework, una struttura concettuale a cui puoi aggiungere nuove caratteristiche o rimuovere tutto ciò
che non prevedi di utilizzare nel gioco. Quando hai bisogno di modificare o estendere il comportamento
di qualche elemento, non devi agire su un insieme di file di codice estremamente complesso e hackerare
o fare il refactoring di una funzionalità nel codice del gioco, ma basta lavorare solo con il gem o il modulo
che contiene la funzionalità che desideri modificare. Concentrandoti sulla modularità, puoi sperimentare
con sicurezza diverse modifiche delle caratteristiche senza rischiare di introdurre nel gioco una regressione
involontaria.
La libreria AZFramework che mette in relazione tutti i sistemi, i moduli e i gem nell'infrastruttura per il
gioco è una componente essenziale di Lumberyard Il sistema Event Bus (EBus) garantisce lo scambio di
messaggi di richiesta e notifica tra le DLL di questi sistemi, moduli e gem. Come sviluppatore, scrivi codice
C++ per implementare i metodi definiti nelle intestazioni delle API C++ che definiscono la funzionalità di cui
hai bisogno.
L'installazione predefinita di Lumberyard si trova sul PC nella cartella {drive-letter}:\Amazon
\Lumberyard\{lumberyard-version-number}\. All'interno ci sono due cartelle: \dev e \3rdParty.
Esamineremo i contenuti più importanti di \dev, che è la cartella in cui sono definiti AzFramework e tutte le
varie interfacce di gem e moduli, così come le interfacce di EBus. Contiene anche script, esempi e asset
dell'editor.
• \dev\Bin64vc142 (o, nelle versioni precedenti alla 1.24, \dev\devBin64vc141) contiene, tra le
altre cose, le librerie del compilatore degli asset, i moduli (plugin) e le librerie (sotto \EditorPlugins)
dell'editor di Lumberyard. I log di compilazione e configurazione si trovano sotto \Logs.
• \dev\Code contiene le intestazioni API C++ che includerai in ogni porzione di codice creato per
estendere le funzionalità di base di Lumberyard. Queste sono organizzate in cartelle associate a ogni
sistema o caratteristica che desideri estendere. La maggior parte di esse sono interfacce virtuali che
verranno implementate in modo da connettere tale funzionalità al sistema o alla funzionalità Lumberyard
opportuna tramite EBus o contengono le definizioni dei tipi attesi e dei modelli da utilizzare. Eccone
alcuni:
• \Code\CryEngine contiene intestazioni API e file di codice C++ per sistemi e funzionalità CryEngine.
Se è necessario modificare i comportamenti di CryEngine, incluso il renderer 3D, il motore di fisica
legacy, il motore di rete GridMate o altri componenti di CryEngine, iniziare con i file di codice sorgente
presenti in questa directory.
• \Code\Framework contiene le API di AZFramework. AzFramework è il framework di base di
Lumberyard che definisce tutti i sistemi, tra cui gem, motori di sistema ed EBus.
• \Code\Framework\AzCore\AzCore: contiene tutte le API per l'interazione con i sistemi, i moduli
e i gem di Lumberyard. Se stai estendendo la funzionalità predefinita di Lumberyard, qui troverai
tutte le API di cui hai bisogno.
• \Code\Framework\GridMate: contiene le API di rete GridMate.
• \Editor contiene tutti gli asset, gli script e i file di configurazione dell'editor di Lumberyard e alcuni dei
vari editor che gestisce, come il Materials Editor, l'UI Canvas Editor e il Particle Editor.
• \Engine contiene tutti i file binari degli asset predefiniti, i file di script (.lua), i file di configurazione
delle entità (.ent), i file di definizione dei materiali (.mtl), le estensioni dello shader (.ext) e i file di
configurazione del motore per Lumberyard.
• \Gems contiene tutti i file sorgente e compilati per i gem che vengono distribuiti assieme a Lumberyard.
Quando crei un nuovo gem, aggiungi il codice e compili i sorgenti qui, quindi abiliti il Gem tramite il
Project Configurator.
• \ProjectTemplates contiene i modelli di progetto di gioco che puoi scegliere nella configurazione
iniziale di Lumberyard per lo sviluppo del tuo gioco.
• \SamplesProject e \StarterGame contengono esempi e un livello di gioco completo da esaminare.
• \Tools contiene una serie di strumenti e SDK che utilizzerai durante lo sviluppo del gioco, tra cui:
• \Tools\AWSNativeSDK: contiene script per ottenere vari SDK specifici della piattaforma per
interagire con i servizi cloud di Amazon nei rispettivi linguaggi nativi.
• \Tools\AWSPythonSDK: contiene gli SDK Python per interagire con i servizi cloud di Amazon.
Version 1.24
6Amazon Lumberyard Guida di benvenuto
Utilizzo dei Pacchetti gem
• \Tools\AzCodeGenerator: contiene i file binari e di configurazione di AZ Code Generator, uno
strumento a riga di comando che genera codice sorgente (o qualsiasi dato o testo) a partire da codice
sorgente con tag speciali. Per ulteriori dettagli, consulta Automazione del boilerplate con il generatore
di codice AZ.
• \Tools\build: contiene script e strumenti per creare il progetto di gioco con Waf, incluso lo
strumento di compilazione da riga di comando lmbr_waf.
• \Tools\CrySCompileServer: contiene l'eseguibile e le librerie per il servizio compilatore shader
CryEngine.
• \Tools\LuaRemoteDebugger: contiene l'eseguibile e le librerie per lo strumento di debug remoto
degli script Lua.
• \Tools\Python: contiene tutte le librerie di base e l'interprete Python. Lumberyard richiede almeno la
versione 3.7.5.
• \Tools\Redistributables: contiene pacchetti e file comuni che è possibile includere nel gioco,
incluse le DLL DirectX e Visual Studio.
• \Tools\RemoteConsole: contiene l'applicazione della console remota di Lumberyard.
Lumberyard fornisce anche due strumenti a riga di comando, Lmbr.exe e Lmbr_waf.exe, da utilizzare
per gestire il progetto di gioco complessivo e configurare i dettagli del progetto di gioco durante lo sviluppo.
• Lmbr.exe—Fornisce una serie di comandi per la gestione e il monitoraggio di Gem, funzionalità e
strumenti e pacchetti di terze parti.
• Lmbe_waf.exe—Fornisce una serie di comandi per automatizzare la costruzione e la generazione dei
pacchetti di progetti di gioco con il framework di automazione della compilazione Waf.
Tutti questi componenti, oltre ad altri non elencati qui, costituiscono Lumberyard e possono essere
utilizzati per realizzare il tuo gioco. Mentre incorpori i sistemi Lumberyard e sviluppi i tuoi, vorrai che questi
comunichino tra loro. A questo scopo utilizziamo EBus.
Utilizzo dei Pacchetti gem
Molte delle funzionalità di Lumberyard sono implementate attraverso Pacchetti gem. Un Gem è
un'estensione pacchettizzata che può essere abilitata in un progetto per aggiungere funzionalità o
caratteristiche. I Pacchetti gem potrebbero contenere codice del modulo, asset, script, file di supporto e
riferimenti ad altri Pacchetti gem. L'utilizzo di Pacchetti gem consente di scegliere le funzionalità necessarie
per il progetto ed escludere quelle che non sono necessarie. Mantenendo tutto modulare e utilizzando solo
ciò di cui hai bisogno, il sistema dei Gem ti consente uno sviluppo iterativo più rapido. Le raccolte di asset,
esempi di codice, componenti, librerie, strumenti e persino interi progetti di gioco possono essere distribuiti
sotto forma di Pacchetti gem.
Quando crei il progetto in Project Configurator (Configuratore progetto) attivi i Pacchetti gem. Puoi tornare
a Project Configurator (Configuratore progetto) in qualsiasi momento per abilitare ulteriori Pacchetti gem
e disabilitare Pacchetti gem inutilizzati. Quando crei il primo progetto, assicurati di fare clic sull'opzione
Attiva Pacchetti gem in Project Configurator (Configuratore progetto) per visualizzare l'elenco dei Pacchetti
gem disponibili. Alcuni Pacchetti gem sono sistemi fondamentali e necessari per tutti i progetti Lumberyard.
Altri Pacchetti gem sono estensioni per Pacchetti gem esistenti e richiedono che le loro dipendenze siano
abilitate per il progetto. I Pacchetti gem che abiliti vengono rilevati e compilati automaticamente al momento
della compilazione del progetto.
Puoi creare i tuoi Pacchetti gem e riutilizzare e distribuire facilmente il tuo codice e i tuoi asset. Per avere
un'idea migliore di cosa serva per la creazione di un Gem, dai un'occhiata alla cartella Pacchetti gem della
tua installazione di Lumberyard ed esamina i Pacchetti gem inclusi. Il processo di creazione di un proprio
Gem passa attraverso l'uso di Project Configurator (Configuratore progetto) ed è molto simile alla creazione
di un progetto.
Version 1.24
7Amazon Lumberyard Guida di benvenuto
Messaggistica tra sistemi con EBus
Messaggistica tra sistemi con EBus
Tutte i gem e i sistemi di Lumberyard, così come i componenti dei tuoi progetti, hanno bisogno di un mezzo
per comunicare tra loro. Lumberyard utilizza un sistema di comunicazione generico chiamato Event Bus
(EBus in breve).
Come discusso in precedenza, gem e sistemi sono in genere implementati come DLL. EBus viene utilizzato
per la comunicazione tra di essi e, in particolare, per richiamare funzioni in un gem o in un sistema da un
altro. EBus fornisce le interfacce per eventi (bus) sia di richiesta, sia di tipo pubblicazione/sottoscrizione che
consentono le chiamate attraverso tra tali DLL. Ad esempio, se hai creato un Gem per comportamenti fisici
personalizzati e desideri fornire dati al renderer CryEngine, devi farlo implementando un'interfaccia EBus
nel tuo Gem.
Forniamo le interfacce per i Gem e le DLL dei sistemi inclusi nella distribuzione come intestazioni
nell'installazione predefinita. Per utilizzare la funzionalità in queste DLL, puoi utilizzare le interfacce in
queste intestazioni per registrare un evento con un unico destinatario (Event) o senza destinatari specifici
(Broadcast) oppure fornendo un funtore della richiesta dati a un gestore del bus delle richieste.
Allo stesso modo, per esporre la funzionalità dei tuoi gem e fornire dati a un altro sistema, devi ereditare
l'interfaccia virtuale dichiarata nel file di intestazione corrispondente e implementare i gestori di tale
interfaccia nelle classi dei tuoi Gem, quindi registrare tale gestore sul sistema EBus. In particolare,
registrerai un gestore creato con EBus, che passerà un puntatore al metodo di classe al sistema di
destinazione o pubblicherà una notifica ai sistemi sottoscritti ad esso.
All'interno del codice del tuo Gem, gestisci anche la connessione e la disconnessione del gestore
implementato per l'EBus. EBus è semplicemente un elenco di gestori che richiama tutti i funtori (puntatori di
funzione) registrati su di esso.
Per i gestori singleton in cui è necessaria una sola interfaccia per comunicare tra DLL, prendi in
considerazione l'utilizzo diretto di AZ::Interface e AZ:Event, senza passare tramite EBus.
Sono previsti due tipi di eventi EBus:
• Bus di richiesta: questo tipo di EBus registra un gestore per un metodo che può essere chiamato da altri
sistemi.
• Bus di notifica: questo tipo di EBus fornisce un'interfaccia di messaggistica per le notifiche che i sistemi
possono pubblicare o a cui possono sottoscriversi.
Gli EBus presentano molti vantaggi rispetto ai metodi di polling tradizionali:
• Astrazione: riduce al minimo le dipendenze forti tra sistemi.
• Programmazione basata sugli eventi: elimina gli schemi di polling per ottenere software più scalabili e
dalle prestazioni migliori.
• Codice applicativo più pulito: invia un messaggio in sicurezza senza preoccuparti di cosa li sta gestendo
o addirittura se siano in qualche modo gestiti.
• Concorrenza: accoda gli eventi di vari thread per un'esecuzione sicura in un altro thread o per
applicazioni su sistemi distribuiti.
• Prevedibilità: fornisce supporto per l'ordinamento dei gestori su uno specifico bus.
• Debugging: intercetta i messaggi per la creazione di report, la generazione di profili e a scopo di
introspezione.
Gli EBus sono configurabili e supportano diversi casi d'uso:
• Chiamata di funzione globale diretta.
• Distribuzione dell'elaborazione a più gestori.
Version 1.24
8Amazon Lumberyard Guida di benvenuto
Component Entity System
• Accodamento di tutte le chiamate, agendo da buffer dei comandi.
• Casella email indirizzabile.
• Distribuzione forzata.
• Distribuzione con accodamento.
• Marshalling automatico di una chiamata di funzione in un messaggio di rete o in altri buffer di comandi.
Per ulteriori informazioni sull'utilizzo di EBus, leggere:
• Utilizzo del sistema di bus di eventi (EBus)
• Approfondimento sui Bus evento
Component Entity System
Ma che succede ai componenti che sono veramente incluse nel gioco? Lumberyard ha un modello anche
per quelle, chiamato sistema entità componente.
Capire il sistema entità componente è fondamentale per l'utilizzo Lumberyard. È concettualmente semplice:
ogni oggetto di gioco che crei per il tuo progetto è un' entità, con un ID univoco e un contenitore. Ogni entità
contiene componenti che forniscono funzionalità. Le funzionalità offerte dai componenti forniscono sono
ampie e includono forme primitive, mesh, audio, comportamenti di intelligenza artificiale, animazione, effetti
visivi, fisica, script e molto altro ancora. Ci sono anche componenti che forniscono strumenti e funzionalità
di debug.
Ad esempio, supponiamo di voler creare un'entità porta che possa essere aperta e chiusa. Hai creato una
mesh e un paio di file audio. Ora, considera la funzionalità che deve avere la tua porta.
• Visualizza il modello della porta.
• Riproduci i file audio quando la porta si apre e si chiude.
• Impedisci di passare attraverso la porta quando è chiusa.
• Anima l'apertura e la chiusura della porta.
• Attiva l'apertura e la chiusura della porta attraverso qualche meccanismo.
Conoscendo la funzionalità di cui la tua entità porta ha bisogno, aggiungi componenti all'entità per ogni
aspetto della porta, inclusa la sua presenza nel mondo di gioco e i modi in cui un giocatore può interagire
con essa. Un componente Mesh rappresenta visivamente la porta nel mondo di gioco. I componentiAudio
Trigger forniscono l'audio all'apertura e alla chiusura della porta. Un componente Elemento di collisione
PhysX impedisce a un giocatore di passare attraverso la porta quando è chiusa. I componenti Script
Canvas definiscono i comportamenti, tra cui l'animazione e la riproduzione del suono, quando la porta
viene aperta o chiusa. Qualunque sia il comportamento che bisogna modellare, ogni entità disporrà di
una raccolta di componenti per supportarla. L'unico componente comune a tutte le entità è il componente
Transform che fornisce la posizione, l'orientamento e la scala dell'entità nel mondo del gioco.
Le entità sono facili da comprendere e creare, ma possono diventare complesse. Se l'entità richiede
molte funzionalità, l'elenco dei componenti cresce rapidamente. Cosa succede se si desidera aggiungere
un chiavistello con una propria animazione e un suo audio alla porta? Cosa succede se si desidera
aggiungere un vetro frangibile alla porta? Improvvisamente, l'entità passa dall'avere cinque componenti a
dozzine di componenti. Qui è dove entrano in gioco le sezioni.
Una sezione, come un'entità, è un contenitore con un comportamento di trasformazione. Invece di
contenere componenti, una sezione contiene una o più entità configurate e potrebbe contenere anche altre
sezioni. Per creare una porta più complessa, è possibile avere l'entità iniziale della porta, una seconda
entità per il chiavistello e i relativi componenti e una terza entità per il vetro frangibile e i relativi componenti.
Version 1.24
9Amazon Lumberyard Guida di benvenuto
L'Asset Pipeline di Lumberyard
Queste tre piccole entità vengono raccolte in una sezione che fornisce un asset porta riutilizzabile e
completamente funzionale. Potreste aver già sentito concetti simili denominati prefabs in altri software. In
Lumberyard, una sezione è una raccolta di entità e/o altre sezioni in un singolo asset riutilizzabile.
I comportamenti applicati a una sezione possono potenzialmente essere replicati in cascata a tutte le entità
in essa contenute e quindi ai componenti di tali entità. Tuttavia non vale il contrario, in quanto non avrebbe
senso applicare la frantumazione di un vetro al chiavistello della porta.
Dopo aver compreso la gerarchia sezione > entità > componenti, pensa a come potresti utilizzare questi
concetti per sviluppare i vari elementi che potenzialmente popolano i livelli del tuo gioco e del tuo mondo.
L'Asset Pipeline di Lumberyard
Abbiamo parlato del contenuto dell'installazione di Lumberyard, del framework di base di Lumberyard e di
come le sue varie parti comunicano tra loro e di come sono rappresentati gli oggetti nel gioco. Ma come
crei e gestisci gli asset per il tuo gioco? Dopo tutto, una porta non esiste veramente nel tuo gioco se non ha
qualche forma di rappresentazione.
Ai fini di Lumberyard, definiremo un asset come un file di asset, salvato su disco, consumato dal progetto
in qualche modo. Un asset potrebbe essere un font per l'interfaccia utente, un file bitmap che contiene una
trama erbosa del terreno, una mesh rocciosa che hai scolpito, le animazioni di un personaggio, ecc. Alcuni
asset potrebbero essere creati in Lumberyard. Ad esempio, i file specializzati denominati inputbindings che
mappano i pulsanti di un game pad agli eventi di input per il progetto e physicsmaterials che descrivono le
proprietà fisiche delle superfici, vengono entrambi creati nell'Asset Editor di Lumberyard.
Per molte ragioni, principalmente legate alle prestazioni, queste diversi asset non possono essere
consumati da Lumberyard senza essere convertiti in dati specifici per il sistema operativo e pronti per il
gioco. Questo processo, che permette di passare da un file sorgente di asset su disco a dati pronti per il
gioco è detto Asset Pipeline (Pipeline asset). L'elaborazione viene eseguita automaticamente da Asset
Processor (Elaboratore asset).
Asset Processor (Elaboratore asset) è un processo in background (vedrai la sua icona nella barra delle
applicazioni quando è in esecuzione) che scansiona costantemente le directory nel tuo progetto alla ricerca
di modifiche nei file. Quando vengono rilevate modifiche, Asset Processor (Elaboratore asset) utilizza
regole configurabili per determinare come gestire le modifiche. L'obiettivo è ottenere versioni pronte per il
gioco di tutti gli asset, per ogni sistema operativo e ogni cartella del gioco, in una posizione chiamata cache
degli asset. La cache degli asset viene tenuta separata dalle cartelle degli asset e può essere interamente
ricompilata in modo automatico a partire dai sorgenti degli asset tramite Asset Processor (Elaboratore
asset).
La cache degli asset contiene un'immagine completa di tutti i file (ad eccezione degli eseguibili e dei file
correlati) necessari per eseguire il progetto. Asset Processor (Elaboratore asset) mantiene l'immagine
aggiornata, assicurando che i nuovi file siano pronti per l'uso nel runtime del progetto e in Lumberyard
Editor (Editor Lumberyard) il prima possibile. Il runtime del progetto caricherà solo gli asset dalla cache
degli asset e mai direttamente dalle directory di origine degli stessi.
Progetti come i giochi moderni possono avere migliaia di asset che devono essere monitorate ed elaborate
per più sistemi operativi di destinazione. Per gestire questa complessità, Asset Pipeline (Pipeline asset) è
completamente configurabile. Ecco alcune delle opzioni di configurazione disponibili:
• Specificare quali cartelle devono essere monitorate per le modifiche.
• Specificare i sistemi operativi di destinazione e personalizzare il comportamento di Asset Pipeline
(Pipeline asset) per il sistema operativo di destinazione.
• Impostare il numero di attività simultanee di elaborazione.
• Utilizzare le informazioni sui metadati per associare i tipi di file ed elaborare gli asset affiancati.
• Aggiungere i propri tipi di asset a Asset Pipeline (Pipeline asset).
Version 1.24
10Amazon Lumberyard Guida di benvenuto
Scripting per il framework Lumberyard
• Asset di processo batch su un server di compilazione.
Quando prepari la versione finale, dovrai creare un pacchetto degli asset utilizzati dal tuo progetto. Anche
i piccoli progetti possono includere centinaia di asset, tra cui più versioni di essi, molte delle quali non
sono necessarie nel progetto finale. Tenere traccia e determinare manualmente quali asset è necessario
includere nella versione finale è un'attività noiosa, che fa perdere molto tempo ed è soggetta a errori. Asset
Bundler risolve queste problema per tuo conto.
Asset Bundler rende l'inclusione degli asset specifici utilizzati nella versione di rilascio del gioco
un'operazione più affidabile e ripetibile. L'affidabilità si basa su un sistema di dipendenza sottostante. Se
si apportano modifiche al progetto e si aggiungono, si rimuovono o si aggiornano gli asset, Asset Bundler
utilizza le dipendenze per determinare automaticamente gli asset da includere. La ripetibilità si basa sui file
di configurazione sottostanti che garantiscono la coerenza di ogni esecuzione di Asset Bundler.
Scripting per il framework Lumberyard
Ora, hai creato gli asset e li hai definiti nel gioco usando sezioni, entità e componenti. Disponi di un livello o
un mondo vuoto in cui vagare, ma dov'è il gioco? Ecco dove entra in gioco lo scripting.
Lumberyard include due tecnologie di scripting per la creazione di logica e comportamenti: Script Canvas e
Lua.
Script Canvas è un ambiente di scripting visuale. Nell'editor di Script Canvas puoi creare, connettere e
riorganizzare nodi grafici che forniscono una rappresentazione visiva del flusso logico. Script Canvas offre
un ambiente accessibile e facile da leggere per creare comportamenti utilizzando lo stesso framework di
Lua e C ++. Puoi utilizzare Script Canvas per creare script senza bisogno di saper programmare.
Per abilitare Script Canvas per Lumberyard, devi abilitare il Gem Script Canvas.
Lua è un linguaggio di scripting potente, veloce, leggero e integrabile. Facilita l'iterazione rapida nel
progetto di gioco perché consente di apportare immediatamente le modifiche senza dover ricompilare il
codice sorgente.
Le funzionalità di Lumberyard sono esposte a Script Canvas e Lua dal contesto di comportamento. Il
contesto di comportamento riflette il codice runtime e lo rende accessibile agli script fornendo associazioni
a classi, metodi, proprietà, costanti ed enumerazioni C++. Il contesto di comportamento fornisce anche
associazioni per EBus di Lumberyard in modo da poter inviare e gestire eventi attraverso Script Canvas e
Lua.
Le funzionalità di Script Canvas e Lua sono aggiunte alle entità tramite i componenti. All'interno delle
entità puoi aggiungere più componenti di script e combinare insieme script Lua e Script Canvas. Questo
approccio consente di creare piccoli moduli di logica e comportamento gestibili che possono essere
riutilizzati in tutti i progetti.
Ulteriori apprendimenti
Come probabilmente hai intuito, Lumberyard offre molto altro, ma speriamo che quanto illustrato qui ti dia
un'idea su dove iniziare le ricerche per trovare maggiori dettagli nei nostri documenti e nel codice. Ecco
alcuni link aggiuntivi per aiutarti ad approfondire il tema:
Per alcuni fantastici video su come iniziare a usare Lumberyard, guarda la nostra serie di tutorial sulle
nozioni di base.
Per alcuni documenti per iniziare, dai un'occhiata ai seguenti argomenti:
Version 1.24
11Amazon Lumberyard Guida di benvenuto
Ulteriori apprendimenti
• Lumberyard Editor (Editor Lumberyard)
• Nozioni di programmazione
• Pacchetti gem
• Modello ECS (Component Entity System)
• Documentazione di riferimento dei componenti
• Guida per i programmatori per entità e componenti
• Emotion FX Animation Editor (Editor animazione)
• Script Canvas
• Editor Lua
Version 1.24
12Amazon Lumberyard Guida di benvenuto
Requisiti di sistema
Configurazione Amazon Lumberyard
Amazon Lumberyard ha un processo di installazione in due parti:
1. L'applicazione di installazione scarica, estrae e installa Lumberyard.
2. Assistente configurazione consente di configurare e installare software aggiuntivi sulle tue esigenze
di sviluppo. Vai direttamente al Lumberyard Editor (Editor Lumberyard) con un Installazione rapida o
personalizza Lumberyardle caratteristiche di per il tuo di sviluppo con un Installazione personalizzata.
Dopo Lumberyard è installato, utilizzare Project Configurator (Configuratore progetto) per selezionare un
o creare un nuovo progetto. Le seguenti sezioni descrivono in dettaglio i requisiti minimi per Lumberyard e
guidarvi attraverso il processo di installazione.
Argomenti di configurazione
• Amazon Lumberyard requisiti di sistema (p. 13)
• Installazione Amazon Lumberyard (p. 15)
• Configurazione di Amazon Lumberyard con Assistente configurazione (p. 17)
• Gestisci Lumberyard progetti con Project Configurator (p. 19)
Amazon Lumberyard requisiti di sistema
Lumberyard dispone di una serie minima di requisiti di sistema per lo sviluppo, come descritto nella
seguenti sezioni. I requisiti di spazio su disco e RAM dipendono dalle opzioni scegliere durante
l'installazione.
Requisiti di sistema
Se il sistema è in grado di eseguire un moderno gioco 3D in tempo reale con buone prestazioni, tuttavia,
rivedere questi requisiti dettagliati per essere certi.
Lumberyard richiede Windows 10.
Lumberyard requisiti hardware minimi:
• Processore quad-core da 3 GHz
• 8 GB di RAM
• Scheda video compatibile con VRAM DirectX 11 o versioni successive da 2 GB
• NVIDIA GeForce GTX 660 Ti con driver versione 368.81 o successiva
Version 1.24
13Amazon Lumberyard Guida di benvenuto
Prerequisites
• AMD Radeon HD 8730M con driver versione 16.15.2211 o successiva
• 60 GB di spazio libero su disco
Note
Se si selezionano le opzioni per creare il motore, l'editor o gli strumenti in Assistente
configurazione, Per la compilazione sono necessari 14 GB di RAM.
Alcune funzioni grafiche avanzate richiedono un video compatibile con DirectX 12 o versione
successiva scheda.
Lo spazio libero su disco richiesto dipende dalle opzioni selezionate quando installazione
Lumberyard.
Prerequisites
È possibile utilizzare la scheda Lumberyard Editor (Editor Lumberyard) e strumenti senza installare
software aggiuntivo. A creare nuovi progetti o utilizzare funzionalità di sviluppo avanzate in Lumberyard, hai
bisogno di uno sviluppatore ambiente. È richiesta una delle seguenti versioni di Microsoft Visual Studio:
• Versione di Microsoft Visual Studio 2019 16,2,4 o successiva.
• Versione di Microsoft Visual Studio 2017 15,9,14 o successiva.
Microsoft offre Visual Studio Community Edition gratuitamente ai singoli sviluppatori. Per ulteriori
informazioni e per scaricare e installare Visual Studio Community, visitare il sito Community di Visual
Studio portale.
Funzionalità richieste di Visual Studio 2017 e 2019
L'installazione predefinita di Visual Studio potrebbe non includere tutte le caratteristiche che sono richiesti
da Lumberyard. Verificare che le seguenti caratteristiche di Visual Studio siano abilitato:
1. Lanciare il Programma di installazione di Visual Studio dal tuo download o la directory Menu di avvio se
hai già installato Visual Studio.
2. Se Visual Studio è stato installato, scegliere Altro - Modifica sulla versione di Visual Studio che utilizzerai
con Lumberyard.
3. Nella pagina Carichi di lavoro scheda:
• Seleziona Sviluppo di giochi con C++.
• Nella finestra Dettagli di installazione sul pannello seleziona almeno una Finestre 10 Kit di sviluppo
software (SDK.
4. Nella pagina Componenti individuali , sotto Compilatori, strumenti di compilazione e runtime, selezionare
il pulsante Set di strumenti VC++ che corrisponde alla versione installata di Visual Studio:
• Studio visivo 2017: Seleziona almeno una versione del Set di strumenti VC++ 2017.
• Studio visivo 2019: Seleziona almeno una versione del Creazione MSVC v142 - VS 2019 C++ x64/x86
strumento.
• (Facoltativo) Per creare con il set di strumenti di Visual Studio 2017, seleziona Creazione MSVC
v141 - VS 2017 C++ x64/x86 strumenti.
Pacchetti ridistribuibili Visual C++
Lumberyard Installatore tenterà di scaricare e installare il necessario Pacchetti ridistribuibili Visual C++
durante il processo di installazione. In alcune circostanze, l’installazione di questi potrebbe non riuscire.
Version 1.24
14Amazon Lumberyard Guida di benvenuto
Installazione
Se si riceve un runtime Visual C++ mancante .dll errore durante l'esecuzione Lumberyard Installatore,
Lumberyard Setup Assistant (Assistente configurazione Lumberyard), o Project Configurator (Configuratore
progetto), procedere come segue:
1. Verificare che i programmi di installazione ridistribuibili di Visual C++ per Visual Studio 2012 e Visual
Studio 2019 siano stati correttamente ha scaricato. Gli installatori si trovano nel corrispondente Studio
visivo directory nella lumberyard_version\dev\Tools\Redistributables\ directory.
2. Se i programmi di installazione ridistribuibili di Visual C++ per Visual Studio 2012 e Visual Studio 2019
non sono stati scaricati da parte di Lumberyard Programma di installazione, scarica manualmente i
programmi di installazione da Microsoft.
• Ridistribuibile a Visual C++ per Visual Studio 2012
• Ridistribuibile a Visual C++ per Visual Studio 2019
3. Eseguire entrambi i programmi di installazione ridistribuibili di Visual C++.
4. Riprovare Lumberyard dopo che i ridistribuibili di Visual Studio hanno installato correttamente.
Note
Il Visual C++ Redistributable for Visual Studio 2019 contiene anche ridistribuibili per Visual Studio
2015 e 2017.
Installazione Amazon Lumberyard
Utilizza il link di download qui sotto per ottenere le ultime Lumberyard Installatore applicazione.
Esegui il Lumberyard installatore
Vai a Downloads ed esegui LumberyardInstaller.exe per scaricare, estrarre e installare
Lumberyard.
Il valore predefinito Lumberyard il percorso di installazione è C:\Amazon\Lumberyard\. A impostare un
percorso di installazione diverso, scegliere Options pulsante. Scegli il Install per avviare l'installazione di. Il
processo può prenditi un po' di tempo, a seconda della velocità di connessione Internet.
Note
In alcune situazioni, il Lumberyard Il programma di installazione può bloccarsi e rifiutare di
avanzare. L’unico rimedio noto in questo momento è di chiudere forzatamente il programma di
installazione tramite Gestione attività di Windows e riavviarlo, quindi riprovare l'installazione.
Il programma di installazione visualizza un Installazione completata correttamente messaggio. Fai clic
Lancia Lumberyard Setup Assistant (Assistente configurazione Lumberyard) per continuare con la
configurazione.
Version 1.24
15Amazon Lumberyard Guida di benvenuto
Lumberyardeseguibili di
Lumberyardeseguibili di
LumberyardInstaller.exe crea collegamenti sul desktop e in il menu Start per tre applicazioni:
Assistente configurazione (p. 17)
Assistente configurazione configura Lumberyarddi in base al tuo sviluppo e scarica e installa
software e SDKS aggiuntivi. È possibile utilizzare Assistente configurazione in qualsiasi momento per
aggiungere funzionalità di sviluppo Lumberyard ambiente.
SetupAssistant.exe si trova in lumberyard_version\dev\Tools\LmbrSetup\Win.
Project Configurator (Configuratore progetto) (p. 19)
con Project Configurator (Configuratore progetto), è possibile creare, configurare, impostare e
compilare progetti. Quando corri Project Configurator (Configuratore progetto) per la prima volta,
vedete diversi progetti di esempio disponibili per aiutarvi a imparare Lumberyarddi caratteristiche di.
ProjectConfigurator.exe si trova in lumberyard_version\dev\Bin64vc141_or_vc142.
Lumberyard Editor (Editor Lumberyard) (p. 29)
Lumberyard Editor (Editor Lumberyard) è Lumberyardl'applicazione core di. Ingresso Lumberyard
Editor (Editor Lumberyard), si crea livelli, asset e interazioni per i tuoi progetti.
Editor.exe si trova in lumberyard_version\dev\Bin64vc141_or_vc142.
LumberyardStruttura della directory di
Il valore predefinito Lumberyard la posizione di installazione è C:\Amazon\Lumberyard
\lumberyard_version\. La directory principale contiene le seguenti directory e file:
• dev
• _WAF_: File di sistema di compilazione Waf.
• Bin64: Binari e file di configurazione per Resource Compiler (Compilatore risorse).
• Bin64vc141: File binari e di configurazione per Visual Studio 2017.
• Bin64vc142: File binari e di configurazione per Visual Studio 2019.
• Code: File di origine e file di soluzione per Lumberyard motore e strumenti.
• Editor: Asset dell'editor.
• Engine: Risorse del motore.
• Gems: Componenti e asset modulari.
• MultiplayerSample: Progetto di esempio multigiocatore che mostra come creare un gioco
multigiocatore con sistema entità componente.
• ProjectTemplates: File di configurazione, librerie, e gli script per il modello vuoto.
• SamplesProject: Progetto di esempio.
• StarterGame: Un gioco di esempio completo con 3D ambienti, script di eventi e IA nemica di base.
• Tools: Strumenti e plug-in di terze parti.
• engineroot.txt: File di sistema richiesto da Lumberyard Setup Assistant (Assistente configurazione
Lumberyard) per verificare la directory.
• 3rdParty
• Software di terze parti necessario per l'utilizzo o la compilazione Lumberyard.
Version
• 3rdParty.txt: File di sistema utilizzato 1.24strumenti di terze parti per verificare la directory.
da altri
16Amazon Lumberyard Guida di benvenuto
Assistente configurazione
Configurazione di Amazon Lumberyard con
Assistente configurazione
Lumberyard Setup Assistant (Assistente configurazione Lumberyard) configura e mantiene il tuo
Lumberyard in base al vostro sviluppo ha bisogno di. Se si continua da Installazione Amazon
Lumberyard (p. 15), Assistente configurazione dovrebbe essere in esecuzione sul desktop. Assistente
configurazione possono essere lanciati anche dalla scheda Collegamenti dal menu o dal desktop.
Lumberyard Setup Assistant (Assistente configurazione Lumberyard) svolge diverse funzioni importanti:
• Verifica di disporre del software di runtime richiesto.
• Verifica che tu disponga degli SDK richiesti.
• Fornisce plug-in per applicazioni di contenuti rilevati come Photoshop e Maya.
• Convalida le impostazioni, i percorsi e le librerie del registro.
Alla prima esecuzione, Lumberyard Setup Assistant (Assistente configurazione Lumberyard) presenta due
opzioni, Installazione rapida e Installazione personalizzata. Se sei un esperto creatore, come un designer
o artista, e non compilerà il codice, o se vuoi saltare direttamente e utilizzare il Lumberyard Editor (Editor
Lumberyard) e strumenti, seleziona Installazione rapida. Puoi sempre rivedere Assistente configurazione
da aggiungere caratteristiche di sviluppo. Se desideri impostare Lumberyard per lo sviluppo del codice,
selezionare Installazione personalizzata.
Dovresti correre Assistente configurazione periodicamente, specialmente dopo aver apportato modifiche
per convalidare e riparare le impostazioni e i percorsi. Puoi anche personalizzare Assistente configurazione
con un per integrare facilmente la struttura di directory specifica.
Note
Alcuni Assistente configurazione richiedono l'installazione di software e licenze di terze parti,
quindi assicurati di consultare i termini di servizio prima di installare del software.
Version 1.24
17Puoi anche leggere
