A shader is a GPU program there are four types currently supported. Vertex, which process the vertices position send on the GPU. Fragment is used to calculate the shading of pixels. Compute that allows you to run generic computation on the GPU and store the result to a Texture that can also be transferred to local memory for CPU processing. Finally, geometry (C/C++ only) that allows you to process primitives (as in triangles, lines etc...)

Shaders are attached to a Material that in turn provides available Texture (aka. Sampler) to the program. Sampler can be used in your program for texture mapping and other types of processing. Without a Shader attached a Material is unable to draw anything; either on screen or to a render target.

To give you a higher level of flexibility uniforms, an external variable that is declared inside your program. This special type of variable that can then be modified at runtime to drive certain parameters or to steer the internal behavior of your shader.

Static Variables

Name	Description
`asset`	Reference to the parent Asset where the Shader is contained.
Declaration Asset *asset
`vertex_code`	Stream that contains the raw vertex shader Shader code.
Declaration Stream vertex_code Remarks Only available within the editor environment, the final used for publishing only contain the `vertex_shader` code.
`fragment_code`	Stream that contains the raw fragment shader Shader code.
Declaration Stream fragment_code Remarks Only available within the editor environment, the final used for publishing only contain the `fragment_shader` code.
`vertex_shader`	Stream containing the parsed, converted and optionally optimized vertex shader code ready to be sent to GPU.
Declaration Stream vertex_shader Warning In the final package used for publishing the `vertex_shader` will be cleared as soon it is sent to the GPU (see `Shader::Build`).
`fragment_shader`	Stream containing the parsed, converted and optionally optimized fragment shader code ready to be sent to GPU.
Declaration Stream fragment_shader Warning In the final package used for publishing the `fragment_shader` will be cleared as soon it is sent to the GPU (see `Shader::Build`).
`nodetree`	Reference to the NodeTree used for visual Shader node programming.
Declaration NodeTree *nodetree Note The NodeTree and all associated Node Definition Tags will not be part of the final published project. It only resides in development mode to generate the final vertex, fragment or compute Shader code.
`compute`	Compute reference handling the settings of a compute Shader.
Declaration Compute *compute
`attribute_count`	Total amount of Attribute currently available within your Shader.
Declaration unsigned char attribute_count
`uniform_count`	Amount of Uniform variables present in your Shader.
Declaration unsigned char uniform_count

Variables

Name	Description
`optimize`	Enable or disable Shader optimization (editor only).
Declaration bool optimize
`revision`	Internal code revision number.
Declaration unsigned int revision Remarks Within the editor if you change this variable manually it will force the system to refresh Uniform variables and re-upload the Shader on GPU.

Functions

