2020-07-31 15:00:13 [INFO ] <TRIAL>: Running on X86-64 DESKTOP-VPC0TH0 NIL
2020-07-31 15:00:13 [INFO ] <TRIAL.MAIN>: GENESIS
2020-07-31 15:00:13 [INFO ] <LEAF.SAVE>: Loading state from #<DIR-PACKET #P"C:/Users/selwyn/Downloads/kandria-windows-mac-linux/world/init/" :INPUT> into #<WORLD 0 units {1007C67FB3}>
2020-07-31 15:00:13 [INFO ] <LEAF.REGION>: Loading #<DIR-PACKET #P"C:/Users/selwyn/Downloads/kandria-windows-mac-linux/world/regions/test/" :INPUT>
2020-07-31 15:00:15 [INFO ] <TRIAL.BACKEND.GLFW>: Creating context #<CONTEXT {100A4250F3}>
2020-07-31 15:00:15 [INFO ] <TRIAL.CONTEXT>: Recreated context successfully.
2020-07-31 15:00:15 [DEBUG] <TRIAL.CONTEXT>: Context information: 
Running GL3.3 CORE
Sample buffers:     0 (0 samples)
Max texture size:   32768
Max texture units:  32 32 32 32 32 32
GL Vendor:          NVIDIA Corporation
GL Renderer:        GeForce RTX 2080/PCIe/SSE2
GL Version:         3.3.0 NVIDIA 441.66
GL Shader Language: 3.30 NVIDIA via Cg compiler
GL Extensions:      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_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_gl_spirv 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_polygon_offset_clamp 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_spirv_extensions 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_anisotropic 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_multiview_texture_multisample GL_EXT_multiview_timer_query 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_shadow_lod GL_EXT_texture_shared_exponent GL_EXT_texture_sRGB GL_EXT_texture_sRGB_R8 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_window_rectangles GL_EXT_import_sync_object GL_IBM_rasterpos_clip GL_IBM_texture_mirrored_repeat GL_KHR_context_flush_control GL_KHR_debug GL_EXT_memory_object GL_EXT_memory_object_win32 GL_EXT_win32_keyed_mutex GL_KHR_parallel_shader_compile GL_KHR_no_error GL_KHR_robust_buffer_access_behavior GL_KHR_robustness GL_EXT_semaphore GL_EXT_semaphore_win32 GL_KHR_shader_subgroup GL_KTX_buffer_region GL_NV_alpha_to_coverage_dither_control 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_NVX_blend_equation_advanced_multi_draw_buffers GL_NV_blend_minmax_factor GL_NV_blend_square GL_NV_clip_space_w_scaling GL_NV_command_list GL_NV_compute_program5 GL_NV_compute_shader_derivatives GL_NV_conditional_render GL_NV_conservative_raster GL_NV_conservative_raster_dilate GL_NV_conservative_raster_pre_snap GL_NV_conservative_raster_pre_snap_triangles GL_NV_conservative_raster_underestimation 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_draw_vulkan_image GL_NV_ES1_1_compatibility GL_NV_ES3_1_compatibility GL_NV_explicit_multisample GL_NV_feature_query 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_barycentric 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_memory_attachment GL_NV_mesh_shader 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_query_resource GL_NV_query_resource_tag GL_NV_register_combiners GL_NV_register_combiners2 GL_NV_representative_fragment_test GL_NV_sample_locations GL_NV_sample_mask_override_coverage GL_NV_scissor_exclusive GL_NV_shader_atomic_counters GL_NV_shader_atomic_float GL_NV_shader_atomic_float64 GL_NV_shader_atomic_fp16_vector GL_NV_shader_atomic_int64 GL_NV_shader_buffer_load GL_NV_shader_storage_buffer_object GL_NV_shader_subgroup_partitioned GL_NV_shader_texture_footprint GL_NV_shading_rate_image GL_NV_stereo_view_rendering 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_rectangle_compressed 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_NV_viewport_swizzle GL_NVX_conditional_render GL_NVX_linked_gpu_multicast GL_NV_gpu_multicast GL_NVX_gpu_multicast2 GL_NVX_progress_fence GL_NVX_gpu_memory_info GL_NVX_multigpu_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_OVR_multiview GL_OVR_multiview2 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

2020-07-31 15:00:15 [INFO ] <TRIAL.CONTEXT>: #<THREAD "main thread" RUNNING {10003900C3}> acquiring #<CONTEXT {100A4250F3}>.
2020-07-31 15:00:15 [INFO ] <TRIAL.MAIN>: Setting up #<WORLD 9 units {1007C67FB3}>
2020-07-31 15:00:16 [INFO ] <TRIAL.MAIN>: Scene setup took 0.312s run time, 0.313s clock time.
2020-07-31 15:00:16 [INFO ] <TRIAL.PIPELINE>: #<WORLD 14 units {1007C67FB3}> packing for #<CONTEXT {100A4250F3}> (1280x720)
2020-07-31 15:00:16 [INFO ] <TRIAL.PIPELINE>: #<WORLD 14 units {1007C67FB3}> pass order: (#<SHADOW-MAP-PASS  {10082567D3}>
                                            #<LIGHTING-PASS LIGHTING-PASS {1008539133}>
                                            #<RENDERING-PASS  {10085A7083}>)
2020-07-31 15:00:16 [INFO ] <TRIAL.PIPELINE>: #<WORLD 14 units {1007C67FB3}> texture count: 4
2020-07-31 15:00:16 [INFO ] <TRIAL.PIPELINE>: #<WORLD 14 units {1007C67FB3}> texture allocation: 
#<SHADOW-MAP-PASS  {10082567D3}>
    SHADOW-MAP: #<TEXTURE 1280x720 RGBA16F {1008BA7463}>
#<LIGHTING-PASS LIGHTING-PASS {1008539133}>
    COLOR: #<TEXTURE 1280x720 RGBA16F {1008BA8FE3}>
#<RENDERING-PASS  {10085A7083}>
    COLOR: #<TEXTURE 1280x720 RGBA16F {1008BAA533}>
    DEPTH: #<TEXTURE 1280x720 DEPTH-STENCIL {1008B93B03}>
    LIGHTING: #<TEXTURE 1280x720 RGBA16F {1008BA8FE3}>
    SHADOW-MAP: #<TEXTURE 1280x720 RGBA16F {1008BA7463}>
