Be one of the first to get your own avatar, and gain early access to Decentraland.
X
Hello! Please choose your
desired language:
Dismiss

Scene limitations

In order to improve performance in the metaverse, we have established a set of limits that every scene must follow. If a scene exceeds these limitations, then the parcel won’t be loaded and the preview will display an error message.

For a straight-forward reference of what limitations you’ll have for a specific number of parcels, check the following table:

Reference table

Scene limitation rules

Below are the maximum number of elements allowed allowed in a scene:

n represents the number of parcels that a scene occupies.

  • Triangles: n x 10000 Total amount of triangles for all the models in the scene.
  • Entities: n x 200 Amount of entities in the scene.
  • Bodies: n x 300 Amount of meshes in the scene.
  • Materials: log2(n+1) x 20 Amount of materials in the scene. It includes materials imported as part of models.
  • Textures: log2(n+1) x 10 Amount of textures in the scene. It includes textures imported as part of models.
  • Height: log2(n+1) x 20 Height in meters.

    Note: User avatars and any items brought by users from outside the scene don’t count for calculating these limits. <!–

Query scene limitations via code

From a scene’s code, you can query both the limitations that apply to the scene and how much the scene is currently using. This is especially useful with scenes where the content changes dynamically. For example, in a scene where you add a new entity each time the user clicks, you could stop adding entities when you reach the scene limits.

To use this functionality, you must first import EntityController into your scene.

import { querySceneLimits } from "@decentraland/EntityController"

Obtain scene limitations

Run this.entityController.querySceneLimits() to obtain the limits of your scene. The limits are calculated for your scene based on how many parcels it occupies, according to the scene.json file. The values returned by this command don’t change over time, as the scene’s size is always the same.

The querySceneLimits() is asynchronous, so we recommend calling it using the executeTask() function, including an await statement.

executeTask(async () => {
  try {
    const limits = await querySceneLimits()
    log('limits' + limits)
  }
})

The querySceneLimits() function returns a promise of an object with the following properties, all of type number.

// import controller
import { querySceneLimits } from '@decentraland/EntityController'


// get limits object
executeTask(async () => {
  try {
    const limits = await querySceneLimits()

    // print maximum triangles
    log(limits.triangles)

    // print maximum entities
    log(limits.entities)

    // print maximum bodies
    log(limits.bodies)

    // print maximum materials
    log(limits.materials)

    // print maximum textures
    log(limits.textures)
  }
}

For example, if your scene has only one parcel, logging limits.triangles should print 10000.

Obtain the current use

Just as you can check via code the maximum allowed values for your scene, you can also check how much of that is currently used by the scene. You do this by running this.querySceneMetrics(). The values returned by this command change over time as your scene renders different content.

The querySceneMetrics() is asynchronous, so we recommend calling it using the executeTask() function, including an await statement.

executeTask(async () => {
  try {
    const limits = await querySceneMetrics()
    log('limits' + limits)
  }
})

The querySceneMetrics() function returns a promise of an object with the following properties, all of type number.

// import controller
import { querySceneMetrics } from '@decentraland/EntityController'


// get limits object
executeTask(async () => {
  try {
    const limits = await querySceneMetrics()

    // print maximum triangles
    log(limits.triangles)

    // print maximum entities
    log(limits.entities)

    // print maximum bodies
    log(limits.bodies)

    // print maximum materials
    log(limits.materials)

    // print maximum textures
    log(limits.textures)
  }
}

For example, if your scene is only rendering one box entity at the time, logging limits.entities should print 1. –>

Scene boundaries

When running a preview, any content that is located outside the parcel boundaries is highlighted in red when rendered. If any content is outside these boundaries, you won’t be allowed to deploy this scene to Decentraland.

If the tip a large object leaves the boundaries, this object is considered out of bounds too.

A single parcel scene measures 16 meters x 16 meters. If the scene has multiple parcels, the dimensions vary depending on the arrangement of the parcels.

Shader limitations

3D models used in decentraland must use supported shaders and materials. See 3D model considerations for a list of supported shaders.

Lighting

The scene’s lighting conditions can’t be changed from the default setting.

Entities don’t cast shadows over other entities and dynamic lighting isn’t supported.

Texture size constraints

Texture sizes must use width and height numbers (in pixels) that match the following numbers:

1, 2, 4, 8, 16, 32, 64, 128, 256, 512

This sequence is made up of powers of two: f(x) = 2 ^ x . 512 is the maximum number we allow for a texture size. This is a fairly common requirement among other rendering engines, it’s there due internal optimizations of the graphics processors.

The width and height don’t need to have the same number, but they both need to belong to this sequence.

The recommended size for textures is 512x512, we have found this to be the optimal size to be transported through domestic networks and to provide reasonable loading/quality experiences.

Examples of other valid sizes:

32x32
64x32
512x256
512x512

Although textures of arbitrary sizes work in the alpha release, the engine displays an alert in the console. We will enforce this restriction in coming releases and invalid texture sizes will cease to work.