>> With this in mind, your next assignment requires you to use the data file
you've parsed to render the few images on the screen. You're going to need to
fill out the two functions below to properly draw images on the screen. Now,
before you get started, let's talk about something real quick. Note that, before
now, your artists were actually generating assets referencing loose files. And
artists create some sort of texture, they put it on disk, and then they
reference an object to that texture. Well, of course, there's a post-process.
We've all crammed that all into a small little box, and we now have a missing
correlation. The artist file still is going to reference the loose asset. But
we've got it sitting around in a larger texture. How do we make a connection
between the two? The drawSprite function needs to fix this. It assumes that it's
going to be given a spritename, which represents the name of the loose asset
file as well as the position X and position Y on where it wants to render it on
the canvas. Since we're just given a spitename, we need to map where that
spritename exists inside of the atlases that we've loaded. Now, for your
benefit, we're going to help you out with this. Taking a look at the top of the
file, we define a global dictionary object that represents every sprite sheet
that's been loaded. In the load function for sprite sheet, we go ahead and add
this sprite sheet into the global array, setting the sheet name as the key for
the dictionary element. What this will allow you to do is when you're given the
spritename inside of the draw function, you can iterate through all of the
sprite sheets and for each sprite sheet, determine whether or not the given
spritename exists in the sprites that have been defined for that sheet. This
should be pretty straightforward since we've already covered the defined sprite
function and you already have a list that includes a name. Once the drawSprite
function figures out what atlas this given sprite is actually in, it can pass
that data to drawSpriteInternal, handing off the sprite information, what atlas
sheet its coming from, as well as the position X and Y that was given to us from
drawSprite. Drawspriteinternal should actually do the heavy lifting of
positioning the element, and drawing it to the world, taking advantage of the
draw image API that we just covered with all of its new fancy bells and whistle
parameters.
Para tu próxima tarea, tienes que utilizar el archivo de datos
que has analizado para representar las imágenes de la pantalla.
Debes completar las dos funciones para dibujar bien imágenes en la pantalla.
Antes de empezar, una aclaración.
Hasta ahora, los diseñadores generaban assets que remitían a archivos sueltos.
Y los diseñadores crean una textura, la ponen aquí
y luego remiten un objeto a esa textura. Por supuesto, hay un proceso posterior.
Hemos metido todo eso en una pequeña caja y nos falta una correlación.
El archivo del diseñador seguirá remitiendo al asset suelto.
Pero está en la textura general. ¿Cómo los conectamos?
La función drawSprite puede solucionarlo.
Requiere un spritename, que representa el nombre de archivo del asset suelto
y la posición X e Y del canvas en el que queremos representarlo.
Tenemos que definir en qué atlas de los cargados estará el spritename.
Vamos a ayudarte a hacerlo.
Arriba del documento, definimos un objeto, un diccionario general que representa
todas las hojas de sprites que se han cargado.
En la función de cargar hoja de sprites, añadimos esta hoja en el array global
y ponemos el nombre de la hoja como clave para el elemento del diccionario.
Así, cuando se te da el spritename dentro de la función de dibujo,
puedes explorar las hojas de sprites y determinar si dicho spritename
existe en los sprites definidos para cada hoja.
Debería ser sencillo, porque ya hemos abordado
la función de definir sprites y ya tienes una lista con un nombre.
Cuando la función drawSprite encuentre el atlas de este sprite,
podrá pasar a drawSpriteInternal datos
del sprite, de qué atlas proviene y la posición X e Y que nos dio drawSprite.
drawSpriteInternal debería ubicar el elemento y dibujarlo en el mundo
aprovechando el drawimage API que recién abordamos
con toda la parafernalia de nuevos parámetros.
Dans cette optique, votre prochaine affectation nécessite d'utiliser le fichier de données
vous avez analysé pour restituer les quelques images sur l'écran. Vous allez en avoir besoin pour
remplir les deux fonctions ci-dessous pour dessiner correctement les images sur l'écran. Maintenant,
avant de commencer, nous allons parler rapidement de quelque chose. Notez que, avant
maintenant, vos artistes généraient des actifs référençant des fichiers libres.
Et artistes créent une sorte de texture, ils mettent sur disque, puis ils
font référence à un objet de cette texture. Eh bien, bien sûr, il y a un post-traitement.
Nous avons tous entassés dans une petite boîte et il nous manque maintenant une
corrélation. Le fichier artiste fait toujours référence à l'actif libre. Mais
Nous l'avons dans une texture plus grande. Comment faire une connexion
entre les deux ? La fonction drawSprite doit résoudre ce problème. Il suppose qu'il y a
un "spritename", qui représente le nom de l'actif en vrac dans le fichier
ainsi que la position X et position Y sur où il veut se rendre sur
la toile. Puisque nous avons juste donné une "spitename", nous devons indiquer où se trouve ce
"spritename" à l'intérieur de l'Atlas que nous avons chargé. Maintenant, pour votre
avantage, nous allons vous aider avec ceci. Un regard sur la partie supérieure du
fichier, nous définissons un objet de dictionnaire global qui représente chaque feuille de sprite
qui a été chargé. Dans la fonction load pour feuille de sprite, nous allons de l'avant et ajoutons
la présente fiche de sprite dans le tableau global, affectant le nom de feuille comme clé pour
l'élément de dictionnaire. Ce que cela vous permettra de faire est quand on vous donne la
spritename à l'intérieur de la fonction de tirage au sort, vous pouvez parcourir tous les
feuilles de sprite et pour chaque feuille de sprite, déterminer si oui ou non la donnée
spritename existe dans les sprites qui ont été définis pour cette feuille. Ceci
devrait être assez simple, puisque nous avons déjà défini la fonction de sprite
et vous avez déjà une liste qui inclut un nom. Une fois que la fonction
drawSprite trouve dans quel atlas ce sprite est, il peut passer
ces données à drawSpriteInternal, livrant l'information du sprite, de quel feuille d'atlas
il vient, ainsi que la position X et Y qui nous a été donné de
drawSprite. Drawspriteinternal doit en fait faire le gros du
positionnement de l'élément et du collage dans l'environnement, profitant de
l'API pour dessiner l'image que nous avons défini juste avec toutes ses nouvelles fioritures et
paramètres dégotés.
>> मन में इस के साथ, आप डेटा फ़ाइल का उपयोग करने के लिए अपने अगले काम की आवश्यकता है
आप स्क्रीन पर कुछ छवियाँ रेंडर करने के लिए पार्स है। आप की जरूरत करने जा रहे हैं
दो काम करता है ठीक तरह से स्क्रीन पर छवियाँ आरेखित करने के लिए नीचे भरें। अब,
इससे पहले कि आप शुरू हो, कुछ असली जल्दी है के बारे में बात करते हैं। ध्यान दें कि, इससे पहले कि
अब, अपने कलाकारों वास्तव में ढीले फ़ाइलों को संदर्भित संपत्ति पैदा करने थे। और
कलाकारों बनावट के कुछ प्रकार बनाने के लिए, वे इसे डिस्क पर, और वे फिर डाल
उस संरचना के लिए कोई ऑब्जेक्ट को संदर्भित। ठीक है, जाहिर है, वहाँ एक post-process है।
हम सब crammed है कि एक छोटे छोटे बॉक्स में, और हम सब अब एक याद आ रही है
सहसंबंध। कलाकार फ़ाइल अभी भी ढीली परिसंपत्ति को संदर्भित करने के लिए जा रहा है। लेकिन
हम इसे एक बड़ा बनावट में चारों ओर बैठे मिल गया है। हम एक कनेक्शन कैसे कर सकता हूँ
दोनों के बीच? DrawSprite फ़ंक्शन इसे ठीक करने के लिए की जरूरत है। यह मान लिया गया है कि यह
एक spritename, जो ढीली परिसंपत्ति का नाम का प्रतिनिधित्व करता है दी जानी करने के लिए जा रहा
फ़ाइल के रूप में अच्छी तरह के रूप में स्थिति X और Y स्थिति जहां यह इसे पर प्रस्तुत करना चाहता है पर
कैनवास। हम सिर्फ एक spitename दी रहे हैं के बाद से, हम कहाँ से मैप करने की आवश्यकता कि
spritename कि हम भरी हुई है atlases के अंदर मौजूद है। अब, के लिए अपने
लाभ, हम आप इस के साथ मदद करने के लिए जा रहे हैं। के शीर्ष पर एक नज़र ले जा
फ़ाइल, हम हर प्रेत शीट का प्रतिनिधित्व करता है एक वैश्विक शब्दकोश ऑब्जेक्ट को परिभाषित
कि लोड किया गया है। प्रेत पत्रक के लिए लोड फ़ंक्शन, में हम आगे जाओ और जोड़ें
वैश्विक सरणी, पत्रक का नाम के लिए कुंजी के रूप में सेट करने में इस प्रेत पत्रक
शब्दकोश तत्व है। क्या यह तुम क्या करने की अनुमति देगा है जब तुम दी रहे हैं
spritename आकर्षित फंक्शन के अंदर, आप कर सकते हैं पुनरावृति के सभी के माध्यम से
प्रेत शीट और प्रत्येक प्रेत पत्रक के लिए, निर्धारित करें कि क्या है या नहीं दिए गए
spritename sprites उस पत्रक के लिए परिभाषित किया गया है में मौजूद है। यह
जब से हम पहले से ही परिभाषित प्रेत शामिल है बहुत सीधा होना चाहिए
समारोह और आप पहले से ही एक सूची है कि एक का नाम भी शामिल है। एक बार drawSprite
फ़ंक्शन इस दिए गए प्रेत है वास्तव में, इसे पारित कर सकते हैं क्या एटलस बाहर आंकड़े
drawSpriteInternal, प्रेत जानकारी, क्या एटलस बंद सौंपने के लिए कि डेटा
उसके आने से, साथ ही स्थिति X और Y से हमें दी थी चादर
drawSprite. Drawspriteinternal वास्तव में भारी उठाने का क्या करना चाहिए
स्थिति के तत्व है, और यह दुनिया का लाभ लेने के लिए, आरेखण
छवि API कि हम बस सब अपने नए फैंसी घंटियाँ और सीटी के साथ कवर किया आकर्षित
पैरामीटर।
これを念頭に置いて次の作業では 解析したデータファイルを
いくつかの画像を表示させるために使います
描画には2種類の関数を使用します
始める前に少し別の事をお話しましょう
グラフィック担当者は非圧縮bsaファイルを参照して アセットを作成しています
テクスチャのようなものを作ってディスクに入れてから
オブジェクトを指定しているのです もちろん後工程があります
全てのオブジェクトを小さな箱に 詰め込んだだけの状態です
非圧縮bsaファイルのままで
大きなテクスチャの隣に置いただけです
関連づけるにはdrawSpriteメソッド使います
これは個々のアセットのファイル名を 引数spritenameに代入して
Canvas上のposXとposY座標に 表示する関数です
アセットファイルの名前を表すspritenameと
Canvas上で描く際の位置情報が必要になります
やり方を説明しましょう ファイルの上部で
個々のスプライトシートを表す グローバルディクショナリを定義します
スプライトシートを読み込む関数ではこのシートを
グローバル列に加えシートの名前を キーとして設定します
もし描画関数でディクショナリ要素の
spritenameが与えられたら それぞれの
スプライトシートの名前がなくても シートを繰り返し利用できます
すでに配列spritesを定義しており
名前も含まれているので難しくありません
drawSprite関数ではスプライトが
アトラス画像のどこに入るかを認識し
__drawSpriteInternal関数へデータを渡します アトラス画像の情報と
drawSpriteからのxとyの位置情報も含まれます
__drawSpriteInternal関数は要素の位置づけを決めて
描画を実行する難しい任務を実行している部分です
前のレッスンでカバーした drawImage APIを利用しています
Com isso em mente, sua próxima tarefa requer que você use o arquivo de dados
que você analisou para renderizar as poucas imagens na tela. Você precisará preencher
as duas funções abaixo para desenhar corretamente imagens na tela. Agora, antes de você
começar, vamos falar sobre uma coisa rápida. Perceba que, até agora,
seus artistas estavam, na verdade, criando objetos referenciando arquivos soltos.
E os artistas criam algum tipo de textura, colocam no disco, e então eles
referenciam um objeto àquela textura. Bem, com certeza, existe um processamento posterior.
Nós temos todos eles amontoados em em uma caixa pequena, e agora temos uma correlação
faltando. O arquivo do artista ainda vai referenciar o objeto solto.
Mas teremos esse objeto colocado ao redor de uma textura maior. Como nós fazemos a conexão
entre os dois? A função "drawSprite" precisa arrumar isso. Ela assume que
será dado um "spritename", que representa o nome do arquivo do objeto solto,
assim como a posição X e a posição Y de onde ela vai renderizá-lo na tela.
Já que estamos dando o "spritename", precisamos também mapear onde esse
"spritename" existe dentro dos atlas que nós carregamos. Agora, para seu
benefício, nós vamos te ajudar com isso. Olhando no topo do arquivo,
nós definimos um objeto dicionário global que representa cada página com objetos gráficos
que já foi carregada. Na função de carregamento para a página de objetos gráficos, vamos adicionar
essa página de objetos gráficos no vetor global, definindo o nome da página como a chave para
o elemento dicionário. O que isso te permitirá fazer é quando você recebe um
"spritename" dentro da função de desenho, você pode passar através de todas as
páginas de objetos gráficos e para cada página de objetos gráficos, determinar se o "spritename" dado existe ou não
nos objetos gráficos que foram definidos para aquela página.
Isso deve ser bem direto, dado que nós já cobrimos a definida
função "sprite" e você já tem a lista que inclui um nome. Uma vez que a função "drawSprite"
descobre em que atlas esse objeto gráfico está,
ela pode passar esses dados para "drawSpriteInternal", entregando a informação do objeto gráfico,
de qual página de atlas ele está vindo, assim como a posição X e Y,
que nos foi dada pelo "drawSprite". "DrawSpriteInternal" deve, na verdade, fazer o trabalho pesado
de posicionar do elemento, e desenhá-lo para o mundo, aproveitando o API
de desenho de imagens que nós acabamos de cobrir, com todos os seus novos parâmetros de sinos extravagantes e
assobios.