| Flutter Impeller |

atlas_contents.cc
Go to the documentation of this file.
1 // Copyright 2013 The Flutter Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include <optional>
6
7 #include "impeller/core/formats.h"
8 #include "impeller/entity/contents/atlas_contents.h"
9 #include "impeller/entity/contents/content_context.h"
10 #include "impeller/entity/contents/filters/blend_filter_contents.h"
11 #include "impeller/entity/contents/pipelines.h"
12 #include "impeller/entity/entity.h"
13 #include "impeller/entity/texture_fill.frag.h"
14 #include "impeller/entity/texture_fill.vert.h"
15 #include "impeller/geometry/color.h"
16 #include "impeller/renderer/render_pass.h"
17
18 namespace impeller {
19
20 DrawImageRectAtlasGeometry::DrawImageRectAtlasGeometry(
21 std::shared_ptr<Texture> texture,
22 const Rect& source,
23 const Rect& destination,
24 const Color& color,
25 BlendMode blend_mode,
26 const SamplerDescriptor& desc)
27 : texture_(std::move(texture)),
28 source_(source),
29 destination_(destination),
30 color_(color),
31 blend_mode_(blend_mode),
32 desc_(desc) {}
33
34 DrawImageRectAtlasGeometry::~DrawImageRectAtlasGeometry() = default;
35
36 bool DrawImageRectAtlasGeometry::ShouldUseBlend() const {
37 return true;
38 }
39
40 bool DrawImageRectAtlasGeometry::ShouldSkip() const {
41 return false;
42 }
43
44 VertexBuffer DrawImageRectAtlasGeometry::CreateSimpleVertexBuffer(
45 HostBuffer& host_buffer) const {
46 using VS = TextureFillVertexShader;
47 constexpr size_t indices[6] = {0, 1, 2, 1, 2, 3};
48
49 BufferView buffer_view = host_buffer.Emplace(
50 sizeof(VS::PerVertexData) * 6, alignof(VS::PerVertexData),
51 [&](uint8_t* raw_data) {
52 VS::PerVertexData* data =
53 reinterpret_cast<VS::PerVertexData*>(raw_data);
54 int offset = 0;
55 std::array<TPoint<float>, 4> destination_points =
56 destination_.GetPoints();
57 std::array<TPoint<float>, 4> texture_coords =
58 Rect::MakeSize(texture_->GetSize()).Project(source_).GetPoints();
59 for (size_t j = 0; j < 6; j++) {
60 data[offset].position = destination_points[indices[j]];
61 data[offset].texture_coords = texture_coords[indices[j]];
62 offset++;
63 }
64 });
65
66 return VertexBuffer{
67 .vertex_buffer = buffer_view,
68 .index_buffer = {},
69 .vertex_count = 6,
70 .index_type = IndexType::kNone,
71 };
72 }
73
74 VertexBuffer DrawImageRectAtlasGeometry::CreateBlendVertexBuffer(
75 HostBuffer& host_buffer) const {
76 using VS = PorterDuffBlendVertexShader;
77 constexpr size_t indices[6] = {0, 1, 2, 1, 2, 3};
78
79 BufferView buffer_view = host_buffer.Emplace(
80 sizeof(VS::PerVertexData) * 6, alignof(VS::PerVertexData),
81 [&](uint8_t* raw_data) {
82 VS::PerVertexData* data =
83 reinterpret_cast<VS::PerVertexData*>(raw_data);
84 int offset = 0;
85 std::array<TPoint<float>, 4> texture_coords =
86 Rect::MakeSize(texture_->GetSize()).Project(source_).GetPoints();
87 std::array<TPoint<float>, 4> destination_points =
88 destination_.GetPoints();
89 for (size_t j = 0; j < 6; j++) {
90 data[offset].vertices = destination_points[indices[j]];
91 data[offset].texture_coords = texture_coords[indices[j]];
92 data[offset].color = color_.Premultiply();
93 offset++;
94 }
95 });
96
97 return VertexBuffer{
98 .vertex_buffer = buffer_view,
99 .index_buffer = {},
100 .vertex_count = 6,
101 .index_type = IndexType::kNone,
102 };
103 }
104
105 Rect DrawImageRectAtlasGeometry::ComputeBoundingBox() const {
106 return destination_;
107 }
108
109 const std::shared_ptr<Texture>& DrawImageRectAtlasGeometry::GetAtlas() const {
110 return texture_;
111 }
112
113 const SamplerDescriptor& DrawImageRectAtlasGeometry::GetSamplerDescriptor()
114 const {
115 return desc_;
116 }
117
118 BlendMode DrawImageRectAtlasGeometry::GetBlendMode() const {
119 return blend_mode_;
120 }
121
122 bool DrawImageRectAtlasGeometry::ShouldInvertBlendMode() const {
123 return false;
124 }
125
126 ////
127
128 AtlasContents::AtlasContents() = default;
129
130 AtlasContents::~AtlasContents() = default;
131
132 std::optional<Rect> AtlasContents::GetCoverage(const Entity& entity) const {
133 if (!geometry_) {
134 return std::nullopt;
135 }
136 return geometry_->ComputeBoundingBox().TransformBounds(entity.GetTransform());
137 }
138
139 void AtlasContents::SetGeometry(AtlasGeometry* geometry) {
140 geometry_ = geometry;
141 }
142
143 void AtlasContents::SetAlpha(Scalar alpha) {
144 alpha_ = alpha;
145 }
146
147 bool AtlasContents::Render(const ContentContext& renderer,
148 const Entity& entity,
149 RenderPass& pass) const {
150 if (geometry_->ShouldSkip() || alpha_ <= 0.0) {
151 return true;
152 }
153
154 const SamplerDescriptor& dst_sampler_descriptor =
155 geometry_->GetSamplerDescriptor();
156 raw_ptr<const Sampler> dst_sampler =
157 renderer.GetContext()->GetSamplerLibrary()->GetSampler(
158 dst_sampler_descriptor);
159
160 auto& host_buffer = renderer.GetTransientsBuffer();
161 if (!geometry_->ShouldUseBlend()) {
162 using VS = TextureFillVertexShader;
163 using FS = TextureFillFragmentShader;
164
165 raw_ptr<const Sampler> dst_sampler =
166 renderer.GetContext()->GetSamplerLibrary()->GetSampler(
167 dst_sampler_descriptor);
168
169 auto pipeline_options = OptionsFromPassAndEntity(pass, entity);
170 pipeline_options.primitive_type = PrimitiveType::kTriangle;
171 pipeline_options.depth_write_enabled =
172 pipeline_options.blend_mode == BlendMode::kSrc;
173
174 pass.SetPipeline(renderer.GetTexturePipeline(pipeline_options));
175 pass.SetVertexBuffer(geometry_->CreateSimpleVertexBuffer(host_buffer));
176 #ifdef IMPELLER_DEBUG
177 pass.SetCommandLabel("DrawAtlas");
178 #endif // IMPELLER_DEBUG
179
180 VS::FrameInfo frame_info;
181 frame_info.mvp = entity.GetShaderTransform(pass);
182 frame_info.texture_sampler_y_coord_scale =
183 geometry_->GetAtlas()->GetYCoordScale();
184
185 VS::BindFrameInfo(pass, host_buffer.EmplaceUniform(frame_info));
186
187 FS::FragInfo frag_info;
188 frag_info.alpha = alpha_;
189 FS::BindFragInfo(pass, host_buffer.EmplaceUniform((frag_info)));
190 FS::BindTextureSampler(pass, geometry_->GetAtlas(), dst_sampler);
191 return pass.Draw().ok();
192 }
193
194 BlendMode blend_mode = geometry_->GetBlendMode();
195
196 if (blend_mode <= BlendMode::kModulate) {
197 using VS = PorterDuffBlendPipeline::VertexShader;
198 using FS = PorterDuffBlendPipeline::FragmentShader;
199
200 #ifdef IMPELLER_DEBUG
201 pass.SetCommandLabel("DrawAtlas Blend");
202 #endif // IMPELLER_DEBUG
203 pass.SetVertexBuffer(geometry_->CreateBlendVertexBuffer(host_buffer));
204 BlendMode inverted_blend_mode =
205 geometry_->ShouldInvertBlendMode()
206 ? (InvertPorterDuffBlend(blend_mode).value_or(BlendMode::kSrc))
207 : blend_mode;
208 pass.SetPipeline(renderer.GetPorterDuffPipeline(
209 inverted_blend_mode, OptionsFromPassAndEntity(pass, entity)));
210
211 FS::FragInfo frag_info;
212 VS::FrameInfo frame_info;
213
214 FS::BindTextureSamplerDst(pass, geometry_->GetAtlas(), dst_sampler);
215 frame_info.texture_sampler_y_coord_scale =
216 geometry_->GetAtlas()->GetYCoordScale();
217
218 frag_info.output_alpha = alpha_;
219 frag_info.input_alpha = 1.0;
220
221 // These values are ignored on platforms that natively support decal.
222 frag_info.tmx = static_cast<int>(Entity::TileMode::kDecal);
223 frag_info.tmy = static_cast<int>(Entity::TileMode::kDecal);
224
225 FS::BindFragInfo(pass, host_buffer.EmplaceUniform(frag_info));
226
227 frame_info.mvp = entity.GetShaderTransform(pass);
228
229 auto uniform_view = host_buffer.EmplaceUniform(frame_info);
230 VS::BindFrameInfo(pass, uniform_view);
231
232 return pass.Draw().ok();
233 }
234
235 using VUS = VerticesUber1Shader::VertexShader;
236 using FS = VerticesUber1Shader::FragmentShader;
237
238 #ifdef IMPELLER_DEBUG
239 pass.SetCommandLabel("DrawAtlas Advanced Blend");
240 #endif // IMPELLER_DEBUG
241 pass.SetVertexBuffer(geometry_->CreateBlendVertexBuffer(host_buffer));
242
243 renderer.GetDrawVerticesUberPipeline(blend_mode,
244 OptionsFromPassAndEntity(pass, entity));
245 FS::BindTextureSampler(pass, geometry_->GetAtlas(), dst_sampler);
246
247 VUS::FrameInfo frame_info;
248 FS::FragInfo frag_info;
249
250 frame_info.texture_sampler_y_coord_scale =
251 geometry_->GetAtlas()->GetYCoordScale();
252 frame_info.mvp = entity.GetShaderTransform(pass);
253
254 frag_info.alpha = alpha_;
255 frag_info.blend_mode = static_cast<int>(blend_mode);
256
257 // These values are ignored on platforms that natively support decal.
258 frag_info.tmx = static_cast<int>(Entity::TileMode::kDecal);
259 frag_info.tmy = static_cast<int>(Entity::TileMode::kDecal);
260
261 FS::BindFragInfo(pass, host_buffer.EmplaceUniform(frag_info));
262 VUS::BindFrameInfo(pass, host_buffer.EmplaceUniform(frame_info));
263
264 return pass.Draw().ok();
265 }
266
267 ///////////////
268
269 ColorFilterAtlasContents::ColorFilterAtlasContents() = default;
270
271 ColorFilterAtlasContents::~ColorFilterAtlasContents() = default;
272
273 std::optional<Rect> ColorFilterAtlasContents::GetCoverage(
274 const Entity& entity) const {
275 if (!geometry_) {
276 return std::nullopt;
277 }
278 return geometry_->ComputeBoundingBox().TransformBounds(entity.GetTransform());
279 }
280
281 void ColorFilterAtlasContents::SetGeometry(AtlasGeometry* geometry) {
282 geometry_ = geometry;
283 }
284
285 void ColorFilterAtlasContents::SetAlpha(Scalar alpha) {
286 alpha_ = alpha;
287 }
288
289 void ColorFilterAtlasContents::SetMatrix(ColorMatrix matrix) {
290 matrix_ = matrix;
291 }
292
293 bool ColorFilterAtlasContents::Render(const ContentContext& renderer,
294 const Entity& entity,
295 RenderPass& pass) const {
296 if (geometry_->ShouldSkip() || alpha_ <= 0.0) {
297 return true;
298 }
299
300 const SamplerDescriptor& dst_sampler_descriptor =
301 geometry_->GetSamplerDescriptor();
302
303 raw_ptr<const Sampler> dst_sampler =
304 renderer.GetContext()->GetSamplerLibrary()->GetSampler(
305 dst_sampler_descriptor);
306
307 auto& host_buffer = renderer.GetTransientsBuffer();
308
309 using VS = ColorMatrixColorFilterPipeline::VertexShader;
310 using FS = ColorMatrixColorFilterPipeline::FragmentShader;
311
312 #ifdef IMPELLER_DEBUG
313 pass.SetCommandLabel("Atlas ColorFilter");
314 #endif // IMPELLER_DEBUG
315 pass.SetVertexBuffer(geometry_->CreateSimpleVertexBuffer(host_buffer));
316 pass.SetPipeline(
317 renderer.GetColorMatrixColorFilterPipeline(OptionsFromPass(pass)));
318
319 FS::FragInfo frag_info;
320 VS::FrameInfo frame_info;
321
322 FS::BindInputTexture(pass, geometry_->GetAtlas(), dst_sampler);
323 frame_info.texture_sampler_y_coord_scale =
324 geometry_->GetAtlas()->GetYCoordScale();
325
326 frag_info.input_alpha = 1;
327 frag_info.output_alpha = alpha_;
328 const float* matrix = matrix_.array;
329 frag_info.color_v = Vector4(matrix[4], matrix[9], matrix[14], matrix[19]);
330 frag_info.color_m = Matrix(matrix[0], matrix[5], matrix[10], matrix[15], //
331 matrix[1], matrix[6], matrix[11], matrix[16], //
332 matrix[2], matrix[7], matrix[12], matrix[17], //
333 matrix[3], matrix[8], matrix[13], matrix[18] //
334 );
335
336 FS::BindFragInfo(pass, host_buffer.EmplaceUniform(frag_info));
337
338 frame_info.mvp = entity.GetShaderTransform(pass);
339
340 auto uniform_view = host_buffer.EmplaceUniform(frame_info);
341 VS::BindFrameInfo(pass, uniform_view);
342
343 return pass.Draw().ok();
344 }
345
346 } // namespace impeller
atlas_contents.h
blend_filter_contents.h
buffer_view
BufferView buffer_view
Definition: blit_command_gles.cc:152
impeller::AtlasContents::Render
bool Render(const ContentContext &renderer, const Entity &entity, RenderPass &pass) const override
Definition: atlas_contents.cc:147
impeller::AtlasContents::SetGeometry
void SetGeometry(AtlasGeometry *geometry)
Definition: atlas_contents.cc:139
impeller::AtlasContents::GetCoverage
std::optional< Rect > GetCoverage(const Entity &entity) const override
Get the area of the render pass that will be affected when this contents is rendered.
Definition: atlas_contents.cc:132
impeller::AtlasContents::SetAlpha
void SetAlpha(Scalar alpha)
Definition: atlas_contents.cc:143
impeller::AtlasContents::~AtlasContents
~AtlasContents() override
impeller::AtlasContents::AtlasContents
AtlasContents()
impeller::AtlasGeometry
Definition: atlas_contents.h:19
impeller::AtlasGeometry::CreateSimpleVertexBuffer
virtual VertexBuffer CreateSimpleVertexBuffer(HostBuffer &host_buffer) const =0
impeller::AtlasGeometry::ComputeBoundingBox
virtual Rect ComputeBoundingBox() const =0
impeller::AtlasGeometry::ShouldInvertBlendMode
virtual bool ShouldInvertBlendMode() const
Definition: atlas_contents.h:39
impeller::AtlasGeometry::ShouldUseBlend
virtual bool ShouldUseBlend() const =0
impeller::AtlasGeometry::GetSamplerDescriptor
virtual const SamplerDescriptor & GetSamplerDescriptor() const =0
impeller::AtlasGeometry::ShouldSkip
virtual bool ShouldSkip() const =0
impeller::AtlasGeometry::CreateBlendVertexBuffer
virtual VertexBuffer CreateBlendVertexBuffer(HostBuffer &host_buffer) const =0
impeller::AtlasGeometry::GetBlendMode
virtual BlendMode GetBlendMode() const =0
impeller::AtlasGeometry::GetAtlas
virtual const std::shared_ptr< Texture > & GetAtlas() const =0
impeller::ColorFilterAtlasContents::GetCoverage
std::optional< Rect > GetCoverage(const Entity &entity) const override
Get the area of the render pass that will be affected when this contents is rendered.
Definition: atlas_contents.cc:273
impeller::ColorFilterAtlasContents::SetGeometry
void SetGeometry(AtlasGeometry *geometry)
Definition: atlas_contents.cc:281
impeller::ColorFilterAtlasContents::ColorFilterAtlasContents
ColorFilterAtlasContents()
impeller::ColorFilterAtlasContents::SetAlpha
void SetAlpha(Scalar alpha)
Definition: atlas_contents.cc:285
impeller::ColorFilterAtlasContents::~ColorFilterAtlasContents
~ColorFilterAtlasContents() override
impeller::ColorFilterAtlasContents::SetMatrix
void SetMatrix(ColorMatrix matrix)
Definition: atlas_contents.cc:289
impeller::ColorFilterAtlasContents::Render
bool Render(const ContentContext &renderer, const Entity &entity, RenderPass &pass) const override
Definition: atlas_contents.cc:293
impeller::ContentContext
Definition: content_context.h:138
impeller::ContentContext::GetTransientsBuffer
HostBuffer & GetTransientsBuffer() const
Retrieve the currnent host buffer for transient storage.
Definition: content_context.h:296
impeller::ContentContext::GetPorterDuffPipeline
PipelineRef GetPorterDuffPipeline(BlendMode mode, ContentContextOptions opts) const
Definition: content_context.cc:1129
impeller::ContentContext::GetTexturePipeline
PipelineRef GetTexturePipeline(ContentContextOptions opts) const
Definition: content_context.cc:1070
impeller::ContentContext::GetColorMatrixColorFilterPipeline
PipelineRef GetColorMatrixColorFilterPipeline(ContentContextOptions opts) const
Definition: content_context.cc:1100
impeller::ContentContext::GetContext
std::shared_ptr< Context > GetContext() const
Definition: content_context.cc:913
impeller::ContentContext::GetDrawVerticesUberPipeline
PipelineRef GetDrawVerticesUberPipeline(BlendMode blend_mode, ContentContextOptions opts) const
Definition: content_context.cc:1429
impeller::DrawImageRectAtlasGeometry::ComputeBoundingBox
Rect ComputeBoundingBox() const override
Definition: atlas_contents.cc:105
impeller::DrawImageRectAtlasGeometry::GetSamplerDescriptor
const SamplerDescriptor & GetSamplerDescriptor() const override
Definition: atlas_contents.cc:113
impeller::DrawImageRectAtlasGeometry::ShouldUseBlend
bool ShouldUseBlend() const override
Definition: atlas_contents.cc:36
impeller::DrawImageRectAtlasGeometry::GetBlendMode
BlendMode GetBlendMode() const override
Definition: atlas_contents.cc:118
impeller::DrawImageRectAtlasGeometry::ShouldInvertBlendMode
bool ShouldInvertBlendMode() const override
Definition: atlas_contents.cc:122
impeller::DrawImageRectAtlasGeometry::CreateBlendVertexBuffer
VertexBuffer CreateBlendVertexBuffer(HostBuffer &host_buffer) const override
Definition: atlas_contents.cc:74
impeller::DrawImageRectAtlasGeometry::CreateSimpleVertexBuffer
VertexBuffer CreateSimpleVertexBuffer(HostBuffer &host_buffer) const override
Definition: atlas_contents.cc:44
impeller::DrawImageRectAtlasGeometry::ShouldSkip
bool ShouldSkip() const override
Definition: atlas_contents.cc:40
impeller::DrawImageRectAtlasGeometry::~DrawImageRectAtlasGeometry
~DrawImageRectAtlasGeometry()
impeller::DrawImageRectAtlasGeometry::DrawImageRectAtlasGeometry
DrawImageRectAtlasGeometry(std::shared_ptr< Texture > texture, const Rect &source, const Rect &destination, const Color &color, BlendMode blend_mode, const SamplerDescriptor &desc)
Definition: atlas_contents.cc:20
impeller::DrawImageRectAtlasGeometry::GetAtlas
const std::shared_ptr< Texture > & GetAtlas() const override
Definition: atlas_contents.cc:109
impeller::Entity
Definition: entity.h:20
impeller::Entity::TileMode::kDecal
@ kDecal
impeller::Entity::GetShaderTransform
Matrix GetShaderTransform(const RenderPass &pass) const
Get the vertex shader transform used for drawing this Entity.
Definition: entity.cc:48
impeller::Entity::GetTransform
const Matrix & GetTransform() const
Get the global transform matrix for this Entity.
Definition: entity.cc:44
impeller::HostBuffer
Definition: host_buffer.h:28
impeller::HostBuffer::Emplace
BufferView Emplace(const BufferType &buffer, size_t alignment=0)
Emplace non-uniform data (like contiguous vertices) onto the host buffer.
Definition: host_buffer.h:93
impeller::RenderPass
Render passes encode render commands directed as one specific render target into an underlying comman...
Definition: render_pass.h:30
impeller::RenderPass::SetVertexBuffer
virtual bool SetVertexBuffer(VertexBuffer buffer)
Specify the vertex and index buffer to use for this command.
Definition: render_pass.cc:127
impeller::RenderPass::SetPipeline
virtual void SetPipeline(PipelineRef pipeline)
The pipeline to use for this command.
Definition: render_pass.cc:86
impeller::RenderPass::Draw
virtual fml::Status Draw()
Record the currently pending command.
Definition: render_pass.cc:208
impeller::RenderPass::SetCommandLabel
virtual void SetCommandLabel(std::string_view label)
The debugging label to use for the command.
Definition: render_pass.cc:97
impeller::RenderPipelineHandle::VertexShader
VertexShader_ VertexShader
Definition: pipeline.h:119
impeller::RenderPipelineHandle::FragmentShader
FragmentShader_ FragmentShader
Definition: pipeline.h:120
impeller::raw_ptr
A wrapper around a raw ptr that adds additional unopt mode only checks.
Definition: raw_ptr.h:15
color.h
content_context.h
formats.h
entity.h
impeller
Definition: allocation.cc:12
impeller::IndexType::kNone
@ kNone
Does not use the index buffer.
impeller::PrimitiveType::kTriangle
@ kTriangle
impeller::Scalar
float Scalar
Definition: scalar.h:18
impeller::FS
LinePipeline::FragmentShader FS
Definition: line_contents.cc:14
impeller::InvertPorterDuffBlend
std::optional< BlendMode > InvertPorterDuffBlend(BlendMode blend_mode)
Definition: blend_filter_contents.cc:51
impeller::BlendMode
BlendMode
Definition: color.h:58
impeller::BlendMode::kModulate
@ kModulate
impeller::BlendMode::kSrc
@ kSrc
impeller::VS
LinePipeline::VertexShader VS
Definition: line_contents.cc:13
impeller::OptionsFromPassAndEntity
ContentContextOptions OptionsFromPassAndEntity(const RenderPass &pass, const Entity &entity)
Definition: contents.cc:34
impeller::OptionsFromPass
ContentContextOptions OptionsFromPass(const RenderPass &pass)
Definition: contents.cc:19
std
Definition: comparable.h:95
pipelines.h
render_pass.h
offset
SeparatedVector2 offset
Definition: stroke_path_geometry.cc:322
impeller::BufferView
Definition: buffer_view.h:19
impeller::Color
Definition: color.h:124
impeller::Color::Premultiply
constexpr Color Premultiply() const
Definition: color.h:212
impeller::ColorMatrix
Definition: color.h:117
impeller::ColorMatrix::array
Scalar array[20]
Definition: color.h:118
impeller::Matrix
A 4x4 matrix using column-major storage.
Definition: matrix.h:37
impeller::SamplerDescriptor
Definition: sampler_descriptor.h:14
impeller::TRect< Scalar >
impeller::TRect::TransformBounds
constexpr TRect TransformBounds(const Matrix &transform) const
Creates a new bounding box that contains this transformed rectangle.
Definition: rect.h:476
impeller::TRect::Project
constexpr TRect< T > Project(TRect< T > source) const
Returns a new rectangle that represents the projection of the source rectangle onto this rectangle....
Definition: rect.h:673
impeller::TRect::GetPoints
constexpr std::array< TPoint< T >, 4 > GetPoints() const
Get the points that represent the 4 corners of this rectangle in a Z order that is compatible with tr...
Definition: rect.h:418
impeller::TRect< Scalar >::MakeSize
constexpr static TRect MakeSize(const TSize< U > &size)
Definition: rect.h:150
impeller::Vector4
Definition: vector.h:232
impeller::VertexBuffer
Definition: vertex_buffer.h:15
impeller::VertexBuffer::vertex_buffer
BufferView vertex_buffer
Definition: vertex_buffer.h:16
data
std::shared_ptr< const fml::Mapping > data
Definition: texture_gles.cc:67