tei/MapLibreParticleLab
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

rm rasterize_properties, should be close to working...doesn't work

Browse Source
This commit is contained in:
Lauren Budorick
2014-08-06 17:40:48 -07:00
parent 9e1156d660
commit 560cc112e1
20 changed files with 94 additions and 279 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
include/mbgl/map/raster_tile_data.hpp
View File

@@ -26,6 +26,7 @@ public:
virtual bool hasData(std::shared_ptr<StyleLayer> layer_desc) const;
protected:
StyleBucketRaster properties;
RasterBucket bucket;
};

5
include/mbgl/map/tile_parser.hpp
View File

@@ -14,6 +14,7 @@
namespace mbgl {
class Bucket;
class Texturepool;
class FontStack;
class GlyphAtlas;
class GlyphStore;
@@ -36,6 +37,7 @@ public:
const std::shared_ptr<GlyphStore> &glyphStore,
const std::shared_ptr<SpriteAtlas> &spriteAtlas,
const std::shared_ptr<Sprite> &sprite);
const std::shared_ptr<Texturepool> &texturepool);
public:
void parse();
@@ -46,7 +48,7 @@ private:
std::unique_ptr<Bucket> createBucket(std::shared_ptr<StyleBucket> bucket_desc);
std::unique_ptr<Bucket> createFillBucket(const VectorTileLayer& layer, const FilterExpression &filter, const StyleBucketFill &fill);
std::unique_ptr<Bucket> createRasterBucket(const VectorTileLayer& layer, const FilterExpression &filter, const StyleBucketRaster &raster);
std::unique_ptr<Bucket> createRasterBucket(const std::shared_ptr<Texturepool> &texturepool, const StyleBucketRaster &raster);
std::unique_ptr<Bucket> createLineBucket(const VectorTileLayer& layer, const FilterExpression &filter, const StyleBucketLine &line);
std::unique_ptr<Bucket> createSymbolBucket(const VectorTileLayer& layer, const FilterExpression &filter, const StyleBucketSymbol &symbol);
@@ -62,6 +64,7 @@ private:
std::shared_ptr<GlyphStore> glyphStore;
std::shared_ptr<SpriteAtlas> spriteAtlas;
std::shared_ptr<Sprite> sprite;
std::shared_ptr<Texturepool> texturePool;
Collision collision;
};

2
include/mbgl/renderer/bucket.hpp
View File

@@ -5,7 +5,6 @@
#include <memory>
#include <mbgl/map/tile.hpp>
#include <mbgl/util/noncopyable.hpp>
#include <mbgl/renderer/prerendered_texture.hpp>
namespace mbgl {
@@ -18,7 +17,6 @@ public:
virtual bool hasData() const = 0;
virtual ~Bucket() {}
std::unique_ptr<PrerenderedTexture> prerendered;
};
}

13
include/mbgl/renderer/painter.hpp
View File

@@ -40,7 +40,8 @@ class FillBucket;
class LineBucket;
class SymbolBucket;
class RasterBucket;
class PrerenderedTexture;
struct FillProperties;
struct CompositeProperties;
@@ -84,15 +85,13 @@ public:
void renderLine(LineBucket& bucket, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID& id);
void renderSymbol(SymbolBucket& bucket, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID& id);
void renderRaster(RasterBucket& bucket, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID& id);
void renderRaster(GLuint texture, const RasterizeProperties &properties); // do I want to save that?
void preparePrerender(PrerenderedTexture &texture);
void finishPrerender(PrerenderedTexture &texture);
void preparePrerender(RasterBucket &bucket);
void finishPrerender(RasterBucket &bucket);
template <typename Properties>
void renderPrerenderedTexture(PrerenderedTexture &texture, const Properties &properties);
void renderPrerenderedTexture(RasterBucket &bucket);
void createPrerendered(RasterBucket& bucket, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID& id, const RasterizeProperties& properties);
void createPrerendered(RasterBucket& bucket, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID& id);
void resize();

7
include/mbgl/renderer/prerendered_texture.hpp
View File