Name	Description
`SetUniformInt`	Helper to update an integer Uniform value.
Declaration bool SetUniformInt( const char name, int value ) Parameters* `name`: Name of the Uniform to access. `value`: The new value to assign to the Uniform. Return Value `true` if the Uniform value have successfully been updated; else return `false` if the Uniform does not exists or if it is set as constant.
`SetUniformFloat`	Helper to update a float Uniform value.
Declaration bool SetUniformFloat( const char name, float value ) Parameters* `name`: Name of the Uniform to access. `value`: The new value to assign to the Uniform. Return Value `true` if the Uniform value have successfully been updated; else return `false` if the Uniform does not exists or if it is set as constant.
`SetUniformVec2`	Update an existing two dimensional Uniform value.
Declaration bool SetUniformVec2( const char name, const vec2 value ) Parameters* `name`: Name of the Uniform to access. `value`: The new vector value to assign to the Uniform. Return Value `true` if the Uniform value have successfully been updated; else return `false` if the Uniform does not exists or if it is set as constant.
`SetUniformVec3`	Update an existing vector 3d or color (RGB) Uniform value.
Declaration bool SetUniformVec3( const char name, const vec3 value ) Parameters* `name`: Name of the Uniform to access. `value`: The new vector or color value to assign to the Uniform. Return Value `true` if the Uniform value have successfully been updated; else return `false` if the Uniform does not exists or if it is set as constant.
`SetUniformVec4`	Update an existing four dimensional vector or color (RGBA) Uniform value.
Declaration bool SetUniformVec4( const char name, const vec4 value ) Parameters* `name`: Name of the Uniform to access. `value`: The new vector or color value to assign to the Uniform. Return Value `true` if the Uniform value have successfully been updated; else return `false` if the Uniform does not exists or if it is set as constant.
`SetUniformMat2`	Helper to set the value of a two dimensional Uniform matrix.
Declaration bool SetUniformMat2( const char name, const mat2 value ) Parameters* `name`: Name of the Uniform to access. `value`: The matrix 2d to assign to the Uniform. Return Value `true` if the Uniform value have successfully been updated; else return `false` if the Uniform does not exists or if it is set as constant.
`SetUniformMat3`	Remove a RenderLayer by index.
Declaration bool SetUniformMat3( const char name, const mat3 value ) Parameters* `name`: Name of the Uniform to access. `value`: The new 3d matrix to assign to the Uniform. Return Value `true` if the Uniform value have successfully been updated; else return `false` if the Uniform does not exists or if it is set as constant.
`SetUniformMat4`	Function that update the value of a 4x4 Uniform matrix value.
Declaration bool SetUniformMat4( const char name, const mat4 value ) Parameters* `name`: Name of the Uniform to access. `value`: A 4x4 matrix to assign to the Uniform. Return Value `true` if the Uniform value have successfully been updated; else return `false` if the Uniform does not exists or if it is set as constant.
`SetUniformArray`	Helper to update an existing Uniform array.
Declaration bool SetUniformArray( const char name, unsigned char num_items, unsigned char size, const void array ) Parameters `name`: Name of the Uniform to access. `num_items`: The number of items the array contains. `size`: The size of each element of the array. `array`: The array to assign to the Uniform. Return Value `true` if the array is updated successfully; `false` if the Uniform does not exists or if the item size or the number of items does not match the array defined in the Shader. Example Lua -- Define the weight array. local kernel = { 1.0/256.0, 1.0/64.0, 3.0/128.0, 1.0/64.0, 1.0/256.0, 1.0/64.0, 1.0/16.0, 3.0/32.0, 1.0/16.0, 1.0/64.0, 3.0/128.0, 3.0/32.0, 9.0/64.0, 3.0/32.0, 3.0/128.0, 1.0/64.0, 1.0/16.0, 3.0/32.0, 1.0/16.0, 1.0/64.0, 1.0/256.0, 1.0/64.0, 3.0/128.0, 1.0/64.0, 1.0/256.0 } -- Define the offset array. local offsets = { -2,-2, -1,-2, 0,-2, 1,-2, 2,-2, -2,-1, -1,-1, 0,-1, 1,-1, 2,-1, -2, 0, -1, 0, 0, 0, 1, 0, 2, 0, -2, 1, -1, 1, 0, 1, 1, 1, 2, 1, -2, 2, -1, 2, 0, 2, 1, 2, 2, 2 } -- Get the number of items contained in the kernel array. local sample_size = table.getn( kernel ) -- Send the kernel array to the shader. this.shader:SetUniformArray( "_kernel[0]", -- Start placing elements at the beginning of the uniform array. sample_size, -- How many elements to place. 1, -- The size of each element. kernel ) -- The Lua table containing the kernel array elements. -- Resample the size (since the offset should be a vec2) sample_size = table.getn( offsets ) / 2 -- Send the offset array to the shader. this.shader:SetUniformArray( "_offsets[0]", -- Start placing elements at the beginning of the uniform array. sample_size, -- How many elements to place. 2, -- The size of each element. offsets ) -- The Lua table containing the offset array elements.
`GetUniformInt`	Retrieve the value of an integer Uniform.
Declaration int GetUniformInt( const char name ) Parameters* `name`: Name of the Uniform. Return Value `0` if Uniform does not exists; else return the active integer value of the Uniform.
`GetUniformFloat`	Retrieve the value of a floating point Uniform.
Declaration float GetUniformFloat( const char name ) Parameters* `name`: Name of the Uniform. Return Value `0.0` if Uniform does not exists; else return the active floating point value of the Uniform.
`GetUniformVec2`	Retrieve the value of a two dimensional vector Uniform.
Declaration vec2 GetUniformVec2( const char name ) Parameters* `name`: Name of the Uniform Return Value A zeroed 2d vector value if Uniform does not exists; else return the active two dimensional vector values currently set to the Uniform.
`GetUniformVec3`	Retrieve the value of a tri dimensional vector or color (RGB) Uniform.
Declaration vec3 GetUniformVec3( const char name ) Parameters* `name`: Name of the Uniform Return Value A zeroed tri-dimensional vector or RGB color value if Uniform does not exists; else return the active 3d vector values currently assigned to the Uniform.
`GetUniformVec4`	Retrieve the value of a 4d ector or color (RGBA) Uniform.
Declaration vec4 GetUniformVec4( const char name ) Parameters* `name`: Name of the Uniform Return Value A zeroed 4d vector or RGBA color value if Uniform does not exists; else return the active 4d vector values currently assigned to the Uniform.
`GetUniformMat2`	Helper to retrieve the current 2x2 matrix value assigned to an existing Uniform.
Declaration mat2 GetUniformMat2( const char name ) Parameters* `name`: Name of the Uniform Return Value A zeroed 2x2 matrix if Uniform does not exists; else return the active 2x2 matrix currently assigned to the Uniform.
`GetUniformMat3`	Helper to retrieve the current 3x3 matrix value assigned to an existing Uniform.
Declaration mat3 GetUniformMat3( const char name ) Parameters* `name`: Name of the Uniform Return Value A zeroed 3x3 matrix if Uniform does not exists; else return the active 3x3 matrix currently assigned to the Uniform.
`GetUniformMat4`	Helper to retrieve the current 4x4 matrix value assigned to an existing Uniform.
Declaration mat4 GetUniformMat4( const char name ) Parameters* `name`: Name of the Uniform Return Value A zeroed 4x4 matrix if Uniform does not exists; else return the active 4x4 matrix currently assigned to the Uniform.
`UseNodes`	Enable or disable the use of a NodeTree for the current Shader.
Declaration NodeTree UseNodes( bool use_nodes ) Parameters* `use_nodes`: `true` to create a new NodeTree; `false` to remove the current one attached to the active Shader. Return Value Reference of the NodeTree attached to the Shader (if any); else return `nil`.
`IsUsingNodes`	Function to determine whether or not the active Shader is using nodes to generate its code.
Declaration bool IsUsingNodes( void ) Return Value `true` if the Shader is currently using a NodeTree; else return `false`.
`Build`	Build the current Shader and create/update it on GPU.
Declaration bool Build( void ) Return Value `true` if the Shader is compiled and have successfully been uploaded on the GPU; `false` if a compilation error occur.
`GetUniformAt`	Generic helper to access a specific Uniform.
Declaration Uniform GetUniformAt( unsigned char index ) Parameters* `index`: Index of the Uniform to access. Return Value `nil` if the index provided is out of bounds; else return a reference to the corresponding Uniform.
`GetAttributeAt`	Directly access a specific Attribute by index.
Declaration Attribute GetAttributeAt( unsigned char index ) Parameters* `index`: Index of the Attribute to retrieve. Return Value Reference to the Attribute at `index`; else return `nil` if the index is invalid.
`SetStorageSize`	Function to set the storage size of a Compute Shader.
Declaration bool SetStorageSize( float size_x, float size_y, bool absolute ) Parameters `size_x`: The width of the Compute output. `size_y`: The height of the Compute output. `absolute`: Determine if the size value are absolute or relative. Return Value `true` if the active Shader type is set to `kCompute`; else return `false`.
`SetStorage`	Helper to assign a specific storage Texture to an existing compute Shader slot.
Declaration bool SetStorage( const unsigned char index, Texture storage, bool read_write ) Parameters* `index`: Index of the storage slot to update. `storage`: An existing Texture of the type `kStorage`. `read_write`: Determine wether or not the compute Shader result should be written in the the Texture Texmap data. To disconnect the Texture associated to the slot pointed by `index`; pass `nil` to the function. Return Value `true` on success; `false` if the index slot is invalid, if the `storage` refer to a Texture that is not of the type `kStorage`.
`GetStorage`	Helper that returns the active storage Texture reference for a specific slot.
Declaration Texture GetStorage( const unsigned char index ) Parameters* `index`: Index of the slot to retrieve its storage Texture reference. Return Value `nil` if not storage Texture is connected to the slot pointed by index; or if the index is invalid; else return the reference to the Texture connected to the slot.

