Transcrições
1. Apresentação: Seu, meu nome é Isaac
da Chef Games. E hoje,
analisaremos a configuração das configurações de
resolução no
GDoF . Alguns dos recursos que vamos configurar
neste projeto são um
recurso enorme chamado AMD FSR
, usado para dimensionamento de
tela Você vai ouvir,
pois diz
muito isso nesta aula. Se você estiver lançando
um jogo de três D, precisará oferecer suporte a
esse recurso É muito simples de configurar e dará aos
jogadores uma incrível capacidade ganhar mais quadros se
o dispositivo estiver com problemas. Especialmente com o GIDO 4.2, eles adicionaram o SR 2.2, que é uma grande
melhoria em relação ao FSR Também criaremos
muitas ferramentas neste vídeo. Começaremos com um seletor de opções de
resolução, que nos permitirá alterar
a resolução dentro do jogo E depois disso, vamos configurar
um seletor para tela cheia. Analisaremos o dimensionamento da tela. esse é um recurso muito
importante para Atualmente, esse é um recurso muito
importante para
incluir em um jogo
tridimensional
e, em seguida, faremos o VSync
e a troca de tela Um pequeno ponto para este tutorial, Gudo 4.2 ou superior O FSR 2.2 está disponível apenas
para GiDO 4.2 e superior. Portanto, se você for uma
versão mais antiga do seu jogo, talvez seja necessário
considerar a atualização ou simplesmente fazer isso em
um projeto separado Com tudo isso
dito, vamos entrar no assunto.
2. Por que você deve implementar o FSR em seu jogo: Planejando lançar
um jogo, usando o motor de jogo GI Do, você absolutamente
precisa ter certeza de que está configurando suas opções de
resolução corretamente Muita coisa mudou
desde que lancei minha série de tutoriais no
ano passado para o GiDO 3.5. Já se foram os dias
em que você precisava arruinar sua interface para dar aos jogadores quadros
extras, se precisassem ou aumentar o tamanho para escalar seu jogo com
a visualização e, ao mesmo tempo, manter
a interface em uma camada separada Tornou-se substancialmente
mais simples. Mas, infelizmente, com
todas essas ferramentas incríveis, esses vídeos antigos não são realmente aplicáveis.
Tudo mudou. Outro grande recurso
lançado com o G D 4.2 é o AMD FSR 2.2 Para escalar, isso
é um cara enorme. Eles
criarão uma tonelada de ferramentas neste vídeo.
Vamos começar.
3. Seletor de resolução: Então, vamos dar uma olhada
no projeto, como ele surge. Temos uma luz direcional, ambiente de
solda e uma câmera Está apenas
flutuando nessa cena, para a
qual deixarei um link e créditos abaixo. As configurações do projeto em si devem ser
bem lixadas. A largura e a altura da janela de visualização devem corresponder ao que
normalmente vem no Gadot Eu posso ver que
tenho o V sync aqui,
mas na verdade vou desativá-lo
para que meu projeto corresponda exatamente
como você deveria ver o seu. Além disso, deixe um link
para este projeto na
descrição para que você possa baixá-lo e
acompanhar as imagens Ok, vamos começar a
adicionar nós de controle. Vou adicionar meu
primeiro nó de controle. Vou chamá-lo de algo
como exemplo de opções. Não há nada extravagante aqui. Vou
clicar nas redefinições da âncora e clicar em Full Ok, então eu vou
adicionar um HBox. Mais uma vez,
vou usar essa
âncora para clicar em Full Rec Vou clicar e criar o centro de alinhamento
desse contêiner HBox E então eu vou
adicionar uma caixa V. Vocês não precisam
seguir isso exatamente. É assim
que eu gosto de configurar meus menus para que eles apareçam
no meio da tela. E vou renomear isso para se
chamar Configurações de opções. Ok, então vamos adicionar nosso
primeiro botão aqui. Vai ser
um botão de opções. Essas são pequenas caixas
suspensas que podemos adicionar. Vou voltar para a configuração da opção e adicionar um script. Vou apenas chamar a
configuração da opção e salvá-la diretamente na base deste
projeto. Isso é bom para mim. Vou excluir a função
do processo. Não seremos a primeira
coisa que vou fazer é adicionar esse botão
Opções. Você pode clicar aqui
e segurar a tecla Control. E quando você o soltar, ele
adicionará um r pronto para você. A próxima coisa que
vou fazer é colar uma lista de resoluções
para que possamos selecionar Achei que seria um
pouco mais fácil do que digitar
isso para você Você pode copiar alguns
deles. Não precisa ser
uma lista exaustiva. A minha é apenas um conjunto de resoluções
comuns. Então, a primeira função que
vamos escrever será chamada de Ad
nas resoluções de Scott, e vamos adicionar
esse dicionário ao nosso botão de opção Então, vamos
criar um loop de quatro, então vamos digitar quatro
R em resoluções E nisso,
digitaremos o botão Opções. Na verdade, vou
renomear essa variável porque acho que pode ficar um pouco claro
o que ela é Vou
renomeá-lo para o botão de opção de
sublinhado de resolução opção de
sublinhado E eu vou até
aqui e vou digitar a
opção de resolução por ponto e item, e será apenas R. Isso é tudo
que existe A única coisa que teremos que
lembrar de fazer é realmente adicionar isso
à função ready. Você pode ver aqui que eu
esqueci de verificar isso. Então, a única coisa
que acho que também vou fazer é mudar o alinhamento
do meu contêiner de caixa, para que
meu contêiner VBox também
fique no centro Então isso aparece no meio. E então adicionarei isso
à função ready para que
possamos realmente ver a
lista ser preenchida Como você pode ver agora,
haverá uma lista de resoluções. Obviamente, eles
não fazem nada, então podemos adicionar essa
funcionalidade. Teremos que
voltar ao projeto e clicar no nó do botão de
opção e clicar no nó e conectar o item de sinal
selecionado ao nosso script. Eu tenho muitos nós
aqui para o projeto. Vou apenas
esconder tudo isso e descer até o
nó de configuração de opções e
clicar nele. Tudo bem Portanto, esse sinal nos
fornece um índice que podemos realmente usar para pesquisar
o dicionário de resolução. Portanto, go, o ID é igual à opção de
resolução no texto do
item G,
que na verdade é o que
precisamos para o dicionário que na verdade é o que
precisamos para E podemos pesquisar com o índice e, uma vez que
temos o índice, podemos realmente consultar
a resolução. Vou ligar para get
window dot set size. E dentro dessa função, vou digitar resoluções,
colchetes, e vou passar o
ID que acabamos E isso é tudo que precisamos. executar isso agora e podemos
começar a ver esse trabalho. E, como você pode ver,
estamos mudando o tamanho da janela e é
incrível. Você notará que a
janela salta muito, principalmente porque
tenho certeza de que ela é redimensionada do canto superior
esquerdo Então, em vez do
centro, Gdo 3.5, havia uma função
que permitia fazer isso com
relativa facilidade, mas isso desapareceu no Gudo quatro Então, uma das coisas que
precisamos fazer é ocupar toda
a área
do desktop virtual para atribuir
a posição correta. Então, eu tenho uma configuração padrão de
duas telas, mas você pode ter
algo diferente. Para definir a posição das
janelas, precisamos levar em consideração toda a área
da área de trabalho. Então, começando do arquivo da
esquerda para a extrema direita, eu precisaria considerar
duas telas aqui. É por isso que precisamos
fazer isso dessa maneira. Hum, eu testei isso em algumas configurações
diferentes. Ainda tenho apenas duas telas, mas testei isso desconectando uma ou
movendo sua posição na da área de trabalho virtual só para ver como essa E até agora, eu vi
isso funcionar muito bem. Primeiro, precisamos obter o centro da tela em que
estamos atualmente,
que será a tela de pontos do
servidor de exibição Obter posição,
mais a tela de pontos do servidor de exibição
Obter tamanho dividido por dois. E esse será o ponto central
exato na tela em que a
janela está ativada atualmente. E agora precisamos saber
o tamanho da janela. Vai ser Get window dot, Get size with decorations. Também pode ser apenas um tamanho, mas não estará
exatamente no centro. Isso realmente não importa.
Você pode usar qualquer um deles. A última função
que chamaremos é Get window dot set position. E dentro dessa
função, passaremos na tela central menos o tamanho da
janela dividido por dois E esse será o centro
da tela atual onde
queremos que nossa janela esteja. E por último, mas não menos importante, precisamos nos lembrar de colocar isso onde queremos que a
janela seja centralizada Então, depois de selecionarmos
uma nova resolução, vamos
centralizar a tela. Ok, então vamos ver
isso em ação. E você pode ver agora que isso está se comportando da maneira
que queremos Está aparecendo no
centro da tela. Não importa o tamanho que fabricamos, há um
pouco de cintilação Isso é bem normal. Acho que a maioria das pessoas poderia
perdoá-lo por isso. Isso facilita
muito as coisas quando você está
tentando, por exemplo, redimensionar o jogo para atender às suas necessidades
específicas. Ok. Tudo bem, ótimo. Estamos nos
dando bem
4. Adicione um Butão de tela cheia: Acho que o próximo passo
neste ponto é provavelmente nos levar ao modo
de tela cheia, porque agora podemos selecionar as diferentes resoluções quando
estamos no modo de janela, que é muito conveniente,
mas não temos nada para nos
colocar no modo de tela cheia Então, vamos adicionar isso. Clicaremos no botão
Adicionar nó e adicionaremos uma caixa de seleção Vou renomear
essa caixa de seleção. Vou apenas manter a parte da
caixa de seleção e adicionar um sublinhado em tela
cheia
no início para que
saibamos o que é E também farei o mesmo com meu botão de
resolução porque não
fiz isso. Então, vou fazer isso agora e também precisarei renomear caminho
do nó para a variável que colocamos no script E você também pode simplesmente
clicar e arrastá-lo. E então eu vou
fazer a mesma coisa. Vou controlar o
clique e arrastar próxima variável para que
tenhamos um caminho completo até ela. Entraremos nessa caixa de seleção em tela
cheia e adicionarei um texto
para que saibamos o que é Então, vou digitar o texto
em tela cheia aqui e vou conectar o
sinal alternado ao nosso script Ok, então isso é bem
simples. Em comparação com Gadot Three, costumava
haver apenas duas opções, que eram em janela
e em tela cheia Na verdade, temos
quatro agora, então não
podemos simplesmente transmitir
essa variável. Provavelmente poderíamos fazer algo um pouco mais
complicado com isso, mas vou
manter isso simples. Então, se estiver ativado, vou configurar a janela
para o modo de tela cheia E então vamos ver
isso em ação aqui. Vou digitar Get window
dot set Mode e colocarei o modo lá. Você pode vê-los
aparecer automaticamente , mas se não
aparecerem para
você, basta digitar capitalwwindow
dot mode em tela cheia E então eu coloco um e, e eu vou dizer
exatamente a mesma coisa. Na verdade, vou
copiá-lo e mudar esse modo tela
cheia para o modo de janela Como você pode ver,
temos algumas outras opções,
minimizadas, maximizadas,
todos esses tipos Provavelmente coisas
que você não precisa se estiver criando um jogo, mas nunca
sabe de verdade. Eu sei que o Gudo
se tornou muito mais popular para criar
aplicativos, é provavelmente por isso
que
essas opções existem, o que é bom ter, mas
não precisamos delas agora, vamos apenas fazer
algo simples como isso Ok, então isso deve
funcionar. Sem problemas. Vamos comandar a cena aqui. Bem, vamos marcar isso. E podemos ver que estamos em tela cheia. E como um exemplo rápido agora, você pode ver que a caixa
suspensa não funciona mais. Vamos
abordar isso em breve. Mas, como você pode ver, fora
do modo de tela cheia, não
temos
problemas e podemos clicar para entrar no modo de tela
cheia. O texto não se substitui. Há algumas coisas que
precisamos aperfeiçoar. Mas, por enquanto, você sabe, as coisas
estão funcionando muito bem. A única coisa que
precisaremos acrescentar aqui é que, se você
tirá-lo do modo de tela cheia, ele voltará para a
posição para a qual você o moveu. Isso pode ser algo
que você queira, mas vou adicionar a função centralizada depois de
voltarmos ao modo Janela, para que possamos mover a janela
para uma posição aleatória Mas se colocarmos em tela cheia
e depois abrirmos a tela,
ela voltará ao centro.
Sou só eu. Você não precisa fazer isso.
5. Polindo a interface do usuário: Ok, as coisas parecem muito boas. vou criar uma função Agora vou criar uma função que ajuda a monitorar variáveis que podem ou
não estar definidas como verdadeiras ou falsas, dependendo de como você
configura sua cena, e você não
quer se
preocupar em garantir que as coisas estejam marcadas, como uma
caixa de seleção em tela cheia ao executar o jogo Então, vou criar uma
função chamada verificar variáveis. Eu vou ter
acesso à janela. Porque vamos precisar muito
disso para este. Também vou ter
acesso ao modo, que é algo que
acabamos de definir antes. Então, vou sublinhar o modo Obter pontos
da janela. E vamos apenas consultar
aqui que o modo I é igual ao modo
Window dot em tela cheia, vamos definir essa caixa de seleção para ser ativada
sem Assim, podemos dizer que a
caixa de seleção em tela cheia está pressionada, sem sinal, e vamos
simplesmente digitar Ok, agora, se
entrarmos aqui e configurarmos que ele comece
em tela cheia, que é um
parâmetro bastante comum quando executamos o jogo, podemos ver que essa
caixa de seleção estará marcada. Na verdade, não acontecerá
porque esqueci novamente adicionar essa função
a uma função pronta Então, vou voltar
aqui e adicioná-la
à função pronta, e
rodaremos o jogo. Ok, legal. Uma coisa que
acho que devemos fazer é quando iniciamos o jogo e
adicionamos as resoluções, se a janela estiver configurada para
um tamanho nessa lista, ela deverá ser selecionada
para começar Então, o que podemos fazer
é criar uma variável aqui chamada resolução
atual e consultar o
tamanho da janela. Então, vamos pegar a
janela dot Get SIE. E isso retorna um vetor dois I, que podemos usar
para comparar com essas resoluções à medida
que as examinamos E também precisaremos criar um ID para
acompanhá-los,
que é um
parâmetro opcional da função
do item do anúncio
no botão de opção. Então vamos lá, Var ID é igual a zero. Em seguida, desceremos até a opção de
resolução,
botão, ponto, adição de item, e adicionaremos esse
segundo ID de parâmetro. Ok, então, enquanto
examinamos as resoluções, verificaremos se a resolução atual
corresponde
a uma delas Então, vou digitar as resoluções I, o
colchete R é igual à resolução atual Em seguida, selecionarei essa opção
em nosso botão de opção. Vou digitar o botão de seleção de pontos da
opção de resolução e passarei o ID. E então precisaremos
lembrar de incrementar esse ID. E agora, você verá
que foi selecionado 1920 por 1080 para iniciar o jogo Então, outra coisa com a qual
eu estava lutando
quando estava trabalhando nisso é que o rótulo às vezes não é atualizado quando você
está em tela cheia. Mesmo que eu tenha o
botão de opção para selecionar uma opção, ele simplesmente será lido em voz
alta como se fosse uma opção errada e não funcionaria. Obviamente, quando você vai
para o modo de tela cheia, deseja ir para o modo de tela
cheia, não
deseja selecionar
uma opção
de resolução nessa lista suspensa de Jon.
Isso não vai funcionar. Então, precisamos de uma
função para substituir esse rótulo. Vou usar isso como
uma forma de
dizer às pessoas qual é a
resolução. Então, podemos realmente definir o texto diretamente nesse botão de opção, e ele simplesmente
aparecerá lá. E, você sabe, se eles estão caindo e
é diferente, não
é a pior
coisa do mundo Então, vamos apenas fazer
isso. E acho que isso funcionará muito melhor
para a maioria dos aplicativos. Ok, então a próxima
função que queremos adicionar é uma
pequena função auxiliar nos ajudar
a definir o texto
em nossa caixa suspensa
quando estamos nos movendo entre o modo de
tela cheia e o modo de janela Então, vai se
chamar Definir texto de resolução, e vamos criar uma variável chamada Texto de
resolução, e vamos torná-la igual a, e será um log um. Vai ser STR para string, que é a função
que usamos para strings agora Inga Do four, e vai ser redonda, e vai ser Get
window dot Get size, e
vamos apenas obter o X do tamanho da Obtenha window dogtsiz dot X. Copie esse trecho de código
para que possamos usá-lo Vamos adicionar X, e vamos usar a
string getwindow dotgtz dot y. Ok.
E depois disso, vamos definir o
texto dos botões da opção de resolução para ter essa resolução. Dessa forma, quando
entrarmos no modo de tela cheia, podemos simplesmente definir esse texto. Na verdade
, não será selecionado
e, na verdade, vamos desativá-lo em breve,
eu acho, quando estivermos
no modo de tela cheia. Mas falaremos mais sobre isso
daqui a pouco. Ok, agora
podemos chamar essa função quando
entrarmos no modo de tela cheia. Vou copiar isso e vamos para modo de tela
cheia.
Eu estarei aqui. Vou executar isso. E algo você notará
é que nem sempre funciona. É como um número diferente. E eu acho que a janela está em processo de redimensionamento quando eu estou chamando essa função Então, o que vou fazer
é criar um cronômetro,
um cronômetro muito curto Vou digitar Get tree,
dot create Tr. E será muito curto,
tipo 0,05 segundos. E vou conectar a função de
tempo limite aqui. Vou expirar o tempo limite do dot Connect e colocar o nome
dessa função. Dessa forma, há
um pouco de atraso para que a
janela tenha tempo de redimensionar E descobri que funcionou muito bem. Então, vamos executar isso novamente. E você pode ver agora que está funcionando exatamente como eu
quero. Provavelmente estamos melhor. Veja, agora o texto está configurado para isso e, na verdade, tem
um tamanho diferente. Portanto, é melhor colocar isso em vez apenas na opção de
tela cheia simplesmente colocá-la na parte inferior da função, onde vamos entre tela cheia
e janela Então, a seguir, moverei
o tempo de criação do ponto da árvore
Gt para a parte inferior desta
função para que ela seja
atualizada após ser chamada e a resolução
esteja correta. Ok, agora podemos ver que
ele está começando a escolher um rótulo de resolução
que está realmente correto quando minimizamos quando vamos entre
tela cheia e janela, o que é muito melhor Você pode ver o
atraso entre o momento em que você vai para a tela
cheia e a janela em que o texto é
atualizado posteriormente Mas, você sabe, isso funciona. Não vamos nos preocupar
muito com isso. A funcionalidade
está aí. O rótulo faz sentido para o usuário. que precisamos substituir Acho que precisamos substituir
o texto por qualquer
motivo, só porque a janela é
redimensionada mais lentamente do que a chamada
da função
6. Resolução de tela cheia: a maneira moderna: Ok, então a próxima coisa que você vai
notar é que,
obviamente, vou
para a tela cheia e não consigo redimensionar a janela Agora, antigamente, quando eu era criança, quando você mudava a resolução, toda
a resolução
da tela mudava Não é mais assim.
Não precisamos fazer isso. Atualmente, com a forma como
configuramos o projeto, a tela cheia
corresponderá
automaticamente à resolução
da tela em que estamos. Portanto, não precisamos realmente adicionar suporte para a resolução
da tela do usuário. Desde que configuremos nossa interface de usuário corretamente, isso será
suportado. E acho que isso é
principalmente falar em três D. É um pouco diferente porque, por exemplo, a forma como você configurou o
jogo pode precisar
ter uma resolução definida, especialmente se você estiver
trabalhando com Px Lt. Essa é uma conversa diferente Mas para três D, você
realmente quer manter o modo stretch desativado
e mantido, a menos que, você sabe, talvez esteja fazendo algo muito
específico, como um PS one ou uma aparência no estilo Nintendo
64. Mas se você está apenas criando
um jogo normal de três D, modo
stretch, desabilitar e
manter é a melhor opção, e mostrarei como você
pode reduzir a resolução da sua janela de visualização sem
afetar a interface, como era, você
sabe, há dez anos Quero dizer, até hoje
alguns jogos ainda fazem isso, mas na verdade não é necessário. Podemos contornar isso,
torná-los realmente bons. E, honestamente, é como
duas linhas de código. Então, vamos adicionar
um controle deslizante à cena. Vou até o botão de adição. Vou apenas clicar na
configuração da opção para que ela seja
adicionada ao lugar certo. Vou digitar slider.
Queremos um slide horizontal. Obviamente, pode
ser um slide vertical, pode ser uma caixa suspensa. Pode ser um monte de
coisas diferentes, mas vou transformá-lo em
um slide. Vou
arrastá-lo acima da caixa de seleção de
tela cheia só porque acho que
parece melhor Faz mais sentido
estar perto da
caixa de opções de resolução que acabamos de inserir. Ok, então vamos adicionar um
texto para acompanhar isso. Então, vou adicionar um HBox que eles
fiquem bem alinhados Vou colocar o controle deslizante no HBox e renomear esse
HBox para algo
como caixa de escala, apenas para
que tenha um bom Então, vamos configurar os valores
máximos mínimos neste slide. O valor mínimo será 50 e o valor
máximo será 200. Eu vou dar o passo cinco. Agora, o
valor máximo mínimo precisa ser 5.200. Você não pode escalar nada
além disso em Gadot, então não adianta
aumentá-lo Só vai usar
como padrão esse limite
superior, limite inferior. E sim,
temos cinco etapas só porque é um pouco
melhor quando você está deslizando, e queremos que elas
fiquem marcadas nas bordas Ok, então para o layout, para fazer isso funcionar
dentro de uma caixa H, teremos que ter
um tamanho mínimo personalizado. E isso está em pixels, então
vou fazer o meu 100 e talvez até 200, que
fique um pouco mais largo,
então é melhor jogar com ele do que fazer com
que o HBox
o reduza para um
tamanho pequeno por qualquer motivo Ok, vou
fazer com que o valor seja 100. Esse é o
valor inicial. Isso faz sentido porque começamos
em alta escala. Vou renomear este slide para
chamá-lo de scale sliner. E a próxima coisa que
precisamos fazer é adicionar um pouco de texto para
sabermos qual é a escala. Vamos clicar no
pequeno botão de adição aqui. Vou apenas digitar uma etiqueta. Vamos adicionar uma etiqueta,
digitar 100% e colocar um traço lá, e será apenas 1920 por 1080 Vamos definir isso por código. Ele está lá apenas para que a
interface tenha a aparência que está e nós a deixemos com uma boa aparência. Vou dar
um nome a esse rótulo porque precisaremos
resgatá-lo com frequência. Vamos chamá-lo de rótulo de escala. E vamos
atualizar isso toda
vez que mudarmos o controle deslizante Ok, então o sinal
que queremos conectar é o sinal de mudança de
valor. E isso vai
ser muito fácil. A funcionalidade será muito fácil de configurar e adicionaremos algumas
coisas de interface de usuário para que tenha uma boa aparência. Então, se o
valor do controle deslizante de escala for alterado, obteremos a escala de resolução Precisa ser um valor percentual. Então, vamos
realmente pegar o valor
do nosso controle deslizante e
dividi-lo por 100 Você poderia, é claro,
configurar seu controle deslizante para ser pontos decimais, e
isso também seria bom Mas eu não fiz isso. Portanto, certifique-se de que seja um carro alegórico. Descobri que, com
o que eu faço nas próximas partes deste
vídeo, isso simplesmente funciona melhor. Então, criaremos uma variável para
atualizar o texto da resolução. Na verdade, vou voltar
para a função de resolução de texto e pegar exatamente a mesma coisa. Precisaremos adicionar
algumas coisas aqui. No entanto,
precisaremos multiplicá-lo pela escala de resolução, porque é essencialmente
isso
que estamos fazendo Então, farei isso
tanto no X quanto no Y. E também precisaremos arredondar isso porque teremos mais
uma dúzia de lugares e
realmente não queremos isso para nossa interface Vou arredondar isso para que
obtenhamos apenas números inteiros e
pareça mais legível Não será tão
preciso, mas não será grande coisa. Então, precisaremos ter
acesso a essa etiqueta de escala. Vou arrastar e soltar isso até
o topo para que possamos tê-lo. E eu também vou precisar do slide. Vou arrastar isso para limpar um pouco
essa bagunça. Então, vou digitar o texto do conjunto de
pontos escalável, e o texto será uma string
e será o valor, que estará em qualquer lugar Que é isso aí.
Em seguida, adicionarei o sinal
de porcentagem, um traço e um espaço
e, em seguida, adicionarei
o texto da resolução, que configuramos antes Então, o controle deslizante exibirá a resolução e o
valor da escala E então tudo o que precisamos é obter conjunto de pontos da janela
de
visualização em
uma escala de três d, e ela flutuará e
passaremos a escala de resolução, que definimos logo no
início dessa função E isso é tudo que você precisa fazer. Podemos executar isso agora e você pode começar a ver isso em ação. Curiosamente,
achei um pouco difícil ver esse
modelo específico que temos Você pode começar a ver
as bordas recortadas e coisas assim
na escala de 50%, 960 por 4540, que é a
resolução real do visor E, como você pode ver, isso
não afeta a interface do usuário, que é simplesmente incrível. Isso é muito, muito bom se você estiver executando em tela
cheia por três dias. Você não precisa ter
um menu suspenso, como vimos nos vídeos
anteriores. Vou
voltar ao script e desabilitar esse botão de opção de
resolução quando estivermos no modo de tela cheia. Portanto, se você estiver no modo de tela
cheia, isso não poderá ser
alterado; em vez disso, você precisará usar o controle deslizante
para alterar sua resolução Então, eu vou aparecer e também
vou verificar isso no modo I em tela cheia, e vou configurá-lo como verdadeiro Dessa forma, não
vamos
confundir as pessoas quando
elas estiverem trabalhando com isso Se estiverem no
modo Janela, poderão usá-lo para definir rapidamente a resolução
que desejarem Se você estiver no
modo de tela cheia, queremos que você use isso.
7. Como adicionar FSR ao seu projeto: A próxima coisa importante
que queremos adicionar é escolher o
escalar que queremos Gadot tem escala bilinear,
que você viu antes, que
é E você também tem
a opção de adicionar AMD FSR 2.2, 1.1 Como todos esses outros escalares, vamos adicionar
ao AMD FSR É um escalar de código aberto
semelhante ao DLSS. Coisas muito poderosas.
Parece incrível. Você vai
ver isso em um segundo. Se você está criando um Gdo para jogos em
três D, você absolutamente precisa
colocar isso em seu jogo Então, vamos criar
um botão de opção. Vou chamar isso de escalar. E, ao contrário do outro
que
definimos com código, na verdade teremos que
fazer esse talvez possamos fazer isso com código. Eu não sei. Isso não importa. Portanto, o primeiro item será chamado apenas
de escalar. Vou configurar isso para
desativá-lo e o separador. E, na verdade, na caixa
selecionada aqui, vou definir isso como zero, que é a opção para escalar Então, isso só será definido
quando o jogo começar, e o outro
será chamado de bilinear, e eu adicionarei um elemento
aqui e ele será chamado AMD FSR OK. E eles
serão apenas os IDs um e dois. Conectaremos o item
de sinal selecionado. E para este,
vamos apenas igualar o índice. Sabemos que existem
apenas dois,
então vai ser
bom e simples. Vou digitar match index e a função é
muito simples Para começar
, obteremos uma cópia
da janela de visualização, apenas para tornar as coisas
um pouco mais organizadas, e eu digitarei o conjunto de pontos da janela de
visualização sublinhado escalando E você pode ver agora que eu
tenho algumas opções
para escolher, e elas desapareceram em mim. Ok, mas podemos vincular a escala de
pontos da janela de visualização a três FSR
no modo D, bilinear Apenas certifique-se de
selecionar a opção certa para a opção certa. Então, o número um para
mim é bilinear. Então, se eu estiver atingindo
um no índice, é para
isso que eu
quero configurá-lo E por baixo disso, vou
transformar dois na próxima condição, e vamos fazer exatamente o
mesmo trecho de código, mas vamos
mudá-lo para AMD FSR Ok, agora
podemos rodar o jogo. Você pode ver que agora é possível
reduzi-lo para 50% no AMD FSR Você pode ver imediatamente a diferença
entre esses dois O AMD FSI parece muito
melhor do que o bilinear. E há alguns
artefatos aqui e ali. Você pode ver isso quando
o bonde chega. Há alguns artefatos estranhos, especialmente se você estiver olhando onde estão as lanternas
ou se ele passa por Mas, além
disso, é ótimo. Parece muito bom. Eu posso ver que houve uma grande queda de quadro quando
virei esta esquina
com a câmera, e eu não sei se isso é por causa da cena
ou por causa do FSR Não tenho muita certeza. Honestamente,
reduzi para 50% e funcionou muito bem Outra coisa é que,
se você estiver usando o AMD FSR, os documentos dizem que
você deve
bloqueá-lo em quatro opções específicas Vamos configurá-los agora. Acho que é por isso que eu
estava recebendo quedas de quadros porque não estava escolhendo
uma dessas três opções. Você pode ver que
tem uma qualidade de
altíssima qualidade equilibrada em desempenho. Então, essas são as opções para
as quais você precisa configurá-lo. Então, o que precisamos
fazer é que, se alguém escolher o escalar AMD FSR, precisamos bloquear esse controle deslizante e apenas introduzir uma caixa
suspensa para essas opções Então, vou criar
um botão de opção. Vou colocá-lo
abaixo do escalar
e vou colocar as opções de FSR A razão pela qual não
queremos fazer isso com
o bilinear é porque você pode
superescalar com Portanto, você pode
dobrar a resolução, mas não com
o AMD FSR Então,
exatamente como antes, vamos criar
um botão de opção. Vamos criar
vários itens para isso. Vamos criar o primeiro, vamos torná-lo opções de FSR, separador
desativado, definiremos o item
selecionado como número zero Então, isso é selecionado na
inicialização ,
vamos digitá-los. Temos desempenho. Temos um equilíbrio. Temos qualidade e
temos qualidade ultra. E você pode ver que eu fico um
pouco confusa sobre
onde colocá-los. Foi uma gravação longa.
É meu primeiro dia de
volta do feriado, pessoal. Na verdade, não é.
Desempenho balanceado, qualidade
de alta qualidade Eu fiquei muito confuso.
Equilíbrio do equilíbrio. Sim, temos dois lá, mano. Apenas jogue esse aí. Ok, bom. Ok, então esses
são os quatro que você quer. Então, vamos fazer com que
isso só apareça quando estivermos usando
as opções de FSR Então, vou
criar uma variável lá muito rapidamente, basta
clicar e arrastá-la. E quando escolhemos o escalar FSR entre
as opções escalares, vamos
torná-lo visível Então, vamos usar fsroptions dot show, e faremos exatamente o oposto
quando escolhermos bilinear, vamos
esconder essas opções porque não precisamos Vamos fazer isso para que você
possa ver como fica. Quando escolhermos o bilinear, veremos as opções de FSI
e todas essas E você pode ver esse quadro
lutando com 100% de FSI. Não deveria
ser feito dessa forma, então é por isso que precisamos
introduzir essas opções. A outra coisa que
vamos fazer é que o controle deslizante de escala tornará isso editável somente
no modo bilinear Então, temos o controle deslizante de escala. A função que
precisamos usar é chamada de set editable É exclusivo para guardas florestais, por algum motivo.
Eu não sei por quê. Conjunto de pontos deslizantes de escala
editável verdadeiro para bilinear e falso para FSR.
Não queremos usá-lo. OK. Então, vamos ver
como isso funciona. Podemos usar o escalar. Se formos para a FSR, não podemos. Ótimo. É exatamente
assim que queremos que pareça. OK. Selecione conectar o
sinal para essas opções de FSR Conectaremos o item selecionado ao script
logo abaixo deste. E faremos
exatamente a mesma coisa. Vamos apenas criar um índice de correspondência. Vou
copiar que sou preguiçoso, e desta vez será de 1 a 4 Vou digitar pass aqui só para poder
digitar os números. E, convenientemente,
já temos algo que define a escala. Então, eu
vou usar isso. Então, na alteração do
valor do controle deslizante escalar, essa é a função
criada
a partir do sinal que
conectamos ao Podemos simplesmente reciclar isso e repassar o
valor que queremos E eu vou copiar isso. Certifique-se de que seja um carro alegórico.
O próximo será 59. O próximo será 67. E o último será 77. Então, esses são os quatro
valores que a AMD recomenda, e vamos nos ater a eles. Portanto, certifique-se de que eles
correspondam à documentação. Ok, vamos executar isso agora. Ok, escolheremos o AMD FSR e escolheremos o desempenho Tudo bem. E
isso caiu para 50%. Você pode ver que as molduras
voltam ao normal e funcionam bem. Tem
altíssima qualidade. Parece ótimo. Estou realmente impressionado com
a aparência e, sim, você pode ver a melhoria
entre o equilíbrio e o
desempenho e tudo Definitivamente, você pode ver isso quando se trata de altíssima qualidade. Para mim, pessoalmente, acho que
é indistinguível de,
tipo, uma pessoa 100% bilinear. Ainda tenho aquela moldura ao
virar da esquina. Não sei se acho que isso é
específico desse projeto. Essa malha é algo que acabei
de baixar da Internet. Não sei se está
bem otimizado. Então, vamos dar uma olhada no FPS, e você pode ver que
é uma grande queda quando eu viro aquela esquina Eu não sei. Isso é
tudo que vou dizer. Também vou
salientar que parece
muito pior do que a
gravação porque também
estou usando minha GPU para
gravar Então, acho que, à medida que está
ficando mais cansativo para a gravação de Gadot
executar esse projeto, também
estou diminuindo
os frames Então, não parece tão ruim.
8. Adicionar V Sync: A próxima coisa que
vamos fazer é adicionar V sync para que
tenhamos essa opção. Vai importar quando se
trata de escalabilidade e de todas essas coisas de FPS a
que se relaciona,
especialmente se eu Portanto, talvez seja principalmente uma ferramenta de
demonstração neste momento. Mas vou adicionar um
rótulo que mostre a FBS. Então, isso é muito fácil. Então
você não precisa fazer isso. Isso é só para que vocês
possam ver enquanto eu
rodo o jogo o tipo de FBS que
estamos vendo na tela Então, eu deixei de rotular aqui. Vou chamá-lo de FPS. Eu vou para uma posição
arbitrária, o
que é bom E vou adicionar um script a isso para que
possamos definir o FPS. É só uma única linha. E na
função de processo aqui, vou apenas chamar set text. E a função exata
que queremos usar é engine dot Get frames per
second. E é isso. Ele exibirá apenas os
quadros por segundo. Certifique-se de envolver isso
em uma função de string. E feche o suporte
e estaremos prontos para andar. É tudo o que você precisa
para um contador de quadros, aqui está um
pequeno
tutorial bônus. E você pode ver
lá, diz 59, o que é bastante preciso. Tudo bem. E se escalarmos tudo duas
vezes, ele ainda está funcionando em 59. Se colocarmos o AMD FSR, mudamos o escalador e
todo esse tipo de coisa Ao virarmos a esquina aqui, podemos ver as molduras caírem, todo esse tipo de coisa boa. Só estou tentando ver
se está relacionado ao AMD FSR, porque toda vez que
venho por
aqui , nós voltamos E você pode ver que
realmente funcionou muito bem. Então eu não sei. Talvez tenha algo
a ver com a AMD. Com 50%, funciona bem. Esse bonde é basicamente um
câncer para as armações. D. Ok, então vamos adicionar um
pouco de sincronização V a isso. Será apenas
outro botão de alternância, caixa de
seleção, devo dizer,
outro botão de caixa Então, vamos adicionar essa caixa de seleção. Vamos garantir que haja,
você sabe, a caixa V aqui, e eu vou renomeá-la para a caixa de seleção Vsc stink Stink V sync, caixa de seleção
V sync, e vou digitar sincronização
V ativada no Ok, então nas opções alternadas, conectaremos isso ao nosso script de configuração de
opções E, na verdade, você tem
quatro opções para o V sync, mas vou definir
essa opção para ser ativada ou desativada Então, eu vou dizer que eu ativei, vamos digitar o
ponto do servidor de exibição Window set V sync mode E você pode ver essas
opções aqui: você tem adaptativo desativado
ativado e a caixa de correio Vamos apenas usar
ativado e desativado por enquanto. Mas você pode expor uma caixa suspensa ou
algo assim para seus usuários, mas eles precisam entender
quais são essas opções Eu acho que é melhor apenas
ligar ou desligar, mas você pode
fazer o que quiser. Ok, então temos o V sync e , obviamente,
o resto está desativado. Queremos voltar à função de variáveis
verificadas
que configuramos no início. E também queremos verificar
se o Vsyncmde está habilitado. Assim, podemos digitar I display
server dot Get Vsync mode é igual ao ponto do
servidor de exibição VsncEnable E então podemos simplesmente definir
essa caixa de seleção para ser ativada. Certifique-se de que incluímos
essa variável que
possamos arrastá-la e
soltá-la lá em cima. Então, podemos ir para Vsncheckbox dot set Pres Nenhum sinal
é Ok, é muito bom e fácil. Vamos rodar o jogo. ver que está marcado e
eu vou desmarcá-lo, e você pode ver os
quadros subirem para Você pode
ver que está marcado e
eu vou desmarcá-lo,
e você pode ver os
quadros subirem para
161. Vou dobrar a escala. Você pode ver que eles
caem para 105, e eu vou cair para 50%, e você pode ver eles pularem.
Eles não mudam em nada. Na verdade, eu não
sei sobre isso. Definitivamente, há algo
acontecendo com essa malha. Realmente não parece se importar com a escala que eu tenho. Ele ainda funciona praticamente com o mesmo AMD FSR, mesmo tipo de acordo Começa alto em 300, mas cai para 69. Eu não sei. Na verdade não
sei o que está
acontecendo com essa malha, mas você pode ver as diferenças que
parecem acontecer aqui. Vamos voltar para o VSink
e voltar para 59 quadros, e então ele aparece
quando você
desmarca para 161, mas depois E realmente virou aquela
esquina novamente. Seja. Sim, está em todo lugar, mas ainda assim é muito legal. Definitivamente, acho que
você precisa adicionar essas opções a qualquer
jogo que esteja enviando. É um toque muito bom tê-los disponíveis
para seus usuários.
9. Limpeza: Uma coisa que você
notará que é possível
fazer com essa configuração atual é colocá-la no modo janela, reduzi-la para 800 por 600, que é
praticamente a menor você criaria em qualquer tipo de tela
ao jogar um jogo, e então você também pode
reduzir a escala em 50% Portanto, você pode obter uma resolução muito
pequena aqui. Quero dizer, se alguém tem uma batata para um computador,
então talvez seja possível. Talvez você queira isso.
Você pode não querer isso. Você também pode desativá-lo. Você pode desativar o escalador
quando estiver no modo Janela. Depende totalmente de você
as funções lá. Você sabe o que fazer. Ok, então uma coisa que você deve
ter notado é que quando estamos mudando do modo de tela
cheia para o modo de janela, não
estamos atualizando o
controle deslizante e não estamos atualizando o rótulo de
resolução aqui, é um pouco
confuso de ver Agora, acho que a escala ainda
está precisa. Então, se formos para a tela cheia, ainda
estamos em 50%, você ainda pode ver
os recortes ao longo das bordas Mas o texto real da
resolução da escala está errado. Agora, o que eu acho que
devemos fazer é redefini-lo para
100 sempre que houver
uma mudança no tamanho da janela porque não sabemos realmente o que
os jogadores estão tentando fazer, e provavelmente é um pouco confuso se eles estão tentando maximizar os quadros ou
algo parecido Eu realmente não sei, mas é
isso que vou
fazer porque também é muito fácil. Então, a maneira mais fácil de fazer isso é chegar ao texto de resolução
definido, e precisamos chamar dois. Vou te mostrar isso em um segundo, então podemos pegar
o controle deslizante de escala E podemos definir valor. Podemos chamar valor definido sem sinal
ou podemos chamar valor definido. Vou mostrar a vocês o valor
definido por um segundo,
porque, de acordo com os documentos, vou salientar que
o valor passado é flutuante Caso contrário, essa
função não funcionará. Abaixo da faixa, diz, valor atual da
faixa. A alteração nessa
propriedade, mesmo por meio de código acionará um sinal de
mudança de valor. Agora, imaginaríamos
que o sinal de
deslizamento da escala para o valor alterado iria para esse método e faria todas as coisas que
precisávamos fazer atualizar a escala de resolução. Então eu tenho uma impressão digital aqui. Vou apenas
imprimir o valor. Então, a outra coisa antes de
rodarmos o jogo é desfazer o item do botão de opção selecionado Também vamos redefinir
a escala de resolução. Então, vou chamar o texto
de resolução definida aqui também. Então, neste momento, em cada estágio em que estamos
alterando o tamanho da tela, devemos
atualizar esse controle deslizante e acionar Vou executar isso. Vou
pular para a tela cheia. Então, devemos
esperar que eu imprima toda vez que
mudarmos isso, mas não o fazemos Eu não sei o que é.
Por exemplo, se os sinais não dispararem ou se for um bug, não
tenho certeza se preciso me
aprofundar nisso Mas por causa
desta lição em particular, se eu conseguir me orientar, vou mudar isso para definir o valor sem sinal,
apenas
para preparar isso para o futuro, para que não liguemos duas vezes
se isso eventualmente for corrigido ou talvez eu esteja entendendo
mal Eu não sei Mas podemos pegar
a função e chamá-la diretamente. Também estou passando dos 100. Então, se você acha que
sabe o porquê, me avise. Então, vamos executar isso
novamente. E vamos entrar no Window Word e você pode começar a
ver essas impressões,
então elas estão realmente funcionando, e estamos definindo os detalhes corretos
da resolução E talvez eu esteja exagerando
com a rotulagem aqui. Isso é só um exemplo. Então, se vocês quiserem
mudar essas coisas, à vontade. Depende
totalmente de você. pessoal conhece as
funções agora para que você possa organizar sua interface
do jeito que quiser. BS. Então, essa é uma peculiaridade estranha,
mas estamos fazendo com que funcione. Vamos passar para a próxima
coisa que quero mostrar a vocês.
10. Comutação de tela: Ok, então a próxima
coisa em que queremos
começar a trabalhar é
a capacidade de trocar de tela agora que temos todas essas
outras coisas funcionando. Então, vamos adicionar
um botão de opção aqui, e será uma configuração
semelhante à anterior. Então, vou renomear esse
botão de opção, seletor de tela, e vamos entrar
no script e criar
uma variável para Então, basta arrastar e
controlar
e soltar isso, e desceremos e soltar isso, e desceremos até o final e
criaremos uma função. E chamaremos essa
função de telas G. E o que realmente podemos
fazer é criar uma variável chamada telas, fazer uma chamada
para o servidor de exibição e usar a
função G screen count. Agora, isso
retornará apenas um número inteiro, mas vamos
percorrer isso Então, para S nas telas, pegaremos o seletor de tela e usaremos a função de adicionar
item lá E o que faremos é na verdade, passar
uma string personalizada, que será a palavra tela,
ponto
e vírgula e um espaço, e então também
adicionaremos o número da tela E esses
serão apenas colchetes STR S. E então aparecerá como a
tela zero ou a tela Não há como sabermos o nome da tela, então
vamos continuar com isso. Em seguida, precisaremos
conectar o sinal e, acessaremos
o seletor de tela Vamos clicar em Node. Conectaremos o sinal
selecionado do item mais uma vez e nos certificaremos de chamar essa função
Obter telas na função pronta . Nesse sinal, depois de
selecionarmos uma tela, teremos
acesso à janela,
então digitaremos o sublinhado Janela
e ficaremos
iguais a Obter janela e ficaremos
iguais a E então também
precisaremos ter acesso ao modo, porque isso vai
importar quando estivermos no modo de tela
cheia
para trocar as telas que eu encontrei. Então, teremos acesso ao modo. O modo Va é igual ao ponto da
janela de sublinhado ao modo Obter. E quando tivermos isso, podemos praticamente definir o modo
Janela para janela Vou explicar o porquê em um momento. Então, definiremos o modo
para o modo de janela
e, em seguida, trocaremos as telas, então chamaremos underscoe window
dot set E ele quer um índice, podemos simplesmente passar o índice a
partir do botão de opção. Será o mesmo que a tela. E então, o que
faremos é consultar o modo original que
obtivemos para ver se
estava em tela cheia. Então, se for se o
modo for igual ao modo de pontos
da janela em
tela cheia, definiremos o modo. Vamos colocar o
modo Windows de volta em tela cheia. Agora, a razão pela qual
fiz isso é porque descobri que, se você estiver
no modo de tela cheia, pelo
menos para mim com meu ambiente de
desktop, alterar as telas no modo de
tela cheia não funciona. Portanto, se você for para o modo Janela, alterne as telas e depois volte para o modo de tela
cheia. Há uma pequena cintilação,
mas é bem rápida. Então você realmente não percebe
, o que é muito bom. Então, podemos testar isso
e vê-lo em ação. E eu vou escolher a próxima tela, e tive que parar e mudar
minha gravação para que eu pudesse gravar minhas duas
telas para que você pudesse ver exatamente isso em ação. Portanto, é o modo de tela cheia.
Você clica na próxima tela e ela aparecerá
na próxima, sem problemas. Então, só para esclarecer, tela zero é minha
tela à direita. Sei que é um pouco estranho, mas os números estão corretos.
11. Revisão e considerações: Outra cena que eu criei é basicamente a digitalização de uma sala. Eu coloquei o link abaixo. Eu tenho que dar crédito
porque é CC BY. Mas não é uma mistura muito
eficiente, é o que estou
tentando dizer, porque escaneamentos não são bons para jogos Eles precisam ser
limpos. Portanto, é uma boa maneira de demonstrar a quantidade de quadros
que você pode recuperar Portanto, minha GPU não é tão lenta e ainda está obtendo apenas
100 quadros com resolução de 50% Eu posso escalar até 200%. E com o vSnc desativado, estou recebendo 40 quadros Então, você sabe, se alguém decidir usar algo
tão eficiente ou, você sabe, o jogo, tem
muita coisa acontecendo, resolução de
quatro K, você
só tem 45 quadros. Você quer obter 60, então
muda para o AMD FSR, opta por uma qualidade ultra alta e pode ampliar tudo Obviamente, não vai
ser como quatro K para mim porque eu só tenho
uma tela de 1080 peças, mas você pode
ver instantaneamente a qualidade
e as molduras são muito altas Agora, pessoalmente, acho
que com o AMD FSR, V sync torna tudo
1 milhão de vezes melhor, especialmente nessas configurações de
baixa qualidade Vou ter algo na tela em
que fiz isso com a
demonstração do controlador em terceira pessoa que vem com o Gadot, então há um pouco mais de
ação na tela, e eu posso dizer 100% com o
VSNCEnabled O AMD FSR 2.2 é 100% jogável. se você tem
um laptop que não tem uma
placa dedicada ou está usando Por exemplo, se você tem
um laptop que
não tem uma
placa dedicada ou está usando
um Steam Deck e está tentando
fazer algo que é particularmente
desgastante para esse dispositivo, ter isso disponível
para os usuários é obrigatório Você precisa expor essa configuração. Eu só vou
dizer isso agora. Pelo menos, é nisso
que eu acredito. Isso está com resolução de 50%. Então, 960 por 540. E é tão difícil até mesmo
notar a diferença. Isso é bilinear, obviamente, e vamos
reduzir isso de volta para 100 E é impressionante a diferença
que você verá aqui E então, eu não sei. Eu
não sei o que dizer. Desempenho. Equilibrado.
É tão bom. E ainda dá para ver em
ação cenas em movimento. Então essa câmera está
se movendo bem devagar. É difícil perceber
a diferença. É um bom exemplo de quão
poderoso é o software, mas não é uma boa
representação de como
será a experiência porque, você sabe, muita coisa acontecerá na tela em muitos jogos. Mas ainda é incrível que
tenhamos isso disponível para nossos jogadores com
muito pouco esforço, totalmente mínimo.
Então isso é ótimo.
12. Conclusão: Tudo bem, pessoal. É isso mesmo. Deixe-me saber se você
tiver alguma dúvida. Estou na discórdia. Se
precisar de ajuda, eu estou lá. Há um monte de outras pessoas
lá que podem te ajudar. E estamos sempre
procurando conversar sobre o
desenvolvimento de cães e jogos em geral. Isso é tudo por esse, pessoal. Sou Oak, da Shaft Games,
e nos vemos na próxima vez.