@@ -3,16 +3,15 @@
#include <mbgl/util/noncopyable.hpp>
#include <mbgl/platform/gl.hpp>
#include <mbgl/style/rasterize_properties.hpp>
//#include <mbgl/renderer/raster_bucket.hpp>
namespace mbgl {
class StyleBucketRaster;
class Painter;
class PrerenderedTexture : private util::noncopyable {
public:
PrerenderedTexture(const RasterBucket &properties);
PrerenderedTexture(const StyleBucketRaster &properties);
~PrerenderedTexture();
void bindTexture();
@@ -24,7 +23,7 @@ public:
void blur(Painter& painter, uint16_t passes);
public:
const RasterBucket properties;
const StyleBucketRaster &properties;
private:
GLint previous_fbo = 0;

11
include/mbgl/renderer/raster_bucket.hpp
View File

@@ -3,6 +3,10 @@
#include <mbgl/renderer/bucket.hpp>
#include <mbgl/util/raster.hpp>
#include <mbgl/renderer/prerendered_texture.hpp>
#include <mbgl/style/style_bucket.hpp>
namespace mbgl {
@@ -12,12 +16,15 @@ class VertexArrayObject;
class RasterBucket : public Bucket {
public:
RasterBucket(const std::shared_ptr<Texturepool> &texturepool);
RasterBucket(const std::shared_ptr<Texturepool> &texturepool, const StyleBucketRaster& properties);
virtual void render(Painter& painter, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID& id);
virtual bool hasData() const;
bool setImage(const std::string &data);
const StyleBucketRaster &properties;
PrerenderedTexture texture;
void drawRaster(RasterShader& shader, VertexBuffer &vertices, VertexArrayObject &array);

38
include/mbgl/style/rasterize_properties.hpp
View File

@@ -1,38 +0,0 @@
#ifndef MBGL_STYLE_RASTERIZE_PROPERTIES
#define MBGL_STYLE_RASTERIZE_PROPERTIES
#include <mbgl/style/function_properties.hpp>
namespace mbgl {
// The calculated properties for a layer in a tile.
class RasterizedProperties {
public:
float buffer = 1.0f / 32.0f;
uint16_t size = 256;
uint8_t blur = 0;
};
class RasterizeProperties {
public:
Function<bool> enabled = ConstantFunction<bool>(false); // maybe delete?
Function<float> buffer = ConstantFunction<float>(1.0f / 32.0f);
Function<float> size = ConstantFunction<float>(256);
Function<float> blur = ConstantFunction<float>(0);
// inline bool isEnabled(const int8_t z) const {
// return util::apply_visitor(FunctionEvaluator<bool>(z), enabled);
// }
inline RasterizedProperties get(const int8_t z) const {
RasterizedProperties properties;
properties.buffer = util::apply_visitor(FunctionEvaluator<float>(z), buffer);
properties.size = util::apply_visitor(FunctionEvaluator<float>(z), size);
properties.blur = util::apply_visitor(FunctionEvaluator<float>(z), blur);
return properties;
}
};
}
#endif

2
include/mbgl/style/style_bucket.hpp
View File

@@ -83,7 +83,7 @@ public:
class StyleBucketRaster {
public:
bool prerendered = false;
uint16_t raster_size = 256;
uint16_t size = 256;
float blur = 0.0f;
float buffer = 0.03125f;
};

6
include/mbgl/style/style_layer.hpp
View File

@@ -4,7 +4,6 @@
#include <mbgl/style/class_dictionary.hpp>
#include <mbgl/style/class_properties.hpp>
#include <mbgl/style/style_properties.hpp>
#include <mbgl/style/rasterize_properties.hpp>
#include <mbgl/style/applied_class_properties.hpp>
#include <vector>
@@ -79,11 +78,6 @@ public:
// layer's type.
StyleProperties properties;
// Rasterization properties are used for prerendering the tile to a bitmap,
// which is then used as a raster image instead of rendering this layer
// directly in every frame.
// const std::unique_ptr<const RasterizeProperties> rasterize;
// Child layer array (if this layer has child layers).
std::shared_ptr<StyleLayerGroup> layers;
};

2
include/mbgl/style/style_parser.hpp
View File

@@ -6,7 +6,6 @@
#include <mbgl/style/style_source.hpp>
#include <mbgl/style/filter_expression.hpp>
#include <mbgl/style/class_properties.hpp>
#include <mbgl/style/rasterize_properties.hpp>
#include <mbgl/style/style_bucket.hpp>
#include <unordered_map>
@@ -52,7 +51,6 @@ private:
void parseLayer(std::pair<JSVal, std::shared_ptr<StyleLayer>> &pair);
void parseStyles(JSVal value, std::map<ClassID, ClassProperties> &styles);
void parseStyle(JSVal, ClassProperties &properties);
std::unique_ptr<RasterizeProperties> parseRasterize(JSVal value);
void parseReference(JSVal value, std::shared_ptr<StyleLayer> &layer);
void parseBucket(JSVal value, std::shared_ptr<StyleLayer> &layer);
void parseRender(JSVal value, std::shared_ptr<StyleLayer> &layer);

68
src/map/map.cpp
View File

@@ -649,63 +649,29 @@ void Map::renderLayers(std::shared_ptr<StyleLayerGroup> group) {
}
void Map::renderLayer(std::shared_ptr<StyleLayer> layer_desc, RenderPass pass) {
if (layer_desc->layers) {
if (layer_desc->type == StyleLayerType::Raster) {
const RasterProperties &properties = layer_desc->getProperties<RasterProperties>();
// const RasterizedProperties rasterize = layer_desc->getProperties<RasterProperties>();
//
// auto prerendered = std::make_unique<PrerenderedTexture>(rasterize);
// prerendered->bindFramebuffer();
//
// painter.preparePrerender(*prerendered);
//
// const int buffer = rasterize.buffer * 4096.0f;
// const mat4 vtxMatrix = [&]{
// mat4 vtxMatrix;
// matrix::ortho(vtxMatrix, -buffer, 4096 + buffer, -4096 - buffer, buffer, 0, 1);
// matrix::translate(vtxMatrix, vtxMatrix, 0, -4096, 0);
// return vtxMatrix;
// }();
//
// painter.setOpaque();
// renderLayers(layer_desc->layers);
// painter.setTranslucent();
// renderLayers(layer_desc->layers);
//
// if (rasterize.blur > 0) {
// prerendered->blur(painter, rasterize.blur);
// }
//
// prerendered->unbindFramebuffer();
// painter.finishPrerender(*prerendered);
//
// painter.renderPrerenderedTexture(*prerendered, rasterize);
} else {
// This is a layer group. We render them during our translucent render pass.
if (pass == Translucent) {
const CompositeProperties &properties = layer_desc->getProperties<CompositeProperties>();
if (properties.isVisible()) {
gl::group group(std::string("group: ") + layer_desc->id);
if (layer_desc->layers && layer_desc->type != StyleLayerType::Raster) {
// This is a layer group. We render them during our translucent render pass.
if (pass == Translucent) {
const CompositeProperties &properties = layer_desc->getProperties<CompositeProperties>();
if (properties.isVisible()) {
gl::group group(std::string("group: ") + layer_desc->id);
if (debug::renderTree) {
std::cout << std::string(indent++ * 4, ' ') << "+ " << layer_desc->id
<< " (Composite) {" << std::endl;
}
if (debug::renderTree) {
std::cout << std::string(indent++ * 4, ' ') << "+ " << layer_desc->id
<< " (Composite) {" << std::endl;
}
painter.pushFramebuffer();
painter.pushFramebuffer();
renderLayers(layer_desc->layers);
renderLayers(layer_desc->layers);
GLuint texture = painter.popFramebuffer();
GLuint texture = painter.popFramebuffer();
// Render the previous texture onto the screen.
painter.drawComposite(texture, properties);
// Render the previous texture onto the screen.
painter.drawComposite(texture, properties);
if (debug::renderTree) {
std::cout << std::string(--indent * 4, ' ') << "}" << std::endl;
}
if (debug::renderTree) {
std::cout << std::string(--indent * 4, ' ') << "}" << std::endl;
}
}
}

2
src/map/raster_tile_data.cpp
View File

@@ -7,7 +7,7 @@ using namespace mbgl;
RasterTileData::RasterTileData(Tile::ID id, Map &map, const SourceInfo &source)
: TileData(id, map, source),
bucket(map.getTexturepool()) {
bucket(map.getTexturepool(), properties) {
}
RasterTileData::~RasterTileData() {

9
src/map/tile_parser.cpp
View File

@@ -14,6 +14,7 @@
#include <mbgl/geometry/glyph_atlas.hpp>
#include <mbgl/text/glyph_store.hpp>
#include <mbgl/text/glyph.hpp>
#include <mbgl/map/map.hpp>
#include <mbgl/util/std.hpp>
#include <mbgl/util/utf.hpp>
@@ -44,6 +45,7 @@ TileParser::TileParser(const std::string &data, VectorTileData &tile,
spriteAtlas(spriteAtlas),
sprite(sprite),
collision(tile.id.z, 4096, tile.source.tile_size, tile.depth) {
// placement(tile.id.z, tile.id.z >= tile.source.max_zoom ? tile.source.max_zoom - tile.id.z : 1) { // TODO : i'm guessing remove this in the rebase?
}
void TileParser::parse() {
@@ -116,7 +118,7 @@ std::unique_ptr<Bucket> TileParser::createBucket(std::shared_ptr<StyleBucket> bu
}
} else if (bucket_desc->render.is<StyleBucketRaster>()) {
// Assume this is a prerendered raster layer -- TODO more thorough checking here??
return createRasterBucket(layer, bucket_desc->filter, bucket_desc->render.get<StyleBucketRaster>());
return createRasterBucket(texturePool, bucket_desc->render.get<StyleBucketRaster>());
} else {
// The layer specified in the bucket does not exist. Do nothing.
if (debug::tileParseWarnings) {
@@ -152,9 +154,8 @@ std::unique_ptr<Bucket> TileParser::createFillBucket(const VectorTileLayer& laye
return obsolete() ? nullptr : std::move(bucket);
}
std::unique_ptr<Bucket> TileParser::createRasterBucket(const VectorTileLayer& layer, const FilterExpression &filter, const StyleBucketRaster &raster) {
std::unique_ptr<RasterBucket> bucket = std::make_unique<RasterBucket>(raster);
// addBucketFeatures(bucket, layer, filter);
std::unique_ptr<Bucket> TileParser::createRasterBucket(const std::shared_ptr<Texturepool> &texturepool, const StyleBucketRaster &raster) {
std::unique_ptr<RasterBucket> bucket = std::make_unique<RasterBucket>(texturepool, raster);
return obsolete() ? nullptr : std::move(bucket);
}

3
src/map/vector_tile_data.cpp
View File

@@ -58,9 +58,6 @@ void VectorTileData::render(Painter &painter, std::shared_ptr<StyleLayer> layer_
if (databucket_it != buckets.end()) {
assert(databucket_it->second);
databucket_it->second->render(painter, layer_desc, id);
} else if (layer_desc->type == StyleLayerType::Raster && layer_desc->layers) {
// HELP
}
}
}

52
src/renderer/painter_fill.cpp
View File

@@ -150,54 +150,6 @@ void Painter::renderFill(FillBucket& bucket, std::shared_ptr<StyleLayer> layer_d
// Abort early.
if (!bucket.hasData()) return;
const FillProperties &properties = layer_desc->getProperties<FillProperties>();
// if (layer_desc->rasterize && layer_desc->rasterize->isEnabled(id.z)) {
// if (pass == Translucent) {
// const RasterizedProperties rasterize = layer_desc->rasterize->get(id.z);
// // Buffer value around the 0..4096 extent that will be drawn into the 256x256 pixel
// // texture. We later scale the texture so that the actual bounds will align with this
// // tile's bounds. The reason we do this is so that the
// if (!bucket.prerendered) {
// bucket.prerendered = std::make_unique<PrerenderedTexture>(rasterize);
// bucket.prerendered->bindFramebuffer();
//
// preparePrerender(*bucket.prerendered);
//
// const FillProperties modifiedProperties = [&]{
// FillProperties modifiedProperties = properties;
// modifiedProperties.opacity = 1;
// return modifiedProperties;
// }();
//
// // When drawing the fill, we want to draw a buffer around too, so we
// // essentially downscale everyting, and then upscale it later when rendering.
// const int buffer = rasterize.buffer * 4096.0f;
// const mat4 vtxMatrix = [&]{
// mat4 vtxMatrix;
// matrix::ortho(vtxMatrix, -buffer, 4096 + buffer, -4096 - buffer, buffer, 0, 1);
// matrix::translate(vtxMatrix, vtxMatrix, 0, -4096, 0);
// return vtxMatrix;
// }();
//
// setOpaque();
// renderFill(bucket, modifiedProperties, id, vtxMatrix);
//
// setTranslucent();
// renderFill(bucket, modifiedProperties, id, vtxMatrix);
//
// if (rasterize.blur > 0) {
// bucket.prerendered->blur(*this, rasterize.blur);
// }
//
// // RESET STATE
// bucket.prerendered->unbindFramebuffer();
// finishPrerender(*bucket.prerendered);
// }
//
// renderPrerenderedTexture(*bucket.prerendered, properties);
// }
// } else {
const mat4 &vtxMatrix = translatedMatrix(properties.translate, id, properties.translateAnchor);
renderFill(bucket, properties, id, vtxMatrix);
// }
const mat4 &vtxMatrix = translatedMatrix(properties.translate, id, properties.translateAnchor);
renderFill(bucket, properties, id, vtxMatrix);
}

20
src/renderer/painter_prerender.cpp
View File

@@ -1,9 +1,11 @@
#include <mbgl/renderer/painter.hpp>
#include <mbgl/style/style_properties.hpp>
#include <mbgl/renderer/prerendered_texture.hpp>
#include <mbgl/renderer/raster_bucket.hpp>
using namespace mbgl;
void Painter::preparePrerender(PrerenderedTexture &texture) {
void Painter::preparePrerender(RasterBucket &bucket) {
glDisable(GL_DEPTH_TEST);
glDisable(GL_STENCIL_TEST);
@@ -14,19 +16,18 @@ void Painter::preparePrerender(PrerenderedTexture &texture) {
#endif
glClear(GL_COLOR_BUFFER_BIT);
glViewport(0, 0, texture.properties.size, texture.properties.size);
glViewport(0, 0, bucket.properties.size, bucket.properties.size);
}
void Painter::finishPrerender(PrerenderedTexture &/*texture*/) {
void Painter::finishPrerender(RasterBucket &bucket) {
glEnable(GL_DEPTH_TEST);
glEnable(GL_STENCIL_TEST);
glViewport(0, 0, gl_viewport[0], gl_viewport[1]);
}
template <typename Properties>
void Painter::renderPrerenderedTexture(PrerenderedTexture &texture, const Properties &properties) {
const int buffer = texture.properties.buffer * 4096.0f;
void Painter::renderPrerenderedTexture(RasterBucket &bucket) {
const int buffer = bucket.properties.buffer * 4096.0f;
// draw the texture on a quad
useProgram(rasterShader->program);
@@ -39,11 +40,8 @@ void Painter::renderPrerenderedTexture(PrerenderedTexture &texture, const Proper
rasterShader->setImage(0);
rasterShader->setBuffer(buffer);
rasterShader->setOpacity(1);
// rasterShader->setOpacity(properties.opacity); // TODO find a place to pass opacity and change this back
texture.bindTexture();
// rasterShader->setOpacity(bucket.properties.opacity); // TODO find a place to pass opacity and change this back
bucket.texture.bindTexture();
coveringRasterArray.bind(*rasterShader, tileStencilBuffer, BUFFER_OFFSET(0));
glDrawArrays(GL_TRIANGLES, 0, (GLsizei)tileStencilBuffer.index());
}
template void Painter::renderPrerenderedTexture(PrerenderedTexture &, const FillProperties &);
template void Painter::renderPrerenderedTexture(PrerenderedTexture &, const RasterizedProperties &);

102
src/renderer/painter_raster.cpp
View File

@@ -11,81 +11,37 @@ void Painter::renderRaster(RasterBucket& bucket, std::shared_ptr<StyleLayer> lay
const RasterProperties &properties = layer_desc->getProperties<RasterProperties>();
if (layer_desc->rasterize) {
auto rasterize = std::make_unique<RasterizeProperties>();
if (layer_desc->layers) {
bucket.texture.bindFramebuffer();
if (pass == Translucent) {
// Buffer value around the 0..4096 extent that will be drawn into the 256x256 pixel
// texture. We later scale the texture so that the actual bounds will align with this
// tile's bounds. The reason we do this is so that the
const RasterizedProperties rasterize = layer_desc->rasterize->get(id.z);
if (!bucket.prerendered) {
bucket.prerendered = std::make_unique<PrerenderedTexture>(rasterize);
bucket.prerendered->bindFramebuffer();
preparePrerender(*bucket.prerendered);
const RasterProperties modifiedProperties = [&]{
RasterProperties modifiedProperties = properties;
// modifiedProperties.opacity = 1; // figure out why this was here
return modifiedProperties;
}();
// When drawing the fill, we want to draw a buffer around too, so we
// essentially downscale everyting, and then upscale it later when rendering.
const int buffer = rasterize.buffer * 4096.0f;
const mat4 vtxMatrix = [&]{
mat4 vtxMatrix;
matrix::ortho(vtxMatrix, -buffer, 4096 + buffer, -4096 - buffer, buffer, 0, 1);
matrix::translate(vtxMatrix, vtxMatrix, 0, -4096, 0);
return vtxMatrix;
}();
setOpaque();
// renderFill(bucket, modifiedProperties, id, vtxMatrix);
// resize();
// changeMatrix();
// map.updateRenderState();
// drawClippingMasks(getActiveSources());
// Actually render the layers
map.renderLayers(layer_desc->layers);
// Finalize the rendering, e.g. by calling debug render calls per tile.
// This guarantees that we have at least one function per tile called.
// When only rendering layers via the stylesheet, it's possible that we don't
// ever visit a tile during rendering.
// for (const std::shared_ptr<StyleSource> &source : getActiveSources()) {
// source->source->finishRender(painter);
// }
//
// // Schedule another rerender when we definitely need a next frame.
// if (transform.needsTransition() || style->hasTransitions()) {
// update();
// }
glFlush();
preparePrerender(bucket);
if (rasterize.blur > 0) {
bucket.prerendered->blur(*this, rasterize.blur);
}
// RESET STATE
bucket.prerendered->unbindFramebuffer();
finishPrerender(*bucket.prerendered);
}
renderPrerenderedTexture(*bucket.prerendered, properties);
const RasterProperties modifiedProperties = [&]{
RasterProperties modifiedProperties = properties;
modifiedProperties.opacity = 1; // figure out why this was here
return modifiedProperties;
}();
const int buffer = bucket.properties.buffer * 4096.0f;
const mat4 vtxMatrix = [&]{
mat4 vtxMatrix;
matrix::ortho(vtxMatrix, -buffer, 4096 + buffer, -4096 - buffer, buffer, 0, 1);
matrix::translate(vtxMatrix, vtxMatrix, 0, -4096, 0);
return vtxMatrix;
}();
map.renderLayers(layer_desc->layers);
if (bucket.properties.blur > 0) {
bucket.texture.blur(*this, bucket.properties.blur);
}
bucket.texture.unbindFramebuffer();
finishPrerender(bucket);
renderPrerenderedTexture(bucket);
}
depthMask(false);
@@ -94,7 +50,7 @@ void Painter::renderRaster(RasterBucket& bucket, std::shared_ptr<StyleLayer> lay
rasterShader->setMatrix(matrix);
rasterShader->setBuffer(0);
rasterShader->setOpacity(1);
// rasterShader->setOpacity(properties.opacity * tile_data->raster->opacity);
// rasterShader->setOpacity(properties.opacity * tile_data->raster->opacity); // TODO fix
glDepthRange(strata + strata_epsilon, 1.0f);
bucket.drawRaster(*rasterShader, tileStencilBuffer, coveringRasterArray);
@@ -102,7 +58,3 @@ void Painter::renderRaster(RasterBucket& bucket, std::shared_ptr<StyleLayer> lay
depthMask(true);
}
void Painter::renderRaster(GLuint texture, const RasterizeProperties &properties){
// TODO do I need this?
// map.renderLayers(layer_desc->layers);
}

6
src/renderer/prerendered_texture.cpp
View File

@@ -1,10 +1,11 @@
#include <mbgl/renderer/prerendered_texture.hpp>
#include <mbgl/renderer/painter.hpp>
#include <mbgl/style/style_bucket.hpp>
using namespace mbgl;
PrerenderedTexture::PrerenderedTexture(const RasterizedProperties &properties)
PrerenderedTexture::PrerenderedTexture(const StyleBucketRaster &properties)
: properties(properties) {
}
@@ -40,8 +41,7 @@ void PrerenderedTexture::bindFramebuffer() {
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
// glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, properties.size, properties.size, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0); // TODO change this back once i have non-zero size readings
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, properties.size, properties.size, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
glBindTexture(GL_TEXTURE_2D, 0);
}

12
src/renderer/raster_bucket.cpp
View File

@@ -3,16 +3,12 @@
using namespace mbgl;
RasterBucket::RasterBucket(const std::shared_ptr<Texturepool> &texturepool)
: raster(texturepool) {
RasterBucket::RasterBucket(const std::shared_ptr<Texturepool> &texturepool, const StyleBucketRaster& properties)
: properties(properties),
texture(properties),
raster(texturepool) {
}
//RasterBucket::RasterBucket(const StyleBucketRaster &properties)
// : properties(properties) {
//}
// TODO ^ Somehow overload with another constructor for prerender?
void RasterBucket::render(Painter &painter, std::shared_ptr<StyleLayer> layer_desc, const Tile::ID &id) {
painter.renderRaster(*this, layer_desc, id);
}

12
src/style/style_parser.cpp
View File

@@ -492,15 +492,8 @@ std::shared_ptr<StyleLayer> StyleParser::createLayer(JSVal value) {
std::map<ClassID, ClassProperties> styles;
parseStyles(value, styles);
// Parse Rasterization options, as they can't be inherited anyway.
// std::unique_ptr<const RasterizeProperties> rasterize;
// if (value.HasMember("rasterize")) {
// rasterize = parseRasterize(replaceConstant(value["rasterize"]));
// }
std::shared_ptr<StyleLayer> layer = std::make_shared<StyleLayer>(
layer_id, std::move(styles));
// layer_id, std::move(styles), std::move(rasterize));
if (value.HasMember("layers")) {
if (value.HasMember("type")) {
@@ -643,7 +636,7 @@ void StyleParser::parseStyle(JSVal value, ClassProperties &klass) {
parseOptionalProperty<Function<float>>("composite-opacity", Key::CompositeOpacity, klass, value);
parseOptionalProperty<PropertyTransition>("transition-composite-opacity", Key::CompositeOpacity, klass, value);
// TODO edit these:
// TODO edit these?:
parseOptionalProperty<Function<float>>("raster-opacity", Key::RasterOpacity, klass, value);
parseOptionalProperty<PropertyTransition>("transition-raster-opacity", Key::RasterOpacity, klass, value);
parseOptionalProperty<Function<float>>("raster-spin", Key::RasterSpin, klass, value);
@@ -924,8 +917,7 @@ void StyleParser::parseRender(JSVal value, std::shared_ptr<StyleLayer> &layer) {
case StyleLayerType::Raster: {
StyleBucketRaster &render = bucket.render.get<StyleBucketRaster>();
// auto rasterize = std::make_unique<RasterizedProperties>();
parseRenderProperty(value, render.raster_size, "raster-size");
parseRenderProperty(value, render.size, "raster-size");
parseRenderProperty(value, render.blur, "raster-blur");
parseRenderProperty(value, render.buffer, "raster-buffer");
if (layer->layers) {