Compute

Available settings when the Shader type is set to kCompute.

Static Variables

Name	Description
`size`	Current size of the data set that will be handled by the compute Shader.
Declaration vec2 size
`absolute`	Determine wheter or not the `size` of the compute Shader is absolute (pixels) or a ratio relative to the backbuffer size.
Declaration bool absolute
`width`	The width of the compute Shader data set.
Declaration unsigned short width
`height`	The height of the compute Shader data set.
Declaration unsigned short height
`workgroup`	Size of the compute Shader workgroup that will be handling the data set.
Declaration vec2 workgroup

UniformValue

Structure to access read-only values and properties of a Uniform value.

Static Variables

Name	Description
`type`	The internal data type of the Uniform (as specified by OpenGL & ES).
Declaration unsigned int type
`index`	Index assigned to the Uniform is the case it is a Sampler.
Declaration unsigned int index Remarks This value is the one set within the Shader code; in example `uniform sampler2D SAMPLER2` will set the `index` value to `2`.
`_int`	Access the integer value assigned to the active Uniform.
Declaration int _int Attention Return `0` if the Uniform type is not an integer.
`_float`	Access the floating point value assigned to the active Uniform.
Declaration float _float Attention Return `0.0` if the Uniform is not of the type float.
`_vec2`	Access the 2d vector value assigned to the active Uniform.
Declaration vec2 _vec2 Attention Return a zeroed vector if the Uniform type is not a vector 2d.
`_vec3`	Access the 3d vector value assigned to the active Uniform.
Declaration vec3 _vec3 Attention Return a zeroed vector if the Uniform type is not a vector 3d.
`_vec4`	Access the 4d vector value assigned to the active Uniform.
Declaration vec4 _vec4 Attention Return a zeroed vector if the Uniform type is not a vector 4d.
`_mat2`	Access the 2x2 matrix value assigned to the active Uniform.
Declaration mat2 _mat2 Attention Return a zeroed 2x2 matrix if the Uniform type is not a matrix 2d.
`_mat3`	Access the 3x3 matrix value assigned to the active Uniform.
Declaration mat3 _mat3 Attention Return a zeroed 3x3 matrix if the Uniform type is not a matrix 3d.
`_mat4`	Access the 4x4 matrix value assigned to the active Uniform.
Declaration mat4 _mat4 Attention Return a zeroed 4x4 matrix if the Uniform type is not a matrix 4d.

