Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

ADR 276: light sources #276

Draft
wants to merge 4 commits into
base: main
Choose a base branch
from
Draft
Changes from 2 commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
117 changes: 117 additions & 0 deletions content/ADR-253-light-sources.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,117 @@
---
layout: adr
adr: 253
title: Light Sources
date: 2024-11-13
status: Draft
type: RFC
spdx-license: CC0-1.0
authors:
- nearnshaw
---

# Abstract

This document explores a new feature that has been missing from Decentraland scenes: letting creators control light. We will allow creators to define a limited number of entities in their scenes that will behave as sources of light, and offer a number of parameters to control the kind of light-source, color, luminosity, etc.

We also explore how we can make this work in an open world, and its implications.
We also discuss limitations that should be imposed, to prevent a degradation of the experience if this feature is misused.

# Context

Up until now, all light in Decentraland came from a single rigid source (the sun or moon). Enabling creators to create their own light sources enables a lot of creative possibilities. We see the control of light as important for the following:

- Creating ambience and enhance the architecture of a scene
- Flashy effects for music festivals, fashion week, and other events of high visual impact
- Light as a visual cue: guide the player towards what’s important in a scene by shining a light on it. Signal a change in what’s going on in the scene by switching the lights to a different intensity or color.
- Darkness as a mechanic for spooky games
- Flashlights as a mechanic: the act of having to point a light to reveal what’s there can be a whole game mechanic.

To be able to play with darkness, we'll also need to provide controls to be able to disable the global default light sources and play with that.

Note: Some GLTF models come with lights packaged as nodes inside the structure of the model. We should ignore those completely. The only lights we will be rendering are the ones defined via code using the LightSource component.

## Component description

We should create a `LightSource` component that, when added to an entity, tells the engine to shine a light from that entity’s Transform position.

A Type field will let you chose between _Spot_ and _Point_ light. We believe these two types of lights are enough for now, the component could be expanded in the future if we want to include other types.
nearnshaw marked this conversation as resolved.
Show resolved Hide resolved
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Regarding the component structure, I'd like to discuss an alternative approach based on composition rather than a single component with type discrimination:

Instead of:

interface LightSource {
  type: 'point' | 'spot' | 'directional';
  intensity: number;
  // ... common properties ...
  // spot-specific properties when type === 'spot'
  angle?: number;
  innerAngle?: number;
}

Consider a composable approach:

interface Light {
  illuminance: number;
  color: Color3;
  shadows: boolean;
}

interface Spotlight {
  angle: number;
  innerAngle?: number;
}

interface GlobalLight {
  direction?: Vector3;
  ambientColor?: Color3;
  ambientBrightness?: number;
}

Benefits:

  1. Cleaner Separation: Each component handles one specific aspect of lighting
  2. Type Safety: No need for runtime type checking or optional properties
  3. Extensibility: New light types can be added without modifying existing components
  4. Flexibility: SDKs can provide their own abstractions while the protocol remains clean
  5. Clarity: Entity behavior is determined by component composition:
    • Point Light = Entity + Light
    • Spot Light = Entity + Light + Spotlight
    • Directional Light = Root Entity + Light + GlobalLight

Copy link
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

We debated this point, and reached the conclusion that we still much prefer to use a single component, for the following reasons:

  1. It's consistent with how many other components in our SDK already work (eg Material, Tween, MeshRenderer, MeshCollider)
  2. It's friendlier to have to remember a single component name, and have the field suggestions do the rest for you. If you need to add two separate components, you don't have that guidance, you need to remember the two component names by heart. Users can also get potentially lost if they try to only add the SpotLight component and see no effect.
  3. We can add helpers, like we already do on other components to make this friendlier. eg:
    LightSource.spotLight(myEntity, { brightness: 1000, angle: 10})


A _Spot_ light projects a cone of concentrated light in a single direction, originating from a single point in the scene. It's ideal for shows and theatric effects, it can also be used to shine a light on something with a functional intention.

A _Point_ light expands in all directions from a point in the scene, illuminating the space in a more subtle way. The point of origin is often not easy to pinpoint for the player.

The following fields will be available on both types of light:

- Color: _Color4_ The color of the light
- Intensity: _number_ The luminosity value of the light, from 0 to 1.
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I suggest reconsidering the use of arbitrary 0-1 values for light intensity in favor of physically-based units (lumens/m² or lux). This would provide several advantages:

  1. Predictability: Artists and developers can reference real-world light measurements

    • A 100W household bulb (~1200 lumens) = ~100 lux at 1m
    • Sunlight varies from 400 lux (sunrise) to 10,000 lux (midday)
  2. Consistency: Light behavior becomes more predictable across different implementations and scenes

  3. Realism: Natural light falloff can be accurately modeled using the inverse square law

  4. Interoperability: Better alignment with industry standards and other 3D tools

We have a working implementation of this approach in the protocol files that you might want to review: light.proto

