Light

Light extends Object, adding functions and properties to it.

A Light is an object that can be placed in the scene to act as a light source.

There are currently 3 types of light: point, spot, and directional.

Note: shadow features are under development and will be available soon.

Constructors

Light ( )

Creates a Light with default properties.

local l = Light()

-- change light properties
l.Radius = 50
l.Color = Color(1.0, 1.0, 0.5)

-- use it as a normal object in the scene
l:SetParent(World)
l.Position = { x, y, z }

Functions

Inherited from Object

Hide

Adds given Object as a child.

Object extensions like Shape or MutableShape are naturally accepted too.

By default, when using AddChild, the child maintains it's LocalPosition. But since the local position remains the same in the new parent, it means the child's world position may change.

The keepWorld optional parameter, false by default, can be used to maintain the child's Position (world position) instead.

It's also a good practice to set child/parent relationships before setting positions.

local o = Object()
local myShape = Shape(Items.someuser.someitem)
o:AddChild(myShape)

Unsets parent/child relationship with child parameter. The child ends up being deleted if it has no other references.

o:RemoveChild(someChildObject)

Unsets parent/child relationship with all children. Individual children end up being deleted if they have no other references.

o:RemoveChildren()
nil GetChild ( integer index )

Get child Object at index.

if o.ChildrenCount > 0 then
  print(o:GetChild(1)) -- prints first child
end

Get Light's parent.

print(myObject:GetParent())

Sets parent/child relationship with parent parameter. nil can be used to remove the Object from its parent.

By default, when using SetParent, the child maintains it's LocalPosition. But since the local position remains the same in the new parent, it means the child's world position may change.

The keepWorld optional parameter, false by default, can be used to maintain the child's Position (world position) instead.

It's also a good practice to set child/parent relationships before setting positions.

local o = Object()
o:SetParent(Map) -- o is now a child of the map
-- (Map is an extension of Object)

Removes the Light from its parent. Doesn't do anything if the Light has no parent.

o:RemoveFromParent()

Converts a local position to world coordinate system.

local p = Number3(1, 2, 3)
local pInWorldCoords = myObject:PositionLocalToWorld(p)

Converts a world position to local coordinate system.

local p = Number3(1, 2, 3)
local pInLocalCoords = myObject:PositionWorldToLocal(p)

Object:RotateLocal(number3) -- euler angles
Object:RotateLocal(number3, number) -- axis angle

Object:RotateWorld(number3) -- euler angles
Object:RotateWorld(number3, number) -- axis angle

Converts a local rotation to world coordinate system.

Converts a world rotation to local coordinate system.

Adds a text bubble at Object's position. For a Shape or Player, the text bubble will appear above its bounding box.

You may use a duration of -1 to set a permanent text bubble.

Returns true if the two Objects may collide with each other.

nil ApplyForce ( Object self, Number3 value )

Apply a force to Object, taking into account its Mass.

Instantaneously remove any ongoing text bubble.

Properties

Angle of the cone of a spot light, default is 0.7 radians. Has no effect on other light types.

Color of the light, white by default.

The hardness of a light source represents the core intensity of the emitted light.

At the minimum value of 0, the lit area will appear diffuse with smooth edges. At its maximum value of 1, it will appear bright with clear sharp edges.

Default hardness is 0.5.

Toggles the light source on and off.

PriorityGroup is a way to create light groups in order of importance from 0 to 255 (default group).

If your world is played on a mobile or lower-end device, the maximum number of simultaneaous lights on screen may vary based on hardware capabilities.

If you want to ensure a smooth gameplay on your world for all users, a good practice is to prioritize all gameplay-essential lights.
For example, if your game features a light torch that the player carries, you could place it in PriorityGroup 0 to ensure it is always rendered first and leave other lights that are part of the environment in a lower group.

You can assign as many lights as you want per group, however only groups order is garanteed, lights within a given group are rendered unordered.

Radius of a point light. Alias to Light.Range for convenience.

Range of the light, 30 by default. Has no effect for directional lights.

LightType Type

The light type can be one of LightType.Point (by default), LightType.Spot, or LightType.Directional.

Note that it can be changed at any time.

Inherited from Object

Hide

Light's constant acceleration in world coordinates per second squared.

⚠️ Acceleration will only affect Light's position while Light.Physics is true.

