Activates or deactivates the component.
The returned active state also accounts for the active state of the parent SceneObject.
Range at which the light contribution fades out to zero. Use SetUseAutoAttenuation to provide a radius automatically dependant on light intensity. The radius will cut-off light contribution and therefore manually set very small radius can end up being very physically incorrect.
Determines does this light cast shadows when rendered.
Returns the current color of the light as an RGB value. If the light color mode is set to RGB then this will return the same value as assigned to the RGB color, otherwise the color will be determined from the currently set color temperature.
Determines how is light color calculated.
Determines the color temperature of the light, in Kelvins. Reasonable range is 1000 to 12000 Kelvins, where lower values represent warmer light (orange tint) and higher values represent colder light (blue tint). Only used if light color mode is set to Temperature.
Various flags set on the component that affect it's behavior.
Determines the power of the light source. Units used depend on the selected light unit and light type: - For radial, spot and rectangular lights: - Lumens (Luminous flux) if selected light unit is lumens. Value can be found on most common light bulb packaging. Reasonable values are between 200 and 800 lumens for popular light bulbs. - Watts (Radiant flux) if selected light unit in watts. Note that in this case you must also select the luminous efficacy of the light bulb this light is simulating. The default is for a tungsten incandescent lightbulb where a reasonable value range is 30 to 80 watts for popular light bulbs.
Determines what unit is the light intensity represented as.
Determines whether the component itself is active, without accounting for the active state of the parent scene object.
Determines if the object has been destroyed.
Determines if the component is currently active, enabled and running.
Determines the lumens per watt. This value is only relevant if watts are used as the light intensity value. Some common values are 12-18 for incandescent light bulbs and 75-110 for LED lights. Find a more complete list here: https://en.wikipedia.org/wiki/Luminous_efficacy.
Returns luminous intensity of the light source. Assumes all light sources are punctual. Returns zero for directional lights. Does not account for light profile intensity.
Determines the cases that will trigger the onTransformChanged event.
Profile determining light distribution, as measured by real-world sensors. This will essentially 'mask' light intensity, attenuating it in certain directions across the sphere surrounding the light.
Profile determining light distribution, as measured by real-world sensors. This will essentially 'mask' light intensity, attenuating it in certain directions across the sphere surrounding the light.
Profile determining light distribution, as measured by real-world sensors. This will essentially 'mask' light intensity, attenuating it in certain directions across the sphere surrounding the light.
Returns the PhysicsScene this node is being simulated on.
The signed execution priority of the component.
Determines order of execution of this component in relation to other components, higher priorities will execute earlier.
The priority value determines the order of initialize, enable and update calls.
Valid priorities are in the range [-100...100], other priorities are reserved for internal use.
The priority should not be modified after onCreate has been called.
The default priority for user implement components is -10. BuiltInComponent have a default priority of 0. However, instances that have dependencies or are a dependency to another component might have non zero default priorities. For example, the Camera component has a default priority of 50 as other components may depend on the camera being initialized early. The RigidBody component has a default priority of 22 and Joint components have a priority of 20 as the joint depends on fully initialized rigid bodies.
Returns the SceneInstance this node is attached to.
Returns the SceneObject this component is attached to.
Settings that control shadow rendering, if shadow casting is enabled.
Radius of the light source. If non-zero then this light represents an area light, otherwise it is a punctual light. Area lights have different attenuation then punctual lights, and their appearance in specular reflections is realistic. Shape of the area light depends on light type: - For directional light the shape is a disc projected on the hemisphere on the sky. This parameter represents angular radius (in degrees) of the disk and should be very small (think of how much space the Sun takes on the sky - roughly 0.25 degree radius). - For radial light the shape is a sphere and the source radius is the radius of the sphere.
If enabled the attenuation radius will automatically be controlled in order to provide reasonable light radius, depending on its intensity.
When enabled the light intensity will be determined from the photometric light profile. If disabled the photometric light profile will act as a mask while the actual intensity can be manually specified. Only relevant if photometric light profile is set.
Note that photometric light profiles are measured with the assumption of punctual or very small lights, meaning their intensity will only be correct if you use such light type yourself.
Determines the contribution of this light on the in-scattering effect in volumetric lighting. Value of 0 will disable light's contribution, while value of 1 will contribute the light fully. In visual terms greater values create so called 'light shafts'.
Destroys the component, removing it from its scene object and stopping component updates.
Optionalimmediate: booleanIf true the component will be fully destroyed immediately. This means that objects that are still referencing this component might fail. Normally destruction is delayed until the end of the frame to give other objects a chance to stop using it.
Checks if the component has a specific ComponentFlag bit flag set.
The flag to check.
ProtectedonProtectedonProtectedonVirtualCalled every time a component is placed into the Stopped state.
This method may be called during component destruction, if the component wasn't already in ScenePlayState.Stopped state during destruction. When called during destruction, it is called before onDestroy.
ProtectedonVirtualCalled every time a component leaves the ScenePlayState.Stopped state.
This method might be called during component creation, if the requirements for leaving the stopped state are met. One such case would be a component class that has the runInEditor attribute. When called during creation it is called after onInitialize.
Called at fixed time intervals (e.g. 60 times per frame). Only called if the component is in ScenePlayState.Playing state.
ProtectedonVirtualCalled once when the component first leaves the ScenePlayState.Stopped state.
This method might be called during component creation, if the requirements for leaving the stopped state are met. One such case would be a component class that has the runInEditor attribute. When called during creation it is called after onCreate.
VirtualCalled once per frame, after all other components received their onUpdate invocation. Only called if the component is in ScenePlayState.Playing state.
This method should only be implemented if your component needs logic that implements on other component or SceneObject changes performend in onUpdate. An example could be a camera controller logic that updates in response to changes to the object that is being tracked.
ProtectedonVirtualCalled when the script domain has been refreshed or when the component is initialized. During initialization it is called after onInitialize but before onEnable.
ProtectedonVirtualCalled when the component's parent SceneObject has changed.
The transform flags.
This method is only called if TransformChangedFlag.Transform is set on the Component.notifyFlags. The method will also not be called if the component is currently in the ScenePlayState.Stopped state.
To get the event for editor components that are active outside the simulation, attach the runInEditor attribute to your component class.
VirtualCalled once per frame. Only called if the component is in ScenePlayState.Playing state.
Sets or unsets the specified ComponentFlag bit flag on the instance.
The flag to set.
True to set the flag.
Registers the coroutine for the specified component using the provided args as arguments.
true if the coroutine was registered.
The coroutine will be called for the first time when the coroutine subsystem runs for update events.
There is no guarantee with regards to the order of how coroutines are invoked.
Coroutines are a great way for time-deferred or delayed system. To implement a coroutine simply add a
generator method to your component and register it as coroutine:
public *myCoroutine(text:string)
{
const endTime:number = Time.realElapsed + 3;
while(Time.realElapsed < endTime)
{
yield true;
}
Debug.log("This code will be invoked after 3 seconds with the text=" + text);
}
To register the function simply call
this.startCoroutine(this.myCoroutine, "Hello World!");
The function will be invoked once the coroutine runs. The coroutine function can yield the program
control flow by using the keyword yield. The coroutine will then stop execution at that point,
and pick up the execution in the next update event, right after the yield keyword that caused
the coroutine to pause.
With helper functions such as waitForSeconds or waitForAsyncOp it is easy to create coroutines that pause for a set time interval.
Registers the coroutine for the specified component using the provided args as arguments.
true if the coroutine was registered.
The coroutine will be called for the first time when the coroutine subsystem runs for fixedUpdate events.
There is no guarantee with regards to the order of how coroutines are invoked.
Coroutines are a great way for time-deferred or delayed system. To implement a coroutine simply add a
generator method to your component and register it as coroutine:
public *myCoroutine(text:string)
{
const endTime:number = Time.realElapsed + 3;
while(Time.realElapsed < endTime)
{
yield true;
}
Debug.log("This code will be invoked after 3 seconds!");
}
To register the function simply call
this.startCoroutine(this.myCoroutine, "Hello World!");
The function will be invoked once the coroutine runs. The coroutine function can yield the program
control flow by using the keyword yield. The coroutine will then stop execution at that point,
and pick up the execution in the next fixedUpdate event, right after the yield keyword that caused
the coroutine to pause.
With helper functions such as waitForSeconds or waitForAsyncOp it is easy to create coroutines that pause for a set time interval.
Stops the coroutine for the specified component.
The coroutine to stop.
true if the coroutine was registered.
StaticgetLocates a rsx object by its sceneRuntimeID and UUID.
The runtime ID of the SceneInstance of the object.
The UUID of the object to retrieve.
The object or null if no object with given sceneRuntimeID and uuid has been registered
Illuminates a portion of the scene covered by the light.