# Quick Start do SDK O Decentraland SDK é uma ferramenta poderosa que permite criar ou aprimorar as suas Scenes escrevendo código em Typescript (Javascript + Types). {% hint style="info" %} **💡 Dica**: Se preferir criar as suas Scenes usando apenas ferramentas sem código, veja [Scene Editor no Creator Hub](https://github.com/decentraland/docs/blob/main/creator/sdk7/get-started/about-editor.md). {% endhint %} {% hint style="info" %} **💡 Dica**: Você também pode criar Scenes descrevendo ao assistente de IA o que deseja, sem escrever código à mão. Veja [Vibe Coding com IA](https://github.com/decentraland/docs/blob/main/creator/sdk7/getting-started/vibe-coding.md). {% endhint %} Este tutorial mostra como configurar tudo e apresenta os conceitos básicos para escrever código numa scene do Decentraland. ## Instale o Creator Hub O Creator Hub permite criar, pré-visualizar e publicar scenes do Decentraland. Faça o download do Creator Hub [aqui](https://decentraland.org/download/creator-hub). Para editar o código da sua scene, também precisa instalar [Visual Studio Code](https://code.visualstudio.com/), se ainda não o tiver. Leia [guia de instalação](https://github.com/decentraland/docs/blob/main/creator/sdk7/get-started/editor-installation.md) para mais detalhes sobre a instalação do Creator Hub. ## Crie a sua primeira scene Para criar a sua primeira scene, siga estes passos. 1. Abra o Creator Hub. 2. Selecione o separador **Scenes** , e clique em **Create Scene**. ![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-4c870038c8005f81ed55248ff8d6a93865bf4a98%2Fcreate-scene.png?alt=media) 3. Pode então escolher entre diferentes templates iniciais. Para este exercício, escolha **Empty Scene**. Este passo pode demorar alguns minutos. Ele preenche a sua pasta com o conjunto padrão de ficheiros para uma scene básica. Quando isso terminar, verá a grelha vazia da sua scene. ## Adicione itens dos asset packs Explore os **Asset packs** na secção inferior do Scene Editor no Creator Hub, arraste alguns itens e ajuste as suas posições. Para os fins deste tutorial, qualquer item serve por agora. ![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-533d4553c3a38522cdd08dce8040a08c038699e7%2Fasset-packs.png?alt=media) Para colocar um item, clique e arraste-o do menu do asset pack para uma localização na sua scene no canvas. ![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-30237e6006c76b69f5cfe737e543875987ed67b8%2Fdrop-item.gif?alt=media) Um item já colocado pode ser clicado e arrastado para o reposicionar livremente. Veja [conceitos básicos do scene editor](https://github.com/decentraland/docs/blob/main/creator/sdk7/get-started/scene-editor-essentials.md#position-items) para mais detalhes. {% hint style="info" %} **💡 Dica**: Cubra toda a scene com um item Ground. Itens do tipo **Ground** têm um ícone de balde de tinta. Se arrastar um destes para a sua scene, ele cobre todo o chão da sua scene com cópias deste item. Ground {% endhint %} ## Executar uma pré-visualização Clique no botão **Preview** no menu superior para carregar a sua scene dentro do Decentraland. Agora pode explorar a scene como um avatar do Decentraland. ![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-39c019806cf83fa82b105ac12836311e3e7bae7c%2Frunning-preview.png?alt=media) Leia mais sobre a pré-visualização da scene em [pré-visualizar uma scene](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/primeiros-passos/preview-scene). {% hint style="info" %} **💡 Dica**: Pode manter a janela de pré-visualização aberta enquanto continua a trabalhar na sua scene, e ela será atualizada sempre que fizer uma alteração no Scene Editor. {% endhint %} ## Assets 3D personalizados Faça download deste modelo 3D de um abacate em *glb* formato a partir do seguinte [link](https://github.com/decentraland-scenes/avocado/raw/main/avocado-glb.zip) e descompacte-o. ![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-8da7cae3effded9686a5efd6238653c527edc988%2Favocado-babylon.png?alt=media) 1. Clique no sinal de mais no canto superior direito da secção Asset Packs da UI do Scene Editor. 2. Arraste o ficheiro **avocado.glb** para a região na UI do Scene Editor e clique em **Import**. ![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-7c5cc9b92e593be1c3808b15abd54037818fa588%2Fimport-avocado.png?alt=media) Agora pode encontrar o **avocado.glb** modelo no separador **Local Assets** , dentro da pasta **Scene** . Arraste-o para a sua scene, tal como faria com qualquer item dos Asset Packs. ![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-01ea843bc76e6f15b8e99d50391936d8b0344a93%2Favocado-in-local-assets.png?alt=media) ## Edite o código da scene As secções seguintes descrevem como pode editar o código da sua scene, dando-lhe muito mais liberdade como criador. Clique no botão **<> Code** botão no menu superior para abrir o projeto da sua scene no Visual Studio Code. ![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-5837e60ee5b65bd46815c97282d53b1a44a70665%2Fcode-button.png?alt=media) {% hint style="warning" %} **📔 Nota**: Instale [Visual Studio Code](https://code.visualstudio.com/), se ainda não o tiver. {% endhint %} Isto abre uma janela separada com o Visual Studio Code. Na margem esquerda pode navegar pelos ficheiros e pela estrutura de pastas do seu projeto. ![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-e94bcfd7f720dddb6343bbb79d444afae3cbff33%2Ffiles-on-vs-studio.png?alt=media) Abra o ficheiro `index.ts` de dentro da pasta `src` da sua scene. O conteúdo deve parecer-se com isto: ```ts import {} from '@dcl/sdk/math' import { engine } from '@dcl/sdk/ecs' export function main() {} ``` As duas primeiras linhas lidam com instruções de `import` . Estas obtêm referências a coisas definidas noutros ficheiros, para que possam ser usadas neste ficheiro. Não precisará lidar diretamente com estas linhas neste tutorial, mas note que a lista de coisas a serem obtidas vai crescer à medida que escreve o seu código. Note que este ficheiro define uma função chamada `main()`. Esta função é o ponto de entrada da scene; qualquer código que colocar aí será executado quando a scene carregar pela primeira vez. Se escrever linhas de código fora desta função, elas nunca serão executadas. Na secção anterior mostramos como pode facilmente arrastar o modelo 3D personalizado do abacate para a sua scene de forma sem código. Agora vamos adicionar um segundo abacate, para ver como obter o mesmo resultado escrevendo código. Substitua todo o conteúdo do seu `index.ts` ficheiro pelo seguinte. Estas linhas expandem a função `main()` e adicionam alguns imports: ```ts import { Vector3 } from '@dcl/sdk/math' import { engine, Transform, GltfContainer } from '@dcl/sdk/ecs' export function main() { // criar uma Entity nova em folha let avocado2 = engine.addEntity() // dar-lhe um Transform Transform.create(avocado2, { position: Vector3.create(8, 0, 8), }) // dar-lhe um GLTF GltfContainer.create(avocado2, { src: 'assets/scene/avocado.glb', }) } ``` Se abrir novamente a pré-visualização da scene, agora deverá ver dois abacates: o que adicionou no Scene Editor e o que adicionou via código. ![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-10e98ca0228fa04e0cd9afde8c457b8fb7932d19%2Favocados.png?alt=media) As linhas que acabou de adicionar criam uma nova [entity](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/arquitetura/entities-components), dão-lhe uma [shape](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/essenciais-de-conteudo-3d/shape-components) com base no modelo 3D que descarregou, e [definem a sua posição e escala](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/essenciais-de-conteudo-3d/entity-positioning) através do **Transform**. Agora volte ao Scene Editor e selecione o primeiro abacate que adicionou. No painel de propriedades deste item, verá que a UI para os componentes Transform e GLTF mostra a mesma informação que no código que acabou de escrever. ![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-6ce41a7d98cb2b5c59c9bf2b870ea05d34a73f62%2Favocado-components.png?alt=media) ## Adicionar interatividade Para tornar a sua scene mais envolvente, vamos fazer com que as entities na scene respondam às interações do jogador. No final da `main()` função (antes de ser fechada pelo último **}**), adicione um manipulador de evento de pointer à entity do abacate. Isto executa uma função personalizada sempre que o jogador clica no abacate. ```ts pointerEventsSystem.onPointerDown( { entity: avocado2, opts: { button: InputAction.IA_POINTER, hoverText: 'Collect' }, }, function () { console.log('CLICKED AVOCADO') } ) ``` {% hint style="info" %} **💡 Dica**: O Visual Studio Code ajuda-o marcando erros de sintaxe, completando automaticamente enquanto escreve e até mostrando sugestões inteligentes que dependem do contexto. Também pode clicar num objeto para ver a definição completa da sua class. Se alguma das palavras que colou estiver sublinhada a vermelho, passe o cursor por cima para ver se o VS Studio oferece uma solução fácil. Provavelmente terá de fazer isso para **pointerEventsSystem**, e **InputAction**. Clicar na lâmpada irá sugerir `Update import from @dcl/sdk/ecs`. Selecione esta opção para adicionar imports ao início do seu `index.ts` ficheiro. {% endhint %} A instrução `pointerEventsSystem.onPointerDown()` define três coisas: * Em que `entity` funcionam os pointer events. * Um objeto `opts` com parâmetros adicionais opcionais. Neste caso, incluímos que botão usar e que texto de dica mostrar. * Uma função, que será executada sempre que a entity for clicada. Neste caso, a função que estamos a executar é muito simples. Tem apenas uma linha e simplesmente imprime algum texto na console. ```ts console.log('CLICKED AVOCADO') ``` Na secção `opts` estamos a definir o campo `button` para que escute o botão de pointer (o botão esquerdo do rato num PC). Também estamos a definir o parâmetro `hoverText` para mostrar texto personalizado. Assim, os jogadores verão o texto "collect" quando passarem o cursor sobre o abacate, e saberão o que acontecerá se clicarem nele. O abacate ainda não faz muito, mas chegaremos lá nos próximos passos. Para ver a mensagem que o evento de clique está a registar, precisará de abrir a console. Para isso, abra novamente a pré-visualização da scene, se ainda não a estiver a executar, e pressione a tecla **\`** para alternar a apresentação da console. Agora, sempre que clicar no abacate que adicionou via código, verá: ![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-da59e95c8a6642350fcf0c49e7e589609ef68eec%2Flogs-avocado.png?alt=media) {% hint style="warning" %} \*\*📔 Nota\*\*: Para uma entity ser clicável, precisa de ter uma geometria de collider. O modelo usado aqui já inclui uma. Veja a secção \[Colliders]\(../3d-modeling/colliders.md) para soluções alternativas para modelos que não incluem uma geometria de collider. {% endhint %} Agora vamos fazer com que essa função de clique faça algo mais interessante: vamos fazer o abacate desaparecer. Use \` engine.removeEntity()\` para se livrar do abacate assim que ele for clicado. Vamos adicionar uma linha extra ao nosso snippet: ```ts pointerEventsSystem.onPointerDown( { entity: avocado2, opts: { button: InputAction.IA_POINTER, hoverText: 'Collect' }, }, function () { console.log('CLICKED AVOCADO') engine.removeEntity(avocado2) } ) ``` Agora, quando clicado, o abacate desaparece da sua scene. ## Tweens Tweens descrevem uma transição gradual de uma posição/rotação/escala para outra, ao longo de um período de tempo. Vamos começar por adicionar um tween de escala ao nosso abacate, apenas para experimentar a funcionalidade. Adicione as seguintes linhas dentro da `main()` função, no final, sem alterar nada do que já adicionou: ```ts export function main() { // Código dos snippets anteriores (não alterar) // (...) // Novo código: Tween.setMove(avocado2, Vector3.create(3, 0, 3), Vector3.create(8, 0, 8), 5000 ) } ``` {% hint style="info" %} **💡 Dica**: Ao colar isto, poderá encontrar mais palavras sublinhadas a vermelho devido a imports em falta. Passe o cursor por cima de cada uma e clique na lâmpada; ela sugerirá `Update import from @dcl/sdk/ecs`. Selecione esta opção para adicionar imports ao início do seu `index.ts` ficheiro. {% endhint %} A instrução `Tween` componente que criámos tem argumentos que fazem com que mude de posição, de uma posição nas coordenadas *3,0,3* da scene, para as coordenadas *8,0,8*, ao longo de um período de 5000 milissegundos (5 segundos). Este movimento começará assim que a scene arrancar. Uma `Tween` função setMove requer a seguinte informação: * `entity`: Que entity usar. * `start`: Posição inicial. * `end`: Posição final. * `duration`: Duração (em milissegundos) do scale de início até ao fim. Este outro parâmetro opcional também está disponível: * `easingFunction`: Que tipo de curva usar para controlar a taxa de mudança ao longo do tempo. Neste caso usamos linear, o que resulta numa mudança constante e suave. Podemos brincar com o parâmetro `easingFunction` para obter alguns efeitos interessantes. Por exemplo, podemos usar em vez disso `EF_EASEINBOUNCE` para realizar a transição usando uma interpolação bounce ease-in, que começa com um efeito saltitante e depois passa de lento para rápido. {% hint style="info" %} **💡 Dica**: Também pode usar o componente **Tween** para escalar ou rodar uma entity ao longo de um período de tempo; esta é uma ferramenta realmente útil! Saiba mais [aqui](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/essenciais-de-conteudo-3d/move-entities) {% endhint %} ## Usar as suas próprias funções Nesta secção vamos adicionar outro tween à escala do Abacate, para tornar o efeito de desaparecimento mais apelativo. Mas vamos adotar uma abordagem um pouco menos direta para introduzir alguns outros conceitos. A forma mais simples de fazer o nosso abacate encolher quando clicamos nele é adicionar um tween dentro da função de pointer events, em vez da linha `engine.removeEntity(avocado2)`. Mas, em vez disso, vamos criar este tween numa função separada que depois podemos reutilizar para outros itens. Assim, não precisaremos de escrever o mesmo código duas vezes! A nossa nova função será separada de `main()`, por isso não fará nada por si só, mas em breve iremos chamá-la. ```ts function collect(myEntity: Entity) { Tween.setScale(myEntity, Vector3.One(), Vector3.Zero(), 500, EasingFunction.EF_EASEINBOUNCE ) } ``` Note que o tween é adicionado a uma entity chamada `myEntity`, em vez de `avocado2`. `myEntity` é apenas um placeholder, não existe nenhuma entity com esse nome na scene. Vem de um parâmetro definido na função. Quando chama a função `collect()` função, pode passar qualquer entity da scene, e ela aplicará um `Tween` a ela. Mais sobre isso mais tarde. {% hint style="info" %} **💡 Dica**: Sempre que houver código que possa usar várias vezes na sua scene, é uma boa prática colocá-lo dentro de uma função. Assim, só precisa escrevê-lo uma vez, e é mais fácil de manter. {% endhint %} Aqui criámos um Tween que afeta a *Scale*, portanto agora `start` e `end` referem-se ao tamanho do abacate, não à posição. Vai de um tamanho de um para zero, ao longo de uma duração de 500 milissegundos (meio segundo), e usa uma função de easing `EASEINBOUNCE` , que lhe dá um efeito divertido e saltitante. Agora vamos modificar a função que escrevemos para quando clicamos no abacate. Vamos alterar a linha que diz `engine.removeEntity(avocado)`, e em vez disso vamos chamar a `collect()` função que acabámos de definir, passando uma referência para a nossa entity do abacate: ```ts pointerEventsSystem.onPointerDown( { entity: avocado2, opts: { button: InputAction.IA_POINTER, hoverText: 'Collect' }, }, function () { console.log('CLICKED AVOCADO') collect(avocado2) } ) ``` Se agora abrir a pré-visualização da scene e clicar no abacate, deverá vê-lo desaparecer com estilo, realizando um movimento divertido e saltitante. {% hint style="warning" %} **📔 Nota**: Pode já ter percebido que agora o abacate encolhe até ao tamanho 0, mas continua a existir. Não abordaremos isto neste primeiro tutorial, mas, num cenário ideal, deve certificar-se de que elimina a entity depois de o tween terminar, para otimizar o desempenho da sua scene. Veja [On tween finished](https://docs.decentraland.org/creator/content-creator-pt/essenciais-de-conteudo-3d/move-entities#on-tween-finished). {% endhint %} ## Referenciar um item do Scene Editor O seu código também pode fazer coisas com os itens que adicionou visualmente no Scene Editor no Creator Hub. Pode obter estes itens pelo nome no seu código, usando a função `engine.getEntityOrNullByName()`. Use o nome do item que vê escrito na [entity tree](https://github.com/decentraland/docs/blob/main/creator/sdk7/get-started/scene-editor-essentials.md#the-entity-tree). Neste exemplo, temos uma entity chamada **Yellow Crate**. Pode usar qualquer item que quiser; apenas certifique-se de escrever o nome exatamente como aparece na entity tree. {% hint style="info" %} **💡 Dica**: Pode renomear entities clicando com o botão direito e selecionando **Rename** na entity na entity tree. {% endhint %} ![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-533d4553c3a38522cdd08dce8040a08c038699e7%2Fasset-packs.png?alt=media) ```ts export function main() { // Coisas do Abacate const crate = engine.getEntityOrNullByName('Yellow Crate') if (crate) { console.log('The crate exists') } } ``` No snippet acima, usamos `engine.getEntityOrNullByName()` para obter uma referência para uma entity chamada *Yellow Crate*. Na linha seguinte, fazemos `if (crate)` para garantir que realmente existe uma entity com este nome na scene. Se não existir, então o valor de `crate` será `null`. Veja [Itens de Referência](https://github.com/decentraland/docs/blob/main/creator/sdk7/code/reference-items.md) para mais informações. {% hint style="info" %} **💡 Dica**: Todas as entities adicionadas via Scene Editor já estarão carregadas na sua scene quando o código na função `main()` for chamado. Deve ser seguro referenciá-las nesta função, ou noutras funções chamadas indiretamente por ela. {% endhint %} Agora vamos adicionar um comportamento de pointer à nossa entity Yellow Crate, tal como fizemos com o abacate. ```ts export function main() { // Coisas do Abacate const crate = engine.getEntityOrNullByName('Yellow Crate') if (crate) { console.log('The crate exists') pointerEventsSystem.onPointerDown( { entity: crate, opts: { button: InputAction.IA_POINTER, hoverText: 'Collect' }, }, function () { console.log('CLICKED CRATE') collect(crate) } ) } } ``` Note como estamos a chamar a função `collect()` que definimos antes. Como a função é definida separadamente, só precisámos de escrever essa linha para a chamar! {% hint style="info" %} **💡 Dica**: Também pode obter [Smart Items](https://github.com/decentraland/docs/blob/main/creator/sdk7/interactivity-1/smart-items.md) da sua scene da mesma forma e fazer o que quiser com eles via código. Veja [Itens de Referência](https://github.com/decentraland/docs/blob/main/creator/sdk7/code/reference-items.md) para mais informações. {% endhint %} ## Mais Tutoriais Leia [coding-scenes](https://github.com/decentraland/docs-creator/blob/main/sdk7/getting-started/coding-scenes.md) para uma compreensão de alto nível de como as scenes do Decentraland funcionam. Para exemplos criados com SDK7, consulte a [página de Examples](https://studios.decentraland.org/resources?sdk_version=SDK7) que contém várias scenes pequenas, todas escritas com SDK7. Veja a secção **guia de desenvolvimento** para mais instruções sobre como adicionar conteúdo à sua scene. ## Interaja com outros developers Visite [o Discord do Decentraland](https://dcl.gg/discord) e o [Discord da Decentraland DAO](https://discord.gg/bxHtcMxUs4), para participar numa conversa animada sobre o que é possível e como! Para depurar quaisquer problemas, recomendamos que consulte as secções [Troubleshooting](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/debugging/troubleshooting) e [debug](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/debugging/debug-in-preview) na documentação. Se não encontrar uma solução aí, pode publicar issues na categoria [SDK Support](https://forum.decentraland.org/c/support-sdk/11) no Fórum do Decentraland. Também pode publicar em [Stack Overflow](https://stackoverflow.com/questions/ask?tags=+\[decentraland-ecs]), usando as tags `decentraland` ou `decentraland-ecs`. Também pode pedir ajuda no [Discord do Decentralnad](https://dcl.gg/discord). Na secção **Support** , o canal **#sdk** é para perguntas sobre código, o canal **#builder-and-3d** é para perguntas sobre modelos 3D e arte. **#code-contribution** é para discutir PRs para a base de código do SDK. Na secção [Discord da Decentraland DAO](https://discord.gg/bxHtcMxUs4) também pode obter ajuda no canal **sdk-support** . ## Assets de Arte 3D Uma boa experiência terá ótima arte 3D a acompanhá-la. Se tiver vontade de criar esses modelos 3D você mesmo, é incentivado a fazê-lo; veja a secção [3D Modeling section](https://github.com/decentraland/docs/blob/main/creator/sdk7/3d-modeling/3d-models.md) para mais informações. Mas, se preferir focar-se na programação ou no design do jogo, não precisa de criar os seus próprios assets! Aqui estão algumas fontes para obter ótimos modelos 3D que pode usar numa scene do Decentraland: * [IWB Catalog](https://dcl-iwb.co/) * [Asset Ovi](https://assetovi.com/) * [SketchFab](https://sketchfab.com/) * [Clara.io](https://clara.io/) * [Archive3D](https://archive3d.net/) * [SketchUp 3D Warehouse](https://3dwarehouse.sketchup.com/) * [Thingiverse](https://www.thingiverse.com/) * [ShareCG](https://www.sharecg.com/) * [CGTrader](https://cgtrader.com) Também pode usar ferramentas de IA generativa para criar os seus próprios modelos 3D. Veja: * [Meshy](https://www.meshy.ai/) * [Luma AI](https://lumalabs.ai/genie) * [TRipo3D](https://www.tripo3d.ai/app) * [Rodin](https://hyper3d.ai/rodin) {% hint style="warning" %} **📔 Nota**: Os modelos devem estar nos formatos suportados `.gltf` ou `.glb` , e devem ter um número de triangles, textures e materials que respeite as [limitações da scene](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/otimizacao/scene-limitations). Se obtiver modelos de um site de terceiros, preste atenção às restrições de licença que o conteúdo descarregado possui. {% endhint %} ## Publique a sua scene Se for proprietário de LAND, de um NAME do Decentraland ou de um nome ETH ENS, ou se tiver permissões concedidas por alguém que as tenha, pode carregar a sua scene para o Decentraland. Veja [publicação](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/publicacao/publishing). ## Outras informações úteis * [Bibliotecas](https://studios.decentraland.org/resources?sdk_version=SDK7\&resource_type=Library) * [Restrições de design para jogos](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/desenhar-a-experiencia/design-games) * [modelação 3D](https://github.com/decentraland/docs/blob/main/creator/sdk7/3d-modeling/3d-models.md) * [limitações da scene](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/otimizacao/scene-limitations)