gliConfig

//////////////////////////////////////////////////////////////
//
//   GLI - openGL Intercept Configuration file
//
//////////////////////////////////////////////////////////////
//
// (Note: all options are case sensetitive)
//
//////////////////////////////////////////////////////////////

//ProfileName = "Basic Logging";
//ProfileDescription = "Does Basic Logging";

//////////////////////////////////////////////////////////////
//
//  Log Options:
//
//////////////////////////////////////////////////////////////
//
//  LogEnabled      - Enable function call logging
//
//  LogFlush        - If true, will flush the logger after each OpenGL call is made.
//                    This is useful to catch a OpenGL call that crashes the
//                    application. This only applies to text file logging.
//
//  LogPath         - Path to store the logged files. If not specified, files
//                    will be stored relative to the GLI OpenGL dll.
//
//  LogFileName     - The name of the file to log to (without extension)
//
//  AdditionalRenderCalls - Names of additional OpenGL functions that are to be treated as render calls.
//                    (extra frame and state info can be dumped at render calls)
//
//  LogMaxNumFrames - The maximum number of frames that will be logged.
//                    This is useful for retrieving startup information from a
//                    application or limiting the file size on apps that make
//                    a lot of OpenGL calls (Note: This also affects per-frame logging)
//
//  LogFormat       - The format of the log. If equal to "XML" (without quotes)
//                    will log in the XML format. Else, the plain text format is used.
//
//  XMLFormat::XSLFile - When the log format is XML, this option specifies the XSL file
//                       to be used (if any). A XSL file usually formats the XML into a
//                       readable HTML format.
//
//  XMLFormat::BaseDir - The base (or source) directory where the XSL file can be found.
//
//////////////////////////////////////////////////////////////

FunctionLog
{
  LogEnabled = false
  LogFlush   = False;
  //LogPath     = "c:\temp\";
  LogFileName = "gliInterceptLog"

  //AdditionalRenderCalls = ("glClear");

  //LogMaxNumFrames = 200;

  //LogFormat   = XML;

  XMLFormat
  {
    XSLFile = gliIntercept_DHTML2.xsl;
    BaseDir = "C:\Program Files\GLInterceptx64_1_3_3\XSL";
  }
}


//////////////////////////////////////////////////////////////
//
//  LogPerFrame Options:
//
//////////////////////////////////////////////////////////////
//
//  Enabled         - Enable logging per frame. If this is true, instead of
//                    logging all OpenGL calls, the below frame start keys will
//                    enable the loggers at the start of a frame. The loggers
//                    will be disabled when the keys are pressed again and the next
//                    frame is reached (see OneFrameOnly for other options).
//
//                    Output of logging is saved to a directory called
//                    Frame_XXXX where XXXX is the frame number that logging
//                    started.
//
//  FrameStartKeys  - The keys used to enable/disable logging. Valid values can be any
//                    combination of 0-9,a-z,f1-f12,ctrl,shift,tab,lwin,rwin,
//                    print,up,down,left,right,add,sub,insert,delete etc.
//
//  OneFrameOnly    - If enabled, will only log only one frame per key-press.
//                    Loggers will be disabled at the end of the next frame.
//
//////////////////////////////////////////////////////////////

LogPerFrame
{
  Enabled = False;
  FrameStartKeys = (ctrl,shift,f);
  OneFrameOnly = True;
}




//////////////////////////////////////////////////////////////
//
//  Input Files:
//
//////////////////////////////////////////////////////////////
//
//  GLFunctionDefines - The file to retrieve the OpenGL function defines from.
//                      (The text header files that contain the parameters of OpenGL functions to be logged)
//
//  GLSystemLib       - The full path to the "real" OpenGL system library. This will be assigned automatically
//                      so usually does not have to be defined.
//
//////////////////////////////////////////////////////////////

InputFiles
{
  GLFunctionDefines = "C:\Program Files\GLInterceptx64_1_3_3\GLFunctions\gliIncludes.h"
  //GLSystemLib     = "c:\windows\system32\opengl32.dll"
}