2020-07-31 15:00:16 [INFO ] <TRIAL.LOADER>: About to load the following:
  #(#<TILE-DATA LEAF/DEBUG> #<SPRITE-DATA LEAF/PLAYER> #<MESH LEAF/1X>
    #<IMAGE LEAF/TUNDRA-BG> #<SPRITE-DATA LEAF/EFFECTS>
    #<MESH TRIAL/FULLSCREEN-SQUARE> #<SPRITE-DATA LEAF/DUMMY>
    #<SPRITE-DATA LEAF/DEBUG-DOOR> #<TILE-DATA LEAF/TUNDRA> #<IMAGE LEAF/BALL>
    #<SPRITE-DATA LEAF/BALLOON> #<FONT TRIAL/NOTO-MONO> #<MESH LEAF/SWEEPER>
    #<TEXTURE 40x51 RG8UI {1007008CA3}>
    #<VERTEX-BUFFER ELEMENT-ARRAY-BUFFER STATIC-DRAW {100701E633}>
    #<TEXTURE 40x117 RG8UI {1007007283}> #<TEXTURE 62x34 RG8UI {10070059A3}>
    #<PLACEHOLDER-RESOURCE LEAF/TUNDRA[T]>
    #<PLACEHOLDER-RESOURCE LEAF/DEBUG[T]>
    #<PLACEHOLDER-RESOURCE TRIAL/FULLSCREEN-SQUARE[T]>
    #<TEXTURE 40x51 RG8UI {1007008CE3}> #<TEXTURE 62x34 RG8UI {1007005A63}>
    #<PLACEHOLDER-RESOURCE LEAF/PLAYER[T]> #<TEXTURE 40x117 RG8UI {1007007383}>
    #<PLACEHOLDER-RESOURCE LEAF/PLAYER[T]>
    #<PLACEHOLDER-RESOURCE LEAF/DUMMY[T]>
    #<VERTEX-BUFFER ARRAY-BUFFER STATIC-DRAW {100ABBA983}>
    #<VERTEX-ARRAY  {100ABBA9A3}> #<PLACEHOLDER-RESOURCE LEAF/DUMMY[T]>
    #<PLACEHOLDER-RESOURCE LEAF/BALLOON[T]>
    #<VERTEX-BUFFER ELEMENT-ARRAY-BUFFER STATIC-DRAW {100708AB43}>
    #<TEXTURE 40x117 RG8UI {10070072C3}> #<TEXTURE 62x34 RG8UI {10070059E3}>
    #<TEXTURE 40x26 RG8UI {1007004BC3}> #<PLACEHOLDER-RESOURCE LEAF/TUNDRA[T]>
    #<TEXTURE 196x58 RG8UI {10070014C3}> #<TEXTURE 62x34 RG8UI {1007005A23}>
    #<TEXTURE 40x26 RG8UI {1007004C03}> #<TEXTURE 196x58 RG8UI {1007001503}>
    #<TEXTURE 40x117 RG8UI {1007007303}> #<TEXTURE 40x51 RG8UI {1007008D23}>
    #<TEXTURE 196x58 RG8UI {1007001583}> #<TEXTURE 40x26 RG8UI {1007004C43}>
    #<TEXTURE 2048x2048 RGBA8 {1006A40233}>
    #<TEXTURE 40x117 RG8UI {1007007343}> #<TEXTURE 40x51 RG8UI {1007008D63}>
    #<TEXTURE 196x58 RG8UI {10070015C3}> #<TEXTURE 40x26 RG8UI {1007004C83}>
    #<TEXTURE 62x34 RG8UI {1007005AA3}> #<SHADER VERTEX-SHADER {100ACDA4B3}>
    #<TEXTURE 40x51 RG8UI {1007008DA3}> #<TEXTURE 196x58 RG8UI {1006F61813}>
    #<VERTEX-BUFFER ARRAY-BUFFER DYNAMIC-DRAW {100710A4C3}>
    #<VERTEX-ARRAY 6828 {1006F7BE83}>
    #<VERTEX-BUFFER ARRAY-BUFFER STATIC-DRAW {100710A523}>
    #<VERTEX-ARRAY  {1006F7C083}> #<TEXTURE 40x26 RG8UI {1006F61913}>
    #<VERTEX-BUFFER ARRAY-BUFFER DYNAMIC-DRAW {100713FF23}>
    #<VERTEX-ARRAY 2616 {1006FBC6B3}>
    #<VERTEX-BUFFER ARRAY-BUFFER STATIC-DRAW {100713FF83}>
    #<VERTEX-ARRAY  {1006FBC913}> #<PLACEHOLDER-RESOURCE TRIAL/NOTO-MONO[T]>
    #<TEXTURE 196x58 RG8UI {1007001543}>
    #<VERTEX-BUFFER ARRAY-BUFFER DYNAMIC-DRAW {100714E743}>
    #<VERTEX-ARRAY 7584 {1006FCC743}>
    #<PLACEHOLDER-RESOURCE LEAF/DEBUG-DOOR[T]>
    #<TEXTURE 40x26 RG8UI {1007004B83}> #<TEXTURE 40x117 RG8UI {1006F61B13}>
    #<VERTEX-BUFFER ARRAY-BUFFER STATIC-DRAW {1007145003}>
    #<PLACEHOLDER-RESOURCE LEAF/1X[T]>
    #<VERTEX-BUFFER ELEMENT-ARRAY-BUFFER STATIC-DRAW {10070B1553}>
    #<SHADER FRAGMENT-SHADER {100AD73E53}>
    #<VERTEX-BUFFER ELEMENT-ARRAY-BUFFER STATIC-DRAW {10070BDC43}>
    #<VERTEX-BUFFER ARRAY-BUFFER STATIC-DRAW {100714E7A3}>
    #<VERTEX-ARRAY  {1006FCC943}> #<TEXTURE 40x51 RG8UI {1006F61C13}>
    #<VERTEX-BUFFER ARRAY-BUFFER DYNAMIC-DRAW {1007168713}>
    #<VERTEX-ARRAY 3708 {1006FF24B3}>
    #<VERTEX-BUFFER ELEMENT-ARRAY-BUFFER STATIC-DRAW {10070EAE53}>
    #<VERTEX-BUFFER ARRAY-BUFFER STATIC-DRAW {1007168773}>
    #<VERTEX-ARRAY  {1006FF26B3}> #<PLACEHOLDER-RESOURCE LEAF/SWEEPER[T]>
    #<SHADER FRAGMENT-SHADER {100AD74553}>
    #<TEXTURE 2048x2048 RGBA8 {100ABC0203}> #<FONT {100AB80B63}>
    #<FONT {1006F19973}> #<SHADER VERTEX-SHADER {100AC81873}>
    #<SHADER FRAGMENT-SHADER {100AC81893}> #<SHADER-PROGRAM {100AB85073}>
    #<SHADER VERTEX-SHADER {100ACDA673}> #<SHADER FRAGMENT-SHADER {100ACDA693}>
    #<SHADER-PROGRAM {100ABBAB43}> #<SHADER VERTEX-SHADER {100ACDA593}>
    #<SHADER FRAGMENT-SHADER {100ACDA5B3}> #<SHADER-PROGRAM {100ABBAB23}>
    #<SHADER FRAGMENT-SHADER {100ACDA4D3}> #<SHADER-PROGRAM {100ABBAB03}>
    #<VERTEX-BUFFER ARRAY-BUFFER STREAM-DRAW {100ABBAAC3}>
    #<VERTEX-ARRAY  {100ABBAAE3}>
    #<VERTEX-BUFFER ARRAY-BUFFER STREAM-DRAW {100ABBAA83}>
    #<VERTEX-ARRAY  {100ABBAAA3}>
    #<VERTEX-BUFFER ARRAY-BUFFER STATIC-DRAW {100ABBAA43}>
    #<VERTEX-ARRAY  {100ABBAA63}>
    #<VERTEX-BUFFER ARRAY-BUFFER STATIC-DRAW {100ABBAA03}>
    #<VERTEX-ARRAY  {100ABBAA23}>
    #<VERTEX-BUFFER ARRAY-BUFFER STREAM-DRAW {100ABBA9C3}>
    #<VERTEX-ARRAY  {100ABBA9E3}>
    #<VERTEX-BUFFER ARRAY-BUFFER STATIC-DRAW {100ABBA943}>
    #<VERTEX-ARRAY  {100ABBA963}> #<SHADER VERTEX-SHADER {100ACDA323}>
    #<SHADER FRAGMENT-SHADER {100ACDA343}> #<SHADER-PROGRAM {100ABBA923}>
    #<VERTEX-BUFFER ARRAY-BUFFER DYNAMIC-DRAW {100ABBA8E3}>
    #<VERTEX-ARRAY  {100ABBA903}> #<EDITOR-UI  {100832E383}>
    #<SHADER FRAGMENT-SHADER {100AD73873}> #<SHADER VERTEX-SHADER {100AD73893}>
    #<SHADER-PROGRAM {100AD073B3}> #<TEXTURE 1280x720 RGBA16F {100AC17F93}>
    #<VERTEX-ARRAY  {1006FC4333}>
    #<VERTEX-BUFFER ARRAY-BUFFER DYNAMIC-DRAW {1007144FA3}>
    #<VERTEX-BUFFER ELEMENT-ARRAY-BUFFER DYNAMIC-DRAW {1006F58C23}>
    #<VERTEX-BUFFER ARRAY-BUFFER DYNAMIC-DRAW {1006F67E43}>
    #<VERTEX-ARRAY  {1006EEBAD3}> #<VERTEX-ARRAY 3552 {1006FC4133}>
    #<PLACEHOLDER-RESOURCE LEAF/BALL[T]>
    #<VERTEX-BUFFER ARRAY-BUFFER DYNAMIC-DRAW {1006F60A13}>
    #<VERTEX-BUFFER ELEMENT-ARRAY-BUFFER DYNAMIC-DRAW {1006F60A33}>
    #<VERTEX-ARRAY  {1006F609C3}> #<SHADER VERTEX-SHADER {100AD2D813}>
    #<SHADER FRAGMENT-SHADER {100AD2D833}>
    #<UNIFORM-BUFFER UNIFORM-BUFFER STREAM-DRAW {1004565613}>
    #<SHADER-PROGRAM {100AC5B693}> #<TEXTURE 1280x720 RGBA16F {100AC17FB3}>
    #<TEXTURE 62x34 RG8UI {1006F61A13}>
    #<FRAMEBUFFER COLOR-ATTACHMENT0  {100AC5B573}>
    #<FRAMEBUFFER COLOR-ATTACHMENT0  {100AC5B7A3}>
    #<TEXTURE 40x26 RG8UI {1007004CC3}>
    #<TEXTURE 1280x720 RGBA16F {100AC17FD3}>
    #<TEXTURE 1280x720 DEPTH-STENCIL {100AC17F73}>
    #<FRAMEBUFFER COLOR-ATTACHMENT0 DEPTH-STENCIL-ATTACHMENT  {100AC5BA83}>
    #<SHADER VERTEX-SHADER {100AD73E73}> #<SHADER-PROGRAM {100AD07773}>
    #<PLACEHOLDER-RESOURCE LEAF/BALLOON[T]>
    #<SHADER FRAGMENT-SHADER {100AD73F33}> #<SHADER VERTEX-SHADER {100AD73F53}>
    #<SHADER-PROGRAM {100AD07793}> #<SHADER FRAGMENT-SHADER {100AD74013}>
    #<SHADER VERTEX-SHADER {100AD74033}> #<SHADER-PROGRAM {100AD077B3}>
    #<SHADER FRAGMENT-SHADER {100AD740F3}> #<SHADER VERTEX-SHADER {100AD74113}>
    #<SHADER-PROGRAM {100AD077D3}> #<SHADER FRAGMENT-SHADER {100AD741D3}>
    #<SHADER VERTEX-SHADER {100AD741F3}> #<SHADER-PROGRAM {100AD077F3}>
    #<SHADER FRAGMENT-SHADER {100AD742B3}> #<SHADER VERTEX-SHADER {100AD742D3}>
    #<SHADER-PROGRAM {100AD07813}> #<SHADER FRAGMENT-SHADER {100AD74393}>
    #<SHADER VERTEX-SHADER {100AD743B3}> #<SHADER-PROGRAM {100AD07833}>
    #<SHADER FRAGMENT-SHADER {100AD74473}> #<SHADER VERTEX-SHADER {100AD74493}>
    #<SHADER-PROGRAM {100AD07853}> #<SHADER VERTEX-SHADER {100AD74573}>
    #<SHADER-PROGRAM {100AD07873}> #<PLACEHOLDER-RESOURCE LEAF/DEBUG-DOOR[T]>
    #<PLACEHOLDER-RESOURCE LEAF/EFFECTS[T]>
    #<PLACEHOLDER-RESOURCE LEAF/DEBUG[T]>
    #<PLACEHOLDER-RESOURCE LEAF/EFFECTS[T]>
    #<PLACEHOLDER-RESOURCE LEAF/TUNDRA-BG[T]>)
2020-07-31 15:00:16 [TRACE] <TRIAL.ASSET>: Loading LEAF/DEBUG
2020-07-31 15:00:16 [TRACE] <TRIAL.ASSET>: Loading LEAF/PLAYER
2020-07-31 15:00:16 [TRACE] <TRIAL.ASSET>: Loading LEAF/1X
2020-07-31 15:00:16 [TRACE] <TRIAL.ASSET>: Loading LEAF/TUNDRA-BG
2020-07-31 15:00:16 [TRACE] <TRIAL.ASSET>: Loading LEAF/EFFECTS
2020-07-31 15:00:16 [TRACE] <TRIAL.ASSET>: Loading TRIAL/FULLSCREEN-SQUARE
2020-07-31 15:00:16 [TRACE] <TRIAL.ASSET>: Loading LEAF/DUMMY
2020-07-31 15:00:16 [TRACE] <TRIAL.ASSET>: Loading LEAF/DEBUG-DOOR
2020-07-31 15:00:16 [TRACE] <TRIAL.ASSET>: Loading LEAF/TUNDRA
2020-07-31 15:00:16 [TRACE] <TRIAL.ASSET>: Loading LEAF/BALL
2020-07-31 15:00:16 [TRACE] <TRIAL.ASSET>: Loading LEAF/BALLOON
2020-07-31 15:00:16 [TRACE] <TRIAL.ASSET>: Loading TRIAL/NOTO-MONO
2020-07-31 15:00:16 [TRACE] <TRIAL.ASSET>: Loading LEAF/SWEEPER
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER VERTEX-SHADER {100ACDA4B3}>: 
#version 330 core
layout(location = 0) in vec2 position;
layout(location = 1) in vec2 normal;

out vec2 line_normal;
uniform float line_width = 3.0;
uniform mat3 transform;
uniform vec2 view_size;