The property could be renamed to illuminance to better reflect its physical meaning. The actual visual impact would still be subject to the renderer's exposure and tone mapping, but the relative relationships between lights would be preserved.

Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Good suggestion, how about we use Lumens instead, it measure the total amount of light emitted by a source. This makes it the ideal metric for describing the output of a light source, independent of where or how it is used. Lumens are inherently tied to the light source itself, while lux depends on the environment. Since we want to define properties of the light sources rather than the effect of light on a surface, lumens are a better fit, in my option.

Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

We could use Lumens of course, that would be equivalent to divide the luxs by 4*π. But you should keep using lux for directional lights since the source is practically infinity. And this differentiation is the one glTF extension uses.

glTF extension:

intensity Brightness of light in. The units that this is defined in depend on the type of light. point and spot lights use luminous intensity in candela (lm/sr) while directional lights use illuminance in lux (lm/m2)

Copy link
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

After talking it over and looking at other platforms, we changed the value to be measured in lumens and renamed to "brightness"

Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

And luxs for directional/global?

Copy link
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

You're right, I was leaving that out bc global lights aren't in the plan for our first implementation, but it should be in the ADR.
I just included a clarification for that:

For Spot and Point light, this value is expressed in Lumens, for Global light, it's expressed in Lux units (lumens per square metre).

- Range: _number_ The maximum distance that can be affected by the light source.
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Regarding light range, I suggest following GLTF's KHR_lights_punctual approach:

  1. The range should be optional (or even more not being added now). When unspecified, light naturally SHOULD attenuate following the inverse square law (1/d²)

  2. When specified, GLTF uses this attenuation formula after following the inverse square law, then:

attenuation = max(min(1.0 - (distance/range)^4, 1), 0) / distance^2

Within the range of the light, attenuation should follow the inverse square law as closely as possible, although some non-quadratic falloff near the edge of the range may be used to avoid a hard cutoff

This provides:

  • Natural physical falloff (1/d²)
  • Smooth cutoff at the range distance
  • Performance optimization opportunity (GPU can skip calculations beyond range)

Instead of having developers guess appropriate range values, we could:

  • Make range optional
  • Calculate a reasonable default cutoff based on illuminance
  • Allow manual override when needed for performance tuning

This aligns with industry standards while maintaining physically-based behavior.

Copy link
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

We agree that the attenuation curve of light should mimic real life as closely as possible
The "range" field should serve as a hard cut-off, but not distort the attenuation curve.

It's mostly there to allow creators to optimize. The default value should be something reasonable, and most novice creators might not need to tweak it

- Active: _boolean_ Determines if the light is currently on or not.

In lights of type _Spot_, we will also include:

- Inner angle: _number_ This angle, measured from the direction vertex, defines a cone where the light has full intensity. Max 180, can’t be more than outer angle.
- Outer angle: _number_ This angle, measured from the direction vertex, defines a cone where the light has an effect, the intensity decreases farther away from the inner cone. Max 180.

The `Active` flag lets creators easily turn a light source on or off. We could otherwise achieve the same by setting intensity to 0, but offering a switch makes it easier to retain the prior configuration.

## Shadows
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Regarding shadows, I suggest expanding this section to address several important aspects:

  1. Shadow Control
    Instead of a simple boolean, consider these key properties:
  • shadows: boolean - Whether the light casts shadows
  • Default values should differ by light type:
    • Point/Spot lights: false (performance consideration)
    • Global/Directional light: true (essential for scene depth)
  1. Implementation Considerations
    Add a note that shadow rendering may vary by platform:
// Even when shadows = true, the engine may:
// - Not display shadows at all
// - Show shadows for limited number of lights
// - Vary shadow quality
// Based on:
// - Platform capabilities
// - User settings
// - Performance requirements
  1. Priority System
    Consider adding guidance for implementations about shadow priority:
  • Global/Directional light shadows take precedence
  • Point/Spot lights could use distance/illuminance for priority

This approach:

  • Gives developers clear expectations
  • Allows implementations to optimize performance
  • Maintains flexibility for different platforms
  • Provides predictable behavior across scenes

See our protocol implementation for a working example of these concepts.

Copy link
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

We agree that it's better to have shadows as a simple boolean, and let each engine determine things like shadow resolution, priorities, etc.
I changed this in the document


Note: This feature will likely not ba a part of the initial implementation. It's included here to discuss the full vision, but field for this may not be present on the protocol or the SDK until later.

By default lights won’t have shadows. Each light source can chose if they want shadows or not, and if to use hard shadows or soft shadows.

We will add fields for this on the `LightSource` component:

- Shadow type: No shadows / Hard Shadows / Soft shadows

- The creator can chose the shadow resolution as a setting on each light source
- The shadow resolution is picked by the player in the user’s settings, as a global option. If they have low settings they’ll always use low res