//////////////////////////////////////////////////////////////
//
//  Error Checking:
//
//////////////////////////////////////////////////////////////
//
//  GLErrorChecking - A OpenGL glGetError() is made after all appropiate OpenGL calls.
//                    If an error is detected, the error code is logged to the current text/XML log next
//                    to the function that caused the error.
//                    (OpenGL Error context is still saved so application invoked glGetError() calls are safe)
//
//  ThreadChecking  - While GLIntercept is not currently thread-safe, (ie. So you cannot have multiple render
//                    contexts active at the same time) enabling this option will perform basic thread checking.
//                    (Will currently check OpenGL calls to see if they are made on the thread with the
//                     active render context)
//
//  BreakOnError    - (used with above) Issue programmer debug breakpoint on an error.
//                    Note that glIntercept alters the stack, so to get a valid call stack when debugging
//                    you will need to step through some assembly (F10 on VC6) until the stack is restored.
//
//  LogOnError      - (used with above) Log all OpenGL errors to the GLIntercept error log (gliLog.txt).
//
//  ExtendedErrorLog - (used with above) Report all available data about the function the produced the error.
//                     (ie. Full resolved parameters that were passed to the function are reported.)
//                     (Enabling this option will cause a severe slowdown even when no errors are produced. Only
//                      enable when debugging specific errors)
//
//  DebuggerErrorLog - Mirror the contents of the error log (gliLog.txt) file to the debuggers' window.
//
//////////////////////////////////////////////////////////////

ErrorChecking
{
  GLErrorChecking  = false;
  ThreadChecking   = False;
  BreakOnError     = False;
  LogOnError       = false;
  ExtendedErrorLog = false;
  DebuggerErrorLog = false;
}

//////////////////////////////////////////////////////////////
//
//  Image logging:
//
//////////////////////////////////////////////////////////////
//
//  LogEnabled    - Enabled the image logger. OpenGL textures are saved to the directory
//                  "Images" under the main log path. Only the texture types specified in
//                  SaveGLTypes are saved.
//
//  RenderCallStateLog - If enabled, each render call issued will list the currently bound
//                       textures for all texture stages. (works with text and XML logging)
//
//  SaveFormats    - The image formats to save the textures in. Current valid formats are
//                   PNG,JPG and TGA. Note that more than one format can be specified.
//                   (ie. (PNG,TGA) will save all textures twice, once in PNG format, once
//                    in TGA format)
//
//                   Note on image formats:
//                   TGA - Is pixel precise and is the fastest save format but is also the biggest.
//                         TGA's are also not supported by web browsers (if you use XML with XSL to view the logs).
//                   PNG - Is pixel precise and is slower to save but is smaller than TGA.
//                         PNG's are brower compatable.
//                   JPG - Is a format that does not save alpha and saves colors in a lossy format.
//                         It is the smallest format and is slower to save than TGA's.
//                         JPG's are brower compatable.
//
//  FlipXAxis      - The saving of textures is upside-down by default. Using this option will
//                   flip the image before saving.
//
//  TileCubeMaps   - Cube map textures are saved as six individual images. Enabling this option enables
//                   the six image to be tiled together (flattened cube shaped) and saved as one image.
//
//  SaveGLTypes    - The types of OpenGL textures to save. Valid options are 1D,2D,3D and CUBE.
//                   Note: NVRect textures use the 2D option.
//
//  SavePbufferTex - This option enables/disables the saving of textures that are bound from a p-buffer.
//                   Note: P-Buffer textures are saved each time a p-buffer is bound to the texture.
//                   (ie. no checks are performed to see if the p-buffer has changed)
//
//  ImageIcon->Enabled    - This enables saving a icon version of all images saved. (useful in XML browser viewing)
//
//  ImageIcon->SaveFormat - The format of the save icon images (TGA,PNG or JPG)
//
//  ImageIcon->Size       - The size of the icons to save
//
//////////////////////////////////////////////////////////////

