diff options
156 files changed, 2480 insertions, 2567 deletions
diff --git a/scripts/generate-shaders.js b/scripts/generate-shaders.js index 78d8911839..59544d0b34 100755 --- a/scripts/generate-shaders.js +++ b/scripts/generate-shaders.js @@ -3,7 +3,7 @@ require('flow-remove-types/register'); const path = require('path'); -const outputPath = 'src/mbgl/shaders'; +const outputPath = 'src/mbgl/programs/gl'; const zlib = require('zlib'); var shaders = require('../mapbox-gl-js/src/shaders'); @@ -31,52 +31,82 @@ for (const key in shaders) { concatenated += basicMinify(shaders[key].fragmentSource); concatenated += '\n\0'; - offsets[key] = {vertex, fragment}; + offsets[key] = { + vertex, + fragment, + originalKey: key, + shaderName: key.replace(/[A-Z]+/g, (match) => `_${match.toLowerCase()}`), + ShaderName: key.replace(/^[a-z]/g, (match) => match.toUpperCase()) + }; } +// Overrides: The symbolSDF shader is used for two underlying programs. +offsets.symbolSDFIcon = { + vertex: offsets.symbolSDF.vertex, + fragment: offsets.symbolSDF.fragment, + originalKey: 'symbolSDF', + shaderName: 'symbol_sdf_icon', + ShaderName: 'SymbolSDFIcon', +}; + +offsets.symbolSDFText = { + vertex: offsets.symbolSDF.vertex, + fragment: offsets.symbolSDF.fragment, + originalKey: 'symbolSDF', + shaderName: 'symbol_sdf_text', + ShaderName: 'SymbolSDFText', +}; + +delete offsets.symbolSDF; + const compressed = zlib.deflateSync(concatenated, {level: zlib.Z_BEST_COMPRESSION}) .toString('hex') - .match(/.{1,16}/g) + .match(/.{1,32}/g) .map(line => line.match(/.{1,2}/g).map(n => `0x${n}`).join(', ')) - .join(',\n ') + .join(',\n ') .trim(); function sourceOffset(key, type) { - return `source() + ${offsets[key][type]}` + return `programs::gl::shaderSource() + ${offsets[key][type]}` } -writeIfModified(path.join(outputPath, 'source.hpp'), `// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. +writeIfModified(path.join(outputPath, 'shader_source.hpp'), `// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. #pragma once namespace mbgl { -namespace shaders { +namespace programs { +namespace gl { -const char* source(); +const char* shaderSource(); -} // namespace shaders +} // namespace gl +} // namespace programs } // namespace mbgl `); -writeIfModified(path.join(outputPath, 'source.cpp'), `// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. +writeIfModified(path.join(outputPath, 'shader_source.cpp'), `// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. -#include <mbgl/shaders/source.hpp> +#include <mbgl/programs/gl/shader_source.hpp> #include <mbgl/util/compression.hpp> #include <cstdint> namespace mbgl { -namespace shaders { +namespace programs { +namespace gl { -const char* source() { - static const uint8_t compressed[] = { - ${compressed} - }; - static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed))); +constexpr const uint8_t compressedShaderSource[] = { + ${compressed} +}; + +const char* shaderSource() { + static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressedShaderSource), sizeof(compressedShaderSource))); return decompressed.c_str(); }; -} // namespace shaders +} // namespace gl +} // namespace programs } // namespace mbgl `); @@ -85,77 +115,69 @@ writeIfModified(path.join(outputPath, 'preludes.hpp'), `// NOTE: DO NOT CHANGE T #pragma once namespace mbgl { -namespace shaders { +namespace programs { +namespace gl { -extern const char* vertexPrelude; -extern const char* fragmentPrelude; +extern const char* vertexShaderPrelude; +extern const char* fragmentShaderPrelude; -} // namespace shaders +} // namespace gl +} // namespace programs } // namespace mbgl `); writeIfModified(path.join(outputPath, 'preludes.cpp'), `// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. -#include <mbgl/shaders/preludes.hpp> -#include <mbgl/shaders/source.hpp> +#include <mbgl/programs/gl/preludes.hpp> +#include <mbgl/programs/gl/shader_source.hpp> namespace mbgl { -namespace shaders { +namespace programs { +namespace gl { -const char* vertexPrelude = ${sourceOffset('prelude', 'vertex')}; -const char* fragmentPrelude = ${sourceOffset('prelude', 'fragment')}; +const char* vertexShaderPrelude = ${sourceOffset('prelude', 'vertex')}; +const char* fragmentShaderPrelude = ${sourceOffset('prelude', 'fragment')}; -} // namespace shaders +} // namespace gl +} // namespace programs } // namespace mbgl `); -for (const key in shaders) { +for (const key in offsets) { if (key === 'prelude') continue; - const shaderName = key.replace(/[A-Z]+/g, (match) => `_${match.toLowerCase()}`); - - writeIfModified(path.join(outputPath, `${shaderName}.hpp`), `// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. - -#pragma once - -namespace mbgl { -namespace shaders { - -class ${shaderName} { -public: - static const char* name; - static const char* vertexSource; - static const char* fragmentSource; -}; - -} // namespace shaders -} // namespace mbgl -`); + const { shaderName, ShaderName, originalKey } = offsets[key]; writeIfModified(path.join(outputPath, `${shaderName}.cpp`), `// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. -#include <mbgl/shaders/${shaderName}.hpp> -#include <mbgl/shaders/source.hpp> +#include <mbgl/programs/${shaderName}_program.hpp> +#include <mbgl/programs/gl/shader_source.hpp> +#include <mbgl/gl/program.hpp> namespace mbgl { -namespace shaders { +namespace gfx { + +template <> +std::unique_ptr<Program<${ShaderName}Program>> +Context::createProgram<gl::Context>(const ProgramParameters& programParameters) { + return gl::Program<${ShaderName}Program>::createProgram( + reinterpret_cast<gl::Context&>(*this), programParameters, "${shaderName}", + ${sourceOffset(key, 'vertex')}, ${sourceOffset(key, 'fragment')}); +} -const char* ${shaderName}::name = "${shaderName}"; -const char* ${shaderName}::vertexSource = ${sourceOffset(key, 'vertex')}; -const char* ${shaderName}::fragmentSource = ${sourceOffset(key, 'fragment')}; +} // namespace gfx +} // namespace mbgl // Uncompressed source of ${shaderName}.vertex.glsl: /* -${shaders[key].vertexSource} +${shaders[originalKey].vertexSource} */ // Uncompressed source of ${shaderName}.fragment.glsl: /* -${shaders[key].fragmentSource} +${shaders[originalKey].fragmentSource} */ -} // namespace shaders -} // namespace mbgl `); } diff --git a/src/core-files.json b/src/core-files.json index 6415f03182..272faaf9b6 100644 --- a/src/core-files.json +++ b/src/core-files.json @@ -16,7 +16,9 @@ "src/mbgl/geometry/dem_data.cpp", "src/mbgl/geometry/feature_index.cpp", "src/mbgl/geometry/line_atlas.cpp", + "src/mbgl/gfx/attribute.cpp", "src/mbgl/gl/attribute.cpp", + "src/mbgl/gl/binary_program.cpp", "src/mbgl/gl/context.cpp", "src/mbgl/gl/debugging.cpp", "src/mbgl/gl/debugging_extension.cpp", @@ -51,12 +53,42 @@ "src/mbgl/math/log2.cpp", "src/mbgl/platform/gl_functions.cpp", "src/mbgl/programs/background_program.cpp", - "src/mbgl/programs/binary_program.cpp", "src/mbgl/programs/circle_program.cpp", + "src/mbgl/programs/clipping_mask_program.cpp", "src/mbgl/programs/collision_box_program.cpp", + "src/mbgl/programs/debug_program.cpp", "src/mbgl/programs/extrusion_texture_program.cpp", "src/mbgl/programs/fill_extrusion_program.cpp", "src/mbgl/programs/fill_program.cpp", + "src/mbgl/programs/gl/background.cpp", + "src/mbgl/programs/gl/background_pattern.cpp", + "src/mbgl/programs/gl/circle.cpp", + "src/mbgl/programs/gl/clipping_mask.cpp", + "src/mbgl/programs/gl/collision_box.cpp", + "src/mbgl/programs/gl/collision_circle.cpp", + "src/mbgl/programs/gl/debug.cpp", + "src/mbgl/programs/gl/extrusion_texture.cpp", + "src/mbgl/programs/gl/fill.cpp", + "src/mbgl/programs/gl/fill_extrusion.cpp", + "src/mbgl/programs/gl/fill_extrusion_pattern.cpp", + "src/mbgl/programs/gl/fill_outline.cpp", + "src/mbgl/programs/gl/fill_outline_pattern.cpp", + "src/mbgl/programs/gl/fill_pattern.cpp", + "src/mbgl/programs/gl/heatmap.cpp", + "src/mbgl/programs/gl/heatmap_texture.cpp", + "src/mbgl/programs/gl/hillshade.cpp", + "src/mbgl/programs/gl/hillshade_prepare.cpp", + "src/mbgl/programs/gl/line.cpp", + "src/mbgl/programs/gl/line_gradient.cpp", + "src/mbgl/programs/gl/line_pattern.cpp", + "src/mbgl/programs/gl/line_sdf.cpp", + "src/mbgl/programs/gl/preludes.cpp", + "src/mbgl/programs/gl/raster.cpp", + "src/mbgl/programs/gl/shader_source.cpp", + "src/mbgl/programs/gl/shaders.cpp", + "src/mbgl/programs/gl/symbol_icon.cpp", + "src/mbgl/programs/gl/symbol_sdf_icon.cpp", + "src/mbgl/programs/gl/symbol_sdf_text.cpp", "src/mbgl/programs/heatmap_program.cpp", "src/mbgl/programs/heatmap_texture_program.cpp", "src/mbgl/programs/hillshade_prepare_program.cpp", @@ -109,34 +141,6 @@ "src/mbgl/renderer/sources/render_vector_source.cpp", "src/mbgl/renderer/style_diff.cpp", "src/mbgl/renderer/tile_pyramid.cpp", - "src/mbgl/shaders/background.cpp", - "src/mbgl/shaders/background_pattern.cpp", - "src/mbgl/shaders/circle.cpp", - "src/mbgl/shaders/clipping_mask.cpp", - "src/mbgl/shaders/collision_box.cpp", - "src/mbgl/shaders/collision_circle.cpp", - "src/mbgl/shaders/debug.cpp", - "src/mbgl/shaders/extrusion_texture.cpp", - "src/mbgl/shaders/fill.cpp", - "src/mbgl/shaders/fill_extrusion.cpp", - "src/mbgl/shaders/fill_extrusion_pattern.cpp", - "src/mbgl/shaders/fill_outline.cpp", - "src/mbgl/shaders/fill_outline_pattern.cpp", - "src/mbgl/shaders/fill_pattern.cpp", - "src/mbgl/shaders/heatmap.cpp", - "src/mbgl/shaders/heatmap_texture.cpp", - "src/mbgl/shaders/hillshade.cpp", - "src/mbgl/shaders/hillshade_prepare.cpp", - "src/mbgl/shaders/line.cpp", - "src/mbgl/shaders/line_gradient.cpp", - "src/mbgl/shaders/line_pattern.cpp", - "src/mbgl/shaders/line_sdf.cpp", - "src/mbgl/shaders/preludes.cpp", - "src/mbgl/shaders/raster.cpp", - "src/mbgl/shaders/shaders.cpp", - "src/mbgl/shaders/source.cpp", - "src/mbgl/shaders/symbol_icon.cpp", - "src/mbgl/shaders/symbol_sdf.cpp", "src/mbgl/sprite/sprite_loader.cpp", "src/mbgl/sprite/sprite_loader_worker.cpp", "src/mbgl/sprite/sprite_parser.cpp", @@ -505,12 +509,14 @@ "mbgl/gfx/attribute.hpp": "src/mbgl/gfx/attribute.hpp", "mbgl/gfx/color_mode.hpp": "src/mbgl/gfx/color_mode.hpp", "mbgl/gfx/context.hpp": "src/mbgl/gfx/context.hpp", + "mbgl/gfx/context_impl.hpp": "src/mbgl/gfx/context_impl.hpp", "mbgl/gfx/cull_face_mode.hpp": "src/mbgl/gfx/cull_face_mode.hpp", "mbgl/gfx/depth_mode.hpp": "src/mbgl/gfx/depth_mode.hpp", "mbgl/gfx/draw_mode.hpp": "src/mbgl/gfx/draw_mode.hpp", + "mbgl/gfx/draw_scope.hpp": "src/mbgl/gfx/draw_scope.hpp", "mbgl/gfx/index_buffer.hpp": "src/mbgl/gfx/index_buffer.hpp", "mbgl/gfx/index_vector.hpp": "src/mbgl/gfx/index_vector.hpp", - "mbgl/gfx/primitives.hpp": "src/mbgl/gfx/primitives.hpp", + "mbgl/gfx/program.hpp": "src/mbgl/gfx/program.hpp", "mbgl/gfx/stencil_mode.hpp": "src/mbgl/gfx/stencil_mode.hpp", "mbgl/gfx/texture.hpp": "src/mbgl/gfx/texture.hpp", "mbgl/gfx/types.hpp": "src/mbgl/gfx/types.hpp", @@ -518,10 +524,12 @@ "mbgl/gfx/vertex_buffer.hpp": "src/mbgl/gfx/vertex_buffer.hpp", "mbgl/gfx/vertex_vector.hpp": "src/mbgl/gfx/vertex_vector.hpp", "mbgl/gl/attribute.hpp": "src/mbgl/gl/attribute.hpp", + "mbgl/gl/binary_program.hpp": "src/mbgl/gl/binary_program.hpp", "mbgl/gl/context.hpp": "src/mbgl/gl/context.hpp", "mbgl/gl/debugging.hpp": "src/mbgl/gl/debugging.hpp", "mbgl/gl/debugging_extension.hpp": "src/mbgl/gl/debugging_extension.hpp", "mbgl/gl/defines.hpp": "src/mbgl/gl/defines.hpp", + "mbgl/gl/draw_scope_resource.hpp": "src/mbgl/gl/draw_scope_resource.hpp", "mbgl/gl/enum.hpp": "src/mbgl/gl/enum.hpp", "mbgl/gl/extension.hpp": "src/mbgl/gl/extension.hpp", "mbgl/gl/features.hpp": "src/mbgl/gl/features.hpp", @@ -553,26 +561,40 @@ "mbgl/map/transform_state.hpp": "src/mbgl/map/transform_state.hpp", "mbgl/map/zoom_history.hpp": "src/mbgl/map/zoom_history.hpp", "mbgl/programs/attributes.hpp": "src/mbgl/programs/attributes.hpp", + "mbgl/programs/background_pattern_program.hpp": "src/mbgl/programs/background_pattern_program.hpp", "mbgl/programs/background_program.hpp": "src/mbgl/programs/background_program.hpp", - "mbgl/programs/binary_program.hpp": "src/mbgl/programs/binary_program.hpp", "mbgl/programs/circle_program.hpp": "src/mbgl/programs/circle_program.hpp", "mbgl/programs/clipping_mask_program.hpp": "src/mbgl/programs/clipping_mask_program.hpp", "mbgl/programs/collision_box_program.hpp": "src/mbgl/programs/collision_box_program.hpp", + "mbgl/programs/collision_circle_program.hpp": "src/mbgl/programs/collision_circle_program.hpp", "mbgl/programs/debug_program.hpp": "src/mbgl/programs/debug_program.hpp", "mbgl/programs/extrusion_texture_program.hpp": "src/mbgl/programs/extrusion_texture_program.hpp", + "mbgl/programs/fill_extrusion_pattern_program.hpp": "src/mbgl/programs/fill_extrusion_pattern_program.hpp", "mbgl/programs/fill_extrusion_program.hpp": "src/mbgl/programs/fill_extrusion_program.hpp", + "mbgl/programs/fill_outline_pattern_program.hpp": "src/mbgl/programs/fill_outline_pattern_program.hpp", + "mbgl/programs/fill_outline_program.hpp": "src/mbgl/programs/fill_outline_program.hpp", + "mbgl/programs/fill_pattern_program.hpp": "src/mbgl/programs/fill_pattern_program.hpp", "mbgl/programs/fill_program.hpp": "src/mbgl/programs/fill_program.hpp", + "mbgl/programs/gl/preludes.hpp": "src/mbgl/programs/gl/preludes.hpp", + "mbgl/programs/gl/shader_source.hpp": "src/mbgl/programs/gl/shader_source.hpp", + "mbgl/programs/gl/shaders.hpp": "src/mbgl/programs/gl/shaders.hpp", "mbgl/programs/heatmap_program.hpp": "src/mbgl/programs/heatmap_program.hpp", "mbgl/programs/heatmap_texture_program.hpp": "src/mbgl/programs/heatmap_texture_program.hpp", "mbgl/programs/hillshade_prepare_program.hpp": "src/mbgl/programs/hillshade_prepare_program.hpp", "mbgl/programs/hillshade_program.hpp": "src/mbgl/programs/hillshade_program.hpp", + "mbgl/programs/line_gradient_program.hpp": "src/mbgl/programs/line_gradient_program.hpp", + "mbgl/programs/line_pattern_program.hpp": "src/mbgl/programs/line_pattern_program.hpp", "mbgl/programs/line_program.hpp": "src/mbgl/programs/line_program.hpp", + "mbgl/programs/line_sdf_program.hpp": "src/mbgl/programs/line_sdf_program.hpp", "mbgl/programs/program.hpp": "src/mbgl/programs/program.hpp", "mbgl/programs/program_parameters.hpp": "src/mbgl/programs/program_parameters.hpp", "mbgl/programs/programs.hpp": "src/mbgl/programs/programs.hpp", "mbgl/programs/raster_program.hpp": "src/mbgl/programs/raster_program.hpp", "mbgl/programs/segment.hpp": "src/mbgl/programs/segment.hpp", + "mbgl/programs/symbol_icon_program.hpp": "src/mbgl/programs/symbol_icon_program.hpp", "mbgl/programs/symbol_program.hpp": "src/mbgl/programs/symbol_program.hpp", + "mbgl/programs/symbol_sdf_icon_program.hpp": "src/mbgl/programs/symbol_sdf_icon_program.hpp", + "mbgl/programs/symbol_sdf_text_program.hpp": "src/mbgl/programs/symbol_sdf_text_program.hpp", "mbgl/programs/textures.hpp": "src/mbgl/programs/textures.hpp", "mbgl/programs/uniforms.hpp": "src/mbgl/programs/uniforms.hpp", "mbgl/renderer/bucket.hpp": "src/mbgl/renderer/bucket.hpp", @@ -628,34 +650,6 @@ "mbgl/renderer/tile_pyramid.hpp": "src/mbgl/renderer/tile_pyramid.hpp", "mbgl/renderer/transition_parameters.hpp": "src/mbgl/renderer/transition_parameters.hpp", "mbgl/renderer/update_parameters.hpp": "src/mbgl/renderer/update_parameters.hpp", - "mbgl/shaders/background.hpp": "src/mbgl/shaders/background.hpp", - "mbgl/shaders/background_pattern.hpp": "src/mbgl/shaders/background_pattern.hpp", - "mbgl/shaders/circle.hpp": "src/mbgl/shaders/circle.hpp", - "mbgl/shaders/clipping_mask.hpp": "src/mbgl/shaders/clipping_mask.hpp", - "mbgl/shaders/collision_box.hpp": "src/mbgl/shaders/collision_box.hpp", - "mbgl/shaders/collision_circle.hpp": "src/mbgl/shaders/collision_circle.hpp", - "mbgl/shaders/debug.hpp": "src/mbgl/shaders/debug.hpp", - "mbgl/shaders/extrusion_texture.hpp": "src/mbgl/shaders/extrusion_texture.hpp", - "mbgl/shaders/fill.hpp": "src/mbgl/shaders/fill.hpp", - "mbgl/shaders/fill_extrusion.hpp": "src/mbgl/shaders/fill_extrusion.hpp", - "mbgl/shaders/fill_extrusion_pattern.hpp": "src/mbgl/shaders/fill_extrusion_pattern.hpp", - "mbgl/shaders/fill_outline.hpp": "src/mbgl/shaders/fill_outline.hpp", - "mbgl/shaders/fill_outline_pattern.hpp": "src/mbgl/shaders/fill_outline_pattern.hpp", - "mbgl/shaders/fill_pattern.hpp": "src/mbgl/shaders/fill_pattern.hpp", - "mbgl/shaders/heatmap.hpp": "src/mbgl/shaders/heatmap.hpp", - "mbgl/shaders/heatmap_texture.hpp": "src/mbgl/shaders/heatmap_texture.hpp", - "mbgl/shaders/hillshade.hpp": "src/mbgl/shaders/hillshade.hpp", - "mbgl/shaders/hillshade_prepare.hpp": "src/mbgl/shaders/hillshade_prepare.hpp", - "mbgl/shaders/line.hpp": "src/mbgl/shaders/line.hpp", - "mbgl/shaders/line_gradient.hpp": "src/mbgl/shaders/line_gradient.hpp", - "mbgl/shaders/line_pattern.hpp": "src/mbgl/shaders/line_pattern.hpp", - "mbgl/shaders/line_sdf.hpp": "src/mbgl/shaders/line_sdf.hpp", - "mbgl/shaders/preludes.hpp": "src/mbgl/shaders/preludes.hpp", - "mbgl/shaders/raster.hpp": "src/mbgl/shaders/raster.hpp", - "mbgl/shaders/shaders.hpp": "src/mbgl/shaders/shaders.hpp", - "mbgl/shaders/source.hpp": "src/mbgl/shaders/source.hpp", - "mbgl/shaders/symbol_icon.hpp": "src/mbgl/shaders/symbol_icon.hpp", - "mbgl/shaders/symbol_sdf.hpp": "src/mbgl/shaders/symbol_sdf.hpp", "mbgl/sprite/sprite_loader.hpp": "src/mbgl/sprite/sprite_loader.hpp", "mbgl/sprite/sprite_loader_observer.hpp": "src/mbgl/sprite/sprite_loader_observer.hpp", "mbgl/sprite/sprite_loader_worker.hpp": "src/mbgl/sprite/sprite_loader_worker.hpp", diff --git a/src/mbgl/gfx/attribute.cpp b/src/mbgl/gfx/attribute.cpp new file mode 100644 index 0000000000..ed5d4032f4 --- /dev/null +++ b/src/mbgl/gfx/attribute.cpp @@ -0,0 +1,21 @@ +#include <mbgl/gfx/attribute.hpp> + +#include <limits> +#include <cassert> + +namespace mbgl { +namespace gfx { + +optional<AttributeBinding> offsetAttributeBinding(const optional<AttributeBinding>& binding, std::size_t vertexOffset) { + assert(vertexOffset <= std::numeric_limits<uint32_t>::max()); + if (binding) { + AttributeBinding result = *binding; + result.vertexOffset = static_cast<uint32_t>(vertexOffset); + return result; + } else { + return binding; + } +} + +} // namespace gfx +} // namespace mbgl diff --git a/src/mbgl/gfx/attribute.hpp b/src/mbgl/gfx/attribute.hpp index 0dce6b2a06..4f44d68d7b 100644 --- a/src/mbgl/gfx/attribute.hpp +++ b/src/mbgl/gfx/attribute.hpp @@ -1,8 +1,11 @@ #pragma once #include <mbgl/gfx/types.hpp> +#include <mbgl/gfx/vertex_buffer.hpp> #include <mbgl/util/type_list.hpp> #include <mbgl/util/indexed_tuple.hpp> +#include <mbgl/util/ignore.hpp> +#include <mbgl/util/optional.hpp> #include <array> #include <type_traits> @@ -79,6 +82,21 @@ struct VertexDescriptor { AttributeDescriptor attributes[5]; }; +class AttributeBinding { +public: + AttributeDescriptor attribute; + uint8_t vertexStride; + const VertexBufferResource* vertexBufferResource; + uint32_t vertexOffset; + + friend bool operator==(const AttributeBinding& lhs, const AttributeBinding& rhs) { + return lhs.attribute == rhs.attribute && + lhs.vertexStride == rhs.vertexStride && + lhs.vertexBufferResource == rhs.vertexBufferResource && + lhs.vertexOffset == rhs.vertexOffset; + } +}; + // Attribute binding requires member offsets. The only standard way to // obtain an offset is the offsetof macro. The offsetof macro has defined // behavior only for standard layout types. That rules out std::tuple and @@ -89,32 +107,32 @@ struct VertexDescriptor { namespace detail { template <class...> -struct Vertex; +struct VertexType; template <class A1> -struct Vertex<A1> { - using Type = Vertex<A1>; +struct VertexType<A1> { + using Type = VertexType<A1>; typename A1::Value a1; } MBGL_VERTEX_ALIGN; template <class A1, class A2> -struct Vertex<A1, A2> { - using Type = Vertex<A1, A2>; +struct VertexType<A1, A2> { + using Type = VertexType<A1, A2>; typename A1::Value a1; typename A2::Value a2; } MBGL_VERTEX_ALIGN; template <class A1, class A2, class A3> -struct Vertex<A1, A2, A3> { - using Type = Vertex<A1, A2, A3>; +struct VertexType<A1, A2, A3> { + using Type = VertexType<A1, A2, A3>; typename A1::Value a1; typename A2::Value a2; typename A3::Value a3; } MBGL_VERTEX_ALIGN; template <class A1, class A2, class A3, class A4> -struct Vertex<A1, A2, A3, A4> { - using Type = Vertex<A1, A2, A3, A4>; +struct VertexType<A1, A2, A3, A4> { + using Type = VertexType<A1, A2, A3, A4>; typename A1::Value a1; typename A2::Value a2; typename A3::Value a3; @@ -122,8 +140,8 @@ struct Vertex<A1, A2, A3, A4> { } MBGL_VERTEX_ALIGN; template <class A1, class A2, class A3, class A4, class A5> -struct Vertex<A1, A2, A3, A4, A5> { - using Type = Vertex<A1, A2, A3, A4, A5>; +struct VertexType<A1, A2, A3, A4, A5> { + using Type = VertexType<A1, A2, A3, A4, A5>; typename A1::Value a1; typename A2::Value a2; typename A3::Value a3; @@ -135,8 +153,8 @@ template <class> struct Descriptor; template <class A1> -struct Descriptor<Vertex<A1>> { - using Type = Vertex<A1>; +struct Descriptor<VertexType<A1>> { + using Type = VertexType<A1>; static_assert(sizeof(Type) < 256, "vertex type must be smaller than 256 bytes"); static_assert(std::is_standard_layout<Type>::value, "vertex type must use standard layout"); static constexpr const VertexDescriptor data = { sizeof(Type), 1, { @@ -145,11 +163,11 @@ struct Descriptor<Vertex<A1>> { }; template <class A1> -constexpr const VertexDescriptor Descriptor<Vertex<A1>>::data; +constexpr const VertexDescriptor Descriptor<VertexType<A1>>::data; template <class A1, class A2> -struct Descriptor<Vertex<A1, A2>> { - using Type = Vertex<A1, A2>; +struct Descriptor<VertexType<A1, A2>> { + using Type = VertexType<A1, A2>; static_assert(sizeof(Type) < 256, "vertex type must be smaller than 256 bytes"); static_assert(std::is_standard_layout<Type>::value, "vertex type must use standard layout"); static constexpr const VertexDescriptor data = { sizeof(Type), 2, { @@ -159,11 +177,11 @@ struct Descriptor<Vertex<A1, A2>> { }; template <class A1, class A2> -constexpr const VertexDescriptor Descriptor<Vertex<A1, A2>>::data; +constexpr const VertexDescriptor Descriptor<VertexType<A1, A2>>::data; template <class A1, class A2, class A3> -struct Descriptor<Vertex<A1, A2, A3>> { - using Type = Vertex<A1, A2, A3>; +struct Descriptor<VertexType<A1, A2, A3>> { + using Type = VertexType<A1, A2, A3>; static_assert(sizeof(Type) < 256, "vertex type must be smaller than 256 bytes"); static_assert(std::is_standard_layout<Type>::value, "vertex type must use standard layout"); static constexpr const VertexDescriptor data = { sizeof(Type), 3, { @@ -174,11 +192,11 @@ struct Descriptor<Vertex<A1, A2, A3>> { }; template <class A1, class A2, class A3> -constexpr const VertexDescriptor Descriptor<Vertex<A1, A2, A3>>::data; +constexpr const VertexDescriptor Descriptor<VertexType<A1, A2, A3>>::data; template <class A1, class A2, class A3, class A4> -struct Descriptor<Vertex<A1, A2, A3, A4>> { - using Type = Vertex<A1, A2, A3, A4>; +struct Descriptor<VertexType<A1, A2, A3, A4>> { + using Type = VertexType<A1, A2, A3, A4>; static_assert(sizeof(Type) < 256, "vertex type must be smaller than 256 bytes"); static_assert(std::is_standard_layout<Type>::value, "vertex type must use standard layout"); static constexpr const VertexDescriptor data = { sizeof(Type), 4, { @@ -190,11 +208,11 @@ struct Descriptor<Vertex<A1, A2, A3, A4>> { }; template <class A1, class A2, class A3, class A4> -constexpr const VertexDescriptor Descriptor<Vertex<A1, A2, A3, A4>>::data; +constexpr const VertexDescriptor Descriptor<VertexType<A1, A2, A3, A4>>::data; template <class A1, class A2, class A3, class A4, class A5> -struct Descriptor<Vertex<A1, A2, A3, A4, A5>> { - using Type = Vertex<A1, A2, A3, A4, A5>; +struct Descriptor<VertexType<A1, A2, A3, A4, A5>> { + using Type = VertexType<A1, A2, A3, A4, A5>; static_assert(sizeof(Type) < 256, "vertex type must be smaller than 256 bytes"); static_assert(std::is_standard_layout<Type>::value, "vertex type must use standard layout"); static constexpr const VertexDescriptor data = { sizeof(Type), 5, { @@ -207,11 +225,14 @@ struct Descriptor<Vertex<A1, A2, A3, A4, A5>> { }; template <class A1, class A2, class A3, class A4, class A5> -constexpr const VertexDescriptor Descriptor<Vertex<A1, A2, A3, A4, A5>>::data; +constexpr const VertexDescriptor Descriptor<VertexType<A1, A2, A3, A4, A5>>::data; + +template <class> +struct Vertex; template <class... As> struct Vertex<TypeList<As...>> { - using Type = Vertex<typename As::Type...>; + using Type = VertexType<typename As::Type...>; }; } // namespace detail @@ -219,8 +240,52 @@ struct Vertex<TypeList<As...>> { template <class A> using Vertex = typename detail::Vertex<A>::Type; -template <class V> -using VertexDescriptorOf = detail::Descriptor<V>; +template <class T> +using VertexType = typename detail::VertexType<T>; + +template <size_t I = 0, class... As> +AttributeBinding attributeBinding(const VertexBuffer<detail::VertexType<As...>>& buffer) { + using Descriptor = detail::Descriptor<detail::VertexType<As...>>; + static_assert(I < Descriptor::data.count, "attribute index must be in range"); + return { + Descriptor::data.attributes[I], + Descriptor::data.stride, + buffer.resource.get(), + 0, + }; +} + +optional<gfx::AttributeBinding> offsetAttributeBinding(const optional<gfx::AttributeBinding>& binding, std::size_t vertexOffset); + +template <class> +class AttributeBindings; + +template <class... As> +class AttributeBindings<TypeList<As...>> final + : public IndexedTuple<TypeList<As...>, + TypeList<ExpandToType<As, optional<AttributeBinding>>...>> { + using Base = IndexedTuple<TypeList<As...>, + TypeList<ExpandToType<As, optional<AttributeBinding>>...>>; + +public: + AttributeBindings(const VertexBuffer<Vertex<TypeList<As...>>>& buffer) + : Base{ attributeBinding<TypeIndex<As, As...>::value>(buffer)... } { + } + + template <class... Args> + AttributeBindings(Args&&... args) : Base(std::forward<Args>(args)...) { + } + + AttributeBindings offset(const std::size_t vertexOffset) const { + return { offsetAttributeBinding(Base::template get<As>(), vertexOffset)... }; + } + + uint32_t activeCount() const { + uint32_t result = 0; + util::ignore({ ((result += bool(Base::template get<As>())), 0)... }); + return result; + } +}; } // namespace gfx } // namespace mbgl diff --git a/src/mbgl/gfx/context.hpp b/src/mbgl/gfx/context.hpp index 5ec73b8a41..90b62c94a4 100644 --- a/src/mbgl/gfx/context.hpp +++ b/src/mbgl/gfx/context.hpp @@ -5,14 +5,22 @@ #include <mbgl/gfx/index_vector.hpp> #include <mbgl/gfx/index_buffer.hpp> #include <mbgl/gfx/texture.hpp> +#include <mbgl/gfx/draw_scope.hpp> +#include <mbgl/gfx/program.hpp> #include <mbgl/gfx/types.hpp> namespace mbgl { + +class ProgramParameters; + namespace gfx { class Context { protected: - Context() = default; + Context(ContextType type_) : backend(type_) { + } + + const ContextType backend; public: Context(Context&&) = delete; @@ -89,6 +97,22 @@ protected: Size, const void* data, TexturePixelType, TextureChannelDataType) = 0; virtual void updateTextureResource(const TextureResource&, Size, const void* data, TexturePixelType, TextureChannelDataType) = 0; + +public: + DrawScope createDrawScope() { + return { createDrawScopeResource() }; + } + +protected: + virtual std::unique_ptr<DrawScopeResource> createDrawScopeResource() = 0; + +public: + template <typename Name> + std::unique_ptr<Program<Name>> createProgram(const ProgramParameters&); + +private: + template <typename Backend, typename Name> + std::unique_ptr<Program<Name>> createProgram(const ProgramParameters&); }; } // namespace gfx diff --git a/src/mbgl/gfx/context_impl.hpp b/src/mbgl/gfx/context_impl.hpp new file mode 100644 index 0000000000..0145535bb3 --- /dev/null +++ b/src/mbgl/gfx/context_impl.hpp @@ -0,0 +1,23 @@ +#pragma once + +#include <mbgl/gfx/context.hpp> + +namespace mbgl { + +namespace gl { +class Context; +} // namespace gl + +namespace gfx { + +template <typename Name> +std::unique_ptr<Program<Name>> Context::createProgram(const ProgramParameters& programParameters) { + if (backend == ContextType::OpenGL) { + return createProgram<gl::Context, Name>(programParameters); + } + assert(false); + return nullptr; +} + +} // namespace gfx +} // namespace mbgl diff --git a/src/mbgl/gfx/draw_mode.hpp b/src/mbgl/gfx/draw_mode.hpp index a0a9b6c575..e18a38903e 100644 --- a/src/mbgl/gfx/draw_mode.hpp +++ b/src/mbgl/gfx/draw_mode.hpp @@ -1,72 +1,77 @@ #pragma once #include <mbgl/gfx/types.hpp> -#include <mbgl/gfx/primitives.hpp> #include <cassert> namespace mbgl { namespace gfx { -class Points { -public: - using Primitive = Point; - - static constexpr std::size_t bufferGroupSize = 1; - static constexpr PrimitiveType primitiveType = PrimitiveType::Points; - - explicit Points(float pointSize_) : pointSize(pointSize_) {} - - float pointSize; -}; +class DrawMode { +protected: + DrawMode(DrawModeType type_, float size_) + : type(type_), size(size_) { + } -class Lines { public: - using Primitive = Line; + const DrawModeType type; + const float size; +}; - static constexpr std::size_t bufferGroupSize = 2; - static constexpr PrimitiveType primitiveType = PrimitiveType::Lines; +template <class> struct BufferGroupSizeOf; +template <class> struct PrimitiveTypeOf; - explicit Lines(float lineWidth_) : lineWidth(lineWidth_) { - assert(lineWidth > 0); +class Points : public DrawMode { +public: + explicit Points(float pointSize_) : DrawMode(DrawModeType::Points, pointSize_) { + assert(size > 0); } - - float lineWidth; }; -class LineStrip { +template <> struct BufferGroupSizeOf<Points> : std::integral_constant<std::size_t, 1> {}; +template <> struct PrimitiveTypeOf<Points> : std::integral_constant<PrimitiveType, PrimitiveType::Point> {}; + +class Lines : public DrawMode { public: - // LineStrip is a form of "Line" rendering, but the element buffer - // cannot be grouped into logical elements beyond a single Point. - using Primitive = Line; + explicit Lines(float lineWidth_) : DrawMode(DrawModeType::Lines, lineWidth_) { + assert(size > 0); + } +}; - static constexpr std::size_t bufferGroupSize = 1; - static constexpr PrimitiveType primitiveType = PrimitiveType::LineStrip; +template <> struct BufferGroupSizeOf<Lines> : std::integral_constant<std::size_t, 2> {}; +template <> struct PrimitiveTypeOf<Lines> : std::integral_constant<PrimitiveType, PrimitiveType::Line> {}; - explicit LineStrip(float lineWidth_) : lineWidth(lineWidth_) { - assert(lineWidth > 0); +// LineStrip is a form of "Line" rendering, but the element buffer +// cannot be grouped into logical elements beyond a single Point. +class LineStrip : public DrawMode { +public: + explicit LineStrip(float lineWidth_) : DrawMode(DrawModeType::LineStrip, lineWidth_) { + assert(size > 0); } - - float lineWidth; }; -class Triangles { -public: - using Primitive = Triangle; +template <> struct BufferGroupSizeOf<LineStrip> : std::integral_constant<std::size_t, 1> {}; +template <> struct PrimitiveTypeOf<LineStrip> : std::integral_constant<PrimitiveType, PrimitiveType::Line> {}; - static constexpr std::size_t bufferGroupSize = 3; - static constexpr PrimitiveType primitiveType = PrimitiveType::Triangles; +class Triangles : public DrawMode { +public: + explicit Triangles() : DrawMode(DrawModeType::Triangles, 0) { + } }; -class TriangleStrip { -public: - // TriangleStrip is a form of "Triangle" rendering, but the element buffer - // cannot be grouped into logical elements beyond a single Point. - using Primitive = Triangle; +template <> struct BufferGroupSizeOf<Triangles> : std::integral_constant<std::size_t, 3> {}; +template <> struct PrimitiveTypeOf<Triangles> : std::integral_constant<PrimitiveType, PrimitiveType::Triangle> {}; - static constexpr std::size_t bufferGroupSize = 1; - static constexpr PrimitiveType primitiveType = PrimitiveType::TriangleStrip; +// TriangleStrip is a form of "Triangle" rendering, but the element buffer +// cannot be grouped into logical elements beyond a single Point. +class TriangleStrip : public DrawMode { +public: + explicit TriangleStrip() : DrawMode(DrawModeType::TriangleStrip, 0) { + } }; +template <> struct BufferGroupSizeOf<TriangleStrip> : std::integral_constant<std::size_t, 1> {}; +template <> struct PrimitiveTypeOf<TriangleStrip> : std::integral_constant<PrimitiveType, PrimitiveType::Triangle> {}; + } // namespace gfx } // namespace mbgl diff --git a/src/mbgl/gfx/draw_scope.hpp b/src/mbgl/gfx/draw_scope.hpp new file mode 100644 index 0000000000..60aae7a44c --- /dev/null +++ b/src/mbgl/gfx/draw_scope.hpp @@ -0,0 +1,21 @@ +#pragma once + +#include <memory> + +namespace mbgl { +namespace gfx { + +class DrawScopeResource { +protected: + DrawScopeResource() = default; +public: + virtual ~DrawScopeResource() = default; +}; + +class DrawScope { +public: + std::unique_ptr<DrawScopeResource> resource; +}; + +} // namespace gfx +} // namespace mbgl diff --git a/src/mbgl/gfx/index_vector.hpp b/src/mbgl/gfx/index_vector.hpp index dc760feb90..826d43bee3 100644 --- a/src/mbgl/gfx/index_vector.hpp +++ b/src/mbgl/gfx/index_vector.hpp @@ -1,5 +1,6 @@ #pragma once +#include <mbgl/gfx/draw_mode.hpp> #include <mbgl/util/ignore.hpp> #include <vector> @@ -10,7 +11,7 @@ namespace gfx { template <class DrawMode> class IndexVector { public: - static constexpr std::size_t groupSize = DrawMode::bufferGroupSize; + static constexpr std::size_t groupSize = BufferGroupSizeOf<DrawMode>::value; template <class... Args> void emplace_back(Args&&... args) { diff --git a/src/mbgl/gfx/primitives.hpp b/src/mbgl/gfx/primitives.hpp deleted file mode 100644 index f92b1ec525..0000000000 --- a/src/mbgl/gfx/primitives.hpp +++ /dev/null @@ -1,24 +0,0 @@ -#pragma once - -#include <cstddef> - -namespace mbgl { -namespace gfx { - -class Point { -public: - static constexpr std::size_t vertexCount = 1; -}; - -class Line { -public: - static constexpr std::size_t vertexCount = 2; -}; - -class Triangle { -public: - static constexpr std::size_t vertexCount = 3; -}; - -} // namespace gfx -} // namespace mbgl diff --git a/src/mbgl/gfx/program.hpp b/src/mbgl/gfx/program.hpp new file mode 100644 index 0000000000..94ba3b18ef --- /dev/null +++ b/src/mbgl/gfx/program.hpp @@ -0,0 +1,53 @@ +#pragma once + +#include <cstddef> + +namespace mbgl { +namespace gfx { + +class Context; +class DrawMode; +class DepthMode; +class StencilMode; +class ColorMode; +class CullFaceMode; +class DrawScope; +class IndexBuffer; +template <class> class UniformValues; +template <class> class AttributeBindings; +template <class> class TextureBindings; + +template <class Name> +class Program { +protected: + Program() = default; + +public: + virtual ~Program() = default; + + Program(Program&&) = delete; + Program(const Program&) = delete; + Program& operator=(Program&&) = delete; + Program& operator=(const Program&) = delete; + + using AttributeList = typename Name::AttributeList; + using UniformList = typename Name::UniformList; + using TextureList = typename Name::TextureList; + + virtual void draw(Context&, + const DrawMode&, + const DepthMode&, + const StencilMode&, + const ColorMode&, + const CullFaceMode&, + const UniformValues<UniformList>&, + DrawScope&, + const AttributeBindings<AttributeList>&, + const TextureBindings<TextureList>&, + const IndexBuffer&, + std::size_t indexOffset, + std::size_t indexLength) = 0; +}; + +} // namespace gfx +} // namespace mbgl diff --git a/src/mbgl/gfx/texture.hpp b/src/mbgl/gfx/texture.hpp index 758bdd1b09..a957c4ebdf 100644 --- a/src/mbgl/gfx/texture.hpp +++ b/src/mbgl/gfx/texture.hpp @@ -52,21 +52,19 @@ public: TextureWrapType wrapY; }; -namespace detail { - template <class> class TextureBindings; template <class... Ts> -class TextureBindings<TypeList<Ts...>> { +class TextureBindings<TypeList<Ts...>> final + : public IndexedTuple<TypeList<Ts...>, TypeList<ExpandToType<Ts, TextureBinding>...>> { + using Base = IndexedTuple<TypeList<Ts...>, TypeList<ExpandToType<Ts, TextureBinding>...>>; + public: - using Type = IndexedTuple<TypeList<Ts...>, TypeList<ExpandToType<Ts, TextureBinding>...>>; + template <class... Args> + TextureBindings(Args&&... args) : Base(std::forward<Args>(args)...) { + } }; -} // namespace detail - -template <class TextureTypeList> -using TextureBindings = typename detail::TextureBindings<TextureTypeList>::Type; - } // namespace gfx } // namespace mbgl diff --git a/src/mbgl/gfx/types.hpp b/src/mbgl/gfx/types.hpp index 4c6a040b1f..da2bc14ddd 100644 --- a/src/mbgl/gfx/types.hpp +++ b/src/mbgl/gfx/types.hpp @@ -5,7 +5,17 @@ namespace mbgl { namespace gfx { +enum class ContextType : uint8_t { + OpenGL, +}; + enum class PrimitiveType : uint8_t { + Point, + Line, + Triangle, +}; + +enum class DrawModeType : uint8_t { Points, Lines, LineLoop, diff --git a/src/mbgl/gfx/uniform.hpp b/src/mbgl/gfx/uniform.hpp index bc6e7c1866..f6896b9138 100644 --- a/src/mbgl/gfx/uniform.hpp +++ b/src/mbgl/gfx/uniform.hpp @@ -31,21 +31,20 @@ namespace mbgl { namespace gfx { -namespace detail { template <class> class UniformValues; template <class... Us> -class UniformValues<TypeList<Us...>> { +class UniformValues<TypeList<Us...>> final + : public IndexedTuple<TypeList<Us...>, TypeList<typename Us::Value...>> { + using Base = IndexedTuple<TypeList<Us...>, TypeList<typename Us::Value...>>; + public: - using Type = IndexedTuple<TypeList<Us...>, TypeList<typename Us::Value...>>; + template <class... Args> + UniformValues(Args&&... args) : Base(std::forward<Args>(args)...) { + } }; -} // namespace detail - -template <class UniformTypeList> -using UniformValues = typename detail::UniformValues<UniformTypeList>::Type; - } // namespace gfx } // namespace mbgl diff --git a/src/mbgl/gl/attribute.cpp b/src/mbgl/gl/attribute.cpp index 1b43ad2b64..4983a8c204 100644 --- a/src/mbgl/gl/attribute.cpp +++ b/src/mbgl/gl/attribute.cpp @@ -7,17 +7,6 @@ namespace gl { using namespace platform; -optional<AttributeBinding> offsetAttributeBinding(const optional<AttributeBinding>& binding, std::size_t vertexOffset) { - assert(vertexOffset <= std::numeric_limits<uint32_t>::max()); - if (binding) { - AttributeBinding result = *binding; - result.vertexOffset = static_cast<uint32_t>(vertexOffset); - return result; - } else { - return binding; - } -} - void bindAttributeLocation(Context& context, ProgramID id, AttributeLocation location, const char* name) { // We're using sequentially numberered attribute locations starting with 0. Therefore we can use // the location as a proxy for the number of attributes. diff --git a/src/mbgl/gl/attribute.hpp b/src/mbgl/gl/attribute.hpp index dc112c1ad8..c4fe8b993f 100644 --- a/src/mbgl/gl/attribute.hpp +++ b/src/mbgl/gl/attribute.hpp @@ -2,7 +2,6 @@ #include <mbgl/gfx/attribute.hpp> #include <mbgl/gl/types.hpp> -#include <mbgl/gfx/vertex_buffer.hpp> #include <mbgl/util/ignore.hpp> #include <mbgl/util/indexed_tuple.hpp> #include <mbgl/util/optional.hpp> @@ -18,83 +17,50 @@ namespace mbgl { namespace gl { -class AttributeBinding { -public: - gfx::AttributeDescriptor attribute; - uint8_t vertexStride; - const gfx::VertexBufferResource* vertexBufferResource; - uint32_t vertexOffset; - - friend bool operator==(const AttributeBinding& lhs, const AttributeBinding& rhs) { - return lhs.attribute == rhs.attribute && - lhs.vertexStride == rhs.vertexStride && - lhs.vertexBufferResource == rhs.vertexBufferResource && - lhs.vertexOffset == rhs.vertexOffset; - } -}; - -using AttributeBindingArray = std::vector<optional<AttributeBinding>>; - - /* - Create a binding for this attribute. The `attributeSize` parameter may be used to - override the number of components available in the buffer for each vertex. Thus, - a buffer with only one float for each vertex can be bound to a `vec2` attribute - */ -template <std::size_t I, typename Vertex> -AttributeBinding attributeBinding(const gfx::VertexBuffer<Vertex>& buffer) { - static_assert(I < gfx::VertexDescriptorOf<Vertex>::data.count, "vertex attribute index out of range"); - return { - gfx::VertexDescriptorOf<Vertex>::data.attributes[I], - gfx::VertexDescriptorOf<Vertex>::data.stride, - buffer.resource.get(), - 0, - }; -} - -optional<AttributeBinding> offsetAttributeBinding(const optional<AttributeBinding>& binding, std::size_t vertexOffset); +using AttributeBindingArray = std::vector<optional<gfx::AttributeBinding>>; +using NamedAttributeLocations = std::vector<std::pair<const std::string, AttributeLocation>>; class Context; void bindAttributeLocation(Context&, ProgramID, AttributeLocation, const char * name); std::set<std::string> getActiveAttributes(ProgramID); template <class> -class Attributes; +class AttributeLocations; template <class... As> -class Attributes<TypeList<As...>> final { -public: - using Types = TypeList<As...>; - using Locations = IndexedTuple< - TypeList<As...>, - TypeList<ExpandToType<As, optional<AttributeLocation>>...>>; - using Bindings = IndexedTuple< - TypeList<As...>, - TypeList<ExpandToType<As, optional<AttributeBinding>>...>>; - using NamedLocations = std::vector<std::pair<const std::string, AttributeLocation>>; - - static Locations bindLocations(Context& context, const ProgramID& id) { - std::set<std::string> activeAttributes = getActiveAttributes(id); - - AttributeLocation location = 0; - auto maybeBindLocation = [&](const char* name) -> optional<AttributeLocation> { - if (activeAttributes.count(name)) { - bindAttributeLocation(context, id, location, name); - return location++; - } else { - return {}; - } - }; +class AttributeLocations<TypeList<As...>> final { +private: + using Locations = + IndexedTuple<TypeList<As...>, TypeList<ExpandToType<As, optional<AttributeLocation>>...>>; + + Locations locations; - return Locations { maybeBindLocation(As::name())... }; +public: + AttributeLocations(Context& context, const ProgramID& id) + : locations([&] { + std::set<std::string> activeAttributes = getActiveAttributes(id); + + AttributeLocation location = 0; + auto maybeBindLocation = [&](const char* name) -> optional<AttributeLocation> { + if (activeAttributes.count(name)) { + bindAttributeLocation(context, id, location, name); + return location++; + } else { + return {}; + } + }; + + return Locations{ maybeBindLocation(As::name())... }; + }()) { } - template <class Program> - static Locations loadNamedLocations(const Program& program) { - return Locations{ program.attributeLocation(As::name())... }; + template <class BinaryProgram> + AttributeLocations(const BinaryProgram& program) + : locations{ program.attributeLocation(As::name())... } { } - static NamedLocations getNamedLocations(const Locations& locations) { - NamedLocations result; + NamedAttributeLocations getNamedLocations() const { + NamedAttributeLocations result; auto maybeAddLocation = [&] (const std::string& name, const optional<AttributeLocation>& location) { if (location) { @@ -107,20 +73,12 @@ public: return result; } - static Bindings bindings(const gfx::VertexBuffer<gfx::Vertex<Types>>& buffer) { - return Bindings { attributeBinding<TypeIndex<As, As...>::value>(buffer)... }; - } - - static Bindings offsetBindings(const Bindings& bindings, std::size_t vertexOffset) { - return Bindings { offsetAttributeBinding(bindings.template get<As>(), vertexOffset)... }; - } - - static AttributeBindingArray toBindingArray(const Locations& locations, const Bindings& bindings) { + AttributeBindingArray toBindingArray(const gfx::AttributeBindings<TypeList<As...>>& bindings) const { AttributeBindingArray result; result.resize(sizeof...(As)); auto maybeAddBinding = [&] (const optional<AttributeLocation>& location, - const optional<AttributeBinding>& binding) { + const optional<gfx::AttributeBinding>& binding) { if (location) { result.at(*location) = binding; } @@ -130,12 +88,6 @@ public: return result; } - - static uint32_t activeBindingCount(const Bindings& bindings) { - uint32_t result = 0; - util::ignore({ ((result += bool(bindings.template get<As>())), 0)... }); - return result; - } }; } // namespace gl diff --git a/src/mbgl/programs/binary_program.cpp b/src/mbgl/gl/binary_program.cpp index 598a547252..9fdbdb8ee1 100644 --- a/src/mbgl/programs/binary_program.cpp +++ b/src/mbgl/gl/binary_program.cpp @@ -1,4 +1,4 @@ -#include <mbgl/programs/binary_program.hpp> +#include <mbgl/gl/binary_program.hpp> #include <protozero/pbf_reader.hpp> #include <protozero/pbf_writer.hpp> @@ -31,6 +31,7 @@ static std::pair<const std::string, Binding> parseBinding(protozero::pbf_reader& } namespace mbgl { +namespace gl { BinaryProgram::BinaryProgram(std::string&& data) { bool hasFormat = false, hasCode = false; @@ -137,4 +138,5 @@ gl::UniformLocation BinaryProgram::textureLocation(const std::string& name) cons return -1; } +} // namespace gl } // namespace mbgl diff --git a/src/mbgl/programs/binary_program.hpp b/src/mbgl/gl/binary_program.hpp index 1ae874800b..38160b62b5 100644 --- a/src/mbgl/programs/binary_program.hpp +++ b/src/mbgl/gl/binary_program.hpp @@ -7,6 +7,7 @@ #include <vector> namespace mbgl { +namespace gl { class BinaryProgram { public: @@ -45,4 +46,5 @@ private: std::vector<std::pair<const std::string, gl::UniformLocation>> textures; }; +} // namespace gl } // namespace mbgl diff --git a/src/mbgl/gl/context.cpp b/src/mbgl/gl/context.cpp index ca06ab660d..5193381251 100644 --- a/src/mbgl/gl/context.cpp +++ b/src/mbgl/gl/context.cpp @@ -3,6 +3,7 @@ #include <mbgl/gl/vertex_buffer_resource.hpp> #include <mbgl/gl/index_buffer_resource.hpp> #include <mbgl/gl/texture_resource.hpp> +#include <mbgl/gl/draw_scope_resource.hpp> #include <mbgl/gl/texture.hpp> #include <mbgl/gl/debugging_extension.hpp> #include <mbgl/gl/vertex_array_extension.hpp> @@ -66,7 +67,7 @@ static_assert(underlying_type(UniformDataType::SamplerCube) == GL_SAMPLER_CUBE, static_assert(std::is_same<BinaryProgramFormat, GLenum>::value, "OpenGL type mismatch"); Context::Context() - : maximumVertexBindingCount([] { + : gfx::Context(gfx::ContextType::OpenGL), maximumVertexBindingCount([] { GLint value; MBGL_CHECK_ERROR(glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &value)); return value; @@ -190,6 +191,8 @@ UniqueProgram Context::createProgram(ShaderID vertexShader, ShaderID fragmentSha MBGL_CHECK_ERROR(glAttachShader(result, vertexShader)); MBGL_CHECK_ERROR(glAttachShader(result, fragmentShader)); + linkProgram(result); + return result; } @@ -544,6 +547,10 @@ void Context::updateTextureResource(const gfx::TextureResource& resource, Enum<gfx::TextureChannelDataType>::to(type), data)); } +std::unique_ptr<gfx::DrawScopeResource> Context::createDrawScopeResource() { + return std::make_unique<gl::DrawScopeResource>(createVertexArray()); +} + void Context::reset() { std::copy(pooledTextures.begin(), pooledTextures.end(), std::back_inserter(abandonedTextures)); pooledTextures.resize(0); @@ -628,29 +635,6 @@ void Context::setCullFaceMode(const gfx::CullFaceMode& mode) { cullFaceWinding = mode.winding; } -#if not MBGL_USE_GLES2 -void Context::setDrawMode(const gfx::Points& points) { - pointSize = points.pointSize; -} -#else -void Context::setDrawMode(const gfx::Points&) { -} -#endif // MBGL_USE_GLES2 - -void Context::setDrawMode(const gfx::Lines& lines) { - lineWidth = lines.lineWidth; -} - -void Context::setDrawMode(const gfx::LineStrip& lineStrip) { - lineWidth = lineStrip.lineWidth; -} - -void Context::setDrawMode(const gfx::Triangles&) { -} - -void Context::setDrawMode(const gfx::TriangleStrip&) { -} - void Context::setDepthMode(const gfx::DepthMode& depth) { if (depth.func == gfx::DepthFunctionType::Always && depth.mask != gfx::DepthMaskType::ReadWrite) { depthTest = false; @@ -697,11 +681,27 @@ void Context::setColorMode(const gfx::ColorMode& color) { colorMask = color.mask; } -void Context::draw(gfx::PrimitiveType primitiveType, +void Context::draw(const gfx::DrawMode& drawMode, std::size_t indexOffset, std::size_t indexLength) { + switch (drawMode.type) { + case gfx::DrawModeType::Points: +#if not MBGL_USE_GLES2 + // In OpenGL ES 2, the point size is set in the vertex shader. + pointSize = drawMode.size; +#endif // MBGL_USE_GLES2 + break; + case gfx::DrawModeType::Lines: + case gfx::DrawModeType::LineLoop: + case gfx::DrawModeType::LineStrip: + lineWidth = drawMode.size; + break; + default: + break; + } + MBGL_CHECK_ERROR(glDrawElements( - Enum<gfx::PrimitiveType>::to(primitiveType), + Enum<gfx::DrawModeType>::to(drawMode.type), static_cast<GLsizei>(indexLength), GL_UNSIGNED_SHORT, reinterpret_cast<GLvoid*>(sizeof(uint16_t) * indexOffset))); diff --git a/src/mbgl/gl/context.hpp b/src/mbgl/gl/context.hpp index 51b79200ba..fe09390cc6 100644 --- a/src/mbgl/gl/context.hpp +++ b/src/mbgl/gl/context.hpp @@ -52,7 +52,6 @@ public: void verifyProgramLinkage(ProgramID); void linkProgram(ProgramID); UniqueTexture createUniqueTexture(); - VertexArray createVertexArray(); #if MBGL_HAS_BINARY_PROGRAMS bool supportsProgramBinaries() const; @@ -100,18 +99,12 @@ public: optional<float> depth, optional<int32_t> stencil); - void setDrawMode(const gfx::Points&); - void setDrawMode(const gfx::Lines&); - void setDrawMode(const gfx::LineStrip&); - void setDrawMode(const gfx::Triangles&); - void setDrawMode(const gfx::TriangleStrip&); - void setDepthMode(const gfx::DepthMode&); void setStencilMode(const gfx::StencilMode&); void setColorMode(const gfx::ColorMode&); void setCullFaceMode(const gfx::CullFaceMode&); - void draw(gfx::PrimitiveType, + void draw(const gfx::DrawMode&, std::size_t indexOffset, std::size_t indexLength); @@ -216,6 +209,8 @@ private: std::unique_ptr<gfx::TextureResource> createTextureResource(Size, const void* data, gfx::TexturePixelType, gfx::TextureChannelDataType) override; void updateTextureResource(const gfx::TextureResource&, Size, const void* data, gfx::TexturePixelType, gfx::TextureChannelDataType) override; + std::unique_ptr<gfx::DrawScopeResource> createDrawScopeResource() override; + UniqueFramebuffer createFramebuffer(); UniqueRenderbuffer createRenderbuffer(RenderbufferType, Size size); std::unique_ptr<uint8_t[]> readFramebuffer(Size, gfx::TexturePixelType, bool flip); @@ -223,6 +218,7 @@ private: void drawPixels(Size size, const void* data, gfx::TexturePixelType); #endif // MBGL_USE_GLES2 + VertexArray createVertexArray(); bool supportsVertexArrays() const; friend detail::ProgramDeleter; diff --git a/src/mbgl/gl/draw_scope_resource.hpp b/src/mbgl/gl/draw_scope_resource.hpp new file mode 100644 index 0000000000..4c446cd4fe --- /dev/null +++ b/src/mbgl/gl/draw_scope_resource.hpp @@ -0,0 +1,18 @@ +#pragma once + +#include <mbgl/gfx/draw_scope.hpp> +#include <mbgl/gl/vertex_array.hpp> + +namespace mbgl { +namespace gl { + +class DrawScopeResource : public gfx::DrawScopeResource { +public: + DrawScopeResource(VertexArray&& vertexArray_) : vertexArray(std::move(vertexArray_)) { + } + + VertexArray vertexArray; +}; + +} // namespace gl +} // namespace mbgl diff --git a/src/mbgl/gl/enum.cpp b/src/mbgl/gl/enum.cpp index c1a51944de..673d43b5d6 100644 --- a/src/mbgl/gl/enum.cpp +++ b/src/mbgl/gl/enum.cpp @@ -6,15 +6,15 @@ namespace mbgl { namespace gl { template <> -platform::GLenum Enum<gfx::PrimitiveType>::to(const gfx::PrimitiveType value) { +platform::GLenum Enum<gfx::DrawModeType>::to(const gfx::DrawModeType value) { switch (value) { - case gfx::PrimitiveType::Points: return GL_POINTS; - case gfx::PrimitiveType::Lines: return GL_LINES; - case gfx::PrimitiveType::LineLoop: return GL_LINE_LOOP; - case gfx::PrimitiveType::LineStrip: return GL_LINE_STRIP; - case gfx::PrimitiveType::Triangles: return GL_TRIANGLES; - case gfx::PrimitiveType::TriangleStrip: return GL_TRIANGLE_STRIP; - case gfx::PrimitiveType::TriangleFan: return GL_TRIANGLE_FAN; + case gfx::DrawModeType::Points: return GL_POINTS; + case gfx::DrawModeType::Lines: return GL_LINES; + case gfx::DrawModeType::LineLoop: return GL_LINE_LOOP; + case gfx::DrawModeType::LineStrip: return GL_LINE_STRIP; + case gfx::DrawModeType::Triangles: return GL_TRIANGLES; + case gfx::DrawModeType::TriangleStrip: return GL_TRIANGLE_STRIP; + case gfx::DrawModeType::TriangleFan: return GL_TRIANGLE_FAN; } return GL_INVALID_ENUM; } diff --git a/src/mbgl/gl/program.hpp b/src/mbgl/gl/program.hpp index ffa3e07391..9028ffdf53 100644 --- a/src/mbgl/gl/program.hpp +++ b/src/mbgl/gl/program.hpp @@ -1,80 +1,79 @@ #pragma once +#include <mbgl/gfx/program.hpp> #include <mbgl/gl/types.hpp> #include <mbgl/gl/object.hpp> #include <mbgl/gl/context.hpp> +#include <mbgl/gl/draw_scope_resource.hpp> #include <mbgl/gfx/vertex_buffer.hpp> #include <mbgl/gfx/index_buffer.hpp> +#include <mbgl/gfx/uniform.hpp> #include <mbgl/gl/vertex_array.hpp> #include <mbgl/gl/attribute.hpp> #include <mbgl/gl/uniform.hpp> #include <mbgl/gl/texture.hpp> - +#include <mbgl/gl/features.hpp> +#include <mbgl/gl/binary_program.hpp> #include <mbgl/util/io.hpp> + #include <mbgl/util/logging.hpp> -#include <mbgl/programs/binary_program.hpp> #include <mbgl/programs/program_parameters.hpp> -#include <mbgl/shaders/shaders.hpp> +#include <mbgl/programs/gl/shaders.hpp> #include <string> namespace mbgl { namespace gl { -template <class P, class As, class Us, class TextureList> -class Program { +template <class Name> +class Program final : public gfx::Program<Name> { public: - using Primitive = P; - using Attributes = As; - using Uniforms = Us; - - using UniformValues = typename Uniforms::Values; - using AttributeBindings = typename Attributes::Bindings; - using TextureBindings = gfx::TextureBindings<TextureList>; - + using AttributeList = typename Name::AttributeList; + using UniformList = typename Name::UniformList; + using TextureList = typename Name::TextureList; + Program(Context& context, const std::string& vertexSource, const std::string& fragmentSource) : program( context.createProgram(context.createShader(ShaderType::Vertex, vertexSource), context.createShader(ShaderType::Fragment, fragmentSource))), - uniformsState((context.linkProgram(program), Uniforms::bindLocations(program))), - attributeLocations(Attributes::bindLocations(context, program)) { - // Re-link program after manually binding only active attributes in Attributes::bindLocations + attributeLocations(context, program) { + // Re-link program after manually binding only active attributes in Attributes::queryLocations context.linkProgram(program); // We have to re-initialize the uniforms state from the bindings as the uniform locations // get shifted on some implementations - uniformsState = Uniforms::bindLocations(program); + uniformStates.queryLocations(program); // Texture units are specified via uniforms as well, so we need query their locations - textures.queryLocations(program); + textureStates.queryLocations(program); } template <class BinaryProgram> Program(Context& context, const BinaryProgram& binaryProgram) : program(context.createProgram(binaryProgram.format(), binaryProgram.code())), - uniformsState(Uniforms::loadNamedLocations(binaryProgram)), - attributeLocations(Attributes::loadNamedLocations(binaryProgram)) { - textures.loadNamedLocations(binaryProgram); + attributeLocations(binaryProgram) { + uniformStates.loadNamedLocations(binaryProgram); + textureStates.loadNamedLocations(binaryProgram); } - - static Program createProgram(gl::Context& context, - const ProgramParameters& programParameters, - const char* name, - const char* vertexSource_, - const char* fragmentSource_) { - const std::string vertexSource = shaders::vertexSource(programParameters, vertexSource_); - const std::string fragmentSource = shaders::fragmentSource(programParameters, fragmentSource_); + + static std::unique_ptr<Program> createProgram(gl::Context& context, + const ProgramParameters& programParameters, + const char* name, + const char* vertexSource_, + const char* fragmentSource_) { + const std::string vertexSource = programs::gl::vertexSource(programParameters, vertexSource_); + const std::string fragmentSource = programs::gl::fragmentSource(programParameters, fragmentSource_); #if MBGL_HAS_BINARY_PROGRAMS optional<std::string> cachePath = programParameters.cachePath(name); if (cachePath && context.supportsProgramBinaries()) { - const std::string identifier = shaders::programIdentifier(vertexSource, fragmentSource); + const std::string identifier = programs::gl::programIdentifier(vertexSource, fragmentSource); try { if (auto cachedBinaryProgram = util::readFile(*cachePath)) { const BinaryProgram binaryProgram(std::move(*cachedBinaryProgram)); if (binaryProgram.identifier() == identifier) { - return Program { context, binaryProgram }; + return std::make_unique<Program>(context, binaryProgram); } else { Log::Warning(Event::OpenGL, "Cached program %s changed. Recompilation required.", @@ -87,11 +86,11 @@ public: } // Compile the shader - Program result{ context, vertexSource, fragmentSource }; + auto result = std::make_unique<Program>(context, vertexSource, fragmentSource); try { if (const auto binaryProgram = - result.template get<BinaryProgram>(context, identifier)) { + result->template get<BinaryProgram>(context, identifier)) { util::write_file(*cachePath, binaryProgram->serialize()); Log::Warning(Event::OpenGL, "Caching program in: %s", (*cachePath).c_str()); } @@ -104,37 +103,37 @@ public: #endif (void)name; - return Program { context, vertexSource, fragmentSource }; + return std::make_unique<Program>(context, vertexSource, fragmentSource); } template <class BinaryProgram> optional<BinaryProgram> get(Context& context, const std::string& identifier) const { if (auto binaryProgram = context.getBinaryProgram(program)) { - return BinaryProgram{ binaryProgram->first, std::move(binaryProgram->second), - identifier, Attributes::getNamedLocations(attributeLocations), - Uniforms::getNamedLocations(uniformsState), - textures.getNamedLocations() }; + return BinaryProgram{ binaryProgram->first, + std::move(binaryProgram->second), + identifier, + attributeLocations.getNamedLocations(), + uniformStates.getNamedLocations(), + textureStates.getNamedLocations() }; } return {}; } - template <class DrawMode> - void draw(Context& context, - DrawMode drawMode, - gfx::DepthMode depthMode, - gfx::StencilMode stencilMode, - gfx::ColorMode colorMode, - gfx::CullFaceMode cullFaceMode, - const UniformValues& uniformValues, - gl::VertexArray& vertexArray, - const AttributeBindings& attributeBindings, - const TextureBindings& textureBindings, + void draw(gfx::Context& genericContext, + const gfx::DrawMode& drawMode, + const gfx::DepthMode& depthMode, + const gfx::StencilMode& stencilMode, + const gfx::ColorMode& colorMode, + const gfx::CullFaceMode& cullFaceMode, + const gfx::UniformValues<UniformList>& uniformValues, + gfx::DrawScope& drawScope, + const gfx::AttributeBindings<AttributeList>& attributeBindings, + const gfx::TextureBindings<TextureList>& textureBindings, const gfx::IndexBuffer& indexBuffer, std::size_t indexOffset, - std::size_t indexLength) { - static_assert(std::is_same<Primitive, typename DrawMode::Primitive>::value, "incompatible draw mode"); + std::size_t indexLength) override { + auto& context = reinterpret_cast<gl::Context&>(genericContext); - context.setDrawMode(drawMode); context.setDepthMode(depthMode); context.setStencilMode(stencilMode); context.setColorMode(colorMode); @@ -142,15 +141,16 @@ public: context.program = program; - Uniforms::bind(uniformsState, uniformValues); + uniformStates.bind(uniformValues); - textures.bind(context, textureBindings); + textureStates.bind(context, textureBindings); + auto& vertexArray = reinterpret_cast<gl::DrawScopeResource&>(*drawScope.resource).vertexArray; vertexArray.bind(context, indexBuffer, - Attributes::toBindingArray(attributeLocations, attributeBindings)); + attributeLocations.toBindingArray(attributeBindings)); - context.draw(drawMode.primitiveType, + context.draw(drawMode, indexOffset, indexLength); } @@ -158,9 +158,9 @@ public: private: UniqueProgram program; - typename Uniforms::State uniformsState; - typename Attributes::Locations attributeLocations; - gl::Textures<TextureList> textures; + gl::AttributeLocations<AttributeList> attributeLocations; + gl::UniformStates<UniformList> uniformStates; + gl::TextureStates<TextureList> textureStates; }; } // namespace gl diff --git a/src/mbgl/gl/texture.hpp b/src/mbgl/gl/texture.hpp index 8230be1652..0569adc3b0 100644 --- a/src/mbgl/gl/texture.hpp +++ b/src/mbgl/gl/texture.hpp @@ -15,13 +15,15 @@ class Context; void bindTexture(gl::Context&, uint8_t unit, const gfx::TextureBinding&); template <class> -class Textures; +class TextureStates; template <class... Ts> -class Textures<TypeList<Ts...>> { +class TextureStates<TypeList<Ts...>> { +private: using State = IndexedTuple<TypeList<Ts...>, TypeList<ExpandToType<Ts, gl::UniformState<uint8_t>>...>>; - using NamedLocations = std::vector<std::pair<const std::string, gl::UniformLocation>>; + + State state; public: void queryLocations(const ProgramID& id) { @@ -33,8 +35,8 @@ public: state = State{ program.textureLocation(Ts::name())... }; } - NamedLocations getNamedLocations() const { - return NamedLocations{ { Ts::name(), state.template get<Ts>().location }... }; + NamedUniformLocations getNamedLocations() const { + return NamedUniformLocations{ { Ts::name(), state.template get<Ts>().location }... }; } void bind(gl::Context& context, const gfx::TextureBindings<TypeList<Ts...>>& bindings) { @@ -43,9 +45,6 @@ public: gl::bindTexture(context, TypeIndex<Ts, Ts...>::value, bindings.template get<Ts>()), 0)... }); } - -private: - State state; }; } // namespace gl diff --git a/src/mbgl/gl/uniform.hpp b/src/mbgl/gl/uniform.hpp index 3827015bb3..770f3e2294 100644 --- a/src/mbgl/gl/uniform.hpp +++ b/src/mbgl/gl/uniform.hpp @@ -1,5 +1,6 @@ #pragma once +#include <mbgl/gfx/uniform.hpp> #include <mbgl/gl/types.hpp> #include <mbgl/util/optional.hpp> #include <mbgl/util/ignore.hpp> @@ -49,23 +50,25 @@ public: optional<Value> current = {}; }; -UniformLocation uniformLocation(ProgramID, const char * name); +UniformLocation uniformLocation(ProgramID, const char* name); + +using NamedUniformLocations = std::vector<std::pair<const std::string, UniformLocation>>; template <class> -class Uniforms; +class UniformStates; template <class... Us> -class Uniforms<TypeList<Us...>> final { -public: - using Types = TypeList<Us...>; +class UniformStates<TypeList<Us...>> final { +private: using State = IndexedTuple<TypeList<Us...>, TypeList<UniformState<typename Us::Value>...>>; - using Values = IndexedTuple<TypeList<Us...>, TypeList<typename Us::Value...>>; - using NamedLocations = std::vector<std::pair<const std::string, UniformLocation>>; - static State bindLocations(const ProgramID& id) { + State state; + +public: + void queryLocations(const ProgramID& id) { #ifndef NDEBUG // Verify active uniform types match the enum - const auto active = activeUniforms(id); + const auto active = gl::activeUniforms(id); util::ignore( { // Some shader programs have uniforms declared, but not used, so they're not active. @@ -75,19 +78,19 @@ public: : false)... }); #endif - return State(uniformLocation(id, Us::name())...); + state = State{ gl::uniformLocation(id, Us::name())... }; } - template <class Program> - static State loadNamedLocations(const Program& program) { - return State(UniformState<typename Us::Value>(program.uniformLocation(Us::name()))...); + template <class BinaryProgram> + void loadNamedLocations(const BinaryProgram& program) { + state = State{ UniformState<typename Us::Value>(program.uniformLocation(Us::name()))... }; } - static NamedLocations getNamedLocations(const State& state) { - return NamedLocations{ { Us::name(), state.template get<Us>().location }... }; + NamedUniformLocations getNamedLocations() const { + return NamedUniformLocations{ { Us::name(), state.template get<Us>().location }... }; } - static void bind(State& state, const Values& values) { + void bind(const gfx::UniformValues<TypeList<Us...>>& values) { util::ignore({ (state.template get<Us>() = values.template get<Us>(), 0)... }); } }; diff --git a/src/mbgl/gl/value.cpp b/src/mbgl/gl/value.cpp index 8f5b53fcac..bd08ac48fc 100644 --- a/src/mbgl/gl/value.cpp +++ b/src/mbgl/gl/value.cpp @@ -397,7 +397,7 @@ BindVertexArray::Type BindVertexArray::Get(const Context& context) { return binding; } -const optional<AttributeBinding> VertexAttribute::Default {}; +const VertexAttribute::Type VertexAttribute::Default {}; namespace { @@ -484,7 +484,7 @@ GLint components(const gfx::AttributeDataType type) { } // namespace -void VertexAttribute::Set(const optional<AttributeBinding>& binding, Context& context, AttributeLocation location) { +void VertexAttribute::Set(const Type& binding, Context& context, AttributeLocation location) { if (binding) { context.vertexBuffer = reinterpret_cast<const gl::VertexBufferResource&>(*binding->vertexBufferResource).buffer; MBGL_CHECK_ERROR(glEnableVertexAttribArray(location)); diff --git a/src/mbgl/gl/value.hpp b/src/mbgl/gl/value.hpp index 15812a49bd..5bd2132ecf 100644 --- a/src/mbgl/gl/value.hpp +++ b/src/mbgl/gl/value.hpp @@ -264,7 +264,7 @@ struct BindVertexArray { }; struct VertexAttribute { - using Type = optional<gl::AttributeBinding>; + using Type = optional<gfx::AttributeBinding>; static const Type Default; static void Set(const Type&, Context&, AttributeLocation); }; diff --git a/src/mbgl/programs/background_pattern_program.hpp b/src/mbgl/programs/background_pattern_program.hpp new file mode 100644 index 0000000000..4b66065670 --- /dev/null +++ b/src/mbgl/programs/background_pattern_program.hpp @@ -0,0 +1,4 @@ +#pragma once + +// Alias +#include <mbgl/programs/background_program.hpp> diff --git a/src/mbgl/programs/background_program.cpp b/src/mbgl/programs/background_program.cpp index 99c9c55e84..7d68f62fb1 100644 --- a/src/mbgl/programs/background_program.cpp +++ b/src/mbgl/programs/background_program.cpp @@ -1,4 +1,5 @@ #include <mbgl/programs/background_program.hpp> +#include <mbgl/gfx/context_impl.hpp> #include <mbgl/renderer/image_atlas.hpp> #include <mbgl/renderer/cross_faded_property_evaluator.hpp> #include <mbgl/tile/tile_id.hpp> @@ -6,20 +7,22 @@ namespace mbgl { +template std::unique_ptr<gfx::Program<BackgroundProgram>> gfx::Context::createProgram(const ProgramParameters&); +template std::unique_ptr<gfx::Program<BackgroundPatternProgram>> gfx::Context::createProgram(const ProgramParameters&); + using namespace style; static_assert(sizeof(BackgroundLayoutVertex) == 4, "expected BackgroundLayoutVertex size"); -BackgroundPatternProgram::UniformValues -BackgroundPatternProgram::uniformValues(mat4 matrix, - float opacity, - Size atlasSize, - const ImagePosition& a, - const ImagePosition& b, - const CrossfadeParameters& fading, - const UnwrappedTileID& tileID, - const TransformState& state) -{ +BackgroundPatternProgram::LayoutUniformValues +BackgroundPatternProgram::layoutUniformValues(mat4 matrix, + float opacity, + Size atlasSize, + const ImagePosition& a, + const ImagePosition& b, + const CrossfadeParameters& fading, + const UnwrappedTileID& tileID, + const TransformState& state) { int32_t tileSizeAtNearestZoom = util::tileSize * state.zoomScale(state.getIntegerZoom() - tileID.canonical.z); int32_t pixelX = tileSizeAtNearestZoom * (tileID.canonical.x + tileID.wrap * state.zoomScale(tileID.canonical.z)); int32_t pixelY = tileSizeAtNearestZoom * tileID.canonical.y; diff --git a/src/mbgl/programs/background_program.hpp b/src/mbgl/programs/background_program.hpp index 9899fb695a..b1ade6dc84 100644 --- a/src/mbgl/programs/background_program.hpp +++ b/src/mbgl/programs/background_program.hpp @@ -4,14 +4,9 @@ #include <mbgl/programs/attributes.hpp> #include <mbgl/programs/uniforms.hpp> #include <mbgl/programs/textures.hpp> -#include <mbgl/shaders/background.hpp> -#include <mbgl/shaders/background_pattern.hpp> #include <mbgl/util/geometry.hpp> #include <mbgl/util/mat4.hpp> #include <mbgl/util/size.hpp> -#include <mbgl/style/layers/background_layer_properties.hpp> - -#include <string> namespace mbgl { @@ -45,8 +40,8 @@ using BackgroundPatternUniforms = TypeList< uniforms::u_tile_units_to_pixels>; class BackgroundProgram : public Program< - shaders::background, - gfx::Triangle, + BackgroundProgram, + gfx::PrimitiveType::Triangle, BackgroundLayoutAttributes, BackgroundUniforms, TypeList<>, @@ -57,8 +52,8 @@ public: }; class BackgroundPatternProgram : public Program< - shaders::background_pattern, - gfx::Triangle, + BackgroundPatternProgram, + gfx::PrimitiveType::Triangle, BackgroundLayoutAttributes, BackgroundPatternUniforms, TypeList< @@ -68,22 +63,22 @@ class BackgroundPatternProgram : public Program< public: using Program::Program; - static UniformValues uniformValues(mat4 matrix, - float opacity, - Size atlasSize, - const ImagePosition&, - const ImagePosition&, - const CrossfadeParameters&, - const UnwrappedTileID&, - const TransformState&); + static LayoutUniformValues layoutUniformValues(mat4 matrix, + float opacity, + Size atlasSize, + const ImagePosition&, + const ImagePosition&, + const CrossfadeParameters&, + const UnwrappedTileID&, + const TransformState&); }; using BackgroundLayoutVertex = BackgroundProgram::LayoutVertex; -using BackgroundAttributes = BackgroundProgram::Attributes; +using BackgroundAttributes = BackgroundProgram::AttributeList; class BackgroundLayerPrograms final : public LayerTypePrograms { public: - BackgroundLayerPrograms(gl::Context& context, const ProgramParameters& programParameters) + BackgroundLayerPrograms(gfx::Context& context, const ProgramParameters& programParameters) : background(context, programParameters), backgroundPattern(context, programParameters) {} BackgroundProgram background; diff --git a/src/mbgl/programs/circle_program.cpp b/src/mbgl/programs/circle_program.cpp index 99b47dd5c0..577410d94e 100644 --- a/src/mbgl/programs/circle_program.cpp +++ b/src/mbgl/programs/circle_program.cpp @@ -1,7 +1,10 @@ #include <mbgl/programs/circle_program.hpp> +#include <mbgl/gfx/context_impl.hpp> namespace mbgl { +template std::unique_ptr<gfx::Program<CircleProgram>> gfx::Context::createProgram(const ProgramParameters&); + static_assert(sizeof(CircleLayoutVertex) == 4, "expected CircleLayoutVertex size"); } // namespace mbgl diff --git a/src/mbgl/programs/circle_program.hpp b/src/mbgl/programs/circle_program.hpp index 5a381d8fa9..0caa1b2a15 100644 --- a/src/mbgl/programs/circle_program.hpp +++ b/src/mbgl/programs/circle_program.hpp @@ -3,7 +3,6 @@ #include <mbgl/programs/program.hpp> #include <mbgl/programs/attributes.hpp> #include <mbgl/programs/uniforms.hpp> -#include <mbgl/shaders/circle.hpp> #include <mbgl/util/geometry.hpp> #include <mbgl/style/layers/circle_layer_properties.hpp> @@ -14,8 +13,8 @@ MBGL_DEFINE_UNIFORM_SCALAR(bool, u_scale_with_map); } // namespace uniforms class CircleProgram : public Program< - shaders::circle, - gfx::Triangle, + CircleProgram, + gfx::PrimitiveType::Triangle, TypeList< attributes::a_pos>, TypeList< @@ -47,11 +46,11 @@ public: }; using CircleLayoutVertex = CircleProgram::LayoutVertex; -using CircleAttributes = CircleProgram::Attributes; +using CircleAttributes = CircleProgram::AttributeList; class CircleLayerPrograms final : public LayerTypePrograms { public: - CircleLayerPrograms(gl::Context& context, const ProgramParameters& programParameters) + CircleLayerPrograms(gfx::Context& context, const ProgramParameters& programParameters) : circle(context, programParameters) {} ProgramMap<CircleProgram> circle; }; diff --git a/src/mbgl/programs/clipping_mask_program.cpp b/src/mbgl/programs/clipping_mask_program.cpp new file mode 100644 index 0000000000..9b1a9ef4fc --- /dev/null +++ b/src/mbgl/programs/clipping_mask_program.cpp @@ -0,0 +1,8 @@ +#include <mbgl/programs/clipping_mask_program.hpp> +#include <mbgl/gfx/context_impl.hpp> + +namespace mbgl { + +template std::unique_ptr<gfx::Program<ClippingMaskProgram>> gfx::Context::createProgram(const ProgramParameters&); + +} // namespace mbgl diff --git a/src/mbgl/programs/clipping_mask_program.hpp b/src/mbgl/programs/clipping_mask_program.hpp index 033d466116..874708a52f 100644 --- a/src/mbgl/programs/clipping_mask_program.hpp +++ b/src/mbgl/programs/clipping_mask_program.hpp @@ -3,14 +3,13 @@ #include <mbgl/programs/program.hpp> #include <mbgl/programs/attributes.hpp> #include <mbgl/programs/uniforms.hpp> -#include <mbgl/shaders/clipping_mask.hpp> #include <mbgl/style/properties.hpp> namespace mbgl { class ClippingMaskProgram : public Program< - shaders::clipping_mask, - gfx::Triangle, + ClippingMaskProgram, + gfx::PrimitiveType::Triangle, PositionOnlyLayoutAttributes, TypeList< uniforms::u_matrix>, @@ -22,6 +21,6 @@ public: }; using ClippingMaskLayoutVertex = ClippingMaskProgram::LayoutVertex; -using ClippingMaskAttributes = ClippingMaskProgram::Attributes; +using ClippingMaskAttributes = ClippingMaskProgram::AttributeList; } // namespace mbgl diff --git a/src/mbgl/programs/collision_box_program.cpp b/src/mbgl/programs/collision_box_program.cpp index 584013640e..885894526e 100644 --- a/src/mbgl/programs/collision_box_program.cpp +++ b/src/mbgl/programs/collision_box_program.cpp @@ -1,7 +1,11 @@ #include <mbgl/programs/collision_box_program.hpp> +#include <mbgl/gfx/context_impl.hpp> namespace mbgl { +template std::unique_ptr<gfx::Program<CollisionBoxProgram>> gfx::Context::createProgram(const ProgramParameters&); +template std::unique_ptr<gfx::Program<CollisionCircleProgram>> gfx::Context::createProgram(const ProgramParameters&); + static_assert(sizeof(CollisionBoxProgram::LayoutVertex) == 24, "expected CollisionBoxVertex size"); } // namespace mbgl diff --git a/src/mbgl/programs/collision_box_program.hpp b/src/mbgl/programs/collision_box_program.hpp index cd7f0bfd68..7b81752a94 100644 --- a/src/mbgl/programs/collision_box_program.hpp +++ b/src/mbgl/programs/collision_box_program.hpp @@ -3,8 +3,6 @@ #include <mbgl/programs/program.hpp> #include <mbgl/programs/attributes.hpp> #include <mbgl/programs/uniforms.hpp> -#include <mbgl/shaders/collision_box.hpp> -#include <mbgl/shaders/collision_circle.hpp> #include <mbgl/style/properties.hpp> #include <mbgl/util/geometry.hpp> @@ -21,8 +19,8 @@ using CollisionBoxLayoutAttributes = TypeList< using CollisionBoxDynamicAttributes = TypeList<attributes::a_placed>; class CollisionBoxProgram : public Program< - shaders::collision_box, - gfx::Line, + CollisionBoxProgram, + gfx::PrimitiveType::Line, TypeListConcat<CollisionBoxLayoutAttributes, CollisionBoxDynamicAttributes>, TypeList< uniforms::u_matrix, @@ -62,48 +60,48 @@ public: } template <class DrawMode> - void draw(gl::Context& context, - DrawMode drawMode, - gfx::DepthMode depthMode, - gfx::StencilMode stencilMode, - gfx::ColorMode colorMode, - gfx::CullFaceMode cullFaceMode, - const UniformValues& uniformValues, + void draw(gfx::Context& context, + const DrawMode& drawMode, + const gfx::DepthMode& depthMode, + const gfx::StencilMode& stencilMode, + const gfx::ColorMode& colorMode, + const gfx::CullFaceMode& cullFaceMode, + const LayoutUniformValues& layoutUniformValues, const gfx::VertexBuffer<gfx::Vertex<CollisionBoxLayoutAttributes>>& layoutVertexBuffer, const gfx::VertexBuffer<gfx::Vertex<CollisionBoxDynamicAttributes>>& dynamicVertexBuffer, const gfx::IndexBuffer& indexBuffer, - const SegmentVector<Attributes>& segments, + const SegmentVector<AttributeList>& segments, const Binders& paintPropertyBinders, const typename PaintProperties::PossiblyEvaluated& currentProperties, const TextureBindings& textureBindings, float currentZoom, const std::string& layerID) { - typename AllUniforms::Values allUniformValues = uniformValues + UniformValues uniformValues = layoutUniformValues .concat(paintPropertyBinders.uniformValues(currentZoom, currentProperties)); - typename Attributes::Bindings allAttributeBindings = gl::Attributes<CollisionBoxLayoutAttributes>::bindings(layoutVertexBuffer) - .concat(gl::Attributes<CollisionBoxDynamicAttributes>::bindings(dynamicVertexBuffer)) + AttributeBindings allAttributeBindings = gfx::AttributeBindings<CollisionBoxLayoutAttributes>(layoutVertexBuffer) + .concat(gfx::AttributeBindings<CollisionBoxDynamicAttributes>(dynamicVertexBuffer)) .concat(paintPropertyBinders.attributeBindings(currentProperties)); assert(layoutVertexBuffer.elements == dynamicVertexBuffer.elements); for (auto& segment : segments) { - auto vertexArrayIt = segment.vertexArrays.find(layerID); + auto drawScopeIt = segment.drawScopes.find(layerID); - if (vertexArrayIt == segment.vertexArrays.end()) { - vertexArrayIt = segment.vertexArrays.emplace(layerID, context.createVertexArray()).first; + if (drawScopeIt == segment.drawScopes.end()) { + drawScopeIt = segment.drawScopes.emplace(layerID, context.createDrawScope()).first; } - program.draw( + program->draw( context, std::move(drawMode), std::move(depthMode), std::move(stencilMode), std::move(colorMode), std::move(cullFaceMode), - allUniformValues, - vertexArrayIt->second, - Attributes::offsetBindings(allAttributeBindings, segment.vertexOffset), + uniformValues, + drawScopeIt->second, + allAttributeBindings.offset(segment.vertexOffset), textureBindings, indexBuffer, segment.indexOffset, @@ -114,8 +112,8 @@ public: class CollisionCircleProgram : public Program< - shaders::collision_circle, - gfx::Triangle, + CollisionCircleProgram, + gfx::PrimitiveType::Triangle, TypeListConcat<CollisionBoxLayoutAttributes, CollisionBoxDynamicAttributes>, TypeList< uniforms::u_matrix, @@ -150,46 +148,46 @@ public: } template <class DrawMode> - void draw(gl::Context& context, - DrawMode drawMode, - gfx::DepthMode depthMode, - gfx::StencilMode stencilMode, - gfx::ColorMode colorMode, - gfx::CullFaceMode cullFaceMode, - const UniformValues& uniformValues, + void draw(gfx::Context& context, + const DrawMode& drawMode, + const gfx::DepthMode& depthMode, + const gfx::StencilMode& stencilMode, + const gfx::ColorMode& colorMode, + const gfx::CullFaceMode& cullFaceMode, + const LayoutUniformValues& layoutUniformValues, const gfx::VertexBuffer<gfx::Vertex<CollisionBoxLayoutAttributes>>& layoutVertexBuffer, const gfx::VertexBuffer<gfx::Vertex<CollisionBoxDynamicAttributes>>& dynamicVertexBuffer, const gfx::IndexBuffer& indexBuffer, - const SegmentVector<Attributes>& segments, + const SegmentVector<AttributeList>& segments, const Binders& paintPropertyBinders, const typename PaintProperties::PossiblyEvaluated& currentProperties, const TextureBindings& textureBindings, float currentZoom, const std::string& layerID) { - typename AllUniforms::Values allUniformValues = uniformValues + UniformValues uniformValues = layoutUniformValues .concat(paintPropertyBinders.uniformValues(currentZoom, currentProperties)); - typename Attributes::Bindings allAttributeBindings = gl::Attributes<CollisionBoxLayoutAttributes>::bindings(layoutVertexBuffer) - .concat(gl::Attributes<CollisionBoxDynamicAttributes>::bindings(dynamicVertexBuffer)) + AttributeBindings allAttributeBindings = gfx::AttributeBindings<CollisionBoxLayoutAttributes>(layoutVertexBuffer) + .concat(gfx::AttributeBindings<CollisionBoxDynamicAttributes>(dynamicVertexBuffer)) .concat(paintPropertyBinders.attributeBindings(currentProperties)); for (auto& segment : segments) { - auto vertexArrayIt = segment.vertexArrays.find(layerID); + auto drawScopeIt = segment.drawScopes.find(layerID); - if (vertexArrayIt == segment.vertexArrays.end()) { - vertexArrayIt = segment.vertexArrays.emplace(layerID, context.createVertexArray()).first; + if (drawScopeIt == segment.drawScopes.end()) { + drawScopeIt = segment.drawScopes.emplace(layerID, context.createDrawScope()).first; } - program.draw( + program->draw( context, std::move(drawMode), std::move(depthMode), std::move(stencilMode), std::move(colorMode), std::move(cullFaceMode), - allUniformValues, - vertexArrayIt->second, - Attributes::offsetBindings(allAttributeBindings, segment.vertexOffset), + uniformValues, + drawScopeIt->second, + allAttributeBindings.offset(segment.vertexOffset), textureBindings, indexBuffer, segment.indexOffset, diff --git a/src/mbgl/programs/collision_circle_program.hpp b/src/mbgl/programs/collision_circle_program.hpp new file mode 100644 index 0000000000..1fd36af360 --- /dev/null +++ b/src/mbgl/programs/collision_circle_program.hpp @@ -0,0 +1,4 @@ +#pragma once + +// Alias +#include <mbgl/programs/collision_box_program.hpp> diff --git a/src/mbgl/programs/debug_program.cpp b/src/mbgl/programs/debug_program.cpp new file mode 100644 index 0000000000..9b8df789e4 --- /dev/null +++ b/src/mbgl/programs/debug_program.cpp @@ -0,0 +1,8 @@ +#include <mbgl/programs/debug_program.hpp> +#include <mbgl/gfx/context_impl.hpp> + +namespace mbgl { + +template std::unique_ptr<gfx::Program<DebugProgram>> gfx::Context::createProgram(const ProgramParameters&); + +} // namespace mbgl diff --git a/src/mbgl/programs/debug_program.hpp b/src/mbgl/programs/debug_program.hpp index 7fdfc84cc0..61125b55bf 100644 --- a/src/mbgl/programs/debug_program.hpp +++ b/src/mbgl/programs/debug_program.hpp @@ -3,14 +3,13 @@ #include <mbgl/programs/program.hpp> #include <mbgl/programs/attributes.hpp> #include <mbgl/programs/uniforms.hpp> -#include <mbgl/shaders/debug.hpp> #include <mbgl/style/properties.hpp> namespace mbgl { class DebugProgram : public Program< - shaders::debug, - gfx::Line, + DebugProgram, + gfx::PrimitiveType::Line, TypeList< attributes::a_pos>, TypeList< @@ -24,6 +23,6 @@ public: }; using DebugLayoutVertex = DebugProgram::LayoutVertex; -using DebugAttributes = DebugProgram::Attributes; +using DebugAttributes = DebugProgram::AttributeList; } // namespace mbgl diff --git a/src/mbgl/programs/extrusion_texture_program.cpp b/src/mbgl/programs/extrusion_texture_program.cpp index afda4384b7..50fcd76221 100644 --- a/src/mbgl/programs/extrusion_texture_program.cpp +++ b/src/mbgl/programs/extrusion_texture_program.cpp @@ -1,7 +1,10 @@ #include <mbgl/programs/extrusion_texture_program.hpp> +#include <mbgl/gfx/context_impl.hpp> namespace mbgl { +template std::unique_ptr<gfx::Program<ExtrusionTextureProgram>> gfx::Context::createProgram(const ProgramParameters&); + static_assert(sizeof(ExtrusionTextureLayoutVertex) == 4, "expected ExtrusionTextureLayoutVertex size"); } // namespace mbgl diff --git a/src/mbgl/programs/extrusion_texture_program.hpp b/src/mbgl/programs/extrusion_texture_program.hpp index 8281037b2a..bdeeabb8cd 100644 --- a/src/mbgl/programs/extrusion_texture_program.hpp +++ b/src/mbgl/programs/extrusion_texture_program.hpp @@ -4,15 +4,14 @@ #include <mbgl/programs/attributes.hpp> #include <mbgl/programs/uniforms.hpp> #include <mbgl/programs/textures.hpp> -#include <mbgl/shaders/extrusion_texture.hpp> #include <mbgl/style/properties.hpp> #include <mbgl/util/geometry.hpp> namespace mbgl { class ExtrusionTextureProgram : public Program< - shaders::extrusion_texture, - gfx::Triangle, + ExtrusionTextureProgram, + gfx::PrimitiveType::Triangle, TypeList<attributes::a_pos>, TypeList< uniforms::u_matrix, @@ -35,6 +34,6 @@ public: }; using ExtrusionTextureLayoutVertex = ExtrusionTextureProgram::LayoutVertex; -using ExtrusionTextureAttributes = ExtrusionTextureProgram::Attributes; +using ExtrusionTextureAttributes = ExtrusionTextureProgram::AttributeList; } // namespace mbgl diff --git a/src/mbgl/programs/fill_extrusion_pattern_program.hpp b/src/mbgl/programs/fill_extrusion_pattern_program.hpp new file mode 100644 index 0000000000..b723ce0614 --- /dev/null +++ b/src/mbgl/programs/fill_extrusion_pattern_program.hpp @@ -0,0 +1,4 @@ +#pragma once + +// Alias +#include <mbgl/programs/fill_extrusion_program.hpp> diff --git a/src/mbgl/programs/fill_extrusion_program.cpp b/src/mbgl/programs/fill_extrusion_program.cpp index fb9c9f7b4a..7688d09299 100644 --- a/src/mbgl/programs/fill_extrusion_program.cpp +++ b/src/mbgl/programs/fill_extrusion_program.cpp @@ -1,4 +1,5 @@ #include <mbgl/programs/fill_extrusion_program.hpp> +#include <mbgl/gfx/context_impl.hpp> #include <mbgl/renderer/image_atlas.hpp> #include <mbgl/renderer/cross_faded_property_evaluator.hpp> #include <mbgl/tile/tile_id.hpp> @@ -7,6 +8,9 @@ namespace mbgl { +template std::unique_ptr<gfx::Program<FillExtrusionProgram>> gfx::Context::createProgram(const ProgramParameters&); +template std::unique_ptr<gfx::Program<FillExtrusionPatternProgram>> gfx::Context::createProgram(const ProgramParameters&); + using namespace style; static_assert(sizeof(FillExtrusionLayoutVertex) == 12, "expected FillExtrusionLayoutVertex size"); @@ -31,10 +35,8 @@ float lightIntensity(const EvaluatedLight& light) { return light.get<LightIntensity>(); } -FillExtrusionProgram::UniformValues -FillExtrusionProgram::uniformValues(mat4 matrix, - const TransformState& state, - const EvaluatedLight& light) { +FillExtrusionProgram::LayoutUniformValues FillExtrusionProgram::layoutUniformValues( + mat4 matrix, const TransformState& state, const EvaluatedLight& light) { return { uniforms::u_matrix::Value( matrix ), uniforms::u_lightcolor::Value( lightColor(light) ), @@ -43,8 +45,8 @@ FillExtrusionProgram::uniformValues(mat4 matrix, }; } -FillExtrusionPatternProgram::UniformValues -FillExtrusionPatternProgram::uniformValues(mat4 matrix, +FillExtrusionPatternProgram::LayoutUniformValues +FillExtrusionPatternProgram::layoutUniformValues(mat4 matrix, Size atlasSize, const CrossfadeParameters& crossfade, const UnwrappedTileID& tileID, diff --git a/src/mbgl/programs/fill_extrusion_program.hpp b/src/mbgl/programs/fill_extrusion_program.hpp index 0723770143..e1c3ca7f17 100644 --- a/src/mbgl/programs/fill_extrusion_program.hpp +++ b/src/mbgl/programs/fill_extrusion_program.hpp @@ -5,8 +5,6 @@ #include <mbgl/programs/extrusion_texture_program.hpp> #include <mbgl/programs/uniforms.hpp> #include <mbgl/programs/textures.hpp> -#include <mbgl/shaders/fill_extrusion.hpp> -#include <mbgl/shaders/fill_extrusion_pattern.hpp> #include <mbgl/util/geometry.hpp> #include <mbgl/util/mat4.hpp> #include <mbgl/util/size.hpp> @@ -53,8 +51,8 @@ using FillExtrusionPatternUniforms = TypeList< uniforms::u_lightintensity>; class FillExtrusionProgram : public Program< - shaders::fill_extrusion, - gfx::Triangle, + FillExtrusionProgram, + gfx::PrimitiveType::Triangle, FillExtrusionLayoutAttributes, FillExtrusionUniforms, TypeList<>, @@ -83,15 +81,13 @@ public: }; } - static UniformValues uniformValues(mat4, - const TransformState&, - const EvaluatedLight&); - + static LayoutUniformValues + layoutUniformValues(mat4, const TransformState&, const EvaluatedLight&); }; class FillExtrusionPatternProgram : public Program< - shaders::fill_extrusion_pattern, - gfx::Triangle, + FillExtrusionPatternProgram, + gfx::PrimitiveType::Triangle, FillExtrusionLayoutAttributes, FillExtrusionPatternUniforms, TypeList< @@ -101,23 +97,23 @@ class FillExtrusionPatternProgram : public Program< public: using Program::Program; - static UniformValues uniformValues(mat4, - Size atlasSize, - const CrossfadeParameters&, - const UnwrappedTileID&, - const TransformState&, - const float heightFactor, - const float pixelRatio, - const EvaluatedLight&); + static LayoutUniformValues layoutUniformValues(mat4, + Size atlasSize, + const CrossfadeParameters&, + const UnwrappedTileID&, + const TransformState&, + const float heightFactor, + const float pixelRatio, + const EvaluatedLight&); }; using FillExtrusionLayoutVertex = FillExtrusionProgram::LayoutVertex; -using FillExtrusionAttributes = FillExtrusionProgram::Attributes; +using FillExtrusionAttributes = FillExtrusionProgram::AttributeList; class FillExtrusionLayerPrograms final : public LayerTypePrograms { public: - FillExtrusionLayerPrograms(gl::Context& context, const ProgramParameters& programParameters) + FillExtrusionLayerPrograms(gfx::Context& context, const ProgramParameters& programParameters) : fillExtrusion(context, programParameters), fillExtrusionPattern(context, programParameters), extrusionTexture(context, programParameters) {} diff --git a/src/mbgl/programs/fill_outline_pattern_program.hpp b/src/mbgl/programs/fill_outline_pattern_program.hpp new file mode 100644 index 0000000000..a2c26a168d --- /dev/null +++ b/src/mbgl/programs/fill_outline_pattern_program.hpp @@ -0,0 +1,4 @@ +#pragma once + +// Alias +#include <mbgl/programs/fill_program.hpp> diff --git a/src/mbgl/programs/fill_outline_program.hpp b/src/mbgl/programs/fill_outline_program.hpp new file mode 100644 index 0000000000..a2c26a168d --- /dev/null +++ b/src/mbgl/programs/fill_outline_program.hpp @@ -0,0 +1,4 @@ +#pragma once + +// Alias +#include <mbgl/programs/fill_program.hpp> diff --git a/src/mbgl/programs/fill_pattern_program.hpp b/src/mbgl/programs/fill_pattern_program.hpp new file mode 100644 index 0000000000..a2c26a168d --- /dev/null +++ b/src/mbgl/programs/fill_pattern_program.hpp @@ -0,0 +1,4 @@ +#pragma once + +// Alias +#include <mbgl/programs/fill_program.hpp> diff --git a/src/mbgl/programs/fill_program.cpp b/src/mbgl/programs/fill_program.cpp index 2c290dd15d..e0dfc71f81 100644 --- a/src/mbgl/programs/fill_program.cpp +++ b/src/mbgl/programs/fill_program.cpp @@ -1,4 +1,5 @@ #include <mbgl/programs/fill_program.hpp> +#include <mbgl/gfx/context_impl.hpp> #include <mbgl/renderer/image_atlas.hpp> #include <mbgl/renderer/cross_faded_property_evaluator.hpp> #include <mbgl/tile/tile_id.hpp> @@ -6,19 +7,23 @@ namespace mbgl { +template std::unique_ptr<gfx::Program<FillProgram>> gfx::Context::createProgram(const ProgramParameters&); +template std::unique_ptr<gfx::Program<FillPatternProgram>> gfx::Context::createProgram(const ProgramParameters&); +template std::unique_ptr<gfx::Program<FillOutlineProgram>> gfx::Context::createProgram(const ProgramParameters&); +template std::unique_ptr<gfx::Program<FillOutlinePatternProgram>> gfx::Context::createProgram(const ProgramParameters&); + using namespace style; static_assert(sizeof(FillLayoutVertex) == 4, "expected FillLayoutVertex size"); -FillPatternProgram::UniformValues -FillPatternProgram::uniformValues(mat4 matrix, - Size framebufferSize, - Size atlasSize, - const CrossfadeParameters& crossfade, - const UnwrappedTileID& tileID, - const TransformState& state, - const float pixelRatio) -{ +FillPatternProgram::LayoutUniformValues +FillPatternProgram::layoutUniformValues(mat4 matrix, + Size framebufferSize, + Size atlasSize, + const CrossfadeParameters& crossfade, + const UnwrappedTileID& tileID, + const TransformState& state, + const float pixelRatio) { const auto tileRatio = 1 / tileID.pixelsToTileUnits(1, state.getIntegerZoom()); int32_t tileSizeAtNearestZoom = util::tileSize * state.zoomScale(state.getIntegerZoom() - tileID.canonical.z); int32_t pixelX = tileSizeAtNearestZoom * (tileID.canonical.x + tileID.wrap * state.zoomScale(tileID.canonical.z)); diff --git a/src/mbgl/programs/fill_program.hpp b/src/mbgl/programs/fill_program.hpp index 5c0fbdcb62..8519e482d6 100644 --- a/src/mbgl/programs/fill_program.hpp +++ b/src/mbgl/programs/fill_program.hpp @@ -4,10 +4,6 @@ #include <mbgl/programs/attributes.hpp> #include <mbgl/programs/uniforms.hpp> #include <mbgl/programs/textures.hpp> -#include <mbgl/shaders/fill.hpp> -#include <mbgl/shaders/fill_pattern.hpp> -#include <mbgl/shaders/fill_outline.hpp> -#include <mbgl/shaders/fill_outline_pattern.hpp> #include <mbgl/util/geometry.hpp> #include <mbgl/util/mat4.hpp> #include <mbgl/util/size.hpp> @@ -38,8 +34,8 @@ using FillPatternUniforms = TypeList< uniforms::u_pixel_coord_lower>; class FillProgram : public Program< - shaders::fill, - gfx::Triangle, + FillProgram, + gfx::PrimitiveType::Triangle, FillLayoutAttributes, FillUniforms, TypeList<>, @@ -59,8 +55,8 @@ public: }; class FillPatternProgram : public Program< - shaders::fill_pattern, - gfx::Triangle, + FillPatternProgram, + gfx::PrimitiveType::Triangle, FillLayoutAttributes, FillPatternUniforms, TypeList< @@ -70,18 +66,18 @@ class FillPatternProgram : public Program< public: using Program::Program; - static UniformValues uniformValues(mat4 matrix, - Size framebufferSize, - Size atlasSize, - const CrossfadeParameters& crossfade, - const UnwrappedTileID&, - const TransformState&, - const float pixelRatio); + static LayoutUniformValues layoutUniformValues(mat4 matrix, + Size framebufferSize, + Size atlasSize, + const CrossfadeParameters& crossfade, + const UnwrappedTileID&, + const TransformState&, + const float pixelRatio); }; class FillOutlineProgram : public Program< - shaders::fill_outline, - gfx::Line, + FillOutlineProgram, + gfx::PrimitiveType::Line, FillLayoutAttributes, FillUniforms, TypeList<>, @@ -92,8 +88,8 @@ public: }; class FillOutlinePatternProgram : public Program< - shaders::fill_outline_pattern, - gfx::Line, + FillOutlinePatternProgram, + gfx::PrimitiveType::Line, FillLayoutAttributes, FillPatternUniforms, TypeList< @@ -105,11 +101,11 @@ public: }; using FillLayoutVertex = FillProgram::LayoutVertex; -using FillAttributes = FillProgram::Attributes; +using FillAttributes = FillProgram::AttributeList; class FillLayerPrograms final : public LayerTypePrograms { public: - FillLayerPrograms(gl::Context& context, const ProgramParameters& programParameters) + FillLayerPrograms(gfx::Context& context, const ProgramParameters& programParameters) : fill(context, programParameters), fillPattern(context, programParameters), fillOutline(context, programParameters), diff --git a/src/mbgl/programs/gl/background.cpp b/src/mbgl/programs/gl/background.cpp new file mode 100644 index 0000000000..da5ea25410 --- /dev/null +++ b/src/mbgl/programs/gl/background.cpp @@ -0,0 +1,47 @@ +// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. + +#include <mbgl/programs/background_program.hpp> +#include <mbgl/programs/gl/shader_source.hpp> +#include <mbgl/gl/program.hpp> + +namespace mbgl { +namespace gfx { + +template <> +std::unique_ptr<Program<BackgroundProgram>> +Context::createProgram<gl::Context>(const ProgramParameters& programParameters) { + return gl::Program<BackgroundProgram>::createProgram( + reinterpret_cast<gl::Context&>(*this), programParameters, "background", + programs::gl::shaderSource() + 1429, programs::gl::shaderSource() + 1525); +} + +} // namespace gfx +} // namespace mbgl + +// Uncompressed source of background.vertex.glsl: +/* +attribute vec2 a_pos; + +uniform mat4 u_matrix; + +void main() { + gl_Position = u_matrix * vec4(a_pos, 0, 1); +} + +*/ + +// Uncompressed source of background.fragment.glsl: +/* +uniform vec4 u_color; +uniform float u_opacity; + +void main() { + gl_FragColor = u_color * u_opacity; + +#ifdef OVERDRAW_INSPECTOR + gl_FragColor = vec4(1.0); +#endif +} + +*/ + diff --git a/src/mbgl/shaders/background_pattern.cpp b/src/mbgl/programs/gl/background_pattern.cpp index 35023455ea..af5d87129e 100644 --- a/src/mbgl/shaders/background_pattern.cpp +++ b/src/mbgl/programs/gl/background_pattern.cpp @@ -1,14 +1,22 @@ // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. -#include <mbgl/shaders/background_pattern.hpp> -#include <mbgl/shaders/source.hpp> +#include <mbgl/programs/background_pattern_program.hpp> +#include <mbgl/programs/gl/shader_source.hpp> +#include <mbgl/gl/program.hpp> namespace mbgl { -namespace shaders { +namespace gfx { + +template <> +std::unique_ptr<Program<BackgroundPatternProgram>> +Context::createProgram<gl::Context>(const ProgramParameters& programParameters) { + return gl::Program<BackgroundPatternProgram>::createProgram( + reinterpret_cast<gl::Context&>(*this), programParameters, "background_pattern", + programs::gl::shaderSource() + 1675, programs::gl::shaderSource() + 2266); +} -const char* background_pattern::name = "background_pattern"; -const char* background_pattern::vertexSource = source() + 1675; -const char* background_pattern::fragmentSource = source() + 2266; +} // namespace gfx +} // namespace mbgl // Uncompressed source of background_pattern.vertex.glsl: /* @@ -68,5 +76,3 @@ void main() { */ -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/circle.cpp b/src/mbgl/programs/gl/circle.cpp index e5da9fb37e..04c3f60870 100644 --- a/src/mbgl/shaders/circle.cpp +++ b/src/mbgl/programs/gl/circle.cpp @@ -1,14 +1,22 @@ // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. -#include <mbgl/shaders/circle.hpp> -#include <mbgl/shaders/source.hpp> +#include <mbgl/programs/circle_program.hpp> +#include <mbgl/programs/gl/shader_source.hpp> +#include <mbgl/gl/program.hpp> namespace mbgl { -namespace shaders { +namespace gfx { + +template <> +std::unique_ptr<Program<CircleProgram>> +Context::createProgram<gl::Context>(const ProgramParameters& programParameters) { + return gl::Program<CircleProgram>::createProgram( + reinterpret_cast<gl::Context&>(*this), programParameters, "circle", + programs::gl::shaderSource() + 2927, programs::gl::shaderSource() + 6093); +} -const char* circle::name = "circle"; -const char* circle::vertexSource = source() + 2927; -const char* circle::fragmentSource = source() + 6093; +} // namespace gfx +} // namespace mbgl // Uncompressed source of circle.vertex.glsl: /* @@ -290,5 +298,3 @@ void main() { */ -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/programs/gl/clipping_mask.cpp b/src/mbgl/programs/gl/clipping_mask.cpp new file mode 100644 index 0000000000..311877f065 --- /dev/null +++ b/src/mbgl/programs/gl/clipping_mask.cpp @@ -0,0 +1,40 @@ +// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. + +#include <mbgl/programs/clipping_mask_program.hpp> +#include <mbgl/programs/gl/shader_source.hpp> +#include <mbgl/gl/program.hpp> + +namespace mbgl { +namespace gfx { + +template <> +std::unique_ptr<Program<ClippingMaskProgram>> +Context::createProgram<gl::Context>(const ProgramParameters& programParameters) { + return gl::Program<ClippingMaskProgram>::createProgram( + reinterpret_cast<gl::Context&>(*this), programParameters, "clipping_mask", + programs::gl::shaderSource() + 7848, programs::gl::shaderSource() + 7944); +} + +} // namespace gfx +} // namespace mbgl + +// Uncompressed source of clipping_mask.vertex.glsl: +/* +attribute vec2 a_pos; + +uniform mat4 u_matrix; + +void main() { + gl_Position = u_matrix * vec4(a_pos, 0, 1); +} + +*/ + +// Uncompressed source of clipping_mask.fragment.glsl: +/* +void main() { + gl_FragColor = vec4(1.0); +} + +*/ + diff --git a/src/mbgl/shaders/collision_box.cpp b/src/mbgl/programs/gl/collision_box.cpp index b016d48cc8..9af67f7981 100644 --- a/src/mbgl/shaders/collision_box.cpp +++ b/src/mbgl/programs/gl/collision_box.cpp @@ -1,14 +1,22 @@ // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. -#include <mbgl/shaders/collision_box.hpp> -#include <mbgl/shaders/source.hpp> +#include <mbgl/programs/collision_box_program.hpp> +#include <mbgl/programs/gl/shader_source.hpp> +#include <mbgl/gl/program.hpp> namespace mbgl { -namespace shaders { +namespace gfx { + +template <> +std::unique_ptr<Program<CollisionBoxProgram>> +Context::createProgram<gl::Context>(const ProgramParameters& programParameters) { + return gl::Program<CollisionBoxProgram>::createProgram( + reinterpret_cast<gl::Context&>(*this), programParameters, "collision_box", + programs::gl::shaderSource() + 9956, programs::gl::shaderSource() + 10635); +} -const char* collision_box::name = "collision_box"; -const char* collision_box::vertexSource = source() + 9956; -const char* collision_box::fragmentSource = source() + 10635; +} // namespace gfx +} // namespace mbgl // Uncompressed source of collision_box.vertex.glsl: /* @@ -67,5 +75,3 @@ void main() { } */ -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/collision_circle.cpp b/src/mbgl/programs/gl/collision_circle.cpp index 0700ecead5..843f9161bb 100644 --- a/src/mbgl/shaders/collision_circle.cpp +++ b/src/mbgl/programs/gl/collision_circle.cpp @@ -1,14 +1,22 @@ // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. -#include <mbgl/shaders/collision_circle.hpp> -#include <mbgl/shaders/source.hpp> +#include <mbgl/programs/collision_circle_program.hpp> +#include <mbgl/programs/gl/shader_source.hpp> +#include <mbgl/gl/program.hpp> namespace mbgl { -namespace shaders { +namespace gfx { + +template <> +std::unique_ptr<Program<CollisionCircleProgram>> +Context::createProgram<gl::Context>(const ProgramParameters& programParameters) { + return gl::Program<CollisionCircleProgram>::createProgram( + reinterpret_cast<gl::Context&>(*this), programParameters, "collision_circle", + programs::gl::shaderSource() + 10858, programs::gl::shaderSource() + 11774); +} -const char* collision_circle::name = "collision_circle"; -const char* collision_circle::vertexSource = source() + 10858; -const char* collision_circle::fragmentSource = source() + 11774; +} // namespace gfx +} // namespace mbgl // Uncompressed source of collision_circle.vertex.glsl: /* @@ -90,5 +98,3 @@ void main() { */ -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/programs/gl/debug.cpp b/src/mbgl/programs/gl/debug.cpp new file mode 100644 index 0000000000..8b7aee5a0b --- /dev/null +++ b/src/mbgl/programs/gl/debug.cpp @@ -0,0 +1,42 @@ +// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. + +#include <mbgl/programs/debug_program.hpp> +#include <mbgl/programs/gl/shader_source.hpp> +#include <mbgl/gl/program.hpp> + +namespace mbgl { +namespace gfx { + +template <> +std::unique_ptr<Program<DebugProgram>> +Context::createProgram<gl::Context>(const ProgramParameters& programParameters) { + return gl::Program<DebugProgram>::createProgram( + reinterpret_cast<gl::Context&>(*this), programParameters, "debug", + programs::gl::shaderSource() + 12450, programs::gl::shaderSource() + 12546); +} + +} // namespace gfx +} // namespace mbgl + +// Uncompressed source of debug.vertex.glsl: +/* +attribute vec2 a_pos; + +uniform mat4 u_matrix; + +void main() { + gl_Position = u_matrix * vec4(a_pos, 0, 1); +} + +*/ + +// Uncompressed source of debug.fragment.glsl: +/* +uniform highp vec4 u_color; + +void main() { + gl_FragColor = u_color; +} + +*/ + diff --git a/src/mbgl/shaders/extrusion_texture.cpp b/src/mbgl/programs/gl/extrusion_texture.cpp index c254413513..bd320d52cf 100644 --- a/src/mbgl/shaders/extrusion_texture.cpp +++ b/src/mbgl/programs/gl/extrusion_texture.cpp @@ -1,14 +1,22 @@ // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. -#include <mbgl/shaders/extrusion_texture.hpp> -#include <mbgl/shaders/source.hpp> +#include <mbgl/programs/extrusion_texture_program.hpp> +#include <mbgl/programs/gl/shader_source.hpp> +#include <mbgl/gl/program.hpp> namespace mbgl { -namespace shaders { +namespace gfx { + +template <> +std::unique_ptr<Program<ExtrusionTextureProgram>> +Context::createProgram<gl::Context>(const ProgramParameters& programParameters) { + return gl::Program<ExtrusionTextureProgram>::createProgram( + reinterpret_cast<gl::Context&>(*this), programParameters, "extrusion_texture", + programs::gl::shaderSource() + 27554, programs::gl::shaderSource() + 27734); +} -const char* extrusion_texture::name = "extrusion_texture"; -const char* extrusion_texture::vertexSource = source() + 27554; -const char* extrusion_texture::fragmentSource = source() + 27734; +} // namespace gfx +} // namespace mbgl // Uncompressed source of extrusion_texture.vertex.glsl: /* @@ -42,5 +50,3 @@ void main() { */ -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/fill.cpp b/src/mbgl/programs/gl/fill.cpp index 93d69f7e4b..c15c2774ab 100644 --- a/src/mbgl/shaders/fill.cpp +++ b/src/mbgl/programs/gl/fill.cpp @@ -1,14 +1,22 @@ // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. -#include <mbgl/shaders/fill.hpp> -#include <mbgl/shaders/source.hpp> +#include <mbgl/programs/fill_program.hpp> +#include <mbgl/programs/gl/shader_source.hpp> +#include <mbgl/gl/program.hpp> namespace mbgl { -namespace shaders { +namespace gfx { + +template <> +std::unique_ptr<Program<FillProgram>> +Context::createProgram<gl::Context>(const ProgramParameters& programParameters) { + return gl::Program<FillProgram>::createProgram( + reinterpret_cast<gl::Context&>(*this), programParameters, "fill", + programs::gl::shaderSource() + 12610, programs::gl::shaderSource() + 13254); +} -const char* fill::name = "fill"; -const char* fill::vertexSource = source() + 12610; -const char* fill::fragmentSource = source() + 13254; +} // namespace gfx +} // namespace mbgl // Uncompressed source of fill.vertex.glsl: /* @@ -94,5 +102,3 @@ void main() { */ -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/fill_extrusion.cpp b/src/mbgl/programs/gl/fill_extrusion.cpp index 79241afcc3..45ebb68dd4 100644 --- a/src/mbgl/shaders/fill_extrusion.cpp +++ b/src/mbgl/programs/gl/fill_extrusion.cpp @@ -1,14 +1,22 @@ // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. -#include <mbgl/shaders/fill_extrusion.hpp> -#include <mbgl/shaders/source.hpp> +#include <mbgl/programs/fill_extrusion_program.hpp> +#include <mbgl/programs/gl/shader_source.hpp> +#include <mbgl/gl/program.hpp> namespace mbgl { -namespace shaders { +namespace gfx { + +template <> +std::unique_ptr<Program<FillExtrusionProgram>> +Context::createProgram<gl::Context>(const ProgramParameters& programParameters) { + return gl::Program<FillExtrusionProgram>::createProgram( + reinterpret_cast<gl::Context&>(*this), programParameters, "fill_extrusion", + programs::gl::shaderSource() + 21238, programs::gl::shaderSource() + 23121); +} -const char* fill_extrusion::name = "fill_extrusion"; -const char* fill_extrusion::vertexSource = source() + 21238; -const char* fill_extrusion::fragmentSource = source() + 23121; +} // namespace gfx +} // namespace mbgl // Uncompressed source of fill_extrusion.vertex.glsl: /* @@ -132,5 +140,3 @@ void main() { */ -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/fill_extrusion_pattern.cpp b/src/mbgl/programs/gl/fill_extrusion_pattern.cpp index 8ac17828cf..9c2da87b11 100644 --- a/src/mbgl/shaders/fill_extrusion_pattern.cpp +++ b/src/mbgl/programs/gl/fill_extrusion_pattern.cpp @@ -1,14 +1,22 @@ // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. -#include <mbgl/shaders/fill_extrusion_pattern.hpp> -#include <mbgl/shaders/source.hpp> +#include <mbgl/programs/fill_extrusion_pattern_program.hpp> +#include <mbgl/programs/gl/shader_source.hpp> +#include <mbgl/gl/program.hpp> namespace mbgl { -namespace shaders { +namespace gfx { + +template <> +std::unique_ptr<Program<FillExtrusionPatternProgram>> +Context::createProgram<gl::Context>(const ProgramParameters& programParameters) { + return gl::Program<FillExtrusionPatternProgram>::createProgram( + reinterpret_cast<gl::Context&>(*this), programParameters, "fill_extrusion_pattern", + programs::gl::shaderSource() + 23237, programs::gl::shaderSource() + 26157); +} -const char* fill_extrusion_pattern::name = "fill_extrusion_pattern"; -const char* fill_extrusion_pattern::vertexSource = source() + 23237; -const char* fill_extrusion_pattern::fragmentSource = source() + 26157; +} // namespace gfx +} // namespace mbgl // Uncompressed source of fill_extrusion_pattern.vertex.glsl: /* @@ -231,5 +239,3 @@ void main() { */ -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/fill_outline.cpp b/src/mbgl/programs/gl/fill_outline.cpp index 43d92857d5..07615b2138 100644 --- a/src/mbgl/shaders/fill_outline.cpp +++ b/src/mbgl/programs/gl/fill_outline.cpp @@ -1,14 +1,22 @@ // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. -#include <mbgl/shaders/fill_outline.hpp> -#include <mbgl/shaders/source.hpp> +#include <mbgl/programs/fill_outline_program.hpp> +#include <mbgl/programs/gl/shader_source.hpp> +#include <mbgl/gl/program.hpp> namespace mbgl { -namespace shaders { +namespace gfx { + +template <> +std::unique_ptr<Program<FillOutlineProgram>> +Context::createProgram<gl::Context>(const ProgramParameters& programParameters) { + return gl::Program<FillOutlineProgram>::createProgram( + reinterpret_cast<gl::Context&>(*this), programParameters, "fill_outline", + programs::gl::shaderSource() + 13678, programs::gl::shaderSource() + 14503); +} -const char* fill_outline::name = "fill_outline"; -const char* fill_outline::vertexSource = source() + 13678; -const char* fill_outline::fragmentSource = source() + 14503; +} // namespace gfx +} // namespace mbgl // Uncompressed source of fill_outline.vertex.glsl: /* @@ -102,5 +110,3 @@ void main() { */ -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/fill_outline_pattern.cpp b/src/mbgl/programs/gl/fill_outline_pattern.cpp index eeb2177582..7e0bf19655 100644 --- a/src/mbgl/shaders/fill_outline_pattern.cpp +++ b/src/mbgl/programs/gl/fill_outline_pattern.cpp @@ -1,14 +1,22 @@ // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. -#include <mbgl/shaders/fill_outline_pattern.hpp> -#include <mbgl/shaders/source.hpp> +#include <mbgl/programs/fill_outline_pattern_program.hpp> +#include <mbgl/programs/gl/shader_source.hpp> +#include <mbgl/gl/program.hpp> namespace mbgl { -namespace shaders { +namespace gfx { + +template <> +std::unique_ptr<Program<FillOutlinePatternProgram>> +Context::createProgram<gl::Context>(const ProgramParameters& programParameters) { + return gl::Program<FillOutlinePatternProgram>::createProgram( + reinterpret_cast<gl::Context&>(*this), programParameters, "fill_outline_pattern", + programs::gl::shaderSource() + 15092, programs::gl::shaderSource() + 16952); +} -const char* fill_outline_pattern::name = "fill_outline_pattern"; -const char* fill_outline_pattern::vertexSource = source() + 15092; -const char* fill_outline_pattern::fragmentSource = source() + 16952; +} // namespace gfx +} // namespace mbgl // Uncompressed source of fill_outline_pattern.vertex.glsl: /* @@ -176,5 +184,3 @@ void main() { */ -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/fill_pattern.cpp b/src/mbgl/programs/gl/fill_pattern.cpp index d062ae7ecc..256b1ede99 100644 --- a/src/mbgl/shaders/fill_pattern.cpp +++ b/src/mbgl/programs/gl/fill_pattern.cpp @@ -1,14 +1,22 @@ // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. -#include <mbgl/shaders/fill_pattern.hpp> -#include <mbgl/shaders/source.hpp> +#include <mbgl/programs/fill_pattern_program.hpp> +#include <mbgl/programs/gl/shader_source.hpp> +#include <mbgl/gl/program.hpp> namespace mbgl { -namespace shaders { +namespace gfx { + +template <> +std::unique_ptr<Program<FillPatternProgram>> +Context::createProgram<gl::Context>(const ProgramParameters& programParameters) { + return gl::Program<FillPatternProgram>::createProgram( + reinterpret_cast<gl::Context&>(*this), programParameters, "fill_pattern", + programs::gl::shaderSource() + 18259, programs::gl::shaderSource() + 20038); +} -const char* fill_pattern::name = "fill_pattern"; -const char* fill_pattern::vertexSource = source() + 18259; -const char* fill_pattern::fragmentSource = source() + 20038; +} // namespace gfx +} // namespace mbgl // Uncompressed source of fill_pattern.vertex.glsl: /* @@ -164,5 +172,3 @@ void main() { */ -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/heatmap.cpp b/src/mbgl/programs/gl/heatmap.cpp index a768a6d4ad..59f8ad9f69 100644 --- a/src/mbgl/shaders/heatmap.cpp +++ b/src/mbgl/programs/gl/heatmap.cpp @@ -1,14 +1,22 @@ // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. -#include <mbgl/shaders/heatmap.hpp> -#include <mbgl/shaders/source.hpp> +#include <mbgl/programs/heatmap_program.hpp> +#include <mbgl/programs/gl/shader_source.hpp> +#include <mbgl/gl/program.hpp> namespace mbgl { -namespace shaders { +namespace gfx { + +template <> +std::unique_ptr<Program<HeatmapProgram>> +Context::createProgram<gl::Context>(const ProgramParameters& programParameters) { + return gl::Program<HeatmapProgram>::createProgram( + reinterpret_cast<gl::Context&>(*this), programParameters, "heatmap", + programs::gl::shaderSource() + 7983, programs::gl::shaderSource() + 9030); +} -const char* heatmap::name = "heatmap"; -const char* heatmap::vertexSource = source() + 7983; -const char* heatmap::fragmentSource = source() + 9030; +} // namespace gfx +} // namespace mbgl // Uncompressed source of heatmap.vertex.glsl: /* @@ -131,5 +139,3 @@ void main() { */ -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/heatmap_texture.cpp b/src/mbgl/programs/gl/heatmap_texture.cpp index 9b881b416f..530e9fa18b 100644 --- a/src/mbgl/shaders/heatmap_texture.cpp +++ b/src/mbgl/programs/gl/heatmap_texture.cpp @@ -1,14 +1,22 @@ // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. -#include <mbgl/shaders/heatmap_texture.hpp> -#include <mbgl/shaders/source.hpp> +#include <mbgl/programs/heatmap_texture_program.hpp> +#include <mbgl/programs/gl/shader_source.hpp> +#include <mbgl/gl/program.hpp> namespace mbgl { -namespace shaders { +namespace gfx { + +template <> +std::unique_ptr<Program<HeatmapTextureProgram>> +Context::createProgram<gl::Context>(const ProgramParameters& programParameters) { + return gl::Program<HeatmapTextureProgram>::createProgram( + reinterpret_cast<gl::Context&>(*this), programParameters, "heatmap_texture", + programs::gl::shaderSource() + 9491, programs::gl::shaderSource() + 9671); +} -const char* heatmap_texture::name = "heatmap_texture"; -const char* heatmap_texture::vertexSource = source() + 9491; -const char* heatmap_texture::fragmentSource = source() + 9671; +} // namespace gfx +} // namespace mbgl // Uncompressed source of heatmap_texture.vertex.glsl: /* @@ -45,5 +53,3 @@ void main() { */ -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/hillshade.cpp b/src/mbgl/programs/gl/hillshade.cpp index 48ddabcba1..dcf90f1149 100644 --- a/src/mbgl/shaders/hillshade.cpp +++ b/src/mbgl/programs/gl/hillshade.cpp @@ -1,14 +1,22 @@ // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. -#include <mbgl/shaders/hillshade.hpp> -#include <mbgl/shaders/source.hpp> +#include <mbgl/programs/hillshade_program.hpp> +#include <mbgl/programs/gl/shader_source.hpp> +#include <mbgl/gl/program.hpp> namespace mbgl { -namespace shaders { +namespace gfx { + +template <> +std::unique_ptr<Program<HillshadeProgram>> +Context::createProgram<gl::Context>(const ProgramParameters& programParameters) { + return gl::Program<HillshadeProgram>::createProgram( + reinterpret_cast<gl::Context&>(*this), programParameters, "hillshade", + programs::gl::shaderSource() + 29340, programs::gl::shaderSource() + 29511); +} -const char* hillshade::name = "hillshade"; -const char* hillshade::vertexSource = source() + 29340; -const char* hillshade::fragmentSource = source() + 29511; +} // namespace gfx +} // namespace mbgl // Uncompressed source of hillshade.vertex.glsl: /* @@ -83,5 +91,3 @@ void main() { */ -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/hillshade_prepare.cpp b/src/mbgl/programs/gl/hillshade_prepare.cpp index 9517e1f489..b445713530 100644 --- a/src/mbgl/shaders/hillshade_prepare.cpp +++ b/src/mbgl/programs/gl/hillshade_prepare.cpp @@ -1,14 +1,22 @@ // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. -#include <mbgl/shaders/hillshade_prepare.hpp> -#include <mbgl/shaders/source.hpp> +#include <mbgl/programs/hillshade_prepare_program.hpp> +#include <mbgl/programs/gl/shader_source.hpp> +#include <mbgl/gl/program.hpp> namespace mbgl { -namespace shaders { +namespace gfx { + +template <> +std::unique_ptr<Program<HillshadePrepareProgram>> +Context::createProgram<gl::Context>(const ProgramParameters& programParameters) { + return gl::Program<HillshadePrepareProgram>::createProgram( + reinterpret_cast<gl::Context&>(*this), programParameters, "hillshade_prepare", + programs::gl::shaderSource() + 27925, programs::gl::shaderSource() + 28218); +} -const char* hillshade_prepare::name = "hillshade_prepare"; -const char* hillshade_prepare::vertexSource = source() + 27925; -const char* hillshade_prepare::fragmentSource = source() + 28218; +} // namespace gfx +} // namespace mbgl // Uncompressed source of hillshade_prepare.vertex.glsl: /* @@ -107,5 +115,3 @@ void main() { */ -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/line.cpp b/src/mbgl/programs/gl/line.cpp index a7f2a6d439..c25679ae1f 100644 --- a/src/mbgl/shaders/line.cpp +++ b/src/mbgl/programs/gl/line.cpp @@ -1,14 +1,22 @@ // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. -#include <mbgl/shaders/line.hpp> -#include <mbgl/shaders/source.hpp> +#include <mbgl/programs/line_program.hpp> +#include <mbgl/programs/gl/shader_source.hpp> +#include <mbgl/gl/program.hpp> namespace mbgl { -namespace shaders { +namespace gfx { + +template <> +std::unique_ptr<Program<LineProgram>> +Context::createProgram<gl::Context>(const ProgramParameters& programParameters) { + return gl::Program<LineProgram>::createProgram( + reinterpret_cast<gl::Context&>(*this), programParameters, "line", + programs::gl::shaderSource() + 30585, programs::gl::shaderSource() + 33509); +} -const char* line::name = "line"; -const char* line::vertexSource = source() + 30585; -const char* line::fragmentSource = source() + 33509; +} // namespace gfx +} // namespace mbgl // Uncompressed source of line.vertex.glsl: /* @@ -243,5 +251,3 @@ void main() { */ -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/line_gradient.cpp b/src/mbgl/programs/gl/line_gradient.cpp index d9ce2af7b1..fae94b4596 100644 --- a/src/mbgl/shaders/line_gradient.cpp +++ b/src/mbgl/programs/gl/line_gradient.cpp @@ -1,14 +1,22 @@ // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. -#include <mbgl/shaders/line_gradient.hpp> -#include <mbgl/shaders/source.hpp> +#include <mbgl/programs/line_gradient_program.hpp> +#include <mbgl/programs/gl/shader_source.hpp> +#include <mbgl/gl/program.hpp> namespace mbgl { -namespace shaders { +namespace gfx { + +template <> +std::unique_ptr<Program<LineGradientProgram>> +Context::createProgram<gl::Context>(const ProgramParameters& programParameters) { + return gl::Program<LineGradientProgram>::createProgram( + reinterpret_cast<gl::Context&>(*this), programParameters, "line_gradient", + programs::gl::shaderSource() + 34335, programs::gl::shaderSource() + 37054); +} -const char* line_gradient::name = "line_gradient"; -const char* line_gradient::vertexSource = source() + 34335; -const char* line_gradient::fragmentSource = source() + 37054; +} // namespace gfx +} // namespace mbgl // Uncompressed source of line_gradient.vertex.glsl: /* @@ -225,5 +233,3 @@ void main() { */ -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/line_pattern.cpp b/src/mbgl/programs/gl/line_pattern.cpp index 2c05c8c7ec..2e9ebaf5ea 100644 --- a/src/mbgl/shaders/line_pattern.cpp +++ b/src/mbgl/programs/gl/line_pattern.cpp @@ -1,14 +1,22 @@ // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. -#include <mbgl/shaders/line_pattern.hpp> -#include <mbgl/shaders/source.hpp> +#include <mbgl/programs/line_pattern_program.hpp> +#include <mbgl/programs/gl/shader_source.hpp> +#include <mbgl/gl/program.hpp> namespace mbgl { -namespace shaders { +namespace gfx { + +template <> +std::unique_ptr<Program<LinePatternProgram>> +Context::createProgram<gl::Context>(const ProgramParameters& programParameters) { + return gl::Program<LinePatternProgram>::createProgram( + reinterpret_cast<gl::Context&>(*this), programParameters, "line_pattern", + programs::gl::shaderSource() + 37841, programs::gl::shaderSource() + 41162); +} -const char* line_pattern::name = "line_pattern"; -const char* line_pattern::vertexSource = source() + 37841; -const char* line_pattern::fragmentSource = source() + 41162; +} // namespace gfx +} // namespace mbgl // Uncompressed source of line_pattern.vertex.glsl: /* @@ -312,5 +320,3 @@ void main() { */ -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/line_sdf.cpp b/src/mbgl/programs/gl/line_sdf.cpp index 05695abd1b..0886bfcdf0 100644 --- a/src/mbgl/shaders/line_sdf.cpp +++ b/src/mbgl/programs/gl/line_sdf.cpp @@ -1,14 +1,22 @@ // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. -#include <mbgl/shaders/line_sdf.hpp> -#include <mbgl/shaders/source.hpp> +#include <mbgl/programs/line_sdf_program.hpp> +#include <mbgl/programs/gl/shader_source.hpp> +#include <mbgl/gl/program.hpp> namespace mbgl { -namespace shaders { +namespace gfx { + +template <> +std::unique_ptr<Program<LineSDFProgram>> +Context::createProgram<gl::Context>(const ProgramParameters& programParameters) { + return gl::Program<LineSDFProgram>::createProgram( + reinterpret_cast<gl::Context&>(*this), programParameters, "line_sdf", + programs::gl::shaderSource() + 43475, programs::gl::shaderSource() + 47089); +} -const char* line_sdf::name = "line_sdf"; -const char* line_sdf::vertexSource = source() + 43475; -const char* line_sdf::fragmentSource = source() + 47089; +} // namespace gfx +} // namespace mbgl // Uncompressed source of line_sdf.vertex.glsl: /* @@ -305,5 +313,3 @@ void main() { */ -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/programs/gl/preludes.cpp b/src/mbgl/programs/gl/preludes.cpp new file mode 100644 index 0000000000..6c895c0d36 --- /dev/null +++ b/src/mbgl/programs/gl/preludes.cpp @@ -0,0 +1,15 @@ +// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. + +#include <mbgl/programs/gl/preludes.hpp> +#include <mbgl/programs/gl/shader_source.hpp> + +namespace mbgl { +namespace programs { +namespace gl { + +const char* vertexShaderPrelude = programs::gl::shaderSource() + 0; +const char* fragmentShaderPrelude = programs::gl::shaderSource() + 1252; + +} // namespace gl +} // namespace programs +} // namespace mbgl diff --git a/src/mbgl/programs/gl/preludes.hpp b/src/mbgl/programs/gl/preludes.hpp new file mode 100644 index 0000000000..6d86ee45c5 --- /dev/null +++ b/src/mbgl/programs/gl/preludes.hpp @@ -0,0 +1,14 @@ +// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. + +#pragma once + +namespace mbgl { +namespace programs { +namespace gl { + +extern const char* vertexShaderPrelude; +extern const char* fragmentShaderPrelude; + +} // namespace gl +} // namespace programs +} // namespace mbgl diff --git a/src/mbgl/shaders/raster.cpp b/src/mbgl/programs/gl/raster.cpp index 9fcf995915..512dc81a30 100644 --- a/src/mbgl/shaders/raster.cpp +++ b/src/mbgl/programs/gl/raster.cpp @@ -1,14 +1,22 @@ // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. -#include <mbgl/shaders/raster.hpp> -#include <mbgl/shaders/source.hpp> +#include <mbgl/programs/raster_program.hpp> +#include <mbgl/programs/gl/shader_source.hpp> +#include <mbgl/gl/program.hpp> namespace mbgl { -namespace shaders { +namespace gfx { + +template <> +std::unique_ptr<Program<RasterProgram>> +Context::createProgram<gl::Context>(const ProgramParameters& programParameters) { + return gl::Program<RasterProgram>::createProgram( + reinterpret_cast<gl::Context&>(*this), programParameters, "raster", + programs::gl::shaderSource() + 48592, programs::gl::shaderSource() + 48941); +} -const char* raster::name = "raster"; -const char* raster::vertexSource = source() + 48592; -const char* raster::fragmentSource = source() + 48941; +} // namespace gfx +} // namespace mbgl // Uncompressed source of raster.vertex.glsl: /* @@ -93,5 +101,3 @@ void main() { */ -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/programs/gl/shader_source.cpp b/src/mbgl/programs/gl/shader_source.cpp new file mode 100644 index 0000000000..4a986403f7 --- /dev/null +++ b/src/mbgl/programs/gl/shader_source.cpp @@ -0,0 +1,471 @@ +// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. + +#include <mbgl/programs/gl/shader_source.hpp> +#include <mbgl/util/compression.hpp> + +#include <cstdint> + +namespace mbgl { +namespace programs { +namespace gl { + +constexpr const uint8_t compressedShaderSource[] = { + 0x78, 0xda, 0xed, 0x3d, 0xfd, 0x6f, 0xe3, 0x36, 0xb2, 0xf7, 0x73, 0xfe, 0x0a, 0x17, 0x05, 0x0e, + 0x92, 0x2c, 0x5b, 0xb6, 0x93, 0xec, 0x97, 0x4e, 0xaf, 0x08, 0x76, 0xb3, 0x7d, 0x01, 0xda, 0xdd, + 0x60, 0xd3, 0xf6, 0x15, 0x57, 0x2c, 0x0c, 0xc9, 0x56, 0x6c, 0xdf, 0xd9, 0x96, 0x9f, 0xad, 0x24, + 0x76, 0x0e, 0xf9, 0xdf, 0x1f, 0x87, 0xdf, 0xa4, 0x48, 0x59, 0x76, 0x12, 0xe7, 0xe3, 0x19, 0x45, + 0x37, 0x16, 0x39, 0x1c, 0x0e, 0xc9, 0xe1, 0x70, 0x66, 0x48, 0x0e, 0x7f, 0x1c, 0x5d, 0xf6, 0xd3, + 0xcb, 0xda, 0xcf, 0xbf, 0x74, 0x4f, 0x2f, 0x0e, 0x66, 0xf3, 0xb4, 0x37, 0x5a, 0x8c, 0xb2, 0x69, + 0x6d, 0x38, 0x1a, 0x0c, 0x67, 0xb5, 0xcb, 0x71, 0x16, 0xe7, 0xe1, 0xc1, 0x8f, 0xe9, 0x78, 0x91, + 0x1e, 0xfc, 0x38, 0xba, 0xac, 0xfd, 0x80, 0x60, 0x47, 0xd3, 0xb4, 0xef, 0x8c, 0xb3, 0x9b, 0x99, + 0x7b, 0xf0, 0x23, 0xf9, 0xac, 0xc1, 0x17, 0x82, 0x9a, 0xf6, 0x47, 0x97, 0x2a, 0xd8, 0x24, 0xed, + 0x8f, 0xae, 0x26, 0x12, 0x24, 0x4d, 0x30, 0x02, 0xe3, 0x3a, 0x05, 0x28, 0xfe, 0xe4, 0x80, 0xe4, + 0xcf, 0x75, 0xda, 0xeb, 0xd4, 0xae, 0xa6, 0xb3, 0xb8, 0xf7, 0xef, 0x2e, 0x26, 0xce, 0xe9, 0x65, + 0xd3, 0x45, 0x4e, 0x08, 0xad, 0x41, 0x72, 0xda, 0xff, 0x23, 0x1e, 0x5f, 0xa5, 0x6e, 0xed, 0x3f, + 0xa3, 0x29, 0x4b, 0x39, 0x9b, 0xe6, 0x38, 0x31, 0x42, 0x49, 0x8e, 0x0c, 0x14, 0x02, 0xcc, 0x75, + 0x2b, 0x52, 0xc1, 0x82, 0xce, 0xf1, 0x9b, 0x70, 0x9e, 0xe6, 0x57, 0xf3, 0x69, 0x0d, 0x2a, 0x74, + 0xae, 0x5b, 0xbe, 0x0a, 0xd1, 0xb8, 0x6e, 0x79, 0x08, 0xc8, 0x0d, 0xef, 0x64, 0x82, 0x32, 0xf4, + 0xef, 0x28, 0x5f, 0x19, 0x48, 0xfa, 0x4a, 0x72, 0x28, 0x51, 0xe8, 0x7f, 0x9a, 0x20, 0x11, 0xc4, + 0x40, 0x82, 0x8e, 0x52, 0x35, 0x69, 0xa4, 0x28, 0xe1, 0x06, 0xed, 0xce, 0xdb, 0x66, 0xcb, 0x9f, + 0x64, 0x7d, 0xb5, 0xa0, 0xdf, 0x69, 0xb6, 0x5c, 0x42, 0xd0, 0x51, 0xad, 0x9f, 0xf6, 0xb2, 0x7e, + 0xda, 0xed, 0x65, 0xe3, 0x6c, 0x4e, 0xc9, 0xc1, 0x84, 0xa6, 0x53, 0x48, 0xef, 0x7f, 0x84, 0x74, + 0x44, 0x8c, 0xa8, 0xe8, 0xc8, 0x51, 0x3a, 0x55, 0x86, 0xfb, 0xab, 0xf5, 0x1d, 0x11, 0x75, 0x7c, + 0x8c, 0x2a, 0xb5, 0xc3, 0xb4, 0x19, 0xcc, 0x01, 0x22, 0x81, 0xb4, 0x9c, 0x02, 0x4f, 0x46, 0xcb, + 0x2e, 0x6e, 0x89, 0x44, 0x86, 0x34, 0x04, 0xbe, 0xdc, 0x59, 0xb9, 0xa0, 0x09, 0x15, 0x93, 0x47, + 0x0a, 0x11, 0xe1, 0xcb, 0x9f, 0xed, 0xef, 0x7e, 0xce, 0x1a, 0x2b, 0x55, 0xa4, 0x35, 0xf8, 0x88, + 0xd6, 0x84, 0x69, 0x5c, 0x14, 0xaa, 0xc2, 0x10, 0x93, 0xd1, 0x14, 0x67, 0x47, 0x4a, 0x9f, 0x61, + 0x8a, 0xe5, 0xc2, 0x82, 0x00, 0xfa, 0x8d, 0x5a, 0xec, 0x86, 0x04, 0x43, 0xbc, 0xac, 0x84, 0xa1, + 0xa3, 0x61, 0x38, 0x04, 0x0c, 0x52, 0x73, 0x19, 0x25, 0x3e, 0x43, 0xc8, 0x9a, 0xd8, 0xa9, 0x0d, + 0xd2, 0xbc, 0x3b, 0x8b, 0xf3, 0x3c, 0x9d, 0x4f, 0xbb, 0xb3, 0x6c, 0xa1, 0xf4, 0xe5, 0x68, 0x99, + 0x8e, 0x51, 0x9d, 0xd9, 0xbc, 0xdf, 0xbd, 0x9a, 0xcd, 0xd2, 0xb9, 0x6f, 0xc9, 0x44, 0x73, 0x54, + 0xcb, 0xa4, 0x08, 0x17, 0xa3, 0x5b, 0x6d, 0x18, 0x46, 0xe3, 0xb4, 0x7b, 0x35, 0x1d, 0xe5, 0x8b, + 0x6e, 0x9e, 0x75, 0x31, 0x8e, 0x85, 0x52, 0x30, 0x5b, 0x90, 0xde, 0xeb, 0xd4, 0xb2, 0xcb, 0xcb, + 0x45, 0x9a, 0x47, 0xc0, 0x8d, 0xec, 0xff, 0x22, 0x41, 0x72, 0x45, 0x2e, 0xcc, 0x9b, 0x66, 0xcb, + 0x94, 0x56, 0x2f, 0x52, 0xab, 0x40, 0xb1, 0xbe, 0x72, 0x4c, 0xf4, 0x79, 0x88, 0xa8, 0x3a, 0xa1, + 0xc6, 0x0d, 0xe4, 0x62, 0xe1, 0xdd, 0xc1, 0xdf, 0x7e, 0x34, 0xcb, 0x38, 0x2a, 0x8b, 0x9e, 0x9f, + 0x94, 0xfb, 0x1b, 0xa2, 0x7f, 0x3e, 0x4a, 0xae, 0xf2, 0x94, 0x74, 0x78, 0x0c, 0x83, 0x1e, 0xa2, + 0x16, 0x5f, 0x66, 0xf3, 0x09, 0xe2, 0xb7, 0x1c, 0x31, 0x7d, 0x17, 0xfd, 0x99, 0x8f, 0x96, 0xe1, + 0x75, 0x36, 0xea, 0xa3, 0xa4, 0xd1, 0xd4, 0x41, 0x63, 0x32, 0x18, 0x77, 0xcf, 0xb3, 0xc5, 0x28, + 0x47, 0xad, 0x8b, 0x18, 0x84, 0x87, 0xa7, 0x37, 0x46, 0xe1, 0xb7, 0xfc, 0xb6, 0x0b, 0x1d, 0xc2, + 0x50, 0x91, 0xf9, 0x43, 0x38, 0x96, 0xe3, 0xa7, 0xd3, 0x97, 0x89, 0xb3, 0x42, 0x0d, 0x9f, 0xe7, + 0xf1, 0x80, 0x30, 0x3c, 0x2d, 0xe9, 0x09, 0xd8, 0x03, 0xda, 0xd5, 0x5f, 0xff, 0x38, 0xfd, 0xf6, + 0xe9, 0xdb, 0xc9, 0xff, 0x74, 0xcf, 0xbe, 0x5c, 0x9c, 0x9f, 0x7e, 0xfc, 0xed, 0xeb, 0xb7, 0x03, + 0xa5, 0x24, 0xa6, 0xa9, 0x8d, 0x24, 0x56, 0xc8, 0xda, 0x2c, 0x51, 0xa5, 0x36, 0x50, 0xa2, 0x15, + 0x49, 0xda, 0xae, 0x3c, 0xb6, 0xdd, 0xb8, 0x34, 0x37, 0x29, 0xe4, 0xea, 0xac, 0x59, 0x06, 0x80, + 0x39, 0xb0, 0xd0, 0x29, 0x8b, 0x5e, 0x3c, 0x96, 0xeb, 0x55, 0xd3, 0x93, 0x42, 0xba, 0x89, 0x57, + 0x43, 0xe3, 0xf0, 0x5e, 0xc7, 0xf3, 0xd5, 0x68, 0x3a, 0x20, 0x49, 0xd7, 0x90, 0x84, 0xaa, 0x31, + 0x24, 0x26, 0x5b, 0x0c, 0x39, 0x45, 0x17, 0xe9, 0x72, 0xc4, 0xd0, 0x25, 0xbe, 0xa1, 0x17, 0x7c, + 0xde, 0x6e, 0x4f, 0x1f, 0x00, 0xdf, 0xdc, 0x44, 0x1f, 0x57, 0xce, 0x2a, 0x4e, 0xee, 0x5d, 0x71, + 0xa2, 0x57, 0x9c, 0xac, 0xa9, 0x58, 0x65, 0x72, 0x99, 0x35, 0xf2, 0xb1, 0x9d, 0x6d, 0x92, 0xb9, + 0x3d, 0x0f, 0x95, 0x4b, 0x4a, 0xca, 0x15, 0xf2, 0xf2, 0x74, 0x89, 0xe5, 0x8f, 0xce, 0x11, 0x13, + 0x89, 0xa7, 0xf5, 0xa9, 0xc6, 0xd2, 0x17, 0xf1, 0x64, 0x36, 0x4e, 0xe7, 0x9d, 0x4f, 0x28, 0x6f, + 0x34, 0x89, 0x07, 0xe9, 0xb6, 0xdc, 0x81, 0x73, 0x30, 0x06, 0xdc, 0xab, 0x58, 0x50, 0xd3, 0xd2, + 0x3e, 0x9e, 0x7e, 0x4c, 0xa0, 0x47, 0xb0, 0x02, 0xa9, 0x9d, 0x14, 0xf0, 0x36, 0xf8, 0x6a, 0x0f, + 0x49, 0x19, 0x02, 0x35, 0x5d, 0x0c, 0xb1, 0x40, 0x68, 0x47, 0x28, 0x1f, 0xc9, 0xea, 0xb4, 0xf3, + 0xc9, 0xa1, 0x0d, 0xf0, 0x09, 0x3b, 0xa8, 0xe4, 0x20, 0xc6, 0x10, 0x04, 0x25, 0x2a, 0x41, 0x9d, + 0x22, 0x45, 0x89, 0x8d, 0xa2, 0xc4, 0x48, 0x51, 0x37, 0x91, 0x69, 0xea, 0x98, 0x69, 0xea, 0xb8, + 0xa1, 0x22, 0x98, 0xa0, 0x52, 0xd2, 0x06, 0x9f, 0x14, 0xf3, 0xf1, 0x88, 0xb9, 0xbb, 0x91, 0x71, + 0x49, 0x96, 0x8d, 0xb9, 0x30, 0xb9, 0x19, 0xe5, 0x43, 0x04, 0x30, 0xd3, 0x73, 0x67, 0xa3, 0xbc, + 0x37, 0x2c, 0xe6, 0x52, 0xb6, 0x43, 0x8d, 0x9c, 0x5f, 0x21, 0x2d, 0x04, 0xe3, 0xe0, 0x99, 0x92, + 0x3a, 0x0f, 0xf2, 0x3e, 0x9e, 0xa4, 0xf3, 0x18, 0x26, 0x4d, 0x2f, 0x9d, 0xa2, 0x4e, 0xec, 0xf6, + 0x47, 0x8b, 0x3c, 0x9e, 0xf6, 0x52, 0xb3, 0x64, 0x82, 0x06, 0x4f, 0xa1, 0xc5, 0xff, 0x7d, 0x72, + 0xd1, 0xfd, 0xfd, 0xcb, 0xd9, 0xe7, 0xaf, 0xdf, 0x7e, 0xed, 0x52, 0xd9, 0x7f, 0xc0, 0x6a, 0x80, + 0xc5, 0x91, 0x56, 0x10, 0x93, 0xac, 0x6e, 0x2e, 0xa1, 0x23, 0x04, 0xe0, 0xe1, 0xa0, 0xd9, 0x9c, + 0x7b, 0xa5, 0x2c, 0x92, 0x41, 0x57, 0x62, 0x95, 0x76, 0x65, 0xa9, 0x92, 0x16, 0x56, 0x03, 0x61, + 0xf3, 0x18, 0xad, 0xbe, 0x0b, 0x33, 0x65, 0x24, 0x4f, 0x21, 0x8d, 0xa9, 0x01, 0xb4, 0xc5, 0x04, + 0x82, 0x53, 0xa7, 0x28, 0x09, 0x35, 0x9a, 0xa9, 0x51, 0xa8, 0xc2, 0x30, 0x02, 0xd6, 0x50, 0x99, + 0x8c, 0xaf, 0x2c, 0xbd, 0x07, 0x39, 0x0a, 0x85, 0x38, 0x97, 0x92, 0x07, 0x99, 0x9c, 0x38, 0xa9, + 0x18, 0x4e, 0xd7, 0xe8, 0x92, 0xb2, 0x49, 0x7d, 0x6b, 0x48, 0xa2, 0x1c, 0x6e, 0xa6, 0x8a, 0x66, + 0x5a, 0x09, 0xe3, 0xea, 0x42, 0x91, 0x36, 0x31, 0x73, 0xec, 0xe4, 0x49, 0x30, 0x25, 0x14, 0x2e, + 0xf2, 0x79, 0xf6, 0xef, 0xb4, 0x8c, 0xf5, 0x64, 0x08, 0x3b, 0x07, 0xca, 0x50, 0x26, 0x46, 0x54, + 0xf2, 0xcb, 0xf8, 0x51, 0x07, 0x5c, 0x4f, 0xfb, 0xcd, 0xa8, 0x9f, 0x0f, 0x4b, 0x69, 0xc7, 0x10, + 0x65, 0x2c, 0x2a, 0xc3, 0x59, 0x18, 0x55, 0x01, 0x59, 0xc3, 0xae, 0x3a, 0xec, 0xfa, 0x36, 0x94, + 0x32, 0x8a, 0x0a, 0x63, 0xe5, 0x17, 0x15, 0xcc, 0xc4, 0x36, 0x1a, 0x44, 0x19, 0xf7, 0x14, 0x41, + 0x89, 0xbb, 0x40, 0x2c, 0x90, 0x87, 0x68, 0x81, 0xec, 0xc7, 0x79, 0x2c, 0xad, 0x8f, 0xf0, 0x0b, + 0xad, 0x91, 0xa5, 0xe2, 0xad, 0x47, 0x14, 0x5d, 0xdd, 0xc4, 0xa4, 0x32, 0xcc, 0xe7, 0xa2, 0xce, + 0x65, 0xe4, 0xe9, 0xd2, 0x2c, 0xda, 0x48, 0x66, 0x91, 0x3f, 0x91, 0x6e, 0x3b, 0x33, 0xa9, 0xe4, + 0x0b, 0x01, 0xc6, 0x2b, 0x34, 0x09, 0xa8, 0x68, 0x13, 0x19, 0x04, 0xff, 0x18, 0x6a, 0x84, 0x64, + 0x9f, 0x09, 0x23, 0x5e, 0x9b, 0x26, 0x71, 0xa2, 0x8d, 0xe4, 0x0a, 0xfd, 0x6b, 0xa8, 0x8c, 0xe6, + 0xf8, 0x92, 0x98, 0x31, 0x55, 0xc9, 0x11, 0x6c, 0x23, 0x2e, 0xe4, 0x0f, 0xd3, 0x88, 0xca, 0xf9, + 0xbe, 0x2e, 0x48, 0x4c, 0xe3, 0xab, 0x22, 0xdc, 0x5a, 0x14, 0xc8, 0x1f, 0x86, 0xae, 0x91, 0xb3, + 0x7d, 0x5d, 0x46, 0x58, 0xb8, 0x40, 0x45, 0x79, 0x8f, 0x09, 0xae, 0x7e, 0xda, 0xa9, 0x13, 0xe3, + 0xa7, 0xcf, 0x7e, 0xd3, 0x30, 0xea, 0x58, 0xad, 0xd3, 0x17, 0xfb, 0xac, 0x88, 0x42, 0x13, 0xe1, + 0x0a, 0x41, 0x5d, 0x24, 0x76, 0x0d, 0xb8, 0xbb, 0x3c, 0xf4, 0x4f, 0x43, 0x68, 0x8d, 0xbd, 0xd1, + 0xbc, 0x87, 0xf4, 0x26, 0xa2, 0xd3, 0x44, 0xa8, 0x2a, 0x3c, 0xac, 0x08, 0xd8, 0x6b, 0x35, 0x8f, + 0xdd, 0x10, 0x19, 0xe1, 0x8e, 0xae, 0x3d, 0x31, 0x15, 0xb9, 0x97, 0xcd, 0xa7, 0x48, 0x0f, 0x9a, + 0x31, 0x4b, 0x4a, 0x41, 0x45, 0x4b, 0xaa, 0x5a, 0x19, 0x2a, 0xa9, 0x15, 0xaa, 0x47, 0x94, 0x54, + 0xcf, 0x21, 0x93, 0xaf, 0x2e, 0xf7, 0x3b, 0x68, 0x90, 0xaa, 0x6e, 0x76, 0x57, 0x83, 0x7e, 0xa1, + 0x6e, 0xa8, 0xd9, 0x3c, 0xfb, 0x57, 0xda, 0xcb, 0xd3, 0x3e, 0x23, 0x5f, 0xb5, 0xe5, 0x14, 0x7a, + 0x88, 0x4d, 0x77, 0xbf, 0xda, 0x3d, 0x47, 0xaf, 0xb1, 0x79, 0x13, 0x94, 0x68, 0x86, 0xc8, 0xa2, + 0xb2, 0x5b, 0x9a, 0x1a, 0x29, 0xd4, 0xcd, 0x40, 0x9b, 0x57, 0x52, 0xac, 0xd8, 0x28, 0x4b, 0x4f, + 0x4b, 0x38, 0x9a, 0xcb, 0xd5, 0xa6, 0x4d, 0x2d, 0x53, 0x78, 0x0d, 0x54, 0x6e, 0x51, 0x83, 0x5c, + 0xfa, 0x26, 0xbc, 0xbb, 0x93, 0xd7, 0xc3, 0x69, 0x3e, 0x8a, 0xc7, 0xa3, 0x78, 0x81, 0xc5, 0x25, + 0x62, 0xd6, 0xe0, 0xd3, 0xe9, 0x1f, 0x67, 0x1f, 0x4f, 0xbb, 0xe7, 0x67, 0x7f, 0x9e, 0xfe, 0xd2, + 0xfd, 0x76, 0xf2, 0xdb, 0xd9, 0xd7, 0xc0, 0x58, 0x4b, 0x48, 0x16, 0x2c, 0x60, 0xfc, 0x43, 0x87, + 0xd6, 0xd7, 0x5c, 0xfa, 0xec, 0x17, 0x9a, 0x6c, 0x32, 0x6a, 0x97, 0x3a, 0xba, 0xac, 0x2b, 0xd9, + 0x63, 0xab, 0xdb, 0xbb, 0x51, 0x98, 0x1f, 0x59, 0xf3, 0xdd, 0x9d, 0xf2, 0xfa, 0x14, 0x4a, 0xe7, + 0x53, 0xaa, 0x8a, 0x4f, 0xa0, 0xdf, 0x51, 0xdd, 0xce, 0x36, 0x21, 0xaa, 0x68, 0x6a, 0x56, 0x6e, + 0xaf, 0xac, 0x75, 0x59, 0xf8, 0x78, 0xbd, 0x1e, 0x65, 0x67, 0xd2, 0xaa, 0x0a, 0xd1, 0x1a, 0x0e, + 0xdc, 0x5c, 0x93, 0x59, 0xc3, 0x5e, 0x5b, 0xe9, 0x20, 0x6b, 0x19, 0xe7, 0xde, 0x7a, 0x03, 0x66, + 0x0b, 0x24, 0xd4, 0x43, 0x82, 0x84, 0x49, 0xee, 0x71, 0x3a, 0x1d, 0x20, 0xca, 0xc8, 0x1f, 0x26, + 0x5f, 0xdd, 0xd0, 0x2a, 0xba, 0x29, 0x9e, 0xdb, 0x50, 0xcb, 0x44, 0x0b, 0x28, 0xce, 0x6f, 0x4c, + 0xe2, 0xa5, 0x43, 0x94, 0x66, 0x55, 0x2e, 0x2b, 0x23, 0xd5, 0xcd, 0xa3, 0xc5, 0x24, 0xcb, 0xf2, + 0xe1, 0x22, 0x4f, 0x67, 0x4e, 0xab, 0xd9, 0xf2, 0x75, 0x44, 0xbe, 0x4a, 0x20, 0xd1, 0x6f, 0x08, + 0x0e, 0xaa, 0x8b, 0x46, 0x72, 0x5f, 0xd6, 0xfe, 0x51, 0x43, 0x58, 0xda, 0xb5, 0x9f, 0xe0, 0x4f, + 0xed, 0x43, 0x4d, 0xc2, 0x5e, 0xc0, 0x0c, 0xd5, 0x69, 0xd8, 0x09, 0xc3, 0x9a, 0x17, 0x20, 0xcd, + 0x35, 0xc6, 0x5b, 0xe0, 0x71, 0x27, 0x99, 0xc7, 0xf4, 0x3e, 0x99, 0x63, 0x3c, 0x4d, 0x27, 0x94, + 0x34, 0xe8, 0x7b, 0x38, 0xce, 0x1e, 0x7b, 0x4b, 0xc4, 0xbe, 0xcb, 0x21, 0xc8, 0xb1, 0xae, 0xb0, + 0x37, 0x29, 0x9a, 0x4b, 0xb9, 0xd9, 0x1c, 0x26, 0x79, 0x66, 0x57, 0x44, 0x87, 0xe7, 0x6b, 0x4e, + 0x08, 0x52, 0x98, 0x66, 0x19, 0x97, 0x02, 0x26, 0x19, 0x05, 0xcc, 0x63, 0x7b, 0xc4, 0x36, 0x5b, + 0xc3, 0xcb, 0x1d, 0x9d, 0xac, 0x90, 0xd9, 0x5b, 0x69, 0x73, 0x8b, 0xb3, 0xf4, 0x11, 0xd2, 0xe1, + 0xa6, 0x0b, 0xc8, 0xa9, 0xb2, 0x93, 0x42, 0xeb, 0x08, 0xc9, 0x0e, 0xa6, 0xdc, 0x7b, 0xff, 0x3c, + 0xfd, 0xf6, 0x15, 0xab, 0x64, 0x78, 0xeb, 0x3a, 0x68, 0xbf, 0x69, 0xb6, 0x42, 0xbe, 0x31, 0xf7, + 0xf3, 0xc9, 0xef, 0x17, 0x17, 0xdd, 0x8f, 0x5f, 0x4f, 0x3f, 0xa3, 0x99, 0x75, 0xf8, 0xfe, 0xdd, + 0xfb, 0xa3, 0x4e, 0xe7, 0x5d, 0xeb, 0xa8, 0xd5, 0x3e, 0x3a, 0xec, 0xbc, 0x3d, 0xa8, 0xea, 0x45, + 0xa0, 0x9c, 0x41, 0xfe, 0x18, 0xec, 0x27, 0x92, 0xe1, 0x0b, 0x36, 0xd1, 0x0c, 0x4d, 0x99, 0x11, + 0xa2, 0xcd, 0x46, 0xdb, 0xbc, 0x44, 0x3d, 0xb8, 0x67, 0x81, 0x9e, 0x80, 0xc0, 0x23, 0xd8, 0xef, + 0x56, 0xb2, 0xd6, 0x08, 0xc2, 0x8b, 0x68, 0xf1, 0xbf, 0xf3, 0xdc, 0x69, 0xa0, 0x64, 0x6f, 0x9c, + 0x0d, 0x1c, 0x18, 0x8d, 0x80, 0x34, 0x30, 0x90, 0xc6, 0x38, 0x10, 0x03, 0xe1, 0xba, 0xc1, 0x21, + 0x1a, 0x22, 0x3e, 0xa4, 0xd1, 0x85, 0xa7, 0x57, 0x1c, 0x6a, 0xb2, 0x9f, 0xe9, 0xf1, 0x84, 0xe8, + 0x82, 0x0d, 0x46, 0x6c, 0xaf, 0x6c, 0x41, 0x26, 0xb9, 0x6e, 0x32, 0xd6, 0x29, 0x30, 0x11, 0x12, + 0x46, 0x49, 0x02, 0xfc, 0xb6, 0x4e, 0x2c, 0x3c, 0xd0, 0xd4, 0x36, 0x03, 0x89, 0xb9, 0x60, 0x61, + 0xfb, 0x8d, 0x19, 0xda, 0xaa, 0x36, 0xd1, 0xe6, 0x54, 0x61, 0x4c, 0x92, 0xdb, 0x8f, 0x1a, 0xa8, + 0x1b, 0x3d, 0x34, 0x66, 0xf8, 0xff, 0x7e, 0x96, 0x3b, 0x9c, 0x2e, 0x9f, 0xff, 0x62, 0xfc, 0x70, + 0x1d, 0x8f, 0x23, 0x82, 0xc6, 0x93, 0x9a, 0xe5, 0x09, 0xb2, 0xbd, 0x74, 0x39, 0x73, 0xfa, 0xda, + 0xaa, 0x84, 0x07, 0x0e, 0x15, 0x85, 0xdd, 0x23, 0xf6, 0xbf, 0xbb, 0x83, 0x7d, 0xe8, 0x9b, 0x6c, + 0x3e, 0xee, 0x57, 0xdd, 0xc9, 0xdd, 0x68, 0x49, 0xf2, 0x28, 0x72, 0x69, 0xeb, 0xb6, 0xb9, 0x8c, + 0x62, 0xf2, 0x97, 0x7e, 0xaf, 0x40, 0x6c, 0x35, 0x48, 0xda, 0x4a, 0xde, 0xec, 0x2c, 0xee, 0x1c, + 0x9a, 0x72, 0xc8, 0x92, 0x3c, 0x47, 0x29, 0xf6, 0x5d, 0xff, 0x35, 0x8d, 0xa0, 0x47, 0x45, 0x0c, + 0xbb, 0x6a, 0x18, 0xd8, 0x6d, 0xce, 0xa5, 0xcd, 0x37, 0x05, 0x4a, 0x54, 0xee, 0x63, 0x29, 0x91, + 0xfb, 0x30, 0xd7, 0xb4, 0x61, 0xbd, 0xd7, 0xc1, 0x82, 0x56, 0x15, 0xdd, 0xa1, 0x90, 0x18, 0x4f, + 0x7b, 0xc3, 0x6c, 0x6e, 0xce, 0x63, 0x93, 0xa9, 0x88, 0x69, 0x1c, 0xf7, 0x52, 0x03, 0x1f, 0x2c, + 0x86, 0xa3, 0xcb, 0x3c, 0xac, 0xc4, 0x49, 0xe5, 0x6b, 0xa0, 0xdd, 0x75, 0xc1, 0x46, 0x88, 0xce, + 0x1e, 0x46, 0x8a, 0x9e, 0x3c, 0xcd, 0xf2, 0xdf, 0x17, 0x90, 0xae, 0xed, 0x0b, 0x4b, 0x3e, 0xa7, + 0xf3, 0x0c, 0x4d, 0xb7, 0x02, 0x2b, 0x8a, 0xfe, 0x20, 0x9c, 0x28, 0xcf, 0x7b, 0x41, 0x15, 0x85, + 0x62, 0x54, 0x45, 0x2a, 0xd2, 0xe6, 0x8d, 0x5a, 0x2c, 0x1b, 0x8f, 0xf1, 0xd9, 0x9b, 0xee, 0x2c, + 0x9d, 0x2f, 0x66, 0x08, 0x6e, 0x74, 0x9d, 0x22, 0x56, 0x40, 0x53, 0x21, 0xea, 0x8d, 0x11, 0x47, + 0xa0, 0xa1, 0x3b, 0xae, 0x83, 0xcc, 0x70, 0x4a, 0x5a, 0x1e, 0x58, 0x6b, 0x77, 0xb1, 0x8a, 0x7b, + 0x04, 0xc3, 0xbf, 0x56, 0xef, 0x63, 0xa2, 0x42, 0xf7, 0xfc, 0x38, 0x7c, 0xb4, 0xeb, 0x74, 0x18, + 0xd7, 0xf8, 0x7b, 0xbc, 0x92, 0x56, 0x85, 0x6c, 0x58, 0x22, 0xc6, 0x2a, 0x78, 0x0a, 0xd3, 0x31, + 0x11, 0x89, 0x78, 0x0e, 0xdf, 0x67, 0x40, 0xa9, 0x36, 0x37, 0x9e, 0x0d, 0xe3, 0x08, 0xf5, 0x5f, + 0x68, 0x94, 0x72, 0xb8, 0xd1, 0xac, 0xe1, 0x1e, 0x06, 0xc6, 0x1e, 0x37, 0x56, 0x55, 0xed, 0xbf, + 0x6a, 0x30, 0x15, 0x4d, 0xfa, 0xaf, 0x54, 0x12, 0x4f, 0x57, 0x5a, 0xfa, 0x8e, 0x14, 0xa7, 0x24, + 0x19, 0xcb, 0x7b, 0x51, 0xb3, 0x1d, 0xde, 0xed, 0x64, 0x16, 0x3e, 0xab, 0xe9, 0xa6, 0xa5, 0x6b, + 0xdb, 0xca, 0xda, 0x22, 0x6d, 0x4e, 0x66, 0x4a, 0xca, 0x7e, 0xe6, 0x1a, 0x67, 0xae, 0x4c, 0xdf, + 0x2c, 0xee, 0xf7, 0x51, 0x07, 0x76, 0x2f, 0xe3, 0x5e, 0x9e, 0x81, 0x9f, 0xb5, 0x53, 0x98, 0xd8, + 0x9c, 0x7f, 0x0a, 0xd3, 0x59, 0x2d, 0xfc, 0x18, 0xb3, 0x9b, 0x8d, 0x7f, 0x14, 0x27, 0x0b, 0x21, + 0x60, 0x9a, 0x2b, 0x57, 0x52, 0x66, 0x05, 0x7d, 0x2a, 0x3d, 0xa1, 0xc6, 0x0f, 0xd1, 0x06, 0xfe, + 0xed, 0x52, 0xea, 0x25, 0xb5, 0x81, 0xaf, 0xfe, 0xd7, 0x08, 0x0a, 0x7b, 0xdf, 0x59, 0xdd, 0xcf, + 0x83, 0xeb, 0x75, 0xf1, 0x26, 0xa9, 0x16, 0x1b, 0x0b, 0xb7, 0xde, 0xb6, 0x52, 0xad, 0x47, 0xc5, + 0x59, 0x87, 0x1d, 0x71, 0x56, 0x08, 0xd6, 0x1c, 0x4a, 0x5a, 0x73, 0xdc, 0x52, 0xef, 0x93, 0xd0, + 0x85, 0x3d, 0x13, 0xce, 0xd0, 0xe0, 0x51, 0x6b, 0x23, 0x8b, 0xd5, 0x08, 0x1c, 0x18, 0x46, 0x51, + 0xb1, 0xe0, 0xd8, 0xa8, 0x94, 0x55, 0xc5, 0xf8, 0x07, 0x58, 0x2a, 0xed, 0x0f, 0x52, 0xcc, 0xb7, + 0x46, 0xd7, 0x51, 0xa9, 0x7f, 0xab, 0xa1, 0x6c, 0x5e, 0x42, 0x4f, 0x37, 0x74, 0xcc, 0x56, 0x27, + 0x13, 0xf1, 0x3e, 0xde, 0xed, 0xee, 0x30, 0xac, 0x61, 0xe3, 0x63, 0xed, 0xd1, 0xd7, 0x0d, 0xe9, + 0x7b, 0x69, 0x27, 0xa9, 0x9e, 0xd3, 0x81, 0xa0, 0x82, 0x81, 0xfa, 0xe4, 0x67, 0x36, 0x76, 0x70, + 0xac, 0xa1, 0x2a, 0x0f, 0x3f, 0xc9, 0xc6, 0xdf, 0x03, 0x6f, 0x9a, 0x3d, 0xf2, 0xc6, 0xcd, 0x46, + 0xbb, 0x27, 0x06, 0x5b, 0xf4, 0x41, 0x8e, 0x7f, 0x6e, 0x20, 0x2b, 0x8c, 0xfe, 0x06, 0x83, 0x55, + 0x6e, 0x1b, 0x9c, 0xab, 0x7c, 0x3c, 0x9a, 0x96, 0x1e, 0x95, 0x53, 0x40, 0xec, 0x32, 0x46, 0x01, + 0x33, 0xc9, 0x1a, 0x15, 0xa0, 0x8c, 0xab, 0x0a, 0x90, 0xaf, 0x48, 0xf6, 0xa8, 0x1d, 0xae, 0x7c, + 0x99, 0x64, 0x91, 0x02, 0xe0, 0x17, 0x06, 0xc3, 0x24, 0x9b, 0x34, 0x9c, 0x5b, 0xf5, 0xe6, 0x53, + 0xcb, 0x2a, 0xcc, 0xb3, 0x91, 0xa3, 0xea, 0xe6, 0x81, 0xa2, 0x71, 0xd7, 0x61, 0xd2, 0x04, 0xe0, + 0x15, 0x66, 0x5c, 0x6f, 0x15, 0x70, 0x6a, 0x9f, 0xef, 0x9c, 0x35, 0x1f, 0x8a, 0xbb, 0xd6, 0xb8, + 0xda, 0x2c, 0xf2, 0x4c, 0x69, 0xfb, 0x36, 0x6c, 0x72, 0x4f, 0x19, 0x29, 0x34, 0x45, 0xa1, 0xc6, + 0x22, 0xda, 0x1b, 0x5c, 0x0a, 0x66, 0x73, 0x64, 0x0f, 0xad, 0x98, 0x82, 0x48, 0x94, 0x77, 0x70, + 0x5b, 0x6a, 0x1b, 0xa0, 0xa0, 0x7c, 0x03, 0x16, 0x5d, 0x13, 0x94, 0xc9, 0xf6, 0x1c, 0x5c, 0x9c, + 0x09, 0xe1, 0xdd, 0x39, 0x78, 0x1f, 0xee, 0x06, 0x11, 0x3b, 0xbb, 0x81, 0x8d, 0x9b, 0xfb, 0xde, + 0x00, 0xaa, 0xbe, 0x0c, 0x3c, 0xfb, 0x23, 0xdd, 0xec, 0x1e, 0xc7, 0xe5, 0x3c, 0x9b, 0x98, 0xc9, + 0x94, 0x21, 0x8c, 0xb4, 0x1e, 0x69, 0x40, 0x2a, 0xc1, 0xf4, 0x22, 0xa8, 0x94, 0x6d, 0x22, 0x9a, + 0x0e, 0x8f, 0x0e, 0x57, 0x81, 0xf0, 0x3c, 0x2b, 0x27, 0x1b, 0x19, 0x3a, 0xeb, 0x88, 0xce, 0xb3, + 0x12, 0x92, 0x51, 0x66, 0x05, 0x82, 0x09, 0x54, 0xf5, 0xd5, 0xea, 0xa9, 0x8e, 0xe4, 0x2a, 0xc3, + 0x2d, 0x7f, 0x44, 0x71, 0xd7, 0x34, 0x48, 0xd2, 0x5e, 0xb4, 0x3a, 0x8a, 0xd1, 0xb6, 0x83, 0x25, + 0x7e, 0x46, 0x71, 0xb7, 0xd8, 0xc9, 0xc6, 0x0a, 0x11, 0xac, 0xb9, 0xab, 0xe5, 0x8b, 0xb4, 0x70, + 0x69, 0x2a, 0x92, 0x69, 0x82, 0x43, 0x27, 0x0a, 0x04, 0xdc, 0x9e, 0x52, 0x21, 0x6e, 0x6f, 0x42, + 0x1d, 0x47, 0x12, 0x89, 0x8a, 0x4c, 0x18, 0x94, 0x7c, 0x54, 0x9e, 0x3a, 0xc0, 0x40, 0xf0, 0x7c, + 0xc3, 0xfe, 0x38, 0x2a, 0x64, 0x9a, 0xcb, 0x50, 0xdc, 0xe7, 0x55, 0x73, 0xd8, 0x59, 0x18, 0x20, + 0xe1, 0x82, 0xfa, 0x94, 0x48, 0x0e, 0x3b, 0xde, 0x92, 0x67, 0x6a, 0xfa, 0x4d, 0x58, 0x6d, 0x79, + 0x07, 0x5a, 0x91, 0x30, 0x9f, 0x8d, 0xe3, 0x15, 0xbd, 0x21, 0x48, 0xb6, 0x82, 0x1d, 0xb9, 0x0b, + 0x9a, 0xcb, 0x86, 0xdc, 0x67, 0xcd, 0xa5, 0x1b, 0x08, 0xf2, 0x7d, 0x15, 0x74, 0xa5, 0x82, 0xae, + 0x64, 0x50, 0x53, 0x7d, 0x49, 0xb1, 0xbe, 0x44, 0xad, 0x2f, 0x29, 0xa9, 0x2f, 0x51, 0xeb, 0x4b, + 0x0a, 0xf5, 0xdd, 0xf3, 0x22, 0x25, 0xef, 0x70, 0x4f, 0xed, 0x24, 0x9f, 0x8f, 0xd1, 0x43, 0xdd, + 0x9c, 0xa4, 0x03, 0xa8, 0xd6, 0x93, 0x58, 0xea, 0xd9, 0x42, 0x21, 0x5b, 0x73, 0xdb, 0xd1, 0xbe, + 0x0f, 0xc9, 0x56, 0x87, 0xcb, 0xb8, 0x9f, 0x3e, 0xea, 0x92, 0xb7, 0xbb, 0x55, 0x6b, 0xd7, 0xcb, + 0xcd, 0x63, 0xae, 0x15, 0x8f, 0x71, 0xec, 0x50, 0xe9, 0xac, 0x6d, 0x04, 0x7a, 0x69, 0x6f, 0xbc, + 0x38, 0x81, 0xbd, 0xd9, 0xa5, 0x5c, 0xcb, 0x95, 0xdc, 0x27, 0xba, 0x90, 0x6b, 0xb9, 0x8e, 0xfb, + 0x60, 0x97, 0x71, 0x1f, 0xd9, 0xa8, 0x30, 0x5d, 0xef, 0x05, 0x41, 0x44, 0x3d, 0xff, 0xde, 0x0e, + 0xe3, 0x18, 0x3c, 0x0f, 0x4b, 0x62, 0x6f, 0x36, 0xec, 0xcd, 0x86, 0xbd, 0xd9, 0xb0, 0x37, 0x1b, + 0x2c, 0x66, 0xc3, 0x3f, 0xb3, 0x6c, 0x72, 0x7f, 0xd3, 0xe1, 0xb5, 0x5b, 0x05, 0x3b, 0x89, 0xc1, + 0x52, 0x6a, 0x3a, 0xf0, 0x71, 0xda, 0x81, 0xf9, 0x50, 0xa8, 0x6b, 0xbd, 0x35, 0xa0, 0xe8, 0xfc, + 0x0f, 0x11, 0xe4, 0x64, 0xaf, 0xfa, 0xef, 0x55, 0xff, 0xbd, 0xea, 0xff, 0xba, 0x54, 0xff, 0x8a, + 0x8a, 0xfa, 0x6e, 0x54, 0xf4, 0x43, 0x94, 0x3a, 0x86, 0xb3, 0xe8, 0x6a, 0x6c, 0x34, 0x36, 0xa5, + 0x78, 0xb6, 0xbc, 0x7f, 0xab, 0xc8, 0x12, 0x9c, 0x2b, 0x0e, 0xe7, 0xeb, 0x92, 0xf0, 0x3a, 0x9d, + 0xe7, 0x23, 0x24, 0x61, 0xbb, 0x03, 0x38, 0x46, 0x93, 0x4e, 0xf3, 0x70, 0xfd, 0xf1, 0x48, 0x50, + 0xfd, 0xa6, 0x08, 0x09, 0x2a, 0x95, 0x2a, 0x5b, 0xc1, 0x47, 0x48, 0x2e, 0xb2, 0xdd, 0x1d, 0xf3, + 0xd5, 0xd9, 0xd8, 0x2c, 0xf2, 0x62, 0x9c, 0x63, 0xbf, 0x9b, 0x04, 0xb9, 0xe5, 0x77, 0x14, 0x18, + 0x44, 0x89, 0xf4, 0x1a, 0x96, 0x5c, 0x8e, 0x1a, 0xae, 0xb9, 0x1c, 0x35, 0xac, 0x70, 0x4d, 0x62, + 0x58, 0xe5, 0x4e, 0xcc, 0x7d, 0x8f, 0xd8, 0x54, 0x3f, 0x2b, 0x51, 0x45, 0x8d, 0xc6, 0xe3, 0x21, + 0xb7, 0x02, 0x12, 0x4c, 0x31, 0x38, 0x50, 0xb2, 0xcf, 0x06, 0xc9, 0x78, 0x33, 0x88, 0x14, 0xdc, + 0x60, 0x18, 0xe4, 0xc2, 0x43, 0xdb, 0xad, 0xa4, 0x21, 0xbb, 0x95, 0x34, 0x2c, 0xbb, 0x95, 0xc4, + 0x8a, 0x6f, 0x32, 0x02, 0xc5, 0xb3, 0x1b, 0x0f, 0x78, 0x4c, 0x07, 0x4f, 0x4c, 0x32, 0x43, 0x22, + 0x69, 0xaa, 0x20, 0xc1, 0x7c, 0x1b, 0xe2, 0x8e, 0x82, 0x2b, 0x9a, 0xe0, 0x1d, 0x80, 0x0f, 0x37, + 0xa4, 0xf4, 0xb3, 0x44, 0xf2, 0xc9, 0x3c, 0x0b, 0x24, 0xa8, 0x25, 0xc1, 0xd1, 0x5c, 0xe2, 0x0b, + 0x4c, 0x6b, 0xf5, 0xbc, 0x1c, 0x1f, 0x15, 0x6c, 0xd5, 0x7e, 0xa2, 0x5d, 0x53, 0xfb, 0x80, 0xc7, + 0x07, 0xb4, 0x3f, 0xe9, 0x02, 0xe7, 0x35, 0x0e, 0x45, 0x8b, 0x7f, 0x36, 0xe7, 0x5e, 0xab, 0xd9, + 0x69, 0x77, 0xde, 0xd4, 0xc9, 0xe7, 0x00, 0x7d, 0xbe, 0x6d, 0x1f, 0x77, 0xe8, 0x67, 0x82, 0x3e, + 0x5b, 0x6f, 0x3b, 0x9d, 0x90, 0x4e, 0x6f, 0xf5, 0xd0, 0x22, 0x3f, 0x07, 0x4b, 0x18, 0x75, 0x92, + 0x80, 0x18, 0xc1, 0x62, 0x87, 0xc3, 0x1d, 0xfa, 0xe2, 0x1f, 0x0c, 0x8a, 0xd1, 0xd4, 0x23, 0x19, + 0x98, 0xbb, 0x5c, 0xe6, 0x70, 0x38, 0x34, 0x9b, 0xa2, 0xbe, 0x23, 0x07, 0x7a, 0xe1, 0xba, 0x0e, + 0x69, 0x7f, 0xd0, 0x7e, 0x73, 0xf8, 0xee, 0x08, 0x02, 0xc0, 0x72, 0xa1, 0xe7, 0x8a, 0xea, 0xe5, + 0x92, 0x20, 0xb6, 0x41, 0xd8, 0x36, 0x74, 0x01, 0xe8, 0x42, 0x54, 0x53, 0x92, 0x25, 0x3a, 0xa1, + 0x5e, 0x84, 0x02, 0x8c, 0xbe, 0x84, 0x91, 0x84, 0x84, 0xa0, 0xc3, 0xb0, 0xaa, 0xfd, 0x10, 0xc1, + 0xdd, 0x8e, 0xda, 0x7f, 0x24, 0x08, 0x2f, 0x62, 0x35, 0x16, 0x64, 0xaa, 0x5b, 0x77, 0x0c, 0xa9, + 0x1e, 0x69, 0x9e, 0x93, 0xd7, 0x31, 0x1b, 0x78, 0xb3, 0xec, 0xc6, 0x21, 0xe3, 0x15, 0xb4, 0x8f, + 0x5b, 0xf4, 0x24, 0xa8, 0x0f, 0x2d, 0x41, 0x83, 0x81, 0x3e, 0xde, 0xbf, 0xf3, 0xcd, 0x2d, 0x02, + 0x5a, 0x71, 0xc8, 0xdd, 0x2e, 0x1d, 0xcc, 0x3a, 0xed, 0x39, 0x36, 0xb6, 0x32, 0x95, 0xf2, 0x72, + 0xd2, 0x9c, 0x53, 0xf4, 0x50, 0xd7, 0xa1, 0x8c, 0x9d, 0x66, 0xbb, 0x74, 0x60, 0x29, 0xe2, 0x81, + 0x8a, 0x78, 0x60, 0x47, 0x3c, 0x28, 0x47, 0x3c, 0xd0, 0x10, 0x27, 0x2a, 0xe2, 0xc4, 0x8e, 0x38, + 0x29, 0x47, 0x9c, 0x50, 0xc4, 0xd2, 0x2d, 0x06, 0x65, 0x5d, 0x2a, 0xb9, 0x5d, 0x2b, 0xad, 0x5c, + 0xcf, 0xd6, 0xe3, 0xa6, 0x2e, 0x35, 0xec, 0x54, 0xad, 0xd1, 0x1f, 0xb7, 0x7e, 0xa1, 0x7f, 0x44, + 0x2d, 0xe3, 0x1e, 0x3a, 0x44, 0xf5, 0xed, 0x17, 0x18, 0x55, 0x5a, 0xef, 0xe0, 0x01, 0x14, 0x0e, + 0x25, 0xb8, 0x1d, 0x2c, 0x63, 0xa6, 0x10, 0x1f, 0x06, 0x3d, 0x44, 0x0d, 0xf1, 0xf1, 0xe0, 0x6a, + 0x88, 0x4c, 0xd6, 0x50, 0xbd, 0xa2, 0x2d, 0x15, 0x35, 0xeb, 0x27, 0x0a, 0x69, 0x95, 0x16, 0xc7, + 0xbd, 0x37, 0xf3, 0x29, 0xbc, 0x99, 0x98, 0x4b, 0x37, 0x52, 0xbd, 0x34, 0x9e, 0xdc, 0x4c, 0xf3, + 0xda, 0x5c, 0xdb, 0x2a, 0x70, 0x5a, 0xb4, 0x0d, 0x3f, 0xed, 0xdd, 0xa5, 0x2f, 0xe7, 0x94, 0x45, + 0x99, 0x0a, 0x4b, 0x6f, 0x90, 0xf4, 0x07, 0x29, 0xbf, 0xb3, 0x25, 0x83, 0xbc, 0x7e, 0x3f, 0xeb, + 0x43, 0xe8, 0xf0, 0x24, 0xe7, 0x36, 0xb2, 0xe8, 0xea, 0x6b, 0x75, 0xfc, 0x5b, 0x7e, 0xcc, 0x05, + 0xbc, 0x34, 0x0c, 0x77, 0x04, 0x7b, 0x90, 0xb5, 0xbf, 0xff, 0xbd, 0xc6, 0x34, 0xd5, 0x08, 0x14, + 0x55, 0x29, 0xe1, 0x16, 0x41, 0x10, 0x25, 0xfa, 0xe0, 0x27, 0xb2, 0x2e, 0x1f, 0x7c, 0x20, 0x2f, + 0x3c, 0xc8, 0xe3, 0xe9, 0xdf, 0x7a, 0x9a, 0x92, 0xb1, 0x93, 0x23, 0x27, 0xbb, 0x39, 0x70, 0x42, + 0x6b, 0x61, 0xaa, 0x83, 0xc5, 0x98, 0xa9, 0x68, 0x8d, 0x1c, 0x3e, 0x84, 0x35, 0x02, 0x57, 0x16, + 0x5f, 0x8b, 0x09, 0xc2, 0xba, 0xb5, 0x39, 0x1f, 0x70, 0xad, 0xde, 0xa6, 0xcd, 0x63, 0xcc, 0x38, + 0xac, 0x1c, 0x34, 0xc5, 0xa7, 0xbf, 0x0e, 0xdd, 0x82, 0x5e, 0x4f, 0xf3, 0xda, 0xe4, 0x69, 0x91, + 0xdd, 0xbb, 0xf9, 0xb7, 0xd1, 0x3a, 0x1f, 0x57, 0x7d, 0xdc, 0x95, 0x0e, 0xf8, 0xba, 0xf7, 0x15, + 0xf0, 0x40, 0xad, 0xd7, 0xa5, 0xac, 0xa3, 0x50, 0x4d, 0x2f, 0xda, 0xef, 0x46, 0xec, 0x77, 0x23, + 0xb6, 0xde, 0x8d, 0xa0, 0x8f, 0x03, 0x2d, 0xe9, 0x73, 0x3d, 0xf6, 0x0d, 0x89, 0xc2, 0xbe, 0x05, + 0x2d, 0xe1, 0x69, 0xf2, 0x6a, 0x1f, 0x8e, 0xc6, 0x78, 0x0c, 0xb4, 0x6a, 0xbc, 0x19, 0xa5, 0x9f, + 0x6c, 0x41, 0x67, 0x1e, 0x2a, 0x60, 0x4c, 0xa5, 0x2e, 0xef, 0x8f, 0x26, 0xb0, 0x0c, 0x67, 0xd3, + 0xb0, 0x5a, 0x64, 0x0b, 0x4a, 0xf4, 0x43, 0x8c, 0x89, 0x1c, 0xd6, 0x81, 0x04, 0xbc, 0x9a, 0x2d, + 0x46, 0x63, 0x04, 0x0b, 0xc1, 0xcc, 0x64, 0xca, 0xe8, 0xc5, 0x71, 0x6c, 0x64, 0x38, 0x52, 0x06, + 0xd2, 0xc9, 0x41, 0x1b, 0x0e, 0x94, 0x24, 0x76, 0x16, 0x58, 0x21, 0x35, 0x78, 0xd7, 0x7e, 0x8f, + 0xa3, 0x77, 0x61, 0x24, 0x75, 0x5a, 0x51, 0xc9, 0xab, 0x4a, 0xda, 0xcb, 0x71, 0x4a, 0xe8, 0xaa, + 0x2a, 0xba, 0x80, 0xbd, 0x9b, 0x75, 0xd6, 0xb9, 0xcd, 0x90, 0x70, 0x2e, 0x3c, 0xaf, 0x12, 0x2f, + 0x71, 0x3a, 0xf9, 0x46, 0xca, 0xec, 0xe9, 0x38, 0xbd, 0x06, 0xfd, 0x73, 0xea, 0xd0, 0x48, 0xcf, + 0x48, 0x08, 0xf8, 0x74, 0xd9, 0x19, 0xc5, 0x0b, 0x16, 0x52, 0x03, 0x87, 0xda, 0x2d, 0xf2, 0x15, + 0x91, 0x60, 0x1e, 0x0e, 0x10, 0xc7, 0x1f, 0xa0, 0xc2, 0x81, 0x20, 0xe7, 0x75, 0xfc, 0x67, 0x40, + 0x1f, 0xaf, 0xc2, 0x1f, 0x09, 0xf9, 0x20, 0xff, 0xba, 0x01, 0xd2, 0xf6, 0x91, 0x6a, 0x56, 0x78, + 0x8f, 0xa5, 0x7c, 0xb0, 0xb0, 0xa6, 0x2f, 0x11, 0x0d, 0x7d, 0x52, 0xc7, 0x96, 0x42, 0x83, 0x16, + 0x44, 0xa6, 0x0c, 0xff, 0xb9, 0xc2, 0xaa, 0x2f, 0x53, 0x9b, 0x13, 0x6b, 0xd9, 0x96, 0xad, 0x48, + 0xcf, 0x5a, 0x64, 0x6d, 0x6d, 0xfd, 0x2a, 0x94, 0xb6, 0x94, 0x22, 0xa9, 0xa1, 0x88, 0x9c, 0x7f, + 0x59, 0x81, 0x1a, 0x15, 0xe3, 0xa0, 0x0a, 0x11, 0x66, 0xfa, 0x87, 0x25, 0xbd, 0x65, 0x2e, 0x31, + 0xaa, 0x40, 0x9e, 0xb9, 0x64, 0xba, 0x8c, 0x07, 0x83, 0x14, 0xc7, 0xdd, 0x80, 0x19, 0x0d, 0x2c, + 0x5a, 0xfb, 0x47, 0xad, 0x83, 0x0d, 0xd0, 0x56, 0xf3, 0x08, 0x59, 0x9f, 0x3c, 0xf1, 0xa8, 0x79, + 0x8c, 0x13, 0x0f, 0x8f, 0x51, 0x2a, 0xfa, 0x43, 0xcd, 0xec, 0x74, 0x3e, 0xba, 0xa6, 0xd6, 0x75, + 0xaf, 0x7e, 0x89, 0xfe, 0x1b, 0xb9, 0x0d, 0x27, 0xae, 0xf7, 0xd1, 0x7f, 0x03, 0xd7, 0x77, 0x06, + 0xf5, 0x21, 0xfa, 0x8f, 0xa4, 0x25, 0xe8, 0xbf, 0x9e, 0xeb, 0x06, 0x35, 0xb0, 0x2b, 0x50, 0x1d, + 0xbe, 0x43, 0x90, 0x37, 0xf8, 0xf4, 0x80, 0x38, 0x13, 0x82, 0xa0, 0x7a, 0xfb, 0x7d, 0x13, 0xb1, + 0x6c, 0xa7, 0x41, 0xc0, 0xf4, 0x50, 0x5c, 0xd8, 0x96, 0xc0, 0xc2, 0x07, 0x13, 0xd1, 0x5c, 0xc2, + 0x5d, 0x00, 0x88, 0xf5, 0xe2, 0x93, 0xef, 0x15, 0xff, 0x66, 0xf1, 0xd7, 0x84, 0x39, 0xf6, 0x08, + 0x2b, 0xdf, 0x13, 0x49, 0x5b, 0x22, 0x1c, 0x4d, 0xb2, 0xb1, 0x7c, 0xc1, 0x5b, 0x2f, 0xe1, 0xc6, + 0xa8, 0xc2, 0x78, 0x2a, 0xad, 0x8d, 0x2c, 0x1d, 0x2b, 0xb4, 0xfa, 0x2e, 0xc3, 0x30, 0xee, 0x67, + 0x37, 0x7a, 0x2a, 0x08, 0x5d, 0x23, 0x78, 0xdc, 0x83, 0x88, 0x30, 0x22, 0x08, 0xe0, 0xf9, 0x59, + 0xed, 0xb0, 0xd9, 0x3e, 0x6a, 0x1f, 0xbf, 0xef, 0xbc, 0x39, 0x3e, 0x3c, 0x7e, 0xf7, 0xfe, 0xed, + 0xfb, 0xc3, 0x03, 0x43, 0x80, 0x21, 0x30, 0xef, 0xad, 0xcb, 0xac, 0xcc, 0x91, 0x0e, 0x79, 0xf0, + 0x0f, 0x99, 0x9d, 0x10, 0xdf, 0xd1, 0x95, 0x03, 0x3c, 0xe2, 0x15, 0xe3, 0x33, 0x09, 0xc8, 0xd3, + 0xcb, 0x16, 0x38, 0xc6, 0x6c, 0x3c, 0x5d, 0x38, 0x8e, 0x68, 0xf2, 0x5f, 0xad, 0xef, 0x0d, 0xe9, + 0xab, 0xfd, 0xdd, 0xf5, 0xb0, 0x25, 0x4d, 0xd5, 0x0a, 0xb7, 0xae, 0x66, 0x72, 0xcc, 0xe3, 0x6c, + 0x96, 0x46, 0x48, 0xe2, 0x4e, 0x11, 0x74, 0xe7, 0xd8, 0xa3, 0x47, 0xc5, 0x31, 0x45, 0x6e, 0x20, + 0xd5, 0xcb, 0xcf, 0x89, 0xe3, 0xd0, 0x37, 0x11, 0xe5, 0x5f, 0x62, 0xc3, 0xa3, 0x49, 0x86, 0x31, + 0x50, 0x26, 0xf6, 0x1b, 0x34, 0xd7, 0x45, 0xd3, 0xee, 0xfc, 0x0c, 0xdf, 0x77, 0x61, 0x79, 0xdc, + 0x57, 0x04, 0x5e, 0x9e, 0x0f, 0x72, 0x1b, 0xb9, 0x2d, 0x1e, 0xd1, 0xf1, 0xe2, 0xfe, 0xc0, 0xf8, + 0x76, 0x34, 0xb9, 0xc2, 0xa1, 0x8f, 0x49, 0xfa, 0xaa, 0x7e, 0x7e, 0x16, 0x4a, 0xe6, 0x4e, 0xbb, + 0xf9, 0xee, 0xed, 0x71, 0x43, 0xc4, 0x39, 0x6c, 0x37, 0xdf, 0x1e, 0xd3, 0x7c, 0x34, 0x49, 0xc9, + 0x7b, 0xa5, 0x10, 0x4f, 0x89, 0x97, 0x22, 0x81, 0x2e, 0x2f, 0x70, 0xd3, 0x79, 0x31, 0xdc, 0x14, + 0x90, 0x17, 0x68, 0x1c, 0xd0, 0x64, 0xc7, 0x5e, 0x6b, 0xdc, 0x3b, 0x64, 0x24, 0x02, 0x91, 0xca, + 0x90, 0x92, 0x0c, 0xd7, 0x63, 0xdf, 0x10, 0x33, 0x18, 0x0a, 0x30, 0xb2, 0x31, 0xc3, 0xe0, 0xf1, + 0x92, 0x2a, 0x64, 0x9b, 0xcc, 0x38, 0x93, 0x6e, 0x46, 0xe3, 0x81, 0x22, 0x29, 0xa0, 0x78, 0x91, + 0x5f, 0xd4, 0xb3, 0x21, 0x9a, 0xd5, 0x29, 0x3a, 0x77, 0x80, 0x85, 0x49, 0x44, 0x19, 0xd0, 0xf1, + 0x1d, 0x32, 0x36, 0x75, 0xda, 0x5f, 0x6e, 0x70, 0x7e, 0x86, 0x65, 0x89, 0xe0, 0x26, 0x12, 0xa2, + 0x1a, 0x0a, 0xd1, 0x9a, 0xc9, 0xcb, 0x60, 0x64, 0x26, 0xf8, 0x12, 0xf3, 0xfb, 0x18, 0x08, 0xa9, + 0x2a, 0x88, 0x93, 0x65, 0xe2, 0xcb, 0x89, 0x52, 0xe4, 0x90, 0xdc, 0x42, 0xc2, 0x8a, 0x52, 0xc5, + 0xcd, 0xd8, 0xad, 0x4b, 0x9f, 0xf7, 0x13, 0x6e, 0x7c, 0x4a, 0x9e, 0x7c, 0xf9, 0xed, 0xec, 0xe4, + 0x97, 0xb3, 0x93, 0x8b, 0xb3, 0x2f, 0x3f, 0xd7, 0x2c, 0x0f, 0x04, 0x20, 0x82, 0x39, 0x3c, 0x6e, + 0x19, 0x0e, 0xfa, 0x7c, 0xfc, 0xee, 0xed, 0x61, 0xab, 0xfd, 0xe6, 0xa0, 0xb0, 0xc3, 0x07, 0x56, + 0x13, 0x71, 0x58, 0x15, 0x77, 0xff, 0x70, 0x90, 0xf4, 0x72, 0x05, 0xb7, 0x18, 0xda, 0x17, 0xc2, + 0x45, 0x69, 0xd2, 0x09, 0xb5, 0x50, 0x7f, 0xd7, 0x50, 0x13, 0x75, 0x94, 0x02, 0x2d, 0x15, 0xc7, + 0x02, 0xea, 0x14, 0x22, 0x45, 0x0d, 0xe2, 0xc9, 0x24, 0x66, 0xa1, 0x9f, 0x0c, 0x01, 0x53, 0xc1, + 0x9a, 0x9a, 0xa6, 0x8b, 0xec, 0x32, 0x9e, 0xbf, 0xb8, 0x30, 0x3a, 0xfb, 0xa7, 0xbe, 0xb6, 0x38, + 0x66, 0x3b, 0x88, 0x67, 0x25, 0x4f, 0x65, 0xb1, 0xdc, 0xb2, 0xb8, 0xd5, 0x0c, 0x66, 0x5d, 0xe4, + 0x6a, 0x19, 0xae, 0xac, 0xcb, 0xf0, 0xeb, 0xb2, 0x96, 0x1e, 0xc3, 0x79, 0xf6, 0x0e, 0xc3, 0xd9, + 0xe5, 0x9d, 0xc2, 0x41, 0x4a, 0x48, 0x28, 0xe9, 0x90, 0xb5, 0xbd, 0x51, 0xa9, 0x2b, 0xd4, 0x7e, + 0x78, 0x7e, 0x21, 0x97, 0x5e, 0xfb, 0x83, 0x55, 0x9c, 0xe9, 0xd5, 0x81, 0x61, 0xc9, 0x06, 0x42, + 0x58, 0x96, 0x2f, 0xcf, 0x09, 0x4b, 0x08, 0x6f, 0x81, 0x66, 0x43, 0x9e, 0x97, 0x5b, 0x44, 0x5e, + 0x7c, 0x36, 0xf4, 0x08, 0xce, 0xf0, 0xc5, 0x5c, 0x30, 0xf6, 0x07, 0x2d, 0xbd, 0x09, 0xbb, 0xab, + 0x6d, 0xb0, 0xf5, 0x03, 0xeb, 0x84, 0xf2, 0x1e, 0x60, 0xcd, 0xd7, 0xf8, 0x5c, 0x09, 0x2f, 0x1a, + 0xc5, 0xec, 0xc5, 0x88, 0x46, 0xbb, 0xf3, 0x0e, 0xa9, 0xf7, 0x6c, 0x8a, 0xf1, 0xed, 0x94, 0x88, + 0x04, 0x36, 0x27, 0xef, 0x41, 0xe0, 0xa0, 0x95, 0xa0, 0xa8, 0x84, 0xd2, 0x12, 0x15, 0xf1, 0x58, + 0xe2, 0x04, 0x08, 0x5c, 0x01, 0x6e, 0x9d, 0x7e, 0xdd, 0x78, 0x6f, 0x8e, 0x68, 0x3c, 0x74, 0xe1, + 0x61, 0x95, 0x17, 0x6d, 0xf0, 0xdd, 0x2a, 0xb3, 0x97, 0x6f, 0x08, 0x4b, 0x30, 0xe0, 0xbf, 0xa5, + 0xbf, 0xe9, 0x36, 0x64, 0xc8, 0xc7, 0x97, 0xfd, 0x00, 0xbd, 0x81, 0x19, 0xbb, 0xf1, 0xf8, 0x92, + 0x64, 0x8a, 0x1c, 0x3a, 0x1a, 0x40, 0xbc, 0x47, 0x07, 0x84, 0x69, 0xb5, 0x90, 0xce, 0xb0, 0xd4, + 0x1d, 0xf6, 0x8b, 0xeb, 0xc1, 0x8a, 0xce, 0x02, 0x56, 0x2a, 0x57, 0xee, 0xb2, 0xab, 0x5c, 0x29, + 0xcb, 0xeb, 0xf5, 0x8a, 0x58, 0x3a, 0xf8, 0xc5, 0x0a, 0x50, 0x8c, 0xea, 0x8e, 0xa0, 0x8f, 0xea, + 0xe6, 0xe4, 0x39, 0x0b, 0xb9, 0x22, 0x57, 0xed, 0x14, 0x7c, 0x49, 0x94, 0x54, 0xe7, 0x89, 0xd8, + 0x99, 0x44, 0x83, 0xd0, 0xe4, 0x1a, 0x56, 0xa4, 0xa5, 0x01, 0xd4, 0xf2, 0x73, 0xe2, 0xbe, 0x44, + 0x0a, 0xe9, 0x95, 0x56, 0x07, 0xe9, 0x95, 0x4e, 0x44, 0xfe, 0xea, 0xd5, 0x78, 0x6c, 0x53, 0x10, + 0x29, 0xd3, 0x39, 0x04, 0xb2, 0x6e, 0x5c, 0xf9, 0x57, 0xf0, 0x6a, 0xbb, 0xf6, 0xa4, 0x17, 0x63, + 0x2c, 0xd5, 0xb6, 0x04, 0xfa, 0x03, 0xaa, 0x5c, 0xb1, 0x3d, 0xd0, 0xb2, 0x33, 0xa6, 0xe2, 0x85, + 0xf3, 0x8e, 0x52, 0x0c, 0xf7, 0x5f, 0xa1, 0x32, 0x63, 0xbc, 0x49, 0xfc, 0xa6, 0x16, 0xea, 0x32, + 0x39, 0x18, 0x28, 0xbb, 0x67, 0x4b, 0x6e, 0xcb, 0x5a, 0x4b, 0x99, 0x8a, 0x14, 0x2a, 0x2d, 0x84, + 0x0e, 0xf0, 0x4c, 0x7a, 0x22, 0xd8, 0xd2, 0x92, 0xba, 0x17, 0xad, 0xa7, 0x31, 0x58, 0x43, 0x50, + 0xc8, 0xd4, 0x4a, 0xe2, 0x20, 0x21, 0x4c, 0xe1, 0x63, 0x2e, 0x7e, 0xba, 0xf0, 0x78, 0x2f, 0xe8, + 0xbd, 0xaa, 0x72, 0x15, 0xdd, 0xac, 0xce, 0x1b, 0x15, 0xf7, 0xc7, 0x0d, 0xe1, 0xb7, 0x9b, 0x97, + 0x93, 0x4c, 0x57, 0xd0, 0x49, 0xdb, 0x5d, 0x8f, 0xf5, 0x4d, 0x73, 0x11, 0x0a, 0x12, 0x3a, 0x11, + 0x7e, 0xf7, 0xa7, 0x6e, 0xb6, 0xdd, 0xa0, 0x90, 0xdc, 0x47, 0xf2, 0xc5, 0x75, 0x62, 0x97, 0x4e, + 0x50, 0x7f, 0x41, 0x75, 0x0d, 0x87, 0xa3, 0xcf, 0x1b, 0x18, 0xb1, 0xeb, 0x8b, 0x0a, 0x71, 0xe4, + 0x54, 0x37, 0xc0, 0xe9, 0x16, 0xe3, 0xf5, 0x11, 0x42, 0x65, 0x71, 0xab, 0xf3, 0xd7, 0x93, 0x3f, + 0xbb, 0xbf, 0x9c, 0x7d, 0x39, 0xed, 0x7e, 0x3a, 0xbb, 0xf8, 0xed, 0xe4, 0xcb, 0xc7, 0xd3, 0xda, + 0x61, 0xe7, 0xed, 0x9b, 0xb7, 0x92, 0x5d, 0xba, 0xb7, 0x63, 0xab, 0xdb, 0xb1, 0x48, 0x72, 0x0e, + 0xe6, 0xe9, 0xc2, 0x1a, 0xc3, 0x64, 0x6f, 0x31, 0xee, 0x2d, 0xc6, 0xd7, 0x6a, 0x31, 0xee, 0x6d, + 0xb8, 0xbd, 0x0d, 0xf7, 0xcc, 0x6d, 0x38, 0x26, 0x9e, 0xab, 0x9a, 0x71, 0x41, 0x61, 0x75, 0xdc, + 0x1b, 0x76, 0x7b, 0xc3, 0x6e, 0x6f, 0xd8, 0x3d, 0x91, 0x61, 0xf7, 0x82, 0x2c, 0xaf, 0xca, 0xfb, + 0xc6, 0xdb, 0xdb, 0x64, 0xeb, 0x95, 0xd0, 0x2a, 0x27, 0x36, 0xf7, 0xa6, 0x97, 0x6e, 0x7a, 0x59, + 0x9e, 0x37, 0xa3, 0x1b, 0xe5, 0xc0, 0xae, 0x6a, 0x37, 0xdb, 0x9f, 0x39, 0x7b, 0x1c, 0x8b, 0xad, + 0x68, 0x5f, 0xb1, 0x1c, 0x65, 0xa5, 0xea, 0x5e, 0x7c, 0x3c, 0xf9, 0xe5, 0xb4, 0xd6, 0xd9, 0xc2, + 0x92, 0x7b, 0x68, 0x7b, 0xcd, 0x6e, 0x91, 0x95, 0x5b, 0x74, 0xf7, 0xb1, 0xd7, 0xc4, 0xae, 0x62, + 0xd9, 0x24, 0xda, 0x9b, 0x69, 0x0f, 0x67, 0xa6, 0x3d, 0x03, 0xab, 0xe8, 0xd9, 0x59, 0x8a, 0x3b, + 0x36, 0xd3, 0xf6, 0x97, 0x50, 0x9f, 0xd1, 0x25, 0xd4, 0x57, 0x6e, 0x0e, 0x3f, 0xad, 0xf9, 0xf9, + 0xdc, 0x8c, 0xf1, 0x5d, 0x99, 0xc3, 0xff, 0x6f, 0xae, 0x05, 0xdf, 0xdf, 0xe4, 0x67, 0x70, 0x9b, + 0x6d, 0xde, 0x1a, 0x74, 0xa8, 0xbd, 0xcd, 0xbf, 0xb7, 0xf9, 0xf7, 0x36, 0xff, 0x43, 0xd8, 0xfc, + 0x62, 0x2a, 0xc6, 0xb2, 0x82, 0x5e, 0xee, 0x0b, 0xd8, 0xe6, 0x72, 0xaa, 0x22, 0x6f, 0xf4, 0x10, + 0x2e, 0x6b, 0x6d, 0xf2, 0xdd, 0x19, 0x1a, 0xaf, 0xe5, 0x6e, 0xe8, 0xcb, 0xdf, 0x29, 0x5f, 0xef, + 0x2a, 0x79, 0x46, 0x97, 0x4c, 0x9f, 0xd0, 0x95, 0xb3, 0x0f, 0x71, 0xfc, 0xba, 0x1e, 0x3e, 0x91, + 0xbb, 0x5a, 0x6e, 0x9f, 0xda, 0xe6, 0xe6, 0xd2, 0xe3, 0xbd, 0x16, 0xa8, 0xc1, 0x82, 0x35, 0xc0, + 0x95, 0x09, 0x67, 0x62, 0xc0, 0x89, 0xa8, 0xf6, 0x68, 0x7f, 0x97, 0x61, 0x04, 0x8a, 0xc3, 0x17, + 0xe5, 0x3f, 0x24, 0xd8, 0x96, 0xa8, 0x23, 0xc9, 0x55, 0x67, 0xbe, 0x40, 0x04, 0x6a, 0x3f, 0x37, + 0x97, 0x2a, 0x7c, 0x52, 0x0e, 0x9f, 0xa8, 0xf0, 0xab, 0x2e, 0x7e, 0x31, 0xb9, 0xce, 0x7b, 0x02, + 0x29, 0x38, 0xf4, 0x46, 0x17, 0xa7, 0x0f, 0xd3, 0xe4, 0x68, 0xb5, 0xae, 0xea, 0x1d, 0xfa, 0xec, + 0x8b, 0xab, 0x13, 0xb4, 0x12, 0xc8, 0x93, 0x6d, 0x90, 0x27, 0x76, 0xe4, 0x89, 0x60, 0x0c, 0x1c, + 0xf5, 0x64, 0xf3, 0x8b, 0xe7, 0x98, 0x83, 0x50, 0xaf, 0xfa, 0xa8, 0xe5, 0xae, 0x84, 0x2b, 0xd9, + 0xe2, 0xda, 0x38, 0xc5, 0x95, 0x20, 0x5c, 0x89, 0xab, 0x78, 0x7c, 0x01, 0x97, 0xf1, 0xea, 0x38, + 0xaa, 0xd4, 0x37, 0x67, 0x24, 0xae, 0xf9, 0xca, 0x38, 0xf1, 0x01, 0x3f, 0xe0, 0xfb, 0x13, 0x2f, + 0xd8, 0x03, 0x5c, 0xe9, 0xc4, 0x0e, 0x1d, 0x2c, 0xf2, 0x6c, 0x75, 0x5c, 0x50, 0xf0, 0x50, 0xef, + 0x77, 0x57, 0x52, 0xba, 0xa9, 0x54, 0x62, 0x29, 0x95, 0x3c, 0xd2, 0xe9, 0x20, 0x9a, 0x0a, 0x95, + 0xc4, 0xa6, 0xc4, 0x64, 0x1b, 0xa5, 0x70, 0x7f, 0xdf, 0x65, 0x7f, 0x7a, 0x69, 0x7f, 0x7a, 0xa9, + 0xdc, 0x2d, 0xce, 0x86, 0xcc, 0xe0, 0x33, 0x7b, 0x08, 0x97, 0x39, 0x76, 0x14, 0x95, 0x50, 0x29, + 0xf2, 0xad, 0x7d, 0x25, 0x40, 0x4c, 0xfc, 0x25, 0xe5, 0x96, 0xf5, 0xa6, 0x0a, 0xb6, 0xbf, 0xbc, + 0xb3, 0x3f, 0xf8, 0xf5, 0x4c, 0x0e, 0x7e, 0xed, 0xce, 0xb7, 0x2d, 0x4d, 0x45, 0xf1, 0xd3, 0x50, + 0xb3, 0xc8, 0xf4, 0xd5, 0xf9, 0x69, 0x6a, 0xb2, 0x8c, 0xc9, 0x38, 0xc9, 0xf6, 0x2e, 0xe8, 0xbd, + 0x0b, 0x7a, 0xef, 0x82, 0x7e, 0x85, 0x2e, 0x68, 0xac, 0xaa, 0x47, 0x54, 0x66, 0xf0, 0x79, 0xe9, + 0xe9, 0xd6, 0x47, 0x73, 0x19, 0x48, 0x02, 0x85, 0x8f, 0x5f, 0x01, 0x6c, 0x55, 0xe7, 0x86, 0x89, + 0x4b, 0xb1, 0x27, 0x6b, 0xb1, 0x27, 0xd5, 0xb0, 0x27, 0x12, 0x76, 0x88, 0x6e, 0x56, 0xcd, 0x4d, + 0xbe, 0x3e, 0x34, 0xd7, 0xa2, 0x7f, 0x89, 0xbb, 0xb5, 0x18, 0x63, 0x09, 0x59, 0x6c, 0xcf, 0xcc, + 0x0a, 0xda, 0xdf, 0xe2, 0x2a, 0x5f, 0x87, 0x77, 0xa7, 0x07, 0x3f, 0xae, 0x12, 0xfb, 0x12, 0x2f, + 0x94, 0x19, 0x31, 0x94, 0x1c, 0x04, 0x28, 0xf6, 0x78, 0x69, 0x87, 0x6f, 0xa0, 0xae, 0xbc, 0x40, + 0xff, 0x28, 0x12, 0x42, 0x90, 0xdb, 0x8d, 0x8d, 0xd1, 0x88, 0xb0, 0x28, 0x71, 0x9b, 0xb1, 0x06, + 0x9c, 0x58, 0x81, 0x93, 0x02, 0x30, 0x76, 0xe5, 0xf1, 0x5a, 0x7c, 0x8e, 0xc2, 0xc7, 0x72, 0xce, + 0x0d, 0x89, 0x63, 0x2e, 0x52, 0xde, 0x97, 0x3d, 0x6e, 0x08, 0xe9, 0x28, 0x4b, 0x68, 0x12, 0x50, + 0xd8, 0x94, 0x43, 0xd1, 0x3e, 0xfe, 0xf1, 0xcf, 0x4a, 0x27, 0x2c, 0xf3, 0x31, 0x5a, 0x41, 0xe6, + 0xf2, 0x63, 0x14, 0x5c, 0xe6, 0xe3, 0x15, 0xc5, 0x92, 0x99, 0x5c, 0x5d, 0x5e, 0xa6, 0xf3, 0xb2, + 0x87, 0x67, 0x37, 0x0c, 0xc3, 0xd5, 0x32, 0xa4, 0xb5, 0xb7, 0x8d, 0xcd, 0xd5, 0x8a, 0x1c, 0xc7, + 0x1c, 0xbb, 0xb0, 0x01, 0x27, 0x6f, 0x03, 0x95, 0xfe, 0x9a, 0x0b, 0x51, 0x86, 0x48, 0xc9, 0x76, + 0x44, 0x42, 0xb9, 0xc1, 0x03, 0xe7, 0x72, 0x07, 0x40, 0xf8, 0x29, 0xd1, 0x55, 0x52, 0xe7, 0xca, + 0x7b, 0xc9, 0xdd, 0xdc, 0x1a, 0xd3, 0xd2, 0xba, 0xd4, 0xb6, 0xec, 0x59, 0xed, 0xca, 0xdd, 0x54, + 0x18, 0x9d, 0x39, 0xc4, 0x40, 0x42, 0xaa, 0xc4, 0x02, 0x22, 0x72, 0x97, 0x65, 0x83, 0xb0, 0x2c, + 0x8e, 0x7c, 0x8c, 0xba, 0x0d, 0x87, 0x83, 0xd3, 0xdf, 0x37, 0x61, 0x10, 0xbd, 0x6c, 0x9a, 0xcf, + 0xe3, 0x85, 0xe9, 0xfd, 0x13, 0x78, 0xa9, 0x64, 0x31, 0x1b, 0x4d, 0xbb, 0x37, 0x38, 0x0a, 0xaf, + 0x76, 0xa4, 0x5c, 0x88, 0xe5, 0x56, 0x71, 0x62, 0xb6, 0x48, 0x50, 0xb1, 0xd6, 0x9a, 0x30, 0xb1, + 0x6d, 0x02, 0xd6, 0x26, 0xd1, 0xb8, 0x09, 0xb2, 0x66, 0x4c, 0x54, 0x7f, 0x54, 0x05, 0x4d, 0x98, + 0x0f, 0x92, 0x48, 0xfc, 0x0c, 0x18, 0x58, 0x78, 0xc7, 0x0b, 0xb5, 0xf5, 0x42, 0x6d, 0x51, 0xa8, + 0x2d, 0x0a, 0xb5, 0xa1, 0x90, 0xe6, 0xef, 0x27, 0xd8, 0x7c, 0x1a, 0x05, 0x96, 0x8d, 0x3e, 0x7d, + 0x54, 0xa9, 0x89, 0x64, 0x84, 0x14, 0xcd, 0x14, 0xba, 0x84, 0xe3, 0x05, 0xb4, 0x21, 0x7c, 0xe1, + 0x68, 0xda, 0x10, 0xc9, 0x1c, 0x7d, 0xf8, 0x6a, 0x8f, 0x41, 0x84, 0x7f, 0xd7, 0xb7, 0xe4, 0xdd, + 0x2e, 0x57, 0xd6, 0xbc, 0xd5, 0xed, 0x92, 0xc7, 0x45, 0x8b, 0xaf, 0x53, 0x24, 0x1d, 0xd2, 0x88, + 0xbd, 0x40, 0xc4, 0x9e, 0x95, 0x62, 0xef, 0x49, 0xb9, 0xc1, 0x21, 0x84, 0xb1, 0x84, 0x08, 0xe1, + 0x0e, 0x85, 0x6d, 0xa0, 0x2f, 0x08, 0xdf, 0x55, 0x1c, 0x7e, 0x20, 0x18, 0x2a, 0xc4, 0xb3, 0xc7, + 0x2b, 0x0c, 0x3f, 0x99, 0x3e, 0x64, 0xe8, 0x81, 0xa1, 0xc0, 0xbe, 0x26, 0x0d, 0xd4, 0x59, 0xd1, + 0x5f, 0x9b, 0xe0, 0x32, 0x44, 0xe8, 0xb7, 0x05, 0x0f, 0x54, 0xe1, 0x57, 0x48, 0xd1, 0x24, 0x2c, + 0x96, 0x14, 0x24, 0x5e, 0x18, 0x23, 0xd2, 0xe7, 0xd5, 0xf8, 0xb8, 0xed, 0x74, 0xf8, 0x7c, 0x16, + 0xe2, 0xeb, 0x7e, 0xf2, 0x17, 0xf5, 0xd2, 0x22, 0xa7, 0x53, 0xe6, 0xfc, 0x2c, 0x2a, 0x04, 0xdb, + 0x0b, 0x8d, 0x5b, 0x26, 0xd4, 0x5a, 0x36, 0x6f, 0x99, 0x28, 0xa9, 0x87, 0x50, 0x82, 0xdb, 0x49, + 0xaa, 0xcc, 0xe5, 0x5e, 0x47, 0x60, 0x4c, 0x5d, 0x08, 0x25, 0x59, 0x36, 0x06, 0x21, 0xb3, 0x20, + 0x1b, 0x6d, 0x10, 0xe8, 0xb1, 0x8b, 0x89, 0x8d, 0x25, 0x49, 0xaf, 0x01, 0x5d, 0xa6, 0x31, 0x96, + 0xa5, 0x05, 0x38, 0xf5, 0x05, 0x3e, 0x0c, 0x5b, 0x96, 0x69, 0xc9, 0xea, 0xc5, 0x13, 0xc4, 0x83, + 0x60, 0xc8, 0x41, 0xd0, 0x35, 0x24, 0x99, 0xd9, 0x3b, 0x08, 0x16, 0xf8, 0xd9, 0x28, 0xef, 0x0d, + 0x75, 0x5a, 0xe7, 0x59, 0x1e, 0xe7, 0x69, 0x77, 0xb1, 0x9a, 0x24, 0xd9, 0xd8, 0x52, 0x90, 0x84, + 0x98, 0xd3, 0x76, 0x93, 0x14, 0x21, 0xde, 0x1b, 0xe2, 0x08, 0x8c, 0x2f, 0x60, 0xf7, 0x60, 0xcd, + 0x06, 0x1a, 0x49, 0x1d, 0xc7, 0x49, 0x8a, 0x16, 0xae, 0x71, 0x3c, 0x4d, 0x2d, 0x10, 0x03, 0xf6, + 0x7a, 0x83, 0x96, 0x2d, 0x38, 0x00, 0x44, 0xb0, 0x9e, 0x8c, 0x47, 0x80, 0x98, 0xcb, 0x93, 0x78, + 0x16, 0x5a, 0x8e, 0x5c, 0x15, 0x4d, 0xbb, 0x82, 0x61, 0xa7, 0xb0, 0xe8, 0x33, 0x79, 0x79, 0x5c, + 0xe8, 0x31, 0x91, 0x3c, 0x2b, 0xf9, 0x49, 0x13, 0xe6, 0x1d, 0x55, 0x73, 0xd9, 0x39, 0x15, 0xac, + 0x79, 0x08, 0x0f, 0x20, 0x4b, 0x84, 0x0e, 0x61, 0xa9, 0x08, 0x54, 0xe6, 0xcb, 0x45, 0x3a, 0x98, + 0x40, 0xb0, 0x41, 0xc4, 0x79, 0xe3, 0x34, 0x6a, 0x68, 0xf3, 0xfa, 0xaf, 0xce, 0x77, 0xa6, 0xa8, + 0x42, 0x9f, 0xc2, 0x02, 0xf6, 0x83, 0x65, 0xfa, 0xc2, 0x3b, 0x23, 0x3f, 0xd8, 0x67, 0x2d, 0xea, + 0x54, 0x4c, 0x05, 0x88, 0x41, 0x42, 0xd0, 0x5f, 0xad, 0xef, 0x3e, 0xfd, 0xd5, 0xfe, 0xee, 0xb3, + 0x09, 0xec, 0x06, 0x38, 0x6e, 0x71, 0x78, 0x57, 0x83, 0x3e, 0xab, 0x41, 0x8d, 0xf7, 0xab, 0x90, + 0x57, 0x56, 0x44, 0x5c, 0xd6, 0x94, 0xf5, 0x88, 0xa9, 0x54, 0xa1, 0xf8, 0xd4, 0x34, 0xd5, 0x57, + 0x76, 0x9e, 0x8d, 0xa6, 0xf9, 0xba, 0x10, 0xda, 0x34, 0x12, 0x32, 0x97, 0x46, 0x48, 0x04, 0x0d, + 0x33, 0x21, 0x8d, 0x22, 0x15, 0x5b, 0x53, 0x1d, 0x45, 0x06, 0x45, 0xa4, 0x4b, 0xa4, 0xcf, 0x91, + 0xda, 0x4f, 0x07, 0x56, 0xc4, 0x41, 0x89, 0x08, 0xac, 0x7d, 0x38, 0x28, 0xc9, 0x0d, 0xac, 0x38, + 0x15, 0xda, 0x24, 0x97, 0x16, 0x25, 0x8f, 0x98, 0x65, 0x60, 0xa7, 0x80, 0x0b, 0x53, 0xa5, 0x1d, + 0x9b, 0x5e, 0xe0, 0x59, 0x0e, 0xa1, 0x27, 0xbd, 0xa8, 0x50, 0x9a, 0x9d, 0x8b, 0x42, 0x8a, 0x00, + 0x3b, 0xff, 0x44, 0xe5, 0x44, 0xed, 0x27, 0xcc, 0xa5, 0x41, 0xe7, 0x08, 0x7b, 0x59, 0xf1, 0x48, + 0x28, 0xac, 0x8e, 0xa5, 0x33, 0x91, 0xd5, 0xa0, 0xc9, 0xa3, 0x9a, 0x42, 0xc2, 0x5f, 0x8a, 0xf8, + 0x66, 0xba, 0x22, 0x99, 0x5a, 0xe7, 0x6b, 0x07, 0x91, 0xc4, 0x5e, 0x6e, 0xe3, 0x90, 0xd0, 0xfc, + 0x5d, 0x9e, 0x58, 0x1f, 0xaf, 0xe5, 0x2a, 0x28, 0x8c, 0x20, 0x86, 0x4c, 0x22, 0x53, 0x45, 0x00, + 0x6f, 0x4c, 0xbf, 0x09, 0xf5, 0x66, 0xe0, 0xf8, 0xb1, 0x0e, 0x9c, 0x9d, 0xc2, 0x07, 0xb4, 0xd4, + 0x85, 0xc6, 0x87, 0xe3, 0x57, 0x70, 0xc6, 0x2b, 0xbc, 0x93, 0xbb, 0x02, 0xcf, 0x76, 0xc4, 0xab, + 0xd3, 0x08, 0x87, 0x29, 0x95, 0x65, 0x40, 0x5d, 0xc3, 0xaf, 0xf2, 0x27, 0x29, 0xd8, 0x43, 0xd2, + 0x09, 0x07, 0x67, 0x2d, 0x2f, 0x08, 0x0e, 0xe4, 0x1a, 0xfb, 0xa4, 0x1d, 0x17, 0x61, 0xaf, 0x32, + 0x47, 0xe3, 0x63, 0x3f, 0x3d, 0x27, 0xc7, 0xd7, 0x7f, 0xf5, 0x68, 0xa4, 0x5f, 0xd9, 0xf3, 0x0c, + 0xb2, 0xd1, 0xb4, 0xba, 0xf0, 0x31, 0x91, 0x21, 0x51, 0x47, 0x2a, 0x81, 0x6a, 0x24, 0x3b, 0x4e, + 0x5b, 0x7d, 0xa8, 0x43, 0x5a, 0x2b, 0x1c, 0xa8, 0x09, 0x37, 0x75, 0xad, 0x3d, 0x1e, 0xdf, 0xb8, + 0x0a, 0x0e, 0x21, 0x5a, 0x2f, 0xe7, 0x4b, 0x29, 0xfe, 0xf4, 0x35, 0x95, 0xca, 0xe8, 0xdf, 0x40, + 0x5a, 0xa0, 0x60, 0xf4, 0xe5, 0x25, 0x88, 0x2d, 0x27, 0xf4, 0xd3, 0x51, 0x75, 0x28, 0x1e, 0x9d, + 0x5c, 0x68, 0x0a, 0x91, 0x9c, 0x8f, 0x84, 0x28, 0xb6, 0x29, 0x20, 0x0e, 0xaf, 0xa2, 0x4f, 0xd4, + 0x3e, 0x34, 0x54, 0xfd, 0x42, 0x5d, 0xf8, 0xf8, 0xb3, 0x55, 0xe0, 0x26, 0x81, 0xd8, 0xd9, 0x0a, + 0xd2, 0xd6, 0xf7, 0xba, 0x54, 0xd4, 0xb5, 0x3a, 0x6f, 0xa9, 0xa9, 0x14, 0x3e, 0x49, 0xa8, 0xa8, + 0xcd, 0xd7, 0xf6, 0x7b, 0x3a, 0xd3, 0x64, 0xd5, 0x0b, 0x3b, 0x9a, 0x28, 0x80, 0xa7, 0xd5, 0x6b, + 0x7d, 0x2f, 0x82, 0xfe, 0x26, 0xfe, 0x20, 0x97, 0x9c, 0xbb, 0xda, 0xab, 0xfc, 0x0f, 0xaf, 0xf2, + 0xdb, 0x3c, 0xc5, 0xa3, 0xf1, 0xb8, 0xec, 0xe4, 0x92, 0xc8, 0xb7, 0x1f, 0x5f, 0x12, 0x30, 0xa6, + 0x33, 0x4c, 0x52, 0x6e, 0x99, 0xf3, 0x5f, 0x05, 0x2b, 0x7b, 0xf9, 0x29, 0x1e, 0x67, 0x65, 0x14, + 0x8b, 0x7c, 0x3b, 0xc5, 0x02, 0xc6, 0x44, 0xb1, 0x94, 0x5b, 0x46, 0xb1, 0x0a, 0xf6, 0xa2, 0x0f, + 0x3b, 0xe1, 0xa6, 0x94, 0x9c, 0x9b, 0x11, 0xf9, 0xf6, 0x47, 0x59, 0x39, 0x88, 0xf1, 0x61, 0x56, + 0x91, 0x5b, 0xfa, 0x30, 0x97, 0x02, 0xb6, 0x8e, 0x60, 0xfb, 0xb9, 0x36, 0x9e, 0x5d, 0x4e, 0xae, + 0xed, 0x84, 0x9b, 0xc8, 0x5c, 0x4b, 0xac, 0xb2, 0x37, 0xf1, 0x1c, 0x6d, 0xc1, 0xc7, 0x34, 0xd9, + 0x37, 0x75, 0x1f, 0x98, 0x4c, 0xfc, 0x6a, 0x36, 0x2b, 0x48, 0x61, 0xc5, 0xed, 0x7a, 0x48, 0x13, + 0xdb, 0x95, 0xac, 0x55, 0x49, 0xca, 0x89, 0x9f, 0xa6, 0x23, 0x56, 0x22, 0xd7, 0x57, 0x65, 0x9f, + 0xe9, 0xb0, 0x95, 0x8c, 0x6a, 0x2b, 0xf9, 0x25, 0x7e, 0x9a, 0x68, 0x11, 0xb9, 0xbe, 0x2a, 0xd5, + 0x4c, 0xb4, 0xc8, 0xa8, 0x36, 0x97, 0x4c, 0x3b, 0x3f, 0x9b, 0x25, 0x09, 0x1c, 0xf1, 0xd3, 0xf4, + 0x16, 0x2f, 0xcf, 0xf4, 0x55, 0x29, 0x64, 0x7c, 0x93, 0x57, 0xc2, 0xb4, 0x8d, 0x28, 0xe1, 0xbf, + 0x6c, 0x84, 0xd0, 0x53, 0x71, 0x92, 0x74, 0xb1, 0x92, 0x41, 0xb7, 0x2e, 0x8b, 0x32, 0x62, 0xef, + 0xd5, 0xd8, 0x7b, 0x35, 0xf6, 0x5e, 0x8d, 0xbd, 0x57, 0x63, 0xef, 0xd5, 0x78, 0x3d, 0x5e, 0x0d, + 0x76, 0x22, 0x58, 0x9c, 0x79, 0x53, 0x4e, 0xc9, 0x11, 0x3e, 0x78, 0x56, 0x8e, 0x0f, 0xf1, 0x5a, + 0xd2, 0x7c, 0x96, 0x8d, 0x63, 0x68, 0xfd, 0x3d, 0x3c, 0x21, 0x54, 0x3f, 0x23, 0x27, 0xdc, 0x50, + 0xdb, 0x9a, 0x4b, 0xb8, 0x73, 0x85, 0xaf, 0x8e, 0x11, 0x25, 0x8d, 0x6c, 0x20, 0x4a, 0x1d, 0xe4, + 0x93, 0x67, 0x40, 0x6d, 0xf5, 0x93, 0x60, 0x72, 0xf4, 0xf2, 0xd3, 0xc5, 0xa7, 0xcf, 0xdd, 0xf3, + 0x3f, 0x6b, 0xef, 0xa4, 0xfb, 0x50, 0xa7, 0x9f, 0x7e, 0x3e, 0xed, 0xfe, 0x7c, 0xf2, 0xeb, 0xaf, + 0x27, 0xa8, 0xb5, 0xed, 0xd6, 0xb1, 0xe1, 0x30, 0xcc, 0x41, 0x51, 0x6b, 0x86, 0xc5, 0xb8, 0x82, + 0x1d, 0xbc, 0x5b, 0x1b, 0x76, 0x87, 0xf6, 0xe7, 0xae, 0x4c, 0xc8, 0x9d, 0xda, 0x7f, 0x8f, 0x60, + 0xbe, 0x99, 0xbc, 0x79, 0x66, 0x93, 0x47, 0x3e, 0x6d, 0x65, 0xb1, 0xd2, 0xee, 0x61, 0xc8, 0x94, + 0x72, 0xe9, 0x66, 0x76, 0x48, 0xb9, 0x19, 0xb2, 0x91, 0x19, 0xf1, 0x18, 0xa7, 0xef, 0x24, 0xe6, + 0xd9, 0x4c, 0x9f, 0x2f, 0xe3, 0x8c, 0xcd, 0x54, 0x72, 0x10, 0xcf, 0x74, 0x78, 0x40, 0xb1, 0x2e, + 0x8a, 0x74, 0x3a, 0x4c, 0xfc, 0xb2, 0x3a, 0xd6, 0x07, 0x59, 0xe2, 0x4a, 0x96, 0xcc, 0xac, 0xf1, + 0x34, 0x53, 0xe8, 0xd8, 0x15, 0x75, 0x1a, 0x11, 0xb4, 0x81, 0x8c, 0x84, 0x34, 0xa4, 0x32, 0xfb, + 0x61, 0xe2, 0x22, 0x21, 0x0a, 0x03, 0x87, 0xe3, 0xf7, 0x14, 0xd6, 0x74, 0x43, 0xf9, 0x4c, 0xe5, + 0xd5, 0xe5, 0x65, 0xe4, 0x60, 0x55, 0xb9, 0x81, 0xef, 0x2d, 0x50, 0xb5, 0x99, 0x2b, 0xe2, 0xd0, + 0x3f, 0xec, 0x30, 0x4e, 0x24, 0xb1, 0x00, 0xa9, 0xce, 0xe1, 0xdd, 0xe7, 0xb5, 0x9b, 0xed, 0xf7, + 0x01, 0x11, 0xce, 0x75, 0x41, 0x85, 0x5b, 0x42, 0x06, 0xa9, 0x1b, 0x6a, 0x16, 0xa3, 0x19, 0x88, + 0x05, 0x95, 0x22, 0x0b, 0xef, 0x24, 0x72, 0xf1, 0x91, 0x40, 0x93, 0xbf, 0x18, 0xbc, 0xc5, 0xcd, + 0xb8, 0xd8, 0x21, 0xa4, 0xae, 0x7e, 0x84, 0x3f, 0x3c, 0x79, 0x82, 0x2a, 0x6a, 0x0e, 0xf6, 0x55, + 0x4b, 0x87, 0x08, 0x81, 0xb4, 0x86, 0x8c, 0xc0, 0x87, 0x94, 0xba, 0x92, 0x52, 0xf1, 0xc4, 0xa0, + 0xa7, 0xae, 0x64, 0xf7, 0xf2, 0x65, 0xff, 0x1f, 0x03, 0x90, 0xfe, 0x1c +}; + +const char* shaderSource() { + static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressedShaderSource), sizeof(compressedShaderSource))); + return decompressed.c_str(); +}; + +} // namespace gl +} // namespace programs +} // namespace mbgl diff --git a/src/mbgl/shaders/source.hpp b/src/mbgl/programs/gl/shader_source.hpp index 38a5ea6ece..f6de8a56cc 100644 --- a/src/mbgl/shaders/source.hpp +++ b/src/mbgl/programs/gl/shader_source.hpp @@ -3,9 +3,11 @@ #pragma once namespace mbgl { -namespace shaders { +namespace programs { +namespace gl { -const char* source(); +const char* shaderSource(); -} // namespace shaders +} // namespace gl +} // namespace programs } // namespace mbgl diff --git a/src/mbgl/shaders/shaders.cpp b/src/mbgl/programs/gl/shaders.cpp index 578c2db624..3cc33992de 100644 --- a/src/mbgl/shaders/shaders.cpp +++ b/src/mbgl/programs/gl/shaders.cpp @@ -1,19 +1,20 @@ -#include <mbgl/shaders/shaders.hpp> -#include <mbgl/shaders/preludes.hpp> +#include <mbgl/programs/gl/shaders.hpp> +#include <mbgl/programs/gl/preludes.hpp> #include <mbgl/programs/program_parameters.hpp> #include <mbgl/util/string.hpp> #include <cassert> namespace mbgl { -namespace shaders { +namespace programs { +namespace gl { std::string fragmentSource(const ProgramParameters& parameters, const char* fragmentSource) { - return parameters.getDefines() + fragmentPrelude + fragmentSource; + return parameters.getDefines() + fragmentShaderPrelude + fragmentSource; } std::string vertexSource(const ProgramParameters& parameters, const char* vertexSource) { - return parameters.getDefines() + vertexPrelude + vertexSource; + return parameters.getDefines() + vertexShaderPrelude + vertexSource; } std::string programIdentifier(const std::string& vertexSource, const std::string& fragmentSource) { @@ -25,5 +26,6 @@ std::string programIdentifier(const std::string& vertexSource, const std::string return result; } -} // namespace shaders +} // namespace gl +} // namespace programs } // namespace mbgl diff --git a/src/mbgl/shaders/shaders.hpp b/src/mbgl/programs/gl/shaders.hpp index 513d37fa6f..5278ea54da 100644 --- a/src/mbgl/shaders/shaders.hpp +++ b/src/mbgl/programs/gl/shaders.hpp @@ -6,11 +6,13 @@ namespace mbgl { class ProgramParameters; -namespace shaders { +namespace programs { +namespace gl { std::string fragmentSource(const ProgramParameters&, const char* fragmentSource); std::string vertexSource(const ProgramParameters&, const char* vertexSource); std::string programIdentifier(const std::string& vertexSource, const std::string& fragmentSource); -} // namespace shaders +} // namespace gl +} // namespace programs } // namespace mbgl diff --git a/src/mbgl/shaders/symbol_icon.cpp b/src/mbgl/programs/gl/symbol_icon.cpp index 7e10f23aa2..733d3b7ebd 100644 --- a/src/mbgl/shaders/symbol_icon.cpp +++ b/src/mbgl/programs/gl/symbol_icon.cpp @@ -1,14 +1,22 @@ // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. -#include <mbgl/shaders/symbol_icon.hpp> -#include <mbgl/shaders/source.hpp> +#include <mbgl/programs/symbol_icon_program.hpp> +#include <mbgl/programs/gl/shader_source.hpp> +#include <mbgl/gl/program.hpp> namespace mbgl { -namespace shaders { +namespace gfx { + +template <> +std::unique_ptr<Program<SymbolIconProgram>> +Context::createProgram<gl::Context>(const ProgramParameters& programParameters) { + return gl::Program<SymbolIconProgram>::createProgram( + reinterpret_cast<gl::Context&>(*this), programParameters, "symbol_icon", + programs::gl::shaderSource() + 50000, programs::gl::shaderSource() + 52654); +} -const char* symbol_icon::name = "symbol_icon"; -const char* symbol_icon::vertexSource = source() + 50000; -const char* symbol_icon::fragmentSource = source() + 52654; +} // namespace gfx +} // namespace mbgl // Uncompressed source of symbol_icon.vertex.glsl: /* @@ -152,5 +160,3 @@ void main() { */ -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/symbol_sdf.cpp b/src/mbgl/programs/gl/symbol_sdf_icon.cpp index 1ffc4c338c..ef3ecd138c 100644 --- a/src/mbgl/shaders/symbol_sdf.cpp +++ b/src/mbgl/programs/gl/symbol_sdf_icon.cpp @@ -1,16 +1,24 @@ // NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. -#include <mbgl/shaders/symbol_sdf.hpp> -#include <mbgl/shaders/source.hpp> +#include <mbgl/programs/symbol_sdf_icon_program.hpp> +#include <mbgl/programs/gl/shader_source.hpp> +#include <mbgl/gl/program.hpp> namespace mbgl { -namespace shaders { +namespace gfx { + +template <> +std::unique_ptr<Program<SymbolSDFIconProgram>> +Context::createProgram<gl::Context>(const ProgramParameters& programParameters) { + return gl::Program<SymbolSDFIconProgram>::createProgram( + reinterpret_cast<gl::Context&>(*this), programParameters, "symbol_sdf_icon", + programs::gl::shaderSource() + 53059, programs::gl::shaderSource() + 57099); +} -const char* symbol_sdf::name = "symbol_sdf"; -const char* symbol_sdf::vertexSource = source() + 53059; -const char* symbol_sdf::fragmentSource = source() + 57099; +} // namespace gfx +} // namespace mbgl -// Uncompressed source of symbol_sdf.vertex.glsl: +// Uncompressed source of symbol_sdf_icon.vertex.glsl: /* const float PI = 3.141592653589793; @@ -202,7 +210,7 @@ void main() { */ -// Uncompressed source of symbol_sdf.fragment.glsl: +// Uncompressed source of symbol_sdf_icon.fragment.glsl: /* #define SDF_PX 8.0 #define EDGE_GAMMA 0.105/DEVICE_PIXEL_RATIO @@ -307,5 +315,3 @@ void main() { */ -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/programs/gl/symbol_sdf_text.cpp b/src/mbgl/programs/gl/symbol_sdf_text.cpp new file mode 100644 index 0000000000..a0d810d1ce --- /dev/null +++ b/src/mbgl/programs/gl/symbol_sdf_text.cpp @@ -0,0 +1,317 @@ +// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. + +#include <mbgl/programs/symbol_sdf_text_program.hpp> +#include <mbgl/programs/gl/shader_source.hpp> +#include <mbgl/gl/program.hpp> + +namespace mbgl { +namespace gfx { + +template <> +std::unique_ptr<Program<SymbolSDFTextProgram>> +Context::createProgram<gl::Context>(const ProgramParameters& programParameters) { + return gl::Program<SymbolSDFTextProgram>::createProgram( + reinterpret_cast<gl::Context&>(*this), programParameters, "symbol_sdf_text", + programs::gl::shaderSource() + 53059, programs::gl::shaderSource() + 57099); +} + +} // namespace gfx +} // namespace mbgl + +// Uncompressed source of symbol_sdf_text.vertex.glsl: +/* +const float PI = 3.141592653589793; + +attribute vec4 a_pos_offset; +attribute vec4 a_data; +attribute vec3 a_projected_pos; +attribute float a_fade_opacity; + +// contents of a_size vary based on the type of property value +// used for {text,icon}-size. +// For constants, a_size is disabled. +// For source functions, we bind only one value per vertex: the value of {text,icon}-size evaluated for the current feature. +// For composite functions: +// [ text-size(lowerZoomStop, feature), +// text-size(upperZoomStop, feature) ] +uniform bool u_is_size_zoom_constant; +uniform bool u_is_size_feature_constant; +uniform highp float u_size_t; // used to interpolate between zoom stops when size is a composite function +uniform highp float u_size; // used when size is both zoom and feature constant + + +#ifndef HAS_UNIFORM_u_fill_color +uniform lowp float a_fill_color_t; +attribute highp vec4 a_fill_color; +varying highp vec4 fill_color; +#else +uniform highp vec4 u_fill_color; +#endif + + +#ifndef HAS_UNIFORM_u_halo_color +uniform lowp float a_halo_color_t; +attribute highp vec4 a_halo_color; +varying highp vec4 halo_color; +#else +uniform highp vec4 u_halo_color; +#endif + + +#ifndef HAS_UNIFORM_u_opacity +uniform lowp float a_opacity_t; +attribute lowp vec2 a_opacity; +varying lowp float opacity; +#else +uniform lowp float u_opacity; +#endif + + +#ifndef HAS_UNIFORM_u_halo_width +uniform lowp float a_halo_width_t; +attribute lowp vec2 a_halo_width; +varying lowp float halo_width; +#else +uniform lowp float u_halo_width; +#endif + + +#ifndef HAS_UNIFORM_u_halo_blur +uniform lowp float a_halo_blur_t; +attribute lowp vec2 a_halo_blur; +varying lowp float halo_blur; +#else +uniform lowp float u_halo_blur; +#endif + + +uniform mat4 u_matrix; +uniform mat4 u_label_plane_matrix; +uniform mat4 u_gl_coord_matrix; + +uniform bool u_is_text; +uniform bool u_pitch_with_map; +uniform highp float u_pitch; +uniform bool u_rotate_symbol; +uniform highp float u_aspect_ratio; +uniform highp float u_camera_to_center_distance; +uniform float u_fade_change; + +uniform vec2 u_texsize; + +varying vec2 v_data0; +varying vec3 v_data1; + +void main() { + +#ifndef HAS_UNIFORM_u_fill_color + fill_color = unpack_mix_color(a_fill_color, a_fill_color_t); +#else + highp vec4 fill_color = u_fill_color; +#endif + + +#ifndef HAS_UNIFORM_u_halo_color + halo_color = unpack_mix_color(a_halo_color, a_halo_color_t); +#else + highp vec4 halo_color = u_halo_color; +#endif + + +#ifndef HAS_UNIFORM_u_opacity + opacity = unpack_mix_vec2(a_opacity, a_opacity_t); +#else + lowp float opacity = u_opacity; +#endif + + +#ifndef HAS_UNIFORM_u_halo_width + halo_width = unpack_mix_vec2(a_halo_width, a_halo_width_t); +#else + lowp float halo_width = u_halo_width; +#endif + + +#ifndef HAS_UNIFORM_u_halo_blur + halo_blur = unpack_mix_vec2(a_halo_blur, a_halo_blur_t); +#else + lowp float halo_blur = u_halo_blur; +#endif + + + vec2 a_pos = a_pos_offset.xy; + vec2 a_offset = a_pos_offset.zw; + + vec2 a_tex = a_data.xy; + vec2 a_size = a_data.zw; + + highp float segment_angle = -a_projected_pos[2]; + float size; + + if (!u_is_size_zoom_constant && !u_is_size_feature_constant) { + size = mix(a_size[0], a_size[1], u_size_t) / 256.0; + } else if (u_is_size_zoom_constant && !u_is_size_feature_constant) { + size = a_size[0] / 256.0; + } else if (!u_is_size_zoom_constant && u_is_size_feature_constant) { + size = u_size; + } else { + size = u_size; + } + + vec4 projectedPoint = u_matrix * vec4(a_pos, 0, 1); + highp float camera_to_anchor_distance = projectedPoint.w; + // If the label is pitched with the map, layout is done in pitched space, + // which makes labels in the distance smaller relative to viewport space. + // We counteract part of that effect by multiplying by the perspective ratio. + // If the label isn't pitched with the map, we do layout in viewport space, + // which makes labels in the distance larger relative to the features around + // them. We counteract part of that effect by dividing by the perspective ratio. + highp float distance_ratio = u_pitch_with_map ? + camera_to_anchor_distance / u_camera_to_center_distance : + u_camera_to_center_distance / camera_to_anchor_distance; + highp float perspective_ratio = clamp( + 0.5 + 0.5 * distance_ratio, + 0.0, // Prevents oversized near-field symbols in pitched/overzoomed tiles + 4.0); + + size *= perspective_ratio; + + float fontScale = u_is_text ? size / 24.0 : size; + + highp float symbol_rotation = 0.0; + if (u_rotate_symbol) { + // Point labels with 'rotation-alignment: map' are horizontal with respect to tile units + // To figure out that angle in projected space, we draw a short horizontal line in tile + // space, project it, and measure its angle in projected space. + vec4 offsetProjectedPoint = u_matrix * vec4(a_pos + vec2(1, 0), 0, 1); + + vec2 a = projectedPoint.xy / projectedPoint.w; + vec2 b = offsetProjectedPoint.xy / offsetProjectedPoint.w; + + symbol_rotation = atan((b.y - a.y) / u_aspect_ratio, b.x - a.x); + } + + highp float angle_sin = sin(segment_angle + symbol_rotation); + highp float angle_cos = cos(segment_angle + symbol_rotation); + mat2 rotation_matrix = mat2(angle_cos, -1.0 * angle_sin, angle_sin, angle_cos); + + vec4 projected_pos = u_label_plane_matrix * vec4(a_projected_pos.xy, 0.0, 1.0); + gl_Position = u_gl_coord_matrix * vec4(projected_pos.xy / projected_pos.w + rotation_matrix * (a_offset / 32.0 * fontScale), 0.0, 1.0); + float gamma_scale = gl_Position.w; + + vec2 tex = a_tex / u_texsize; + vec2 fade_opacity = unpack_opacity(a_fade_opacity); + float fade_change = fade_opacity[1] > 0.5 ? u_fade_change : -u_fade_change; + float interpolated_fade_opacity = max(0.0, min(1.0, fade_opacity[0] + fade_change)); + + v_data0 = vec2(tex.x, tex.y); + v_data1 = vec3(gamma_scale, size, interpolated_fade_opacity); +} + +*/ + +// Uncompressed source of symbol_sdf_text.fragment.glsl: +/* +#define SDF_PX 8.0 +#define EDGE_GAMMA 0.105/DEVICE_PIXEL_RATIO + +uniform bool u_is_halo; + +#ifndef HAS_UNIFORM_u_fill_color +varying highp vec4 fill_color; +#else +uniform highp vec4 u_fill_color; +#endif + + +#ifndef HAS_UNIFORM_u_halo_color +varying highp vec4 halo_color; +#else +uniform highp vec4 u_halo_color; +#endif + + +#ifndef HAS_UNIFORM_u_opacity +varying lowp float opacity; +#else +uniform lowp float u_opacity; +#endif + + +#ifndef HAS_UNIFORM_u_halo_width +varying lowp float halo_width; +#else +uniform lowp float u_halo_width; +#endif + + +#ifndef HAS_UNIFORM_u_halo_blur +varying lowp float halo_blur; +#else +uniform lowp float u_halo_blur; +#endif + + +uniform sampler2D u_texture; +uniform highp float u_gamma_scale; +uniform bool u_is_text; + +varying vec2 v_data0; +varying vec3 v_data1; + +void main() { + +#ifdef HAS_UNIFORM_u_fill_color + highp vec4 fill_color = u_fill_color; +#endif + + +#ifdef HAS_UNIFORM_u_halo_color + highp vec4 halo_color = u_halo_color; +#endif + + +#ifdef HAS_UNIFORM_u_opacity + lowp float opacity = u_opacity; +#endif + + +#ifdef HAS_UNIFORM_u_halo_width + lowp float halo_width = u_halo_width; +#endif + + +#ifdef HAS_UNIFORM_u_halo_blur + lowp float halo_blur = u_halo_blur; +#endif + + + vec2 tex = v_data0.xy; + float gamma_scale = v_data1.x; + float size = v_data1.y; + float fade_opacity = v_data1[2]; + + float fontScale = u_is_text ? size / 24.0 : size; + + lowp vec4 color = fill_color; + highp float gamma = EDGE_GAMMA / (fontScale * u_gamma_scale); + lowp float buff = (256.0 - 64.0) / 256.0; + if (u_is_halo) { + color = halo_color; + gamma = (halo_blur * 1.19 / SDF_PX + EDGE_GAMMA) / (fontScale * u_gamma_scale); + buff = (6.0 - halo_width / fontScale) / SDF_PX; + } + + lowp float dist = texture2D(u_texture, tex).a; + highp float gamma_scaled = gamma * gamma_scale; + highp float alpha = smoothstep(buff - gamma_scaled, buff + gamma_scaled, dist); + + gl_FragColor = color * (alpha * opacity * fade_opacity); + +#ifdef OVERDRAW_INSPECTOR + gl_FragColor = vec4(1.0); +#endif +} + +*/ + diff --git a/src/mbgl/programs/heatmap_program.cpp b/src/mbgl/programs/heatmap_program.cpp index 67f84fbd52..32c30ea313 100644 --- a/src/mbgl/programs/heatmap_program.cpp +++ b/src/mbgl/programs/heatmap_program.cpp @@ -1,7 +1,10 @@ #include <mbgl/programs/heatmap_program.hpp> +#include <mbgl/gfx/context_impl.hpp> namespace mbgl { +template std::unique_ptr<gfx::Program<HeatmapProgram>> gfx::Context::createProgram(const ProgramParameters&); + static_assert(sizeof(HeatmapLayoutVertex) == 4, "expected HeatmapLayoutVertex size"); } // namespace mbgl diff --git a/src/mbgl/programs/heatmap_program.hpp b/src/mbgl/programs/heatmap_program.hpp index a90e9d4053..9563dd8d1b 100644 --- a/src/mbgl/programs/heatmap_program.hpp +++ b/src/mbgl/programs/heatmap_program.hpp @@ -4,7 +4,6 @@ #include <mbgl/programs/attributes.hpp> #include <mbgl/programs/heatmap_texture_program.hpp> #include <mbgl/programs/uniforms.hpp> -#include <mbgl/shaders/heatmap.hpp> #include <mbgl/util/geometry.hpp> #include <mbgl/style/layers/heatmap_layer_properties.hpp> @@ -15,8 +14,8 @@ MBGL_DEFINE_UNIFORM_SCALAR(float, u_intensity); } // namespace uniforms class HeatmapProgram : public Program< - shaders::heatmap, - gfx::Triangle, + HeatmapProgram, + gfx::PrimitiveType::Triangle, TypeList< attributes::a_pos>, TypeList< @@ -46,11 +45,11 @@ public: }; using HeatmapLayoutVertex = HeatmapProgram::LayoutVertex; -using HeatmapAttributes = HeatmapProgram::Attributes; +using HeatmapAttributes = HeatmapProgram::AttributeList; class HeatmapLayerPrograms final : public LayerTypePrograms { public: - HeatmapLayerPrograms(gl::Context& context, const ProgramParameters& programParameters) + HeatmapLayerPrograms(gfx::Context& context, const ProgramParameters& programParameters) : heatmap(context, programParameters), heatmapTexture(context, programParameters) {} ProgramMap<HeatmapProgram> heatmap; diff --git a/src/mbgl/programs/heatmap_texture_program.cpp b/src/mbgl/programs/heatmap_texture_program.cpp index 3b0e24eab8..04c5ff56a7 100644 --- a/src/mbgl/programs/heatmap_texture_program.cpp +++ b/src/mbgl/programs/heatmap_texture_program.cpp @@ -1,7 +1,10 @@ #include <mbgl/programs/heatmap_texture_program.hpp> +#include <mbgl/gfx/context_impl.hpp> namespace mbgl { +template std::unique_ptr<gfx::Program<HeatmapTextureProgram>> gfx::Context::createProgram(const ProgramParameters&); + static_assert(sizeof(HeatmapTextureLayoutVertex) == 4, "expected HeatmapTextureLayoutVertex size"); } // namespace mbgl diff --git a/src/mbgl/programs/heatmap_texture_program.hpp b/src/mbgl/programs/heatmap_texture_program.hpp index a1d3835821..954e03f9b6 100644 --- a/src/mbgl/programs/heatmap_texture_program.hpp +++ b/src/mbgl/programs/heatmap_texture_program.hpp @@ -4,15 +4,14 @@ #include <mbgl/programs/attributes.hpp> #include <mbgl/programs/uniforms.hpp> #include <mbgl/programs/textures.hpp> -#include <mbgl/shaders/heatmap_texture.hpp> #include <mbgl/style/properties.hpp> #include <mbgl/util/geometry.hpp> namespace mbgl { class HeatmapTextureProgram : public Program< - shaders::heatmap_texture, - gfx::Triangle, + HeatmapTextureProgram, + gfx::PrimitiveType::Triangle, TypeList<attributes::a_pos>, TypeList< uniforms::u_matrix, @@ -36,6 +35,6 @@ public: }; using HeatmapTextureLayoutVertex = HeatmapTextureProgram::LayoutVertex; -using HeatmapTextureAttributes = HeatmapTextureProgram::Attributes; +using HeatmapTextureAttributes = HeatmapTextureProgram::AttributeList; } // namespace mbgl diff --git a/src/mbgl/programs/hillshade_prepare_program.cpp b/src/mbgl/programs/hillshade_prepare_program.cpp index 0c0446d3f5..5bbac9eaec 100644 --- a/src/mbgl/programs/hillshade_prepare_program.cpp +++ b/src/mbgl/programs/hillshade_prepare_program.cpp @@ -1,7 +1,10 @@ #include <mbgl/programs/hillshade_prepare_program.hpp> +#include <mbgl/gfx/context_impl.hpp> namespace mbgl { +template std::unique_ptr<gfx::Program<HillshadePrepareProgram>> gfx::Context::createProgram(const ProgramParameters&); + static_assert(sizeof(HillshadePrepareLayoutVertex) == 8, "expected HillshadeLayoutVertex size"); } // namespace mbgl diff --git a/src/mbgl/programs/hillshade_prepare_program.hpp b/src/mbgl/programs/hillshade_prepare_program.hpp index b58525bbfd..0243cc1879 100644 --- a/src/mbgl/programs/hillshade_prepare_program.hpp +++ b/src/mbgl/programs/hillshade_prepare_program.hpp @@ -4,7 +4,6 @@ #include <mbgl/programs/attributes.hpp> #include <mbgl/programs/uniforms.hpp> #include <mbgl/programs/textures.hpp> -#include <mbgl/shaders/hillshade_prepare.hpp> #include <mbgl/util/geometry.hpp> namespace mbgl { @@ -15,8 +14,8 @@ MBGL_DEFINE_UNIFORM_SCALAR(float, u_maxzoom); } // namespace uniforms class HillshadePrepareProgram : public Program< - shaders::hillshade_prepare, - gfx::Triangle, + HillshadePrepareProgram, + gfx::PrimitiveType::Triangle, TypeList< attributes::a_pos, attributes::a_texture_pos>, @@ -46,6 +45,6 @@ public: }; using HillshadePrepareLayoutVertex = HillshadePrepareProgram::LayoutVertex; -using HillshadePrepareAttributes = HillshadePrepareProgram::Attributes; +using HillshadePrepareAttributes = HillshadePrepareProgram::AttributeList; } // namespace mbgl diff --git a/src/mbgl/programs/hillshade_program.cpp b/src/mbgl/programs/hillshade_program.cpp index f054ad4b74..31673afcd4 100644 --- a/src/mbgl/programs/hillshade_program.cpp +++ b/src/mbgl/programs/hillshade_program.cpp @@ -1,7 +1,10 @@ #include <mbgl/programs/hillshade_program.hpp> +#include <mbgl/gfx/context_impl.hpp> namespace mbgl { +template std::unique_ptr<gfx::Program<HillshadeProgram>> gfx::Context::createProgram(const ProgramParameters&); + static_assert(sizeof(HillshadeLayoutVertex) == 8, "expected HillshadeLayoutVertex size"); } // namespace mbgl diff --git a/src/mbgl/programs/hillshade_program.hpp b/src/mbgl/programs/hillshade_program.hpp index 2a67338c7c..68d67917df 100644 --- a/src/mbgl/programs/hillshade_program.hpp +++ b/src/mbgl/programs/hillshade_program.hpp @@ -5,7 +5,6 @@ #include <mbgl/programs/hillshade_prepare_program.hpp> #include <mbgl/programs/uniforms.hpp> #include <mbgl/programs/textures.hpp> -#include <mbgl/shaders/hillshade.hpp> #include <mbgl/util/geometry.hpp> #include <mbgl/style/layers/hillshade_layer_properties.hpp> @@ -20,8 +19,8 @@ MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_latrange); } // namespace uniforms class HillshadeProgram : public Program< - shaders::hillshade, - gfx::Triangle, + HillshadeProgram, + gfx::PrimitiveType::Triangle, TypeList< attributes::a_pos, attributes::a_texture_pos>, @@ -53,11 +52,11 @@ public: }; using HillshadeLayoutVertex = HillshadeProgram::LayoutVertex; -using HillshadeAttributes = HillshadeProgram::Attributes; +using HillshadeAttributes = HillshadeProgram::AttributeList; class HillshadeLayerPrograms final : public LayerTypePrograms { public: - HillshadeLayerPrograms(gl::Context& context, const ProgramParameters& programParameters) + HillshadeLayerPrograms(gfx::Context& context, const ProgramParameters& programParameters) : hillshade(context, programParameters), hillshadePrepare(context, programParameters) {} HillshadeProgram hillshade; diff --git a/src/mbgl/programs/line_gradient_program.hpp b/src/mbgl/programs/line_gradient_program.hpp new file mode 100644 index 0000000000..c98cd37e98 --- /dev/null +++ b/src/mbgl/programs/line_gradient_program.hpp @@ -0,0 +1,4 @@ +#pragma once + +// Alias +#include <mbgl/programs/line_program.hpp> diff --git a/src/mbgl/programs/line_pattern_program.hpp b/src/mbgl/programs/line_pattern_program.hpp new file mode 100644 index 0000000000..c98cd37e98 --- /dev/null +++ b/src/mbgl/programs/line_pattern_program.hpp @@ -0,0 +1,4 @@ +#pragma once + +// Alias +#include <mbgl/programs/line_program.hpp> diff --git a/src/mbgl/programs/line_program.cpp b/src/mbgl/programs/line_program.cpp index e5b4cc2ad5..74a1ba3162 100644 --- a/src/mbgl/programs/line_program.cpp +++ b/src/mbgl/programs/line_program.cpp @@ -1,4 +1,5 @@ #include <mbgl/programs/line_program.hpp> +#include <mbgl/gfx/context_impl.hpp> #include <mbgl/style/layers/line_layer_properties.hpp> #include <mbgl/renderer/render_tile.hpp> #include <mbgl/renderer/image_atlas.hpp> @@ -8,6 +9,11 @@ namespace mbgl { +template std::unique_ptr<gfx::Program<LineProgram>> gfx::Context::createProgram(const ProgramParameters&); +template std::unique_ptr<gfx::Program<LinePatternProgram>> gfx::Context::createProgram(const ProgramParameters&); +template std::unique_ptr<gfx::Program<LineGradientProgram>> gfx::Context::createProgram(const ProgramParameters&); +template std::unique_ptr<gfx::Program<LineSDFProgram>> gfx::Context::createProgram(const ProgramParameters&); + using namespace style; static_assert(sizeof(LineLayoutVertex) == 12, "expected LineLayoutVertex size"); @@ -31,12 +37,12 @@ Values makeValues(const RenderLinePaintProperties::PossiblyEvaluated& properties }; } -LineProgram::UniformValues -LineProgram::uniformValues(const RenderLinePaintProperties::PossiblyEvaluated& properties, - const RenderTile& tile, - const TransformState& state, - const std::array<float, 2>& pixelsToGLUnits) { - return makeValues<LineProgram::UniformValues>( +LineProgram::LayoutUniformValues +LineProgram::layoutUniformValues(const RenderLinePaintProperties::PossiblyEvaluated& properties, + const RenderTile& tile, + const TransformState& state, + const std::array<float, 2>& pixelsToGLUnits) { + return makeValues<LineProgram::LayoutUniformValues>( properties, tile, state, @@ -44,16 +50,16 @@ LineProgram::uniformValues(const RenderLinePaintProperties::PossiblyEvaluated& p ); } -LineSDFProgram::UniformValues -LineSDFProgram::uniformValues(const RenderLinePaintProperties::PossiblyEvaluated& properties, - float pixelRatio, - const RenderTile& tile, - const TransformState& state, - const std::array<float, 2>& pixelsToGLUnits, - const LinePatternPos& posA, - const LinePatternPos& posB, - const CrossfadeParameters& crossfade, - float atlasWidth) { +LineSDFProgram::LayoutUniformValues +LineSDFProgram::layoutUniformValues(const RenderLinePaintProperties::PossiblyEvaluated& properties, + float pixelRatio, + const RenderTile& tile, + const TransformState& state, + const std::array<float, 2>& pixelsToGLUnits, + const LinePatternPos& posA, + const LinePatternPos& posB, + const CrossfadeParameters& crossfade, + float atlasWidth) { const float widthA = posA.width * crossfade.fromScale; const float widthB = posB.width * crossfade.toScale; @@ -67,7 +73,7 @@ LineSDFProgram::uniformValues(const RenderLinePaintProperties::PossiblyEvaluated -posB.height / 2.0f }}; - return makeValues<LineSDFProgram::UniformValues>( + return makeValues<LineSDFProgram::LayoutUniformValues>( properties, tile, state, @@ -81,18 +87,18 @@ LineSDFProgram::uniformValues(const RenderLinePaintProperties::PossiblyEvaluated ); } -LinePatternProgram::UniformValues -LinePatternProgram::uniformValues(const RenderLinePaintProperties::PossiblyEvaluated& properties, - const RenderTile& tile, - const TransformState& state, - const std::array<float, 2>& pixelsToGLUnits, - const Size atlasSize, - const CrossfadeParameters& crossfade, - const float pixelRatio) { - +LinePatternProgram::LayoutUniformValues LinePatternProgram::layoutUniformValues( + const RenderLinePaintProperties::PossiblyEvaluated& properties, + const RenderTile& tile, + const TransformState& state, + const std::array<float, 2>& pixelsToGLUnits, + const Size atlasSize, + const CrossfadeParameters& crossfade, + const float pixelRatio) { + const auto tileRatio = 1 / tile.id.pixelsToTileUnits(1, state.getIntegerZoom()); - return makeValues<LinePatternProgram::UniformValues>( + return makeValues<LinePatternProgram::LayoutUniformValues>( properties, tile, state, @@ -103,12 +109,12 @@ LinePatternProgram::uniformValues(const RenderLinePaintProperties::PossiblyEvalu ); } -LineGradientProgram::UniformValues -LineGradientProgram::uniformValues(const RenderLinePaintProperties::PossiblyEvaluated& properties, - const RenderTile& tile, - const TransformState& state, - const std::array<float, 2>& pixelsToGLUnits) { - return makeValues<LineGradientProgram::UniformValues>( +LineGradientProgram::LayoutUniformValues LineGradientProgram::layoutUniformValues( + const RenderLinePaintProperties::PossiblyEvaluated& properties, + const RenderTile& tile, + const TransformState& state, + const std::array<float, 2>& pixelsToGLUnits) { + return makeValues<LineGradientProgram::LayoutUniformValues>( properties, tile, state, diff --git a/src/mbgl/programs/line_program.hpp b/src/mbgl/programs/line_program.hpp index 0e4055bded..05546e3cbe 100644 --- a/src/mbgl/programs/line_program.hpp +++ b/src/mbgl/programs/line_program.hpp @@ -4,10 +4,6 @@ #include <mbgl/programs/attributes.hpp> #include <mbgl/programs/uniforms.hpp> #include <mbgl/programs/textures.hpp> -#include <mbgl/shaders/line.hpp> -#include <mbgl/shaders/line_gradient.hpp> -#include <mbgl/shaders/line_pattern.hpp> -#include <mbgl/shaders/line_sdf.hpp> #include <mbgl/util/geometry.hpp> #include <mbgl/renderer/layers/render_line_layer.hpp> #include <mbgl/renderer/cross_faded_property_evaluator.hpp> @@ -35,8 +31,8 @@ using LineLayoutAttributes = TypeList< attributes::a_data<uint8_t, 4>>; class LineProgram : public Program< - shaders::line, - gfx::Triangle, + LineProgram, + gfx::PrimitiveType::Triangle, LineLayoutAttributes, TypeList< uniforms::u_matrix, @@ -93,15 +89,16 @@ public: */ static const int8_t extrudeScale = 63; - static UniformValues uniformValues(const RenderLinePaintProperties::PossiblyEvaluated&, - const RenderTile&, - const TransformState&, - const std::array<float, 2>& pixelsToGLUnits); + static LayoutUniformValues + layoutUniformValues(const RenderLinePaintProperties::PossiblyEvaluated&, + const RenderTile&, + const TransformState&, + const std::array<float, 2>& pixelsToGLUnits); }; class LinePatternProgram : public Program< - shaders::line_pattern, - gfx::Triangle, + LinePatternProgram, + gfx::PrimitiveType::Triangle, LineLayoutAttributes, TypeList< uniforms::u_matrix, @@ -117,18 +114,19 @@ class LinePatternProgram : public Program< public: using Program::Program; - static UniformValues uniformValues(const RenderLinePaintProperties::PossiblyEvaluated&, - const RenderTile&, - const TransformState&, - const std::array<float, 2>& pixelsToGLUnits, - Size atlasSize, - const CrossfadeParameters& crossfade, - const float pixelRatio); + static LayoutUniformValues + layoutUniformValues(const RenderLinePaintProperties::PossiblyEvaluated&, + const RenderTile&, + const TransformState&, + const std::array<float, 2>& pixelsToGLUnits, + Size atlasSize, + const CrossfadeParameters& crossfade, + const float pixelRatio); }; class LineSDFProgram : public Program< - shaders::line_sdf, - gfx::Triangle, + LineSDFProgram, + gfx::PrimitiveType::Triangle, LineLayoutAttributes, TypeList< uniforms::u_matrix, @@ -147,20 +145,21 @@ class LineSDFProgram : public Program< public: using Program::Program; - static UniformValues uniformValues(const RenderLinePaintProperties::PossiblyEvaluated&, - float pixelRatio, - const RenderTile&, - const TransformState&, - const std::array<float, 2>& pixelsToGLUnits, - const LinePatternPos& posA, - const LinePatternPos& posB, - const CrossfadeParameters& crossfade, - float atlasWidth); + static LayoutUniformValues + layoutUniformValues(const RenderLinePaintProperties::PossiblyEvaluated&, + float pixelRatio, + const RenderTile&, + const TransformState&, + const std::array<float, 2>& pixelsToGLUnits, + const LinePatternPos& posA, + const LinePatternPos& posB, + const CrossfadeParameters& crossfade, + float atlasWidth); }; class LineGradientProgram : public Program< - shaders::line_gradient, - gfx::Triangle, + LineGradientProgram, + gfx::PrimitiveType::Triangle, LineLayoutAttributes, TypeList< uniforms::u_matrix, @@ -173,18 +172,19 @@ class LineGradientProgram : public Program< public: using Program::Program; - static UniformValues uniformValues(const RenderLinePaintProperties::PossiblyEvaluated&, - const RenderTile&, - const TransformState&, - const std::array<float, 2>& pixelsToGLUnits); + static LayoutUniformValues + layoutUniformValues(const RenderLinePaintProperties::PossiblyEvaluated&, + const RenderTile&, + const TransformState&, + const std::array<float, 2>& pixelsToGLUnits); }; using LineLayoutVertex = LineProgram::LayoutVertex; -using LineAttributes = LineProgram::Attributes; +using LineAttributes = LineProgram::AttributeList; class LineLayerPrograms final : public LayerTypePrograms { public: - LineLayerPrograms(gl::Context& context, const ProgramParameters& programParameters) + LineLayerPrograms(gfx::Context& context, const ProgramParameters& programParameters) : line(context, programParameters), lineGradient(context, programParameters), lineSDF(context, programParameters), diff --git a/src/mbgl/programs/line_sdf_program.hpp b/src/mbgl/programs/line_sdf_program.hpp new file mode 100644 index 0000000000..c98cd37e98 --- /dev/null +++ b/src/mbgl/programs/line_sdf_program.hpp @@ -0,0 +1,4 @@ +#pragma once + +// Alias +#include <mbgl/programs/line_program.hpp> diff --git a/src/mbgl/programs/program.hpp b/src/mbgl/programs/program.hpp index 379cc6b842..240da22b4f 100644 --- a/src/mbgl/programs/program.hpp +++ b/src/mbgl/programs/program.hpp @@ -1,106 +1,106 @@ #pragma once -#include <mbgl/gl/program.hpp> -#include <mbgl/gl/features.hpp> +#include <mbgl/gfx/attribute.hpp> +#include <mbgl/gfx/uniform.hpp> #include <mbgl/programs/segment.hpp> -#include <mbgl/programs/binary_program.hpp> #include <mbgl/programs/attributes.hpp> #include <mbgl/programs/program_parameters.hpp> #include <mbgl/style/paint_property.hpp> #include <mbgl/renderer/paint_property_binder.hpp> -#include <mbgl/shaders/shaders.hpp> #include <mbgl/util/io.hpp> #include <unordered_map> namespace mbgl { -template <class Shaders, - class Primitive, +template <class Name, + gfx::PrimitiveType Primitive, class LayoutAttributeList, - class UniformList, - class TextureList, + class LayoutUniformList, + class Textures, class PaintProps> class Program { public: - using LayoutAttributes = gl::Attributes<LayoutAttributeList>; using LayoutVertex = gfx::Vertex<LayoutAttributeList>; using PaintProperties = PaintProps; using Binders = PaintPropertyBinders<typename PaintProperties::DataDrivenProperties>; + using PaintAttributeList = typename Binders::AttributeList; - using Attributes = gl::Attributes<TypeListConcat<LayoutAttributeList, PaintAttributeList>>; + using AttributeList = TypeListConcat<LayoutAttributeList, PaintAttributeList>; + using AttributeBindings = gfx::AttributeBindings<AttributeList>; - using UniformValues = gfx::UniformValues<UniformList>; using PaintUniformList = typename Binders::UniformList; - using AllUniforms = gl::Uniforms<TypeListConcat<UniformList, PaintUniformList>>; + using UniformList = TypeListConcat<LayoutUniformList, PaintUniformList>; + using LayoutUniformValues = gfx::UniformValues<LayoutUniformList>; + using UniformValues = gfx::UniformValues<UniformList>; + using TextureList = Textures; using TextureBindings = gfx::TextureBindings<TextureList>; - using ProgramType = gl::Program<Primitive, Attributes, AllUniforms, TextureList>; - - ProgramType program; + std::unique_ptr<gfx::Program<Name>> program; - Program(gl::Context& context, const ProgramParameters& programParameters) - : program(ProgramType::createProgram( - context, - programParameters, - Shaders::name, - Shaders::vertexSource, - Shaders::fragmentSource)) { + Program(gfx::Context& context, const ProgramParameters& programParameters) + : program(context.createProgram<Name>(programParameters)) { } - static typename AllUniforms::Values computeAllUniformValues( - const UniformValues& uniformValues, + static UniformValues computeAllUniformValues( + const LayoutUniformValues& layoutUniformValues, const Binders& paintPropertyBinders, const typename PaintProperties::PossiblyEvaluated& currentProperties, float currentZoom) { - return uniformValues + return layoutUniformValues .concat(paintPropertyBinders.uniformValues(currentZoom, currentProperties)); } - static typename Attributes::Bindings computeAllAttributeBindings( + static AttributeBindings computeAllAttributeBindings( const gfx::VertexBuffer<LayoutVertex>& layoutVertexBuffer, const Binders& paintPropertyBinders, const typename PaintProperties::PossiblyEvaluated& currentProperties) { - return LayoutAttributes::bindings(layoutVertexBuffer) + return gfx::AttributeBindings<LayoutAttributeList>(layoutVertexBuffer) .concat(paintPropertyBinders.attributeBindings(currentProperties)); } - static uint32_t activeBindingCount(const typename Attributes::Bindings& allAttributeBindings) { - return Attributes::activeBindingCount(allAttributeBindings); + static uint32_t activeBindingCount(const AttributeBindings& allAttributeBindings) { + return allAttributeBindings.activeCount(); } template <class DrawMode> - void draw(gl::Context& context, - DrawMode drawMode, - gfx::DepthMode depthMode, - gfx::StencilMode stencilMode, - gfx::ColorMode colorMode, - gfx::CullFaceMode cullFaceMode, + void draw(gfx::Context& context, + const DrawMode& drawMode, + const gfx::DepthMode& depthMode, + const gfx::StencilMode& stencilMode, + const gfx::ColorMode& colorMode, + const gfx::CullFaceMode& cullFaceMode, const gfx::IndexBuffer& indexBuffer, - const SegmentVector<Attributes>& segments, - const typename AllUniforms::Values& allUniformValues, - const typename Attributes::Bindings& allAttributeBindings, + const SegmentVector<AttributeList>& segments, + const UniformValues& uniformValues, + const AttributeBindings& allAttributeBindings, const TextureBindings& textureBindings, const std::string& layerID) { + static_assert(Primitive == gfx::PrimitiveTypeOf<DrawMode>::value, "incompatible draw mode"); + + if (!program) { + return; + } + for (auto& segment : segments) { - auto vertexArrayIt = segment.vertexArrays.find(layerID); + auto drawScopeIt = segment.drawScopes.find(layerID); - if (vertexArrayIt == segment.vertexArrays.end()) { - vertexArrayIt = segment.vertexArrays.emplace(layerID, context.createVertexArray()).first; + if (drawScopeIt == segment.drawScopes.end()) { + drawScopeIt = segment.drawScopes.emplace(layerID, context.createDrawScope()).first; } - program.draw( + program->draw( context, - std::move(drawMode), - std::move(depthMode), - std::move(stencilMode), - std::move(colorMode), - std::move(cullFaceMode), - allUniformValues, - vertexArrayIt->second, - Attributes::offsetBindings(allAttributeBindings, segment.vertexOffset), + drawMode, + depthMode, + stencilMode, + colorMode, + cullFaceMode, + uniformValues, + drawScopeIt->second, + allAttributeBindings.offset(segment.vertexOffset), textureBindings, indexBuffer, segment.indexOffset, @@ -116,7 +116,7 @@ public: using Binders = typename Program::Binders; using Bitset = typename Binders::Bitset; - ProgramMap(gl::Context& context_, ProgramParameters parameters_) + ProgramMap(gfx::Context& context_, ProgramParameters parameters_) : context(context_), parameters(std::move(parameters_)) { } @@ -134,7 +134,7 @@ public: } private: - gl::Context& context; + gfx::Context& context; ProgramParameters parameters; std::unordered_map<Bitset, Program> programs; }; diff --git a/src/mbgl/programs/programs.cpp b/src/mbgl/programs/programs.cpp index f3b3af8ac9..f82e46c9a2 100644 --- a/src/mbgl/programs/programs.cpp +++ b/src/mbgl/programs/programs.cpp @@ -12,7 +12,7 @@ namespace mbgl { -Programs::Programs(gl::Context& context_, const ProgramParameters& programParameters_) +Programs::Programs(gfx::Context& context_, const ProgramParameters& programParameters_) : debug(context_, programParameters_), clippingMask(context_, programParameters_), context(context_), diff --git a/src/mbgl/programs/programs.hpp b/src/mbgl/programs/programs.hpp index a12a0e8fa6..ca9359b267 100644 --- a/src/mbgl/programs/programs.hpp +++ b/src/mbgl/programs/programs.hpp @@ -20,7 +20,7 @@ class SymbolLayerPrograms; class Programs { public: - Programs(gl::Context&, const ProgramParameters&); + Programs(gfx::Context&, const ProgramParameters&); ~Programs(); BackgroundLayerPrograms& getBackgroundLayerPrograms() noexcept; @@ -47,7 +47,7 @@ private: std::unique_ptr<LayerTypePrograms> linePrograms; std::unique_ptr<LayerTypePrograms> symbolPrograms; - gl::Context& context; + gfx::Context& context; ProgramParameters programParameters; }; diff --git a/src/mbgl/programs/raster_program.cpp b/src/mbgl/programs/raster_program.cpp index 6906903e6b..f3b1052284 100644 --- a/src/mbgl/programs/raster_program.cpp +++ b/src/mbgl/programs/raster_program.cpp @@ -1,7 +1,10 @@ #include <mbgl/programs/raster_program.hpp> +#include <mbgl/gfx/context_impl.hpp> namespace mbgl { +template std::unique_ptr<gfx::Program<RasterProgram>> gfx::Context::createProgram(const ProgramParameters&); + static_assert(sizeof(RasterLayoutVertex) == 8, "expected RasterLayoutVertex size"); } // namespace mbgl diff --git a/src/mbgl/programs/raster_program.hpp b/src/mbgl/programs/raster_program.hpp index a5b4ee36ba..55f1fb0a2e 100644 --- a/src/mbgl/programs/raster_program.hpp +++ b/src/mbgl/programs/raster_program.hpp @@ -4,7 +4,6 @@ #include <mbgl/programs/attributes.hpp> #include <mbgl/programs/uniforms.hpp> #include <mbgl/programs/textures.hpp> -#include <mbgl/shaders/raster.hpp> #include <mbgl/util/geometry.hpp> #include <mbgl/style/layers/raster_layer_properties.hpp> @@ -23,8 +22,8 @@ MBGL_DEFINE_UNIFORM_VECTOR(float, 2, u_tl_parent); } // namespace uniforms class RasterProgram : public Program< - shaders::raster, - gfx::Triangle, + RasterProgram, + gfx::PrimitiveType::Triangle, TypeList< attributes::a_pos, attributes::a_texture_pos>, @@ -63,11 +62,11 @@ public: }; using RasterLayoutVertex = RasterProgram::LayoutVertex; -using RasterAttributes = RasterProgram::Attributes; +using RasterAttributes = RasterProgram::AttributeList; class RasterLayerPrograms final : public LayerTypePrograms { public: - RasterLayerPrograms(gl::Context& context, const ProgramParameters& programParameters) + RasterLayerPrograms(gfx::Context& context, const ProgramParameters& programParameters) : raster(context, programParameters) {} RasterProgram raster; }; diff --git a/src/mbgl/programs/segment.hpp b/src/mbgl/programs/segment.hpp index 5158ce7dbf..5976550d2c 100644 --- a/src/mbgl/programs/segment.hpp +++ b/src/mbgl/programs/segment.hpp @@ -1,6 +1,6 @@ #pragma once -#include <mbgl/gl/vertex_array.hpp> +#include <mbgl/gfx/draw_scope.hpp> #include <cstddef> #include <vector> @@ -8,7 +8,7 @@ namespace mbgl { -template <class Attributes> +template <class AttributeList> class Segment { public: Segment(std::size_t vertexOffset_, @@ -28,17 +28,17 @@ public: std::size_t vertexLength; std::size_t indexLength; - // One VertexArray per layer ID. This minimizes rebinding in cases where + // One DrawScope per layer ID. This minimizes rebinding in cases where // several layers share buckets but have different sets of active attributes. // This can happen: // * when two layers have the same layout properties, but differing // data-driven paint properties // * when two fill layers have the same layout properties, but one // uses fill-color and the other uses fill-pattern - mutable std::map<std::string, gl::VertexArray> vertexArrays; + mutable std::map<std::string, gfx::DrawScope> drawScopes; }; -template <class Attributes> -using SegmentVector = std::vector<Segment<Attributes>>; +template <class AttributeList> +using SegmentVector = std::vector<Segment<AttributeList>>; } // namespace mbgl diff --git a/src/mbgl/programs/symbol_icon_program.hpp b/src/mbgl/programs/symbol_icon_program.hpp new file mode 100644 index 0000000000..57f27518d1 --- /dev/null +++ b/src/mbgl/programs/symbol_icon_program.hpp @@ -0,0 +1,4 @@ +#pragma once + +// Alias +#include <mbgl/programs/symbol_program.hpp> diff --git a/src/mbgl/programs/symbol_program.cpp b/src/mbgl/programs/symbol_program.cpp index 03643d6422..2300dedff3 100644 --- a/src/mbgl/programs/symbol_program.cpp +++ b/src/mbgl/programs/symbol_program.cpp @@ -1,4 +1,5 @@ #include <mbgl/programs/symbol_program.hpp> +#include <mbgl/gfx/context_impl.hpp> #include <mbgl/renderer/render_tile.hpp> #include <mbgl/map/transform_state.hpp> #include <mbgl/style/layers/symbol_layer_impl.hpp> @@ -9,6 +10,10 @@ namespace mbgl { +template std::unique_ptr<gfx::Program<SymbolIconProgram>> gfx::Context::createProgram(const ProgramParameters&); +template std::unique_ptr<gfx::Program<SymbolSDFTextProgram>> gfx::Context::createProgram(const ProgramParameters&); +template std::unique_ptr<gfx::Program<SymbolSDFIconProgram>> gfx::Context::createProgram(const ProgramParameters&); + using namespace style; static_assert(sizeof(SymbolLayoutVertex) == 16, "expected SymbolLayoutVertex size"); @@ -99,17 +104,16 @@ Values makeValues(const bool isText, }; } -SymbolIconProgram::UniformValues -SymbolIconProgram::uniformValues(const bool isText, - const style::SymbolPropertyValues& values, - const Size& texsize, - const std::array<float, 2>& pixelsToGLUnits, - const bool alongLine, - const RenderTile& tile, - const TransformState& state, - const float symbolFadeChange) -{ - return makeValues<SymbolIconProgram::UniformValues>( +SymbolIconProgram::LayoutUniformValues +SymbolIconProgram::layoutUniformValues(const bool isText, + const style::SymbolPropertyValues& values, + const Size& texsize, + const std::array<float, 2>& pixelsToGLUnits, + const bool alongLine, + const RenderTile& tile, + const TransformState& state, + const float symbolFadeChange) { + return makeValues<SymbolIconProgram::LayoutUniformValues>( isText, values, texsize, @@ -121,23 +125,22 @@ SymbolIconProgram::uniformValues(const bool isText, ); } -template <class PaintProperties> -typename SymbolSDFProgram<PaintProperties>::UniformValues SymbolSDFProgram<PaintProperties>::uniformValues( - const bool isText, - const style::SymbolPropertyValues& values, - const Size& texsize, - const std::array<float, 2>& pixelsToGLUnits, - const bool alongLine, - const RenderTile& tile, - const TransformState& state, - const float symbolFadeChange, - const SymbolSDFPart part) -{ +template <class Name, class PaintProperties> +typename SymbolSDFProgram<Name, PaintProperties>::LayoutUniformValues +SymbolSDFProgram<Name, PaintProperties>::layoutUniformValues(const bool isText, + const style::SymbolPropertyValues& values, + const Size& texsize, + const std::array<float, 2>& pixelsToGLUnits, + const bool alongLine, + const RenderTile& tile, + const TransformState& state, + const float symbolFadeChange, + const SymbolSDFPart part) { const float gammaScale = (values.pitchAlignment == AlignmentType::Map ? std::cos(state.getPitch()) * state.getCameraToCenterDistance() : 1.0); - return makeValues<SymbolSDFProgram<PaintProperties>::UniformValues>( + return makeValues<SymbolSDFProgram<Name, PaintProperties>::LayoutUniformValues>( isText, values, texsize, @@ -151,7 +154,7 @@ typename SymbolSDFProgram<PaintProperties>::UniformValues SymbolSDFProgram<Paint ); } -template class SymbolSDFProgram<style::IconPaintProperties>; -template class SymbolSDFProgram<style::TextPaintProperties>; +template class SymbolSDFProgram<SymbolSDFIconProgram, style::IconPaintProperties>; +template class SymbolSDFProgram<SymbolSDFTextProgram, style::TextPaintProperties>; } // namespace mbgl diff --git a/src/mbgl/programs/symbol_program.hpp b/src/mbgl/programs/symbol_program.hpp index 7b8a2c1330..383f5162d8 100644 --- a/src/mbgl/programs/symbol_program.hpp +++ b/src/mbgl/programs/symbol_program.hpp @@ -1,6 +1,5 @@ #pragma once -#include <mbgl/gl/context.hpp> #include <mbgl/gl/program.hpp> #include <mbgl/math/clamp.hpp> #include <mbgl/util/interpolate.hpp> @@ -10,8 +9,6 @@ #include <mbgl/programs/uniforms.hpp> #include <mbgl/programs/textures.hpp> #include <mbgl/programs/segment.hpp> -#include <mbgl/shaders/symbol_icon.hpp> -#include <mbgl/shaders/symbol_sdf.hpp> #include <mbgl/util/geometry.hpp> #include <mbgl/util/size.hpp> #include <mbgl/style/layers/symbol_layer_properties.hpp> @@ -240,55 +237,51 @@ public: } }; -template <class Shaders, - class Primitive, +template <class Name, + gfx::PrimitiveType Primitive, class LayoutAttributeList, - class UniformList, - class TextureList, + class LayoutUniformList, + class Textures, class PaintProps> class SymbolProgram : public SymbolProgramBase { public: - using LayoutAttributes = gl::Attributes<LayoutAttributeList>; using LayoutVertex = gfx::Vertex<LayoutAttributeList>; using LayoutAndSizeAttributeList = TypeListConcat<LayoutAttributeList, SymbolDynamicLayoutAttributes, SymbolOpacityAttributes>; using PaintProperties = PaintProps; using Binders = PaintPropertyBinders<typename PaintProperties::DataDrivenProperties>; + using PaintAttributeList = typename Binders::AttributeList; - using Attributes = gl::Attributes<TypeListConcat<LayoutAndSizeAttributeList, PaintAttributeList>>; + using AttributeList = TypeListConcat<LayoutAndSizeAttributeList, PaintAttributeList>; + using AttributeBindings = gfx::AttributeBindings<AttributeList>; - using UniformValues = gfx::UniformValues<UniformList>; + using LayoutUniformValues = gfx::UniformValues<LayoutUniformList>; using SizeUniformList = typename SymbolSizeBinder::UniformList; using PaintUniformList = typename Binders::UniformList; - using AllUniforms = gl::Uniforms<TypeListConcat<UniformList, SizeUniformList, PaintUniformList>>; + using UniformList = TypeListConcat<LayoutUniformList, SizeUniformList, PaintUniformList>; + using UniformValues = gfx::UniformValues<UniformList>; + using TextureList = Textures; using TextureBindings = gfx::TextureBindings<TextureList>; - using ProgramType = gl::Program<Primitive, Attributes, AllUniforms, TextureList>; + std::unique_ptr<gfx::Program<Name>> program; - ProgramType program; - - SymbolProgram(gl::Context& context, const ProgramParameters& programParameters) - : program(ProgramType::createProgram( - context, - programParameters, - Shaders::name, - Shaders::vertexSource, - Shaders::fragmentSource)) { + SymbolProgram(gfx::Context& context, const ProgramParameters& programParameters) + : program(context.createProgram<Name>(programParameters)) { } - static typename AllUniforms::Values computeAllUniformValues( - const UniformValues& uniformValues, + static UniformValues computeAllUniformValues( + const LayoutUniformValues& layoutUniformValues, const SymbolSizeBinder& symbolSizeBinder, const Binders& paintPropertyBinders, const typename PaintProperties::PossiblyEvaluated& currentProperties, float currentZoom) { - return uniformValues.concat(symbolSizeBinder.uniformValues(currentZoom)) + return layoutUniformValues.concat(symbolSizeBinder.uniformValues(currentZoom)) .concat(paintPropertyBinders.uniformValues(currentZoom, currentProperties)); } - static typename Attributes::Bindings computeAllAttributeBindings( + static AttributeBindings computeAllAttributeBindings( const gfx::VertexBuffer<LayoutVertex>& layoutVertexBuffer, const gfx::VertexBuffer<gfx::Vertex<SymbolDynamicLayoutAttributes>>& dynamicLayoutVertexBuffer, const gfx::VertexBuffer<gfx::Vertex<SymbolOpacityAttributes>>& opacityVertexBuffer, @@ -296,46 +289,52 @@ public: const typename PaintProperties::PossiblyEvaluated& currentProperties) { assert(layoutVertexBuffer.elements == dynamicLayoutVertexBuffer.elements && layoutVertexBuffer.elements == opacityVertexBuffer.elements); - return gl::Attributes<LayoutAttributeList>::bindings(layoutVertexBuffer) - .concat(gl::Attributes<SymbolDynamicLayoutAttributes>::bindings(dynamicLayoutVertexBuffer)) - .concat(gl::Attributes<SymbolOpacityAttributes>::bindings(opacityVertexBuffer)) + return gfx::AttributeBindings<LayoutAttributeList>(layoutVertexBuffer) + .concat(gfx::AttributeBindings<SymbolDynamicLayoutAttributes>(dynamicLayoutVertexBuffer)) + .concat(gfx::AttributeBindings<SymbolOpacityAttributes>(opacityVertexBuffer)) .concat(paintPropertyBinders.attributeBindings(currentProperties)); } - static uint32_t activeBindingCount(const typename Attributes::Bindings& allAttributeBindings) { - return Attributes::activeBindingCount(allAttributeBindings); + static uint32_t activeBindingCount(const AttributeBindings& allAttributeBindings) { + return allAttributeBindings.activeCount(); } template <class DrawMode> - void draw(gl::Context& context, - DrawMode drawMode, - gfx::DepthMode depthMode, - gfx::StencilMode stencilMode, - gfx::ColorMode colorMode, - gfx::CullFaceMode cullFaceMode, + void draw(gfx::Context& context, + const DrawMode& drawMode, + const gfx::DepthMode& depthMode, + const gfx::StencilMode& stencilMode, + const gfx::ColorMode& colorMode, + const gfx::CullFaceMode& cullFaceMode, const gfx::IndexBuffer& indexBuffer, - const SegmentVector<Attributes>& segments, - const typename AllUniforms::Values& allUniformValues, - const typename Attributes::Bindings& allAttributeBindings, + const SegmentVector<AttributeList>& segments, + const UniformValues& uniformValues, + const AttributeBindings& allAttributeBindings, const TextureBindings& textureBindings, const std::string& layerID) { + static_assert(Primitive == gfx::PrimitiveTypeOf<DrawMode>::value, "incompatible draw mode"); + + if (!program) { + return; + } + for (auto& segment : segments) { - auto vertexArrayIt = segment.vertexArrays.find(layerID); + auto drawScopeIt = segment.drawScopes.find(layerID); - if (vertexArrayIt == segment.vertexArrays.end()) { - vertexArrayIt = segment.vertexArrays.emplace(layerID, context.createVertexArray()).first; + if (drawScopeIt == segment.drawScopes.end()) { + drawScopeIt = segment.drawScopes.emplace(layerID, context.createDrawScope()).first; } - program.draw( + program->draw( context, - std::move(drawMode), - std::move(depthMode), - std::move(stencilMode), - std::move(colorMode), - std::move(cullFaceMode), - allUniformValues, - vertexArrayIt->second, - Attributes::offsetBindings(allAttributeBindings, segment.vertexOffset), + drawMode, + depthMode, + stencilMode, + colorMode, + cullFaceMode, + uniformValues, + drawScopeIt->second, + allAttributeBindings.offset(segment.vertexOffset), textureBindings, indexBuffer, segment.indexOffset, @@ -345,8 +344,8 @@ public: }; class SymbolIconProgram : public SymbolProgram< - shaders::symbol_icon, - gfx::Triangle, + SymbolIconProgram, + gfx::PrimitiveType::Triangle, SymbolLayoutAttributes, TypeList< uniforms::u_matrix, @@ -368,14 +367,14 @@ class SymbolIconProgram : public SymbolProgram< public: using SymbolProgram::SymbolProgram; - static UniformValues uniformValues(const bool isText, - const style::SymbolPropertyValues&, - const Size& texsize, - const std::array<float, 2>& pixelsToGLUnits, - const bool alongLine, - const RenderTile&, - const TransformState&, - const float symbolFadeChange); + static LayoutUniformValues layoutUniformValues(const bool isText, + const style::SymbolPropertyValues&, + const Size& texsize, + const std::array<float, 2>& pixelsToGLUnits, + const bool alongLine, + const RenderTile&, + const TransformState&, + const float symbolFadeChange); }; enum class SymbolSDFPart { @@ -383,10 +382,10 @@ enum class SymbolSDFPart { Halo = 0 }; -template <class PaintProperties> +template <class Name, class PaintProperties> class SymbolSDFProgram : public SymbolProgram< - shaders::symbol_sdf, - gfx::Triangle, + Name, + gfx::PrimitiveType::Triangle, SymbolLayoutAttributes, TypeList< uniforms::u_matrix, @@ -408,8 +407,9 @@ class SymbolSDFProgram : public SymbolProgram< PaintProperties> { public: - using BaseProgram = SymbolProgram<shaders::symbol_sdf, - gfx::Triangle, + using BaseProgram = SymbolProgram< + Name, + gfx::PrimitiveType::Triangle, SymbolLayoutAttributes, TypeList< uniforms::u_matrix, @@ -430,33 +430,40 @@ public: textures::u_texture>, PaintProperties>; - using UniformValues = typename BaseProgram::UniformValues; + using LayoutUniformValues = typename BaseProgram::LayoutUniformValues; using BaseProgram::BaseProgram; - static UniformValues uniformValues(const bool isText, - const style::SymbolPropertyValues&, - const Size& texsize, - const std::array<float, 2>& pixelsToGLUnits, - const bool alongLine, - const RenderTile&, - const TransformState&, - const float SymbolFadeChange, - const SymbolSDFPart); + static LayoutUniformValues layoutUniformValues(const bool isText, + const style::SymbolPropertyValues&, + const Size& texsize, + const std::array<float, 2>& pixelsToGLUnits, + const bool alongLine, + const RenderTile&, + const TransformState&, + const float SymbolFadeChange, + const SymbolSDFPart); +}; + +class SymbolSDFIconProgram : public SymbolSDFProgram<SymbolSDFIconProgram, style::IconPaintProperties> { +public: + using SymbolSDFProgram::SymbolSDFProgram; }; -using SymbolSDFIconProgram = SymbolSDFProgram<style::IconPaintProperties>; -using SymbolSDFTextProgram = SymbolSDFProgram<style::TextPaintProperties>; +class SymbolSDFTextProgram : public SymbolSDFProgram<SymbolSDFTextProgram, style::TextPaintProperties> { +public: + using SymbolSDFProgram::SymbolSDFProgram; +}; using SymbolLayoutVertex = gfx::Vertex<SymbolLayoutAttributes>; -using SymbolIconAttributes = SymbolIconProgram::Attributes; -using SymbolTextAttributes = SymbolSDFTextProgram::Attributes; +using SymbolIconAttributes = SymbolIconProgram::AttributeList; +using SymbolTextAttributes = SymbolSDFTextProgram::AttributeList; class SymbolLayerPrograms final : public LayerTypePrograms { public: - SymbolLayerPrograms(gl::Context& context, const ProgramParameters& programParameters) + SymbolLayerPrograms(gfx::Context& context, const ProgramParameters& programParameters) : symbolIcon(context, programParameters), symbolIconSDF(context, programParameters), symbolGlyph(context, programParameters), diff --git a/src/mbgl/programs/symbol_sdf_icon_program.hpp b/src/mbgl/programs/symbol_sdf_icon_program.hpp new file mode 100644 index 0000000000..57f27518d1 --- /dev/null +++ b/src/mbgl/programs/symbol_sdf_icon_program.hpp @@ -0,0 +1,4 @@ +#pragma once + +// Alias +#include <mbgl/programs/symbol_program.hpp> diff --git a/src/mbgl/programs/symbol_sdf_text_program.hpp b/src/mbgl/programs/symbol_sdf_text_program.hpp new file mode 100644 index 0000000000..57f27518d1 --- /dev/null +++ b/src/mbgl/programs/symbol_sdf_text_program.hpp @@ -0,0 +1,4 @@ +#pragma once + +// Alias +#include <mbgl/programs/symbol_program.hpp> diff --git a/src/mbgl/renderer/buckets/hillshade_bucket.cpp b/src/mbgl/renderer/buckets/hillshade_bucket.cpp index 588e4e50b1..3c14845dd8 100644 --- a/src/mbgl/renderer/buckets/hillshade_bucket.cpp +++ b/src/mbgl/renderer/buckets/hillshade_bucket.cpp @@ -2,7 +2,7 @@ #include <mbgl/renderer/layers/render_hillshade_layer.hpp> #include <mbgl/programs/hillshade_program.hpp> #include <mbgl/programs/hillshade_prepare_program.hpp> -#include <mbgl/gl/context.hpp> +#include <mbgl/gfx/context.hpp> namespace mbgl { diff --git a/src/mbgl/renderer/buckets/raster_bucket.cpp b/src/mbgl/renderer/buckets/raster_bucket.cpp index bf6dffbf17..a8cb47d52c 100644 --- a/src/mbgl/renderer/buckets/raster_bucket.cpp +++ b/src/mbgl/renderer/buckets/raster_bucket.cpp @@ -1,7 +1,7 @@ #include <mbgl/renderer/buckets/raster_bucket.hpp> #include <mbgl/renderer/layers/render_raster_layer.hpp> #include <mbgl/programs/raster_program.hpp> -#include <mbgl/gl/context.hpp> +#include <mbgl/gfx/context.hpp> namespace mbgl { diff --git a/src/mbgl/renderer/buckets/symbol_bucket.hpp b/src/mbgl/renderer/buckets/symbol_bucket.hpp index 9764d870da..fafa2592fe 100644 --- a/src/mbgl/renderer/buckets/symbol_bucket.hpp +++ b/src/mbgl/renderer/buckets/symbol_bucket.hpp @@ -114,7 +114,7 @@ public: struct CollisionBuffer { gfx::VertexVector<gfx::Vertex<CollisionBoxLayoutAttributes>> vertices; gfx::VertexVector<gfx::Vertex<CollisionBoxDynamicAttributes>> dynamicVertices; - SegmentVector<CollisionBoxProgram::Attributes> segments; + SegmentVector<CollisionBoxProgram::AttributeList> segments; optional<gfx::VertexBuffer<gfx::Vertex<CollisionBoxLayoutAttributes>>> vertexBuffer; optional<gfx::VertexBuffer<gfx::Vertex<CollisionBoxDynamicAttributes>>> dynamicVertexBuffer; diff --git a/src/mbgl/renderer/layers/render_background_layer.cpp b/src/mbgl/renderer/layers/render_background_layer.cpp index ae89a08cac..32e05a38ab 100644 --- a/src/mbgl/renderer/layers/render_background_layer.cpp +++ b/src/mbgl/renderer/layers/render_background_layer.cpp @@ -8,6 +8,7 @@ #include <mbgl/programs/background_program.hpp> #include <mbgl/util/tile_cover.hpp> #include <mbgl/map/transform_state.hpp> +#include <mbgl/gfx/cull_face_mode.hpp> #include <mbgl/gl/context.hpp> namespace mbgl { @@ -91,7 +92,7 @@ void RenderBackgroundLayer::render(PaintParameters& parameters, RenderSource*) { for (const auto& tileID : util::tileCover(parameters.state, parameters.state.getIntegerZoom())) { draw( parameters.programs.getBackgroundLayerPrograms().backgroundPattern, - BackgroundPatternProgram::uniformValues( + BackgroundPatternProgram::layoutUniformValues( parameters.matrixForTile(tileID), evaluated.get<BackgroundOpacity>(), parameters.imageManager.getPixelSize(), @@ -110,7 +111,7 @@ void RenderBackgroundLayer::render(PaintParameters& parameters, RenderSource*) { for (const auto& tileID : util::tileCover(parameters.state, parameters.state.getIntegerZoom())) { draw( parameters.programs.getBackgroundLayerPrograms().background, - BackgroundProgram::UniformValues { + BackgroundProgram::LayoutUniformValues { uniforms::u_matrix::Value( parameters.matrixForTile(tileID) ), uniforms::u_color::Value( evaluated.get<BackgroundColor>() ), uniforms::u_opacity::Value( evaluated.get<BackgroundOpacity>() ), diff --git a/src/mbgl/renderer/layers/render_circle_layer.cpp b/src/mbgl/renderer/layers/render_circle_layer.cpp index 32ee24551c..60a3bf8e01 100644 --- a/src/mbgl/renderer/layers/render_circle_layer.cpp +++ b/src/mbgl/renderer/layers/render_circle_layer.cpp @@ -7,6 +7,8 @@ #include <mbgl/tile/tile.hpp> #include <mbgl/style/layers/circle_layer_impl.hpp> #include <mbgl/geometry/feature_index.hpp> +#include <mbgl/gfx/cull_face_mode.hpp> +#include <mbgl/gl/context.hpp> #include <mbgl/util/math.hpp> #include <mbgl/util/intersection_tests.hpp> @@ -67,7 +69,7 @@ void RenderCircleLayer::render(PaintParameters& parameters, RenderSource*) { auto& programInstance = parameters.programs.getCircleLayerPrograms().circle.get(evaluated); const auto allUniformValues = programInstance.computeAllUniformValues( - CircleProgram::UniformValues { + CircleProgram::LayoutUniformValues { uniforms::u_matrix::Value( tile.translatedMatrix(evaluated.get<CircleTranslate>(), evaluated.get<CircleTranslateAnchor>(), diff --git a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp index 08f35f1c76..5af4732aa3 100644 --- a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp +++ b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp @@ -13,6 +13,7 @@ #include <mbgl/util/math.hpp> #include <mbgl/util/intersection_tests.hpp> #include <mbgl/tile/geometry_tile.hpp> +#include <mbgl/gfx/cull_face_mode.hpp> #include <mbgl/gl/context.hpp> namespace mbgl { @@ -117,7 +118,7 @@ void RenderFillExtrusionLayer::render(PaintParameters& parameters, RenderSource* draw( parameters.programs.getFillExtrusionLayerPrograms().fillExtrusion.get(evaluated), bucket, - FillExtrusionProgram::uniformValues( + FillExtrusionProgram::layoutUniformValues( tile.translatedClipMatrix(evaluated.get<FillExtrusionTranslate>(), evaluated.get<FillExtrusionTranslateAnchor>(), parameters.state), @@ -144,7 +145,7 @@ void RenderFillExtrusionLayer::render(PaintParameters& parameters, RenderSource* draw( parameters.programs.getFillExtrusionLayerPrograms().fillExtrusionPattern.get(evaluated), bucket, - FillExtrusionPatternProgram::uniformValues( + FillExtrusionPatternProgram::layoutUniformValues( tile.translatedClipMatrix(evaluated.get<FillExtrusionTranslate>(), evaluated.get<FillExtrusionTranslateAnchor>(), parameters.state), @@ -177,7 +178,7 @@ void RenderFillExtrusionLayer::render(PaintParameters& parameters, RenderSource* auto& programInstance = parameters.programs.getFillExtrusionLayerPrograms().extrusionTexture; const auto allUniformValues = programInstance.computeAllUniformValues( - ExtrusionTextureProgram::UniformValues{ + ExtrusionTextureProgram::LayoutUniformValues{ uniforms::u_matrix::Value( viewportMat ), uniforms::u_world::Value( size ), uniforms::u_opacity::Value( evaluated.get<FillExtrusionOpacity>() ) diff --git a/src/mbgl/renderer/layers/render_fill_layer.cpp b/src/mbgl/renderer/layers/render_fill_layer.cpp index 83989fa012..64f3448c69 100644 --- a/src/mbgl/renderer/layers/render_fill_layer.cpp +++ b/src/mbgl/renderer/layers/render_fill_layer.cpp @@ -8,6 +8,8 @@ #include <mbgl/tile/tile.hpp> #include <mbgl/style/layers/fill_layer_impl.hpp> #include <mbgl/geometry/feature_index.hpp> +#include <mbgl/gfx/cull_face_mode.hpp> +#include <mbgl/gl/context.hpp> #include <mbgl/util/math.hpp> #include <mbgl/util/intersection_tests.hpp> #include <mbgl/tile/geometry_tile.hpp> @@ -80,7 +82,7 @@ void RenderFillLayer::render(PaintParameters& parameters, RenderSource*) { const auto& paintPropertyBinders = bucket.paintPropertyBinders.at(getID()); const auto allUniformValues = programInstance.computeAllUniformValues( - FillProgram::UniformValues { + FillProgram::LayoutUniformValues { uniforms::u_matrix::Value( tile.translatedMatrix(evaluated.get<FillTranslate>(), evaluated.get<FillTranslateAnchor>(), @@ -169,7 +171,7 @@ void RenderFillLayer::render(PaintParameters& parameters, RenderSource*) { paintPropertyBinders.setPatternParameters(patternPosA, patternPosB, crossfade); const auto allUniformValues = programInstance.computeAllUniformValues( - FillPatternProgram::uniformValues( + FillPatternProgram::layoutUniformValues( tile.translatedMatrix(evaluated.get<FillTranslate>(), evaluated.get<FillTranslateAnchor>(), parameters.state), diff --git a/src/mbgl/renderer/layers/render_heatmap_layer.cpp b/src/mbgl/renderer/layers/render_heatmap_layer.cpp index 74b976658e..efc16fb28a 100644 --- a/src/mbgl/renderer/layers/render_heatmap_layer.cpp +++ b/src/mbgl/renderer/layers/render_heatmap_layer.cpp @@ -9,6 +9,8 @@ #include <mbgl/style/layers/heatmap_layer.hpp> #include <mbgl/style/layers/heatmap_layer_impl.hpp> #include <mbgl/geometry/feature_index.hpp> +#include <mbgl/gfx/cull_face_mode.hpp> +#include <mbgl/gl/context.hpp> #include <mbgl/util/math.hpp> #include <mbgl/util/intersection_tests.hpp> @@ -100,7 +102,7 @@ void RenderHeatmapLayer::render(PaintParameters& parameters, RenderSource*) { auto& programInstance = parameters.programs.getHeatmapLayerPrograms().heatmap.get(evaluated); const auto allUniformValues = programInstance.computeAllUniformValues( - HeatmapProgram::UniformValues { + HeatmapProgram::LayoutUniformValues { uniforms::u_intensity::Value( evaluated.get<style::HeatmapIntensity>() ), uniforms::u_matrix::Value( tile.matrix ), uniforms::heatmap::u_extrude_scale::Value( extrudeScale ) @@ -145,8 +147,9 @@ void RenderHeatmapLayer::render(PaintParameters& parameters, RenderSource*) { auto& programInstance = parameters.programs.getHeatmapLayerPrograms().heatmapTexture; const auto allUniformValues = programInstance.computeAllUniformValues( - HeatmapTextureProgram::UniformValues{ - uniforms::u_matrix::Value( viewportMat ), uniforms::u_world::Value( size ), + HeatmapTextureProgram::LayoutUniformValues{ + uniforms::u_matrix::Value( viewportMat ), + uniforms::u_world::Value( size ), uniforms::u_opacity::Value( evaluated.get<HeatmapOpacity>() ) }, paintAttributeData, diff --git a/src/mbgl/renderer/layers/render_hillshade_layer.cpp b/src/mbgl/renderer/layers/render_hillshade_layer.cpp index b428e357e7..00ecad444c 100644 --- a/src/mbgl/renderer/layers/render_hillshade_layer.cpp +++ b/src/mbgl/renderer/layers/render_hillshade_layer.cpp @@ -9,6 +9,8 @@ #include <mbgl/programs/hillshade_prepare_program.hpp> #include <mbgl/tile/tile.hpp> #include <mbgl/style/layers/hillshade_layer_impl.hpp> +#include <mbgl/gfx/cull_face_mode.hpp> +#include <mbgl/gl/context.hpp> #include <mbgl/util/geo.hpp> #include <mbgl/util/offscreen_texture.hpp> @@ -74,7 +76,7 @@ void RenderHillshadeLayer::render(PaintParameters& parameters, RenderSource* src const HillshadeProgram::Binders paintAttributeData{ evaluated, 0 }; const auto allUniformValues = programInstance.computeAllUniformValues( - HillshadeProgram::UniformValues { + HillshadeProgram::LayoutUniformValues { uniforms::u_matrix::Value( matrix ), uniforms::u_highlight::Value( evaluated.get<HillshadeHighlightColor>() ), uniforms::u_shadow::Value( evaluated.get<HillshadeShadowColor>() ), @@ -138,7 +140,7 @@ void RenderHillshadeLayer::render(PaintParameters& parameters, RenderSource* src auto& programInstance = parameters.programs.getHillshadeLayerPrograms().hillshadePrepare; const auto allUniformValues = programInstance.computeAllUniformValues( - HillshadePrepareProgram::UniformValues { + HillshadePrepareProgram::LayoutUniformValues { uniforms::u_matrix::Value( mat ), uniforms::u_dimension::Value( {{stride, stride}} ), uniforms::u_zoom::Value( float(tile.id.canonical.z) ), diff --git a/src/mbgl/renderer/layers/render_line_layer.cpp b/src/mbgl/renderer/layers/render_line_layer.cpp index 096afadf7d..eee151ccaa 100644 --- a/src/mbgl/renderer/layers/render_line_layer.cpp +++ b/src/mbgl/renderer/layers/render_line_layer.cpp @@ -8,6 +8,8 @@ #include <mbgl/geometry/line_atlas.hpp> #include <mbgl/tile/tile.hpp> #include <mbgl/style/layers/line_layer_impl.hpp> +#include <mbgl/gfx/cull_face_mode.hpp> +#include <mbgl/gl/context.hpp> #include <mbgl/geometry/feature_index.hpp> #include <mbgl/util/math.hpp> #include <mbgl/util/intersection_tests.hpp> @@ -110,7 +112,7 @@ void RenderLineLayer::render(PaintParameters& parameters, RenderSource*) { LinePatternPos posB = parameters.lineAtlas.getDashPosition(evaluated.get<LineDasharray>().to, cap); draw(parameters.programs.getLineLayerPrograms().lineSDF, - LineSDFProgram::uniformValues( + LineSDFProgram::layoutUniformValues( evaluated, parameters.pixelRatio, tile, @@ -135,7 +137,7 @@ void RenderLineLayer::render(PaintParameters& parameters, RenderSource*) { optional<ImagePosition> posB = geometryTile.getPattern(linePatternValue.to); draw(parameters.programs.getLineLayerPrograms().linePattern, - LinePatternProgram::uniformValues( + LinePatternProgram::layoutUniformValues( evaluated, tile, parameters.state, @@ -154,7 +156,7 @@ void RenderLineLayer::render(PaintParameters& parameters, RenderSource*) { } draw(parameters.programs.getLineLayerPrograms().lineGradient, - LineGradientProgram::uniformValues( + LineGradientProgram::layoutUniformValues( evaluated, tile, parameters.state, @@ -166,7 +168,7 @@ void RenderLineLayer::render(PaintParameters& parameters, RenderSource*) { }); } else { draw(parameters.programs.getLineLayerPrograms().line, - LineProgram::uniformValues( + LineProgram::layoutUniformValues( evaluated, tile, parameters.state, diff --git a/src/mbgl/renderer/layers/render_raster_layer.cpp b/src/mbgl/renderer/layers/render_raster_layer.cpp index f68acd4061..c8f00eb1fd 100644 --- a/src/mbgl/renderer/layers/render_raster_layer.cpp +++ b/src/mbgl/renderer/layers/render_raster_layer.cpp @@ -7,6 +7,8 @@ #include <mbgl/programs/programs.hpp> #include <mbgl/programs/raster_program.hpp> #include <mbgl/tile/tile.hpp> +#include <mbgl/gfx/cull_face_mode.hpp> +#include <mbgl/gl/context.hpp> #include <mbgl/style/layers/raster_layer_impl.hpp> namespace mbgl { @@ -82,7 +84,7 @@ void RenderRasterLayer::render(PaintParameters& parameters, RenderSource* source auto& programInstance = parameters.programs.getRasterLayerPrograms().raster; const auto allUniformValues = programInstance.computeAllUniformValues( - RasterProgram::UniformValues { + RasterProgram::LayoutUniformValues { uniforms::u_matrix::Value( matrix ), uniforms::u_opacity::Value( evaluated.get<RasterOpacity>() ), uniforms::u_fade_t::Value( 1 ), diff --git a/src/mbgl/renderer/layers/render_symbol_layer.cpp b/src/mbgl/renderer/layers/render_symbol_layer.cpp index 43e3068ff0..31d92dd414 100644 --- a/src/mbgl/renderer/layers/render_symbol_layer.cpp +++ b/src/mbgl/renderer/layers/render_symbol_layer.cpp @@ -12,6 +12,8 @@ #include <mbgl/tile/geometry_tile.hpp> #include <mbgl/tile/geometry_tile_data.hpp> #include <mbgl/style/layers/symbol_layer_impl.hpp> +#include <mbgl/gfx/cull_face_mode.hpp> +#include <mbgl/gl/context.hpp> #include <mbgl/layout/symbol_projection.hpp> #include <mbgl/util/math.hpp> @@ -170,7 +172,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) { if (bucket.sdfIcons) { if (values.hasHalo) { draw(parameters.programs.getSymbolLayerPrograms().symbolIconSDF, - SymbolSDFIconProgram::uniformValues(false, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange, SymbolSDFPart::Halo), + SymbolSDFIconProgram::layoutUniformValues(false, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange, SymbolSDFPart::Halo), bucket.icon, bucket.iconSizeBinder, values, @@ -183,7 +185,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) { if (values.hasFill) { draw(parameters.programs.getSymbolLayerPrograms().symbolIconSDF, - SymbolSDFIconProgram::uniformValues(false, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange, SymbolSDFPart::Fill), + SymbolSDFIconProgram::layoutUniformValues(false, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange, SymbolSDFPart::Fill), bucket.icon, bucket.iconSizeBinder, values, @@ -195,7 +197,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) { } } else { draw(parameters.programs.getSymbolLayerPrograms().symbolIcon, - SymbolIconProgram::uniformValues(false, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange), + SymbolIconProgram::layoutUniformValues(false, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange), bucket.icon, bucket.iconSizeBinder, values, @@ -233,7 +235,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) { if (values.hasHalo) { draw(parameters.programs.getSymbolLayerPrograms().symbolGlyph, - SymbolSDFTextProgram::uniformValues(true, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange, SymbolSDFPart::Halo), + SymbolSDFTextProgram::layoutUniformValues(true, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange, SymbolSDFPart::Halo), bucket.text, bucket.textSizeBinder, values, @@ -246,7 +248,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) { if (values.hasFill) { draw(parameters.programs.getSymbolLayerPrograms().symbolGlyph, - SymbolSDFTextProgram::uniformValues(true, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange, SymbolSDFPart::Fill), + SymbolSDFTextProgram::layoutUniformValues(true, values, texsize, parameters.pixelsToGLUnits, alongLine, tile, parameters.state, parameters.symbolFadeChange, SymbolSDFPart::Fill), bucket.text, bucket.textSizeBinder, values, @@ -277,7 +279,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) { gfx::StencilMode::disabled(), parameters.colorModeForRenderPass(), gfx::CullFaceMode::disabled(), - CollisionBoxProgram::UniformValues { + CollisionBoxProgram::LayoutUniformValues { uniforms::u_matrix::Value( tile.matrix ), uniforms::u_extrude_scale::Value( extrudeScale ), uniforms::u_camera_to_center_distance::Value( parameters.state.getCameraToCenterDistance() ) @@ -313,7 +315,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) { gfx::StencilMode::disabled(), parameters.colorModeForRenderPass(), gfx::CullFaceMode::disabled(), - CollisionCircleProgram::UniformValues { + CollisionCircleProgram::LayoutUniformValues { uniforms::u_matrix::Value( tile.matrix ), uniforms::u_extrude_scale::Value( extrudeScale ), uniforms::u_overscale_factor::Value( float(tile.tile.id.overscaleFactor()) ), diff --git a/src/mbgl/renderer/paint_property_binder.hpp b/src/mbgl/renderer/paint_property_binder.hpp index dc5ab6ae22..a014b36ece 100644 --- a/src/mbgl/renderer/paint_property_binder.hpp +++ b/src/mbgl/renderer/paint_property_binder.hpp @@ -2,9 +2,8 @@ #include <mbgl/gfx/context.hpp> #include <mbgl/gfx/uniform.hpp> +#include <mbgl/gfx/attribute.hpp> #include <mbgl/programs/attributes.hpp> -#include <mbgl/gl/attribute.hpp> -#include <mbgl/gl/uniform.hpp> #include <mbgl/util/type_list.hpp> #include <mbgl/renderer/possibly_evaluated_property_value.hpp> #include <mbgl/renderer/paint_property_statistics.hpp> @@ -101,7 +100,7 @@ public: const style::expression::Value&) = 0; virtual void upload(gfx::Context& context) = 0; virtual void setPatternParameters(const optional<ImagePosition>&, const optional<ImagePosition>&, CrossfadeParameters&) = 0; - virtual std::tuple<ExpandToType<As, optional<gl::AttributeBinding>>...> attributeBinding(const PossiblyEvaluatedType& currentValue) const = 0; + virtual std::tuple<ExpandToType<As, optional<gfx::AttributeBinding>>...> attributeBinding(const PossiblyEvaluatedType& currentValue) const = 0; virtual std::tuple<ExpandToType<As, float>...> interpolationFactor(float currentZoom) const = 0; virtual std::tuple<ExpandToType<As, UniformValueType>...> uniformValue(const PossiblyEvaluatedType& currentValue) const = 0; @@ -121,8 +120,8 @@ public: void upload(gfx::Context&) override {} void setPatternParameters(const optional<ImagePosition>&, const optional<ImagePosition>&, CrossfadeParameters&) override {}; - std::tuple<optional<gl::AttributeBinding>> attributeBinding(const PossiblyEvaluatedPropertyValue<T>&) const override { - return std::tuple<optional<gl::AttributeBinding>> {}; + std::tuple<optional<gfx::AttributeBinding>> attributeBinding(const PossiblyEvaluatedPropertyValue<T>&) const override { + return {}; } std::tuple<float> interpolationFactor(float) const override { @@ -155,9 +154,9 @@ public: } } - std::tuple<optional<gl::AttributeBinding>, optional<gl::AttributeBinding>> + std::tuple<optional<gfx::AttributeBinding>, optional<gfx::AttributeBinding>> attributeBinding(const PossiblyEvaluatedPropertyValue<Faded<T>>&) const override { - return std::tuple<optional<gl::AttributeBinding>, optional<gl::AttributeBinding>> {}; + return {}; } std::tuple<float, float> interpolationFactor(float) const override { @@ -177,7 +176,7 @@ template <class T, class A> class SourceFunctionPaintPropertyBinder final : public PaintPropertyBinder<T, T, PossiblyEvaluatedPropertyValue<T>, A> { public: using BaseAttributeType = A; - using BaseVertex = gfx::Vertex<BaseAttributeType>; + using BaseVertex = gfx::VertexType<BaseAttributeType>; using AttributeType = ZoomInterpolatedAttributeType<A>; @@ -200,12 +199,12 @@ public: vertexBuffer = context.createVertexBuffer(std::move(vertexVector)); } - std::tuple<optional<gl::AttributeBinding>> attributeBinding(const PossiblyEvaluatedPropertyValue<T>& currentValue) const override { + std::tuple<optional<gfx::AttributeBinding>> attributeBinding(const PossiblyEvaluatedPropertyValue<T>& currentValue) const override { if (currentValue.isConstant()) { return {}; } else { - return std::tuple<optional<gl::AttributeBinding>>{ - gl::attributeBinding<0>(*vertexBuffer) + return std::tuple<optional<gfx::AttributeBinding>>{ + gfx::attributeBinding(*vertexBuffer) }; } } @@ -236,7 +235,7 @@ public: using AttributeType = ZoomInterpolatedAttributeType<A>; using AttributeValue = typename AttributeType::Value; - using Vertex = gfx::Vertex<AttributeType>; + using Vertex = gfx::VertexType<AttributeType>; CompositeFunctionPaintPropertyBinder(style::PropertyExpression<T> expression_, float zoom, T defaultValue_) : expression(std::move(expression_)), @@ -264,12 +263,12 @@ public: vertexBuffer = context.createVertexBuffer(std::move(vertexVector)); } - std::tuple<optional<gl::AttributeBinding>> attributeBinding(const PossiblyEvaluatedPropertyValue<T>& currentValue) const override { + std::tuple<optional<gfx::AttributeBinding>> attributeBinding(const PossiblyEvaluatedPropertyValue<T>& currentValue) const override { if (currentValue.isConstant()) { return {}; } else { - return std::tuple<optional<gl::AttributeBinding>>{ - gl::attributeBinding<0>(*vertexBuffer) + return std::tuple<optional<gfx::AttributeBinding>>{ + gfx::attributeBinding(*vertexBuffer) }; } } @@ -308,8 +307,8 @@ public: using BaseAttributeType = A1; using BaseAttributeType2 = A2; - using Vertex = gfx::Vertex<BaseAttributeType>; - using Vertex2 = gfx::Vertex<BaseAttributeType2>; + using Vertex = gfx::VertexType<BaseAttributeType>; + using Vertex2 = gfx::VertexType<BaseAttributeType2>; CompositeCrossFadedPaintPropertyBinder(style::PropertyExpression<T> expression_, float zoom, T defaultValue_) : expression(std::move(expression_)), @@ -358,13 +357,13 @@ public: zoomOutVertexBuffer = context.createVertexBuffer(std::move(zoomOutVertexVector)); } - std::tuple<optional<gl::AttributeBinding>, optional<gl::AttributeBinding>> attributeBinding(const PossiblyEvaluatedPropertyValue<Faded<T>>& currentValue) const override { + std::tuple<optional<gfx::AttributeBinding>, optional<gfx::AttributeBinding>> attributeBinding(const PossiblyEvaluatedPropertyValue<Faded<T>>& currentValue) const override { if (currentValue.isConstant()) { return {}; } else { - return std::tuple<optional<gl::AttributeBinding>, optional<gl::AttributeBinding>>{ - gl::attributeBinding<0>(*patternToVertexBuffer), - gl::attributeBinding<0>(crossfade.fromScale == 2 ? *zoomInVertexBuffer : *zoomOutVertexBuffer) + return std::tuple<optional<gfx::AttributeBinding>, optional<gfx::AttributeBinding>>{ + gfx::attributeBinding(*patternToVertexBuffer), + gfx::attributeBinding(crossfade.fromScale == 2 ? *zoomInVertexBuffer : *zoomOutVertexBuffer) }; } } @@ -506,8 +505,7 @@ public: using InterpolationUniformList = typename Property<P>::InterpolationUniformList; using AttributeList = TypeListConcat<ZoomInterpolatedAttributeList<Ps>...>; - using Attributes = gl::Attributes<AttributeList>; - using AttributeBindings = typename Attributes::Bindings; + using AttributeBindings = gfx::AttributeBindings<AttributeList>; template <class EvaluatedProperties> AttributeBindings attributeBindings(const EvaluatedProperties& currentProperties) const { @@ -518,7 +516,6 @@ public: using UniformList = TypeListConcat<InterpolationUniformList<Ps>..., typename Ps::UniformList...>; using UniformValues = gfx::UniformValues<UniformList>; - using Uniforms = gl::Uniforms<UniformList>; template <class EvaluatedProperties> UniformValues uniformValues(float currentZoom, EvaluatedProperties& currentProperties) const { diff --git a/src/mbgl/renderer/render_static_data.cpp b/src/mbgl/renderer/render_static_data.cpp index cae0e0a820..16d0d64a33 100644 --- a/src/mbgl/renderer/render_static_data.cpp +++ b/src/mbgl/renderer/render_static_data.cpp @@ -1,4 +1,5 @@ #include <mbgl/renderer/render_static_data.hpp> +#include <mbgl/gl/context.hpp> #include <mbgl/programs/program_parameters.hpp> namespace mbgl { diff --git a/src/mbgl/renderer/render_static_data.hpp b/src/mbgl/renderer/render_static_data.hpp index da887dff22..b9b52b09ca 100644 --- a/src/mbgl/renderer/render_static_data.hpp +++ b/src/mbgl/renderer/render_static_data.hpp @@ -2,6 +2,7 @@ #include <mbgl/gfx/vertex_buffer.hpp> #include <mbgl/gfx/index_buffer.hpp> +#include <mbgl/gl/renderbuffer.hpp> #include <mbgl/programs/background_program.hpp> #include <mbgl/programs/extrusion_texture_program.hpp> #include <mbgl/programs/programs.hpp> diff --git a/src/mbgl/renderer/render_tile.cpp b/src/mbgl/renderer/render_tile.cpp index d240189d74..24826bfd78 100644 --- a/src/mbgl/renderer/render_tile.cpp +++ b/src/mbgl/renderer/render_tile.cpp @@ -4,6 +4,7 @@ #include <mbgl/renderer/render_static_data.hpp> #include <mbgl/programs/programs.hpp> #include <mbgl/map/transform_state.hpp> +#include <mbgl/gl/context.hpp> #include <mbgl/tile/tile.hpp> #include <mbgl/util/math.hpp> @@ -103,7 +104,7 @@ void RenderTile::finishRender(PaintParameters& parameters) { *tile.debugBucket->indexBuffer, tile.debugBucket->segments, program.computeAllUniformValues( - DebugProgram::UniformValues { + DebugProgram::LayoutUniformValues { uniforms::u_matrix::Value( matrix ), uniforms::u_color::Value( Color::white() ) }, @@ -126,7 +127,7 @@ void RenderTile::finishRender(PaintParameters& parameters) { *tile.debugBucket->indexBuffer, tile.debugBucket->segments, program.computeAllUniformValues( - DebugProgram::UniformValues { + DebugProgram::LayoutUniformValues { uniforms::u_matrix::Value( matrix ), uniforms::u_color::Value( Color::black() ) }, @@ -151,7 +152,7 @@ void RenderTile::finishRender(PaintParameters& parameters) { parameters.staticData.tileBorderIndexBuffer, parameters.staticData.tileBorderSegments, program.computeAllUniformValues( - DebugProgram::UniformValues { + DebugProgram::LayoutUniformValues { uniforms::u_matrix::Value( matrix ), uniforms::u_color::Value( Color::red() ) }, diff --git a/src/mbgl/renderer/renderer_impl.cpp b/src/mbgl/renderer/renderer_impl.cpp index 8a9989dd51..471536cf40 100644 --- a/src/mbgl/renderer/renderer_impl.cpp +++ b/src/mbgl/renderer/renderer_impl.cpp @@ -461,7 +461,7 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) { parameters.staticData.quadTriangleIndexBuffer, parameters.staticData.tileTriangleSegments, program.computeAllUniformValues( - ClippingMaskProgram::UniformValues { + ClippingMaskProgram::LayoutUniformValues { uniforms::u_matrix::Value( parameters.matrixForTile(clipID.first) ), }, paintAttributeData, diff --git a/src/mbgl/renderer/sources/render_image_source.cpp b/src/mbgl/renderer/sources/render_image_source.cpp index cc8525aa9f..1b135a2838 100644 --- a/src/mbgl/renderer/sources/render_image_source.cpp +++ b/src/mbgl/renderer/sources/render_image_source.cpp @@ -7,6 +7,7 @@ #include <mbgl/renderer/tile_parameters.hpp> #include <mbgl/renderer/render_static_data.hpp> #include <mbgl/programs/programs.hpp> +#include <mbgl/gl/context.hpp> #include <mbgl/util/tile_coordinate.hpp> #include <mbgl/util/tile_cover.hpp> #include <mbgl/util/logging.hpp> @@ -71,7 +72,7 @@ void RenderImageSource::finishRender(PaintParameters& parameters) { parameters.staticData.tileBorderIndexBuffer, parameters.staticData.tileBorderSegments, programInstance.computeAllUniformValues( - DebugProgram::UniformValues { + DebugProgram::LayoutUniformValues { uniforms::u_matrix::Value( matrix ), uniforms::u_color::Value( Color::red() ) }, diff --git a/src/mbgl/shaders/background.cpp b/src/mbgl/shaders/background.cpp deleted file mode 100644 index 60f2d228be..0000000000 --- a/src/mbgl/shaders/background.cpp +++ /dev/null @@ -1,41 +0,0 @@ -// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. - -#include <mbgl/shaders/background.hpp> -#include <mbgl/shaders/source.hpp> - -namespace mbgl { -namespace shaders { - -const char* background::name = "background"; -const char* background::vertexSource = source() + 1429; -const char* background::fragmentSource = source() + 1525; - -// Uncompressed source of background.vertex.glsl: -/* -attribute vec2 a_pos; - -uniform mat4 u_matrix; - -void main() { - gl_Position = u_matrix * vec4(a_pos, 0, 1); -} - -*/ - -// Uncompressed source of background.fragment.glsl: -/* -uniform vec4 u_color; -uniform float u_opacity; - -void main() { - gl_FragColor = u_color * u_opacity; - -#ifdef OVERDRAW_INSPECTOR - gl_FragColor = vec4(1.0); -#endif -} - -*/ - -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/background.hpp b/src/mbgl/shaders/background.hpp deleted file mode 100644 index 2fa6f56e29..0000000000 --- a/src/mbgl/shaders/background.hpp +++ /dev/null @@ -1,16 +0,0 @@ -// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. - -#pragma once - -namespace mbgl { -namespace shaders { - -class background { -public: - static const char* name; - static const char* vertexSource; - static const char* fragmentSource; -}; - -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/background_pattern.hpp b/src/mbgl/shaders/background_pattern.hpp deleted file mode 100644 index e970ffd670..0000000000 --- a/src/mbgl/shaders/background_pattern.hpp +++ /dev/null @@ -1,16 +0,0 @@ -// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. - -#pragma once - -namespace mbgl { -namespace shaders { - -class background_pattern { -public: - static const char* name; - static const char* vertexSource; - static const char* fragmentSource; -}; - -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/circle.hpp b/src/mbgl/shaders/circle.hpp deleted file mode 100644 index d14b26b783..0000000000 --- a/src/mbgl/shaders/circle.hpp +++ /dev/null @@ -1,16 +0,0 @@ -// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. - -#pragma once - -namespace mbgl { -namespace shaders { - -class circle { -public: - static const char* name; - static const char* vertexSource; - static const char* fragmentSource; -}; - -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/clipping_mask.cpp b/src/mbgl/shaders/clipping_mask.cpp deleted file mode 100644 index 717ebd3e84..0000000000 --- a/src/mbgl/shaders/clipping_mask.cpp +++ /dev/null @@ -1,34 +0,0 @@ -// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. - -#include <mbgl/shaders/clipping_mask.hpp> -#include <mbgl/shaders/source.hpp> - -namespace mbgl { -namespace shaders { - -const char* clipping_mask::name = "clipping_mask"; -const char* clipping_mask::vertexSource = source() + 7848; -const char* clipping_mask::fragmentSource = source() + 7944; - -// Uncompressed source of clipping_mask.vertex.glsl: -/* -attribute vec2 a_pos; - -uniform mat4 u_matrix; - -void main() { - gl_Position = u_matrix * vec4(a_pos, 0, 1); -} - -*/ - -// Uncompressed source of clipping_mask.fragment.glsl: -/* -void main() { - gl_FragColor = vec4(1.0); -} - -*/ - -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/clipping_mask.hpp b/src/mbgl/shaders/clipping_mask.hpp deleted file mode 100644 index bd01ab62fa..0000000000 --- a/src/mbgl/shaders/clipping_mask.hpp +++ /dev/null @@ -1,16 +0,0 @@ -// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. - -#pragma once - -namespace mbgl { -namespace shaders { - -class clipping_mask { -public: - static const char* name; - static const char* vertexSource; - static const char* fragmentSource; -}; - -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/collision_box.hpp b/src/mbgl/shaders/collision_box.hpp deleted file mode 100644 index e0f70c7968..0000000000 --- a/src/mbgl/shaders/collision_box.hpp +++ /dev/null @@ -1,16 +0,0 @@ -// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. - -#pragma once - -namespace mbgl { -namespace shaders { - -class collision_box { -public: - static const char* name; - static const char* vertexSource; - static const char* fragmentSource; -}; - -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/collision_circle.hpp b/src/mbgl/shaders/collision_circle.hpp deleted file mode 100644 index 12b1bcd445..0000000000 --- a/src/mbgl/shaders/collision_circle.hpp +++ /dev/null @@ -1,16 +0,0 @@ -// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. - -#pragma once - -namespace mbgl { -namespace shaders { - -class collision_circle { -public: - static const char* name; - static const char* vertexSource; - static const char* fragmentSource; -}; - -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/debug.cpp b/src/mbgl/shaders/debug.cpp deleted file mode 100644 index 9f3a9cbc37..0000000000 --- a/src/mbgl/shaders/debug.cpp +++ /dev/null @@ -1,36 +0,0 @@ -// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. - -#include <mbgl/shaders/debug.hpp> -#include <mbgl/shaders/source.hpp> - -namespace mbgl { -namespace shaders { - -const char* debug::name = "debug"; -const char* debug::vertexSource = source() + 12450; -const char* debug::fragmentSource = source() + 12546; - -// Uncompressed source of debug.vertex.glsl: -/* -attribute vec2 a_pos; - -uniform mat4 u_matrix; - -void main() { - gl_Position = u_matrix * vec4(a_pos, 0, 1); -} - -*/ - -// Uncompressed source of debug.fragment.glsl: -/* -uniform highp vec4 u_color; - -void main() { - gl_FragColor = u_color; -} - -*/ - -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/debug.hpp b/src/mbgl/shaders/debug.hpp deleted file mode 100644 index 207c7bf075..0000000000 --- a/src/mbgl/shaders/debug.hpp +++ /dev/null @@ -1,16 +0,0 @@ -// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. - -#pragma once - -namespace mbgl { -namespace shaders { - -class debug { -public: - static const char* name; - static const char* vertexSource; - static const char* fragmentSource; -}; - -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/extrusion_texture.hpp b/src/mbgl/shaders/extrusion_texture.hpp deleted file mode 100644 index 05e54c5499..0000000000 --- a/src/mbgl/shaders/extrusion_texture.hpp +++ /dev/null @@ -1,16 +0,0 @@ -// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. - -#pragma once - -namespace mbgl { -namespace shaders { - -class extrusion_texture { -public: - static const char* name; - static const char* vertexSource; - static const char* fragmentSource; -}; - -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/fill.hpp b/src/mbgl/shaders/fill.hpp deleted file mode 100644 index 29fede7b55..0000000000 --- a/src/mbgl/shaders/fill.hpp +++ /dev/null @@ -1,16 +0,0 @@ -// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. - -#pragma once - -namespace mbgl { -namespace shaders { - -class fill { -public: - static const char* name; - static const char* vertexSource; - static const char* fragmentSource; -}; - -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/fill_extrusion.hpp b/src/mbgl/shaders/fill_extrusion.hpp deleted file mode 100644 index 949ae57f12..0000000000 --- a/src/mbgl/shaders/fill_extrusion.hpp +++ /dev/null @@ -1,16 +0,0 @@ -// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. - -#pragma once - -namespace mbgl { -namespace shaders { - -class fill_extrusion { -public: - static const char* name; - static const char* vertexSource; - static const char* fragmentSource; -}; - -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/fill_extrusion_pattern.hpp b/src/mbgl/shaders/fill_extrusion_pattern.hpp deleted file mode 100644 index e9ae001d4e..0000000000 --- a/src/mbgl/shaders/fill_extrusion_pattern.hpp +++ /dev/null @@ -1,16 +0,0 @@ -// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. - -#pragma once - -namespace mbgl { -namespace shaders { - -class fill_extrusion_pattern { -public: - static const char* name; - static const char* vertexSource; - static const char* fragmentSource; -}; - -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/fill_outline.hpp b/src/mbgl/shaders/fill_outline.hpp deleted file mode 100644 index ef685e62fa..0000000000 --- a/src/mbgl/shaders/fill_outline.hpp +++ /dev/null @@ -1,16 +0,0 @@ -// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. - -#pragma once - -namespace mbgl { -namespace shaders { - -class fill_outline { -public: - static const char* name; - static const char* vertexSource; - static const char* fragmentSource; -}; - -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/fill_outline_pattern.hpp b/src/mbgl/shaders/fill_outline_pattern.hpp deleted file mode 100644 index e1c7a173f4..0000000000 --- a/src/mbgl/shaders/fill_outline_pattern.hpp +++ /dev/null @@ -1,16 +0,0 @@ -// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. - -#pragma once - -namespace mbgl { -namespace shaders { - -class fill_outline_pattern { -public: - static const char* name; - static const char* vertexSource; - static const char* fragmentSource; -}; - -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/fill_pattern.hpp b/src/mbgl/shaders/fill_pattern.hpp deleted file mode 100644 index 4d09519ed8..0000000000 --- a/src/mbgl/shaders/fill_pattern.hpp +++ /dev/null @@ -1,16 +0,0 @@ -// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. - -#pragma once - -namespace mbgl { -namespace shaders { - -class fill_pattern { -public: - static const char* name; - static const char* vertexSource; - static const char* fragmentSource; -}; - -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/heatmap.hpp b/src/mbgl/shaders/heatmap.hpp deleted file mode 100644 index a3c64db942..0000000000 --- a/src/mbgl/shaders/heatmap.hpp +++ /dev/null @@ -1,16 +0,0 @@ -// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. - -#pragma once - -namespace mbgl { -namespace shaders { - -class heatmap { -public: - static const char* name; - static const char* vertexSource; - static const char* fragmentSource; -}; - -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/heatmap_texture.hpp b/src/mbgl/shaders/heatmap_texture.hpp deleted file mode 100644 index c51dc6b178..0000000000 --- a/src/mbgl/shaders/heatmap_texture.hpp +++ /dev/null @@ -1,16 +0,0 @@ -// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. - -#pragma once - -namespace mbgl { -namespace shaders { - -class heatmap_texture { -public: - static const char* name; - static const char* vertexSource; - static const char* fragmentSource; -}; - -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/hillshade.hpp b/src/mbgl/shaders/hillshade.hpp deleted file mode 100644 index a4a27cb595..0000000000 --- a/src/mbgl/shaders/hillshade.hpp +++ /dev/null @@ -1,16 +0,0 @@ -// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. - -#pragma once - -namespace mbgl { -namespace shaders { - -class hillshade { -public: - static const char* name; - static const char* vertexSource; - static const char* fragmentSource; -}; - -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/hillshade_prepare.hpp b/src/mbgl/shaders/hillshade_prepare.hpp deleted file mode 100644 index c38b4a0d19..0000000000 --- a/src/mbgl/shaders/hillshade_prepare.hpp +++ /dev/null @@ -1,16 +0,0 @@ -// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. - -#pragma once - -namespace mbgl { -namespace shaders { - -class hillshade_prepare { -public: - static const char* name; - static const char* vertexSource; - static const char* fragmentSource; -}; - -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/line.hpp b/src/mbgl/shaders/line.hpp deleted file mode 100644 index c0d81e6202..0000000000 --- a/src/mbgl/shaders/line.hpp +++ /dev/null @@ -1,16 +0,0 @@ -// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. - -#pragma once - -namespace mbgl { -namespace shaders { - -class line { -public: - static const char* name; - static const char* vertexSource; - static const char* fragmentSource; -}; - -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/line_gradient.hpp b/src/mbgl/shaders/line_gradient.hpp deleted file mode 100644 index 87a9d6d38c..0000000000 --- a/src/mbgl/shaders/line_gradient.hpp +++ /dev/null @@ -1,16 +0,0 @@ -// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. - -#pragma once - -namespace mbgl { -namespace shaders { - -class line_gradient { -public: - static const char* name; - static const char* vertexSource; - static const char* fragmentSource; -}; - -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/line_pattern.hpp b/src/mbgl/shaders/line_pattern.hpp deleted file mode 100644 index 0394e83fe0..0000000000 --- a/src/mbgl/shaders/line_pattern.hpp +++ /dev/null @@ -1,16 +0,0 @@ -// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. - -#pragma once - -namespace mbgl { -namespace shaders { - -class line_pattern { -public: - static const char* name; - static const char* vertexSource; - static const char* fragmentSource; -}; - -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/line_sdf.hpp b/src/mbgl/shaders/line_sdf.hpp deleted file mode 100644 index 1d4b566f25..0000000000 --- a/src/mbgl/shaders/line_sdf.hpp +++ /dev/null @@ -1,16 +0,0 @@ -// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. - -#pragma once - -namespace mbgl { -namespace shaders { - -class line_sdf { -public: - static const char* name; - static const char* vertexSource; - static const char* fragmentSource; -}; - -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/preludes.cpp b/src/mbgl/shaders/preludes.cpp deleted file mode 100644 index a9a507742c..0000000000 --- a/src/mbgl/shaders/preludes.cpp +++ /dev/null @@ -1,13 +0,0 @@ -// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. - -#include <mbgl/shaders/preludes.hpp> -#include <mbgl/shaders/source.hpp> - -namespace mbgl { -namespace shaders { - -const char* vertexPrelude = source() + 0; -const char* fragmentPrelude = source() + 1252; - -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/preludes.hpp b/src/mbgl/shaders/preludes.hpp deleted file mode 100644 index a3abc9001f..0000000000 --- a/src/mbgl/shaders/preludes.hpp +++ /dev/null @@ -1,12 +0,0 @@ -// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. - -#pragma once - -namespace mbgl { -namespace shaders { - -extern const char* vertexPrelude; -extern const char* fragmentPrelude; - -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/raster.hpp b/src/mbgl/shaders/raster.hpp deleted file mode 100644 index 791e2c8be0..0000000000 --- a/src/mbgl/shaders/raster.hpp +++ /dev/null @@ -1,16 +0,0 @@ -// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. - -#pragma once - -namespace mbgl { -namespace shaders { - -class raster { -public: - static const char* name; - static const char* vertexSource; - static const char* fragmentSource; -}; - -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/source.cpp b/src/mbgl/shaders/source.cpp deleted file mode 100644 index bc105946ba..0000000000 --- a/src/mbgl/shaders/source.cpp +++ /dev/null @@ -1,917 +0,0 @@ -// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. - -#include <mbgl/shaders/source.hpp> -#include <mbgl/util/compression.hpp> - -#include <cstdint> - -namespace mbgl { -namespace shaders { - -const char* source() { - static const uint8_t compressed[] = { - 0x78, 0xda, 0xed, 0x3d, 0xfd, 0x6f, 0xe3, 0x36, - 0xb2, 0xf7, 0x73, 0xfe, 0x0a, 0x17, 0x05, 0x0e, - 0x92, 0x2c, 0x5b, 0xb6, 0x93, 0xec, 0x97, 0x4e, - 0xaf, 0x08, 0x76, 0xb3, 0x7d, 0x01, 0xda, 0xdd, - 0x60, 0xd3, 0xf6, 0x15, 0x57, 0x2c, 0x0c, 0xc9, - 0x56, 0x6c, 0xdf, 0xd9, 0x96, 0x9f, 0xad, 0x24, - 0x76, 0x0e, 0xf9, 0xdf, 0x1f, 0x87, 0xdf, 0xa4, - 0x48, 0x59, 0x76, 0x12, 0xe7, 0xe3, 0x19, 0x45, - 0x37, 0x16, 0x39, 0x1c, 0x0e, 0xc9, 0xe1, 0x70, - 0x66, 0x48, 0x0e, 0x7f, 0x1c, 0x5d, 0xf6, 0xd3, - 0xcb, 0xda, 0xcf, 0xbf, 0x74, 0x4f, 0x2f, 0x0e, - 0x66, 0xf3, 0xb4, 0x37, 0x5a, 0x8c, 0xb2, 0x69, - 0x6d, 0x38, 0x1a, 0x0c, 0x67, 0xb5, 0xcb, 0x71, - 0x16, 0xe7, 0xe1, 0xc1, 0x8f, 0xe9, 0x78, 0x91, - 0x1e, 0xfc, 0x38, 0xba, 0xac, 0xfd, 0x80, 0x60, - 0x47, 0xd3, 0xb4, 0xef, 0x8c, 0xb3, 0x9b, 0x99, - 0x7b, 0xf0, 0x23, 0xf9, 0xac, 0xc1, 0x17, 0x82, - 0x9a, 0xf6, 0x47, 0x97, 0x2a, 0xd8, 0x24, 0xed, - 0x8f, 0xae, 0x26, 0x12, 0x24, 0x4d, 0x30, 0x02, - 0xe3, 0x3a, 0x05, 0x28, 0xfe, 0xe4, 0x80, 0xe4, - 0xcf, 0x75, 0xda, 0xeb, 0xd4, 0xae, 0xa6, 0xb3, - 0xb8, 0xf7, 0xef, 0x2e, 0x26, 0xce, 0xe9, 0x65, - 0xd3, 0x45, 0x4e, 0x08, 0xad, 0x41, 0x72, 0xda, - 0xff, 0x23, 0x1e, 0x5f, 0xa5, 0x6e, 0xed, 0x3f, - 0xa3, 0x29, 0x4b, 0x39, 0x9b, 0xe6, 0x38, 0x31, - 0x42, 0x49, 0x8e, 0x0c, 0x14, 0x02, 0xcc, 0x75, - 0x2b, 0x52, 0xc1, 0x82, 0xce, 0xf1, 0x9b, 0x70, - 0x9e, 0xe6, 0x57, 0xf3, 0x69, 0x0d, 0x2a, 0x74, - 0xae, 0x5b, 0xbe, 0x0a, 0xd1, 0xb8, 0x6e, 0x79, - 0x08, 0xc8, 0x0d, 0xef, 0x64, 0x82, 0x32, 0xf4, - 0xef, 0x28, 0x5f, 0x19, 0x48, 0xfa, 0x4a, 0x72, - 0x28, 0x51, 0xe8, 0x7f, 0x9a, 0x20, 0x11, 0xc4, - 0x40, 0x82, 0x8e, 0x52, 0x35, 0x69, 0xa4, 0x28, - 0xe1, 0x06, 0xed, 0xce, 0xdb, 0x66, 0xcb, 0x9f, - 0x64, 0x7d, 0xb5, 0xa0, 0xdf, 0x69, 0xb6, 0x5c, - 0x42, 0xd0, 0x51, 0xad, 0x9f, 0xf6, 0xb2, 0x7e, - 0xda, 0xed, 0x65, 0xe3, 0x6c, 0x4e, 0xc9, 0xc1, - 0x84, 0xa6, 0x53, 0x48, 0xef, 0x7f, 0x84, 0x74, - 0x44, 0x8c, 0xa8, 0xe8, 0xc8, 0x51, 0x3a, 0x55, - 0x86, 0xfb, 0xab, 0xf5, 0x1d, 0x11, 0x75, 0x7c, - 0x8c, 0x2a, 0xb5, 0xc3, 0xb4, 0x19, 0xcc, 0x01, - 0x22, 0x81, 0xb4, 0x9c, 0x02, 0x4f, 0x46, 0xcb, - 0x2e, 0x6e, 0x89, 0x44, 0x86, 0x34, 0x04, 0xbe, - 0xdc, 0x59, 0xb9, 0xa0, 0x09, 0x15, 0x93, 0x47, - 0x0a, 0x11, 0xe1, 0xcb, 0x9f, 0xed, 0xef, 0x7e, - 0xce, 0x1a, 0x2b, 0x55, 0xa4, 0x35, 0xf8, 0x88, - 0xd6, 0x84, 0x69, 0x5c, 0x14, 0xaa, 0xc2, 0x10, - 0x93, 0xd1, 0x14, 0x67, 0x47, 0x4a, 0x9f, 0x61, - 0x8a, 0xe5, 0xc2, 0x82, 0x00, 0xfa, 0x8d, 0x5a, - 0xec, 0x86, 0x04, 0x43, 0xbc, 0xac, 0x84, 0xa1, - 0xa3, 0x61, 0x38, 0x04, 0x0c, 0x52, 0x73, 0x19, - 0x25, 0x3e, 0x43, 0xc8, 0x9a, 0xd8, 0xa9, 0x0d, - 0xd2, 0xbc, 0x3b, 0x8b, 0xf3, 0x3c, 0x9d, 0x4f, - 0xbb, 0xb3, 0x6c, 0xa1, 0xf4, 0xe5, 0x68, 0x99, - 0x8e, 0x51, 0x9d, 0xd9, 0xbc, 0xdf, 0xbd, 0x9a, - 0xcd, 0xd2, 0xb9, 0x6f, 0xc9, 0x44, 0x73, 0x54, - 0xcb, 0xa4, 0x08, 0x17, 0xa3, 0x5b, 0x6d, 0x18, - 0x46, 0xe3, 0xb4, 0x7b, 0x35, 0x1d, 0xe5, 0x8b, - 0x6e, 0x9e, 0x75, 0x31, 0x8e, 0x85, 0x52, 0x30, - 0x5b, 0x90, 0xde, 0xeb, 0xd4, 0xb2, 0xcb, 0xcb, - 0x45, 0x9a, 0x47, 0xc0, 0x8d, 0xec, 0xff, 0x22, - 0x41, 0x72, 0x45, 0x2e, 0xcc, 0x9b, 0x66, 0xcb, - 0x94, 0x56, 0x2f, 0x52, 0xab, 0x40, 0xb1, 0xbe, - 0x72, 0x4c, 0xf4, 0x79, 0x88, 0xa8, 0x3a, 0xa1, - 0xc6, 0x0d, 0xe4, 0x62, 0xe1, 0xdd, 0xc1, 0xdf, - 0x7e, 0x34, 0xcb, 0x38, 0x2a, 0x8b, 0x9e, 0x9f, - 0x94, 0xfb, 0x1b, 0xa2, 0x7f, 0x3e, 0x4a, 0xae, - 0xf2, 0x94, 0x74, 0x78, 0x0c, 0x83, 0x1e, 0xa2, - 0x16, 0x5f, 0x66, 0xf3, 0x09, 0xe2, 0xb7, 0x1c, - 0x31, 0x7d, 0x17, 0xfd, 0x99, 0x8f, 0x96, 0xe1, - 0x75, 0x36, 0xea, 0xa3, 0xa4, 0xd1, 0xd4, 0x41, - 0x63, 0x32, 0x18, 0x77, 0xcf, 0xb3, 0xc5, 0x28, - 0x47, 0xad, 0x8b, 0x18, 0x84, 0x87, 0xa7, 0x37, - 0x46, 0xe1, 0xb7, 0xfc, 0xb6, 0x0b, 0x1d, 0xc2, - 0x50, 0x91, 0xf9, 0x43, 0x38, 0x96, 0xe3, 0xa7, - 0xd3, 0x97, 0x89, 0xb3, 0x42, 0x0d, 0x9f, 0xe7, - 0xf1, 0x80, 0x30, 0x3c, 0x2d, 0xe9, 0x09, 0xd8, - 0x03, 0xda, 0xd5, 0x5f, 0xff, 0x38, 0xfd, 0xf6, - 0xe9, 0xdb, 0xc9, 0xff, 0x74, 0xcf, 0xbe, 0x5c, - 0x9c, 0x9f, 0x7e, 0xfc, 0xed, 0xeb, 0xb7, 0x03, - 0xa5, 0x24, 0xa6, 0xa9, 0x8d, 0x24, 0x56, 0xc8, - 0xda, 0x2c, 0x51, 0xa5, 0x36, 0x50, 0xa2, 0x15, - 0x49, 0xda, 0xae, 0x3c, 0xb6, 0xdd, 0xb8, 0x34, - 0x37, 0x29, 0xe4, 0xea, 0xac, 0x59, 0x06, 0x80, - 0x39, 0xb0, 0xd0, 0x29, 0x8b, 0x5e, 0x3c, 0x96, - 0xeb, 0x55, 0xd3, 0x93, 0x42, 0xba, 0x89, 0x57, - 0x43, 0xe3, 0xf0, 0x5e, 0xc7, 0xf3, 0xd5, 0x68, - 0x3a, 0x20, 0x49, 0xd7, 0x90, 0x84, 0xaa, 0x31, - 0x24, 0x26, 0x5b, 0x0c, 0x39, 0x45, 0x17, 0xe9, - 0x72, 0xc4, 0xd0, 0x25, 0xbe, 0xa1, 0x17, 0x7c, - 0xde, 0x6e, 0x4f, 0x1f, 0x00, 0xdf, 0xdc, 0x44, - 0x1f, 0x57, 0xce, 0x2a, 0x4e, 0xee, 0x5d, 0x71, - 0xa2, 0x57, 0x9c, 0xac, 0xa9, 0x58, 0x65, 0x72, - 0x99, 0x35, 0xf2, 0xb1, 0x9d, 0x6d, 0x92, 0xb9, - 0x3d, 0x0f, 0x95, 0x4b, 0x4a, 0xca, 0x15, 0xf2, - 0xf2, 0x74, 0x89, 0xe5, 0x8f, 0xce, 0x11, 0x13, - 0x89, 0xa7, 0xf5, 0xa9, 0xc6, 0xd2, 0x17, 0xf1, - 0x64, 0x36, 0x4e, 0xe7, 0x9d, 0x4f, 0x28, 0x6f, - 0x34, 0x89, 0x07, 0xe9, 0xb6, 0xdc, 0x81, 0x73, - 0x30, 0x06, 0xdc, 0xab, 0x58, 0x50, 0xd3, 0xd2, - 0x3e, 0x9e, 0x7e, 0x4c, 0xa0, 0x47, 0xb0, 0x02, - 0xa9, 0x9d, 0x14, 0xf0, 0x36, 0xf8, 0x6a, 0x0f, - 0x49, 0x19, 0x02, 0x35, 0x5d, 0x0c, 0xb1, 0x40, - 0x68, 0x47, 0x28, 0x1f, 0xc9, 0xea, 0xb4, 0xf3, - 0xc9, 0xa1, 0x0d, 0xf0, 0x09, 0x3b, 0xa8, 0xe4, - 0x20, 0xc6, 0x10, 0x04, 0x25, 0x2a, 0x41, 0x9d, - 0x22, 0x45, 0x89, 0x8d, 0xa2, 0xc4, 0x48, 0x51, - 0x37, 0x91, 0x69, 0xea, 0x98, 0x69, 0xea, 0xb8, - 0xa1, 0x22, 0x98, 0xa0, 0x52, 0xd2, 0x06, 0x9f, - 0x14, 0xf3, 0xf1, 0x88, 0xb9, 0xbb, 0x91, 0x71, - 0x49, 0x96, 0x8d, 0xb9, 0x30, 0xb9, 0x19, 0xe5, - 0x43, 0x04, 0x30, 0xd3, 0x73, 0x67, 0xa3, 0xbc, - 0x37, 0x2c, 0xe6, 0x52, 0xb6, 0x43, 0x8d, 0x9c, - 0x5f, 0x21, 0x2d, 0x04, 0xe3, 0xe0, 0x99, 0x92, - 0x3a, 0x0f, 0xf2, 0x3e, 0x9e, 0xa4, 0xf3, 0x18, - 0x26, 0x4d, 0x2f, 0x9d, 0xa2, 0x4e, 0xec, 0xf6, - 0x47, 0x8b, 0x3c, 0x9e, 0xf6, 0x52, 0xb3, 0x64, - 0x82, 0x06, 0x4f, 0xa1, 0xc5, 0xff, 0x7d, 0x72, - 0xd1, 0xfd, 0xfd, 0xcb, 0xd9, 0xe7, 0xaf, 0xdf, - 0x7e, 0xed, 0x52, 0xd9, 0x7f, 0xc0, 0x6a, 0x80, - 0xc5, 0x91, 0x56, 0x10, 0x93, 0xac, 0x6e, 0x2e, - 0xa1, 0x23, 0x04, 0xe0, 0xe1, 0xa0, 0xd9, 0x9c, - 0x7b, 0xa5, 0x2c, 0x92, 0x41, 0x57, 0x62, 0x95, - 0x76, 0x65, 0xa9, 0x92, 0x16, 0x56, 0x03, 0x61, - 0xf3, 0x18, 0xad, 0xbe, 0x0b, 0x33, 0x65, 0x24, - 0x4f, 0x21, 0x8d, 0xa9, 0x01, 0xb4, 0xc5, 0x04, - 0x82, 0x53, 0xa7, 0x28, 0x09, 0x35, 0x9a, 0xa9, - 0x51, 0xa8, 0xc2, 0x30, 0x02, 0xd6, 0x50, 0x99, - 0x8c, 0xaf, 0x2c, 0xbd, 0x07, 0x39, 0x0a, 0x85, - 0x38, 0x97, 0x92, 0x07, 0x99, 0x9c, 0x38, 0xa9, - 0x18, 0x4e, 0xd7, 0xe8, 0x92, 0xb2, 0x49, 0x7d, - 0x6b, 0x48, 0xa2, 0x1c, 0x6e, 0xa6, 0x8a, 0x66, - 0x5a, 0x09, 0xe3, 0xea, 0x42, 0x91, 0x36, 0x31, - 0x73, 0xec, 0xe4, 0x49, 0x30, 0x25, 0x14, 0x2e, - 0xf2, 0x79, 0xf6, 0xef, 0xb4, 0x8c, 0xf5, 0x64, - 0x08, 0x3b, 0x07, 0xca, 0x50, 0x26, 0x46, 0x54, - 0xf2, 0xcb, 0xf8, 0x51, 0x07, 0x5c, 0x4f, 0xfb, - 0xcd, 0xa8, 0x9f, 0x0f, 0x4b, 0x69, 0xc7, 0x10, - 0x65, 0x2c, 0x2a, 0xc3, 0x59, 0x18, 0x55, 0x01, - 0x59, 0xc3, 0xae, 0x3a, 0xec, 0xfa, 0x36, 0x94, - 0x32, 0x8a, 0x0a, 0x63, 0xe5, 0x17, 0x15, 0xcc, - 0xc4, 0x36, 0x1a, 0x44, 0x19, 0xf7, 0x14, 0x41, - 0x89, 0xbb, 0x40, 0x2c, 0x90, 0x87, 0x68, 0x81, - 0xec, 0xc7, 0x79, 0x2c, 0xad, 0x8f, 0xf0, 0x0b, - 0xad, 0x91, 0xa5, 0xe2, 0xad, 0x47, 0x14, 0x5d, - 0xdd, 0xc4, 0xa4, 0x32, 0xcc, 0xe7, 0xa2, 0xce, - 0x65, 0xe4, 0xe9, 0xd2, 0x2c, 0xda, 0x48, 0x66, - 0x91, 0x3f, 0x91, 0x6e, 0x3b, 0x33, 0xa9, 0xe4, - 0x0b, 0x01, 0xc6, 0x2b, 0x34, 0x09, 0xa8, 0x68, - 0x13, 0x19, 0x04, 0xff, 0x18, 0x6a, 0x84, 0x64, - 0x9f, 0x09, 0x23, 0x5e, 0x9b, 0x26, 0x71, 0xa2, - 0x8d, 0xe4, 0x0a, 0xfd, 0x6b, 0xa8, 0x8c, 0xe6, - 0xf8, 0x92, 0x98, 0x31, 0x55, 0xc9, 0x11, 0x6c, - 0x23, 0x2e, 0xe4, 0x0f, 0xd3, 0x88, 0xca, 0xf9, - 0xbe, 0x2e, 0x48, 0x4c, 0xe3, 0xab, 0x22, 0xdc, - 0x5a, 0x14, 0xc8, 0x1f, 0x86, 0xae, 0x91, 0xb3, - 0x7d, 0x5d, 0x46, 0x58, 0xb8, 0x40, 0x45, 0x79, - 0x8f, 0x09, 0xae, 0x7e, 0xda, 0xa9, 0x13, 0xe3, - 0xa7, 0xcf, 0x7e, 0xd3, 0x30, 0xea, 0x58, 0xad, - 0xd3, 0x17, 0xfb, 0xac, 0x88, 0x42, 0x13, 0xe1, - 0x0a, 0x41, 0x5d, 0x24, 0x76, 0x0d, 0xb8, 0xbb, - 0x3c, 0xf4, 0x4f, 0x43, 0x68, 0x8d, 0xbd, 0xd1, - 0xbc, 0x87, 0xf4, 0x26, 0xa2, 0xd3, 0x44, 0xa8, - 0x2a, 0x3c, 0xac, 0x08, 0xd8, 0x6b, 0x35, 0x8f, - 0xdd, 0x10, 0x19, 0xe1, 0x8e, 0xae, 0x3d, 0x31, - 0x15, 0xb9, 0x97, 0xcd, 0xa7, 0x48, 0x0f, 0x9a, - 0x31, 0x4b, 0x4a, 0x41, 0x45, 0x4b, 0xaa, 0x5a, - 0x19, 0x2a, 0xa9, 0x15, 0xaa, 0x47, 0x94, 0x54, - 0xcf, 0x21, 0x93, 0xaf, 0x2e, 0xf7, 0x3b, 0x68, - 0x90, 0xaa, 0x6e, 0x76, 0x57, 0x83, 0x7e, 0xa1, - 0x6e, 0xa8, 0xd9, 0x3c, 0xfb, 0x57, 0xda, 0xcb, - 0xd3, 0x3e, 0x23, 0x5f, 0xb5, 0xe5, 0x14, 0x7a, - 0x88, 0x4d, 0x77, 0xbf, 0xda, 0x3d, 0x47, 0xaf, - 0xb1, 0x79, 0x13, 0x94, 0x68, 0x86, 0xc8, 0xa2, - 0xb2, 0x5b, 0x9a, 0x1a, 0x29, 0xd4, 0xcd, 0x40, - 0x9b, 0x57, 0x52, 0xac, 0xd8, 0x28, 0x4b, 0x4f, - 0x4b, 0x38, 0x9a, 0xcb, 0xd5, 0xa6, 0x4d, 0x2d, - 0x53, 0x78, 0x0d, 0x54, 0x6e, 0x51, 0x83, 0x5c, - 0xfa, 0x26, 0xbc, 0xbb, 0x93, 0xd7, 0xc3, 0x69, - 0x3e, 0x8a, 0xc7, 0xa3, 0x78, 0x81, 0xc5, 0x25, - 0x62, 0xd6, 0xe0, 0xd3, 0xe9, 0x1f, 0x67, 0x1f, - 0x4f, 0xbb, 0xe7, 0x67, 0x7f, 0x9e, 0xfe, 0xd2, - 0xfd, 0x76, 0xf2, 0xdb, 0xd9, 0xd7, 0xc0, 0x58, - 0x4b, 0x48, 0x16, 0x2c, 0x60, 0xfc, 0x43, 0x87, - 0xd6, 0xd7, 0x5c, 0xfa, 0xec, 0x17, 0x9a, 0x6c, - 0x32, 0x6a, 0x97, 0x3a, 0xba, 0xac, 0x2b, 0xd9, - 0x63, 0xab, 0xdb, 0xbb, 0x51, 0x98, 0x1f, 0x59, - 0xf3, 0xdd, 0x9d, 0xf2, 0xfa, 0x14, 0x4a, 0xe7, - 0x53, 0xaa, 0x8a, 0x4f, 0xa0, 0xdf, 0x51, 0xdd, - 0xce, 0x36, 0x21, 0xaa, 0x68, 0x6a, 0x56, 0x6e, - 0xaf, 0xac, 0x75, 0x59, 0xf8, 0x78, 0xbd, 0x1e, - 0x65, 0x67, 0xd2, 0xaa, 0x0a, 0xd1, 0x1a, 0x0e, - 0xdc, 0x5c, 0x93, 0x59, 0xc3, 0x5e, 0x5b, 0xe9, - 0x20, 0x6b, 0x19, 0xe7, 0xde, 0x7a, 0x03, 0x66, - 0x0b, 0x24, 0xd4, 0x43, 0x82, 0x84, 0x49, 0xee, - 0x71, 0x3a, 0x1d, 0x20, 0xca, 0xc8, 0x1f, 0x26, - 0x5f, 0xdd, 0xd0, 0x2a, 0xba, 0x29, 0x9e, 0xdb, - 0x50, 0xcb, 0x44, 0x0b, 0x28, 0xce, 0x6f, 0x4c, - 0xe2, 0xa5, 0x43, 0x94, 0x66, 0x55, 0x2e, 0x2b, - 0x23, 0xd5, 0xcd, 0xa3, 0xc5, 0x24, 0xcb, 0xf2, - 0xe1, 0x22, 0x4f, 0x67, 0x4e, 0xab, 0xd9, 0xf2, - 0x75, 0x44, 0xbe, 0x4a, 0x20, 0xd1, 0x6f, 0x08, - 0x0e, 0xaa, 0x8b, 0x46, 0x72, 0x5f, 0xd6, 0xfe, - 0x51, 0x43, 0x58, 0xda, 0xb5, 0x9f, 0xe0, 0x4f, - 0xed, 0x43, 0x4d, 0xc2, 0x5e, 0xc0, 0x0c, 0xd5, - 0x69, 0xd8, 0x09, 0xc3, 0x9a, 0x17, 0x20, 0xcd, - 0x35, 0xc6, 0x5b, 0xe0, 0x71, 0x27, 0x99, 0xc7, - 0xf4, 0x3e, 0x99, 0x63, 0x3c, 0x4d, 0x27, 0x94, - 0x34, 0xe8, 0x7b, 0x38, 0xce, 0x1e, 0x7b, 0x4b, - 0xc4, 0xbe, 0xcb, 0x21, 0xc8, 0xb1, 0xae, 0xb0, - 0x37, 0x29, 0x9a, 0x4b, 0xb9, 0xd9, 0x1c, 0x26, - 0x79, 0x66, 0x57, 0x44, 0x87, 0xe7, 0x6b, 0x4e, - 0x08, 0x52, 0x98, 0x66, 0x19, 0x97, 0x02, 0x26, - 0x19, 0x05, 0xcc, 0x63, 0x7b, 0xc4, 0x36, 0x5b, - 0xc3, 0xcb, 0x1d, 0x9d, 0xac, 0x90, 0xd9, 0x5b, - 0x69, 0x73, 0x8b, 0xb3, 0xf4, 0x11, 0xd2, 0xe1, - 0xa6, 0x0b, 0xc8, 0xa9, 0xb2, 0x93, 0x42, 0xeb, - 0x08, 0xc9, 0x0e, 0xa6, 0xdc, 0x7b, 0xff, 0x3c, - 0xfd, 0xf6, 0x15, 0xab, 0x64, 0x78, 0xeb, 0x3a, - 0x68, 0xbf, 0x69, 0xb6, 0x42, 0xbe, 0x31, 0xf7, - 0xf3, 0xc9, 0xef, 0x17, 0x17, 0xdd, 0x8f, 0x5f, - 0x4f, 0x3f, 0xa3, 0x99, 0x75, 0xf8, 0xfe, 0xdd, - 0xfb, 0xa3, 0x4e, 0xe7, 0x5d, 0xeb, 0xa8, 0xd5, - 0x3e, 0x3a, 0xec, 0xbc, 0x3d, 0xa8, 0xea, 0x45, - 0xa0, 0x9c, 0x41, 0xfe, 0x18, 0xec, 0x27, 0x92, - 0xe1, 0x0b, 0x36, 0xd1, 0x0c, 0x4d, 0x99, 0x11, - 0xa2, 0xcd, 0x46, 0xdb, 0xbc, 0x44, 0x3d, 0xb8, - 0x67, 0x81, 0x9e, 0x80, 0xc0, 0x23, 0xd8, 0xef, - 0x56, 0xb2, 0xd6, 0x08, 0xc2, 0x8b, 0x68, 0xf1, - 0xbf, 0xf3, 0xdc, 0x69, 0xa0, 0x64, 0x6f, 0x9c, - 0x0d, 0x1c, 0x18, 0x8d, 0x80, 0x34, 0x30, 0x90, - 0xc6, 0x38, 0x10, 0x03, 0xe1, 0xba, 0xc1, 0x21, - 0x1a, 0x22, 0x3e, 0xa4, 0xd1, 0x85, 0xa7, 0x57, - 0x1c, 0x6a, 0xb2, 0x9f, 0xe9, 0xf1, 0x84, 0xe8, - 0x82, 0x0d, 0x46, 0x6c, 0xaf, 0x6c, 0x41, 0x26, - 0xb9, 0x6e, 0x32, 0xd6, 0x29, 0x30, 0x11, 0x12, - 0x46, 0x49, 0x02, 0xfc, 0xb6, 0x4e, 0x2c, 0x3c, - 0xd0, 0xd4, 0x36, 0x03, 0x89, 0xb9, 0x60, 0x61, - 0xfb, 0x8d, 0x19, 0xda, 0xaa, 0x36, 0xd1, 0xe6, - 0x54, 0x61, 0x4c, 0x92, 0xdb, 0x8f, 0x1a, 0xa8, - 0x1b, 0x3d, 0x34, 0x66, 0xf8, 0xff, 0x7e, 0x96, - 0x3b, 0x9c, 0x2e, 0x9f, 0xff, 0x62, 0xfc, 0x70, - 0x1d, 0x8f, 0x23, 0x82, 0xc6, 0x93, 0x9a, 0xe5, - 0x09, 0xb2, 0xbd, 0x74, 0x39, 0x73, 0xfa, 0xda, - 0xaa, 0x84, 0x07, 0x0e, 0x15, 0x85, 0xdd, 0x23, - 0xf6, 0xbf, 0xbb, 0x83, 0x7d, 0xe8, 0x9b, 0x6c, - 0x3e, 0xee, 0x57, 0xdd, 0xc9, 0xdd, 0x68, 0x49, - 0xf2, 0x28, 0x72, 0x69, 0xeb, 0xb6, 0xb9, 0x8c, - 0x62, 0xf2, 0x97, 0x7e, 0xaf, 0x40, 0x6c, 0x35, - 0x48, 0xda, 0x4a, 0xde, 0xec, 0x2c, 0xee, 0x1c, - 0x9a, 0x72, 0xc8, 0x92, 0x3c, 0x47, 0x29, 0xf6, - 0x5d, 0xff, 0x35, 0x8d, 0xa0, 0x47, 0x45, 0x0c, - 0xbb, 0x6a, 0x18, 0xd8, 0x6d, 0xce, 0xa5, 0xcd, - 0x37, 0x05, 0x4a, 0x54, 0xee, 0x63, 0x29, 0x91, - 0xfb, 0x30, 0xd7, 0xb4, 0x61, 0xbd, 0xd7, 0xc1, - 0x82, 0x56, 0x15, 0xdd, 0xa1, 0x90, 0x18, 0x4f, - 0x7b, 0xc3, 0x6c, 0x6e, 0xce, 0x63, 0x93, 0xa9, - 0x88, 0x69, 0x1c, 0xf7, 0x52, 0x03, 0x1f, 0x2c, - 0x86, 0xa3, 0xcb, 0x3c, 0xac, 0xc4, 0x49, 0xe5, - 0x6b, 0xa0, 0xdd, 0x75, 0xc1, 0x46, 0x88, 0xce, - 0x1e, 0x46, 0x8a, 0x9e, 0x3c, 0xcd, 0xf2, 0xdf, - 0x17, 0x90, 0xae, 0xed, 0x0b, 0x4b, 0x3e, 0xa7, - 0xf3, 0x0c, 0x4d, 0xb7, 0x02, 0x2b, 0x8a, 0xfe, - 0x20, 0x9c, 0x28, 0xcf, 0x7b, 0x41, 0x15, 0x85, - 0x62, 0x54, 0x45, 0x2a, 0xd2, 0xe6, 0x8d, 0x5a, - 0x2c, 0x1b, 0x8f, 0xf1, 0xd9, 0x9b, 0xee, 0x2c, - 0x9d, 0x2f, 0x66, 0x08, 0x6e, 0x74, 0x9d, 0x22, - 0x56, 0x40, 0x53, 0x21, 0xea, 0x8d, 0x11, 0x47, - 0xa0, 0xa1, 0x3b, 0xae, 0x83, 0xcc, 0x70, 0x4a, - 0x5a, 0x1e, 0x58, 0x6b, 0x77, 0xb1, 0x8a, 0x7b, - 0x04, 0xc3, 0xbf, 0x56, 0xef, 0x63, 0xa2, 0x42, - 0xf7, 0xfc, 0x38, 0x7c, 0xb4, 0xeb, 0x74, 0x18, - 0xd7, 0xf8, 0x7b, 0xbc, 0x92, 0x56, 0x85, 0x6c, - 0x58, 0x22, 0xc6, 0x2a, 0x78, 0x0a, 0xd3, 0x31, - 0x11, 0x89, 0x78, 0x0e, 0xdf, 0x67, 0x40, 0xa9, - 0x36, 0x37, 0x9e, 0x0d, 0xe3, 0x08, 0xf5, 0x5f, - 0x68, 0x94, 0x72, 0xb8, 0xd1, 0xac, 0xe1, 0x1e, - 0x06, 0xc6, 0x1e, 0x37, 0x56, 0x55, 0xed, 0xbf, - 0x6a, 0x30, 0x15, 0x4d, 0xfa, 0xaf, 0x54, 0x12, - 0x4f, 0x57, 0x5a, 0xfa, 0x8e, 0x14, 0xa7, 0x24, - 0x19, 0xcb, 0x7b, 0x51, 0xb3, 0x1d, 0xde, 0xed, - 0x64, 0x16, 0x3e, 0xab, 0xe9, 0xa6, 0xa5, 0x6b, - 0xdb, 0xca, 0xda, 0x22, 0x6d, 0x4e, 0x66, 0x4a, - 0xca, 0x7e, 0xe6, 0x1a, 0x67, 0xae, 0x4c, 0xdf, - 0x2c, 0xee, 0xf7, 0x51, 0x07, 0x76, 0x2f, 0xe3, - 0x5e, 0x9e, 0x81, 0x9f, 0xb5, 0x53, 0x98, 0xd8, - 0x9c, 0x7f, 0x0a, 0xd3, 0x59, 0x2d, 0xfc, 0x18, - 0xb3, 0x9b, 0x8d, 0x7f, 0x14, 0x27, 0x0b, 0x21, - 0x60, 0x9a, 0x2b, 0x57, 0x52, 0x66, 0x05, 0x7d, - 0x2a, 0x3d, 0xa1, 0xc6, 0x0f, 0xd1, 0x06, 0xfe, - 0xed, 0x52, 0xea, 0x25, 0xb5, 0x81, 0xaf, 0xfe, - 0xd7, 0x08, 0x0a, 0x7b, 0xdf, 0x59, 0xdd, 0xcf, - 0x83, 0xeb, 0x75, 0xf1, 0x26, 0xa9, 0x16, 0x1b, - 0x0b, 0xb7, 0xde, 0xb6, 0x52, 0xad, 0x47, 0xc5, - 0x59, 0x87, 0x1d, 0x71, 0x56, 0x08, 0xd6, 0x1c, - 0x4a, 0x5a, 0x73, 0xdc, 0x52, 0xef, 0x93, 0xd0, - 0x85, 0x3d, 0x13, 0xce, 0xd0, 0xe0, 0x51, 0x6b, - 0x23, 0x8b, 0xd5, 0x08, 0x1c, 0x18, 0x46, 0x51, - 0xb1, 0xe0, 0xd8, 0xa8, 0x94, 0x55, 0xc5, 0xf8, - 0x07, 0x58, 0x2a, 0xed, 0x0f, 0x52, 0xcc, 0xb7, - 0x46, 0xd7, 0x51, 0xa9, 0x7f, 0xab, 0xa1, 0x6c, - 0x5e, 0x42, 0x4f, 0x37, 0x74, 0xcc, 0x56, 0x27, - 0x13, 0xf1, 0x3e, 0xde, 0xed, 0xee, 0x30, 0xac, - 0x61, 0xe3, 0x63, 0xed, 0xd1, 0xd7, 0x0d, 0xe9, - 0x7b, 0x69, 0x27, 0xa9, 0x9e, 0xd3, 0x81, 0xa0, - 0x82, 0x81, 0xfa, 0xe4, 0x67, 0x36, 0x76, 0x70, - 0xac, 0xa1, 0x2a, 0x0f, 0x3f, 0xc9, 0xc6, 0xdf, - 0x03, 0x6f, 0x9a, 0x3d, 0xf2, 0xc6, 0xcd, 0x46, - 0xbb, 0x27, 0x06, 0x5b, 0xf4, 0x41, 0x8e, 0x7f, - 0x6e, 0x20, 0x2b, 0x8c, 0xfe, 0x06, 0x83, 0x55, - 0x6e, 0x1b, 0x9c, 0xab, 0x7c, 0x3c, 0x9a, 0x96, - 0x1e, 0x95, 0x53, 0x40, 0xec, 0x32, 0x46, 0x01, - 0x33, 0xc9, 0x1a, 0x15, 0xa0, 0x8c, 0xab, 0x0a, - 0x90, 0xaf, 0x48, 0xf6, 0xa8, 0x1d, 0xae, 0x7c, - 0x99, 0x64, 0x91, 0x02, 0xe0, 0x17, 0x06, 0xc3, - 0x24, 0x9b, 0x34, 0x9c, 0x5b, 0xf5, 0xe6, 0x53, - 0xcb, 0x2a, 0xcc, 0xb3, 0x91, 0xa3, 0xea, 0xe6, - 0x81, 0xa2, 0x71, 0xd7, 0x61, 0xd2, 0x04, 0xe0, - 0x15, 0x66, 0x5c, 0x6f, 0x15, 0x70, 0x6a, 0x9f, - 0xef, 0x9c, 0x35, 0x1f, 0x8a, 0xbb, 0xd6, 0xb8, - 0xda, 0x2c, 0xf2, 0x4c, 0x69, 0xfb, 0x36, 0x6c, - 0x72, 0x4f, 0x19, 0x29, 0x34, 0x45, 0xa1, 0xc6, - 0x22, 0xda, 0x1b, 0x5c, 0x0a, 0x66, 0x73, 0x64, - 0x0f, 0xad, 0x98, 0x82, 0x48, 0x94, 0x77, 0x70, - 0x5b, 0x6a, 0x1b, 0xa0, 0xa0, 0x7c, 0x03, 0x16, - 0x5d, 0x13, 0x94, 0xc9, 0xf6, 0x1c, 0x5c, 0x9c, - 0x09, 0xe1, 0xdd, 0x39, 0x78, 0x1f, 0xee, 0x06, - 0x11, 0x3b, 0xbb, 0x81, 0x8d, 0x9b, 0xfb, 0xde, - 0x00, 0xaa, 0xbe, 0x0c, 0x3c, 0xfb, 0x23, 0xdd, - 0xec, 0x1e, 0xc7, 0xe5, 0x3c, 0x9b, 0x98, 0xc9, - 0x94, 0x21, 0x8c, 0xb4, 0x1e, 0x69, 0x40, 0x2a, - 0xc1, 0xf4, 0x22, 0xa8, 0x94, 0x6d, 0x22, 0x9a, - 0x0e, 0x8f, 0x0e, 0x57, 0x81, 0xf0, 0x3c, 0x2b, - 0x27, 0x1b, 0x19, 0x3a, 0xeb, 0x88, 0xce, 0xb3, - 0x12, 0x92, 0x51, 0x66, 0x05, 0x82, 0x09, 0x54, - 0xf5, 0xd5, 0xea, 0xa9, 0x8e, 0xe4, 0x2a, 0xc3, - 0x2d, 0x7f, 0x44, 0x71, 0xd7, 0x34, 0x48, 0xd2, - 0x5e, 0xb4, 0x3a, 0x8a, 0xd1, 0xb6, 0x83, 0x25, - 0x7e, 0x46, 0x71, 0xb7, 0xd8, 0xc9, 0xc6, 0x0a, - 0x11, 0xac, 0xb9, 0xab, 0xe5, 0x8b, 0xb4, 0x70, - 0x69, 0x2a, 0x92, 0x69, 0x82, 0x43, 0x27, 0x0a, - 0x04, 0xdc, 0x9e, 0x52, 0x21, 0x6e, 0x6f, 0x42, - 0x1d, 0x47, 0x12, 0x89, 0x8a, 0x4c, 0x18, 0x94, - 0x7c, 0x54, 0x9e, 0x3a, 0xc0, 0x40, 0xf0, 0x7c, - 0xc3, 0xfe, 0x38, 0x2a, 0x64, 0x9a, 0xcb, 0x50, - 0xdc, 0xe7, 0x55, 0x73, 0xd8, 0x59, 0x18, 0x20, - 0xe1, 0x82, 0xfa, 0x94, 0x48, 0x0e, 0x3b, 0xde, - 0x92, 0x67, 0x6a, 0xfa, 0x4d, 0x58, 0x6d, 0x79, - 0x07, 0x5a, 0x91, 0x30, 0x9f, 0x8d, 0xe3, 0x15, - 0xbd, 0x21, 0x48, 0xb6, 0x82, 0x1d, 0xb9, 0x0b, - 0x9a, 0xcb, 0x86, 0xdc, 0x67, 0xcd, 0xa5, 0x1b, - 0x08, 0xf2, 0x7d, 0x15, 0x74, 0xa5, 0x82, 0xae, - 0x64, 0x50, 0x53, 0x7d, 0x49, 0xb1, 0xbe, 0x44, - 0xad, 0x2f, 0x29, 0xa9, 0x2f, 0x51, 0xeb, 0x4b, - 0x0a, 0xf5, 0xdd, 0xf3, 0x22, 0x25, 0xef, 0x70, - 0x4f, 0xed, 0x24, 0x9f, 0x8f, 0xd1, 0x43, 0xdd, - 0x9c, 0xa4, 0x03, 0xa8, 0xd6, 0x93, 0x58, 0xea, - 0xd9, 0x42, 0x21, 0x5b, 0x73, 0xdb, 0xd1, 0xbe, - 0x0f, 0xc9, 0x56, 0x87, 0xcb, 0xb8, 0x9f, 0x3e, - 0xea, 0x92, 0xb7, 0xbb, 0x55, 0x6b, 0xd7, 0xcb, - 0xcd, 0x63, 0xae, 0x15, 0x8f, 0x71, 0xec, 0x50, - 0xe9, 0xac, 0x6d, 0x04, 0x7a, 0x69, 0x6f, 0xbc, - 0x38, 0x81, 0xbd, 0xd9, 0xa5, 0x5c, 0xcb, 0x95, - 0xdc, 0x27, 0xba, 0x90, 0x6b, 0xb9, 0x8e, 0xfb, - 0x60, 0x97, 0x71, 0x1f, 0xd9, 0xa8, 0x30, 0x5d, - 0xef, 0x05, 0x41, 0x44, 0x3d, 0xff, 0xde, 0x0e, - 0xe3, 0x18, 0x3c, 0x0f, 0x4b, 0x62, 0x6f, 0x36, - 0xec, 0xcd, 0x86, 0xbd, 0xd9, 0xb0, 0x37, 0x1b, - 0x2c, 0x66, 0xc3, 0x3f, 0xb3, 0x6c, 0x72, 0x7f, - 0xd3, 0xe1, 0xb5, 0x5b, 0x05, 0x3b, 0x89, 0xc1, - 0x52, 0x6a, 0x3a, 0xf0, 0x71, 0xda, 0x81, 0xf9, - 0x50, 0xa8, 0x6b, 0xbd, 0x35, 0xa0, 0xe8, 0xfc, - 0x0f, 0x11, 0xe4, 0x64, 0xaf, 0xfa, 0xef, 0x55, - 0xff, 0xbd, 0xea, 0xff, 0xba, 0x54, 0xff, 0x8a, - 0x8a, 0xfa, 0x6e, 0x54, 0xf4, 0x43, 0x94, 0x3a, - 0x86, 0xb3, 0xe8, 0x6a, 0x6c, 0x34, 0x36, 0xa5, - 0x78, 0xb6, 0xbc, 0x7f, 0xab, 0xc8, 0x12, 0x9c, - 0x2b, 0x0e, 0xe7, 0xeb, 0x92, 0xf0, 0x3a, 0x9d, - 0xe7, 0x23, 0x24, 0x61, 0xbb, 0x03, 0x38, 0x46, - 0x93, 0x4e, 0xf3, 0x70, 0xfd, 0xf1, 0x48, 0x50, - 0xfd, 0xa6, 0x08, 0x09, 0x2a, 0x95, 0x2a, 0x5b, - 0xc1, 0x47, 0x48, 0x2e, 0xb2, 0xdd, 0x1d, 0xf3, - 0xd5, 0xd9, 0xd8, 0x2c, 0xf2, 0x62, 0x9c, 0x63, - 0xbf, 0x9b, 0x04, 0xb9, 0xe5, 0x77, 0x14, 0x18, - 0x44, 0x89, 0xf4, 0x1a, 0x96, 0x5c, 0x8e, 0x1a, - 0xae, 0xb9, 0x1c, 0x35, 0xac, 0x70, 0x4d, 0x62, - 0x58, 0xe5, 0x4e, 0xcc, 0x7d, 0x8f, 0xd8, 0x54, - 0x3f, 0x2b, 0x51, 0x45, 0x8d, 0xc6, 0xe3, 0x21, - 0xb7, 0x02, 0x12, 0x4c, 0x31, 0x38, 0x50, 0xb2, - 0xcf, 0x06, 0xc9, 0x78, 0x33, 0x88, 0x14, 0xdc, - 0x60, 0x18, 0xe4, 0xc2, 0x43, 0xdb, 0xad, 0xa4, - 0x21, 0xbb, 0x95, 0x34, 0x2c, 0xbb, 0x95, 0xc4, - 0x8a, 0x6f, 0x32, 0x02, 0xc5, 0xb3, 0x1b, 0x0f, - 0x78, 0x4c, 0x07, 0x4f, 0x4c, 0x32, 0x43, 0x22, - 0x69, 0xaa, 0x20, 0xc1, 0x7c, 0x1b, 0xe2, 0x8e, - 0x82, 0x2b, 0x9a, 0xe0, 0x1d, 0x80, 0x0f, 0x37, - 0xa4, 0xf4, 0xb3, 0x44, 0xf2, 0xc9, 0x3c, 0x0b, - 0x24, 0xa8, 0x25, 0xc1, 0xd1, 0x5c, 0xe2, 0x0b, - 0x4c, 0x6b, 0xf5, 0xbc, 0x1c, 0x1f, 0x15, 0x6c, - 0xd5, 0x7e, 0xa2, 0x5d, 0x53, 0xfb, 0x80, 0xc7, - 0x07, 0xb4, 0x3f, 0xe9, 0x02, 0xe7, 0x35, 0x0e, - 0x45, 0x8b, 0x7f, 0x36, 0xe7, 0x5e, 0xab, 0xd9, - 0x69, 0x77, 0xde, 0xd4, 0xc9, 0xe7, 0x00, 0x7d, - 0xbe, 0x6d, 0x1f, 0x77, 0xe8, 0x67, 0x82, 0x3e, - 0x5b, 0x6f, 0x3b, 0x9d, 0x90, 0x4e, 0x6f, 0xf5, - 0xd0, 0x22, 0x3f, 0x07, 0x4b, 0x18, 0x75, 0x92, - 0x80, 0x18, 0xc1, 0x62, 0x87, 0xc3, 0x1d, 0xfa, - 0xe2, 0x1f, 0x0c, 0x8a, 0xd1, 0xd4, 0x23, 0x19, - 0x98, 0xbb, 0x5c, 0xe6, 0x70, 0x38, 0x34, 0x9b, - 0xa2, 0xbe, 0x23, 0x07, 0x7a, 0xe1, 0xba, 0x0e, - 0x69, 0x7f, 0xd0, 0x7e, 0x73, 0xf8, 0xee, 0x08, - 0x02, 0xc0, 0x72, 0xa1, 0xe7, 0x8a, 0xea, 0xe5, - 0x92, 0x20, 0xb6, 0x41, 0xd8, 0x36, 0x74, 0x01, - 0xe8, 0x42, 0x54, 0x53, 0x92, 0x25, 0x3a, 0xa1, - 0x5e, 0x84, 0x02, 0x8c, 0xbe, 0x84, 0x91, 0x84, - 0x84, 0xa0, 0xc3, 0xb0, 0xaa, 0xfd, 0x10, 0xc1, - 0xdd, 0x8e, 0xda, 0x7f, 0x24, 0x08, 0x2f, 0x62, - 0x35, 0x16, 0x64, 0xaa, 0x5b, 0x77, 0x0c, 0xa9, - 0x1e, 0x69, 0x9e, 0x93, 0xd7, 0x31, 0x1b, 0x78, - 0xb3, 0xec, 0xc6, 0x21, 0xe3, 0x15, 0xb4, 0x8f, - 0x5b, 0xf4, 0x24, 0xa8, 0x0f, 0x2d, 0x41, 0x83, - 0x81, 0x3e, 0xde, 0xbf, 0xf3, 0xcd, 0x2d, 0x02, - 0x5a, 0x71, 0xc8, 0xdd, 0x2e, 0x1d, 0xcc, 0x3a, - 0xed, 0x39, 0x36, 0xb6, 0x32, 0x95, 0xf2, 0x72, - 0xd2, 0x9c, 0x53, 0xf4, 0x50, 0xd7, 0xa1, 0x8c, - 0x9d, 0x66, 0xbb, 0x74, 0x60, 0x29, 0xe2, 0x81, - 0x8a, 0x78, 0x60, 0x47, 0x3c, 0x28, 0x47, 0x3c, - 0xd0, 0x10, 0x27, 0x2a, 0xe2, 0xc4, 0x8e, 0x38, - 0x29, 0x47, 0x9c, 0x50, 0xc4, 0xd2, 0x2d, 0x06, - 0x65, 0x5d, 0x2a, 0xb9, 0x5d, 0x2b, 0xad, 0x5c, - 0xcf, 0xd6, 0xe3, 0xa6, 0x2e, 0x35, 0xec, 0x54, - 0xad, 0xd1, 0x1f, 0xb7, 0x7e, 0xa1, 0x7f, 0x44, - 0x2d, 0xe3, 0x1e, 0x3a, 0x44, 0xf5, 0xed, 0x17, - 0x18, 0x55, 0x5a, 0xef, 0xe0, 0x01, 0x14, 0x0e, - 0x25, 0xb8, 0x1d, 0x2c, 0x63, 0xa6, 0x10, 0x1f, - 0x06, 0x3d, 0x44, 0x0d, 0xf1, 0xf1, 0xe0, 0x6a, - 0x88, 0x4c, 0xd6, 0x50, 0xbd, 0xa2, 0x2d, 0x15, - 0x35, 0xeb, 0x27, 0x0a, 0x69, 0x95, 0x16, 0xc7, - 0xbd, 0x37, 0xf3, 0x29, 0xbc, 0x99, 0x98, 0x4b, - 0x37, 0x52, 0xbd, 0x34, 0x9e, 0xdc, 0x4c, 0xf3, - 0xda, 0x5c, 0xdb, 0x2a, 0x70, 0x5a, 0xb4, 0x0d, - 0x3f, 0xed, 0xdd, 0xa5, 0x2f, 0xe7, 0x94, 0x45, - 0x99, 0x0a, 0x4b, 0x6f, 0x90, 0xf4, 0x07, 0x29, - 0xbf, 0xb3, 0x25, 0x83, 0xbc, 0x7e, 0x3f, 0xeb, - 0x43, 0xe8, 0xf0, 0x24, 0xe7, 0x36, 0xb2, 0xe8, - 0xea, 0x6b, 0x75, 0xfc, 0x5b, 0x7e, 0xcc, 0x05, - 0xbc, 0x34, 0x0c, 0x77, 0x04, 0x7b, 0x90, 0xb5, - 0xbf, 0xff, 0xbd, 0xc6, 0x34, 0xd5, 0x08, 0x14, - 0x55, 0x29, 0xe1, 0x16, 0x41, 0x10, 0x25, 0xfa, - 0xe0, 0x27, 0xb2, 0x2e, 0x1f, 0x7c, 0x20, 0x2f, - 0x3c, 0xc8, 0xe3, 0xe9, 0xdf, 0x7a, 0x9a, 0x92, - 0xb1, 0x93, 0x23, 0x27, 0xbb, 0x39, 0x70, 0x42, - 0x6b, 0x61, 0xaa, 0x83, 0xc5, 0x98, 0xa9, 0x68, - 0x8d, 0x1c, 0x3e, 0x84, 0x35, 0x02, 0x57, 0x16, - 0x5f, 0x8b, 0x09, 0xc2, 0xba, 0xb5, 0x39, 0x1f, - 0x70, 0xad, 0xde, 0xa6, 0xcd, 0x63, 0xcc, 0x38, - 0xac, 0x1c, 0x34, 0xc5, 0xa7, 0xbf, 0x0e, 0xdd, - 0x82, 0x5e, 0x4f, 0xf3, 0xda, 0xe4, 0x69, 0x91, - 0xdd, 0xbb, 0xf9, 0xb7, 0xd1, 0x3a, 0x1f, 0x57, - 0x7d, 0xdc, 0x95, 0x0e, 0xf8, 0xba, 0xf7, 0x15, - 0xf0, 0x40, 0xad, 0xd7, 0xa5, 0xac, 0xa3, 0x50, - 0x4d, 0x2f, 0xda, 0xef, 0x46, 0xec, 0x77, 0x23, - 0xb6, 0xde, 0x8d, 0xa0, 0x8f, 0x03, 0x2d, 0xe9, - 0x73, 0x3d, 0xf6, 0x0d, 0x89, 0xc2, 0xbe, 0x05, - 0x2d, 0xe1, 0x69, 0xf2, 0x6a, 0x1f, 0x8e, 0xc6, - 0x78, 0x0c, 0xb4, 0x6a, 0xbc, 0x19, 0xa5, 0x9f, - 0x6c, 0x41, 0x67, 0x1e, 0x2a, 0x60, 0x4c, 0xa5, - 0x2e, 0xef, 0x8f, 0x26, 0xb0, 0x0c, 0x67, 0xd3, - 0xb0, 0x5a, 0x64, 0x0b, 0x4a, 0xf4, 0x43, 0x8c, - 0x89, 0x1c, 0xd6, 0x81, 0x04, 0xbc, 0x9a, 0x2d, - 0x46, 0x63, 0x04, 0x0b, 0xc1, 0xcc, 0x64, 0xca, - 0xe8, 0xc5, 0x71, 0x6c, 0x64, 0x38, 0x52, 0x06, - 0xd2, 0xc9, 0x41, 0x1b, 0x0e, 0x94, 0x24, 0x76, - 0x16, 0x58, 0x21, 0x35, 0x78, 0xd7, 0x7e, 0x8f, - 0xa3, 0x77, 0x61, 0x24, 0x75, 0x5a, 0x51, 0xc9, - 0xab, 0x4a, 0xda, 0xcb, 0x71, 0x4a, 0xe8, 0xaa, - 0x2a, 0xba, 0x80, 0xbd, 0x9b, 0x75, 0xd6, 0xb9, - 0xcd, 0x90, 0x70, 0x2e, 0x3c, 0xaf, 0x12, 0x2f, - 0x71, 0x3a, 0xf9, 0x46, 0xca, 0xec, 0xe9, 0x38, - 0xbd, 0x06, 0xfd, 0x73, 0xea, 0xd0, 0x48, 0xcf, - 0x48, 0x08, 0xf8, 0x74, 0xd9, 0x19, 0xc5, 0x0b, - 0x16, 0x52, 0x03, 0x87, 0xda, 0x2d, 0xf2, 0x15, - 0x91, 0x60, 0x1e, 0x0e, 0x10, 0xc7, 0x1f, 0xa0, - 0xc2, 0x81, 0x20, 0xe7, 0x75, 0xfc, 0x67, 0x40, - 0x1f, 0xaf, 0xc2, 0x1f, 0x09, 0xf9, 0x20, 0xff, - 0xba, 0x01, 0xd2, 0xf6, 0x91, 0x6a, 0x56, 0x78, - 0x8f, 0xa5, 0x7c, 0xb0, 0xb0, 0xa6, 0x2f, 0x11, - 0x0d, 0x7d, 0x52, 0xc7, 0x96, 0x42, 0x83, 0x16, - 0x44, 0xa6, 0x0c, 0xff, 0xb9, 0xc2, 0xaa, 0x2f, - 0x53, 0x9b, 0x13, 0x6b, 0xd9, 0x96, 0xad, 0x48, - 0xcf, 0x5a, 0x64, 0x6d, 0x6d, 0xfd, 0x2a, 0x94, - 0xb6, 0x94, 0x22, 0xa9, 0xa1, 0x88, 0x9c, 0x7f, - 0x59, 0x81, 0x1a, 0x15, 0xe3, 0xa0, 0x0a, 0x11, - 0x66, 0xfa, 0x87, 0x25, 0xbd, 0x65, 0x2e, 0x31, - 0xaa, 0x40, 0x9e, 0xb9, 0x64, 0xba, 0x8c, 0x07, - 0x83, 0x14, 0xc7, 0xdd, 0x80, 0x19, 0x0d, 0x2c, - 0x5a, 0xfb, 0x47, 0xad, 0x83, 0x0d, 0xd0, 0x56, - 0xf3, 0x08, 0x59, 0x9f, 0x3c, 0xf1, 0xa8, 0x79, - 0x8c, 0x13, 0x0f, 0x8f, 0x51, 0x2a, 0xfa, 0x43, - 0xcd, 0xec, 0x74, 0x3e, 0xba, 0xa6, 0xd6, 0x75, - 0xaf, 0x7e, 0x89, 0xfe, 0x1b, 0xb9, 0x0d, 0x27, - 0xae, 0xf7, 0xd1, 0x7f, 0x03, 0xd7, 0x77, 0x06, - 0xf5, 0x21, 0xfa, 0x8f, 0xa4, 0x25, 0xe8, 0xbf, - 0x9e, 0xeb, 0x06, 0x35, 0xb0, 0x2b, 0x50, 0x1d, - 0xbe, 0x43, 0x90, 0x37, 0xf8, 0xf4, 0x80, 0x38, - 0x13, 0x82, 0xa0, 0x7a, 0xfb, 0x7d, 0x13, 0xb1, - 0x6c, 0xa7, 0x41, 0xc0, 0xf4, 0x50, 0x5c, 0xd8, - 0x96, 0xc0, 0xc2, 0x07, 0x13, 0xd1, 0x5c, 0xc2, - 0x5d, 0x00, 0x88, 0xf5, 0xe2, 0x93, 0xef, 0x15, - 0xff, 0x66, 0xf1, 0xd7, 0x84, 0x39, 0xf6, 0x08, - 0x2b, 0xdf, 0x13, 0x49, 0x5b, 0x22, 0x1c, 0x4d, - 0xb2, 0xb1, 0x7c, 0xc1, 0x5b, 0x2f, 0xe1, 0xc6, - 0xa8, 0xc2, 0x78, 0x2a, 0xad, 0x8d, 0x2c, 0x1d, - 0x2b, 0xb4, 0xfa, 0x2e, 0xc3, 0x30, 0xee, 0x67, - 0x37, 0x7a, 0x2a, 0x08, 0x5d, 0x23, 0x78, 0xdc, - 0x83, 0x88, 0x30, 0x22, 0x08, 0xe0, 0xf9, 0x59, - 0xed, 0xb0, 0xd9, 0x3e, 0x6a, 0x1f, 0xbf, 0xef, - 0xbc, 0x39, 0x3e, 0x3c, 0x7e, 0xf7, 0xfe, 0xed, - 0xfb, 0xc3, 0x03, 0x43, 0x80, 0x21, 0x30, 0xef, - 0xad, 0xcb, 0xac, 0xcc, 0x91, 0x0e, 0x79, 0xf0, - 0x0f, 0x99, 0x9d, 0x10, 0xdf, 0xd1, 0x95, 0x03, - 0x3c, 0xe2, 0x15, 0xe3, 0x33, 0x09, 0xc8, 0xd3, - 0xcb, 0x16, 0x38, 0xc6, 0x6c, 0x3c, 0x5d, 0x38, - 0x8e, 0x68, 0xf2, 0x5f, 0xad, 0xef, 0x0d, 0xe9, - 0xab, 0xfd, 0xdd, 0xf5, 0xb0, 0x25, 0x4d, 0xd5, - 0x0a, 0xb7, 0xae, 0x66, 0x72, 0xcc, 0xe3, 0x6c, - 0x96, 0x46, 0x48, 0xe2, 0x4e, 0x11, 0x74, 0xe7, - 0xd8, 0xa3, 0x47, 0xc5, 0x31, 0x45, 0x6e, 0x20, - 0xd5, 0xcb, 0xcf, 0x89, 0xe3, 0xd0, 0x37, 0x11, - 0xe5, 0x5f, 0x62, 0xc3, 0xa3, 0x49, 0x86, 0x31, - 0x50, 0x26, 0xf6, 0x1b, 0x34, 0xd7, 0x45, 0xd3, - 0xee, 0xfc, 0x0c, 0xdf, 0x77, 0x61, 0x79, 0xdc, - 0x57, 0x04, 0x5e, 0x9e, 0x0f, 0x72, 0x1b, 0xb9, - 0x2d, 0x1e, 0xd1, 0xf1, 0xe2, 0xfe, 0xc0, 0xf8, - 0x76, 0x34, 0xb9, 0xc2, 0xa1, 0x8f, 0x49, 0xfa, - 0xaa, 0x7e, 0x7e, 0x16, 0x4a, 0xe6, 0x4e, 0xbb, - 0xf9, 0xee, 0xed, 0x71, 0x43, 0xc4, 0x39, 0x6c, - 0x37, 0xdf, 0x1e, 0xd3, 0x7c, 0x34, 0x49, 0xc9, - 0x7b, 0xa5, 0x10, 0x4f, 0x89, 0x97, 0x22, 0x81, - 0x2e, 0x2f, 0x70, 0xd3, 0x79, 0x31, 0xdc, 0x14, - 0x90, 0x17, 0x68, 0x1c, 0xd0, 0x64, 0xc7, 0x5e, - 0x6b, 0xdc, 0x3b, 0x64, 0x24, 0x02, 0x91, 0xca, - 0x90, 0x92, 0x0c, 0xd7, 0x63, 0xdf, 0x10, 0x33, - 0x18, 0x0a, 0x30, 0xb2, 0x31, 0xc3, 0xe0, 0xf1, - 0x92, 0x2a, 0x64, 0x9b, 0xcc, 0x38, 0x93, 0x6e, - 0x46, 0xe3, 0x81, 0x22, 0x29, 0xa0, 0x78, 0x91, - 0x5f, 0xd4, 0xb3, 0x21, 0x9a, 0xd5, 0x29, 0x3a, - 0x77, 0x80, 0x85, 0x49, 0x44, 0x19, 0xd0, 0xf1, - 0x1d, 0x32, 0x36, 0x75, 0xda, 0x5f, 0x6e, 0x70, - 0x7e, 0x86, 0x65, 0x89, 0xe0, 0x26, 0x12, 0xa2, - 0x1a, 0x0a, 0xd1, 0x9a, 0xc9, 0xcb, 0x60, 0x64, - 0x26, 0xf8, 0x12, 0xf3, 0xfb, 0x18, 0x08, 0xa9, - 0x2a, 0x88, 0x93, 0x65, 0xe2, 0xcb, 0x89, 0x52, - 0xe4, 0x90, 0xdc, 0x42, 0xc2, 0x8a, 0x52, 0xc5, - 0xcd, 0xd8, 0xad, 0x4b, 0x9f, 0xf7, 0x13, 0x6e, - 0x7c, 0x4a, 0x9e, 0x7c, 0xf9, 0xed, 0xec, 0xe4, - 0x97, 0xb3, 0x93, 0x8b, 0xb3, 0x2f, 0x3f, 0xd7, - 0x2c, 0x0f, 0x04, 0x20, 0x82, 0x39, 0x3c, 0x6e, - 0x19, 0x0e, 0xfa, 0x7c, 0xfc, 0xee, 0xed, 0x61, - 0xab, 0xfd, 0xe6, 0xa0, 0xb0, 0xc3, 0x07, 0x56, - 0x13, 0x71, 0x58, 0x15, 0x77, 0xff, 0x70, 0x90, - 0xf4, 0x72, 0x05, 0xb7, 0x18, 0xda, 0x17, 0xc2, - 0x45, 0x69, 0xd2, 0x09, 0xb5, 0x50, 0x7f, 0xd7, - 0x50, 0x13, 0x75, 0x94, 0x02, 0x2d, 0x15, 0xc7, - 0x02, 0xea, 0x14, 0x22, 0x45, 0x0d, 0xe2, 0xc9, - 0x24, 0x66, 0xa1, 0x9f, 0x0c, 0x01, 0x53, 0xc1, - 0x9a, 0x9a, 0xa6, 0x8b, 0xec, 0x32, 0x9e, 0xbf, - 0xb8, 0x30, 0x3a, 0xfb, 0xa7, 0xbe, 0xb6, 0x38, - 0x66, 0x3b, 0x88, 0x67, 0x25, 0x4f, 0x65, 0xb1, - 0xdc, 0xb2, 0xb8, 0xd5, 0x0c, 0x66, 0x5d, 0xe4, - 0x6a, 0x19, 0xae, 0xac, 0xcb, 0xf0, 0xeb, 0xb2, - 0x96, 0x1e, 0xc3, 0x79, 0xf6, 0x0e, 0xc3, 0xd9, - 0xe5, 0x9d, 0xc2, 0x41, 0x4a, 0x48, 0x28, 0xe9, - 0x90, 0xb5, 0xbd, 0x51, 0xa9, 0x2b, 0xd4, 0x7e, - 0x78, 0x7e, 0x21, 0x97, 0x5e, 0xfb, 0x83, 0x55, - 0x9c, 0xe9, 0xd5, 0x81, 0x61, 0xc9, 0x06, 0x42, - 0x58, 0x96, 0x2f, 0xcf, 0x09, 0x4b, 0x08, 0x6f, - 0x81, 0x66, 0x43, 0x9e, 0x97, 0x5b, 0x44, 0x5e, - 0x7c, 0x36, 0xf4, 0x08, 0xce, 0xf0, 0xc5, 0x5c, - 0x30, 0xf6, 0x07, 0x2d, 0xbd, 0x09, 0xbb, 0xab, - 0x6d, 0xb0, 0xf5, 0x03, 0xeb, 0x84, 0xf2, 0x1e, - 0x60, 0xcd, 0xd7, 0xf8, 0x5c, 0x09, 0x2f, 0x1a, - 0xc5, 0xec, 0xc5, 0x88, 0x46, 0xbb, 0xf3, 0x0e, - 0xa9, 0xf7, 0x6c, 0x8a, 0xf1, 0xed, 0x94, 0x88, - 0x04, 0x36, 0x27, 0xef, 0x41, 0xe0, 0xa0, 0x95, - 0xa0, 0xa8, 0x84, 0xd2, 0x12, 0x15, 0xf1, 0x58, - 0xe2, 0x04, 0x08, 0x5c, 0x01, 0x6e, 0x9d, 0x7e, - 0xdd, 0x78, 0x6f, 0x8e, 0x68, 0x3c, 0x74, 0xe1, - 0x61, 0x95, 0x17, 0x6d, 0xf0, 0xdd, 0x2a, 0xb3, - 0x97, 0x6f, 0x08, 0x4b, 0x30, 0xe0, 0xbf, 0xa5, - 0xbf, 0xe9, 0x36, 0x64, 0xc8, 0xc7, 0x97, 0xfd, - 0x00, 0xbd, 0x81, 0x19, 0xbb, 0xf1, 0xf8, 0x92, - 0x64, 0x8a, 0x1c, 0x3a, 0x1a, 0x40, 0xbc, 0x47, - 0x07, 0x84, 0x69, 0xb5, 0x90, 0xce, 0xb0, 0xd4, - 0x1d, 0xf6, 0x8b, 0xeb, 0xc1, 0x8a, 0xce, 0x02, - 0x56, 0x2a, 0x57, 0xee, 0xb2, 0xab, 0x5c, 0x29, - 0xcb, 0xeb, 0xf5, 0x8a, 0x58, 0x3a, 0xf8, 0xc5, - 0x0a, 0x50, 0x8c, 0xea, 0x8e, 0xa0, 0x8f, 0xea, - 0xe6, 0xe4, 0x39, 0x0b, 0xb9, 0x22, 0x57, 0xed, - 0x14, 0x7c, 0x49, 0x94, 0x54, 0xe7, 0x89, 0xd8, - 0x99, 0x44, 0x83, 0xd0, 0xe4, 0x1a, 0x56, 0xa4, - 0xa5, 0x01, 0xd4, 0xf2, 0x73, 0xe2, 0xbe, 0x44, - 0x0a, 0xe9, 0x95, 0x56, 0x07, 0xe9, 0x95, 0x4e, - 0x44, 0xfe, 0xea, 0xd5, 0x78, 0x6c, 0x53, 0x10, - 0x29, 0xd3, 0x39, 0x04, 0xb2, 0x6e, 0x5c, 0xf9, - 0x57, 0xf0, 0x6a, 0xbb, 0xf6, 0xa4, 0x17, 0x63, - 0x2c, 0xd5, 0xb6, 0x04, 0xfa, 0x03, 0xaa, 0x5c, - 0xb1, 0x3d, 0xd0, 0xb2, 0x33, 0xa6, 0xe2, 0x85, - 0xf3, 0x8e, 0x52, 0x0c, 0xf7, 0x5f, 0xa1, 0x32, - 0x63, 0xbc, 0x49, 0xfc, 0xa6, 0x16, 0xea, 0x32, - 0x39, 0x18, 0x28, 0xbb, 0x67, 0x4b, 0x6e, 0xcb, - 0x5a, 0x4b, 0x99, 0x8a, 0x14, 0x2a, 0x2d, 0x84, - 0x0e, 0xf0, 0x4c, 0x7a, 0x22, 0xd8, 0xd2, 0x92, - 0xba, 0x17, 0xad, 0xa7, 0x31, 0x58, 0x43, 0x50, - 0xc8, 0xd4, 0x4a, 0xe2, 0x20, 0x21, 0x4c, 0xe1, - 0x63, 0x2e, 0x7e, 0xba, 0xf0, 0x78, 0x2f, 0xe8, - 0xbd, 0xaa, 0x72, 0x15, 0xdd, 0xac, 0xce, 0x1b, - 0x15, 0xf7, 0xc7, 0x0d, 0xe1, 0xb7, 0x9b, 0x97, - 0x93, 0x4c, 0x57, 0xd0, 0x49, 0xdb, 0x5d, 0x8f, - 0xf5, 0x4d, 0x73, 0x11, 0x0a, 0x12, 0x3a, 0x11, - 0x7e, 0xf7, 0xa7, 0x6e, 0xb6, 0xdd, 0xa0, 0x90, - 0xdc, 0x47, 0xf2, 0xc5, 0x75, 0x62, 0x97, 0x4e, - 0x50, 0x7f, 0x41, 0x75, 0x0d, 0x87, 0xa3, 0xcf, - 0x1b, 0x18, 0xb1, 0xeb, 0x8b, 0x0a, 0x71, 0xe4, - 0x54, 0x37, 0xc0, 0xe9, 0x16, 0xe3, 0xf5, 0x11, - 0x42, 0x65, 0x71, 0xab, 0xf3, 0xd7, 0x93, 0x3f, - 0xbb, 0xbf, 0x9c, 0x7d, 0x39, 0xed, 0x7e, 0x3a, - 0xbb, 0xf8, 0xed, 0xe4, 0xcb, 0xc7, 0xd3, 0xda, - 0x61, 0xe7, 0xed, 0x9b, 0xb7, 0x92, 0x5d, 0xba, - 0xb7, 0x63, 0xab, 0xdb, 0xb1, 0x48, 0x72, 0x0e, - 0xe6, 0xe9, 0xc2, 0x1a, 0xc3, 0x64, 0x6f, 0x31, - 0xee, 0x2d, 0xc6, 0xd7, 0x6a, 0x31, 0xee, 0x6d, - 0xb8, 0xbd, 0x0d, 0xf7, 0xcc, 0x6d, 0x38, 0x26, - 0x9e, 0xab, 0x9a, 0x71, 0x41, 0x61, 0x75, 0xdc, - 0x1b, 0x76, 0x7b, 0xc3, 0x6e, 0x6f, 0xd8, 0x3d, - 0x91, 0x61, 0xf7, 0x82, 0x2c, 0xaf, 0xca, 0xfb, - 0xc6, 0xdb, 0xdb, 0x64, 0xeb, 0x95, 0xd0, 0x2a, - 0x27, 0x36, 0xf7, 0xa6, 0x97, 0x6e, 0x7a, 0x59, - 0x9e, 0x37, 0xa3, 0x1b, 0xe5, 0xc0, 0xae, 0x6a, - 0x37, 0xdb, 0x9f, 0x39, 0x7b, 0x1c, 0x8b, 0xad, - 0x68, 0x5f, 0xb1, 0x1c, 0x65, 0xa5, 0xea, 0x5e, - 0x7c, 0x3c, 0xf9, 0xe5, 0xb4, 0xd6, 0xd9, 0xc2, - 0x92, 0x7b, 0x68, 0x7b, 0xcd, 0x6e, 0x91, 0x95, - 0x5b, 0x74, 0xf7, 0xb1, 0xd7, 0xc4, 0xae, 0x62, - 0xd9, 0x24, 0xda, 0x9b, 0x69, 0x0f, 0x67, 0xa6, - 0x3d, 0x03, 0xab, 0xe8, 0xd9, 0x59, 0x8a, 0x3b, - 0x36, 0xd3, 0xf6, 0x97, 0x50, 0x9f, 0xd1, 0x25, - 0xd4, 0x57, 0x6e, 0x0e, 0x3f, 0xad, 0xf9, 0xf9, - 0xdc, 0x8c, 0xf1, 0x5d, 0x99, 0xc3, 0xff, 0x6f, - 0xae, 0x05, 0xdf, 0xdf, 0xe4, 0x67, 0x70, 0x9b, - 0x6d, 0xde, 0x1a, 0x74, 0xa8, 0xbd, 0xcd, 0xbf, - 0xb7, 0xf9, 0xf7, 0x36, 0xff, 0x43, 0xd8, 0xfc, - 0x62, 0x2a, 0xc6, 0xb2, 0x82, 0x5e, 0xee, 0x0b, - 0xd8, 0xe6, 0x72, 0xaa, 0x22, 0x6f, 0xf4, 0x10, - 0x2e, 0x6b, 0x6d, 0xf2, 0xdd, 0x19, 0x1a, 0xaf, - 0xe5, 0x6e, 0xe8, 0xcb, 0xdf, 0x29, 0x5f, 0xef, - 0x2a, 0x79, 0x46, 0x97, 0x4c, 0x9f, 0xd0, 0x95, - 0xb3, 0x0f, 0x71, 0xfc, 0xba, 0x1e, 0x3e, 0x91, - 0xbb, 0x5a, 0x6e, 0x9f, 0xda, 0xe6, 0xe6, 0xd2, - 0xe3, 0xbd, 0x16, 0xa8, 0xc1, 0x82, 0x35, 0xc0, - 0x95, 0x09, 0x67, 0x62, 0xc0, 0x89, 0xa8, 0xf6, - 0x68, 0x7f, 0x97, 0x61, 0x04, 0x8a, 0xc3, 0x17, - 0xe5, 0x3f, 0x24, 0xd8, 0x96, 0xa8, 0x23, 0xc9, - 0x55, 0x67, 0xbe, 0x40, 0x04, 0x6a, 0x3f, 0x37, - 0x97, 0x2a, 0x7c, 0x52, 0x0e, 0x9f, 0xa8, 0xf0, - 0xab, 0x2e, 0x7e, 0x31, 0xb9, 0xce, 0x7b, 0x02, - 0x29, 0x38, 0xf4, 0x46, 0x17, 0xa7, 0x0f, 0xd3, - 0xe4, 0x68, 0xb5, 0xae, 0xea, 0x1d, 0xfa, 0xec, - 0x8b, 0xab, 0x13, 0xb4, 0x12, 0xc8, 0x93, 0x6d, - 0x90, 0x27, 0x76, 0xe4, 0x89, 0x60, 0x0c, 0x1c, - 0xf5, 0x64, 0xf3, 0x8b, 0xe7, 0x98, 0x83, 0x50, - 0xaf, 0xfa, 0xa8, 0xe5, 0xae, 0x84, 0x2b, 0xd9, - 0xe2, 0xda, 0x38, 0xc5, 0x95, 0x20, 0x5c, 0x89, - 0xab, 0x78, 0x7c, 0x01, 0x97, 0xf1, 0xea, 0x38, - 0xaa, 0xd4, 0x37, 0x67, 0x24, 0xae, 0xf9, 0xca, - 0x38, 0xf1, 0x01, 0x3f, 0xe0, 0xfb, 0x13, 0x2f, - 0xd8, 0x03, 0x5c, 0xe9, 0xc4, 0x0e, 0x1d, 0x2c, - 0xf2, 0x6c, 0x75, 0x5c, 0x50, 0xf0, 0x50, 0xef, - 0x77, 0x57, 0x52, 0xba, 0xa9, 0x54, 0x62, 0x29, - 0x95, 0x3c, 0xd2, 0xe9, 0x20, 0x9a, 0x0a, 0x95, - 0xc4, 0xa6, 0xc4, 0x64, 0x1b, 0xa5, 0x70, 0x7f, - 0xdf, 0x65, 0x7f, 0x7a, 0x69, 0x7f, 0x7a, 0xa9, - 0xdc, 0x2d, 0xce, 0x86, 0xcc, 0xe0, 0x33, 0x7b, - 0x08, 0x97, 0x39, 0x76, 0x14, 0x95, 0x50, 0x29, - 0xf2, 0xad, 0x7d, 0x25, 0x40, 0x4c, 0xfc, 0x25, - 0xe5, 0x96, 0xf5, 0xa6, 0x0a, 0xb6, 0xbf, 0xbc, - 0xb3, 0x3f, 0xf8, 0xf5, 0x4c, 0x0e, 0x7e, 0xed, - 0xce, 0xb7, 0x2d, 0x4d, 0x45, 0xf1, 0xd3, 0x50, - 0xb3, 0xc8, 0xf4, 0xd5, 0xf9, 0x69, 0x6a, 0xb2, - 0x8c, 0xc9, 0x38, 0xc9, 0xf6, 0x2e, 0xe8, 0xbd, - 0x0b, 0x7a, 0xef, 0x82, 0x7e, 0x85, 0x2e, 0x68, - 0xac, 0xaa, 0x47, 0x54, 0x66, 0xf0, 0x79, 0xe9, - 0xe9, 0xd6, 0x47, 0x73, 0x19, 0x48, 0x02, 0x85, - 0x8f, 0x5f, 0x01, 0x6c, 0x55, 0xe7, 0x86, 0x89, - 0x4b, 0xb1, 0x27, 0x6b, 0xb1, 0x27, 0xd5, 0xb0, - 0x27, 0x12, 0x76, 0x88, 0x6e, 0x56, 0xcd, 0x4d, - 0xbe, 0x3e, 0x34, 0xd7, 0xa2, 0x7f, 0x89, 0xbb, - 0xb5, 0x18, 0x63, 0x09, 0x59, 0x6c, 0xcf, 0xcc, - 0x0a, 0xda, 0xdf, 0xe2, 0x2a, 0x5f, 0x87, 0x77, - 0xa7, 0x07, 0x3f, 0xae, 0x12, 0xfb, 0x12, 0x2f, - 0x94, 0x19, 0x31, 0x94, 0x1c, 0x04, 0x28, 0xf6, - 0x78, 0x69, 0x87, 0x6f, 0xa0, 0xae, 0xbc, 0x40, - 0xff, 0x28, 0x12, 0x42, 0x90, 0xdb, 0x8d, 0x8d, - 0xd1, 0x88, 0xb0, 0x28, 0x71, 0x9b, 0xb1, 0x06, - 0x9c, 0x58, 0x81, 0x93, 0x02, 0x30, 0x76, 0xe5, - 0xf1, 0x5a, 0x7c, 0x8e, 0xc2, 0xc7, 0x72, 0xce, - 0x0d, 0x89, 0x63, 0x2e, 0x52, 0xde, 0x97, 0x3d, - 0x6e, 0x08, 0xe9, 0x28, 0x4b, 0x68, 0x12, 0x50, - 0xd8, 0x94, 0x43, 0xd1, 0x3e, 0xfe, 0xf1, 0xcf, - 0x4a, 0x27, 0x2c, 0xf3, 0x31, 0x5a, 0x41, 0xe6, - 0xf2, 0x63, 0x14, 0x5c, 0xe6, 0xe3, 0x15, 0xc5, - 0x92, 0x99, 0x5c, 0x5d, 0x5e, 0xa6, 0xf3, 0xb2, - 0x87, 0x67, 0x37, 0x0c, 0xc3, 0xd5, 0x32, 0xa4, - 0xb5, 0xb7, 0x8d, 0xcd, 0xd5, 0x8a, 0x1c, 0xc7, - 0x1c, 0xbb, 0xb0, 0x01, 0x27, 0x6f, 0x03, 0x95, - 0xfe, 0x9a, 0x0b, 0x51, 0x86, 0x48, 0xc9, 0x76, - 0x44, 0x42, 0xb9, 0xc1, 0x03, 0xe7, 0x72, 0x07, - 0x40, 0xf8, 0x29, 0xd1, 0x55, 0x52, 0xe7, 0xca, - 0x7b, 0xc9, 0xdd, 0xdc, 0x1a, 0xd3, 0xd2, 0xba, - 0xd4, 0xb6, 0xec, 0x59, 0xed, 0xca, 0xdd, 0x54, - 0x18, 0x9d, 0x39, 0xc4, 0x40, 0x42, 0xaa, 0xc4, - 0x02, 0x22, 0x72, 0x97, 0x65, 0x83, 0xb0, 0x2c, - 0x8e, 0x7c, 0x8c, 0xba, 0x0d, 0x87, 0x83, 0xd3, - 0xdf, 0x37, 0x61, 0x10, 0xbd, 0x6c, 0x9a, 0xcf, - 0xe3, 0x85, 0xe9, 0xfd, 0x13, 0x78, 0xa9, 0x64, - 0x31, 0x1b, 0x4d, 0xbb, 0x37, 0x38, 0x0a, 0xaf, - 0x76, 0xa4, 0x5c, 0x88, 0xe5, 0x56, 0x71, 0x62, - 0xb6, 0x48, 0x50, 0xb1, 0xd6, 0x9a, 0x30, 0xb1, - 0x6d, 0x02, 0xd6, 0x26, 0xd1, 0xb8, 0x09, 0xb2, - 0x66, 0x4c, 0x54, 0x7f, 0x54, 0x05, 0x4d, 0x98, - 0x0f, 0x92, 0x48, 0xfc, 0x0c, 0x18, 0x58, 0x78, - 0xc7, 0x0b, 0xb5, 0xf5, 0x42, 0x6d, 0x51, 0xa8, - 0x2d, 0x0a, 0xb5, 0xa1, 0x90, 0xe6, 0xef, 0x27, - 0xd8, 0x7c, 0x1a, 0x05, 0x96, 0x8d, 0x3e, 0x7d, - 0x54, 0xa9, 0x89, 0x64, 0x84, 0x14, 0xcd, 0x14, - 0xba, 0x84, 0xe3, 0x05, 0xb4, 0x21, 0x7c, 0xe1, - 0x68, 0xda, 0x10, 0xc9, 0x1c, 0x7d, 0xf8, 0x6a, - 0x8f, 0x41, 0x84, 0x7f, 0xd7, 0xb7, 0xe4, 0xdd, - 0x2e, 0x57, 0xd6, 0xbc, 0xd5, 0xed, 0x92, 0xc7, - 0x45, 0x8b, 0xaf, 0x53, 0x24, 0x1d, 0xd2, 0x88, - 0xbd, 0x40, 0xc4, 0x9e, 0x95, 0x62, 0xef, 0x49, - 0xb9, 0xc1, 0x21, 0x84, 0xb1, 0x84, 0x08, 0xe1, - 0x0e, 0x85, 0x6d, 0xa0, 0x2f, 0x08, 0xdf, 0x55, - 0x1c, 0x7e, 0x20, 0x18, 0x2a, 0xc4, 0xb3, 0xc7, - 0x2b, 0x0c, 0x3f, 0x99, 0x3e, 0x64, 0xe8, 0x81, - 0xa1, 0xc0, 0xbe, 0x26, 0x0d, 0xd4, 0x59, 0xd1, - 0x5f, 0x9b, 0xe0, 0x32, 0x44, 0xe8, 0xb7, 0x05, - 0x0f, 0x54, 0xe1, 0x57, 0x48, 0xd1, 0x24, 0x2c, - 0x96, 0x14, 0x24, 0x5e, 0x18, 0x23, 0xd2, 0xe7, - 0xd5, 0xf8, 0xb8, 0xed, 0x74, 0xf8, 0x7c, 0x16, - 0xe2, 0xeb, 0x7e, 0xf2, 0x17, 0xf5, 0xd2, 0x22, - 0xa7, 0x53, 0xe6, 0xfc, 0x2c, 0x2a, 0x04, 0xdb, - 0x0b, 0x8d, 0x5b, 0x26, 0xd4, 0x5a, 0x36, 0x6f, - 0x99, 0x28, 0xa9, 0x87, 0x50, 0x82, 0xdb, 0x49, - 0xaa, 0xcc, 0xe5, 0x5e, 0x47, 0x60, 0x4c, 0x5d, - 0x08, 0x25, 0x59, 0x36, 0x06, 0x21, 0xb3, 0x20, - 0x1b, 0x6d, 0x10, 0xe8, 0xb1, 0x8b, 0x89, 0x8d, - 0x25, 0x49, 0xaf, 0x01, 0x5d, 0xa6, 0x31, 0x96, - 0xa5, 0x05, 0x38, 0xf5, 0x05, 0x3e, 0x0c, 0x5b, - 0x96, 0x69, 0xc9, 0xea, 0xc5, 0x13, 0xc4, 0x83, - 0x60, 0xc8, 0x41, 0xd0, 0x35, 0x24, 0x99, 0xd9, - 0x3b, 0x08, 0x16, 0xf8, 0xd9, 0x28, 0xef, 0x0d, - 0x75, 0x5a, 0xe7, 0x59, 0x1e, 0xe7, 0x69, 0x77, - 0xb1, 0x9a, 0x24, 0xd9, 0xd8, 0x52, 0x90, 0x84, - 0x98, 0xd3, 0x76, 0x93, 0x14, 0x21, 0xde, 0x1b, - 0xe2, 0x08, 0x8c, 0x2f, 0x60, 0xf7, 0x60, 0xcd, - 0x06, 0x1a, 0x49, 0x1d, 0xc7, 0x49, 0x8a, 0x16, - 0xae, 0x71, 0x3c, 0x4d, 0x2d, 0x10, 0x03, 0xf6, - 0x7a, 0x83, 0x96, 0x2d, 0x38, 0x00, 0x44, 0xb0, - 0x9e, 0x8c, 0x47, 0x80, 0x98, 0xcb, 0x93, 0x78, - 0x16, 0x5a, 0x8e, 0x5c, 0x15, 0x4d, 0xbb, 0x82, - 0x61, 0xa7, 0xb0, 0xe8, 0x33, 0x79, 0x79, 0x5c, - 0xe8, 0x31, 0x91, 0x3c, 0x2b, 0xf9, 0x49, 0x13, - 0xe6, 0x1d, 0x55, 0x73, 0xd9, 0x39, 0x15, 0xac, - 0x79, 0x08, 0x0f, 0x20, 0x4b, 0x84, 0x0e, 0x61, - 0xa9, 0x08, 0x54, 0xe6, 0xcb, 0x45, 0x3a, 0x98, - 0x40, 0xb0, 0x41, 0xc4, 0x79, 0xe3, 0x34, 0x6a, - 0x68, 0xf3, 0xfa, 0xaf, 0xce, 0x77, 0xa6, 0xa8, - 0x42, 0x9f, 0xc2, 0x02, 0xf6, 0x83, 0x65, 0xfa, - 0xc2, 0x3b, 0x23, 0x3f, 0xd8, 0x67, 0x2d, 0xea, - 0x54, 0x4c, 0x05, 0x88, 0x41, 0x42, 0xd0, 0x5f, - 0xad, 0xef, 0x3e, 0xfd, 0xd5, 0xfe, 0xee, 0xb3, - 0x09, 0xec, 0x06, 0x38, 0x6e, 0x71, 0x78, 0x57, - 0x83, 0x3e, 0xab, 0x41, 0x8d, 0xf7, 0xab, 0x90, - 0x57, 0x56, 0x44, 0x5c, 0xd6, 0x94, 0xf5, 0x88, - 0xa9, 0x54, 0xa1, 0xf8, 0xd4, 0x34, 0xd5, 0x57, - 0x76, 0x9e, 0x8d, 0xa6, 0xf9, 0xba, 0x10, 0xda, - 0x34, 0x12, 0x32, 0x97, 0x46, 0x48, 0x04, 0x0d, - 0x33, 0x21, 0x8d, 0x22, 0x15, 0x5b, 0x53, 0x1d, - 0x45, 0x06, 0x45, 0xa4, 0x4b, 0xa4, 0xcf, 0x91, - 0xda, 0x4f, 0x07, 0x56, 0xc4, 0x41, 0x89, 0x08, - 0xac, 0x7d, 0x38, 0x28, 0xc9, 0x0d, 0xac, 0x38, - 0x15, 0xda, 0x24, 0x97, 0x16, 0x25, 0x8f, 0x98, - 0x65, 0x60, 0xa7, 0x80, 0x0b, 0x53, 0xa5, 0x1d, - 0x9b, 0x5e, 0xe0, 0x59, 0x0e, 0xa1, 0x27, 0xbd, - 0xa8, 0x50, 0x9a, 0x9d, 0x8b, 0x42, 0x8a, 0x00, - 0x3b, 0xff, 0x44, 0xe5, 0x44, 0xed, 0x27, 0xcc, - 0xa5, 0x41, 0xe7, 0x08, 0x7b, 0x59, 0xf1, 0x48, - 0x28, 0xac, 0x8e, 0xa5, 0x33, 0x91, 0xd5, 0xa0, - 0xc9, 0xa3, 0x9a, 0x42, 0xc2, 0x5f, 0x8a, 0xf8, - 0x66, 0xba, 0x22, 0x99, 0x5a, 0xe7, 0x6b, 0x07, - 0x91, 0xc4, 0x5e, 0x6e, 0xe3, 0x90, 0xd0, 0xfc, - 0x5d, 0x9e, 0x58, 0x1f, 0xaf, 0xe5, 0x2a, 0x28, - 0x8c, 0x20, 0x86, 0x4c, 0x22, 0x53, 0x45, 0x00, - 0x6f, 0x4c, 0xbf, 0x09, 0xf5, 0x66, 0xe0, 0xf8, - 0xb1, 0x0e, 0x9c, 0x9d, 0xc2, 0x07, 0xb4, 0xd4, - 0x85, 0xc6, 0x87, 0xe3, 0x57, 0x70, 0xc6, 0x2b, - 0xbc, 0x93, 0xbb, 0x02, 0xcf, 0x76, 0xc4, 0xab, - 0xd3, 0x08, 0x87, 0x29, 0x95, 0x65, 0x40, 0x5d, - 0xc3, 0xaf, 0xf2, 0x27, 0x29, 0xd8, 0x43, 0xd2, - 0x09, 0x07, 0x67, 0x2d, 0x2f, 0x08, 0x0e, 0xe4, - 0x1a, 0xfb, 0xa4, 0x1d, 0x17, 0x61, 0xaf, 0x32, - 0x47, 0xe3, 0x63, 0x3f, 0x3d, 0x27, 0xc7, 0xd7, - 0x7f, 0xf5, 0x68, 0xa4, 0x5f, 0xd9, 0xf3, 0x0c, - 0xb2, 0xd1, 0xb4, 0xba, 0xf0, 0x31, 0x91, 0x21, - 0x51, 0x47, 0x2a, 0x81, 0x6a, 0x24, 0x3b, 0x4e, - 0x5b, 0x7d, 0xa8, 0x43, 0x5a, 0x2b, 0x1c, 0xa8, - 0x09, 0x37, 0x75, 0xad, 0x3d, 0x1e, 0xdf, 0xb8, - 0x0a, 0x0e, 0x21, 0x5a, 0x2f, 0xe7, 0x4b, 0x29, - 0xfe, 0xf4, 0x35, 0x95, 0xca, 0xe8, 0xdf, 0x40, - 0x5a, 0xa0, 0x60, 0xf4, 0xe5, 0x25, 0x88, 0x2d, - 0x27, 0xf4, 0xd3, 0x51, 0x75, 0x28, 0x1e, 0x9d, - 0x5c, 0x68, 0x0a, 0x91, 0x9c, 0x8f, 0x84, 0x28, - 0xb6, 0x29, 0x20, 0x0e, 0xaf, 0xa2, 0x4f, 0xd4, - 0x3e, 0x34, 0x54, 0xfd, 0x42, 0x5d, 0xf8, 0xf8, - 0xb3, 0x55, 0xe0, 0x26, 0x81, 0xd8, 0xd9, 0x0a, - 0xd2, 0xd6, 0xf7, 0xba, 0x54, 0xd4, 0xb5, 0x3a, - 0x6f, 0xa9, 0xa9, 0x14, 0x3e, 0x49, 0xa8, 0xa8, - 0xcd, 0xd7, 0xf6, 0x7b, 0x3a, 0xd3, 0x64, 0xd5, - 0x0b, 0x3b, 0x9a, 0x28, 0x80, 0xa7, 0xd5, 0x6b, - 0x7d, 0x2f, 0x82, 0xfe, 0x26, 0xfe, 0x20, 0x97, - 0x9c, 0xbb, 0xda, 0xab, 0xfc, 0x0f, 0xaf, 0xf2, - 0xdb, 0x3c, 0xc5, 0xa3, 0xf1, 0xb8, 0xec, 0xe4, - 0x92, 0xc8, 0xb7, 0x1f, 0x5f, 0x12, 0x30, 0xa6, - 0x33, 0x4c, 0x52, 0x6e, 0x99, 0xf3, 0x5f, 0x05, - 0x2b, 0x7b, 0xf9, 0x29, 0x1e, 0x67, 0x65, 0x14, - 0x8b, 0x7c, 0x3b, 0xc5, 0x02, 0xc6, 0x44, 0xb1, - 0x94, 0x5b, 0x46, 0xb1, 0x0a, 0xf6, 0xa2, 0x0f, - 0x3b, 0xe1, 0xa6, 0x94, 0x9c, 0x9b, 0x11, 0xf9, - 0xf6, 0x47, 0x59, 0x39, 0x88, 0xf1, 0x61, 0x56, - 0x91, 0x5b, 0xfa, 0x30, 0x97, 0x02, 0xb6, 0x8e, - 0x60, 0xfb, 0xb9, 0x36, 0x9e, 0x5d, 0x4e, 0xae, - 0xed, 0x84, 0x9b, 0xc8, 0x5c, 0x4b, 0xac, 0xb2, - 0x37, 0xf1, 0x1c, 0x6d, 0xc1, 0xc7, 0x34, 0xd9, - 0x37, 0x75, 0x1f, 0x98, 0x4c, 0xfc, 0x6a, 0x36, - 0x2b, 0x48, 0x61, 0xc5, 0xed, 0x7a, 0x48, 0x13, - 0xdb, 0x95, 0xac, 0x55, 0x49, 0xca, 0x89, 0x9f, - 0xa6, 0x23, 0x56, 0x22, 0xd7, 0x57, 0x65, 0x9f, - 0xe9, 0xb0, 0x95, 0x8c, 0x6a, 0x2b, 0xf9, 0x25, - 0x7e, 0x9a, 0x68, 0x11, 0xb9, 0xbe, 0x2a, 0xd5, - 0x4c, 0xb4, 0xc8, 0xa8, 0x36, 0x97, 0x4c, 0x3b, - 0x3f, 0x9b, 0x25, 0x09, 0x1c, 0xf1, 0xd3, 0xf4, - 0x16, 0x2f, 0xcf, 0xf4, 0x55, 0x29, 0x64, 0x7c, - 0x93, 0x57, 0xc2, 0xb4, 0x8d, 0x28, 0xe1, 0xbf, - 0x6c, 0x84, 0xd0, 0x53, 0x71, 0x92, 0x74, 0xb1, - 0x92, 0x41, 0xb7, 0x2e, 0x8b, 0x32, 0x62, 0xef, - 0xd5, 0xd8, 0x7b, 0x35, 0xf6, 0x5e, 0x8d, 0xbd, - 0x57, 0x63, 0xef, 0xd5, 0x78, 0x3d, 0x5e, 0x0d, - 0x76, 0x22, 0x58, 0x9c, 0x79, 0x53, 0x4e, 0xc9, - 0x11, 0x3e, 0x78, 0x56, 0x8e, 0x0f, 0xf1, 0x5a, - 0xd2, 0x7c, 0x96, 0x8d, 0x63, 0x68, 0xfd, 0x3d, - 0x3c, 0x21, 0x54, 0x3f, 0x23, 0x27, 0xdc, 0x50, - 0xdb, 0x9a, 0x4b, 0xb8, 0x73, 0x85, 0xaf, 0x8e, - 0x11, 0x25, 0x8d, 0x6c, 0x20, 0x4a, 0x1d, 0xe4, - 0x93, 0x67, 0x40, 0x6d, 0xf5, 0x93, 0x60, 0x72, - 0xf4, 0xf2, 0xd3, 0xc5, 0xa7, 0xcf, 0xdd, 0xf3, - 0x3f, 0x6b, 0xef, 0xa4, 0xfb, 0x50, 0xa7, 0x9f, - 0x7e, 0x3e, 0xed, 0xfe, 0x7c, 0xf2, 0xeb, 0xaf, - 0x27, 0xa8, 0xb5, 0xed, 0xd6, 0xb1, 0xe1, 0x30, - 0xcc, 0x41, 0x51, 0x6b, 0x86, 0xc5, 0xb8, 0x82, - 0x1d, 0xbc, 0x5b, 0x1b, 0x76, 0x87, 0xf6, 0xe7, - 0xae, 0x4c, 0xc8, 0x9d, 0xda, 0x7f, 0x8f, 0x60, - 0xbe, 0x99, 0xbc, 0x79, 0x66, 0x93, 0x47, 0x3e, - 0x6d, 0x65, 0xb1, 0xd2, 0xee, 0x61, 0xc8, 0x94, - 0x72, 0xe9, 0x66, 0x76, 0x48, 0xb9, 0x19, 0xb2, - 0x91, 0x19, 0xf1, 0x18, 0xa7, 0xef, 0x24, 0xe6, - 0xd9, 0x4c, 0x9f, 0x2f, 0xe3, 0x8c, 0xcd, 0x54, - 0x72, 0x10, 0xcf, 0x74, 0x78, 0x40, 0xb1, 0x2e, - 0x8a, 0x74, 0x3a, 0x4c, 0xfc, 0xb2, 0x3a, 0xd6, - 0x07, 0x59, 0xe2, 0x4a, 0x96, 0xcc, 0xac, 0xf1, - 0x34, 0x53, 0xe8, 0xd8, 0x15, 0x75, 0x1a, 0x11, - 0xb4, 0x81, 0x8c, 0x84, 0x34, 0xa4, 0x32, 0xfb, - 0x61, 0xe2, 0x22, 0x21, 0x0a, 0x03, 0x87, 0xe3, - 0xf7, 0x14, 0xd6, 0x74, 0x43, 0xf9, 0x4c, 0xe5, - 0xd5, 0xe5, 0x65, 0xe4, 0x60, 0x55, 0xb9, 0x81, - 0xef, 0x2d, 0x50, 0xb5, 0x99, 0x2b, 0xe2, 0xd0, - 0x3f, 0xec, 0x30, 0x4e, 0x24, 0xb1, 0x00, 0xa9, - 0xce, 0xe1, 0xdd, 0xe7, 0xb5, 0x9b, 0xed, 0xf7, - 0x01, 0x11, 0xce, 0x75, 0x41, 0x85, 0x5b, 0x42, - 0x06, 0xa9, 0x1b, 0x6a, 0x16, 0xa3, 0x19, 0x88, - 0x05, 0x95, 0x22, 0x0b, 0xef, 0x24, 0x72, 0xf1, - 0x91, 0x40, 0x93, 0xbf, 0x18, 0xbc, 0xc5, 0xcd, - 0xb8, 0xd8, 0x21, 0xa4, 0xae, 0x7e, 0x84, 0x3f, - 0x3c, 0x79, 0x82, 0x2a, 0x6a, 0x0e, 0xf6, 0x55, - 0x4b, 0x87, 0x08, 0x81, 0xb4, 0x86, 0x8c, 0xc0, - 0x87, 0x94, 0xba, 0x92, 0x52, 0xf1, 0xc4, 0xa0, - 0xa7, 0xae, 0x64, 0xf7, 0xf2, 0x65, 0xff, 0x1f, - 0x03, 0x90, 0xfe, 0x1c - }; - static std::string decompressed = util::decompress(std::string(reinterpret_cast<const char*>(compressed), sizeof(compressed))); - return decompressed.c_str(); -}; - -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/symbol_icon.hpp b/src/mbgl/shaders/symbol_icon.hpp deleted file mode 100644 index eccf17602d..0000000000 --- a/src/mbgl/shaders/symbol_icon.hpp +++ /dev/null @@ -1,16 +0,0 @@ -// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. - -#pragma once - -namespace mbgl { -namespace shaders { - -class symbol_icon { -public: - static const char* name; - static const char* vertexSource; - static const char* fragmentSource; -}; - -} // namespace shaders -} // namespace mbgl diff --git a/src/mbgl/shaders/symbol_sdf.hpp b/src/mbgl/shaders/symbol_sdf.hpp deleted file mode 100644 index d5761d5fdb..0000000000 --- a/src/mbgl/shaders/symbol_sdf.hpp +++ /dev/null @@ -1,16 +0,0 @@ -// NOTE: DO NOT CHANGE THIS FILE. IT IS AUTOMATICALLY GENERATED. - -#pragma once - -namespace mbgl { -namespace shaders { - -class symbol_sdf { -public: - static const char* name; - static const char* vertexSource; - static const char* fragmentSource; -}; - -} // namespace shaders -} // namespace mbgl diff --git a/test/gl/bucket.test.cpp b/test/gl/bucket.test.cpp index 7e8740d8f9..bc9f6aac5a 100644 --- a/test/gl/bucket.test.cpp +++ b/test/gl/bucket.test.cpp @@ -26,7 +26,7 @@ namespace gfx { namespace detail { template <class A1, class A2> -bool operator==(const Vertex<A1, A2>& lhs, const Vertex<A1, A2>& rhs) { +bool operator==(const VertexType<A1, A2>& lhs, const VertexType<A1, A2>& rhs) { return std::tie(lhs.a1, lhs.a2) == std::tie(rhs.a1, rhs.a2); } diff --git a/test/programs/binary_program.test.cpp b/test/programs/binary_program.test.cpp index c70539ea81..76073efc87 100644 --- a/test/programs/binary_program.test.cpp +++ b/test/programs/binary_program.test.cpp @@ -1,16 +1,16 @@ #include <mbgl/test/util.hpp> -#include <mbgl/programs/binary_program.hpp> +#include <mbgl/gl/binary_program.hpp> using namespace mbgl; TEST(BinaryProgram, ObtainValues) { - const BinaryProgram binaryProgram{ 42, - "binary code", - "identifier", - { { "a_pos", 1 }, { "a_data", 4 } }, - { { "u_world", 1 }, { "u_ratio", 3 } }, - { { "u_image", 0 } } }; + const gl::BinaryProgram binaryProgram{ 42, + "binary code", + "identifier", + { { "a_pos", 1 }, { "a_data", 4 } }, + { { "u_world", 1 }, { "u_ratio", 3 } }, + { { "u_image", 0 } } }; EXPECT_EQ(42u, binaryProgram.format()); EXPECT_EQ("binary code", binaryProgram.code()); @@ -26,7 +26,7 @@ TEST(BinaryProgram, ObtainValues) { auto serialized = binaryProgram.serialize(); - const BinaryProgram binaryProgram2(std::move(serialized)); + const gl::BinaryProgram binaryProgram2(std::move(serialized)); EXPECT_EQ(42u, binaryProgram2.format()); EXPECT_EQ("binary code", binaryProgram2.code()); @@ -40,5 +40,5 @@ TEST(BinaryProgram, ObtainValues) { EXPECT_EQ(0, binaryProgram.textureLocation("u_image")); EXPECT_EQ(-1, binaryProgram.textureLocation("u_image2")); - EXPECT_THROW(BinaryProgram(""), std::runtime_error); + EXPECT_THROW(gl::BinaryProgram(""), std::runtime_error); } |