## Limitations
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I suggest removing the "Limitations and Considerations" section from this ADR. Here's why:

  1. Separation of Concerns
  • This ADR should focus on defining the light component interfaces and their behavior
  • Implementation details like performance limits should be handled separately:
    • Engine-specific optimizations
    • Platform-specific limitations
    • Scene-level restrictions
  1. Flexibility for Implementations
    Let each explorer/renderer decide how to handle:
  • Maximum number of lights
  • Shadow map allocation
  • Performance optimizations
  • Mobile vs desktop capabilities
  • Low-end vs high-end configurations
  1. SDK's Role
    The SDK can provide:
  • Platform-specific warnings
  • Best practice guidelines
  • Performance recommendations
  • Scene validation tools
  1. Better Documentation Structure
    These topics deserve their own documentation:
  • Performance best practices ADR
  • Scene optimization guide
  • Platform compatibility matrix
  • Implementation guidelines

This approach:

  • Keeps the component specification clean and focused
  • Allows for platform-specific optimizations
  • Enables future improvements without spec changes
  • Lets implementations evolve independently

Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I’m okay with removing the Limitations and Considerations section, but I’d like to challenge this approach slightly. These limitations guide how each client should behave, ensuring consistency across implementations. Without them, we risk significant divergence in how the feature works across clients, which might shift responsibility to creators to adapt to different behaviors.

Creating a separate ADR or RFC for these constraints could work, but we’d need to align on how the protocol should remain generic while still providing a baseline for consistent behavior. I also see the value in keeping this ADR abstract to allow for experimentation and flexibility, but it’s crucial we ensure creators aren’t left with unpredictable experiences due to discrepancies between clients.

Are we ok with having that differences between clients?
If we move this to another ADR, then we need to provide a clear guidelines, tools and documentation for creators to navigate that different clients.

Copy link
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I agree with both, the ADR should focus on the protocol, but sometimes the protocol is more than just the data sent via the transport, it's also about the expected behavior.

I simplified these lines to something more generic:

Each engine is free to determine considerations like shadow resolutions, or putting a limit on the number of shadows being computed and how to prioritize these. It's recommendable to make these variables dependent on user quality settings.


Note: This aspect will likely not ba a part of the initial implementation. It's included here to discuss the full vision, but field for this may not be present on the protocol or the SDK until later. Although restrictions will be applied at an engine level, and each engine could theoretically have different values, it's ideal that we're all aligned on these values, so experiences don't differ accross engines.

We will start with restrictive limitations, and raise them gradually if necessary.

1 light source per parcel. We also need a maximum limit for large scenes.
What is a good number? TDB while developing and testing.

We should also constrain the maximum brightness, otherwise we could completely blind the player. TDB while developing and testing.

If a light is not being rendered because of going over the limits, the engine should print an error message to console, to make creators aware of the reasons.

## Open world considerations

We advise that each engine only renders the lights of the current scene you’re standing on. In this way:

- Neighboring scenes don’t get affected in performance
- Neighboring scenes don’t mess with the esthetic of others, at least not when you’re standing on that other scene.

Engines can add a default behavior of fading lights in/out over a period of a second whenever you switch scenes. This is to avoid abrupt light changes when you walk from one parcel to another.

### Affect global ambient light
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The Global Light section needs more detailed specification. Currently, there's a gap between point/spot lights and scene-wide lighting. Consider:

  1. Global Light Components
    A scene's global lighting should be configurable through two complementary components:
// Core light properties (when attached to root)
interface Light {
  illuminance: number;  // 400 (sunrise) to 10,000 (midday)
  color: Color3;
  shadows: boolean;
}

// Global light specific properties
interface GlobalLight {
  direction?: Vector3;      // Sunlight direction
  ambientColor?: Color3;    // Sky/environment contribution
  ambientBrightness?: number; // Overall scene brightness multiplier
}
  1. Root Entity Behavior
  • Light on root = Override default directional (sun) light
  • GlobalLight on root = Control direction and ambient settings
  • Both components can work independently:
    • Light alone = Change sun color/intensity
    • GlobalLight alone = Change direction/ambient
    • Both = Full control
  1. Default Behavior
    Add specification for default values:
  • Default directional light should match typical daylight
  • Direction could vary with time-of-day (if implemented)
  • Reasonable ambient light for scene visibility

This matches our protocol implementation while providing clear guidance for scene creators and engine implementations.

Copy link
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Agreed, I expanded the section, and added more to the initial definition. I however added this as an additional type, rather than its own component.


Note: This point deserves its own ADR and will be addressed in the future, but it's good to start considering how it will interact.

Creators might want to turn off the default light of the sun, to have better control over lighting conditions. This is essential for example to create a spooky ambiance.

They could be done via a component on the root entity. Otherwise it could be a scene setting in the scene.json. TBD.

It should ideally be possible to do both in worlds and in Genesis City, but perhaps we can start with enabling it just in worlds for now if that’s easier.

To consider: Instead of turning on-off, can we also dim or tint the default light?

## Serialization

```yaml
parameters:
```

```protobuf

```

## Semantics

### Example
Loading