ImageLog
{
  LogEnabled  = false;

  RenderCallStateLog = false;

  SaveFormats = PNG;
  FlipXAxis   = False;
  TileCubeMaps= True;

  SaveGLTypes = (1D,2D,3D,CUBE);
  SavePbufferTex = True;

  ImageIcon
  {
    Enabled=True;
    SaveFormat = JPG;
    Size = 40;
  }
}

//////////////////////////////////////////////////////////////
//
//  Shader logging
//
//////////////////////////////////////////////////////////////
//
//  LogEnabled    - Enabled the shader logger. OpenGL shaders/programs are saved to the directory
//                  "Shaders" under the main log path. Supported types included ARB/NV vertex/fragment
//                  programs and vertex/fragment GLSL shaders/programs. ATI specific vertex/fragment
//                  shaders are not supported.
//
//  RenderCallStateLog - If enabled, each render call issued will list the currently bound
//                       shaders (vertex and fragment). (works with text and XML logging)
//
//  AttachLogState - If enabled, attitional information such as compile/link state and additional
//                   driver information may be attached to each shader/program.
//                   (Currently only GLSL support). Note that enabling this option may force
//                   shaders to complete compiling immediately.
//
//  ValidatePreRender - If the above AttachLogState is enabled, this option will perform a validation of
//                      the shader before each render and append it to the log. Enabling this option will
//                      cause the shader to be re-saved at each render call.
//                      (GLSL only feature via glValidateProgram)
//
//  UniformLogPreRender - If the above AttachLogState is enabled, this option will dump all uniforms that
//                        are active in the shader before each render. Enabling this option will
//                        cause the shader to be re-saved at each render call. (GLSL only feature)
//
//////////////////////////////////////////////////////////////

ShaderLog
{
  LogEnabled = false;

  RenderCallStateLog = True;

  AttachLogState      = True;
  ValidatePreRender   = False;
  UniformLogPreRender = False;

  //Future formatting options
}

//////////////////////////////////////////////////////////////
//
//  Display List logging
//
//////////////////////////////////////////////////////////////
//
//  LogEnabled    - Enabled the display list logger. OpenGL display lists are saved to the directory
//                  "DisplayLists" under the main log path. If a program has a lot of big glBegin/glEnd
//                  sections in display lists, (ie 1000's of glVertex calls) the application may seem
//                  un-responsive on startup as all these calls are processed on the list creation.
//
//////////////////////////////////////////////////////////////

DisplayListLog
{
  LogEnabled = false;

}

//////////////////////////////////////////////////////////////
//
//  Frame(Buffer) logging
//
//////////////////////////////////////////////////////////////
//
//  LogEnabled    - Enabled the frame(buffer) logger. When enabled, each render call can
//                  save the pre/post/diff frame buffer (color or depth) to view the changes
//                  that the render call made. Frame buffer saves are written to a directory
//                  "Frames" under the main log path.
//
//  SaveFormat    - The image format to save the frame buffer in. Current options are TGA,PNG, and JPG.
//                  (see ImageLog::SaveFormats for a decription of the formats)
//
//  FrameIcon->Enabled - This enables saving a icon version of all images saved. (useful in XML browser viewing)
//
//  FrameIcon->SaveFormat - The format of the save icon images (TGA,PNG or JPG)
//
//  FrameIcon->Size    - The size of the icons to save
//
//  FrameMovie->Enabled - This enables a movie of the "post" and "diff" frame buffers to be saved. If multiple, buffers
//                        are saved, they are tiled together. (This is useful to quicky inspect how a frame is composed)
//                        The resulting movie is called FrameMovie.avi in the frame buffer directory.
//
//  FrameMovie->Size    - The width height of the saved frame buffers. (ie. (640,480)) The resulting movie will be
//                        larger if multiple buffers are saved at once as they are tiled together.
//
//  FrameMovie->FrameRate - The frame rate of the saved movie.
//
//  FrameMovie->Compression  - The list of compression codecs used to save the movie (usually 4 letters).
//                             The first valid codec is used. Special codecs are:
//                             "menu" -  will display a menu for the user to select a codec.
//                             "none" -  will use no compression.
//
//  ColorBufferLog - The color frame buffer save options. Options can include any combination of
//                   (pre,post,diff).
//                   pre  -  The frame's color buffer is saved before the render call
//
//                   post -  The frame's color buffer is saved after the render call
//
//                   diff -  The difference between the pre and post buffer saves is written.
//                           (green represents pixels with no differnce. If the image is red,
//                            no image differences were detected)
//
//  DepthBufferLog - The depth frame buffer save options. Options are the same as in ColorBufferLog.
//                   (Note: Depth-buffer saving can be very slow)
//
//  StencilBufferLog - The stencil frame buffer save options. Options are the same as in ColorBufferLog.
//                   (Note: Stencil-buffer saving can be very slow)
//
//  StencilColors - When saving the stencil buffer, it can be useful to save the buffer with color codes.
//                  (ie stencil value 1 = red) This array supplies index color pairs for each stencil
//                  value up to 255. The indices must be in order and the colors are in the format
//                  AABBGGRR. If an index is missing, it will take the value of the index as the color.
//                  (ie. stencil index 128 = (255, 128,128,128) = greyscale values)
//
//////////////////////////////////////////////////////////////