-- Acceleration can be used to compensate gravity: 
myObject.Acceleration = -Config.ConstantAcceleration
-- myObject's acceleration is now the invert of 
-- Config.ConstantAcceleration, cancelling it.

Collision groups the Light belongs to.

⚠️ It doesn't mean the Light will collide with other Objects in these groups.

If the Light belongs to group number 3 for example, it means all Objects that have group number 3 in their Object.CollidesWithGroups property will collide with it.

By default:
- Objects collide with the Map and other Objects
- Players collide with the Map only

That can all be configured differently depening on your needs.

local object1 = Object()
local object2 = Object()
-- It's not mandatory to set Physics to true
-- An object with Physics set to false contributes to the
-- physics simulation as a static item (can't be moved)
object1.Physics = true
object2.Physics = true

-- making sure 2 objects collide with each other
-- NOTE: by default:
-- Map.CollisionGroups == {1},
-- Player.CollisionGroups == {2},
-- Object.CollisionGroups == {3}
object1.CollisionGroups = {5}
object2.CollisionGroups = {5}
object1.CollidesWithGroups = {1, 5} -- collides with Map + objects in group 5
object2.CollidesWithGroups = {1, 5} -- collides with Map + objects in group 5

-- would also work this way if you don't 
-- remember Map's group (which can be changed too by the way)
object1.CollidesWithGroups = Map.CollisionGroups + {5}

-- making an object collides with the Map and Players
local object = Object()
object.CollidesWithGroups = Map.CollisionGroups + Player.CollisionGroups

-- for Player (local player) to collide with other players and the Map
Player.CollidesWithGroups = Map.CollisionGroups + Player.CollisionGroups

Collision groups the Light collides with.

By default:
- Objects collide with the Map and other Objects
- Players collide with the Map only

That can all be configured differently depening on your needs.

local object = Object()
-- It's not mandatory to set Physics to true
-- An object with Physics set to false contributes to the
-- physics simulation as a static item (can't be moved)
object.Physics = true

-- making an object collide with the Map and Players
object.CollidesWithGroups = Map.CollisionGroups + Player.CollisionGroups

-- for an Object to collide with other objects only
-- (won't collide with the map)
object.CollidesWithGroups = object.CollisionGroups

-- for Player (local player) to collide with other players and the Map
Player.CollidesWithGroups = Map.CollisionGroups + Player.CollisionGroups

-- making sure 2 objects collide with each others
-- NOTE: by default:
-- Map.CollisionGroups == {1},
-- Player.CollisionGroups == {2},
-- Object.CollisionGroups == {3}
local object1 = Object()
local object2 = Object()
object1.CollisionGroups = {5}
object2.CollisionGroups = {5}
object1.CollidesWithGroups = {1, 5} -- collides with Map + objects in group 5
object2.CollidesWithGroups = {1, 5} -- collides with Map + objects in group 5

-- would also work this way if you don't 
-- remember Map's group (which can be changed too by the way)
object1.CollidesWithGroups = Map.CollisionGroups + {5}

Turns physic simulation on/off when set.

⚠️ When turned off, Light.Velocity & Light.Motion are set to {0,0,0}.

nil by default. Can be set to a function that will be triggered when the Light collides with another Object.

The function is called with 3 parameters: the object the callback was set for, the other actor in the collision and the Face of the first actor that's in contact.

Note: it's not necessary to do use all 3 parameters.

object.OnCollision = function(o1, o2)
  -- `o1` is `object` here
  print("collision detected between", o1, "and", o2)
end

object.OnCollision = function(o1, o2, face)
  -- `o1` is `object` here
  print("collision detected between", o1, "'s", face, "and", o2)
end

nil by default. Can be set to a function that will be triggered when the Light ends colliding with another Object.

The function is called with 2 parameters: the object the callback was set for and the other actor in the collision.

object.OnCollisionEnd = function(o1, o2)
  -- `o1` is `object` here
  print("collision ended between", o1, "and", o2)
end

Executed when the Pointer is dragged (moved while down). Receives a PointerEvent parameter, just like Pointer.Drag.

(nil by default)

myObject.OnPointerDrag = function(pointerEvent)
  print("dx:", pointerEvent.DX, "dy:", pointerEvent.DY)
end

Position of the Light in the world.

local o = Object()
-- places the object where the local player is
o.Position = Player.Position
boolean IsOnGround read-only

true when the Light is not falling.

⚠️ IsOnGround only makes sense when Light.Physics is true.

Can be set to true for the Light to be hidden.
Nothing else changes, the Light remains in the scene and it keeps being affected by the simulation (collisions, etc.).

Position of the Light in its parent.
In other words, LocalPosition refers to the position of the Light relative to the {0,0,0} position of its parent.

Rotation of the Light in the world (as seen on screen).

While it usually works for simple operations (like Rotation.X = Rotation.X + someAngle), we advise you to use Number3.Rotate to rotate an object around X, Y & Z axis.

You can also set unit vectors like Light.Up, Light.Right or Light.Forward to orient your object.

local o = Object()
o.Rotation = {0, math.pi, 0}
-- o revolved half a turn on Y axis

-- another way to rotate the object:
o.Forward:Rotate({0, 0, math.pi / 2})
o.Forward = Camera.Forward

Tick is a function executed ~30 times per second when set (nil by default). Provides the Light and elapsed time in seconds as parameters.

-- executed ~30 times per second on each user device
myObject.Tick = function(object, dt)
  print("elapsed:", dt, "seconds")
end

Rotation of the Light in its parent.

Nested Object local rotations are combined to obtain the "world rotation" (Object.Rotation), the Object's final on-screen rotation.

Velocity of the Light in world coordinates per second.

⚠️ Velocity will only affect Light's position while Light.Physics is true. Whenever it is set to false, Velocity is set to {0,0,0}.

-- makes myObject jump:
myObject.Velocity.Y = 100

Be aware, this Motion property is a hack regarding laws of physics. (sorry Isaac)

But it's very practical to move objects without worrying about forces at play.

This is what's being used by default when you're moving around with your avatar (see Client.DirectionalPad). It's the reason why you can stop moving horizontally while in the air.

Basically, Motion is an instantaneous displacement that contributes to moving Light every frame, without changing Light.Velocity directly.

Motion is expressed in world coordinates per second.

⚠️ Motion will only affect Light's position while Light.Physics is true. Whenever it is set to false, Motion is set to {0,0,0}.

local speed = 10
myObject.Motion = Camera.Forward * speed
-- myObject will move in the same direction the camera is currently facing.
-- If the Camera rotates after this, it won't change where myObject is heading.

Scale of the Object, in its parent.

Nested Object local scales are combined to obtain the "world scale" (Object.LossyScale), the Object's final scale.

myObject.LocalScale = 2 -- the Object is now 2 times bigger
topLevelObject.LocalScale = 2
local o = Object()
o.LocalScale = 0.5
topLevelObject:AddChild(o) -- o becomes a child of topLevelObject
-- o ends up being displayed with a scale of 1
number LossyScale read-only

Convenience property that attempts to match the actual world scale as much as it can. Note that Objects that have multiple levels of nested rotations and scales will return a skewed lossy scale.

The mass of the Object determines how much a given force can move it and whether or not another object can be pushed by it. It cannot be zero, a neutral mass is a mass of 1.

The combined friction of 2 Objects in contact represents how much the moving Object will be able to slide along the colliding Object. It is a rate between 0 (full stop on contact) and 1 (full slide, no friction), values higher than 1 are allowed and will create an increasing momentum, like sliding on ice.

The combined bounciness of 2 Objects in contact represents how much of the moving Object's velocity is produced after being in contact with colliding Object, it is a rate between 0 (no bounce) and 1 (100% of the velocity bounced). Values higher than 1 are allowed and will create an increasing momentum at each bounce (try at your own risk).

All Objects have a collision box that represents the space occupied in the scene with regards to collisions. For Shapes and Players, the collision box is updated with their bounding box. For Objects, it is a 1-cube by default after physics was enabled for the first time.

Returns number of child Objects.

Up is a unit vector (vector with a length of 1). It determines which direction is "up" for the Light.

Setting it is a way to rotate the Light.

Right is a unit vector (vector with a length of 1). It determines which direction is "right" for the Light.

Setting it is a way to rotate the Light.

Forward is a unit vector (vector with a length of 1). It determines which direction is "forward" for the Light.

Setting it is a way to rotate the Light.

Left is a unit vector (vector with a length of 1). It determines which direction is "left" for the Light.

Setting it is a way to rotate the Light.

Down is a unit vector (vector with a length of 1). It determines which direction is "down" for the Light.

Setting it is a way to rotate the Light.

Backward is a unit vector (vector with a length of 1). It determines which direction is "backward" for the Light.

Setting it is a way to rotate the Light.