void main(){
  vec3 delta = vec3(normal * line_width, 0);
  delta.xy /= view_size;
  vec3 pos = transform*vec3(position, 1);
  gl_Position = vec4(pos + delta, 1);
  line_normal = normal;
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER FRAGMENT-SHADER {100AD73E53}>: 
#version 330 core
layout(std140) uniform LightInfo{
  int activep;
  vec2 sun_position;
  vec3 sun_light;
  vec3 ambient_light;
} light_info;
uniform sampler2D lighting;
uniform sampler2D shadow_map;

vec4 apply_lighting(vec4 color, vec2 offset, float absorption){
  vec3 truecolor = pow(color.rgb, vec3(2.2));
  if((light_info.activep != 0)){
    ivec2 pos = ivec2((gl_FragCoord.xy - (vec2(0.5) + offset)));
    float shade = (0.4 < texelFetch(shadow_map, pos, 0).r)? 0 :1;
    vec4 light = texelFetch(lighting, pos, 0);
    truecolor *= light_info.ambient_light;
    truecolor += (light_info.sun_light * (max(0, (shade - absorption)) * color.rgb));
    truecolor += (light.rgb * (max(0, (light.a - absorption)) * color.rgb));
  }else{
    truecolor *= 5;
  };
  ;
  return vec4(truecolor, color.a);
}
out vec4 color;

void _GLSLTK_main_1(){
  color = vec4(1.0, 1.0, 1.0, 1.0);
}
uniform sampler2D background;
uniform int parallax_direction = 1;
in vec2 map_coord;

void _GLSLTK_main_2(){
  ivec2 map_wh = textureSize(background, 0);
  ivec2 map_xy = ivec2(map_coord);
  switch(parallax_direction){
  case 0: 
    map_xy = clamp(map_xy, ivec2(0), (map_wh - 1));
    break;
  case 1: 
    map_xy.x %= map_wh.x;
    map_xy.y = clamp((map_xy.y + (map_wh.y / 2)), 0, (map_wh.y - 1));
    break;
  case 2: 
    map_xy.x = clamp(map_xy.x, 0, (map_wh.x - 1));
    map_xy.y %= map_wh.y;
    break;
  case 3: 
    map_xy %= map_wh;
    break;
  };
  ;
  color = texelFetch(background, map_xy, 0);
  color = mix(color, apply_lighting(color, vec2(0, 0), 0), 1);
}

void _GLSLTK_main_3(){
  _GLSLTK_main_1();
  _GLSLTK_main_2();
}
uniform float gamma = 2.2;
uniform float exposure = 0.5;

void _GLSLTK_main_4(){
  vec3 mapped = (vec3(1.0) - exp((-color.rgb * exposure)));
  color.rgb = pow(mapped, vec3((1.0 / gamma)));
}

void _GLSLTK_main_5(){
  _GLSLTK_main_4();
}

void main(){
  _GLSLTK_main_3();
  _GLSLTK_main_5();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER FRAGMENT-SHADER {100AD74553}>: 
#version 330 core
out vec4 color;

void _GLSLTK_main_1(){
  color = vec4(1.0, 1.0, 1.0, 1.0);
}
in vec2 texcoord;
uniform sampler2D texture_image;

void _GLSLTK_main_2(){
  color *= texture(texture_image, texcoord);
}

void _GLSLTK_main_3(){
  _GLSLTK_main_1();
  _GLSLTK_main_2();
}
uniform float gamma = 2.2;
uniform float exposure = 0.5;

void _GLSLTK_main_4(){
  vec3 mapped = (vec3(1.0) - exp((-color.rgb * exposure)));
  color.rgb = pow(mapped, vec3((1.0 / gamma)));
}

void _GLSLTK_main_5(){
  _GLSLTK_main_4();
}

void main(){
  _GLSLTK_main_3();
  _GLSLTK_main_5();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER VERTEX-SHADER {100AC81873}>: 
#version 330 core
layout (location=0) in vec2 pos;
uniform mat3 transform;
out vec2 uv;

void main(){
  gl_Position = vec4(transform*vec3(pos, 1), 1);
  uv = pos;
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER FRAGMENT-SHADER {100AC81893}>: 
#version 330 core
uniform sampler2D image;
uniform vec2 uv_offset = vec2(0,0);
uniform vec2 uv_scale = vec2(1,1);
in vec2 uv;
out vec4 out_color;

void main(){
  out_color = texture(image, (uv+uv_offset)/uv_scale);
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Linked #<SHADER-PROGRAM {100AB85073}> with (#<SHADER VERTEX-SHADER {100AC81873}>
                                            #<SHADER FRAGMENT-SHADER {100AC81893}>).
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER VERTEX-SHADER {100ACDA673}>: 
#version 330 core
layout (location=0) in vec2 pos;
uniform mat3 transform;

void main(){
  gl_Position = vec4(transform*vec3(pos, 1), 1);
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER FRAGMENT-SHADER {100ACDA693}>: 
#version 330 core
uniform vec4 color;
out vec4 out_color;

void main(){
  out_color = color;
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Linked #<SHADER-PROGRAM {100ABBAB43}> with (#<SHADER VERTEX-SHADER {100ACDA673}>
                                            #<SHADER FRAGMENT-SHADER {100ACDA693}>).
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER VERTEX-SHADER {100ACDA593}>: 
#version 330 core
layout (location=0) in vec2 pos;
layout (location=1) in vec4 vertex_color;

out vec4 color;
uniform mat3 transform;

void main(){
  gl_Position = vec4(transform*vec3(pos, 1), 1);
  color = vertex_color;
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER FRAGMENT-SHADER {100ACDA5B3}>: 
#version 330 core
in vec4 color;
out vec4 out_color;

void main(){
  out_color = color;
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Linked #<SHADER-PROGRAM {100ABBAB23}> with (#<SHADER VERTEX-SHADER {100ACDA593}>
                                            #<SHADER FRAGMENT-SHADER {100ACDA5B3}>).
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER FRAGMENT-SHADER {100ACDA4D3}>: 
#version 330 core
in vec2 line_normal;
uniform float feather = 0.66;
uniform vec4 color;
out vec4 out_color;

void main(){
   float strength = 1-length(line_normal);
   out_color = color * clamp(strength*feather+feather, 0, 1);
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Linked #<SHADER-PROGRAM {100ABBAB03}> with (#<SHADER VERTEX-SHADER {100ACDA4B3}>
                                            #<SHADER FRAGMENT-SHADER {100ACDA4D3}>).
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER VERTEX-SHADER {100ACDA323}>: 
#version 330 core
layout (location=0) in vec2 pos;
layout (location=1) in vec2 in_uv;
uniform mat3 transform;
out vec2 uv;

void main(){
  gl_Position = vec4(transform*vec3(pos, 1), 1);
  uv = in_uv;
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER FRAGMENT-SHADER {100ACDA343}>: 
#version 330 core
in vec2 uv;
uniform sampler2D image;
uniform float pxRange = 4;
uniform vec4 color = vec4(0, 0, 0, 1);
out vec4 out_color;

float median(float r, float g, float b){
  return max(min(r, g), min(max(r, g), b));
}

void main(){
  vec2 msdfUnit = pxRange/vec2(textureSize(image, 0));
  vec3 msdfData = texture(image, uv).rgb;
  float sigDist = median(msdfData.r, msdfData.g, msdfData.b) - 0.5;
  sigDist *= dot(msdfUnit, 0.5/fwidth(uv));
  float opacity = clamp(sigDist + 0.5, 0.0, 1.0);
  out_color = vec4(color.rgb, color.a*opacity);
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Linked #<SHADER-PROGRAM {100ABBA923}> with (#<SHADER VERTEX-SHADER {100ACDA323}>
                                            #<SHADER FRAGMENT-SHADER {100ACDA343}>).
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER FRAGMENT-SHADER {100AD73873}>: 
#version 330 core
out vec4 color;

void _GLSLTK_main_1(){
  color = vec4(1.0, 1.0, 1.0, 1.0);
}
in vec2 texcoord;
uniform sampler2D texture_image;

void _GLSLTK_main_2(){
  color *= texture(texture_image, texcoord);
}

void _GLSLTK_main_3(){
  _GLSLTK_main_1();
  _GLSLTK_main_2();
}

void _GLSLTK_main_4(){
}

void main(){
  _GLSLTK_main_3();
  _GLSLTK_main_4();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER VERTEX-SHADER {100AD73893}>: 
#version 330 core
layout(location = 1) in vec2 in_texcoord;
out vec2 texcoord;

void _GLSLTK_main_1(){
  texcoord = in_texcoord;
}
layout(location = 0) in vec3 position;
uniform mat4 model_matrix;
uniform mat4 view_matrix;
uniform mat4 projection_matrix;

void _GLSLTK_main_2(){
  gl_Position = (projection_matrix * (view_matrix * (model_matrix * vec4(position, 1.0))));
}

void _GLSLTK_main_3(){
  _GLSLTK_main_1();
  _GLSLTK_main_2();
}

void _GLSLTK_main_4(){
}

void main(){
  _GLSLTK_main_3();
  _GLSLTK_main_4();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Linked #<SHADER-PROGRAM {100AD073B3}> with (#<SHADER FRAGMENT-SHADER {100AD73873}>
                                            #<SHADER VERTEX-SHADER {100AD73893}>).
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER VERTEX-SHADER {100AD2D813}>: 
#version 330 core
layout(std140) uniform LightInfo{
  int activep;
  vec2 sun_position;
  vec3 sun_light;
  vec3 ambient_light;
} light_info;
layout(location = 0) in vec2 vertex_position;
uniform mat4 model_matrix;
uniform mat4 view_matrix;
uniform mat4 projection_matrix;

void _GLSLTK_main_1(){
  vec2 vertex = vertex_position;
  if(((gl_VertexID % 2) != 0)){
    vec2 direction = (light_info.sun_position - vertex);
    vertex = (vertex - (direction * 100));
  };
  gl_Position = (projection_matrix * (view_matrix * (model_matrix * vec4(vertex, 0, 1))));
}

void main(){
  _GLSLTK_main_1();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER FRAGMENT-SHADER {100AD2D833}>: 
#version 330 core
out vec4 color;

void _GLSLTK_main_1(){
  color = vec4(0.5);
}

void main(){
  _GLSLTK_main_1();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Linked #<SHADER-PROGRAM {100AC5B693}> with (#<SHADER VERTEX-SHADER {100AD2D813}>
                                            #<SHADER FRAGMENT-SHADER {100AD2D833}>).
2020-07-31 15:00:16 [DEBUG] <TRIAL.FRAMEBUFFER>: Attaching #<TEXTURE 1280x720 RGBA16F {100AC17FB3}> as COLOR-ATTACHMENT0 to #<FRAMEBUFFER COLOR-ATTACHMENT0  {100AC5B573}>.
2020-07-31 15:00:16 [DEBUG] <TRIAL.FRAMEBUFFER>: Attaching #<TEXTURE 1280x720 RGBA16F {100AC17F93}> as COLOR-ATTACHMENT0 to #<FRAMEBUFFER COLOR-ATTACHMENT0  {100AC5B7A3}>.
2020-07-31 15:00:16 [DEBUG] <TRIAL.FRAMEBUFFER>: Attaching #<TEXTURE 1280x720 RGBA16F {100AC17FD3}> as COLOR-ATTACHMENT0 to #<FRAMEBUFFER COLOR-ATTACHMENT0 DEPTH-STENCIL-ATTACHMENT  {100AC5BA83}>.
2020-07-31 15:00:16 [DEBUG] <TRIAL.FRAMEBUFFER>: Attaching #<TEXTURE 1280x720 DEPTH-STENCIL {100AC17F73}> as DEPTH-STENCIL-ATTACHMENT to #<FRAMEBUFFER COLOR-ATTACHMENT0 DEPTH-STENCIL-ATTACHMENT  {100AC5BA83}>.
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER VERTEX-SHADER {100AD73E73}>: 
#version 330 core
layout(location = 1) in vec2 in_texcoord;
out vec2 texcoord;

void _GLSLTK_main_1(){
  texcoord = in_texcoord;
}
layout(location = 0) in vec3 vertex;
uniform vec2 parallax_speed = vec2(2, 1);
uniform vec2 background_scale = vec2(2, 2);
uniform mat4 view_matrix;
uniform mat4 model_matrix;
uniform vec2 view_size;
out vec2 map_coord;

void _GLSLTK_main_2(){
  map_coord = (model_matrix * (view_matrix * vec4((in_texcoord * (view_size * parallax_speed)), 0, 1))).xy;
  map_coord /= (parallax_speed * background_scale);
  gl_Position = vec4(vertex, 1);
}

void _GLSLTK_main_3(){
  _GLSLTK_main_1();
  _GLSLTK_main_2();
}

void _GLSLTK_main_4(){
}

void main(){
  _GLSLTK_main_3();
  _GLSLTK_main_4();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Linked #<SHADER-PROGRAM {100AD07773}> with (#<SHADER FRAGMENT-SHADER {100AD73E53}>
                                            #<SHADER VERTEX-SHADER {100AD73E73}>).
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER FRAGMENT-SHADER {100AD73F33}>: 
#version 330 core
layout(std140) uniform LightInfo{
  int activep;
  vec2 sun_position;
  vec3 sun_light;
  vec3 ambient_light;
} light_info;
uniform sampler2D lighting;
uniform sampler2D shadow_map;

vec4 apply_lighting(vec4 color, vec2 offset, float absorption){
  vec3 truecolor = pow(color.rgb, vec3(2.2));
  if((light_info.activep != 0)){
    ivec2 pos = ivec2((gl_FragCoord.xy - (vec2(0.5) + offset)));
    float shade = (0.4 < texelFetch(shadow_map, pos, 0).r)? 0 :1;
    vec4 light = texelFetch(lighting, pos, 0);
    truecolor *= light_info.ambient_light;
    truecolor += (light_info.sun_light * (max(0, (shade - absorption)) * color.rgb));
    truecolor += (light.rgb * (max(0, (light.a - absorption)) * color.rgb));
  }else{
    truecolor *= 5;
  };
  ;
  return vec4(truecolor, color.a);
}
uniform usampler2D tilemap;
uniform sampler2D albedo;
uniform sampler2D absorption;
uniform vec2 map_size;
uniform vec2 map_position;
uniform int tile_size = 16;
in vec2 map_coord;
out vec4 color;

void _GLSLTK_main_1(){
  ivec2 map_wh = (ivec2(map_size) * tile_size);
  ivec2 map_xy = ivec2((map_coord + (map_wh / 2.0)));
  ivec2 tile_xy = ivec2((map_xy.x / tile_size), (map_xy.y / tile_size));
  ivec2 pixel_xy = ivec2((map_xy.x % tile_size), (map_xy.y % tile_size));
  uvec2 tile = texelFetch(tilemap, tile_xy, 0).rg;
  tile_xy = ((ivec2(tile) * tile_size) + pixel_xy);
  color = texelFetch(albedo, tile_xy, 0);
  float absor = texelFetch(absorption, tile_xy, 0).r;
  color = apply_lighting(color, vec2(0), (1 - absor));
}

void _GLSLTK_main_2(){
  _GLSLTK_main_1();
}
uniform float gamma = 2.2;
uniform float exposure = 0.5;

void _GLSLTK_main_3(){
  vec3 mapped = (vec3(1.0) - exp((-color.rgb * exposure)));
  color.rgb = pow(mapped, vec3((1.0 / gamma)));
}

void _GLSLTK_main_4(){
  _GLSLTK_main_3();
}

void main(){
  _GLSLTK_main_2();
  _GLSLTK_main_4();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER VERTEX-SHADER {100AD73F53}>: 
#version 330 core
layout(location = 0) in vec3 vertex;
layout(location = 1) in vec2 vertex_uv;
uniform mat4 view_matrix;
uniform mat4 model_matrix;
uniform vec2 view_size;
out vec2 map_coord;

void _GLSLTK_main_1(){
  map_coord = (model_matrix * (view_matrix * vec4((vertex_uv * view_size), 0, 1))).xy;
  gl_Position = vec4(vertex, 1);
}

void _GLSLTK_main_2(){
  _GLSLTK_main_1();
}

void _GLSLTK_main_3(){
}

void main(){
  _GLSLTK_main_2();
  _GLSLTK_main_3();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Linked #<SHADER-PROGRAM {100AD07793}> with (#<SHADER FRAGMENT-SHADER {100AD73F33}>
                                            #<SHADER VERTEX-SHADER {100AD73F53}>).
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER FRAGMENT-SHADER {100AD74013}>: 
#version 330 core
layout(std140) uniform LightInfo{
  int activep;
  vec2 sun_position;
  vec3 sun_light;
  vec3 ambient_light;
} light_info;
uniform sampler2D lighting;
uniform sampler2D shadow_map;

vec4 apply_lighting(vec4 color, vec2 offset, float absorption){
  vec3 truecolor = pow(color.rgb, vec3(2.2));
  if((light_info.activep != 0)){
    ivec2 pos = ivec2((gl_FragCoord.xy - (vec2(0.5) + offset)));
    float shade = (0.4 < texelFetch(shadow_map, pos, 0).r)? 0 :1;
    vec4 light = texelFetch(lighting, pos, 0);
    truecolor *= light_info.ambient_light;
    truecolor += (light_info.sun_light * (max(0, (shade - absorption)) * color.rgb));
    truecolor += (light.rgb * (max(0, (light.a - absorption)) * color.rgb));
  }else{
    truecolor *= 5;
  };
  ;
  return vec4(truecolor, color.a);
}
out vec4 color;

void _GLSLTK_main_1(){
  color = vec4(1.0, 1.0, 1.0, 1.0);
}
in vec2 texcoord;
uniform sampler2D texture_image;

void _GLSLTK_main_2(){
  color *= texture(texture_image, texcoord);
}

void _GLSLTK_main_3(){
  color = apply_lighting(color, vec2(0, -5), 0);
}

void _GLSLTK_main_4(){
  _GLSLTK_main_1();
  _GLSLTK_main_2();
  _GLSLTK_main_3();
}
uniform float gamma = 2.2;
uniform float exposure = 0.5;

void _GLSLTK_main_5(){
  vec3 mapped = (vec3(1.0) - exp((-color.rgb * exposure)));
  color.rgb = pow(mapped, vec3((1.0 / gamma)));
}

void _GLSLTK_main_6(){
  _GLSLTK_main_5();
}

void main(){
  _GLSLTK_main_4();
  _GLSLTK_main_6();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER VERTEX-SHADER {100AD74033}>: 
#version 330 core
layout(location = 1) in vec2 in_texcoord;
out vec2 texcoord;

void _GLSLTK_main_1(){
  texcoord = in_texcoord;
}
layout(location = 0) in vec3 position;
uniform mat4 model_matrix;
uniform mat4 view_matrix;
uniform mat4 projection_matrix;

void _GLSLTK_main_2(){
  gl_Position = (projection_matrix * (view_matrix * (model_matrix * vec4(position, 1.0))));
}

void _GLSLTK_main_3(){
  _GLSLTK_main_1();
  _GLSLTK_main_2();
}

void _GLSLTK_main_4(){
}

void main(){
  _GLSLTK_main_3();
  _GLSLTK_main_4();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Linked #<SHADER-PROGRAM {100AD077B3}> with (#<SHADER FRAGMENT-SHADER {100AD74013}>
                                            #<SHADER VERTEX-SHADER {100AD74033}>).
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER FRAGMENT-SHADER {100AD740F3}>: 
#version 330 core
out vec4 color;

void _GLSLTK_main_1(){
  color = vec4(1.0, 1.0, 1.0, 1.0);
}
in vec2 texcoord;
uniform sampler2D texture_image;

void _GLSLTK_main_2(){
  color *= texture(texture_image, texcoord);
}

void _GLSLTK_main_3(){
  _GLSLTK_main_1();
  _GLSLTK_main_2();
}
uniform float gamma = 2.2;
uniform float exposure = 0.5;

void _GLSLTK_main_4(){
  vec3 mapped = (vec3(1.0) - exp((-color.rgb * exposure)));
  color.rgb = pow(mapped, vec3((1.0 / gamma)));
}

void _GLSLTK_main_5(){
  _GLSLTK_main_4();
}

void main(){
  _GLSLTK_main_3();
  _GLSLTK_main_5();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER VERTEX-SHADER {100AD74113}>: 
#version 330 core
layout(location = 1) in vec2 in_texcoord;
out vec2 texcoord;

void _GLSLTK_main_1(){
  texcoord = in_texcoord;
}
layout(location = 0) in vec3 position;
uniform mat4 model_matrix;
uniform mat4 view_matrix;
uniform mat4 projection_matrix;

void _GLSLTK_main_2(){
  gl_Position = (projection_matrix * (view_matrix * (model_matrix * vec4(position, 1.0))));
}

void _GLSLTK_main_3(){
  _GLSLTK_main_1();
  _GLSLTK_main_2();
}

void _GLSLTK_main_4(){
}

void main(){
  _GLSLTK_main_3();
  _GLSLTK_main_4();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Linked #<SHADER-PROGRAM {100AD077D3}> with (#<SHADER FRAGMENT-SHADER {100AD740F3}>
                                            #<SHADER VERTEX-SHADER {100AD74113}>).
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER FRAGMENT-SHADER {100AD741D3}>: 
#version 330 core
layout(std140) uniform LightInfo{
  int activep;
  vec2 sun_position;
  vec3 sun_light;
  vec3 ambient_light;
} light_info;
uniform sampler2D lighting;
uniform sampler2D shadow_map;

vec4 apply_lighting(vec4 color, vec2 offset, float absorption){
  vec3 truecolor = pow(color.rgb, vec3(2.2));
  if((light_info.activep != 0)){
    ivec2 pos = ivec2((gl_FragCoord.xy - (vec2(0.5) + offset)));
    float shade = (0.4 < texelFetch(shadow_map, pos, 0).r)? 0 :1;
    vec4 light = texelFetch(lighting, pos, 0);
    truecolor *= light_info.ambient_light;
    truecolor += (light_info.sun_light * (max(0, (shade - absorption)) * color.rgb));
    truecolor += (light.rgb * (max(0, (light.a - absorption)) * color.rgb));
  }else{
    truecolor *= 5;
  };
  ;
  return vec4(truecolor, color.a);
}
uniform usampler2D tilemap;
uniform sampler2D albedo;
uniform sampler2D absorption;
uniform vec2 map_size;
uniform vec2 map_position;
uniform int tile_size = 16;
in vec2 map_coord;
out vec4 color;

void _GLSLTK_main_1(){
  ivec2 map_wh = (ivec2(map_size) * tile_size);
  ivec2 map_xy = ivec2((map_coord + (map_wh / 2.0)));
  ivec2 tile_xy = ivec2((map_xy.x / tile_size), (map_xy.y / tile_size));
  ivec2 pixel_xy = ivec2((map_xy.x % tile_size), (map_xy.y % tile_size));
  uvec2 tile = texelFetch(tilemap, tile_xy, 0).rg;
  tile_xy = ((ivec2(tile) * tile_size) + pixel_xy);
  color = texelFetch(albedo, tile_xy, 0);
  float absor = texelFetch(absorption, tile_xy, 0).r;
  color = apply_lighting(color, vec2(0), (1 - absor));
}
uniform float visibility = 1.0;

void _GLSLTK_main_2(){
  color *= visibility;
}

void _GLSLTK_main_3(){
  _GLSLTK_main_1();
  _GLSLTK_main_2();
}
uniform float gamma = 2.2;
uniform float exposure = 0.5;

void _GLSLTK_main_4(){
  vec3 mapped = (vec3(1.0) - exp((-color.rgb * exposure)));
  color.rgb = pow(mapped, vec3((1.0 / gamma)));
}

void _GLSLTK_main_5(){
  _GLSLTK_main_4();
}

void main(){
  _GLSLTK_main_3();
  _GLSLTK_main_5();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER VERTEX-SHADER {100AD741F3}>: 
#version 330 core
layout(location = 0) in vec3 vertex;
layout(location = 1) in vec2 vertex_uv;
uniform mat4 view_matrix;
uniform mat4 model_matrix;
uniform vec2 view_size;
out vec2 map_coord;

void _GLSLTK_main_1(){
  map_coord = (model_matrix * (view_matrix * vec4((vertex_uv * view_size), 0, 1))).xy;
  gl_Position = vec4(vertex, 1);
}

void _GLSLTK_main_2(){
  _GLSLTK_main_1();
}

void _GLSLTK_main_3(){
}

void main(){
  _GLSLTK_main_2();
  _GLSLTK_main_3();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Linked #<SHADER-PROGRAM {100AD077F3}> with (#<SHADER FRAGMENT-SHADER {100AD741D3}>
                                            #<SHADER VERTEX-SHADER {100AD741F3}>).
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER FRAGMENT-SHADER {100AD742B3}>: 
#version 330 core
out vec4 color;

void _GLSLTK_main_1(){
  color = vec4(1.0, 1.0, 1.0, 1.0);
}

void _GLSLTK_main_2(){
  color = vec4(0, 0, 0, 1);
}

void _GLSLTK_main_3(){
  _GLSLTK_main_1();
  _GLSLTK_main_2();
}
uniform float gamma = 2.2;
uniform float exposure = 0.5;

void _GLSLTK_main_4(){
  vec3 mapped = (vec3(1.0) - exp((-color.rgb * exposure)));
  color.rgb = pow(mapped, vec3((1.0 / gamma)));
}

void _GLSLTK_main_5(){
  _GLSLTK_main_4();
}

void main(){
  _GLSLTK_main_3();
  _GLSLTK_main_5();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER VERTEX-SHADER {100AD742D3}>: 
#version 330 core
layout(location = 0) in vec3 position;
uniform mat4 model_matrix;
uniform mat4 view_matrix;
uniform mat4 projection_matrix;

void _GLSLTK_main_1(){
  gl_Position = (projection_matrix * (view_matrix * (model_matrix * vec4(position, 1.0))));
}

void _GLSLTK_main_2(){
  _GLSLTK_main_1();
}

void _GLSLTK_main_3(){
}

void main(){
  _GLSLTK_main_2();
  _GLSLTK_main_3();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Linked #<SHADER-PROGRAM {100AD07813}> with (#<SHADER FRAGMENT-SHADER {100AD742B3}>
                                            #<SHADER VERTEX-SHADER {100AD742D3}>).
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER FRAGMENT-SHADER {100AD74393}>: 
#version 330 core
out vec4 color;

void _GLSLTK_main_1(){
  color = vec4(1.0, 1.0, 1.0, 1.0);
}
in vec2 line_normal;
in vec4 line_color;
uniform float feather = 0.3;

void _GLSLTK_main_2(){
  color = (line_color * ((1 - length(line_normal)) / feather));
}

void _GLSLTK_main_3(){
  _GLSLTK_main_1();
  _GLSLTK_main_2();
}
uniform float gamma = 2.2;
uniform float exposure = 0.5;

void _GLSLTK_main_4(){
  vec3 mapped = (vec3(1.0) - exp((-color.rgb * exposure)));
  color.rgb = pow(mapped, vec3((1.0 / gamma)));
}

void _GLSLTK_main_5(){
  _GLSLTK_main_4();
}

void main(){
  _GLSLTK_main_3();
  _GLSLTK_main_5();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER VERTEX-SHADER {100AD743B3}>: 
#version 330 core
layout(location = 0) in vec3 position;
layout(location = 1) in vec3 direction;
layout(location = 2) in vec4 color;
out vec2 line_normal;
out vec4 line_color;
uniform float line_width = 3.0;
uniform vec2 view_size = vec2(800, 600);
uniform mat4 model_matrix;
uniform mat4 view_matrix;
uniform mat4 projection_matrix;

void _GLSLTK_main_1(){
  float aspect = (view_size.x / view_size.y);
  mat4 PVM = (projection_matrix * (view_matrix * model_matrix));
  vec4 screen1 = (PVM * vec4(position, 1));
  vec4 screen2 = (PVM * vec4((position + direction), 1));
  vec2 clip1 = (screen1.xy / max(0.00001, screen1.w));
  vec2 clip2 = (screen2.xy / max(0.00001, screen2.w));
  clip1.x *= aspect;
  clip2.x *= aspect;
  line_normal = normalize((clip2 - clip1));
  line_normal = vec2(-line_normal.y, line_normal.x);
  gl_Position = (screen1 + (screen1.w * vec4(((line_normal * line_width) / view_size), 0, 0)));
  line_color = color;
}

void _GLSLTK_main_2(){
  _GLSLTK_main_1();
}

void _GLSLTK_main_3(){
}

void main(){
  _GLSLTK_main_2();
  _GLSLTK_main_3();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Linked #<SHADER-PROGRAM {100AD07833}> with (#<SHADER FRAGMENT-SHADER {100AD74393}>
                                            #<SHADER VERTEX-SHADER {100AD743B3}>).
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER FRAGMENT-SHADER {100AD74473}>: 
#version 330 core
out vec4 color;

void _GLSLTK_main_1(){
  color = vec4(1.0, 1.0, 1.0, 1.0);
}
uniform vec4 objectcolor;
uniform sampler2D texture_image;
in vec2 texcoord;

void _GLSLTK_main_2(){
  float intensity = texture(texture_image, texcoord, -0.65).r;
  color = (objectcolor * intensity);
}

void _GLSLTK_main_3(){
  _GLSLTK_main_1();
  _GLSLTK_main_2();
}
uniform float gamma = 2.2;
uniform float exposure = 0.5;

void _GLSLTK_main_4(){
  vec3 mapped = (vec3(1.0) - exp((-color.rgb * exposure)));
  color.rgb = pow(mapped, vec3((1.0 / gamma)));
}

void _GLSLTK_main_5(){
  _GLSLTK_main_4();
}

void main(){
  _GLSLTK_main_3();
  _GLSLTK_main_5();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER VERTEX-SHADER {100AD74493}>: 
#version 330 core
layout(location = 1) in vec2 in_texcoord;
out vec2 texcoord;

void _GLSLTK_main_1(){
  texcoord = in_texcoord;
}
layout(location = 0) in vec3 position;
uniform mat4 model_matrix;
uniform mat4 view_matrix;
uniform mat4 projection_matrix;

void _GLSLTK_main_2(){
  gl_Position = (projection_matrix * (view_matrix * (model_matrix * vec4(position, 1.0))));
}

void _GLSLTK_main_3(){
  _GLSLTK_main_1();
  _GLSLTK_main_2();
}

void _GLSLTK_main_4(){
}

void main(){
  _GLSLTK_main_3();
  _GLSLTK_main_4();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Linked #<SHADER-PROGRAM {100AD07853}> with (#<SHADER FRAGMENT-SHADER {100AD74473}>
                                            #<SHADER VERTEX-SHADER {100AD74493}>).
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER VERTEX-SHADER {100AD74573}>: 
#version 330 core
layout(location = 1) in vec2 in_texcoord;
out vec2 texcoord;

void _GLSLTK_main_1(){
  texcoord = in_texcoord;
}
layout(location = 0) in vec3 position;
uniform mat4 model_matrix;
uniform mat4 view_matrix;
uniform mat4 projection_matrix;

void _GLSLTK_main_2(){
  gl_Position = (projection_matrix * (view_matrix * (model_matrix * vec4(position, 1.0))));
}

void _GLSLTK_main_3(){
  _GLSLTK_main_1();
  _GLSLTK_main_2();
}

void _GLSLTK_main_4(){
}

void main(){
  _GLSLTK_main_3();
  _GLSLTK_main_4();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Linked #<SHADER-PROGRAM {100AD07873}> with (#<SHADER FRAGMENT-SHADER {100AD74553}>
                                            #<SHADER VERTEX-SHADER {100AD74573}>).
2020-07-31 15:00:16 [INFO ] <TRIAL.CONTEXT>: #<THREAD "main thread" RUNNING {10003900C3}> releasing #<CONTEXT {100A4250F3}>.
2020-07-31 15:00:16 [INFO ] <TRIAL.CONTEXT>: #<THREAD "render-loop thread" RUNNING {10098C6FC3}> acquiring #<CONTEXT {100A4250F3}>.
2020-07-31 15:00:16 [INFO ] <TRIAL.SHADER-PASS>: Refreshing shader program for #<SHADER-ENTITY-CLASS LEAF::SWEEP>
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER FRAGMENT-SHADER {1007BCDD13}>: 
#version 330 core
out vec4 color;

void _GLSLTK_main_1(){
  color = vec4(1.0, 1.0, 1.0, 1.0);
}

void _GLSLTK_main_2(){
  color = vec4(0, 0, 0, 1);
}

void _GLSLTK_main_3(){
  _GLSLTK_main_1();
  _GLSLTK_main_2();
}
uniform float gamma = 2.2;
uniform float exposure = 0.5;

void _GLSLTK_main_4(){
  vec3 mapped = (vec3(1.0) - exp((-color.rgb * exposure)));
  color.rgb = pow(mapped, vec3((1.0 / gamma)));
}

void _GLSLTK_main_5(){
  _GLSLTK_main_4();
}

void main(){
  _GLSLTK_main_3();
  _GLSLTK_main_5();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER VERTEX-SHADER {1007B959A3}>: 
#version 330 core
layout(location = 0) in vec3 position;
uniform mat4 model_matrix;
uniform mat4 view_matrix;
uniform mat4 projection_matrix;

void _GLSLTK_main_1(){
  gl_Position = (projection_matrix * (view_matrix * (model_matrix * vec4(position, 1.0))));
}

void _GLSLTK_main_2(){
  _GLSLTK_main_1();
}

void _GLSLTK_main_3(){
}

void main(){
  _GLSLTK_main_2();
  _GLSLTK_main_3();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Linked #<SHADER-PROGRAM {1006BEBE53}> with (#<SHADER FRAGMENT-SHADER {1007BCDD13}>
                                            #<SHADER VERTEX-SHADER {1007B959A3}>).
2020-07-31 15:00:16 [INFO ] <TRIAL.SHADER-PASS>: Refreshing shader program for #<SHADER-ENTITY-CLASS TRIAL::LINES>
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER FRAGMENT-SHADER {10080DDF23}>: 
#version 330 core
out vec4 color;

void _GLSLTK_main_1(){
  color = vec4(1.0, 1.0, 1.0, 1.0);
}
in vec2 line_normal;
in vec4 line_color;
uniform float feather = 0.3;

void _GLSLTK_main_2(){
  color = (line_color * ((1 - length(line_normal)) / feather));
}

void _GLSLTK_main_3(){
  _GLSLTK_main_1();
  _GLSLTK_main_2();
}
uniform float gamma = 2.2;
uniform float exposure = 0.5;

void _GLSLTK_main_4(){
  vec3 mapped = (vec3(1.0) - exp((-color.rgb * exposure)));
  color.rgb = pow(mapped, vec3((1.0 / gamma)));
}

void _GLSLTK_main_5(){
  _GLSLTK_main_4();
}

void main(){
  _GLSLTK_main_3();
  _GLSLTK_main_5();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER VERTEX-SHADER {1008049D83}>: 
#version 330 core
layout(location = 0) in vec3 position;
layout(location = 1) in vec3 direction;
layout(location = 2) in vec4 color;
out vec2 line_normal;
out vec4 line_color;
uniform float line_width = 3.0;
uniform vec2 view_size = vec2(800, 600);
uniform mat4 model_matrix;
uniform mat4 view_matrix;
uniform mat4 projection_matrix;

void _GLSLTK_main_1(){
  float aspect = (view_size.x / view_size.y);
  mat4 PVM = (projection_matrix * (view_matrix * model_matrix));
  vec4 screen1 = (PVM * vec4(position, 1));
  vec4 screen2 = (PVM * vec4((position + direction), 1));
  vec2 clip1 = (screen1.xy / max(0.00001, screen1.w));
  vec2 clip2 = (screen2.xy / max(0.00001, screen2.w));
  clip1.x *= aspect;
  clip2.x *= aspect;
  line_normal = normalize((clip2 - clip1));
  line_normal = vec2(-line_normal.y, line_normal.x);
  gl_Position = (screen1 + (screen1.w * vec4(((line_normal * line_width) / view_size), 0, 0)));
  line_color = color;
}

void _GLSLTK_main_2(){
  _GLSLTK_main_1();
}

void _GLSLTK_main_3(){
}

void main(){
  _GLSLTK_main_2();
  _GLSLTK_main_3();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Linked #<SHADER-PROGRAM {1006BEBEB3}> with (#<SHADER FRAGMENT-SHADER {10080DDF23}>
                                            #<SHADER VERTEX-SHADER {1008049D83}>).
2020-07-31 15:00:16 [INFO ] <TRIAL.SHADER-PASS>: Refreshing shader program for #<SHADER-PASS-CLASS LEAF::SHADOW-MAP-PASS>
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER VERTEX-SHADER {10080E4233}>: 
#version 330 core
layout(std140) uniform LightInfo{
  int activep;
  vec2 sun_position;
  vec3 sun_light;
  vec3 ambient_light;
} light_info;
layout(location = 0) in vec2 vertex_position;
uniform mat4 model_matrix;
uniform mat4 view_matrix;
uniform mat4 projection_matrix;

void _GLSLTK_main_1(){
  vec2 vertex = vertex_position;
  if(((gl_VertexID % 2) != 0)){
    vec2 direction = (light_info.sun_position - vertex);
    vertex = (vertex - (direction * 100));
  };
  gl_Position = (projection_matrix * (view_matrix * (model_matrix * vec4(vertex, 0, 1))));
}

void main(){
  _GLSLTK_main_1();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER FRAGMENT-SHADER {10080E42E3}>: 
#version 330 core
out vec4 color;

void _GLSLTK_main_1(){
  color = vec4(0.5);
}

void main(){
  _GLSLTK_main_1();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Linked #<SHADER-PROGRAM {1006BEBB73}> with (#<SHADER VERTEX-SHADER {10080E4233}>
                                            #<SHADER FRAGMENT-SHADER {10080E42E3}>).
2020-07-31 15:00:16 [INFO ] <TRIAL.SHADER-PASS>: Refreshing shader program for #<SHADER-ENTITY-CLASS TRIAL:SPRITE-ENTITY>
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER FRAGMENT-SHADER {100815B453}>: 
#version 330 core
out vec4 color;

void _GLSLTK_main_1(){
  color = vec4(1.0, 1.0, 1.0, 1.0);
}
in vec2 texcoord;
uniform sampler2D texture_image;

void _GLSLTK_main_2(){
  color *= texture(texture_image, texcoord);
}

void _GLSLTK_main_3(){
  _GLSLTK_main_1();
  _GLSLTK_main_2();
}

void _GLSLTK_main_4(){
}

void main(){
  _GLSLTK_main_3();
  _GLSLTK_main_4();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER VERTEX-SHADER {1008150833}>: 
#version 330 core
layout(location = 1) in vec2 in_texcoord;
out vec2 texcoord;

void _GLSLTK_main_1(){
  texcoord = in_texcoord;
}
layout(location = 0) in vec3 position;
uniform mat4 model_matrix;
uniform mat4 view_matrix;
uniform mat4 projection_matrix;

void _GLSLTK_main_2(){
  gl_Position = (projection_matrix * (view_matrix * (model_matrix * vec4(position, 1.0))));
}

void _GLSLTK_main_3(){
  _GLSLTK_main_1();
  _GLSLTK_main_2();
}

void _GLSLTK_main_4(){
}

void main(){
  _GLSLTK_main_3();
  _GLSLTK_main_4();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Linked #<SHADER-PROGRAM {1006BEBAF3}> with (#<SHADER FRAGMENT-SHADER {100815B453}>
                                            #<SHADER VERTEX-SHADER {1008150833}>).
2020-07-31 15:00:16 [INFO ] <TRIAL.SHADER-PASS>: Refreshing shader program for #<SHADER-ENTITY-CLASS LEAF::BACKGROUND>
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER FRAGMENT-SHADER {10084A75A3}>: 
#version 330 core
layout(std140) uniform LightInfo{
  int activep;
  vec2 sun_position;
  vec3 sun_light;
  vec3 ambient_light;
} light_info;
uniform sampler2D lighting;
uniform sampler2D shadow_map;

vec4 apply_lighting(vec4 color, vec2 offset, float absorption){
  vec3 truecolor = pow(color.rgb, vec3(2.2));
  if((light_info.activep != 0)){
    ivec2 pos = ivec2((gl_FragCoord.xy - (vec2(0.5) + offset)));
    float shade = (0.4 < texelFetch(shadow_map, pos, 0).r)? 0 :1;
    vec4 light = texelFetch(lighting, pos, 0);
    truecolor *= light_info.ambient_light;
    truecolor += (light_info.sun_light * (max(0, (shade - absorption)) * color.rgb));
    truecolor += (light.rgb * (max(0, (light.a - absorption)) * color.rgb));
  }else{
    truecolor *= 5;
  };
  ;
  return vec4(truecolor, color.a);
}
out vec4 color;

void _GLSLTK_main_1(){
  color = vec4(1.0, 1.0, 1.0, 1.0);
}
uniform sampler2D background;
uniform int parallax_direction = 1;
in vec2 map_coord;

void _GLSLTK_main_2(){
  ivec2 map_wh = textureSize(background, 0);
  ivec2 map_xy = ivec2(map_coord);
  switch(parallax_direction){
  case 0: 
    map_xy = clamp(map_xy, ivec2(0), (map_wh - 1));
    break;
  case 1: 
    map_xy.x %= map_wh.x;
    map_xy.y = clamp((map_xy.y + (map_wh.y / 2)), 0, (map_wh.y - 1));
    break;
  case 2: 
    map_xy.x = clamp(map_xy.x, 0, (map_wh.x - 1));
    map_xy.y %= map_wh.y;
    break;
  case 3: 
    map_xy %= map_wh;
    break;
  };
  ;
  color = texelFetch(background, map_xy, 0);
  color = mix(color, apply_lighting(color, vec2(0, 0), 0), 1);
}

void _GLSLTK_main_3(){
  _GLSLTK_main_1();
  _GLSLTK_main_2();
}
uniform float gamma = 2.2;
uniform float exposure = 0.5;

void _GLSLTK_main_4(){
  vec3 mapped = (vec3(1.0) - exp((-color.rgb * exposure)));
  color.rgb = pow(mapped, vec3((1.0 / gamma)));
}

void _GLSLTK_main_5(){
  _GLSLTK_main_4();
}

void main(){
  _GLSLTK_main_3();
  _GLSLTK_main_5();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER VERTEX-SHADER {10082111C3}>: 
#version 330 core
layout(location = 1) in vec2 in_texcoord;
out vec2 texcoord;

void _GLSLTK_main_1(){
  texcoord = in_texcoord;
}
layout(location = 0) in vec3 vertex;
uniform vec2 parallax_speed = vec2(2, 1);
uniform vec2 background_scale = vec2(2, 2);
uniform mat4 view_matrix;
uniform mat4 model_matrix;
uniform vec2 view_size;
out vec2 map_coord;

void _GLSLTK_main_2(){
  map_coord = (model_matrix * (view_matrix * vec4((in_texcoord * (view_size * parallax_speed)), 0, 1))).xy;
  map_coord /= (parallax_speed * background_scale);
  gl_Position = vec4(vertex, 1);
}

void _GLSLTK_main_3(){
  _GLSLTK_main_1();
  _GLSLTK_main_2();
}

void _GLSLTK_main_4(){
}

void main(){
  _GLSLTK_main_3();
  _GLSLTK_main_4();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Linked #<SHADER-PROGRAM {1006BEBC73}> with (#<SHADER FRAGMENT-SHADER {10084A75A3}>
                                            #<SHADER VERTEX-SHADER {10082111C3}>).
2020-07-31 15:00:16 [INFO ] <TRIAL.SHADER-PASS>: Refreshing shader program for #<SHADER-ENTITY-CLASS LEAF::LAYER>
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER FRAGMENT-SHADER {100873A493}>: 
#version 330 core
layout(std140) uniform LightInfo{
  int activep;
  vec2 sun_position;
  vec3 sun_light;
  vec3 ambient_light;
} light_info;
uniform sampler2D lighting;
uniform sampler2D shadow_map;

vec4 apply_lighting(vec4 color, vec2 offset, float absorption){
  vec3 truecolor = pow(color.rgb, vec3(2.2));
  if((light_info.activep != 0)){
    ivec2 pos = ivec2((gl_FragCoord.xy - (vec2(0.5) + offset)));
    float shade = (0.4 < texelFetch(shadow_map, pos, 0).r)? 0 :1;
    vec4 light = texelFetch(lighting, pos, 0);
    truecolor *= light_info.ambient_light;
    truecolor += (light_info.sun_light * (max(0, (shade - absorption)) * color.rgb));
    truecolor += (light.rgb * (max(0, (light.a - absorption)) * color.rgb));
  }else{
    truecolor *= 5;
  };
  ;
  return vec4(truecolor, color.a);
}
uniform usampler2D tilemap;
uniform sampler2D albedo;
uniform sampler2D absorption;
uniform vec2 map_size;
uniform vec2 map_position;
uniform int tile_size = 16;
in vec2 map_coord;
out vec4 color;

void _GLSLTK_main_1(){
  ivec2 map_wh = (ivec2(map_size) * tile_size);
  ivec2 map_xy = ivec2((map_coord + (map_wh / 2.0)));
  ivec2 tile_xy = ivec2((map_xy.x / tile_size), (map_xy.y / tile_size));
  ivec2 pixel_xy = ivec2((map_xy.x % tile_size), (map_xy.y % tile_size));
  uvec2 tile = texelFetch(tilemap, tile_xy, 0).rg;
  tile_xy = ((ivec2(tile) * tile_size) + pixel_xy);
  color = texelFetch(albedo, tile_xy, 0);
  float absor = texelFetch(absorption, tile_xy, 0).r;
  color = apply_lighting(color, vec2(0), (1 - absor));
}

void _GLSLTK_main_2(){
  _GLSLTK_main_1();
}
uniform float gamma = 2.2;
uniform float exposure = 0.5;

void _GLSLTK_main_3(){
  vec3 mapped = (vec3(1.0) - exp((-color.rgb * exposure)));
  color.rgb = pow(mapped, vec3((1.0 / gamma)));
}

void _GLSLTK_main_4(){
  _GLSLTK_main_3();
}

void main(){
  _GLSLTK_main_2();
  _GLSLTK_main_4();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER VERTEX-SHADER {10084E3623}>: 
#version 330 core
layout(location = 0) in vec3 vertex;
layout(location = 1) in vec2 vertex_uv;
uniform mat4 view_matrix;
uniform mat4 model_matrix;
uniform vec2 view_size;
out vec2 map_coord;

void _GLSLTK_main_1(){
  map_coord = (model_matrix * (view_matrix * vec4((vertex_uv * view_size), 0, 1))).xy;
  gl_Position = vec4(vertex, 1);
}

void _GLSLTK_main_2(){
  _GLSLTK_main_1();
}

void _GLSLTK_main_3(){
}

void main(){
  _GLSLTK_main_2();
  _GLSLTK_main_3();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Linked #<SHADER-PROGRAM {1006BEBCD3}> with (#<SHADER FRAGMENT-SHADER {100873A493}>
                                            #<SHADER VERTEX-SHADER {10084E3623}>).
2020-07-31 15:00:16 [INFO ] <TRIAL.SHADER-PASS>: Refreshing shader program for #<SHADER-ENTITY-CLASS LEAF::LIT-ANIMATED-SPRITE>
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER FRAGMENT-SHADER {100896B033}>: 
#version 330 core
layout(std140) uniform LightInfo{
  int activep;
  vec2 sun_position;
  vec3 sun_light;
  vec3 ambient_light;
} light_info;
uniform sampler2D lighting;
uniform sampler2D shadow_map;

vec4 apply_lighting(vec4 color, vec2 offset, float absorption){
  vec3 truecolor = pow(color.rgb, vec3(2.2));
  if((light_info.activep != 0)){
    ivec2 pos = ivec2((gl_FragCoord.xy - (vec2(0.5) + offset)));
    float shade = (0.4 < texelFetch(shadow_map, pos, 0).r)? 0 :1;
    vec4 light = texelFetch(lighting, pos, 0);
    truecolor *= light_info.ambient_light;
    truecolor += (light_info.sun_light * (max(0, (shade - absorption)) * color.rgb));
    truecolor += (light.rgb * (max(0, (light.a - absorption)) * color.rgb));
  }else{
    truecolor *= 5;
  };
  ;
  return vec4(truecolor, color.a);
}
out vec4 color;

void _GLSLTK_main_1(){
  color = vec4(1.0, 1.0, 1.0, 1.0);
}
in vec2 texcoord;
uniform sampler2D texture_image;

void _GLSLTK_main_2(){
  color *= texture(texture_image, texcoord);
}

void _GLSLTK_main_3(){
  color = apply_lighting(color, vec2(0, -5), 0);
}

void _GLSLTK_main_4(){
  _GLSLTK_main_1();
  _GLSLTK_main_2();
  _GLSLTK_main_3();
}
uniform float gamma = 2.2;
uniform float exposure = 0.5;

void _GLSLTK_main_5(){
  vec3 mapped = (vec3(1.0) - exp((-color.rgb * exposure)));
  color.rgb = pow(mapped, vec3((1.0 / gamma)));
}

void _GLSLTK_main_6(){
  _GLSLTK_main_5();
}

void main(){
  _GLSLTK_main_4();
  _GLSLTK_main_6();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER VERTEX-SHADER {10087B7153}>: 
#version 330 core
layout(location = 1) in vec2 in_texcoord;
out vec2 texcoord;

void _GLSLTK_main_1(){
  texcoord = in_texcoord;
}
layout(location = 0) in vec3 position;
uniform mat4 model_matrix;
uniform mat4 view_matrix;
uniform mat4 projection_matrix;

void _GLSLTK_main_2(){
  gl_Position = (projection_matrix * (view_matrix * (model_matrix * vec4(position, 1.0))));
}

void _GLSLTK_main_3(){
  _GLSLTK_main_1();
  _GLSLTK_main_2();
}

void _GLSLTK_main_4(){
}

void main(){
  _GLSLTK_main_3();
  _GLSLTK_main_4();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Linked #<SHADER-PROGRAM {1006BEBD33}> with (#<SHADER FRAGMENT-SHADER {100896B033}>
                                            #<SHADER VERTEX-SHADER {10087B7153}>).
2020-07-31 15:00:16 [INFO ] <TRIAL.SHADER-PASS>: Refreshing shader program for #<SHADER-ENTITY-CLASS LEAF::BALL>
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER FRAGMENT-SHADER {1008A2F393}>: 
#version 330 core
out vec4 color;

void _GLSLTK_main_1(){
  color = vec4(1.0, 1.0, 1.0, 1.0);
}
in vec2 texcoord;
uniform sampler2D texture_image;

void _GLSLTK_main_2(){
  color *= texture(texture_image, texcoord);
}

void _GLSLTK_main_3(){
  _GLSLTK_main_1();
  _GLSLTK_main_2();
}
uniform float gamma = 2.2;
uniform float exposure = 0.5;

void _GLSLTK_main_4(){
  vec3 mapped = (vec3(1.0) - exp((-color.rgb * exposure)));
  color.rgb = pow(mapped, vec3((1.0 / gamma)));
}

void _GLSLTK_main_5(){
  _GLSLTK_main_4();
}

void main(){
  _GLSLTK_main_3();
  _GLSLTK_main_5();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER VERTEX-SHADER {10089F7363}>: 
#version 330 core
layout(location = 1) in vec2 in_texcoord;
out vec2 texcoord;

void _GLSLTK_main_1(){
  texcoord = in_texcoord;
}
layout(location = 0) in vec3 position;
uniform mat4 model_matrix;
uniform mat4 view_matrix;
uniform mat4 projection_matrix;

void _GLSLTK_main_2(){
  gl_Position = (projection_matrix * (view_matrix * (model_matrix * vec4(position, 1.0))));
}

void _GLSLTK_main_3(){
  _GLSLTK_main_1();
  _GLSLTK_main_2();
}

void _GLSLTK_main_4(){
}

void main(){
  _GLSLTK_main_3();
  _GLSLTK_main_4();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Linked #<SHADER-PROGRAM {1006BEBD93}> with (#<SHADER FRAGMENT-SHADER {1008A2F393}>
                                            #<SHADER VERTEX-SHADER {10089F7363}>).
2020-07-31 15:00:16 [INFO ] <TRIAL.SHADER-PASS>: Refreshing shader program for #<SHADER-ENTITY-CLASS LEAF::CHUNK>
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER FRAGMENT-SHADER {1008C73BE3}>: 
#version 330 core
layout(std140) uniform LightInfo{
  int activep;
  vec2 sun_position;
  vec3 sun_light;
  vec3 ambient_light;
} light_info;
uniform sampler2D lighting;
uniform sampler2D shadow_map;

vec4 apply_lighting(vec4 color, vec2 offset, float absorption){
  vec3 truecolor = pow(color.rgb, vec3(2.2));
  if((light_info.activep != 0)){
    ivec2 pos = ivec2((gl_FragCoord.xy - (vec2(0.5) + offset)));
    float shade = (0.4 < texelFetch(shadow_map, pos, 0).r)? 0 :1;
    vec4 light = texelFetch(lighting, pos, 0);
    truecolor *= light_info.ambient_light;
    truecolor += (light_info.sun_light * (max(0, (shade - absorption)) * color.rgb));
    truecolor += (light.rgb * (max(0, (light.a - absorption)) * color.rgb));
  }else{
    truecolor *= 5;
  };
  ;
  return vec4(truecolor, color.a);
}
uniform usampler2D tilemap;
uniform sampler2D albedo;
uniform sampler2D absorption;
uniform vec2 map_size;
uniform vec2 map_position;
uniform int tile_size = 16;
in vec2 map_coord;
out vec4 color;

void _GLSLTK_main_1(){
  ivec2 map_wh = (ivec2(map_size) * tile_size);
  ivec2 map_xy = ivec2((map_coord + (map_wh / 2.0)));
  ivec2 tile_xy = ivec2((map_xy.x / tile_size), (map_xy.y / tile_size));
  ivec2 pixel_xy = ivec2((map_xy.x % tile_size), (map_xy.y % tile_size));
  uvec2 tile = texelFetch(tilemap, tile_xy, 0).rg;
  tile_xy = ((ivec2(tile) * tile_size) + pixel_xy);
  color = texelFetch(albedo, tile_xy, 0);
  float absor = texelFetch(absorption, tile_xy, 0).r;
  color = apply_lighting(color, vec2(0), (1 - absor));
}
uniform float visibility = 1.0;

void _GLSLTK_main_2(){
  color *= visibility;
}

void _GLSLTK_main_3(){
  _GLSLTK_main_1();
  _GLSLTK_main_2();
}
uniform float gamma = 2.2;
uniform float exposure = 0.5;

void _GLSLTK_main_4(){
  vec3 mapped = (vec3(1.0) - exp((-color.rgb * exposure)));
  color.rgb = pow(mapped, vec3((1.0 / gamma)));
}

void _GLSLTK_main_5(){
  _GLSLTK_main_4();
}

void main(){
  _GLSLTK_main_3();
  _GLSLTK_main_5();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER VERTEX-SHADER {1008A69A93}>: 
#version 330 core
layout(location = 0) in vec3 vertex;
layout(location = 1) in vec2 vertex_uv;
uniform mat4 view_matrix;
uniform mat4 model_matrix;
uniform vec2 view_size;
out vec2 map_coord;

void _GLSLTK_main_1(){
  map_coord = (model_matrix * (view_matrix * vec4((vertex_uv * view_size), 0, 1))).xy;
  gl_Position = vec4(vertex, 1);
}

void _GLSLTK_main_2(){
  _GLSLTK_main_1();
}

void _GLSLTK_main_3(){
}

void main(){
  _GLSLTK_main_2();
  _GLSLTK_main_3();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Linked #<SHADER-PROGRAM {1006BEBDF3}> with (#<SHADER FRAGMENT-SHADER {1008C73BE3}>
                                            #<SHADER VERTEX-SHADER {1008A69A93}>).
2020-07-31 15:00:16 [INFO ] <TRIAL.SHADER-PASS>: Refreshing shader program for #<SHADER-ENTITY-CLASS LEAF::SWEEP>
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER FRAGMENT-SHADER {1008D15633}>: 
#version 330 core
out vec4 color;

void _GLSLTK_main_1(){
  color = vec4(1.0, 1.0, 1.0, 1.0);
}

void _GLSLTK_main_2(){
  color = vec4(0, 0, 0, 1);
}

void _GLSLTK_main_3(){
  _GLSLTK_main_1();
  _GLSLTK_main_2();
}
uniform float gamma = 2.2;
uniform float exposure = 0.5;

void _GLSLTK_main_4(){
  vec3 mapped = (vec3(1.0) - exp((-color.rgb * exposure)));
  color.rgb = pow(mapped, vec3((1.0 / gamma)));
}

void _GLSLTK_main_5(){
  _GLSLTK_main_4();
}

void main(){
  _GLSLTK_main_3();
  _GLSLTK_main_5();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER VERTEX-SHADER {1008CDD2C3}>: 
#version 330 core
layout(location = 0) in vec3 position;
uniform mat4 model_matrix;
uniform mat4 view_matrix;
uniform mat4 projection_matrix;

void _GLSLTK_main_1(){
  gl_Position = (projection_matrix * (view_matrix * (model_matrix * vec4(position, 1.0))));
}

void _GLSLTK_main_2(){
  _GLSLTK_main_1();
}

void _GLSLTK_main_3(){
}

void main(){
  _GLSLTK_main_2();
  _GLSLTK_main_3();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Linked #<SHADER-PROGRAM {1006BEBE53}> with (#<SHADER FRAGMENT-SHADER {1008D15633}>
                                            #<SHADER VERTEX-SHADER {1008CDD2C3}>).
2020-07-31 15:00:16 [INFO ] <TRIAL.SHADER-PASS>: Refreshing shader program for #<SHADER-ENTITY-CLASS TRIAL::LINES>
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER FRAGMENT-SHADER {1008FDC893}>: 
#version 330 core
out vec4 color;

void _GLSLTK_main_1(){
  color = vec4(1.0, 1.0, 1.0, 1.0);
}
in vec2 line_normal;
in vec4 line_color;
uniform float feather = 0.3;

void _GLSLTK_main_2(){
  color = (line_color * ((1 - length(line_normal)) / feather));
}

void _GLSLTK_main_3(){
  _GLSLTK_main_1();
  _GLSLTK_main_2();
}
uniform float gamma = 2.2;
uniform float exposure = 0.5;

void _GLSLTK_main_4(){
  vec3 mapped = (vec3(1.0) - exp((-color.rgb * exposure)));
  color.rgb = pow(mapped, vec3((1.0 / gamma)));
}

void _GLSLTK_main_5(){
  _GLSLTK_main_4();
}

void main(){
  _GLSLTK_main_3();
  _GLSLTK_main_5();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER VERTEX-SHADER {1008F486F3}>: 
#version 330 core
layout(location = 0) in vec3 position;
layout(location = 1) in vec3 direction;
layout(location = 2) in vec4 color;
out vec2 line_normal;
out vec4 line_color;
uniform float line_width = 3.0;
uniform vec2 view_size = vec2(800, 600);
uniform mat4 model_matrix;
uniform mat4 view_matrix;
uniform mat4 projection_matrix;

void _GLSLTK_main_1(){
  float aspect = (view_size.x / view_size.y);
  mat4 PVM = (projection_matrix * (view_matrix * model_matrix));
  vec4 screen1 = (PVM * vec4(position, 1));
  vec4 screen2 = (PVM * vec4((position + direction), 1));
  vec2 clip1 = (screen1.xy / max(0.00001, screen1.w));
  vec2 clip2 = (screen2.xy / max(0.00001, screen2.w));
  clip1.x *= aspect;
  clip2.x *= aspect;
  line_normal = normalize((clip2 - clip1));
  line_normal = vec2(-line_normal.y, line_normal.x);
  gl_Position = (screen1 + (screen1.w * vec4(((line_normal * line_width) / view_size), 0, 0)));
  line_color = color;
}

void _GLSLTK_main_2(){
  _GLSLTK_main_1();
}

void _GLSLTK_main_3(){
}

void main(){
  _GLSLTK_main_2();
  _GLSLTK_main_3();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Linked #<SHADER-PROGRAM {1006BEBEB3}> with (#<SHADER FRAGMENT-SHADER {1008FDC893}>
                                            #<SHADER VERTEX-SHADER {1008F486F3}>).
2020-07-31 15:00:16 [INFO ] <TRIAL.SHADER-PASS>: Refreshing shader program for #<SHADER-ENTITY-CLASS TRIAL:TEXT>
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER FRAGMENT-SHADER {1009083773}>: 
#version 330 core
out vec4 color;

void _GLSLTK_main_1(){
  color = vec4(1.0, 1.0, 1.0, 1.0);
}
uniform vec4 objectcolor;
uniform sampler2D texture_image;
in vec2 texcoord;

void _GLSLTK_main_2(){
  float intensity = texture(texture_image, texcoord, -0.65).r;
  color = (objectcolor * intensity);
}

void _GLSLTK_main_3(){
  _GLSLTK_main_1();
  _GLSLTK_main_2();
}
uniform float gamma = 2.2;
uniform float exposure = 0.5;

void _GLSLTK_main_4(){
  vec3 mapped = (vec3(1.0) - exp((-color.rgb * exposure)));
  color.rgb = pow(mapped, vec3((1.0 / gamma)));
}

void _GLSLTK_main_5(){
  _GLSLTK_main_4();
}

void main(){
  _GLSLTK_main_3();
  _GLSLTK_main_5();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER VERTEX-SHADER {1009048693}>: 
#version 330 core
layout(location = 1) in vec2 in_texcoord;
out vec2 texcoord;

void _GLSLTK_main_1(){
  texcoord = in_texcoord;
}
layout(location = 0) in vec3 position;
uniform mat4 model_matrix;
uniform mat4 view_matrix;
uniform mat4 projection_matrix;

void _GLSLTK_main_2(){
  gl_Position = (projection_matrix * (view_matrix * (model_matrix * vec4(position, 1.0))));
}

void _GLSLTK_main_3(){
  _GLSLTK_main_1();
  _GLSLTK_main_2();
}

void _GLSLTK_main_4(){
}

void main(){
  _GLSLTK_main_3();
  _GLSLTK_main_4();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Linked #<SHADER-PROGRAM {1006BEBF13}> with (#<SHADER FRAGMENT-SHADER {1009083773}>
                                            #<SHADER VERTEX-SHADER {1009048693}>).
2020-07-31 15:00:16 [INFO ] <TRIAL.SHADER-PASS>: Refreshing shader program for #<SHADER-ENTITY-CLASS TRIAL:SPRITE-ENTITY>
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER FRAGMENT-SHADER {1009126A13}>: 
#version 330 core
out vec4 color;

void _GLSLTK_main_1(){
  color = vec4(1.0, 1.0, 1.0, 1.0);
}
in vec2 texcoord;
uniform sampler2D texture_image;

void _GLSLTK_main_2(){
  color *= texture(texture_image, texcoord);
}

void _GLSLTK_main_3(){
  _GLSLTK_main_1();
  _GLSLTK_main_2();
}
uniform float gamma = 2.2;
uniform float exposure = 0.5;

void _GLSLTK_main_4(){
  vec3 mapped = (vec3(1.0) - exp((-color.rgb * exposure)));
  color.rgb = pow(mapped, vec3((1.0 / gamma)));
}

void _GLSLTK_main_5(){
  _GLSLTK_main_4();
}

void main(){
  _GLSLTK_main_3();
  _GLSLTK_main_5();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Compiled shader #<SHADER VERTEX-SHADER {10090EE9E3}>: 
#version 330 core
layout(location = 1) in vec2 in_texcoord;
out vec2 texcoord;

void _GLSLTK_main_1(){
  texcoord = in_texcoord;
}
layout(location = 0) in vec3 position;
uniform mat4 model_matrix;
uniform mat4 view_matrix;
uniform mat4 projection_matrix;

void _GLSLTK_main_2(){
  gl_Position = (projection_matrix * (view_matrix * (model_matrix * vec4(position, 1.0))));
}

void _GLSLTK_main_3(){
  _GLSLTK_main_1();
  _GLSLTK_main_2();
}

void _GLSLTK_main_4(){
}

void main(){
  _GLSLTK_main_3();
  _GLSLTK_main_4();
}
2020-07-31 15:00:16 [DEBUG] <TRIAL.ASSET>: Linked #<SHADER-PROGRAM {1006BEBF53}> with (#<SHADER FRAGMENT-SHADER {1009126A13}>
                                            #<SHADER VERTEX-SHADER {10090EE9E3}>).
2020-07-31 15:00:19 [DEBUG] <TRIAL.INPUT>: Mouse pressed: LEFT
2020-07-31 15:00:19 [DEBUG] <TRIAL.INPUT>: Mouse released: LEFT
2020-07-31 15:00:19 [DEBUG] <TRIAL.INPUT>: Key pressed: LEFT-SHIFT
2020-07-31 15:00:19 [SEVERE] <TRIAL.RENDER-LOOP>: Error in render thread There is no class named LEAF::DASH.
2020-07-31 15:00:19 [DEBUG] <TRIAL.RENDER-LOOP>: There is no class named LEAF::DASH.
   [Condition of type SB-PCL:CLASS-NOT-FOUND-ERROR]

#<ENVIRONMENT {100A30C173}>
   [Environment of thread #<THREAD "render-loop thread" RUNNING {10098C6FC3}>]

Available restarts:
 0: [ABORT] Don't handle #<TICK {100A21EBF3}> in #<PLAYER (VEC2 5101.677 -145.0) {1006F19103}>.
 1: [SKIP-EVENT] Skip handling the event entirely.
 2: [ABORT] Don't handle #<TICK {100A21EBF3}> in #<WORLD 14 units {1007C67FB3}>.
 3: [DISCARD-EVENTS] Discard all events.
 4: [RESET-RENDER-LOOP] Reset the render loop timing, not catching up with lost frames.
 5: [EXIT-RENDER-LOOP] Exit the render loop entirely.
 6: [ABORT] abort thread (#<THREAD "render-loop thread" RUNNING {10098C6FC3}>)

Backtrace:
 7: (SB-KERNEL::%SIGNAL There is no class named LEAF::DASH.)
 8: (ERROR CLASS-NOT-FOUND-ERROR NAME DASH)
 9: (SB-PCL::FIND-CLASS-FROM-CELL DASH NIL T)
 10: ((FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK :IN SB-PCL::INSTALL-OPTIMIZED-CONSTRUCTOR))
 11: ((FLET "WITHOUT-INTERRUPTS-BODY-11" :IN SB-THREAD::CALL-WITH-RECURSIVE-LOCK))
 12: (SB-THREAD::CALL-WITH-RECURSIVE-LOCK #<CLOSURE (FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK :IN SB-PCL::INSTALL-OPTIMIZED-CONSTRUCTOR) {E95EDFB}> #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "render-loop thread" RUNNING {10098C6FC3}>> T NIL)
 13: (SB-PCL::INSTALL-OPTIMIZED-CONSTRUCTOR #<CTOR LEAF::DASH ()>)
 14: ((LAMBDA (&REST SB-PCL::ARGS) :IN SB-PCL::INSTALL-INITIAL-CONSTRUCTOR))
 15: ((:METHOD TRIAL:HANDLE :BEFORE (FLARE:TICK LEAF::PLAYER)) #<TICK {100A21EBF3}> #<PLAYER (VEC2 5101.677 -145.0) {1006F19103}>)
 16: ((SB-PCL::EMF TRIAL:HANDLE) #<unused argument> #<unused argument> #<TICK {100A21EBF3}> #<PLAYER (VEC2 5101.677 -145.0) {1006F19103}>)
 17: ((:METHOD TRIAL:HANDLE :AROUND (TRIAL:EVENT T)) #<TICK {100A21EBF3}> #<PLAYER (VEC2 5101.677 -145.0) {1006F19103}>)
 18: ((:METHOD TRIAL:HANDLE (TRIAL:EVENT TRIAL:EVENT-LOOP)) #<TICK {100A21EBF3}> #<WORLD 14 units {1007C67FB3}>)
 19: ((SB-PCL::EMF TRIAL:HANDLE) #<unused argument> #<unused argument> #<TICK {100A21EBF3}> #<WORLD 14 units {1007C67FB3}>)
 20: ((:METHOD TRIAL:HANDLE :AROUND (TRIAL:EVENT T)) #<TICK {100A21EBF3}> #<WORLD 14 units {1007C67FB3}>)
 21: ((:METHOD TRIAL:PROCESS (TRIAL:EVENT-LOOP)) #<WORLD 14 units {1007C67FB3}>)
 22: ((:METHOD TRIAL:PROCESS :AROUND (TRIAL:SCENE)) #<WORLD 14 units {1007C67FB3}>)
 23: ((:METHOD TRIAL:RENDER-LOOP (TRIAL:RENDER-LOOP)) #<MAIN {100711FFE3}>)
 24: ((:METHOD TRIAL:RENDER-LOOP :AROUND (TRIAL:DISPLAY)) #<MAIN {100711FFE3}>)
 25: ((LAMBDA NIL :IN TRIAL:MAKE-THREAD))
 26: ((LABELS BORDEAUX-THREADS::%BINDING-DEFAULT-SPECIALS-WRAPPER :IN BORDEAUX-THREADS::BINDING-DEFAULT-SPECIALS))
 27: ((FLET SB-UNIX::BODY :IN SB-THREAD::NEW-LISP-THREAD-TRAMPOLINE))
 28: ((FLET "WITHOUT-INTERRUPTS-BODY-4" :IN SB-THREAD::NEW-LISP-THREAD-TRAMPOLINE))
 29: ((FLET SB-THREAD::WITH-MUTEX-THUNK :IN SB-THREAD::NEW-LISP-THREAD-TRAMPOLINE))
 30: ((FLET "WITHOUT-INTERRUPTS-BODY-1" :IN SB-THREAD::CALL-WITH-MUTEX))
 31: (SB-THREAD::CALL-WITH-MUTEX #<CLOSURE (FLET SB-THREAD::WITH-MUTEX-THUNK :IN SB-THREAD::NEW-LISP-THREAD-TRAMPOLINE) {E95FBEB}> #<MUTEX "thread result lock" owner: #<SB-THREAD:THREAD "render-loop thread" RUNNING {10098C6FC3}>> NIL T NIL)
 32: (SB-THREAD::NEW-LISP-THREAD-TRAMPOLINE #<THREAD "render-loop thread" RUNNING {10098C6FC3}> NIL #<CLOSURE (LABELS BORDEAUX-THREADS::%BINDING-DEFAULT-SPECIALS-WRAPPER :IN BORDEAUX-THREADS::BINDING-DEFAULT-SPECIALS) {10098C6F4B}> NIL)
 33: ("foreign function: #x42FBCB")
 34: ("foreign function: #x4042F8")
2020-07-31 15:00:19 [ERROR] <TRIAL>: There is no class named LEAF::DASH.
   [Condition of type SB-PCL:CLASS-NOT-FOUND-ERROR]

#<ENVIRONMENT {100A55A913}>
   [Environment of thread #<THREAD "render-loop thread" RUNNING {10098C6FC3}>]

Available restarts:
 0: [ABORT] Don't handle #<TICK {100A21EBF3}> in #<PLAYER (VEC2 5101.677 -145.0) {1006F19103}>.
 1: [SKIP-EVENT] Skip handling the event entirely.
 2: [ABORT] Don't handle #<TICK {100A21EBF3}> in #<WORLD 14 units {1007C67FB3}>.
 3: [DISCARD-EVENTS] Discard all events.
 4: [RESET-RENDER-LOOP] Reset the render loop timing, not catching up with lost frames.
 5: [EXIT-RENDER-LOOP] Exit the render loop entirely.
 6: [ABORT] abort thread (#<THREAD "render-loop thread" RUNNING {10098C6FC3}>)

Backtrace:
 7: (TRIAL:STANDALONE-ERROR-HANDLER There is no class named LEAF::DASH.)
 8: (SB-KERNEL::%SIGNAL There is no class named LEAF::DASH.)
 9: (ERROR CLASS-NOT-FOUND-ERROR NAME DASH)
 10: (SB-PCL::FIND-CLASS-FROM-CELL DASH NIL T)
 11: ((FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK :IN SB-PCL::INSTALL-OPTIMIZED-CONSTRUCTOR))
 12: ((FLET "WITHOUT-INTERRUPTS-BODY-11" :IN SB-THREAD::CALL-WITH-RECURSIVE-LOCK))
 13: (SB-THREAD::CALL-WITH-RECURSIVE-LOCK #<CLOSURE (FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK :IN SB-PCL::INSTALL-OPTIMIZED-CONSTRUCTOR) {E95EDFB}> #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "render-loop thread" RUNNING {10098C6FC3}>> T NIL)
 14: (SB-PCL::INSTALL-OPTIMIZED-CONSTRUCTOR #<CTOR LEAF::DASH ()>)
 15: ((LAMBDA (&REST SB-PCL::ARGS) :IN SB-PCL::INSTALL-INITIAL-CONSTRUCTOR))
 16: ((:METHOD TRIAL:HANDLE :BEFORE (FLARE:TICK LEAF::PLAYER)) #<TICK {100A21EBF3}> #<PLAYER (VEC2 5101.677 -145.0) {1006F19103}>)
 17: ((SB-PCL::EMF TRIAL:HANDLE) #<unused argument> #<unused argument> #<TICK {100A21EBF3}> #<PLAYER (VEC2 5101.677 -145.0) {1006F19103}>)
 18: ((:METHOD TRIAL:HANDLE :AROUND (TRIAL:EVENT T)) #<TICK {100A21EBF3}> #<PLAYER (VEC2 5101.677 -145.0) {1006F19103}>)
 19: ((:METHOD TRIAL:HANDLE (TRIAL:EVENT TRIAL:EVENT-LOOP)) #<TICK {100A21EBF3}> #<WORLD 14 units {1007C67FB3}>)
 20: ((SB-PCL::EMF TRIAL:HANDLE) #<unused argument> #<unused argument> #<TICK {100A21EBF3}> #<WORLD 14 units {1007C67FB3}>)
 21: ((:METHOD TRIAL:HANDLE :AROUND (TRIAL:EVENT T)) #<TICK {100A21EBF3}> #<WORLD 14 units {1007C67FB3}>)
 22: ((:METHOD TRIAL:PROCESS (TRIAL:EVENT-LOOP)) #<WORLD 14 units {1007C67FB3}>)
 23: ((:METHOD TRIAL:PROCESS :AROUND (TRIAL:SCENE)) #<WORLD 14 units {1007C67FB3}>)
 24: ((:METHOD TRIAL:RENDER-LOOP (TRIAL:RENDER-LOOP)) #<MAIN {100711FFE3}>)
 25: ((:METHOD TRIAL:RENDER-LOOP :AROUND (TRIAL:DISPLAY)) #<MAIN {100711FFE3}>)
 26: ((LAMBDA NIL :IN TRIAL:MAKE-THREAD))
 27: ((LABELS BORDEAUX-THREADS::%BINDING-DEFAULT-SPECIALS-WRAPPER :IN BORDEAUX-THREADS::BINDING-DEFAULT-SPECIALS))
 28: ((FLET SB-UNIX::BODY :IN SB-THREAD::NEW-LISP-THREAD-TRAMPOLINE))
 29: ((FLET "WITHOUT-INTERRUPTS-BODY-4" :IN SB-THREAD::NEW-LISP-THREAD-TRAMPOLINE))
 30: ((FLET SB-THREAD::WITH-MUTEX-THUNK :IN SB-THREAD::NEW-LISP-THREAD-TRAMPOLINE))
 31: ((FLET "WITHOUT-INTERRUPTS-BODY-1" :IN SB-THREAD::CALL-WITH-MUTEX))
 32: (SB-THREAD::CALL-WITH-MUTEX #<CLOSURE (FLET SB-THREAD::WITH-MUTEX-THUNK :IN SB-THREAD::NEW-LISP-THREAD-TRAMPOLINE) {E95FBEB}> #<MUTEX "thread result lock" owner: #<SB-THREAD:THREAD "render-loop thread" RUNNING {10098C6FC3}>> NIL T NIL)
 33: (SB-THREAD::NEW-LISP-THREAD-TRAMPOLINE #<THREAD "render-loop thread" RUNNING {10098C6FC3}> NIL #<CLOSURE (LABELS BORDEAUX-THREADS::%BINDING-DEFAULT-SPECIALS-WRAPPER :IN BORDEAUX-THREADS::BINDING-DEFAULT-SPECIALS) {10098C6F4B}> NIL)
 34: ("foreign function: #x42FBCB")
 35: ("foreign function: #x4042F8")
2020-07-31 15:00:19 [FATAL] <TRIAL>: Encountered unhandled error in #<THREAD "render-loop thread" RUNNING {10098C6FC3}>, bailing.
2020-07-31 15:00:19 [DEBUG] <TRIAL.INPUT>: Key released: LEFT-SHIFT