Uniform

Read-only properties and settings of a Uniform defined inside a Shader code. By default, all uniforms will be accessible just like a regular member variable accessible from within the editor.

However, in the event, you do not want this variable to be access during development and strictly want to control it using code (either by Script or using a C/C++ plugin) simply add an _ to its name.

In example declaring the following: uniform float _gKernelSize; will prevent _gKernelSize to be accessed by the user. Removing the _ at the beginning of the Uniform name will tell the system to treat it as a regular member variable available to the user of the Shader.

Additionally applicable on uniforms of the type vec3 and vec4; adding the keyword color (case insensitive) will tell the system that the Uniform should be treated as RGB or RGBA and not a vector. As an example declaring uniform vec4 light_color; will allow you to have access to the color picker while modifying the Uniform within the editor; while just calling it: uniform vec4 light; will consider the Uniform as a regular 4d vector.

Static Variables

Name	Description
`location`	Internal location index assigned to the Uniform by the GPU.
Declaration int location
`builtin`	Determine wheter or not the Uniform is user defined or builtin.
Declaration bool builtin
`constant`	Boolean that represent if the Uniform is a constant or a mutable value.
Declaration bool constant
`value`	Access the UniformValue of the Uniform.
Declaration UniformValue value
`name`	The name of the Uniform.
Declaration char *name

Attribute

A structure that accesses the active properties and settings of the vertex attributes contained in the Shader code.

Static Variables

Name	Description
`location`	Internal location index assigned to the Attribute by the GPU.
Declaration int location
`type`	The internal data type of the Attribute (as specified by OpenGL & ES).
Declaration unsigned int type
`index`	Index assigned to the Attribute is the case it is a Sampler.
Declaration unsigned int index Remarks This value is the one set within the Shader code; in example `attribute vec2 TEXCOORD2` will set the `index` value to `2`.
`builtin`	Boolean value that determine if the Attribute is builtin or user defined.
Declaration bool builtin
`name`	The name of the Attribute as defined in the Shader code.
Declaration char *name

ShaderType

Constant identifier to represent the type of Shader that can be accessed through the scripting interface.