FrameLog
{
  LogEnabled = False;
  SaveFormat = JPG;

  FrameIcon
  {
    Enabled = True;
    SaveFormat = JPG;
    Size = 40;
  }
  FrameMovie
  {
    Enabled = False;
    Size    = (640,480);
    FrameRate = 15;
    Compression = ("mpg4","divx","none");
  }

  ColorBufferLog = (pre,post,diff);
  //DepthBufferLog = (pre,post,diff);

  //StencilBufferLog = (pre,post,diff);
  StencilColors = (0,0xFF000000,   //Black
                   1,0xFFFF0000,   //Blue
                   2,0xFFFFFF00,   //Light Blue
                   3,0xFF0000FF,   //Red
                   4,0xFF00FFFF,   //Yellow
                   5,0xFFFF00FF,   //Purple
                   6,0xFF80FFFF,   //Bright Yellow
                   7,0xFFFFFFFF);  //White (Note green is not used as that is the "diff" color)

}



//////////////////////////////////////////////////////////////
//
//  Function time logging
//
//////////////////////////////////////////////////////////////
//
//  NOTE: It is important to not mis-use the results of this logger. OpenGL is a very pipelined
//        API and you can not optimize your code based on how long is spent in each function call.
//        This logger is only intended for advanced users to determine where pipeline stalls "MAY"
//        have occured and determine speeds of operations such as glReadPixels etc.
//
//  LogEnabled    - Enabled the timer log. When enabled, the time taken inside each OpenGL
//                  function is added to the main log. (if enabled). The logging reports
//                  in microseconds (millionth of a second). Only take these results as
//                  approximate figures as GLIntercept will add a small amout of overhead.
//                  (More overhead may be indicated in the functions wglGetProcAddress,
//                   all wgl*(context) functions, glBegin,glEnd,glGetError)
//
//                  If you are using this logger to determine where pipeline stalls occur,
//                  ensure to disable ALL other loggers (image/shader/frame etc) as these
//                  loggers may cause pipline stalls. Also disable parameter logging by
//                  not defining "GLFunctionDefines" and use flat text logging to get the
//                  fastest logging possible. (and hence the most accurate results)
//
//  LogCutoff    -  The number of microseconds below which the time value is not reported.
//
//////////////////////////////////////////////////////////////

TimerLog
{
  LogEnabled = False;

  LogCutoff  = 20;

}


//////////////////////////////////////////////////////////////
//
//  Plugins
//
//////////////////////////////////////////////////////////////
//
//  BaseDir    - The base directory where the plugins can be found
//
//  Plugins    - Listing of all plugins to load (and the locations
//               to load from) Under each plugin, plugin specific options
//               can be specified.
//
//
//////////////////////////////////////////////////////////////

