////////////////////////////////////////////////////////////// // // 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; // } } }