kVertex: Identify a vertex shader.
kFragment: Identify a fragment shader.
kCompute: Identify a compute shader.

Builtins

To facilitate writing shader and to bridge the underlying API with GLSL various type of builtins variables and definitions are at your disposal. The following subsections list and explain each and every one of them that are available while writing your shaders.

Attributes

Name	Description
`POSITION`	Vertex position in model space.
Declaration vec3 POSITION
`WEIGHT`	Weight index and count.
Declaration vec2 WEIGHT
`POINTSIZE`	Point size of the vertex.
Declaration float POINTSIZE
`NORMAL`	Vertex normal in model space.
Declaration vec3 NORMAL
`TEXCOORD`	Texture coordinates for the channel pointed by index.
Declaration vec2 TEXCOORD(0,1,2,3)
`TANGENT`	Tangent coordinates for the channel pointed by index.
Declaration vec4 TANGENT(0,1,2,3) Example GLSL `mat3 tbn; tbn[2] = normalize( gfx_NormalMatrix * NORMAL ); tbn[0] = normalize( gfx_NormalMatrix * TANGENT0.xyz ); tbn[1] = cross( tbn[2], tbn[0] ) * TANGENT0.w;`
`COLOR`	Vertex color for the channel pointed by index.
Declaration vec4 COLOR(0,1,2,3)

Uniforms

Name	Description
`SAMPLER`	Predefined uniform sampler definition for each type supported.
Declaration uniform sampler2D SAMPLER(channel index) uniform sampler3D SAMPLER(channel index) uniform samplerCube SAMPLER(channel index) uniform samplerBuffer SAMPLER(channel index) uniform sampler2DArray SAMPLER(channel index) Example GLSL `// Example of a SAMPLER layout inside a fragment shader. uniform sampler2D SAMPLER0; // baseColor uniform sampler2D SAMPLER1; // surface uniform sampler2D SAMPLER2; // position uniform samplerBuffer SAMPLER3; // bvh_data uniform samplerBuffer SAMPLER4; // tri_data uniform samplerBuffer SAMPLER5; // lvh_data uniform sampler2DArray SAMPLER6; // tex_data uniform sampler2DArray SAMPLER7; // ies_data`
`gfx_ModelViewMatrix`	4x4 matrix evaluated by multiplying the active model matrix with the active view matrix.
Declaration mat4 gfx_ModelViewMatrix
`gfx_ProjectionMatrix`	The projection matrix of the active Camera.
Declaration mat4 gfx_ProjectionMatrix
`gfx_ModelViewProjectionMatrix`	The current 4x4 modelview matrix multiplied by the active projection matrix.
Declaration mat4 gfx_ModelViewProjectionMatrix
`gfx_ViewMatrix`	The 4x4 view matrix of the active Camera.
Declaration mat4 gfx_ViewMatrix
`gfx_ModelMatrix`	Active model matrix used to transform each Geometry vertex.
Declaration mat4 gfx_ModelMatrix
`gfx_NormalMatrix`	3x3 matrix that contains the normalized rotational part of the model matrix.
Declaration mat3 gfx_NormalMatrix
`gfx_ViewMatrixInverseTranspose`	The inverse and transposed modelview matrix allowing to convert back (ie) normals to worldspace.
Declaration mat4 gfx_ViewMatrixInverseTranspose
`gfx_Viewport`	Active viewport boundaries; where `xy` represent its location on the backbuffer and `zw` the width and height.
Declaration vec4 gfx_Viewport
`gfx_Stats`	Access the current statistics.
Declaration vec4 gfx_Stats Remarks The `x` component give you access to the current frame delta time, `y` the application time, `z` the current frame number and `w` the current FPS.
`gfx_Mirror`	Allows you to detect mirrored instanced Geometry and invert its culling/normal direction.
Declaration float gfx_Mirror Example GLSL `// Typical TBN calculation taking in consideration mirrored instances. normal = ( normal.x * tbn[0] ) + ( gfx_Mirror * normal.y * tbn[1] ) + ( normal.z * tbn[2] );`
`gfx_CameraPosition`	Active camera location in world space.
Declaration vec3 gfx_CameraPosition
`gfx_CameraDirection`	Normalized direction vector of the active camera in world space.
Declaration vec3 gfx_CameraDirection

Variables