PluginData
{

  BaseDir = "C:\Program Files\GLInterceptx64_1_3_3\Plugins";

  Plugins
  {
    ExtensionOverride = ("GLExtOverride/GLExtOverride.dll")
    {
      VersionString  ="4.5"
      ShaderVersionString = "4.50 - Custom shader version string"
       AddExtensions = (GL_AMD_multi_draw_indirect
,GL_AMD_seamless_cubemap_per_texture
,GL_AMD_vertex_shader_viewport_index
,GL_AMD_vertex_shader_layer
,GL_ARB_arrays_of_arrays
,GL_ARB_base_instance
,GL_ARB_bindless_texture
,GL_ARB_blend_func_extended
,GL_ARB_buffer_storage
,GL_ARB_clear_buffer_object
,GL_ARB_clear_texture
,GL_ARB_clip_control
,GL_ARB_color_buffer_float
,GL_ARB_compatibility
,GL_ARB_compressed_texture_pixel_storage
,GL_ARB_conservative_depth
,GL_ARB_compute_shader
,GL_ARB_compute_variable_group_size
,GL_ARB_conditional_render_inverted
,GL_ARB_copy_buffer
,GL_ARB_copy_image
,GL_ARB_cull_distance
,GL_ARB_debug_output
,GL_ARB_depth_buffer_float
,GL_ARB_depth_clamp
,GL_ARB_depth_texture
,GL_ARB_derivative_control
,GL_ARB_direct_state_access
,GL_ARB_draw_buffers
,GL_ARB_draw_buffers_blend
,GL_ARB_draw_indirect
,GL_ARB_draw_elements_base_vertex
,GL_ARB_draw_instanced
,GL_ARB_enhanced_layouts
,GL_ARB_ES2_compatibility
,GL_ARB_ES3_compatibility
,GL_ARB_ES3_1_compatibility
,GL_ARB_ES3_2_compatibility
,GL_ARB_explicit_attrib_location
,GL_ARB_explicit_uniform_location
,GL_ARB_fragment_coord_conventions
,GL_ARB_fragment_layer_viewport
,GL_ARB_fragment_program
,GL_ARB_fragment_program_shadow
,GL_ARB_fragment_shader
,GL_ARB_fragment_shader_interlock
,GL_ARB_framebuffer_no_attachments
,GL_ARB_framebuffer_object
,GL_ARB_framebuffer_sRGB
,GL_ARB_geometry_shader4
,GL_ARB_get_program_binary
,GL_ARB_get_texture_sub_image
,GL_ARB_gpu_shader5
,GL_ARB_gpu_shader_fp64
,GL_ARB_gpu_shader_int64
,GL_ARB_half_float_pixel
,GL_ARB_half_float_vertex
,GL_ARB_imaging
,GL_ARB_indirect_parameters
,GL_ARB_instanced_arrays
,GL_ARB_internalformat_query
,GL_ARB_internalformat_query2
,GL_ARB_invalidate_subdata
,GL_ARB_map_buffer_alignment
,GL_ARB_map_buffer_range
,GL_ARB_multi_bind
,GL_ARB_multi_draw_indirect
,GL_ARB_multisample
,GL_ARB_multitexture
,GL_ARB_occlusion_query
,GL_ARB_occlusion_query2
,GL_ARB_parallel_shader_compile
,GL_ARB_pipeline_statistics_query
,GL_ARB_pixel_buffer_object
,GL_ARB_point_parameters
,GL_ARB_point_sprite
,GL_ARB_post_depth_coverage
,GL_ARB_program_interface_query
,GL_ARB_provoking_vertex
,GL_ARB_query_buffer_object
,GL_ARB_robust_buffer_access_behavior
,GL_ARB_robustness
,GL_ARB_sample_locations
,GL_ARB_sample_shading
,GL_ARB_sampler_objects
,GL_ARB_seamless_cube_map
,GL_ARB_seamless_cubemap_per_texture
,GL_ARB_separate_shader_objects
,GL_ARB_shader_atomic_counter_ops
,GL_ARB_shader_atomic_counters
,GL_ARB_shader_ballot
,GL_ARB_shader_bit_encoding
,GL_ARB_shader_clock
,GL_ARB_shader_draw_parameters
,GL_ARB_shader_group_vote
,GL_ARB_shader_image_load_store
,GL_ARB_shader_image_size
,GL_ARB_shader_objects
,GL_ARB_shader_precision
,GL_ARB_shader_storage_buffer_object
,GL_ARB_shader_subroutine
,GL_ARB_shader_texture_image_samples
,GL_ARB_shader_texture_lod
,GL_ARB_shading_language_100
,GL_ARB_shader_viewport_layer_array
,GL_ARB_shading_language_420pack
,GL_ARB_shading_language_include
,GL_ARB_shading_language_packing
,GL_ARB_shadow
,GL_ARB_sparse_buffer
,GL_ARB_sparse_texture
,GL_ARB_sparse_texture2
,GL_ARB_sparse_texture_clamp
,GL_ARB_stencil_texturing
,GL_ARB_sync
,GL_ARB_tessellation_shader
,GL_ARB_texture_barrier
,GL_ARB_texture_border_clamp
,GL_ARB_texture_buffer_object
,GL_ARB_texture_buffer_object_rgb32
,GL_ARB_texture_buffer_range
,GL_ARB_texture_compression
,GL_ARB_texture_compression_bptc
,GL_ARB_texture_compression_rgtc
,GL_ARB_texture_cube_map
,GL_ARB_texture_cube_map_array
,GL_ARB_texture_env_add
,GL_ARB_texture_env_combine
,GL_ARB_texture_env_crossbar
,GL_ARB_texture_env_dot3
,GL_ARB_texture_filter_minmax
,GL_ARB_texture_float
,GL_ARB_texture_gather
,GL_ARB_texture_mirror_clamp_to_edge
,GL_ARB_texture_mirrored_repeat
,GL_ARB_texture_multisample
,GL_ARB_texture_non_power_of_two
,GL_ARB_texture_query_levels
,GL_ARB_texture_query_lod
,GL_ARB_texture_rectangle
,GL_ARB_texture_rg
,GL_ARB_texture_rgb10_a2ui
,GL_ARB_texture_stencil8
,GL_ARB_texture_storage
,GL_ARB_texture_storage_multisample
,GL_ARB_texture_swizzle
,GL_ARB_texture_view
,GL_ARB_timer_query
,GL_ARB_transform_feedback2
,GL_ARB_transform_feedback3
,GL_ARB_transform_feedback_instanced
,GL_ARB_transform_feedback_overflow_query
,GL_ARB_transpose_matrix
,GL_ARB_uniform_buffer_object
,GL_ARB_vertex_array_bgra
,GL_ARB_vertex_array_object
,GL_ARB_vertex_attrib_64bit
,GL_ARB_vertex_attrib_binding
,GL_ARB_vertex_buffer_object
,GL_ARB_vertex_program
,GL_ARB_vertex_shader
,GL_ARB_vertex_type_10f_11f_11f_rev
,GL_ARB_vertex_type_2_10_10_10_rev
,GL_ARB_viewport_array
,GL_ARB_window_pos
,GL_ATI_draw_buffers
,GL_ATI_texture_float
,GL_ATI_texture_mirror_once
,GL_S3_s3tc
,GL_EXT_texture_env_add
,GL_EXT_abgr
,GL_EXT_bgra
,GL_EXT_bindable_uniform
,GL_EXT_blend_color
,GL_EXT_blend_equation_separate
,GL_EXT_blend_func_separate
,GL_EXT_blend_minmax
,GL_EXT_blend_subtract
,GL_EXT_compiled_vertex_array
,GL_EXT_Cg_shader
,GL_EXT_depth_bounds_test
,GL_EXT_direct_state_access
,GL_EXT_draw_buffers2
,GL_EXT_draw_instanced
,GL_EXT_draw_range_elements
,GL_EXT_fog_coord
,GL_EXT_framebuffer_blit
,GL_EXT_framebuffer_multisample
,GL_EXTX_framebuffer_mixed_formats
,GL_EXT_framebuffer_multisample_blit_scaled
,GL_EXT_framebuffer_object
,GL_EXT_framebuffer_sRGB
,GL_EXT_geometry_shader4
,GL_EXT_gpu_program_parameters
,GL_EXT_gpu_shader4
,GL_EXT_multi_draw_arrays
,GL_EXT_packed_depth_stencil
,GL_EXT_packed_float
,GL_EXT_packed_pixels
,GL_EXT_pixel_buffer_object
,GL_EXT_point_parameters
,GL_EXT_polygon_offset_clamp
,GL_EXT_post_depth_coverage
,GL_EXT_provoking_vertex
,GL_EXT_raster_multisample
,GL_EXT_rescale_normal
,GL_EXT_secondary_color
,GL_EXT_separate_shader_objects
,GL_EXT_separate_specular_color
,GL_EXT_shader_image_load_formatted
,GL_EXT_shader_image_load_store
,GL_EXT_shader_integer_mix
,GL_EXT_shadow_funcs
,GL_EXT_sparse_texture2
,GL_EXT_stencil_two_side
,GL_EXT_stencil_wrap
,GL_EXT_texture3D
,GL_EXT_texture_array
,GL_EXT_texture_buffer_object
,GL_EXT_texture_compression_dxt1
,GL_EXT_texture_compression_latc
,GL_EXT_texture_compression_rgtc
,GL_EXT_texture_compression_s3tc
,GL_EXT_texture_cube_map
,GL_EXT_texture_edge_clamp
,GL_EXT_texture_env_combine
,GL_EXT_texture_env_dot3
,GL_EXT_texture_filter_anisotropic
,GL_EXT_texture_filter_minmax
,GL_EXT_texture_integer
,GL_EXT_texture_lod
,GL_EXT_texture_lod_bias
,GL_EXT_texture_mirror_clamp
,GL_EXT_texture_object
,GL_EXT_texture_shared_exponent
,GL_EXT_texture_sRGB
,GL_EXT_texture_sRGB_decode
,GL_EXT_texture_storage
,GL_EXT_texture_swizzle
,GL_EXT_timer_query
,GL_EXT_transform_feedback2
,GL_EXT_vertex_array
,GL_EXT_vertex_array_bgra
,GL_EXT_vertex_attrib_64bit
,GL_EXT_import_sync_object
,GL_IBM_rasterpos_clip
,GL_IBM_texture_mirrored_repeat
,GL_KHR_context_flush_control
,GL_KHR_debug
,GL_KHR_robust_buffer_access_behavior
,GL_KHR_robustness
,GL_KTX_buffer_region
,GL_NV_bindless_multi_draw_indirect
,GL_NV_bindless_multi_draw_indirect_count
,GL_NV_bindless_texture
,GL_NV_blend_equation_advanced
,GL_NV_blend_equation_advanced_coherent
,GL_NV_blend_square
,GL_NV_command_list
,GL_NV_compute_program5
,GL_NV_conditional_render
,GL_NV_conservative_raster
,GL_NV_conservative_raster_dilate
,GL_NV_copy_depth_to_color
,GL_NV_copy_image
,GL_NV_depth_buffer_float
,GL_NV_depth_clamp
,GL_NV_draw_texture
,GL_NV_ES1_1_compatibility
,GL_NV_ES3_1_compatibility
,GL_NV_explicit_multisample
,GL_NV_fence
,GL_NV_fill_rectangle
,GL_NV_float_buffer
,GL_NV_fog_distance
,GL_NV_fragment_coverage_to_color
,GL_NV_fragment_program
,GL_NV_fragment_program_option
,GL_NV_fragment_program2
,GL_NV_fragment_shader_interlock
,GL_NV_framebuffer_mixed_samples
,GL_NV_framebuffer_multisample_coverage
,GL_NV_geometry_shader4
,GL_NV_geometry_shader_passthrough
,GL_NV_gpu_program4
,GL_NV_internalformat_sample_query
,GL_NV_gpu_program4_1
,GL_NV_gpu_program5
,GL_NV_gpu_program5_mem_extended
,GL_NV_gpu_program_fp64
,GL_NV_gpu_shader5
,GL_NV_half_float
,GL_NV_light_max_exponent
,GL_NV_multisample_coverage
,GL_NV_multisample_filter_hint
,GL_NV_occlusion_query
,GL_NV_packed_depth_stencil
,GL_NV_parameter_buffer_object
,GL_NV_parameter_buffer_object2
,GL_NV_path_rendering
,GL_NV_path_rendering_shared_edge
,GL_NV_pixel_data_range
,GL_NV_point_sprite
,GL_NV_primitive_restart
,GL_NV_register_combiners
,GL_NV_register_combiners2
,GL_NV_sample_locations
,GL_NV_sample_mask_override_coverage
,GL_NV_shader_atomic_counters
,GL_NV_shader_atomic_float
,GL_NV_shader_atomic_fp16_vector
,GL_NV_shader_atomic_int64
,GL_NV_shader_buffer_load
,GL_NV_shader_storage_buffer_object
,GL_NV_texgen_reflection
,GL_NV_texture_barrier
,GL_NV_texture_compression_vtc
,GL_NV_texture_env_combine4
,GL_NV_texture_multisample
,GL_NV_texture_rectangle
,GL_NV_texture_shader
,GL_NV_texture_shader2
,GL_NV_texture_shader3
,GL_NV_transform_feedback
,GL_NV_transform_feedback2
,GL_NV_uniform_buffer_unified_memory
,GL_NV_vertex_array_range
,GL_NV_vertex_array_range2
,GL_NV_vertex_attrib_integer_64bit
,GL_NV_vertex_buffer_unified_memory
,GL_NV_vertex_program
,GL_NV_vertex_program1_1
,GL_NV_vertex_program2
,GL_NV_vertex_program2_option
,GL_NV_vertex_program3
,GL_NV_viewport_array2
,GL_NVX_conditional_render
,GL_NVX_gpu_memory_info
,GL_NVX_nvenc_interop
,GL_NV_shader_thread_group
,GL_NV_shader_thread_shuffle
,GL_KHR_blend_equation_advanced
,GL_KHR_blend_equation_advanced_coherent
,GL_SGIS_generate_mipmap
,GL_SGIS_texture_lod
,GL_SGIX_depth_texture
,GL_SGIX_shadow
,GL_SUN_slice_accum
,GL_WIN_swap_hint
,WGL_EXT_swap_control
,WGL_ARB_buffer_region
,WGL_ARB_create_context
,WGL_ARB_create_context_profile
,WGL_ARB_create_context_robustness
,WGL_ARB_context_flush_control
,WGL_ARB_extensions_string
,WGL_ARB_make_current_read
,WGL_ARB_multisample
,WGL_ARB_pbuffer
,WGL_ARB_pixel_format
,WGL_ARB_pixel_format_float
,WGL_ARB_render_texture
,WGL_ATI_pixel_format_float
,WGL_EXT_create_context_es_profile
,WGL_EXT_create_context_es2_profile
,WGL_EXT_extensions_string
,WGL_EXT_framebuffer_sRGB
,WGL_EXT_pixel_format_packed_float
,WGL_EXT_swap_control_tear
,WGL_NVX_DX_interop
,WGL_NV_DX_interop
,WGL_NV_DX_interop2
,WGL_NV_copy_image
,WGL_NV_delay_before_swap
,WGL_NV_float_buffer
,WGL_NV_multisample_coverage
,WGL_NV_render_depth_texture
,WGL_NV_render_texture_rectangle);
    }
    //
    // Name of plugin   |  Plugin load location
    // {  Plugin specific options. (See the plugins' config.ini file for options) }

    // OpenGLFreeCamera = ("GLFreeCam/GLFreeCam.dll")
    // {
    //    CameraMoveSpeed   = 10.0;
    // }

  }
}