Composition

    In addition to the inheritance system, XKSL introduces the concept of composition. A composition is a member whose type is another shader class. It's defined the same way as variables.

    You can compose with an instance of the desired shader class or an instance of a shader class that inherits from the desired one.

    The compositions are compiled in their own context, meaning that the non-stage variables are only accessible within the composition. It's also possible to have compositions inside compositions.

    Example code: access root context

    2. {
    3.     BaseShader rootShader = stage;
    5.     float4 GetColor()
    6.     {
    7.         return rootShader.GetColor();
    8.     }
    9. };

    This is error-prone, since CompositionShaderC expects BaseShader to be available in the root context.

    You can also create an array of compositions the same way you use an array of values. Since there's no way to know beforehand how many compositions there are, you should iterate using a foreach statement.

    Example code: stage behavior

    The behavior of the stage keyword is straightforward: only one instance of the variable or method is produced.

    1. shader BaseShader
    2. {
    3.     stage float BaseStageValue;
    4.     float NonStageValue;
    5. };
    7. shader TestShader : BaseShader
    8. {
    9.     BaseShader comp0;
    10.     BaseShader comp1;
    11. };
    13. // resulting shader (representation)
    14. shader TestShader
    15. {
    16.     float BaseStageValue;
    17.     float NonStageValue;
    18.     float comp0_NonStageValue;

    This behavior is useful when you need a value in multiple composition but you only need to compute it once (eg the normal in view space).

    The clone keyword has a less trivial behavior. It prevents the stage keyword to produce a unique method.

    1. shader BaseShader
    2. {
    3.     stage float BaseStageMethod()
    4.     {
    5.         return 1.0;
    6.     }
    8.     stage float BaseStageMethodNotCloned()
    9.     {
    10.         return 1.0;
    11.     }
    12. };
    14. shader CompShader : BaseShader
    15. {
    16.     override clone float BaseStageMethod()
    17.     {
    18.         return 1.0 + base.BaseStageMethod();
    19.     }
    21.     override float BaseStageMethodNotCloned()
    22.     {
    23.         return 1.0f + base.BaseStageMethodNotCloned();
    24.     }
    25. };
    27. shader TestShader : BaseShader
    28. {
    29.     CompShader comp0;
    31. };
    33. // resulting shader (representation)
    34. {
    35.     // cloned method
    36.     float base_BaseStageMethod()
    37.     {
    38.         return 1.0;
    39.     }
    41.     float comp0_BaseStageMethod()
    42.     {
    43.         return 1.0 + base_BaseStageMethod();
    44.     }
    46.     float BaseStageMethod() // in fact comp1_BaseStageMethod
    47.     {
    48.         return 1.0 + comp0_BaseStageMethod; // 3.0f
    49.     }
    51.     // not cloned method
    52.     float base_BaseStageMethodNotCloned()
    53.     {
    54.         return 1.0f;
    55.     }
    57.     float BaseStageMethodNotCloned()
    58.     {
    59.         return 1.0f + base_BaseStageMethodNotCloned(); // 2.0f
    60.     }

    This behavior is useful when you want to repeat a simple function but with different parameters (eg adding color on top of another).

    See also