For each definition listed below all, you have to do use them within your shader is to copy and paste their associated code. Once the Shader parser detect them it will automatically append and fill the value of the definition.

In example writing #define MOBILE in your Shader will result in the following input that will be sent to the GPU: #define MOBILE 1 (1 meaning that NRG is running on a mobile device and 0 means a regular desktop PC.)

Name Description

MOBILE Allows you to determine if the Shader is compiled on a mobile device (1) or on a regular desktop PC (0).

Declaration

#define MOBILE

GPU_TYPE The type of GPU compiler the Shader have been compiled with.

Declaration

#define GPU_TYPE

GPU	Value	Remark
`0`	Intel	Intel based GPU; use in combination with `MOBILE` to detect mobile and desktop shader compiler.
`1`	ATI
`2`	Nvidia	Take note that Nvidia is also producing mobile GPU; consider also using the `MOBILE` to determine.
`3`	MALI	ARM Mali multimedia SoC.
`4`	PowerVR	PowerVR embedded graphics processors series.
`-1`	Unknown	The parser was unable to detect the active GPU.

BACKBUFFER_WIDTH The width of the backbuffer in pixel (total application screen width).

Declaration

#define BACKBUFFER_WIDTH

Warning: This value is compiled statically and is not dynamic. In other words, if your application window can be resized this value will be updated. If it is the case consider using gfx_Viewport.

BACKBUFFER_HEIGHT The height of the backbuffer (available screen width).

Declaration

#define BACKBUFFER_HEIGHT

Warning: This value is compiled statically and is not dynamic. In other words, if your application window can be resized this value will be updated. If it is the case consider using gfx_Viewport.

Compute Shader

To ensure compatibility with all systems the way compute shader is written have been unified and simplified to mimic a regular fragment shader. Take the code below in example based on the ShaderToy default shader which has been converted to work with the NRG compute shader system:

GLSL

uniform vec4 gfx_Stats; // Built-in frame stats uniform.
uniform vec4 gfx_Viewport; // Built-in viewport uniform.
void main() {
   vec2 uv = gl_FragCoord.xy / vec2( gfx_Viewport.z, gfx_Viewport.w ); // Normalized pixel coordinates (from 0 to 1)
   vec3 col = 0.5 + 0.5*cos((gfx_Stats.y)+uv.xyx+vec3(0,2,4));    // Time varying pixel color using the current frame number.
   gl_FragData[0] = vec4(col,1.0); // Output to storage at index 0.
}

As you can see code above is no different from a regular fragment shader that render to texture; the only exception is that the rendering will be outputted into a kStorage texture instead of a kAttachment.

In other words, writing a compute shader using NRG is basically the same as writing a fragment shader. The internal system will handle all the conversion work (and optionally even writing the data set output to local memory) to ensure that your compute shaders can be reused as a regular fragment shader on platforms that do not support them.

To insure a proper integration on modern, mobile and/or compute shader extensions on older systems; the Shader parser will automatically enable the following features:

#extension GL_ARB_shading_language_420pack : enable
#extension GL_ARB_shader_image_load_store : enable
#extension GL_ARB_compute_shader : enable

Pragma Include

To facilitate coding by reusing existing code, functions and global definitions throughout multiple Shader the instruction #pragma include is available in your toolset. Since not all versions on OpenGL and OpenGLES support the include instructions (either natively or through extension) this alternate method handled directly by the internal parser allows you to connect existing Shader code using this directive.

If the #pragma include directive is included inside a vertex shader the vertex code of the Shader will be available; the same rule applies if it is a fragment shader.

To use the directive inside your code all you have to do is to add the following statement: #pragma include "dir/shader_asset_name". Once the Shader gets compiled the internal parser will automatically extract the path and will look for the Shader Asset specified and append the appropriate code at the location where the directive is declared.

GLSL

//#pragma include "dir/shader_asset_name"
#pragma include "shaders/common"

Pragma Parameter

Another directive is also available to you to deal with uniform variables; #pragma parameter. Using it before the uniform declaration will allow you to specify its range, step and default value.

The following example illustrate how to use and format the directive.

GLSL

//#pragma parameter <uniform_name> "<comment>" <min_value> <max_value> <step> <default_value>
#pragma parameter g_MyExposure "Exposure Level." 0.0 2.0 0.1 1.25
uniform float g_MyExposure;