class RED::ISoftLight

Gets the light attenuation at the given shading point.

The attenuation integrates spots & beams falloffs and global light backface culling vs. the current shading point & normal.

Parameters:

Returns:

Returns the beam inner radius if the light is a beam.

Returns:

Returns the beam outer radius if the light is a beam.

Returns:

Gets the light diffuse intensity.

The diffuse intensity of the light is the color to be used while computing the diffuse part of the shading model (a specular intensity is available for for the specular part of the shading model).

Parameters:

Returns the effect distance of the light.

The effect distance of a light is based on its attenuation equation, and represents the sphere of influence of the light. A light source that has no attenuation emits lights up to RED_INVTOL2 units.

Returns:

Returns the lighting layerset.

An object whose layerset intersects the lit layerset of the light source receives lighting from that light source.

Returns:

Returns the light shadow casting layerset.

An object whose layerset intersects the shadow casting layerset of the light source will cast shadows onto other objects.

Returns:

Returns the light shadow receiver layerset.

An object whose layerset intersects the shadow receiver layerset of the light source will receive shadows from other objects.

Returns:

Returns the light type.

Returns:

Returns light information computed for the next sample of an unknown length sampling sequence.

A sampling sequence must have been previously started using RED::ISoftRayContext::PrepareLights.

This method takes into consideration the light source visibility and attenuation due to decay or falloff (returned in 'oLightColor') and calculates shadows (returned in 'oShadowColor').

Task: Iterating over lights in a software shader

Contrary to the GPU version, a software shader contained in the RED::MTL_LIT pass have to loop through the lights in order to cumulate their effect.

Here is a simple code to iterate over the lights and perform sampling when needed:

// let:
// - rayctx be the RED::ISoftRayContext.
// - shaderctx be the RED::ISoftShaderContext.
// - renderctx be the RED::ISoftRenderingContext.
double hit[4], normal[4];
double latt[4];
double ldir[4], lcolor[4], lshadows[4];
bool moresamples;

// Get the ray hit and normal.
rayctx.GetWCSHit( hit );
rayctx.GetWCSNormal( normal, shaderctx.GetRenderCode(), RED_VSH_NORMAL );

// Prepare lights before shading.
// This call is mandatory before accessing the lights.
RC_TEST( rayctx.PrepareLights( hit, normal, false, renderctx ) );

// Iterate over the scene lights.
for( unsigned int i = 0; i < renderctx.GetLightsCount(); ++i )
{
  const RED::ISoftLight& light = renderctx.GetLight( i );

  // Perform culling.
  if( !light.GetAttenuation( latt, rayctx.GetThreadID() ) )
    continue;

  // Sampled light.
  if( light.NeedSampling() )
  {
    moresamples = true;
    while( true )
    {
      RC_TEST( light.GetNextWCSSample( moresamples,
                                       ldir, lcolor, lshadows, 
                                       hit, normal, 
                                       rayctx, renderctx ) );
      if( !moresamples )
        break;

      // Do something with the light sample...
    }
  }
  // Not sampled light.
  else
  {
    // Do something with the light...
  }
}

Parameters:

Returns:

Gets the requested render mode value.

Parameters:

Returns:

Gets the number of samples set for the light.

Note that the sampling uses the GetNextWCSSample method. As a consequence of sampling adaptivity, the real number of samples used to evaluate a light's contribution at a given shading point is not constant.

The number of samples for the light is ignored during sampling unless the RED::OPTIONS_RAY_LIGHTS_SAMPLING_RATE is set to 0.

Returns:

Returns:

Returns the shadow bias for this light.

Returns:

Returns the color of shadows for this light.

Returns:

GetShape: Returns the light source shape address from which this soft light was created.

Returns:

Gets the light specular intensity.

The specular intensity of the light is the intensity to be used while computing the specular part of the shading model (a diffuse color is available for for the diffuse part of the shading model).

Parameters:

Returns the spot angle if the light is a spot.

Returns:

Returns the spot falloff if the light is a spot.

Returns:

Gets the light attenuation at a given point in a volume.

The attenuation integrates spots & beams falloffs and global light backface culling vs. the shaded 'iPoint' position in WCS (whitout any heading).

Parameters:

Returns:

Gets the light bounding sphere in world coordinates space.

The light must be a physical light to have a bounding sphere. For other light types, the function will return the light position and a radius of 0.

Parameters:

Gets the light direction in world coordinates space.

Parameters:

Gets the direction to the light in world coordinate space from a given point.

Returns the direction from 'iPoint' to the light source. 'iSample' is only needed in the case of a varying sample position on an area light. 'iPoint' can be ignored for directional and beam lights and is otherwise required.
The returned direction is normalized.

Parameters:

Gets the light position in world coordinates space.

Parameters:

Gets a light sample for direct lighting integration.

Users should prefer the use of the classical light sampling sequence described in:

Task: Iterating over lights in a software shader

Contrary to the GPU version, a software shader contained in the RED::MTL_LIT pass have to loop through the lights in order to cumulate their effect.

Here is a simple code to iterate over the lights and perform sampling when needed:

// let:
// - rayctx be the RED::ISoftRayContext.
// - shaderctx be the RED::ISoftShaderContext.
// - renderctx be the RED::ISoftRenderingContext.
double hit[4], normal[4];
double latt[4];
double ldir[4], lcolor[4], lshadows[4];
bool moresamples;

// Get the ray hit and normal.
rayctx.GetWCSHit( hit );
rayctx.GetWCSNormal( normal, shaderctx.GetRenderCode(), RED_VSH_NORMAL );

// Prepare lights before shading.
// This call is mandatory before accessing the lights.
RC_TEST( rayctx.PrepareLights( hit, normal, false, renderctx ) );

// Iterate over the scene lights.
for( unsigned int i = 0; i < renderctx.GetLightsCount(); ++i )
{
  const RED::ISoftLight& light = renderctx.GetLight( i );

  // Perform culling.
  if( !light.GetAttenuation( latt, rayctx.GetThreadID() ) )
    continue;

  // Sampled light.
  if( light.NeedSampling() )
  {
    moresamples = true;
    while( true )
    {
      RC_TEST( light.GetNextWCSSample( moresamples,
                                       ldir, lcolor, lshadows, 
                                       hit, normal, 
                                       rayctx, renderctx ) );
      if( !moresamples )
        break;

      // Do something with the light sample...
    }
  }
  // Not sampled light.
  else
  {
    // Do something with the light...
  }
}

This method is for experienced users only who wrote their own light sampling function.

Parameters:

Returns:

Returns true if the light is a skylight.

Parameters:

Returns:

Returns true if the light needs sampling, false otherwise.

Note that sampling based light types are mapped onto centric lights types if the sampling is disabled for the rendering.

Returns: